/run

name: run
description: Run a Crucible review pipeline on the current project. The Profiler reads the project, interviews the user, and casts a 4–8 persona review committee from a 23-persona library. Peers review at the code level, departments hunt for gaps, leadership grades alignment, and the Aggregator synthesizes a final score and verdict. Output is a live terminal stream plus a fully-detailed markdown report at .review/reports/<id>.md.

/crucible:run — Corporate Review Pipeline

You are orchestrating a Crucible review pipeline on the current project. Execute the following stages in order. Stream progress to the terminal in compact form as each stage completes; write the full markdown report to `.review/reports/<review_id>.md` at the end.

The pipeline has five stages: Profiler (Stage 0) → Peer Code Review (Stage 1) → Cross-functional Gap Review (Stage 2) → Leadership (Stage 3) → Aggregator (Stage 4). Each stage is dispatched as one or more Claude Code subagents via the Task tool, with structured JSON handoff between stages.

Cost preview (mandatory first step)

Before doing anything else — before running `pwd`, before reading files:

1. **Output a one-line assistant-text hint** so the user knows what's about to appear. Suggested phrasing: *"Cost preview below — press Ctrl+O to expand if Claude Code shows it as a collapsed Bash pill."* You may rephrase, but the semantic content (preview is below, Ctrl+O to expand if collapsed) must be preserved. This is purely a visibility hint; the numeric content lives in the file printed by step 2.

2. **Print the cost preview** by running this Bash command:

cat "${CLAUDE_PLUGIN_ROOT}/templates/cost-preview.txt"

**Do not paraphrase, summarize, or modify the numbers** — the preview text is checked into the plugin verbatim and printed verbatim. Earlier versions of this SKILL inlined the preview as a fenced code block and instructed you to "print the following preview"; the orchestrator LLM treated that as "express the substance" rather than "literally output these exact characters" and lowered the per-tier cost floors by $3-5 across the board (e.g., `$4.50-7` was rendered as `$0.50-7`). Externalizing the preview to a file and `cat`-ing it via Bash is the deterministic fix — same architectural pattern as the v0.1.1 report renderer. The step-1 hint exists because Claude Code collapses Bash tool stdout into a pill by default; without the hint, users hit the cost-preview output only after pressing Ctrl+O (wet-test feedback from the 2026-05-22 Omnivore dogfood). Paraphrase risk is bounded for the hint itself because it's semantic, not numeric — unlike the cost numbers, the meaning survives minor rewording.

Then wait for the user's confirmation. If the user answers anything other than `y` or `yes`, halt and print: `Run cancelled. No artifacts written.`

If the user answers `y` or `yes`, proceed to Setup. Do NOT print the cost preview again on subsequent steps of the same run.

The cost preview exists because of a load-bearing v0.1.0 architectural finding: the orchestrator (this skill, running in the user's main thread) is the dominant cost driver, not the dispatched subagent tiers. Earlier v0.1.0 design attempted to move orchestration into a dedicated coordinator subagent (Haiku, then Sonnet) to decouple cost from the user's session model. That approach failed in two ways: (1) Haiku-as-coordinator silently impersonated personas instead of dispatching them via the Task tool, producing complete-looking reports with fabricated `model_used` fields, (2) when the coordinator was escalated to Sonnet to fix the impersonation, the Profiler — which needs to interactively prompt the user for aims confirmation and roster approval — became a sub-subagent, and nested subagent dispatch loses the user-interaction channel. The Profiler ran but didn't ask. v0.1.0 ships main-thread orchestration with this cost warning instead. Note: Haiku **as the main thread** does dispatch subagents correctly (verified 2026-05-12) — the impersonation failure mode was specific to Haiku running as a sub-subagent inside the dispatched coordinator, where the dispatch instructions read as workflow descriptions rather than tool calls. Haiku-main is a viable mode, with the template-adherence caveats noted in the preview text above.

Setup

1. **Determine the project root.** Run `pwd` via the Bash tool. The absolute path it returns is `project_root` — the working directory the user invoked Crucible from, and the root of the project under review.

**`project_root` is NOT `git rev-parse --show-toplevel`.** When the user runs Crucible from a fixture (e.g., `tests/fixtures/go-api/`), a monorepo package, or any nested directory, `project_root` is THAT directory. Using git's toplevel would mis-identify the project: running from `plugin-create/tests/fixtures/go-api/` returns `plugin-create/` as git toplevel, and the Profiler would then read Crucible's README and identify Crucible as the project under review instead of the Go service. **Always use the `pwd` value, never git toplevel.**

Every subsequent step uses `project_root` as the base path. All `.review/` paths resolve as absolute paths within `project_root`. The Profiler and all other subagents are told the exact `project_root` absolute path in their dispatch prompts — you (the orchestrator) are responsible for substituting the literal absolute path into the prompt before dispatching.

2. Generate `review_id` of the form `YYYY-MM-DD-HHMM-<slug>` using the current UTC time. The `<slug>` is derived from the user's review scope description: lowercase, hyphenated, ASCII only, ≤30 characters. If the user has not yet stated a scope, use the placeholder slug `pending`; the Profiler will refine it.

3. Record the run start time as an ISO 8601 string for the report header. Run `date -u -Iseconds` via the Bash tool and use the result as the `started_at` field that flows into the final report's "Generated:" line. The orches