boshu2/agentops
45 skills22k installs18.7k starsGitHub
Install
npx skills add https://github.com/boshu2/agentopsSkills in this repo
1CouncilCouncil is an agentops judgment skill that routes high-stakes decisions through independent multi-judge consensus instead of a single model answer. The fleet stub documents absorbed triggers from multi-model triangulation for cross-validating competing approaches with Codex, Gemini, and Grok judges, and from cross-vendor-trust-gate for operating trust-gate.sh and enforcing cross-vendor parity via skill.trust.json. Mixed-model panels can use dual-pane-atm durable Opus plus Codex panes, while reverse-engineer routes one-way-door steal decisions into council. Outputs bind to result.json and verdict.json schemas with a shared standards dependency and isolated context window excluding history. The canonical implementation moved to Mount Olympus in 2026-06-10; this registry stub preserves fleet routing until the agentops catalog closer updates skill-prune Lane A. Runtime contract references claude-code-latest-features.md for multi-judge runs on the shared Claude surface. Examples include /council prompts for policy engine swaps like Cedar migration decisions.2.9kinstalls2SwarmThe swarm skill is designed for dispatch parallel agents. Triggers: "swarm", "dispatch parallel agents.", "swarm skill". Swarm Skill Spawn isolated agents to execute tasks in parallel. Before you swarm — pick the lightest path that fits > Confirm a swarm is even warranted. Invoke when the user asks about swarm or related SKILL.md workflows.1.4kinstalls3DocThe doc skill from boshu2 agentops generates and validates documentation for any project with mandatory execution, not description-only responses. Default mode handles API docs, code-maps, coverage, and validate commands detecting CODING, INFORMATIONAL, or OPS project types from package.json, pyproject.toml, go.mod, or Cargo.toml indicators. Commands include discover for undocumented public functions, coverage for docstring ratios, gen for feature-specific docs, and all for full gap remediation. Mode routing sends readme requests to --mode=readme following references/readme-craft.md interview generate council-validate flow, and oss requests to --mode=oss for CONTRIBUTING, CHANGELOG, and AGENTS.md scaffolding per references/oss-pack.md. Default steps classify project type, execute the requested command, and write structured markdown with purpose, parameters, returns, and examples for functions. Hexagonal role is supporting with wiki-knowledge-surface and code-complete practices. Output contract is documentation files with standards and council dependencies. Agents must run bash detection commands and produce files in docs directories rather than only advising workflows.1.4kinstalls4ResearchThe research skill explore and write findings. Triggers: "research", "explore and write findings.", "research skill". # Research Skill > **Quick Ref:** Deep codebase exploration with multi-angle analysis. Output: `.agents/research/*.md` **YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.** **CLI dependencies:** ao (knowledge injection - optional). If ao is unavailable, skip prior knowledge search and proceed with direct codebase exploration. ## Flags | Flag | Default | Description | |------|---------|-------------| | `--auto` | off | Skip human approval gate. Used by `/rpi --auto` for fully autonomous lifecycle. | ## Execution Steps Given `/research <topic> [--auto]`: ### Step 1: Create Output Directory ```bash mkdir -p .agents/research ``` ### Step 2: Check Prior Art **First, search and inject existing knowledge (if ao available):** ```bash # Pull relevant prior knowledge for this topic ao lookup --query "<topic>" --limit 5 2>/dev/null || \ ao search "<topic>" 2>/dev/null || \ echo "ao not available, skipping knowledge search" ``` **Apply retrieved knowledge (mandatory when results returned):** If ao returns relevant learnings or patterns, do NOT just load them as passiv.1.3kinstalls5HandoffThe handoff skill write compact session handoffs. Triggers: "handoff", "write compact session handoffs.", "handoff skill". # Handoff Skill > **Quick Ref:** Create structured handoff for session continuation. Output: `.agents/handoff/YYYY-MM-DD-<topic>.md` + continuation prompt. **YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.** Create a handoff document that enables seamless session continuation. ## Handoff is the write-side of the self-healing context loop Handoff is not only an end-of-session ritual - it is the **write-side of the `handoff → clear → rehydrate` loop** that keeps a long-running agent (or a peer orchestrator) healthy against context bloat. The natural pre-`/clear` step is to hand off: capture the working state to durable state *first*, then clear, then rehydrate from the artifact. **Handoff before clear, always** - clearing without a current handoff loses the thread. For that to be safe, the handoff must be **complete enough to rehydrate the lane to exactly where it was**: the active goal, the claimed bead(s), held file reservations, the peer/comms topology, and a pointer to the working thread.1.3kinstalls6PlanThe plan skill decompose goals into issue plans. Triggers: "plan", "decompose goals into issue plans.", "plan skill". # Plan Skill > **Quick Ref:** Decompose goal into trackable issues with waves. Output: `.agents/plans/*.md` + br issues. **YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.** ## Absorbed trigger surface - planning-workflow (folded in, skill-prune phase 2) This skill also covers the retired `planning-workflow` skill: the comprehensive markdown planning methodology for software projects. Use `plan` when starting a new project, creating implementation plans, or refining architecture before coding - planning tokens are far fewer and cheaper than implementation tokens, so front-load the thinking. The absorbed methodology's bar for a *delivered* plan: self-contained (a fresh agent can implement without asking the human), dependency-aware (decomposes cleanly into a beads graph), justified (every non-obvious choice has a *why*), reviewed to steady-state by a strong reasoning model, and converted to beads with the dependency edges intact. Ground every load-bearing architectural claim (library choices, existing-codebase structure, performance/cost numbers) in a ve.1.3kinstalls7RpiThe rpi skill run discovery, crank, validation. Triggers: "run rpi", "research-plan-implement one turn", "drive a turn through the operating loop". # /rpi - Full Lifecycle Orchestrator > Quick ref: `/discovery` -> `/crank` -> `/validate`, then report. Do not only describe it.** RPI is autonomous unless `--interactive` is set. The user touchpoint is after validation, or after a real blocked state exhausts retries. Read [references/autonomous-execution.md](references/autonomous-execution.md) when you need the full autonomy contract. **`--auto` means *pivot autonomously*, NOT *execute the initial plan to the letter*.** Autonomy is agility, not waterfall: between waves the orchestrator re-plans the remaining work and changes course on its own - refactoring, adding, dropping, reordering waves as evidence arrives - without the operator saying so (touched only at the terminal objective or a circuit-breaker trip). See [Agile Re-Plan Loop](#agile-re-plan-loop-the-anti-waterfall-rule). ## Loop position `/rpi` is the orchestrator across **every move** of the [operating loop](../../docs/architecture/operating-loop.md): BDD intent → vertical slices → conflict-free wave → bead acceptance →.1.3kinstalls8ProductThe product skill create or refine PRODUCT md Triggers product create or refine product md product skill product Interactive PRODUCT md Generation Loop position move 1 shape intent of the operating loop docs architecture operating-loop md defines the PRODUCT md that anchors what counts as in-scope intent before discovery shapes a capability Purpose Guide the user through creating a PRODUCT md that unlocks product-aware reviews in pre-mortem and validate including the default quick-mode inline paths YOU MUST EXECUTE THIS WORKFLOW Do not just describe it CLI dependencies None required Execution Steps Given product target-dir target-dir defaults to the current working directory Step 1 Pre-flight Check if PRODUCT md already exists bash ls PRODUCT md 2 dev null If it exists Use AskUserQuestion Question PRODUCT md already exists What would you like to do Options Overwrite start fresh continue to Step 2 Update keep existing content as defaults read existing file use its values as pre-populated suggestions in Step 3 Cancel stop report no changes If it does not exist continue1.3kinstalls9ImplementThe implement skill implement one tracked issue. Triggers: "implement", "implement one tracked issue.", "implement skill". # Implement Skill > **Quick Ref:** Execute single issue end-to-end. Output: code changes + commit + closed issue. **YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.** ## Loop position Move **4 (TDD per slice)** of the [operating loop](../../docs/architecture/operating-loop.md). Consumes one vertical slice from the [slice validation plan](../../docs/templates/slice-validation.md); produces failing test → passing implementation → refactor-under-green. Discipline: (1) first failing test must fail for the right reason (missing behavior, not syntax); (2) smallest change to flip green; (3) refactor as its own commit. Slices that mix refactor + feature are two slices, not one. Code without a failing test has no contract; the slice is not done. Execute a single issue from start to finish. **CLI dependencies:** bd (issue tracking), ao (ratchet gates). Both optional - see `skills/shared/SKILL.md` for fallback table.1.3kinstalls10StatusThe status skill show AgentOps work status Triggers status show agentops work status status skill status Workflow Dashboard Purpose Single-screen overview of your current state YOU MUST EXECUTE THIS WORKFLOW Do not just describe it CLI dependencies bd ao gt all optional Shows what's available skips what isn't Folded triggers ag-s43tg wave 1 quickstart routes here quickstart status Step 3 Use when asked to show the AgentOps next action or what do I do first the state-aware SUGGESTED NEXT ACTION table Step 3 is the next-action surface For a fresh new-user setup Priority 1 Start with quickstart or research and Priority 12 clean state cover the onboarding walkthrough Use Unicode indicators for visual clarity Pass healthy PASS Warning partial WARN Fail missing FAIL Progress 3 7 with bar Workflow Dashboard RECONCILIATION Overall ao reconcile overall_status or unavailable High top high-severity findings max 3 or none Next first high finding next_action or none RPI PROGRESS Phase current phase from chain jsonl research plan implement validate idle Gate last completed gate or1.3kinstalls11GoalsThe goals skill maintain AgentOps goals. Triggers: "goals", "maintain agentops goals.", "goals skill". # /goals - Fitness Goal Maintenance > Maintain GOALS.yaml and GOALS.md fitness specifications. Use `ao goals` CLI for all operations. **YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.** ## Quick Start ```bash /goals # Measure fitness (default) /goals init # Bootstrap GOALS.md interactively /goals steer # Manage directives /goals add # Add a new goal /goals drift # Compare snapshots for regressions /goals history # Show measurement history /goals export # Export snapshot as JSON for CI /goals meta # Run meta-goals only /goals validate # Validate structure /goals prune # Remove stale gates /goals migrate # Migrate YAML to Markdown /goals trace # Render/audit the executable-spec chain /goals render # Export directive scenarios as Gherkin ``` ## Format Support | Format | File | Version | Features | |--------|------|---------|----------| | YAML | GOALS.yaml | 1-3 | Goals with checks, weights, pillars | | Markdown | GOALS.md | 4 | Goals + mission + north/anti stars + directives | When both files exist, GOALS.md takes precedence.1.3kinstalls12SecurityThe security skill run repository security scans for vulnerabilities, dependency risk, secrets, and release gates. Triggers: "security", "run repository security scans for", "security skill". # Security Skill > **Purpose:** Run repeatable security checks across code, scripts, hooks, and release gates, plus composable binary/internal-testing primitives and offline repo-surface redteam for authorized targets. Use this skill when you need deterministic security validation before merge/release, recurring scheduled checks, binary black-box assurance, or offline prompt-surface redteam. This skill has two complementary surfaces: 1. **Repository security gate** (`scripts/security-gate.sh`) - fast/full/nightly scanner gates for code, scripts, hooks, and release readiness. **Composable security suite** (`scripts/security_suite.py`, `scripts/prompt_redteam.py`) - testable, reusable primitives for authorized binaries and repo-managed prompt surfaces, with policy gating and machine-consumable outputs. ## Quick Start ```bash /security # quick security gate /security --full # full gate with test-inclusive toolchain checks /security --release # full gate for release readiness /security --json.1.3kinstalls13ConverterThe converter skill in the boshu2 agentops collection transforms workflow artifacts between supported formats so downstream agentops steps receive normalized inputs. It fits pipelines where logs, manifests, task specs, or exported agent outputs must be converted before validation, reporting, or deployment stages. Agents invoke it when standardizing file formats, normalizing field names, or preparing converter outputs compatible with other agentops skills such as standards or deployment helpers. The skill expects explicit source and target format instructions and preserves traceability by noting conversion assumptions. Use inside broader agentops automation chains rather than as a standalone end-user utility.1.2kinstalls14StandardsThe agentops standards skill defines conventions for boshu2 agentops pipelines including artifact naming, manifest fields, validation checkpoints, and required metadata across automation stages. Agents use it to audit workflow repos for missing standard files, inconsistent step labels, or outputs that break downstream converter and deployment skills. It specifies how tasks should declare inputs, outputs, versioning, and failure reporting so multi-agent runs remain reproducible. Invoke when standardizing an agentops project, onboarding a new workflow stage, or reviewing whether existing automation complies with the shared standards document.1.2kinstalls15SharedThe shared AgentOps skill is an internal library tier reference directory consumed by other AgentOps skills rather than a directly invocable workflow. It provides validation-contract.md for accepting spawned work, Claude Code feature contracts, and backend spawn examples for Claude native teams, Codex subagents, background tasks, and inline single-agent mode. Additional references document verified Claude and Codex CLI command shapes plus a dated failure log with mitigations from live runs. Skills including council, crank, swarm, research, and implement load these JIT reference documents when needed. CLI availability patterns require graceful degradation when external CLIs are absent, treating inline mode as the baseline rather than a degraded fallback.1.2kinstalls16RefactorRefactor is a skill that executes safe, incremental refactors one transformation at a time, running the test suite and committing after each atomic change. A developer uses it to reduce complexity, extract methods or modules, and remove over-abstraction without breaking behavior. It supports target, sweep, and extract modes and never batches changes so any regression is easy to revert.77installs17Testtest generates tests, analyzes coverage, fills gaps, and runs TDD loops, then produces passing tests plus a coverage report. It detects the project language from marker files (go.mod, pyproject.toml, package.json, Cargo.toml), loads that language's standards, and authors tests forward from Gherkin acceptance scenarios when they exist. A developer uses it to raise coverage and prove behavior.77installs18BootstrapBootstrap initializes AgentOps project files in a repository, creating the .agents/ scaffolding plus GOALS.md, PRODUCT.md, README.md, and PROGRAM.md. It detects whether the repo is bare, partial, or complete and fills only the missing pieces, delegating to the goals, product, and doc skills. Developers run it once to set up the AgentOps knowledge-store structure a repo needs before running the flywheel.74installs19ScaffoldThis skill generates project, component, and CI/CD scaffolds with real, functional files rather than placeholders. A developer runs it to stamp a new Go, Python, Node/TypeScript, Rust, or React project, add a module to an existing project, or generate a CI pipeline. It layers in cross-cutting concerns like .editorconfig, pre-commit hooks, a real passing test, and a project CLAUDE.md, then verifies the scaffold builds, tests, and lints.61installs20ScopeThis skill lets an agent operator declare which directories are in scope for a work session and hard-blocks any edit outside them. Frozen directories are written to a .agents/scope.lock file, and a PreToolUse hook rejects Edit, Write, or Bash calls that target paths outside every frozen directory. A developer uses it to fence agent swarms during risky changes; the guard fails open when the lock is missing or empty.47installs21Validatevalidate is the canonical validator skill that produces PASS/WARN/FAIL verdicts for artifacts, plans, code, PRs, or gates. It runs multi-judge consensus reviews, readiness and completion audits, and PR-shape checks, and requires the acceptance verdict to come from a blind judge that did not author the code. A developer uses it to prove a plan or change is ready before a bead closes.45installs22Skill BuilderThis skill materializes a new SKILL.md against the unified AgentOps template, with modes to scaffold from scratch, copy from a sibling skill, or absorb an external skill. After every build it runs skill-auditor as a mandatory self-check and aborts on a FAIL verdict. A developer uses it to author new Claude Code skills; it produces both Claude and Codex twin files and enforces a 250-line ceiling with overflow moved to references.43installs23DomainDomain is a library skill that holds the shared vocabulary and discipline that agents and other skills cite when describing work. It is not run standalone; it fixes the meaning of terms like tracer bullet, vertical slice, and the Context Density Rule so meaning is not improvised across sessions. Entries are loaded just-in-time from an index and cited by slug, and promotion from draft to canonical requires operator approval.41installs24Agent NativeA doctrine skill for making an out-of-session agent (an Anthropic Managed Agent, an Agent SDK loop, or a self-hosted sandbox job) AgentOps-native without runtime hooks. It replaces the old reflex of porting marketplace hooks with three mechanisms: loading AgentOps skills into the agent definition, exposing the ao CLI as a callable tool, and gating output through the local cockpit and CI backstop. A developer uses it to keep a cloud or SDK agent under the same guardrails as an interactive session.25installs25Automation Shape RoutingAutomation-shape-routing is a meta decision skill that picks the shape of an agent automation before any is built. It distinguishes a one-shot deliverable (do it inline or fan out a few in-session subagents) from reusable automation, then routes reusable work to a deterministic Workflow, a long-lived human-attachable ATM swarm, or a plain skill. Developers use it to avoid standing up orchestration machinery that costs more than the task.25installs26Workflow BuilderThis skill scaffolds a new Claude Workflow script for deterministic multi-agent orchestration. A developer uses it once the automation shape is confirmed to be a Workflow (a deterministic DAG returning structured JSON, run headless). It starts from a canonical template and walks through schemas-first authoring, choosing parallel() versus pipeline(), budget guards, and a conformance self-check.25installs27Agent MailOperating doctrine for Agent Mail, a side channel that coordinates multiple agents sharing one repo through file reservations, inboxes, threads, acknowledgements, and handoffs. A developer uses it when two or more agent lanes write the same repo and need to reserve a hot path before editing to prevent silent clobbering. It also defines the boundary: Agent Mail handles leases and notifications, while BR/beads remains the durable source of truth for work state and evidence.23installs28Agy NativeA skill for driving the AgentOps operating loop on Google's Antigravity (AGY) image using the agy CLI backed by its brain/knowledge store. It is the third harness alongside the Claude and Codex images, running the same claim-work-validate-close-persist loop with AGY-native primitives (headless agy -p, plugins, --add-dir scoping, durable brain memory). A developer uses it to run the loop on AGY, enforcing that the author is never the judge and that beads close only against persisted evidence.23installs29Casscass is a skill that mines past agent sessions for working prompts, decisions, and patterns. A developer uses it for session archaeology, prior-art checks, and recovering context after a crash. It wraps the upstream self-describing cass binary and adds an operating doctrine for when and how to search history.23installs30Cc Hookscc-hooks is a skill for configuring Claude Code hooks that fire shell commands at lifecycle events (PreToolUse, PostToolUse, Stop, Notification). A developer uses it to gate or react to tool calls, block actions, or trigger automation inside a session. It is the fold target for the related cc-* loop, subagent, and worktree-isolation skills.23installs31Codex Execcodex-exec is a skill for running Codex workers and validators non-interactively through codex exec on the ChatGPT Pro (OAuth) subscription. A developer uses it to spawn headless factory or loop workers and validators as a second-vendor lane. It enforces subscription (not per-token API) billing, deliberate sandbox selection, and safe stdin handling.23installs32DcgDCG is a destructive-command guard that blocks dangerous shell, git, database, filesystem, and Kubernetes commands and offers a safe alternative for each. When an agent hits a block it explains why, suggests a recoverable variant such as git stash for git reset --hard, and only surfaces a human-approved allow-once code when no alternative exists. It is context-aware, so rm -rf ./build is allowed while rm -rf / is blocked.23installs33NtmA skill that provides operating doctrine for orchestrating NTM (Named Tmux Manager) agent swarms through its robot API. A developer uses it to spawn and send panes, read robot state, manage locks and mail, run pipelines, and triage work in a tmux-based control plane. It enforces a mandatory loop that discovers the live NTM contract, snapshots state, and verifies transitions in the robot snapshot rather than trusting exit codes. The same binary is also aliased as atm.23installs34Rchrch is a Claude Code skill for the Remote Compilation Helper, which transparently offloads compilation commands to remote workers via a PreToolUse hook. A developer uses it when builds are slow or when the RCH pipeline is failing or silently falling back to local execution. It carries a triage doctrine of self-resolving before asking the human, with a fast triage order, quick-fix table, and recovery playbooks for hook, daemon, worker, SSH, sync, and disk issues.23installs35Reality Checkreality-check is a Claude Code skill that runs a mid-epic strategic drift audit. A developer uses it at a wave boundary when tracker counts look healthy but nobody can demo the headline feature, to articulate implemented reality against claimed vision. It extracts falsifiable promises, establishes implemented reality by running the code, emits a cited gap list with per-promise status, and routes uncovered gaps into the planning stack. It is audit-only and never patches code.23installs36SbhSBH (Storage Ballast Helper) is a disk-pressure defense tool for AI coding workloads. It prevents disk-full failures through pre-allocated ballast files that release instantly, an artifact scanner that scores stale files for cleanup, and a daemon that monitors pressure across mounts including /tmp, /dev/shm, and swap. A developer uses it via CLI or systemd/launchd to check free space, run emergency cleanup, and see pressure sources in a TUI dashboard.23installs37Account RotationA router skill for switching coding-agent accounts when you hit a usage or rate limit, or to spread parallel swarm lanes across accounts for more quota. It routes to the right tool by host and agent: claude-acct swaps the Keychain token plus identity for Claude on macOS, and caam swaps the auth file for Codex, Gemini, and Claude on Linux/WSL. It exists because caam's file swap is a no-op for Claude on macOS, whose token lives in the login Keychain.22installs38Good SkillGood Skill is a test fixture for the AgentOps skill-eval gate. It is a minimal SKILL.md that satisfies every blocking eval rule with required metadata, a non-empty description, no secrets, and no unsafe paths. Developers use it to verify that the skill quality gate passes on a known-clean input.22installs39OperationalizeA skill that distills a finished artifact such as a research report, codebase recon sweep, or painful learning into a handful of evidence-anchored rules, then routes each rule to the automation shape that will enforce it next time. A developer uses it when they have gathered rich context and want it to change behavior instead of dying in the artifact. Every rule uses the form 'When X, do Y because Z' with a cited anchor, conflicts are marked DISPUTED, and gates start warn-only. The output is a rule packet plus one handoff stub per routed rule.22installs40Toil Miningtoil-mining scans usage history - past agent sessions, command analytics, and shell history - for repeated manual toil, scores each cluster by frequency times pain, and emits a ranked list of automation candidates. It filters out machine echoes and hands the ranked list to a separate routing skill that decides the automation shape. A developer uses it to decide what to automate next based on measured evidence rather than intuition.22installs41Using Gcusing-gc explains how to run AgentOps loops on the Gas City (gc) substrate for out-of-session orchestration. It maps gc primitives - City, Rig, Pack, Agent, Order, Formula, mayor, refinery - onto AgentOps, where gc dispatches the whole rpi loop as one command without seeing its internal steps. A developer uses it for scheduled maintenance, autonomous bead drain, or a long-lived team-lead agent that drives PRs to merge.17installs42Known BadKnown-bad is a test fixture for the AgentOps skill auditor. Its SKILL.md passes Pass 1 frontmatter validation but intentionally violates Pass-2 content-discipline checks by omitting the Critical Constraints, Why rationales, Output Specification, and Quality Rubric sections. It is used to confirm the auditor returns a FAIL verdict on non-conforming input.2installs43Known GoodKnown-good is a minimal but complete SKILL.md test fixture for the AgentOps skill auditor. It satisfies all 15 auditor checks across Pass 1 and Pass 2, including canonical frontmatter, front-loaded constraints with Why rationales, an explicit Output Specification, and a Quality Rubric. Integration tests use it to confirm the auditor returns a PASS or WARN verdict on conforming input.2installs44AgentopsAgentOps is an operational layer for coding agents that adds bookkeeping, validation, and flows designed to compound knowledge between sessions. It targets teams running AI coding agents who want consistent state, checks, and accumulated context rather than starting cold each time. The skill focuses on the run-and-improve side of agent work.0installs45CassMine past agent sessions for working prompts, decisions, and patterns. Use when "what did I ask?", "find that prompt", session archaeology, or agent history.0installs