cc-codeconductor 0.5.0 → 1.0.0

package/presets/opencode/agents/task-coach.md

@@ -4,6 +4,7 @@ description:
   Transforms vague requests into complete, routable Task Cards by asking
   targeted clarifying questions and enforces the Task Card standard before any
   work begins.
+effort: low
 mode: subagent
 model: "{{MODEL}}"
 temperature: 0.1
@@ -16,7 +17,7 @@ permission:
   grep: allow
   skill: deny
 ---
-# Agent Contract — task-coach v0.5.0
+# Agent Contract — task-coach v1.0.0
 
 ## Role
 
@@ -87,6 +88,34 @@ Default is `isolated`."
 
 ---
 
+## Grilling protocol
+
+Before marking a Task Card `status: "success"`, stress-test every assumption
+behind it with one adversarial question. This differs from the Clarification
+protocol above: clarification fills fields that are missing; grilling attacks
+fields that are already filled but rest on an unstated assumption.
+
+1. List each assumption implied by the request (e.g., "the bug is in the
+   frontend", "backward compatibility is required", "no auth changes needed").
+2. For each assumption, ask exactly one adversarial question that would break
+   it if the assumption is wrong. Grill one assumption at a time — never
+   bundle questions.
+3. Stop and wait for the answer before grilling the next assumption.
+4. An assumption survives grilling once the human confirms or corrects it. Do
+   not stress-test the same assumption twice.
+5. A Task Card is not ready until every assumption behind it has survived
+   exactly one grilling round.
+
+### Example grilling questions
+
+Assumption "no auth changes needed": "Does this endpoint currently require
+authentication, and will that requirement stay the same after this change?"
+
+Assumption "the fix is backward compatible": "Could any existing caller depend
+on the current, buggy behavior you are about to change?"
+
+---
+
 ## Risk estimation
 
 Use these signals to assign a preliminary risk level. When signals conflict,
@@ -145,6 +174,45 @@ signals were observed]
 
 ---
 
+## CCEP-1 structured output
+
+When invoked via the CodeConductor Execution Protocol (`ccep compile` /
+`ccep validate`), return **valid JSON only** for the intake phase — the Markdown
+Task Card above is the human-facing form; under CCEP-1 the same intent is
+serialized to the phase schema.
+
+- `feature` / `refactor` / `test-plan` intake → `planner-output`
+- `fix` intake → `fix-intake-output`
+
+`planner-output` skeleton:
+
+```json
+{
+  "status": "success",
+  "confidence": 0.0,
+  "goal": "",
+  "assumptions": [],
+  "risks": [],
+  "tasks": [],
+  "questionsForUser": [],
+  "needsConfirmation": true
+}
+```
+
+Rules under CCEP-1:
+
+- Use only information present in the compiled context. Never invent repository
+  facts.
+- If a required field is missing, set `status` to `needs_clarification` and
+  populate `questionsForUser` instead of guessing.
+- Set `needsConfirmation` to `true` for medium/high risk so the confirmation
+  gate stops before implementation.
+- Unresolved grilling questions (Grilling protocol) populate
+  `questionsForUser` the same way as missing fields, and set
+  `needsConfirmation` to `true` until every assumption has survived its round.
+
+---
+
 ## Hard rules
 
 - Never write implementation code.

package/presets/opencode/agents/tester.md

@@ -4,6 +4,7 @@ description:
   Generates unit, integration, and contract tests that verify the acceptance
   criteria — writes tests that fail first, then confirms they pass after
   implementation.
+effort: medium
 mode: subagent
 model: "{{MODEL}}"
 temperature: 0.1
@@ -34,7 +35,7 @@ permission:
   grep: allow
   skill: ask
 ---
-# Agent Contract — tester v0.5.0
+# Agent Contract — tester v1.0.0
 
 ## Role
 
@@ -260,6 +261,22 @@ pytest | go test ./... | ...]
 
 ---
 
+## CCEP-1 structured output
+
+When invoked via the CodeConductor Execution Protocol (`test` or `test-plan`
+phase), return **valid JSON only** matching `agent-output` and serialize the
+Test Report / matrix into `artifacts`:
+
+```json
+{ "status": "success", "artifacts": [{ "type": "test-report", "path": "" }], "next_actions": [] }
+```
+
+For a `tdd-cycle` red-state phase, `status` must reflect that tests were written
+and confirmed failing; list the failing test paths in `artifacts` so the
+`implementer` can pick them up.
+
+---
+
 ## Hard rules
 
 - Never edit production source files.

package/presets/opencode/commands/cc-api-contract.md

@@ -8,6 +8,18 @@ description:
 
 API contract request: $ARGUMENTS
 
+## Step 0 — CCEP Bootstrap
+
+Command: `api-contract` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command api-contract "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command api-contract "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile api-contract --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command api-contract --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 `$ARGUMENTS` to planners.
+
+---
+
 ## Step 1 — Task Card validation (task-coach)
 
 Invoke `task-coach` with the request above.

package/presets/opencode/commands/cc-ask.md

@@ -0,0 +1,55 @@
+---
+description: >-
+  [cc: alias] Recommend one CodeConductor slash command from a natural-language
+  problem. Does not start that workflow.
+---
+
+# Ask — recommend a slash command
+
+Problem: $ARGUMENTS
+
+This is a **router**, not a delivery workflow. Recommend exactly one command.
+Do **not** run the recommended `/cc:` command unless the human confirms.
+
+---
+
+## Step 1 — Recommend (deterministic)
+
+Run (local repo: `bun run dev`; published package: `npx cc-codeconductor`):
+
+```bash
+bun run dev ask "$ARGUMENTS" --output json
+```
+
+or:
+
+```bash
+npx cc-codeconductor ask "$ARGUMENTS" --output json
+```
+
+The catalog is only:
+
+| Slash | When |
+| ----- | ---- |
+| `/cc:feature` | new behavior |
+| `/cc:fix` | bug / regression |
+| `/cc:refactor` | structure, no behavior change |
+| `/cc:review` | inspect a diff/PR |
+| `/cc:tdd-cycle` | red → green → refactor |
+| `/cc:openspec` | BACKLOG / BC-xxx delivery |
+
+If the CLI is unavailable, apply the same catalog and the same priority:
+openspec → tdd-cycle → review → refactor → fix → feature (default).
+
+---
+
+## Step 2 — Show and stop
+
+Print:
+
+- **Recommended:** the slash command
+- **Why:** one or two sentences from the CLI `reason` (or your matching)
+
+**STOP.** Wait for the human. Do not invoke the recommended workflow.
+
+For a full preset inventory (skills, commands on disk), use `/cc:help` / `cc-help`.

package/presets/opencode/commands/cc-clarify.md

@@ -0,0 +1,31 @@
+---
+description: Re-explain the last deliverable in Task Card vocabulary when it did not land.
+---
+
+# Clarify Workflow
+
+Clarify request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `clarify` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command clarify "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command clarify "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile clarify --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command clarify --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 `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Re-explain (task-coach)
+
+Invoke `task-coach` / `orchestrator`. Restate the last Task Card, plan, or review in the project's vocabulary. Do not add new scope. If questions remain, one question per branch.
+
+**STOP if ConfirmationGate reports questions.**
+
+---
+
+## Completion
+
+A plain-language restatement plus any remaining questions. Then resume the previous workflow.

package/presets/opencode/commands/cc-council.md

@@ -0,0 +1,87 @@
+---
+description: Council-driven workflow with CCEP-1 bootstrap
+---
+
+# Council-Driven Workflow
+
+Task request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `council` (fixed for this workflow — do not infer from user text)
+command: council
+
+1. Run: `npx cc-codeconductor ccep parse --command council "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command council "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile council --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command council --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 `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (and
+`graphify path` / `graphify explain` when needed). Then invoke `repo-explorer`
+to map impact radius before deliberation. Do not write code in this step.
+
+---
+
+## Step 2 — Deliberation & Specification (SDD)
+
+Invoke the `council` skill to analyze the request before writing any code. The council must act as a steering committee involving `task-coach` (Product), `architect`, and `devil`.
+
+The council must:
+1. Clarify the prompt and define the absolute minimum scope (Simplicity Gate).
+2. Explicitly document all assumptions and run the Grilling protocol on each one (Think Before Coding).
+3. Draft a Task Card & Technical Plan (The Specification).
+
+**STOP here.** Unresolved grilling questions populate `questionsForUser` in the
+CCEP-1 `planner-output`; `ccep evaluate` (ConfirmationGate) halts until a human
+answers. Show the agreed Task Card & Technical Plan and wait for confirmation
+before continuing.
+
+---
+
+## Step 3 — Test Definition (TDD)
+
+Invoke `tester` with the approved Task Card & Technical Plan.
+
+tester must:
+1. Write failing tests based on the Acceptance Criteria defined in the Task Card.
+2. Confirm the tests fail as expected (Red state).
+
+**Goal-Driven Execution (Karpathy)**: Do not proceed until verifiable tests are written and fail for the correct reasons.
+
+---
+
+## Step 4 — Surgical Implementation
+
+Invoke `implementer` with the failing tests and the Technical Plan.
+
+implementer must:
+1. Write the minimal code required to pass the tests.
+2. Touch ONLY the files specified in the Technical Plan (Surgical Changes).
+3. NOT refactor adjacent code, change existing styles, or build speculative features.
+4. Run the tests. Loop `implementer` -> `tester` until all tests pass (Green state).
+
+---
+
+## Step 5 — Multi-Perspective Council Review
+
+Invoke the `council` skill on the generated diff to perform the final review phase.
+
+The council will evaluate the diff against the 6 axes (Architecture, Security, Product, Delivery, DataOps, Devil).
+
+If ANY agent votes CRITICAL (especially due to over-engineering, scope creep, or missing the verifiable goals):
+- The Review Report status is **BLOCKED**.
+- Return to Step 4 with the feedback.
+
+If APPROVED (no CRITICAL findings):
+- Deliver the final Council Verdict and the diff summary.
+
+---
+
+## Completion
+
+Deliver the complete Council Verdict. The feature is only complete when tests pass and the council explicitly approves the implementation according to the specification.

package/presets/opencode/commands/cc-db-migration.md

@@ -8,6 +8,19 @@ description:
 
 Migration request: $ARGUMENTS
 
+## Step 0 — CCEP Bootstrap
+
+Command: `db-migration` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command db-migration "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command db-migration "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile db-migration --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command db-migration --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 `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
 ## Step 1 — Task Card validation (task-coach)
 
 Invoke `task-coach` with the request above.
@@ -35,22 +48,22 @@ compatibility strategy, rollback/forward-fix notes, and test approach.
 
 ---
 
-## Step 3 — Implementation (implementer)
+## Step 3 — Migration tests (tester)
 
-Invoke `implementer` with the approved plan.
+Invoke `tester`.
 
-implementer must keep model and migration changes together, avoid unrelated
-refactors, and preserve the deployment order specified by architect.
+tester must cover migration-sensitive behavior where the stack supports it,
+including happy path, existing-data edge cases, and rollback/forward-fix notes
+when automated rollback tests are not practical.
 
 ---
 
-## Step 4 — Migration tests (tester)
+## Step 4 — Implementation (implementer)
 
-Invoke `tester`.
+Invoke `implementer` with the approved plan.
 
-tester must cover migration-sensitive behavior where the stack supports it,
-including happy path, existing-data edge cases, and rollback/forward-fix notes
-when automated rollback tests are not practical.
+implementer must keep model and migration changes together, avoid unrelated
+refactors, and preserve the deployment order specified by architect.
 
 ---
 

package/presets/opencode/commands/cc-explore.md

@@ -0,0 +1,35 @@
+---
+description: Map the repository and recommend the next CodeConductor slash command. Read-only.
+---
+
+# Explore Workflow
+
+Explore request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+Command: `explore` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command explore "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command explore "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile explore --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command explore --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 `$ARGUMENTS` to planners.
+
+---
+
+## Step 1 — Map (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"`. Invoke `repo-explorer`. Produce a Repo Map. Do not write code.
+
+---
+
+## Step 2 — Suggest next command (orchestrator)
+
+Recommend exactly one next slash command (`/cc:feature`, `/cc:fix`, `/cc:refactor`, `/cc:review`, `/cc:triage`, …) with a one-sentence rationale. Do not start that workflow.
+
+---
+
+## Completion
+
+Report the Repo Map and the recommended next `/cc:` command.

package/presets/opencode/commands/cc-feature.md

@@ -8,7 +8,29 @@ description:
 
 Feature request: $ARGUMENTS
 
-## Step 1 — Task Card validation (task-coach)
+## Step 0 — CCEP Bootstrap
+
+Command: `feature` (fixed for this workflow — do not infer from user text)
+
+1. Run: `npx cc-codeconductor ccep parse --command feature "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command feature "$ARGUMENTS" --output json`
+3. Run: `npx cc-codeconductor ccep profile feature --output json`
+4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command feature --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 `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (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)
 
 Invoke `task-coach` with the feature description above.
 
@@ -25,7 +47,7 @@ continuing.**
 
 ---
 
-## Step 2 — Technical Plan (architect)
+## Step 3 — Technical Plan (architect)
 
 Invoke `architect` with the validated Task Card from Step 1.
 
@@ -43,7 +65,20 @@ not invoke implementer until the plan is approved.**
 
 ---
 
-## Step 3 — Implementation (implementer)
+## Step 4 — Test coverage (tester)
+
+Invoke `tester` with the Implementation Summary and the Task Card.
+
+tester must:
+
+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. Run the full test suite and confirm it passes
+4. Produce a Coverage Summary: test files added or modified, cases covered
+
+---
+
+## Step 5 — Implementation (implementer)
 
 Invoke `implementer` with the approved Technical Plan and the Task Card.
 Implementer creates a Git Worktree before touching any file; all edits happen inside it.
@@ -52,26 +87,13 @@ implementer must:
 
 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 after implementation
+3. Run the project test suite and make the previously written failing tests pass
 4. Produce an Implementation Summary: what changed, which files, how to verify
    locally
 
 ---
 
-## Step 4 — Test coverage (tester)
-
-Invoke `tester` with the Implementation Summary and the Task Card.
-
-tester must:
-
-1. Write or extend tests to cover the new behavior
-2. Ensure all acceptance criteria from the Task Card have at least one test
-3. Run the full test suite and confirm it passes
-4. Produce a Coverage Summary: test files added or modified, cases covered
-
----
-
-## Step 5 — Code review (reviewer)
+## Step 6 — Code review (reviewer)
 
 Invoke `reviewer` with the complete diff and the Task Card.
 
@@ -86,7 +108,7 @@ they are resolved and re-reviewed.
 
 ---
 
-## Step 6 — Documentation (docs)
+## Step 7 — Documentation (docs)
 
 Invoke `docs` only if any of the following changed:
 

package/presets/opencode/commands/cc-fix.md

@@ -1,7 +1,7 @@
 ---
 description:
   Run the bug fix workflow — risk-based routing through task validation,
-  implementation, testing, and optional review.
+  testing, implementation, and optional review.
 ---
 
 # Bug Fix Workflow
@@ -18,7 +18,29 @@ Provide the following information in $ARGUMENTS:
 
 ---
 
-## Step 1 — Task Card validation (task-coach)
+## 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 "$ARGUMENTS" --output json`
+2. Run: `npx cc-codeconductor ccep resolve --command fix "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
+## Step 1 — Wayfinding (repo-explorer)
+
+If `graphify-out/graph.json` exists, run `graphify query "$ARGUMENTS"` (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)
 
 Invoke `task-coach` with the bug description above.
 
@@ -33,11 +55,16 @@ If reproduction steps are missing, task-coach must 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 2 — Route by risk
+## Step 3 — Route by risk
 
 Read the risk field from the Task Card and follow the corresponding route.
 
@@ -46,16 +73,16 @@ Read the risk field from the Task Card and follow the corresponding 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` → `implementer` → `tester`
+Route: `task-coach` → `tester` → `implementer`
 
-Proceed directly to Step 3a.
+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` → `implementer` → `tester` → `reviewer`
+Route: `task-coach` → `architect` → `tester` → `implementer` → `reviewer`
 
 Invoke `architect` before implementation. architect must:
 
@@ -69,7 +96,20 @@ before continuing.**
 
 ---
 
-## Step 3a — Implementation, low-risk (implementer)
+## Step 4 — Regression tests (tester)
+
+Invoke `tester` for all risk levels.
+
+tester must:
+
+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 Coverage Summary: test added, case covered
+
+---
+
+## Step 5a — Implementation, low-risk (implementer)
 
 Invoke `implementer` with the Task Card.
 Implementer creates a Git Worktree before touching any file; all edits happen inside it.
@@ -78,12 +118,12 @@ implementer must:
 
 1. Locate the defect using the reproduction steps
 2. Apply the minimal fix — no unrelated changes
-3. Run the test suite
+3. Run the suite and make the RED regression test pass
 4. Produce an Implementation Summary: root cause, fix applied, files changed
 
 ---
 
-## Step 3b — Implementation, medium/high-risk (implementer)
+## Step 5b — Implementation, medium/high-risk (implementer)
 
 Invoke `implementer` with the approved Technical Plan and the Task Card.
 Implementer creates a Git Worktree before touching any file; all edits happen inside it.
@@ -93,20 +133,7 @@ Plan approval. After implementation, run the full test suite.
 
 ---
 
-## Step 4 — Regression tests (tester)
-
-Invoke `tester` for all risk levels.
-
-tester must:
-
-1. Write a regression test that reproduces the original bug (fails before the
-   fix, passes after)
-2. Verify that existing tests still pass
-3. Produce a Coverage Summary: test added, case covered
-
----
-
-## Step 5 — Review (reviewer) — medium/high-risk only
+## Step 6 — Review (reviewer) — medium/high-risk only
 
 Invoke `reviewer` with the diff and Task Card.