cc-codeconductor 1.1.0 → 1.2.0

package/presets/gemini/commands/cc/fix.toml

@@ -0,0 +1,163 @@
+description = "validation, implementation, testing, and optional review."
+
+prompt = """
+# Bug Fix Workflow
+
+Bug description: {{args}}
+
+Provide the following information in {{args}}:
+
+- What is the incorrect behavior (actual)
+- What is the expected behavior
+- Steps to reproduce
+- Environment or version where the bug occurs (if known)
+- Any relevant error messages or stack traces
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `fix` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command fix "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command fix "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile fix --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command fix --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 0b — OpenSpec quality gates
+
+If `openspec status` reports an active change folder:
+
+1. Run: `npx cc-codeconductor openspec validate --output json`
+2. Run: `npx cc-codeconductor openspec analyze --output json`
+3. If analyze `stop` is true or any finding is CRITICAL, stop. Do not delegate to implementer.
+4. Next command spelling on this runner: `/cc:fix`
+
+Local development: `bun run dev <same argv>`. Published package: `npx cc-codeconductor`.
+
+Skills: `testing-tdd`, `evaluation`. Record `scorecard create --from-diff`.
+A small fix still needs a Task Card and a failing regression test first.
+
+---
+
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "{{args}}"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map modules, conventions, and impact radius. Do not write code in this step.
+Record a Repo Map artifact before intake.
+
+---
+
+## Step 2 — Task Card validation (Task Coach role)
+
+Invoke the `task-coach` subagent via the Task tool.
+
+Produce a Task Card that includes:
+
+- A clear statement of actual vs. expected behavior
+- Reproduction steps (or a note that they are unknown)
+- Risk classification: `low`, `medium`, or `high`
+- Scope: which files or modules are likely affected
+
+If reproduction steps are missing, ask for them before classifying risk. A bug
+without a reproduction path cannot be classified reliably.
+
+Capture evidence before tests: reproduction, logs or stack traces, and one
+falsifiable hypothesis of the root cause. Do not patch without that evidence.
+Redact secrets, tokens, and credential dumps from logs before they enter the
+Task Card. Summarize stack traces; do not paste env files.
+
+**STOP here. Show the Task Card and wait for human confirmation.**
+
+---
+
+## Step 3 — Route by risk
+
+Read the risk field from the Task Card and follow the corresponding route.
+
+### Low-risk route
+
+Applies when: the bug is isolated to a single component, existing tests cover
+the affected code, and no public API or shared state is involved.
+
+Route: Task Coach → Tester → Implementer
+
+Proceed directly to Step 3 (tests), then Step 4a.
+
+### Medium or high-risk route
+
+Applies when: the bug touches shared state, a public API, auth or payment paths,
+database writes, or the root cause is not yet understood.
+
+Route: Task Coach → Architect → Tester → Implementer → Reviewer
+
+Invoke the `architect` subagent before implementation. Architect must:
+
+- Identify the root cause (or document that it is unknown)
+- Define the fix approach and affected files
+- Flag any regression risk to adjacent components
+- Produce a Technical Plan
+
+**STOP here if high-risk. Show the Technical Plan and wait for human approval
+before continuing.**
+
+---
+
+## Step 4 — Regression tests (Tester role)
+
+Invoke the `tester` subagent via the Task tool. Apply for all risk levels.
+
+1. Write a regression test that reproduces the original bug and confirm it fails
+   before any fix (RED).
+2. Verify that existing tests still pass.
+3. Produce a Test Report: test added, case covered.
+
+---
+
+## Step 5a — Implementation, low-risk (Implementer role)
+
+Invoke the `implementer` subagent via the Task tool. Use the Task Card.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+1. Locate the defect using the reproduction steps.
+2. Apply the minimal fix — no unrelated changes.
+3. Run the suite and make the RED regression test pass.
+4. Produce an Implementation Summary: root cause, fix applied, files changed.
+
+---
+
+## Step 5b — Implementation, medium/high-risk (Implementer role)
+
+Invoke the `implementer` subagent via the Task tool. Use the approved
+Technical Plan and the Task Card.
+Implementer creates a Git Worktree before touching any file; all edits happen inside it.
+
+Follow the plan exactly. Any deviation requires a new Technical Plan approval.
+After implementation, run the full test suite.
+
+---
+
+## Step 6 — Review (Reviewer role) — medium/high-risk only
+
+Invoke the `reviewer` subagent via the Task tool. Use the diff and Task
+Card.
+
+Produce a Review Report with CRITICAL / WARNING / SUGGESTION findings. If any
+CRITICAL findings exist, **STOP**. Do not close the fix until they are resolved.
+
+---
+
+## Completion
+
+Report: Task Card, Implementation Summary, regression test added, Review Report
+(if applicable).
+
+The fix is complete only when: the regression test passes, the full suite
+passes, and no CRITICAL review findings remain.
+"""

package/presets/gemini/commands/cc/handoff.toml

@@ -0,0 +1,40 @@
+description = "CodeConductor handoff workflow"
+
+prompt = """
+# Handoff Workflow
+
+Handoff request: {{args}}
+
+## Step 0 — CCEP Bootstrap
+
+Command: `handoff` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command handoff "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command handoff "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile handoff --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command handoff --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Step 1 — Compact (docs)
+
+Invoke `docs`. Write **only** `.codeconductor/sessions/handoff.md` (gitignored).
+Do not write `.codeconductor/handoff.md` or any tracked path.
+
+Before writing, redact secrets, tokens, API keys, passwords, connection strings,
+`.env` contents, and log/stack-trace lines that embed those values. Summarize
+errors instead of pasting dumps. If unresolved credential material remains, stop
+and wait for a human (CCEP `stopOnHighRisk`).
+
+Include: goal, Task Card status (no secret fields), files touched, test
+pass/fail (not log dumps), open questions, and the next `/cc:` command.
+
+Do not edit source or tests.
+
+---
+
+## Completion
+
+Report the handoff path. Another session should be able to continue from that file alone.
+"""

package/presets/gemini/commands/cc/iterative.toml

@@ -0,0 +1,145 @@
+description = "Relentless Grilling, contract and spec design, TDD, council review, and docs."
+
+prompt = """
+# Advanced Iterative Workflow
+
+Iterative request: {{args}}
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `iterative` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command iterative "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command iterative "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile iterative --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command iterative --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 0b — OpenSpec quality gates
+
+If `openspec status` reports an active change folder:
+
+1. Run: `npx cc-codeconductor openspec validate --output json`
+2. Run: `npx cc-codeconductor openspec analyze --output json`
+3. If analyze `stop` is true or any finding is CRITICAL, stop. Do not delegate to implementer.
+4. Next command spelling on this runner: `/cc:iterative`
+
+Local development: `bun run dev <same argv>`. Published package: `npx cc-codeconductor`.
+
+---
+
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "{{args}}"` (and
+`graphify path` / `graphify explain` when two modules or one concept need a
+scoped subgraph). Then invoke the `repo-explorer` subagent via the Task tool
+with that graph output.
+
+repo-explorer maps directory trees, conventions, god nodes, and affected
+modules. Do not write code in this step. Write a short phase handoff (scope,
+files, open questions) before the next phase — do not chain agents on unspoken
+context.
+
+---
+
+## Step 2 — Relentless Grilling & Task Card (task-coach)
+
+Invoke the `task-coach` subagent via the Task tool.
+
+Produce a complete Task Card. The Task Card is ready when it contains: title,
+type, risk classification, scope, context, acceptance criteria, and
+constraints, and every assumption behind it has survived one grilling
+question (Grilling protocol).
+
+If any field is missing or ambiguous, ask one clarifying question at a time and
+wait for the answer. Do not proceed with an incomplete Task Card.
+
+**STOP here.** Unresolved grilling questions or missing fields populate
+`questionsForUser` in the CCEP-1 `planner-output`; the `ConfirmationGate`
+(`ccep evaluate`) reads that field and halts the workflow until a human
+answers. Show the completed Task Card and wait for that confirmation before
+continuing.
+
+---
+
+## Step 3 — Contract & Technical Plan (contract-builder & architect)
+
+Invoke `contract-builder` then `architect` via the Task tool.
+
+1. Define API contracts, JSON Schemas, or TypeScript interfaces.
+2. Formulate the Technical Plan (chosen approach, affected files, trade-offs).
+3. Apply YAGNI, Simplicity First, and Stdlib-First.
+
+**STOP here. Show the Technical Plan and wait for explicit human approval. Do
+not proceed to tests until the plan is approved.**
+
+---
+
+## Step 4 — Test coverage (Tester role)
+
+Invoke the `tester` subagent via the Task tool.
+
+1. Write or extend failing tests for the new behavior before implementation (RED).
+2. Ensure all acceptance criteria from the Task Card have at least one test.
+3. Produce a Test Report: test files added or modified, cases covered.
+
+---
+
+## Step 5 — Implementation (Implementer role)
+
+Invoke the `implementer` subagent via the Task tool.
+
+Use the approved Technical Plan, contracts, and the failing tests.
+Implementer creates a Git Worktree before touching any file; all edits happen
+inside it.
+
+1. Read the Technical Plan before touching any file.
+2. Apply the minimal diff — only what the plan specifies.
+3. Run the project test suite and make the previously written failing tests pass.
+4. If tests fail, run up to 3 repair cycles (`implementer` → `tester`).
+5. Produce an Implementation Summary: what changed, which files, how to verify
+   locally.
+
+---
+
+## Step 6 — Multi-Perspective Council Review
+
+Invoke the `council` skill on the generated diff (`council-review` phase).
+
+The council evaluates Architecture, Security, Product, Delivery, DataOps, and
+Devil. `security-reviewer` may set `securityVeto: true`; that REJECTED verdict
+overrides majority consensus.
+
+If ANY agent votes CRITICAL:
+- The Review Report status is **BLOCKED**.
+- Return to Step 5 with the feedback.
+
+If APPROVED (no CRITICAL findings), continue.
+
+---
+
+## Step 7 — Documentation (Docs role)
+
+Invoke the `docs` subagent via the Task tool when a public API, public module,
+or user-visible behavior changed.
+
+Update: README (if applicable), OpenAPI spec (if applicable), CHANGELOG
+(always when implementation changed), ADR (if an architectural decision was
+made).
+
+If `graphify-out/` is in use, run `graphify update .` (AST-only).
+
+---
+
+## Completion
+
+The iterative workflow is complete only when: all tests pass, the council
+approves the spec and the diff, no CRITICAL findings remain, and documentation
+and the knowledge graph reflect the implemented behavior.
+"""

package/presets/gemini/commands/cc/openspec.toml

@@ -0,0 +1,186 @@
+description = "orchestrate agents by phase, review gate, and update backlog state."
+
+prompt = """
+# OpenSpec Backlog Workflow
+
+Scope: {{args}}
+
+Orchestrate FIFO delivery from `BACKLOG.md`. CodeConductor owns planning; agents execute one TaskCard per phase with the installed preset model for each role.
+
+---
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+Command: `openspec` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command openspec "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command openspec "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile openspec --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command openspec --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 0b — OpenSpec quality gates
+
+If `openspec status` reports an active change folder:
+
+1. Run: `npx cc-codeconductor openspec validate --output json`
+2. Run: `npx cc-codeconductor openspec analyze --output json`
+3. If analyze `stop` is true or any finding is CRITICAL, stop. Do not delegate to implementer.
+4. Next command spelling on this runner: `/cc:openspec`
+
+Local development: `bun run dev <same argv>`. Published package: `npx cc-codeconductor`.
+
+---
+
+
+## Step 1 — Validate (mandatory gate)
+
+Run:
+
+```bash
+npx cc-codeconductor openspec validate
+```
+
+If validation fails:
+
+1. List all errors and recommendations from the CLI output.
+2. Show the canonical BACKLOG.md structure (## Global, ## Items, ### BC-001 | Title, Priority, Status, Type, Depends on, Description, Scope, Acceptance).
+3. **STOP.** Do not scan, plan, or execute until the user fixes BACKLOG.md.
+
+---
+
+## Step 2 — Scan
+
+Run:
+
+```bash
+npx cc-codeconductor openspec scan
+```
+
+Report: new items, modified items, closed/archived items, and whether the file changed.
+
+---
+
+## Step 3 — Select item
+
+If `{{args}}` contains a `BC-xxx` ID, use that item. Otherwise run:
+
+```bash
+npx cc-codeconductor openspec status
+```
+
+Pick the next `READY` item with satisfied dependencies (FIFO by priority). Skip items in `DONE` or `Archive`.
+
+**STOP if no eligible item.** Report backlog status and wait for the user.
+
+---
+
+## Step 4 — Plan
+
+Run:
+
+```bash
+npx cc-codeconductor openspec plan <BC-id>
+```
+
+Show:
+
+- Generated TaskCards (discover → design → test → implement → review when TDD required)
+- Path to `openspec/changes/<slug>/` (proposal, design, tasks, specs)
+
+Update BACKLOG item status to `PLANNED` (CLI does this automatically).
+
+---
+
+## Drive card status (CLI)
+
+Do not edit `.codeconductor/openspec-state.json` by hand.
+
+```bash
+npx cc-codeconductor openspec start <cardId>
+npx cc-codeconductor openspec done <cardId>
+npx cc-codeconductor openspec block <cardId> --reason "waiting on design"
+npx cc-codeconductor openspec archive <itemId>
+```
+
+`start` moves the card `pending → doing` and the item `PLANNED → IN_PROGRESS`. `done` marks the card complete, updates Progress, and moves the item to `REVIEW` when every card is done and review is required. `archive` requires all cards done (and review evidence when Global review is required) and moves `openspec/changes/<slug>` to `archive/`.
+
+---
+
+## Step 5 — Model matrix and execute loop
+
+Before executing phases, show resolved models:
+
+```bash
+npx cc-codeconductor scorecard models
+```
+
+For each pending TaskCard, run:
+
+```bash
+npx cc-codeconductor openspec next
+```
+
+Invoke the agent named on the card with **isolated** context (`/clear` between phases unless continuation is required):
+
+| Phase | Agent | Role |
+|-------|-------|------|
+| discover | repo-explorer | Map repo and impact |
+| design | architect | Technical plan |
+| test | tester | TDD tests (before implement if TDD required) |
+| implement | implementer | Minimal diff in worktree |
+| review | reviewer | Acceptance + scope gate |
+
+Use the model configured in the installed preset for each agent role.
+
+After each phase:
+
+- Mark progress in deliverable summary.
+- Run `npx cc-codeconductor openspec done <cardId>` when the phase completes. Do not edit openspec-state.json by hand.
+
+Implementer: create a Git worktree before editing (`git worktree add ../<branch>-session <branch>`).
+
+---
+
+## Step 6 — Review gate
+
+Run regression when BACKLOG Global `Review required: yes`:
+
+```bash
+npx cc-codeconductor scorecard regression
+```
+
+The `reviewer` agent must verify:
+
+- All acceptance criteria from BACKLOG.md
+- Tests pass
+- Scope matches the backlog item
+- No architectural violations
+
+If **rejected**: set item status `IN_PROGRESS`, record findings in state, **STOP** and report to user.
+
+If **approved**: proceed to Step 6.
+
+---
+
+## Step 7 — Scorecard and update backlog
+
+1. `npx cc-codeconductor scorecard create --task <BC-id> --from-diff`
+2. Complete criteria; `scorecard record` with verdict and optional cost/tokens
+3. Set item `Progress: 100%`, `Status: DONE` if PASS
+4. Move item to `## Archive` in BACKLOG.md if DONE
+5. Run `npx cc-codeconductor openspec scan`
+
+Report completion: Task Cards executed, scorecard verdict, change folder path, files changed.
+
+---
+
+## Skill
+
+Apply `.claude/skills/openspec/SKILL.md` for backlog format rules and state transitions.
+"""

package/presets/gemini/commands/cc/pagespeed.toml

@@ -0,0 +1,119 @@
+description = "CodeConductor pagespeed workflow"
+
+prompt = """
+# PageSpeed Performance Audit
+
+Audit web performance using the PageSpeed Insights API. Applies the 80/20
+principle: identify the 20% of changes that produce 80% of the performance gain.
+Produces a prioritized report in the current working directory.
+
+## Step 0 — CCEP Bootstrap
+
+Command: `pagespeed` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command pagespeed "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command pagespeed "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile pagespeed --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command pagespeed --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Usage
+
+```
+/cc-pagespeed --url <url> [--strategy mobile|desktop|both]
+```
+
+## Parameters
+
+| Parameter     | Required | Description                                                    |
+| ------------- | -------- | -------------------------------------------------------------- |
+| `--url`       | Yes      | Full URL to audit (must include scheme: https://...)           |
+| `--strategy`  | No       | Analysis strategy: `mobile`, `desktop`, or `both` (default: `both`) |
+
+## Requirements
+
+### `PAGESPEED_API_KEY` — Optional but strongly recommended
+
+| Mode         | Lab data | CrUX field data | Rate limits      |
+| ------------ | -------- | --------------- | ---------------- |
+| **With key** | ✅        | ✅ (real users)  | 25,000 req/day   |
+| **Without**  | ✅        | ❌               | ~2 req/s shared  |
+
+Without the key, Core Web Vitals field data (real user experience via CrUX) is
+unavailable. Lab data from Lighthouse still runs.
+
+Set the key before invoking the command:
+
+```powershell
+# Windows PowerShell
+$env:PAGESPEED_API_KEY = "your-api-key"
+
+# macOS / Linux
+export PAGESPEED_API_KEY="your-api-key"
+```
+
+Get a free key (Google account required):
+<https://developers.google.com/speed/docs/insights/v5/get-started>
+
+## Workflow
+
+When `/cc-pagespeed` is invoked, load the `pagespeed-perf` skill and execute
+the following steps in order:
+
+1. **Pre-flight** — Read `$env:PAGESPEED_API_KEY` from the environment. Compute
+   the output filename: `{YYYY-MM-DD}_pagespeed-{hostname}-claude.md`.
+
+2. **Collect** — Call the PageSpeed Insights API for the requested strategy
+   (`mobile`, `desktop`, or `both`). Prefer the Bun scripts in
+   `~/.claude/skills/pagespeed-perf/scripts/run.ts` if Bun is available.
+   Otherwise, use `WebFetch` to call the PSI endpoint directly.
+
+3. **Analyze** — Extract Core Web Vitals (LCP, INP, CLS, FCP, TTFB, TBT),
+   identify the LCP element, enumerate third-party scripts by blocking time,
+   and inspect resource hints in the HTML `<head>`.
+
+4. **Prioritize** — Score each identified optimization using the 80/20 matrix:
+   `Impact × Ease` (each 1–5). Order findings by descending score. Highlight
+   the top actions with Score ≥ 20 as the critical 20%.
+
+5. **Report** — Write the structured markdown report to
+   `{YYYY-MM-DD}_pagespeed-{hostname}-claude.md` in the current directory.
+
+## Output File
+
+The report is saved as `{YYYY-MM-DD}_pagespeed-{hostname}-claude.md`.
+
+- Hostname characters outside `[a-zA-Z0-9]` are replaced with `-`.
+- Example: `https://www.example.com` → `2026-06-07_pagespeed-www-example-com-claude.md`
+
+## Skills Loaded
+
+- `pagespeed-perf` — Web Performance Engineering: PSI API, Core Web Vitals
+  thresholds, 80/20 optimization matrix, resource-hint analysis, third-party
+  script auditing, framework-specific implementation templates.
+
+## Examples
+
+```bash
+# Full audit — mobile + desktop
+/cc-pagespeed --url https://www.example.com
+
+# Mobile only
+/cc-pagespeed --url https://www.example.com --strategy mobile
+
+# Desktop only
+/cc-pagespeed --url https://www.example.com --strategy desktop
+```
+
+## Hard Rules
+
+- **GET only.** Never send POST, PUT, or DELETE to the target URL.
+- **No auth.** Never include cookies, tokens, or auth headers.
+- **No external crawling.** Audit only the provided URL.
+- **Quantify every finding.** Never write "it would improve LCP". Always cite
+  the observed value and estimated gain (e.g., "reduces LCP from 4.2 s to ~3.0 s").
+- **No generic recommendations.** Every finding must be backed by data from
+  the audit of this specific URL.
+"""

package/presets/gemini/commands/cc/prototype.toml

@@ -0,0 +1,37 @@
+description = "CodeConductor prototype workflow"
+
+prompt = """
+# Prototype Workflow
+
+Prototype request: {{args}}
+
+## Step 0 — CCEP Bootstrap
+
+Command: `prototype` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command prototype "{{args}}" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command prototype "{{args}}" --output json`
+3. Run: `npx cc-codeconductor ccep profile prototype --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command prototype --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+5. Delegate to subagents using compiled CCEP prompts — never forward raw `{{args}}` to planners.
+
+---
+
+## Step 1 — Bounds (architect)
+
+Invoke `architect`. Define what the spike may touch, time-box, and what must not leak into main. Do not treat this as a production Technical Plan.
+
+**STOP here. Wait for approval of the spike bounds.**
+
+---
+
+## Step 2 — Spike (implementer)
+
+Invoke `implementer` in a Git worktree that is not a merge candidate. Label the Implementation Summary as disposable. Do not open a PR against protected branches.
+
+---
+
+## Completion
+
+Report bounds, worktree path, and what was learned. Recommend `/cc:feature` or `/cc:fix` if the spike should become real work.
+"""