skills

Render the EFFECTIVE Claude Code harness rulebook for this machine/project — what the current session may actually do — by merging every settings layer (global ~/.claude/settings.json, project .claude/settings.json, project settings.local.json) plus PreToolUse/PostToolUse hooks into one tiered view (free / consequential / guarded), flagging cross-shell asymmetries (a Bash rule with no PowerShell twin), wildcards that undo curated per-verb rules, and denies shadowed by allows. Use when you ask "what am I allowed to do", "what's my floor", "show the effective permissions", "render my rulebook", "why did that prompt", "audit my settings", "what's changed in my permissions", or invoke /floor. Read-only — it never edits settings.

Sign-on tool-health board — reads the workbench friction log and rolls it up per tool into a "how's each tool doing" view (recent friction, worst severity, one-line pain), using a LOCAL model (free, offline). Use when the operator asks "how are my tools doing", "tool health", "what's the friction", "how's everything doing", "anything need attention", "are my tools ok", or invokes /health, especially at sign-on. Distinct from /wip (in-flight work right now) and /status (session recap) — this is standing tool *health* from accumulated friction.

Offload a cheap, verifiable sub-task to the LOCAL model (Ollama, $0, offline) via the `local` CLI — narrow a big file list, extract structure from noisy tool output, classify log lines or command success/failure. Use PROACTIVELY mid-task when a sub-step is mechanical narrowing/extraction/shallow-classification AND you can verify the result at a glance; also when the operator says "offload that", "run that locally", "use the local model", or invokes /offload. NEVER for deep judgment (code review, risk calls, dense-diff reasoning) — that stays with you.

Build and mine a corpus of AI-draft → operator-final pairs so the agent's writing converges on the operator's real voice. Two verbs — capture (freeze the AI version of a draft BEFORE the operator edits it) and learn (diff the operator's final against the frozen AI version, classify every edit as voice vs content, and fold recurring voice edits into voice-profile.md and tellscan.mjs as dated, evidence-backed rules). Use when the operator says "voice learn", "capture this draft", "here's my final version, learn from it", "diff my edits", "store this pair", "learn my voice", or invokes /voice-learn. Corpus lives under a writing dir you configure (e.g. ~/writing/corpus/); the voice profile stays the single contract.

Fork a thread that came up mid-task into its own briefed Claude Code session — without derailing the agent that's currently working. The source agent pauses just long enough to emit a thread-scoped context packet, spins a chip seeded with it, and resumes its main task untouched. The chip becomes a fresh session you can question about that one thread. Use when the user says "transfer context", "pull on that thread", "fork this thread off", "spin that tangent into its own session", "hand this thread to another agent", "don't derail — chip that thread with context", or invokes `/transfer-context`. Distinct from /chip (fires off a TASK, and explicitly avoids conversation-dependent context) and /continue (hands off the WHOLE session). This is thread-scoped, conversation-dependent, and non-disruptive to the source.

Skill librarian - catalog every skill available in this session and recommend the best fit for a task. Discovers all skills on disk (personal ~/.claude/skills, project .claude/skills, and skills stranded in .claude/worktrees) by reading their frontmatter, so the catalog is always current. Run alone (/skills) for a grouped tabular overview of everything you have; run with a prompt (/skills open a pull request for my changes) to rank the catalog against that task and recommend the top matches with the exact command to type. Use when the operator asks "what skills do I have", "which skills are available", "what can I run", "is there a skill for X", "which skill should I use for Y", "recommend a skill", "I forget what skills I built", "what's available to me", or invokes /skills.

Consolidate the AI PR reviewers (Codex, Claude, Cursor Bugbot, GitHub Copilot) on a pull request into ONE verdict — a deduped, severity-ranked finding list plus a block/go merge gate — and post it as a single sticky comment layered on top of (never replacing) the bots' own comments. The "judge" over the finders: it consolidates, it never produces findings of its own. Use when you (or work-driver) want one pane + one merge decision instead of reading four separate bot comment streams. Triggers: "consolidate the reviews on PR <n>", "what's the verdict on PR <n>", "judge the bot findings", "/review-coordinator <n>". NOT a reviewer itself — pair it AFTER the bots have reviewed.

Turn a PR's AI-reviewer comment pile (codex / cursor / claude / copilot) into a clean, line-grouped digest using a LOCAL model — each bot's own headline + stated severity + verdict, extracted (not re-judged), grouped by file:line. Free, offline, no cloud tokens. Use when someone says "triage the comments on PR N", "what did the bots flag on PR N", "digest the review comments", "summarize the PR feedback", or invokes /review-digest N. A pre-pass that feeds a review coordinator — advisory only, it never gates a merge.

Multi-editor editorial pass over a draft (blog post, essay, README-as-prose) in YOUR voice — a mechanical AI-tell scan, six specialized editor lenses fanned out via the Workflow tool, an editor-in-chief consolidation with verbatim old/new fixes and a publish verdict, then must-fixes applied. Use when you say "editorial pass", "edit my draft", "run the panel on this", "de-AI this post", "does this sound like me", "voice pass", or invoke /editorial-pass <draft-path>. Grounded in a voice-profile doc you provide; pairs with /interview for sections that need raw material instead of editing.

Answer a question about YOUR OWN work — your code, docs, notes, past decisions and conventions — using a LOCAL offline second-brain (Ollama RAG over an index of your corpus). Free, no cloud, no data egress. Use when you ask "have we solved this before", "what's my convention for X", "where did I do Y", "what did I decide about Z", "search my own work / docs / notes", or invoke /ask-portfolio. ONLY for questions grounded in your own corpus — never general-knowledge questions.

Route a PR to the right amount of human review — classify a PR's risk so review attention goes where judgment is irreducible and the safe majority clears without a human. Review load should scale with risk, not PR count. Two layers — an optional deterministic floor (a small classifier you provide) plus an agent advisory pass (this skill) that may only escalate, never lower. Use when deciding how much review a PR needs, or invoke /pr-risk <owner/repo#num>.

Reconstruct and resume what an abrupt crash, reboot, or terminal loss interrupted. Scans recent Claude Code session transcripts, classifies each (task · cwd · last action · done-vs-interrupted), detects dead background jobs and crash-casualty dirty repos, and emits a ranked recovery plan with exact `claude --resume <id>` commands. Read-only — never auto-resumes, restarts, or kills anything. Use when the user says "my computer crashed", "I lost my terminals", "recover my sessions", "what was I running", "reboot ate my work", "reattach my sessions", "how do I get my sessions back", or invokes /recover. Distinct from /wip (live cross-store work board), /continue (deliberate handoff prompt), and /shipped (retrospective on landed work).

Take a design doc through to a PR with reviews requested. Implements the doc, opens the PR, iterates locally on CI until green, then waits for reviews and addresses every actionable comment — surfacing anything ambiguous or sweeping back to the user.

Standing cross-store board of what's open or in-flight RIGHT NOW — joins ship (workflow + driver runs), dossier (claimed/in_progress/blocked tasks + the fresh todo queue), and open PRs into one liveness-ranked view, with a red "on fire" band for stuck ship dispatches and stale rows quarantined into a reconcile bucket. Personal-scoped by default (everything behind --all). Use when the user asks "what's in flight", "anything running", "what's queued", "what's cooking", "where are things", "what's open right now", "any work in progress", "wip", or invokes /wip. Distinct from /status (situational session recap) and /shipped (retrospective on landed work).

Turn an expert's unwritten knowledge into a finished artifact (slide deck, design doc, ADR, post-mortem, onboarding guide, Gamma outline) by driving an interview-to-artifact loop. Curate a spine, fan out agents to generate deep story-eliciting questions in the expert's voice, assemble one fillable resumable interview doc, let the human fill answers over time, then synthesize the captured answers into the target artifact in their voice. Parameterized by an artifact adapter. Use when the operator says "interview me about X", "build me an interview for X", "turn my brain dump into a deck/doc/guide", "draw this out of my head", "I want to make a talk/deck/guide about X but staring at a blank page", "elicit my thinking on X", or invokes /interview. The deck adapter hands off to the pptx skill; the doc adapter to markdown/docx. Reach for this whenever the bottleneck is getting knowledge OUT of a person, not the final format.

Scaffold (or refresh) a compact `## Dev workbench` section in a repo's CLAUDE.md — a COMPOSITIONAL map of the operator's portfolio workbench (MCPs dossier/ship/huddle/playwright + the work-driver / review-coordinator / consult / shipped / status / worktree-* skills), NOT an exhaustive per-verb manual. The harness already injects each tool's description + signature into every session; this section captures only what injection can't give: the roster (one line each), the end-to-end loop, the seams, and the behavioral nudge ("call the verb, don't ask"). Same shape across every repo. Idempotent re-run between guarded markers. Use when onboarding a fresh repo, when the workbench's composition changes, or when an existing repo's CLAUDE.md is missing the workbench map.

Summon another portfolio repo's steward agent and get a same-turn answer to a question about that repo — instead of asking the operator. Use when the user says "ask the <repo> agent", "what does the ship steward think", "consult roxiq about X", or invokes /consult <repo> "<question>". Also use PROACTIVELY mid-task, without being asked, whenever you're stuck on a KNOWLEDGE question about another portfolio repo's behavior, design, or conventions — consult that repo's steward before asking the operator. Only AUTHORITY questions (product direction, spend, irreversible calls) go to the operator.

Build the spec docs + work-driver invocation for a batch of dossier tasks. Resolves task IDs or a phase slug, generates one spec doc per task, detects file-overlap conflicts, groups into parallel-safe batches, and emits ready /work-driver commands. Use before /work-driver when you have N small tasks to ship in parallel and want to skip the manual "draft a spec for each, figure out which can run together" step.

Seed a dossier phase + PR-sized task docs from a described chunk of work — sized and dependency-ordered for the /work-driver chain. The lightweight front-end to /work-driver-prep for work that's too big for a single hand-made task but too small for a /tdd (no thousands-of-lines reviewed design doc warranted). Composes dossier verbs only; no repo design doc, no spec docs, no execution. Triggers: "seed the phase + tasks", "set up dossier tasks for <chunk>", "break this chunk into tasks for the driver", "seed work-driver for <chunk>", a mid-size multi-PR chunk that's been discussed and just needs to land in dossier as tasks, explicit /work-driver-seed. Anti-triggers: a single one-off task (task_create directly), a real feature needing a reviewed design (/tdd), tasks already created and ready to spec (/work-driver-prep), a hygiene/polish sweep (/polish).

Chain the post-implementation wrap-up for committed work - file the Jira ticket, open + describe the PR, and sync the epic. Orchestrates /spinup-ticket -> push + PR -> /write-pr -> /sync-epic, threading the new ticket key through each step. Use when the work is committed on a branch and the user says "ship this ticket", "wrap this up", "file the ticket and open the PR", or "/ship-ticket <epic>". NOT for implementation, commits, or merging - the diff is assumed done.

Create a Jira ticket under a given epic via the Jira REST API. Use when the user says "spin up a ticket", "create a Jira ticket", "open a ticket in <epic>", or similar - typically just before kicking off a new piece of work that needs tracking. This skill only deals with the ticket itself; branches, PRs, and implementation are out of scope.

Audit a Jira epic and bring each child ticket's status in line with its GitHub PR state (draft PR -> In Progress, open PR -> In Review, merged PR -> Done). Use when the user says "sync the epic", "fix the epic statuses", "the epic is out of date", or invokes `/sync-epic <epic-key>`. Presents a diff first; applies transitions after one confirmation.

Write or update the current PR description in a standard format (Summary, Closes [ticket], What this adds, Validation). Use when opening a new PR or refreshing an existing one.

Emit a paste-ready continuation prompt that lets a fresh Claude Code session pick up exactly where this one left off. Use when context is filling up and the user says "continuation prompt", "continue prompt", "write me a continuation", "carry this over", "hand this off to a fresh session", "I'm running low on context", or invokes `/continue`. NOT the CLI `--continue` flag — this produces a self-contained handoff brief.

Drive N parallel tasks end-to-end through ship's `ship driver` engine — the state machine (import → dispatch → poll → judgment → land → record) that replaced the hand-run per-stream `mcp__ship__ship` loop. Resolves dossier task IDs (or a phase, or an existing driver.md), preps specs + a conflict-batched manifest, dispatches all streams (cloud by default), handles failures via `ship driver decide`, drives the resulting PRs through review→merge, records merges back, and logs friction. Use when you want to fire one or several tasks in parallel and have an agent drive them to merge — "drive this impl work", "drive these 3 tasks", "run this batch through ship", "parallel-ship these", "ship and merge", "fire N parallel streams", explicit /work-driver.

Scaffold (or refresh) the maintainer's canonical Cursor subagent set into a repo's `.cursor/` tree. Writes five `.cursor/agents/*.md` files (code-reviewer, scope-tracker, test-author, validator, ci-checker) plus `.cursor/rules/use-subagents.mdc` (the dispatch nudge). Same shape across every portfolio repo so any `ship.ship` run anywhere gets the same inner-loop coverage. Idempotent re-run — preserves user-added agents that aren't in the canonical set; prompts on per-file drift before overwriting customizations to canonical files. Use when onboarding a fresh repo for ship dogfood, when one of the canonical agents is updated upstream, or when an existing repo's `.cursor/agents/` is missing or partial. Fork and edit the canonical set under `templates/` to match yours.

Audit a project in your portfolio for polish gaps (CI jobs, README, public-surface doc comments, lint strictness, coverage workflow, doc/code drift, etc.) and emit one dossier task per finding under a fresh `<project>-polish-<YYYY-MM-DD>` phase. Stack-aware — detects Rust / Go / Node / Python / Elixir / Ruby by manifest file and adapts every check to the detected stack. Hand-off chain ends at /work-driver. Triggers: "polish <project>", "what should we clean up in <project>", "audit <project>", explicit /polish.

Remove a secondary git worktree, handling dirty state interactively. Use whenever the user says things like "remove the worktree", "drop the worktree", "clean up the worktree", "kill this worktree", "delete the worktree at X", or wants to free up a branch so another checkout can use it. Refuses to remove the main worktree.

Produce a tight 4-section status update (What happened / What's next / What I recommend / What I need from you), 1-3 sentences each. Use when the user says "give me an update", "status", "where are we", "sitrep", "recap", "summarize the situation", or invokes `/status`. Skip any section that's genuinely empty rather than padding it.

Create a new secondary git worktree under .claude/worktrees/ for isolated work on a branch. Use whenever the user says things like "create a worktree for X", "add a worktree", "spin up a worktree for this ticket", "make a new isolated checkout", "start a branch in a worktree", or wants to do a piece of work in parallel without disturbing the root checkout. Defaults to the .claude/worktrees/<branch>/ convention so the new dir is sandboxed from the main checkout.

List git worktrees in the current repo with branch, dirty state, and optional PR/CI status. Use whenever the user says things like "list worktrees", "what worktrees do I have", "show my worktrees", "which worktrees are open", or wants a status overview of in-flight work across worktrees. Pull PR/CI status from gh when worktrees correspond to branches with open PRs.

Transfer work from a secondary worktree to the root/main worktree by checking out its branch in root and removing the secondary worktree. Use whenever the user says things like "transfer the worktree to root", "bring this work over to main", "move the branch from the worktree", "switch root to the worktree's branch", "pull this into the main worktree", or is working in a .claude/worktrees/ subdirectory and wants to continue in the root. Invoke this proactively any time the user's intent is to consolidate a secondary worktree back into root.

Report the current git worktree, branch, and working directory for this Claude Code session. Use whenever the user says things like "where am I", "what branch am I on", "which worktree is this", "what repo are we in", "remind me where I'm pointing", "what are we working on right now", or is jumping between Claude Code tabs and needs to orient. Resolves the cwd to its worktree root and shows whether it's the main checkout or a secondary worktree.

Retrospective recap after a chunk of work lands — what shipped (PRs merged + shas + weighted-LOC, dossier task closures, friction-log entries), what changed about main, what's open, and what you might do next. Use after /work-driver, a chip blitz, a manual phase, or anytime the operator asks "what just shipped", "what did we ship", "what merged today", "post-run summary", "what now". Auto-detects work-driver manifests for ground truth; falls back to git/gh/dossier signals otherwise. Distinct from /status — /status is an in-flight ping, /shipped is a retrospective on landed work.

Pre-launch audit for any project in your portfolio. Detects stack (Rust/Go/Node/TS/Python/Elixir/Ruby), runs the public-readiness checklist (secrets in history, LICENSE, package metadata, README first-impression, .gitignore, personal/employer leaks, tags, CHANGELOG), and materializes findings as dossier tasks under a fresh prep-public-<date> phase ready for /work-driver-prep. Use when you're about to take a project public — link from a tweet or blog post, push to crates.io / npm / pypi / hex.pm, Show HN, "is <project> ready to launch", "prep <project> for public", "what's missing before I tag v0.1.0", or invokes /prep-public.

Scaffold (or refresh) a `## Engineering principles` section in a repo's CLAUDE.md — the operator's house style (Dave Cheney lineage, https://dave.cheney.net/practical-go): no `else` / line-of-sight, shallow nesting (≤2 per scope), policy vs mechanism, composition of single-responsibility swappable layers, small sharp APIs, errors-as-values, simplicity over cleverness. Stack-aware: detects Rust / Go / Elixir / Node / Python and tailors the idioms + the lint that ENFORCES each principle. Idempotent re-run between guarded markers, same shape across every repo. Use when onboarding a repo, when the principles evolve, or when a CLAUDE.md is missing the house-style context. Triggers: "add my code style / principles to this repo", "stamp the house style / eng philosophy", "the cheney section", explicit /eng-philo.

Spin the current discussion item off into its own Claude Code session via a chip in the UI. Use when the user says "chip this", "I'd like to do this on a chip", "spin this off", "make a chip for this", or invokes `/chip`. The chip launches a fresh session with its own worktree — useful for out-of-scope fixes, hygiene work, or anything you noticed in passing that shouldn't bloat the current turn.