cc-codeconductor 1.5.0 → 1.6.0

package/presets/agy/skills/openspec/SKILL.md

@@ -16,7 +16,7 @@ gates, not a reference doc. Specs describe WHAT; `design.md` describes HOW.
 
 ## When to Use
 
-- `/cc-openspec` or `openspec next` / `plan` / `done` / `archive`
+- `/cc-openspec` or `openspec plan` / `next` / `done` / `sync` / `verify` / `archive`
 - An item is `READY` or later and must move through the state machine
 
 **NOT** for creating `BACKLOG.md` (use skill `backlog`) or for stack-specific
@@ -26,22 +26,43 @@ coding rules.
 
 Local CLI is `bun run dev`. Published package is `npx cc-codeconductor`.
 
-1. `openspec validate` — must pass before delivery.
-2. `openspec plan BC-xxx` if the item is not yet `PLANNED`.
-3. `openspec analyze --output json` — CRITICAL findings exit 1. Do not implement.
-4. Phases: discover (`repo-explorer`) → design (`architect`) → test (`tester`) →
+1. `openspec validate` — must pass before delivery. If you reached this
+   workflow on your own (the user did not ask for OpenSpec) and there is no
+   `BACKLOG.md` / `openspec/` root, answer normally instead — never scaffold
+   one as a side effect.
+2. `openspec plan BC-xxx` if the item is not yet `PLANNED`. Planning only: it
+   writes TaskCards plus proposal/design/tasks/specs under
+   `openspec/changes/<slug>/` and stops. Never implement in this step.
+3. Review the plan before `start`: read proposal → delta specs → tasks, in that
+   order, and confirm intent, scope, testable FR/SC, and edge-case scenarios.
+   Fix the Markdown directly or ask for revisions — code comes later.
+4. `openspec analyze --output json` — CRITICAL findings exit 1. Do not implement.
+5. Phases: discover (`repo-explorer`) → design (`architect`) → test (`tester`) →
    implement (`implementer`) → review (`reviewer`). If Global `TDD required: yes`,
-   test runs before implement.
-5. `openspec done` on test/implement requires `captureTddSuiteEvidence`. Handmade
-   evidence JSON is rejected.
-6. `scorecard create --task BC-xxx --from-diff` then record a verdict.
-7. `openspec archive` only after human review when `Review required: yes` and
-   the scorecard is PASS.
+   test runs before implement. Discover is read-only: it never writes code.
+6. `openspec done` on test/implement requires `captureTddSuiteEvidence`. Handmade
+   evidence JSON is rejected. The implementer ticks `tasks.md` boxes
+   (`- [ ]` → `- [x]`) as each FR lands; only `x`/`X` counts as done.
+7. When implementation reveals a design problem, pause and reconcile the planning
+   artifacts first — in any direction (a later artifact may force revising an
+   earlier one). Planning artifacts only in that step, never code; confirm each
+   edit. If the item's intent changed rather than its details, open a fresh item
+   with `/cc-backlog` (`/cc:backlog`) instead of warping this one.
+8. `openspec verify --output json` — advisory pre-archive checklist
+   (`archiveReady` plus Completeness/Correctness/Coherence issues). Optional:
+   `openspec sync` merges delta specs into `openspec/specs/` without closing.
+9. `scorecard create --task BC-xxx --from-diff` then record a verdict.
+10. `openspec archive` only after human review when `Review required: yes` and
+    the scorecard is PASS. Archive re-checks planning artifacts and analyze
+    CRITICALs, and warns on unchecked `tasks.md` boxes.
 
 Status machine: `TODO` → `READY` → `PLANNED` → `IN_PROGRESS` → `REVIEW` → `DONE`
 → Archive. `BLOCKED` returns to `READY`. Reviewer rejection: `REVIEW` →
 `IN_PROGRESS`.
 
+`openspec status --output json` also reports artifact presence, `tasks.md`
+checkbox progress, and `nextSteps` for the next CLI call.
+
 ## Web interface scope
 
 When the task concerns web layout, component states, feedback, motion, or a
@@ -70,17 +91,24 @@ delivery read-only and record unavailable visual or emulator evidence as pending
 | I'll add tests after green | Global TDD required means tester before implementer. |
 | I'll write the evidence JSON myself | Handmade TDD JSON is rejected. Use the verification runner. |
 | The item is small; skip analyze | `openspec analyze` CRITICAL still stops implement. |
+| The plan is generated; skip reading it | Read proposal → specs → tasks before `start`. Generated is not reviewed. |
+| I'll fix the spec after shipping | Reconcile planning artifacts before continuing to implement. |
 
 ## Red Flags
 
 - Implementing while analyze reports CRITICAL
+- Starting cards before reading the generated plan
 - Archive without a PASS scorecard when review is required
+- Archive while `openspec verify` reports CRITICAL
 - Acceptance like "improve UX" with no measurable check
 
 ## Verification
 
 - [ ] `openspec validate` exit 0
+- [ ] Plan reviewed (proposal → specs → tasks) before `start`
 - [ ] `openspec analyze --output json` has no CRITICAL
 - [ ] TDD evidence from the runner when TDD is required
+- [ ] `tasks.md` boxes ticked as FRs land
+- [ ] `openspec verify --output json` checked before archive
 - [ ] `scorecard create --from-diff` recorded
 - [ ] Suite check (optional): `bun run dev scorecard suite-run --suite workflow-gates`

package/presets/agy/workflows/cc-api-contract.md

@@ -13,11 +13,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/agy/workflows/cc-backlog.md

@@ -18,11 +18,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/agy/workflows/cc-clarify.md

@@ -12,11 +12,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/agy/workflows/cc-council.md

@@ -12,11 +12,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.
 
 ---
 
@@ -64,7 +63,7 @@ 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).
+4. Run the tests. Loop `implementer` -> `tester` until all tests pass (Green state), at most 3 iterations -- then stop and report the failing tests instead of looping.
 
 ---
 
@@ -76,7 +75,7 @@ The council will evaluate the diff against the 6 axes (Architecture, Security, P
 
 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.
+- Return to Step 4 with the feedback (at most 3 review rounds in total -- then deliver the BLOCKED verdict with the unresolved findings instead of looping).
 
 If APPROVED (no CRITICAL findings):
 - Deliver the final Council Verdict and the diff summary.

package/presets/agy/workflows/cc-db-migration.md

@@ -13,11 +13,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/agy/workflows/cc-explore.md

@@ -12,11 +12,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/agy/workflows/cc-feature.md

@@ -35,11 +35,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/agy/workflows/cc-fix.md

@@ -45,11 +45,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.
 
 ---

package/presets/agy/workflows/cc-handoff.md

@@ -12,11 +12,10 @@ Handoff request: $ARGUMENTS
 
 Command: `handoff` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command handoff "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command handoff "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 
@@ -36,6 +35,10 @@ pass/fail (not log dumps), open questions, and the next `/cc-` command.
 Link the Delivery Ledger and verification evidence when they exist; do not
 repeat the original request or transcript. Do not edit source or tests.
 
+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.
+
 ---
 
 ## Completion

package/presets/agy/workflows/cc-iterative.md

@@ -13,11 +13,10 @@ Iterative request: $ARGUMENTS
 
 Command: `iterative` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command iterative "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command iterative "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/agy/workflows/cc-odd.md

@@ -7,9 +7,10 @@ description: Create or resume an opt-in Delivery Ledger for substantial authoriz
 ## Step 0 — CCEP Bootstrap
 
 ```bash
-bun run dev ccep parse --command odd "$ARGUMENTS"
-bun run dev ccep resolve --command odd "$ARGUMENTS"
-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> "$ARGUMENTS" --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.

package/presets/agy/workflows/cc-openspec.md

@@ -33,7 +33,7 @@ stays with the general `android` skill. Audit-only requests remain read-only, an
 unavailable visual or emulator checks remain pending rather than claimed complete.
 
 
-## Step 0 — Validate (mandatory gate)
+## Step 0a — Validate (mandatory gate)
 
 Run `npx cc-codeconductor openspec validate`. If invalid, show errors and recommendations, then **STOP**.
 
@@ -43,11 +43,10 @@ Run `npx cc-codeconductor openspec validate`. If invalid, show errors and recomm
 
 Command: `openspec` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command openspec "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command openspec "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/agy/workflows/cc-pagespeed.md

@@ -15,11 +15,10 @@ Audit URL: $ARGUMENTS
 
 Command: `pagespeed` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command pagespeed "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command pagespeed "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-prototype.md

@@ -12,11 +12,10 @@ Prototype request: $ARGUMENTS
 
 Command: `prototype` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command prototype "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command prototype "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-refactor.md

@@ -38,11 +38,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 "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command refactor "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-review.md

@@ -44,11 +44,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 "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command review "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-scorecard.md

@@ -12,11 +12,10 @@ Scope: $ARGUMENTS
 
 Command: `scorecard` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command scorecard "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command scorecard "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-security.md

@@ -48,11 +48,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 "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command security "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/agy/workflows/cc-spec-mutation.md

@@ -23,11 +23,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 "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command spec-mutation "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/agy/workflows/cc-tdd-cycle.md

@@ -22,11 +22,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 "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command tdd-cycle "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
    Canonical delivery order is test-before-implement whenever both phases apply.
 
 ---

package/presets/agy/workflows/cc-test-plan.md

@@ -25,11 +25,10 @@ If $ARGUMENTS is empty, describe the scope in your next message before invoking
 
 Command: `test-plan` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command test-plan "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command test-plan "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/agy/workflows/cc-triage.md

@@ -12,11 +12,10 @@ Triage request: $ARGUMENTS
 
 Command: `triage` (fixed for this workflow — do not infer from user text)
 
-1. Run: `npx cc-codeconductor ccep parse --command triage "$ARGUMENTS" --output json`
-2. Run: `npx cc-codeconductor ccep resolve --command triage "$ARGUMENTS" --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 `$ARGUMENTS` 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> "$ARGUMENTS" --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 `$ARGUMENTS` to planners.
 
 ---
 

package/presets/claude/CLAUDE.md

@@ -511,11 +511,11 @@ _(none)_ if no suggestions
 
 **Two-Axis Review Model (Standards + Spec)**
 
-The Reviewer role executes two independent, parallel sub-agents without reranking between them:
+_El modelo de dos ejes (Standards, Spec) es la estructura de ejecución de `/cc:review`; los review axes listados en la tabla anterior se aplican DENTRO de cada eje._
 
-1.
+The Reviewer role executes two independent, parallel sub-agents without reranking between them:
 
-_El modelo de dos ejes (Standards, Spec) es la estructura de ejecución de `/cc:review`; los review axes listados en la tabla anterior se aplican DENTRO de cada eje._ **Standards Axis** — Code smell detection against the Fowler baseline (Long Method, Large Class, Duplicated Code, Feature Envy, Shotgun Surgery, Primitive Obsession, Data Clumps, Switch Statements, Speculative Generality, Temporary Fields, Message Chains, Middle Man, Inappropriate Intimacy, Data Class, Comments-as-apology), with documented override allowed via repo standards documentation (e.g., CONTEXT.md or project norms).
+1. **Standards Axis** — Code smell detection against the Fowler baseline (Long Method, Large Class, Duplicated Code, Feature Envy, Shotgun Surgery, Primitive Obsession, Data Clumps, Switch Statements, Speculative Generality, Temporary Fields, Message Chains, Middle Man, Inappropriate Intimacy, Data Class, Comments-as-apology), with documented override allowed via repo standards documentation (e.g., CONTEXT.md or project norms).
 
 2. **Spec Axis** — Alignment with Task Card, acceptance criteria, and scope boundaries.
 
@@ -761,8 +761,9 @@ extending capabilities, apply `.claude/skills/find-skills/SKILL.md`.
 ## Teammate & Loop Agent Rules
 
 ### Teammate delegation (Presets supporting multi-teams)
-- Utilize parallel sub-agent execution by enabling `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` in `settings.json`.
-- Allocate tasks to specific teammates: use `sonnet` for Orchestrator and Architect, and delegate secondary tasks (e.g. testing, review, docs) to `haiku` to optimize token budgets.
+- Use Sonnet 5.5 as the default model for every role, including testing, review, and docs.
+- Use Haiku only for lightweight discovery and routing roles (task coach, repo explorer, goal planner, planner).
+- Escalate a single blocked decision to a subagent with `model: opus`; return to Sonnet afterward.
 
 ### Loop Agent Mode (Intense Workflows)
 - If tests or verifications fail, do not stop. Re-route the failure logs back to the Implementer teammate.

package/presets/claude/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/claude/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.
 
 ---