cc-codeconductor 1.5.0 → 1.6.0

package/presets/claude/settings.json

@@ -2,9 +2,6 @@
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
   "env": {
     "CLAUDE_CODE_ATTRIBUTION_HEADER": "0",
-    "CLAUDE_CODE_DISABLE_1M_CONTEXT": "0",
-    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
-    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
     "CLAUDE_CODE_DISABLE_TERMINAL_TITLE": "1",
     "DISABLE_EXTRA_USAGE_COMMAND": "1",
     "DISABLE_TELEMETRY": "1",
@@ -12,12 +9,7 @@
     "DISABLE_FEEDBACK_COMMAND": "1",
     "CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT": "1",
     "ENABLE_TOOL_SEARCH": "auto",
-    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80",
-    "CLAUDE_CODE_SUBPROCESS_ENV_SCRUB": "0",
-    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
-    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
-    "MAX_THINKING_TOKENS": "24000",
-    "DISABLE_BUG_COMMAND": "1"
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "0"
   },
   "attribution": {
     "commit": "",
@@ -27,29 +19,11 @@
   "includeGitInstructions": false,
   "permissions": {
     "allow": [
-      "Bash(git status*)",
-      "Bash(git diff*)",
-      "Bash(git log*)",
       "Bash(./gradlew test*)",
       "Bash(./gradlew build*)",
       "Bash(./gradlew check*)",
       "Bash(npm test*)",
       "Bash(npm run lint*)",
-      "Bash(ls *)",
-      "Bash(cat *)",
-      "Bash(grep *)",
-      "Bash(rg *)",
-      "Bash(find *)",
-      "Bash(tree *)",
-      "Bash(echo *)",
-      "Bash(pwd)",
-      "Bash(which *)",
-      "Bash(head *)",
-      "Bash(tail *)",
-      "Bash(wc *)",
-      "Bash(diff *)",
-      "Bash(git branch*)",
-      "Bash(git show*)",
       "Bash(git add*)",
       "Bash(git commit*)",
       "Bash(git stash*)",
@@ -113,30 +87,38 @@
       "Bash(rm -fr *)",
       "Bash(chmod -R *)",
       "Bash(eval *)",
-      "Bash(git push --force origin main*)",
-      "Bash(git push --force origin master*)",
-      "Bash(git push -f origin main*)",
-      "Bash(git push -f origin master*)",
-      "Read(./.env)",
-      "Read(./.env.*)",
-      "Read(./**/.env)",
-      "Read(./**/.env.*)",
-      "Read(./secrets/**)",
-      "Read(./**/credentials.json)",
-      "Read(./**/serviceAccount*.json)",
-      "Read(./**/*.pem)",
-      "Read(./**/*.key)",
-      "Read(./**/id_rsa*)",
+      "PowerShell(Remove-Item *)",
+      "PowerShell(git push --force*)",
+      "PowerShell(git push -f*)",
+      "PowerShell(git reset --hard*)",
+      "PowerShell(git rebase *)",
+      "PowerShell(Invoke-Expression *)",
+      "Read(.env)",
+      "Read(.env.*)",
+      "Read(!.env.example)",
+      "Edit(.env)",
+      "Edit(.env.*)",
+      "Edit(!.env.example)",
+      "Read(secrets/**)",
+      "Edit(secrets/**)",
+      "Read(**/credentials.json)",
+      "Edit(**/credentials.json)",
+      "Read(**/serviceAccount*.json)",
+      "Edit(**/serviceAccount*.json)",
+      "Read(**/*.pem)",
+      "Edit(**/*.pem)",
+      "Read(**/*.key)",
+      "Edit(**/*.key)",
+      "Read(**/id_rsa*)",
+      "Edit(**/id_rsa*)",
       "Read(~/.ssh/**)",
+      "Edit(~/.ssh/**)",
       "Read(~/.aws/**)",
+      "Edit(~/.aws/**)",
       "Read(~/.gnupg/**)",
-      "Edit(./.env)",
-      "Edit(./.env.*)",
-      "Edit(./**/.env)"
+      "Edit(~/.gnupg/**)"
     ],
     "ask": [
-      "Bash(git push --force*)",
-      "Bash(git reset --hard*)",
       "Bash(docker run*)",
       "Bash(docker compose up*)",
       "Bash(docker compose down*)"
@@ -158,7 +140,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Bash|Read|Write|Edit|MultiEdit",
+        "matcher": "Bash|PowerShell|Read|Write|Edit|MultiEdit",
         "hooks": [
           {
             "type": "command",
@@ -188,34 +170,6 @@
       }
     ]
   },
-  "sandbox": {
-    "enabled": false,
-    "failIfUnavailable": false,
-    "autoAllowBashIfSandboxed": true,
-    "network": {
-      "allowedDomains": [
-        "github.com",
-        "*.githubusercontent.com",
-        "registry.npmjs.org",
-        "*.npmjs.org",
-        "registry.yarnpkg.com",
-        "pypi.org",
-        "*.pythonhosted.org",
-        "repo.maven.apache.org",
-        "repo1.maven.org",
-        "services.gradle.org",
-        "plugins.gradle.org",
-        "*.gradle.org",
-        "*.googleapis.com",
-        "api.anthropic.com"
-      ],
-      "allowLocalBinding": true
-    },
-    "filesystem": {
-      "denyRead": ["~/.ssh", "~/.aws", "~/.gnupg", "./.env", "./.env.*"]
-    },
-    "excludedCommands": ["docker *"]
-  },
   "extraKnownMarketplaces": {
     "agricidaniel-claude-seo": {
       "source": {
@@ -225,13 +179,13 @@
     }
   },
   "language": "spanish",
+  "model": "sonnet",
+  "effortLevel": "medium",
   "feedbackSurveyRate": 0,
   "spinnerTipsEnabled": false,
-  "alwaysThinkingEnabled": true,
-  "effortLevel": "medium",
   "awaySummaryEnabled": false,
   "showClearContextOnPlanAccept": true,
-  "autoUpdatesChannel": "stable",
+  "autoUpdatesChannel": "latest",
   "prefersReducedMotion": false,
   "autoMemoryEnabled": false,
   "showThinkingSummaries": true,

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

@@ -0,0 +1,2 @@
+model = "gpt-6.1-sol"
+model_reasoning_effort = "medium"

package/presets/codex/skills/cc-api-contract/SKILL.md

@@ -15,11 +15,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/codex/skills/cc-backlog/SKILL.md

@@ -20,11 +20,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/codex/skills/cc-clarify/SKILL.md

@@ -15,11 +15,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/codex/skills/cc-council/SKILL.md

@@ -7,6 +7,12 @@ description: Council-driven workflow with CCEP-1 bootstrap
 
 Invoke as `$cc-council`. The user request follows the skill mention.
 
+## Council context budget
+
+Use GPT-6.1 Sol with medium reasoning effort. Give each necessary council role
+the same short evidence summary and relevant diff. Reuse those findings in the
+verdict; avoid spawning roles for questions already answered by evidence.
+
 # Council-Driven Workflow
 
 Task request: $ARGUMENTS
@@ -16,11 +22,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.
 
 ---
 
@@ -68,7 +73,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.
 
 ---
 
@@ -80,7 +85,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/codex/skills/cc-db-migration/SKILL.md

@@ -15,11 +15,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/codex/skills/cc-explore/SKILL.md

@@ -15,11 +15,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/codex/skills/cc-feature/SKILL.md

@@ -39,11 +39,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/codex/skills/cc-fix/SKILL.md

@@ -47,11 +47,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/codex/skills/cc-handoff/SKILL.md

@@ -15,11 +15,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.
 
 ---
 
@@ -38,6 +37,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/codex/skills/cc-iterative/SKILL.md

@@ -17,11 +17,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/codex/skills/cc-odd/SKILL.md

@@ -12,11 +12,12 @@ Invoke as `$cc-odd`. The user request follows the skill mention.
 ## 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.
 
 When ODD has verification evidence, include its RDD receipt in the ledger

package/presets/codex/skills/cc-openspec/SKILL.md

@@ -7,6 +7,12 @@ description: Run OpenSpec backlog delivery — validate BACKLOG.md, plan TaskCar
 
 Invoke as `$cc-openspec`. The user request follows the skill mention.
 
+## Model and context budget
+
+Use GPT-6.1 Sol with medium reasoning effort for every OpenSpec phase. Pass each
+role only its current TaskCard, relevant file paths, acceptance criteria, and a
+short handoff. Avoid replaying the full transcript or re-reading large files.
+
 # OpenSpec Backlog Workflow
 
 Scope: $ARGUMENTS
@@ -43,11 +49,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 "$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.
 
 ---
@@ -123,6 +128,13 @@ Show:
 
 Update BACKLOG item status to `PLANNED` (CLI does this automatically).
 
+`plan` is planning-only: it writes TaskCards plus proposal/design/tasks/specs
+and stops. Before Step 5, review the plan in this order — proposal → delta
+specs → tasks — and confirm: intent is right, no scope creep, every FR is
+testable with a scenario that exercises it, edge/error cases are covered, and
+each task traces to an FR/SC. Fix the Markdown directly or ask for revisions.
+Do not `start` any card until the plan reads correctly.
+
 ---
 
 ## Drive card status (CLI)
@@ -133,10 +145,12 @@ Do not edit `.codeconductor/openspec-state.json` by hand.
 npx cc-codeconductor openspec start <cardId>
 npx cc-codeconductor openspec done <cardId>
 npx cc-codeconductor openspec block <cardId> --reason "waiting on design"
+npx cc-codeconductor openspec sync <itemId>
+npx cc-codeconductor openspec verify <itemId>
 npx cc-codeconductor openspec archive <itemId>
 ```
 
-`start` moves the card `pending → doing` and the item `PLANNED → IN_PROGRESS`. `done` marks the card complete, updates Progress, and moves the item to `REVIEW` when every card is done and review is required. `archive` requires all cards done (and review evidence when Global review is required) and moves `openspec/changes/<slug>` to `archive/`.
+`start` moves the card `pending → doing` and the item `PLANNED → IN_PROGRESS`. `done` marks the card complete, updates Progress, and moves the item to `REVIEW` when every card is done and review is required. `sync` merges delta specs into `openspec/specs/` without closing the item (optional before archive). `verify` is the advisory pre-archive checklist: exit 0 with `archiveReady` plus Completeness/Correctness/Coherence issues. `archive` requires all cards done (and review evidence when Global review is required), re-checks planning artifacts and analyze CRITICALs, warns on unchecked `tasks.md` boxes, then moves `openspec/changes/<slug>` to `archive/`.
 
 For test and implementation cards, `done` also requires a current RDD-backed
 RED or GREEN receipt respectively. Do not reuse evidence after candidate files
@@ -158,7 +172,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 |
 |-------|-------|------|
@@ -177,6 +191,14 @@ After each phase:
 
 Implementer: create a Git worktree before editing (`git worktree add ../<branch>-session <branch>`).
 
+Discover is read-only: `repo-explorer` never writes code. The implementer ticks
+`tasks.md` boxes (`- [ ]` → `- [x]`) as each FR lands — only `x`/`X` counts as
+done. If implementation reveals a design problem, pause and reconcile the
+planning artifacts first (any direction: a later artifact may force revising an
+earlier one). Planning artifacts only in that step — never code — and confirm
+each edit. If the item's intent changed rather than its details, open a fresh
+item with `$cc-backlog` instead of warping this one.
+
 ---
 
 ## Step 6 — Review gate
@@ -202,6 +224,8 @@ If **approved**: proceed to Step 6.
 
 ## Step 7 — Scorecard and update backlog
 
+First run the advisory pre-archive check (`npx cc-codeconductor openspec verify <BC-id> --output json`): confirm `archiveReady` and clear any Completeness/Correctness/Coherence issues. Optionally run `openspec sync <BC-id>` to merge delta specs into `openspec/specs/` without closing the item. Then:
+
 1. `npx cc-codeconductor scorecard create --task <BC-id> --from-diff`
 2. Complete criteria; `scorecard record` with verdict and optional cost/tokens
 3. Set item `Progress: 100%`, `Status: DONE` if PASS

package/presets/codex/skills/cc-pagespeed/SKILL.md

@@ -17,11 +17,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 "$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/codex/skills/cc-prototype/SKILL.md

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