Skills by boshu2

High-risk skill: `council` spawns parallel judges and executes local shell commands (e.g., `codex exec ...`, `scripts/validate-council.sh`) and reads/writes files under `.agents/council`. It also sets env vars like `COUNCIL_CLAUDE_MODEL`, enabling CLI-driven background processes and external-model invocations.

This skill orchestrates spawning isolated agents to execute tasks in parallel (local and `--mode=distributed` modes). It includes explicit shell operations (`tmux new-session`, `git worktree add`, `ol hero ratchet`), checks/reads credential files like `~/.codex/config.toml`, and directs modification/removal of agent config (`rm -rf ~/.claude/teams/<team-name>`).

This skill automates git-based debugging and root-cause investigation and writes reports to `.agents/research/YYYY-MM-DD-bug-*.md`. It includes explicit shell commands (e.g., `grep`, `git`, `git bisect`) and examples that modify environment variables and invoke the `bd` CLI, so it requires local command execution and environment access.

This skill orchestrates autonomous epic execution using `bd`/`/swarm` with optional distributed Agent Mail. It runs shell commands (e.g., `gt sling`, `tmux`, `git`), calls `http://localhost:8765/health`, modifies `~/.claude/mcp_servers.json`, and sets env vars like `TRACKING_MODE` and `TEST_FIRST`.

The skill automates deep codebase research and produces reports under `.agents/research/`. It contains imperative steps that execute shell commands (e.g., `mkdir`, `git`, `grep`), spawn subagents, and call external services (e.g., `curl` with `X-API-Key` / `$KEY`), introducing execution, network, and credential-use risks.

This skill decomposes goals into trackable issues and writes plan documents to ` .agents/plans/`, using exploration and task tools. It instructs executing shell commands (e.g., `mkdir -p .agents/plans`, `ls -la .agents/research/`), invoking CLIs like `bd create`/`ao ratchet record`, and handling credentials such as `clientId`/`clientSecret`.

Provides code validation: runs complexity analysis and a multi-model council to answer "Is this code ready to ship?" It executes shell tools (e.g., `ol validate stage1 -o json`) and invokes external CLIs/search (e.g., `ao search`), requiring local command execution and outbound network calls.

This skill automates post-mortem workflows: it runs repository checks, invokes council/retro agents, synthesizes learnings, and writes reports to `.agents/rpi/next-work.jsonl` and other `.agents/*` paths. The skill explicitly runs shell/CLI commands (e.g., `PM_START=$(date +%s)`, `ao forge index .agents/learnings/`, `mkdir -p .agents/rpi`).

This skill analyzes Python and Go code complexity and produces reports written to `.agents/complexity/YYYY-MM-DD-<target>.md`. It mandates executing shell commands (e.g., `radon`, `gocyclo`, `git diff`) and installing tools (`pip install radon`, `go install github.com/fzipp/gocyclo/cmd/gocyclo@latest`), which runs code and performs network downloads.

This skill automates writing retrospectives and indexing learnings into `.agents` directories. It runs shell commands like `git log` and `ao forge index`, reads the environment variable `$CLAUDE_SESSION_ID`, and includes examples of modifying `.claude/commands/plan.md`.

This skill searches and synthesizes knowledge from local artifacts and tools (e.g., using `ao forge search`, `mcp__smart-connections-work__lookup`, and `grep`). It explicitly instructs executing shell commands like `ao forge search "<query>"` and `grep -r "<query>" .agents/` that read files such as `~/.claude/plans/`, posing execution/network risk.

This skill automates generating and validating documentation for repositories, writing outputs under `docs/` and `.agents/doc/`. It directs executing local shell commands (e.g., `ls package.json`, `grep`, and `scripts/validate.sh`) and running networked CLIs such as `gh issue create`.

This skill monitors an Agent Mail inbox and fetches messages via MCP or HTTP at `http://localhost:8765/mcp/`. It executes shell commands (e.g., `curl -s http://localhost:8765/health`), reads environment vars like `OLYMPUS_DEMIGOD_ID`, and instructs modifying `~/.claude/mcp_servers.json`.

This skill creates structured session handoffs and writes files under `.agents/handoff`. It instructs executing local shell commands (e.g., `mkdir -p .agents/handoff`, `git log`, `ls .agents/research/*.md`) and does not request network endpoints or secret access.

This skill automates end-to-end implementation of a single issue: it edits files, runs tests, commits changes, and closes the issue. It instructs running shell commands like `bd show <issue-id>` and `git commit`, and calling agent-mail tools such as `mcp__mcp-agent-mail__send_message` while referencing `OLYMPUS_DEMIGOD_ID`.

The `trace` skill traces design decisions across CASS sessions, handoffs, git, and research artifacts and writes reports to `.agents/research/YYYY-MM-DD-trace-<concept-slug>.md`. It contains explicit imperative execution steps and shell/CLI commands (e.g., `cass search`, `git log`, `ls`, `grep`) and includes a runnable script `scripts/validate.sh`.

This skill documents the `bd` CLI and agent integration patterns for issue tracking, routing, and workflows. It instructs running shell/CLI commands (e.g., `bd sync`, `git push`, `rm -rf .beads/`), uses env vars like `BEADS_DIR` and `ANTHROPIC_API_KEY`, and performs remote sync (`bd sync`).

This skill traces knowledge artifact lineage and produces a provenance report for artifacts referenced as ` <artifact-path>` and files in ` .agents/`. It instructs executing shell commands such as `grep`, `find`, `cass search` and `ao forge search`, enabling local shell execution and likely external CLI network queries.

This skill manages RPI workflow gates and records progress using the `ao` CLI and a chain file (`.agents/ao/chain.jsonl`). It instructs executing shell commands such as `ao ratchet status`, `cat .agents/ao/chain.jsonl`, and `echo ... >> .agents/ao/chain.jsonl`, which is shell execution.

This skill provides language-specific coding standards and on-demand reference files for other skills. It includes a repository-local validation script `scripts/validate.sh` and example shell commands (e.g., `wc -w SKILL.md`) that execute local checks; no external network endpoints or secret access are requested.

This skill injects prior knowledge from `.agents/` artifacts into the session context and can be triggered via a SessionStart hook or `/inject [topic]`. It contains explicit local shell commands such as `ao inject --apply-decay --format markdown --max-tokens 1000` and `ls -lt .agents/...` which execute locally.

Monitors a knowledge flywheel by running local shell checks against `.agents/` artifacts, invoking the `ao` CLI, and writing a report to `.agents/flywheel-status.md`. The skill includes shell execution (`ls`, `find`, `ao` commands) and references env vars `AGENTOPS_EVICTION_DISABLED` and `AGENTOPS_PRUNE_AUTO`.

This skill extracts decisions and learnings from Claude session transcripts, processes a pending queue, and writes results to `.agents/learnings/`. It invokes local shell commands such as `ao extract` and reads `.agents/ao/pending.jsonl`, which requires executing host shell commands.

This skill is a meta-reference for the RPI workflow and auto-injection of workflow triggers (e.g., `session-start.sh`) and includes a validation script `scripts/validate.sh`. It contains a fixed shell validation script but does not request secrets or explicit external network endpoints.

This skill orchestrates multiple Codex agents to run code fixes and write artifacts to `.agents/codex-team/`. It includes explicit shell execution (e.g., `codex exec` and `bash lib/scripts/team-runner.sh`), allowing the skill to run CLI processes on the host.

The skill mines session transcripts for decisions, learnings, failures, and patterns and writes findings to `.agents/forge/YYYY-MM-DD-forge.md`. It invokes local CLI commands such as `ao forge transcript --last-session --queue --quiet` and runs `scripts/validate.sh`, requiring shell command execution but no explicit network endpoints or secret access.

This skill is an interactive onboarding `quickstart` that runs an end-to-end Research→Plan→Implement cycle against the user's codebase. It includes executable shell snippets that read files like `~/.claude/settings.json`, modify hooks via `ao init --hooks`, and fetch/install software from `https://github.com/boshu2/homebrew-agentops`.

Dangerous skill: runs arbitrary shell commands for validation (`subprocess.run(..., shell=True)`, `Bash(command='codex exec ...')`) and modifies agent config `rm -rf ~/.claude/teams/<team-name>/`. It documents distributed orchestration and writes results to `.agents/*` files and uses `TeamCreate`/`Task` spawning patterns.

This skill provides a single-screen workflow dashboard that gathers local agent and repository state by running predefined shell commands (e.g., `git`, `ao`, `bd`, `gt`) and reading files under `.agents/` such as `.agents/ao/chain.jsonl`. The workflow explicitly instructs executing bash snippets to collect state; behavior is purpose-aligned and poses low security risk.

This skill prepares local releases: generates changelogs, updates version files, writes files under `.agents/releases/`, creates a release commit and an annotated tag. It instructs executing local shell/git commands (e.g., `git add`, `git commit`, `git tag -a`) which modify the repository; no remote publishing is performed.

This skill orchestrates a full RPI lifecycle (Research→Plan→Pre-mortem→Crank→Vibe→Post-mortem) via sequential sub-skill invocations. It instructs running local shell commands and scripts such as `mkdir -p .agents/rpi`, `scripts/rpi/context-window-contract.sh`, and `bash scripts/log-telemetry.sh`, and mutating `.agents/rpi/next-work.jsonl`.