cc-codeconductor 1.5.0 → 1.5.1

package/presets/gemini/commands/cc/api-contract.toml

@@ -9,11 +9,10 @@ API contract request: {{args}}
 
 Command: `api-contract` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command api-contract "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command api-contract "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile api-contract --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command api-contract --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -14,11 +14,10 @@ deliver implementation — that is `/cc-openspec`.
 
 Command: `backlog` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command backlog "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command backlog "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile backlog --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command backlog --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.
+1. Run: `npx cc-codeconductor ccep profile backlog --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command backlog --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command backlog --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -9,11 +9,10 @@ Clarify request: {{args}}
 
 Command: `clarify` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command clarify "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command clarify "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile clarify --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command clarify --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -10,11 +10,10 @@ Task request: {{args}}
 Command: `council` (fixed for this workflow — do not infer from user text)
 command: council
 
-1. Run: `npx cc-codeconductor ccep parse --command council "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command council "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile council --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command council --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

package/presets/gemini/commands/cc/db-migration.toml

@@ -9,11 +9,10 @@ Migration request: {{args}}
 
 Command: `db-migration` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command db-migration "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command db-migration "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile db-migration --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command db-migration --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -9,11 +9,10 @@ Explore request: {{args}}
 
 Command: `explore` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command explore "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command explore "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile explore --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command explore --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -33,11 +33,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 Command: `feature` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command feature "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command feature "{{args}}" --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 `{{args}}` to planners.
+1. Run: `npx cc-codeconductor ccep profile feature --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command feature --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -41,11 +41,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 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.
+1. Run: `npx cc-codeconductor ccep profile fix --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command fix --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -9,11 +9,10 @@ Handoff request: {{args}}
 
 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.
+1. Run: `npx cc-codeconductor ccep profile handoff --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command handoff --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 
@@ -32,6 +31,10 @@ pass/fail (not log dumps), open questions, the next `/cc:` command, plus links
 to the Delivery Ledger and verification evidence when they exist. Do not repeat
 the original request or transcript.
 
+If a Delivery Ledger exists, run `npx cc-codeconductor odd handoff --id <ledger-id> --output json`
+and use its `handoff` envelope as the source for these fields. Secret redaction
+still applies.
+
 Do not edit source or tests.
 
 ---

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

@@ -11,11 +11,10 @@ Iterative request: {{args}}
 
 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.
+1. Run: `npx cc-codeconductor ccep profile iterative --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command iterative --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -6,11 +6,12 @@ prompt = """
 ## Step 0 — CCEP Bootstrap
 
 ```bash
-bun run dev ccep parse --command odd "{{args}}"
-bun run dev ccep resolve --command odd "{{args}}"
-bun run dev ccep profile --command odd
+bun run dev ccep profile odd --output json
+bun run dev ccep compile --command odd --phase <phase-id> "{{args}}" --view prompt --output json
 ```
 
+Pass each subagent only the compiled `prompt` for its phase.
+
 Create a ledger only after authorization and tracked coordination. Read-only and small work do not create state.
 
 When ODD has verification evidence, include its RDD receipt in the ledger

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

@@ -37,11 +37,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 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.
+1. Run: `npx cc-codeconductor ccep profile openspec --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command openspec --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---
@@ -152,7 +151,7 @@ For each pending TaskCard, run:
 npx cc-codeconductor openspec next
 ```
 
-Invoke the agent named on the card with **isolated** context (`/clear` between phases unless continuation is required):
+Invoke the agent named on the card as a subagent with **isolated** context (subagents already start fresh; do not `/clear` the main session between phases):
 
 | Phase | Agent | Role |
 |-------|-------|------|

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

@@ -11,11 +11,10 @@ Produces a prioritized report in the current working directory.
 
 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.
+1. Run: `npx cc-codeconductor ccep profile pagespeed --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command pagespeed --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -9,11 +9,10 @@ Prototype request: {{args}}
 
 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.
+1. Run: `npx cc-codeconductor ccep profile prototype --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command prototype --phase <phase-id> "{{args}}" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -34,11 +34,10 @@ If coverage is insufficient:
 
 Command: `refactor` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command refactor "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command refactor "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile refactor --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command refactor --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.
+1. Run: `npx cc-codeconductor ccep profile refactor --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command refactor --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command refactor --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -40,11 +40,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 Command: `review` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command review "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command review "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile review --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command review --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.
+1. Run: `npx cc-codeconductor ccep profile review --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command review --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command review --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -11,11 +11,10 @@ Scope: {{args}}
 
 Command: `scorecard` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command scorecard "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command scorecard "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile scorecard --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command scorecard --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.
+1. Run: `npx cc-codeconductor ccep profile scorecard --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command scorecard --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command scorecard --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -44,11 +44,10 @@ payloads, malware, or attack procedures.
 
 Command: `security` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command security "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command security "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile security --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command security --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.
+1. Run: `npx cc-codeconductor ccep profile security --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command security --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command security --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/gemini/commands/cc/spec-mutation.toml

@@ -18,11 +18,10 @@ Describe what behavior you want to implement. Include:
 
 Command: `spec-mutation` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command spec-mutation "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command spec-mutation "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile spec-mutation --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command spec-mutation --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.
+1. Run: `npx cc-codeconductor ccep profile spec-mutation --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command spec-mutation --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command spec-mutation --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/gemini/commands/cc/tdd-cycle.toml

@@ -18,11 +18,10 @@ Describe what behavior you want to implement. Include:
 
 Command: `tdd-cycle` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command tdd-cycle "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command tdd-cycle "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile tdd-cycle --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command tdd-cycle --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.
+1. Run: `npx cc-codeconductor ccep profile tdd-cycle --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command tdd-cycle --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command tdd-cycle --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/gemini/commands/cc/test-plan.toml

@@ -21,11 +21,10 @@ proceeding.
 
 Command: `test-plan` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command test-plan "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command test-plan "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile test-plan --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command test-plan --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.
+1. Run: `npx cc-codeconductor ccep profile test-plan --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command test-plan --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command test-plan --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -9,11 +9,10 @@ Triage request: {{args}}
 
 Command: `triage` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command triage "{{args}}" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command triage "{{args}}" --output json`
-3. Run: `npx cc-codeconductor ccep profile triage --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command triage --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.
+1. Run: `npx cc-codeconductor ccep profile triage --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command triage --phase <phase-id> "{{args}}" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command triage --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `{{args}}` to planners.
 
 ---
 

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

@@ -12,11 +12,10 @@ API contract request: $ARGUMENTS
 
 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.
+1. Run: `npx cc-codeconductor ccep profile api-contract --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command api-contract --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
 
 ---
 

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

@@ -17,11 +17,10 @@ deliver implementation — that is `/cc-openspec`.
 
 Command: `backlog` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command backlog "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command backlog "$ARGUMENTS" --output json`
-3. Run: `npx cc-codeconductor ccep profile backlog --output json`
-4. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command backlog --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.
+1. Run: `npx cc-codeconductor ccep profile backlog --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command backlog --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. After planner/intake JSON is available, run: `npx cc-codeconductor ccep evaluate --command backlog --input <planner.json> --output json`. If `stop` is true, show questions or risks and wait for human input.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
 
 ---
 

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

@@ -10,11 +10,10 @@ Clarify request: $ARGUMENTS
 
 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.
+1. Run: `npx cc-codeconductor ccep profile clarify --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command clarify --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
 
 ---
 

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

@@ -11,11 +11,10 @@ Task request: $ARGUMENTS
 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.
+1. Run: `npx cc-codeconductor ccep profile council --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command council --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
 
 ---
 

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

@@ -12,11 +12,10 @@ Migration request: $ARGUMENTS
 
 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.
+1. Run: `npx cc-codeconductor ccep profile db-migration --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command db-migration --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -10,11 +10,10 @@ Explore request: $ARGUMENTS
 
 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.
+1. Run: `npx cc-codeconductor ccep profile explore --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command explore --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
 
 ---
 

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

@@ -34,11 +34,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 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.
+1. Run: `npx cc-codeconductor ccep profile feature --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command feature --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

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

@@ -44,11 +44,10 @@ unavailable visual or emulator checks remain pending rather than claimed complet
 
 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.
+1. Run: `npx cc-codeconductor ccep profile fix --output json` to get the phases and their roles.
+2. For each delegated phase, run: `npx cc-codeconductor ccep compile --command fix --phase <phase-id> "$ARGUMENTS" --view prompt --output json`
+3. 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.
+4. Pass each subagent only the compiled `prompt` for its phase — never forward raw `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---