cc-codeconductor 0.4.3 → 1.0.0

package/presets/claude/commands/cc/review.md

@@ -17,6 +17,18 @@ Specify what to review. Accepted formats:
 
 ---
 
+## Step 0 — CCEP Bootstrap
+
+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.
+
+---
+
 ## Step 1 — Diff collection
 
 Before adopting the Reviewer role, collect the diff for the specified target.
@@ -45,7 +57,33 @@ Show the diff summary (files changed, lines added/removed) before proceeding.
 
 Adopt the **Reviewer** role as defined in `CLAUDE.md`.
 
-Evaluate the diff against the following checklist:
+Execute two axes in **parallel** without reranking between them, via separate sub-agents:
+
+**Standards Axis** — Code smell detection against Fowler baseline with documented override:
+
+- 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
+
+**Spec Axis** — Task Card, acceptance criteria, and scope validation:
+
+- Does the implementation match the stated intent from the Task Card?
+- Are all acceptance criteria addressed?
+- Are there changes outside the stated scope?
+
+**Combined sub-checks** (apply findings from both axes):
 
 **Correctness**
 
@@ -77,31 +115,45 @@ Evaluate the diff against the following checklist:
 - Are public interfaces documented?
 - Is CHANGELOG updated if behavior changed?
 
----
-
 ## Step 3 — Review Report
 
-Produce a structured Review Report with findings in three categories:
+Produce a structured Review Report combining findings from both Standards and Spec axes (executed in parallel without reranking):
 
 ```markdown
 ## Review Report
 
-### CRITICAL
-[Findings that must be fixed before merge — file:line, description, suggested resolution]
+**Task**: [objective from Task Card] **Verdict**: [approved | approved with warnings | blocked]
+
+---
+
+### Standards Axis
+
+Findings from Fowler code smell baseline evaluation (with documented overrides applied).
 
-### WARNING
-[Findings that should be resolved before merge — same format as CRITICAL]
+- [ ] [S1] [file:line] — [code smell type] | Override: [documented or N/A] | Required action: [change needed] (CRITICAL) or Recommended action: [change needed] (WARNING)
 
-### SUGGESTION
-[Optional improvements — style, readability, future-proofing. These do not block merge.]
+_(none)_ if no code smell findings
 
-### Summary
-- Files reviewed: N
-- Total findings: N (X critical, Y warnings, Z suggestions)
-- Merge recommendation: APPROVED | BLOCKED
+### Spec Axis
+
+Findings from Task Card, acceptance criteria, and scope alignment.
+
+- [ ] [Sp1] [criterion] — [description] | Evidence: [quote] | Required action: [change needed] (CRITICAL) or Recommended action: [change needed] (WARNING)
+
+_(none)_ if no spec findings
+
+### Combined Summary
+
+- Standards findings: [count] (X CRITICAL, Y WARNING, Z SUGGESTION)
+- Spec findings: [count] (X CRITICAL, Y WARNING, Z SUGGESTION)
+- **Combined Verdict**: [approved | approved with warnings | blocked]
+- **Verdict justification**: [one sentence explaining the combined decision]
 ```
 
----
+Verdict mapping from parallel axes (no reranking):
+- If either axis has CRITICAL → verdict is `blocked`
+- Else if either axis has WARNING → verdict is `approved with warnings`
+- Else → verdict is `approved`
 
 ## Step 4 — Merge decision
 
@@ -122,5 +174,26 @@ If no CRITICAL findings exist:
 
 ## Completion
 
-Deliver the complete Review Report. Never summarize or omit findings. Every
-finding must include a location and an actionable description.
+Deliver the complete Review Report. Never summarize or omit findings.
+
+---
+
+## Step 5 — Scorecard and outcome
+
+Record the review outcome via scorecard with explicit verdict mapping:
+
+```bash
+npx cc-codeconductor scorecard create --from-diff --agent reviewer
+npx cc-codeconductor scorecard record --verdict PASS|REVISE|REJECT --score <weighted>
+npx cc-codeconductor scorecard regression
+```
+
+**Verdict Mapping** (combined Standards + Spec axes):
+
+- `approved` → `npx cc-codeconductor scorecard record --verdict PASS`
+- `approved with warnings` → `npx cc-codeconductor scorecard record --verdict REVISE`
+- `blocked` → `npx cc-codeconductor scorecard record --verdict REJECT`
+
+Example: if the combined verdict is `blocked` (either axis found CRITICAL), record with `--verdict REJECT`.
+
+Map each review outcome for trend tracking and decision audit.

package/presets/claude/commands/cc/scorecard.md

@@ -0,0 +1,77 @@
+---
+description: >-
+  [cc: alias] Evaluate deliverable quality — scorecard, outcome tracking, regression
+  checklist, and aggregate stats.
+---
+
+# Scorecard Evaluation Workflow
+
+Scope: $ARGUMENTS
+
+---
+
+## Step 0 — CCEP Bootstrap
+
+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.
+
+---
+
+## Step 1 — Identify task
+
+Use `$ARGUMENTS` as task id (e.g. `BC-001`) or read active item from `npx cc-codeconductor openspec status`.
+
+---
+
+## Step 2 — Create scorecard with auto-signals
+
+```bash
+npx cc-codeconductor scorecard create --task <id> --agent reviewer --from-diff
+```
+
+Review auto-suggested criteria (minimal diff, cc-gain). Complete remaining scores 0–3 per [`docs/agent-scorecard.md`](docs/agent-scorecard.md).
+
+---
+
+## Step 3 — Regression (optional)
+
+```bash
+npx cc-codeconductor scorecard regression
+```
+
+If required checks fail, **STOP** and report failures.
+
+---
+
+## Step 4 — Record outcome
+
+```bash
+npx cc-codeconductor scorecard record --task <id> --agent reviewer --model <model> --verdict PASS --score 2.5
+```
+
+Include `--cost` and `--tokens` when available from session metrics.
+
+---
+
+## Step 5 — Aggregate
+
+```bash
+npx cc-codeconductor scorecard aggregate
+```
+
+Report pass rate and average weighted score.
+
+---
+
+## Routing on verdict
+
+- **PASS** — accept deliverable; update backlog if applicable
+- **REVISE** — return to implementer/tester with findings
+- **REJECT** — route to task-coach for re-scoping
+
+Apply skill `evaluation`.

package/presets/claude/commands/cc/tdd-cycle.md

@@ -18,6 +18,19 @@ Describe what behavior you want to implement. Include:
 
 ---
 
+## Step 0 — CCEP Bootstrap
+
+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.
+   Canonical delivery order is test-before-implement whenever both phases apply.
+
+---
+
 ## Before you begin — mandatory pre-check
 
 This command enforces strict TDD discipline. The three phases are sequential and
@@ -30,13 +43,38 @@ non-negotiable:
 Do not write implementation code during RED. Do not refactor during GREEN.
 Mixing phases invalidates the cycle.
 
+## Verifiable phase gates
+
+RED → GREEN and GREEN → REFACTOR are enforced by `tddCycleStateMachine` in
+`domain/loop`. Evidence must be captured with `captureTddSuiteEvidence` (verification
+runner) — do not hand-edit JSON under `.codeconductor/evidence/`.
+
+- RED→GREEN requires runner evidence that the suite **failed**.
+- GREEN→REFACTOR requires runner evidence that the suite **passed**.
+
+Do not advance phases until that evidence exists.
+
+Each cycle covers a single vertical slice of behavior — one cycle, one
+behavior — and follows red-before-green: RED must complete before GREEN
+starts.
+
 ---
 
 ## Phase 1 — RED (Tester role)
 
 Adopt the **Tester** role as defined in `CLAUDE.md`.
 
-### 1a — Scope clarification
+### 1a — Agree on the seam
+
+Before writing any test, identify and state the seam — the point where the
+behavior under test can be exercised and observed in isolation (a function
+boundary, an interface, an injectable dependency). Confirm the seam does not
+require reaching into implementation internals.
+
+If no seam exists yet (the code is not structured to allow isolated testing),
+say so and agree on the minimal seam to introduce before continuing.
+
+### 1b — Scope clarification
 
 Before writing any test, confirm:
 
@@ -47,7 +85,7 @@ Before writing any test, confirm:
 
 If the scope is ambiguous, ask one clarifying question and wait for the answer.
 
-### 1b — Write the failing test
+### 1c — Write the failing test
 
 Write a test that:
 
@@ -61,7 +99,19 @@ Write a test that:
 Do not write the implementation. Do not make the test pass by any means other
 than the implementation that will follow in Phase 2.
 
-### 1c — Run the test suite and confirm RED
+### 1d — Anti-pattern checklist
+
+Before declaring the test ready, verify none of these anti-patterns apply:
+
+- **Implementation-coupled** — asserts internal details instead of observable
+  behavior.
+- **Tautological** — cannot fail given the test's own setup.
+- **Horizontal slicing** — spans multiple unrelated behaviors instead of one
+  vertical slice.
+
+If any anti-pattern applies, rewrite the test before continuing.
+
+### 1e — Run the test suite and confirm RED
 
 Run the test suite. The new test must fail. Existing tests must pass.
 

package/presets/claude/commands/cc/test-plan.md

@@ -20,6 +20,18 @@ proceeding.
 
 ---
 
+## Step 0 — CCEP Bootstrap
+
+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.
+
+---
+
 ## Step 1 — Scope confirmation
 
 Before generating the test plan, confirm the scope is well-defined.

package/presets/claude/commands/cc/triage.md

@@ -0,0 +1,34 @@
+---
+description: >-
+  [cc: alias] Classify a request into type, risk, and the destination CodeConductor command.
+---
+
+# Triage Workflow
+
+Triage request: $ARGUMENTS
+
+## Step 0 — CCEP Bootstrap
+
+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.
+
+---
+
+## Step 1 — Classify (task-coach)
+
+Invoke `task-coach`. Produce: title, type (`feature` | `fix` | `refactor` | `review` | `docs` | `test`), risk, named scope, and the destination command (`feature`, `fix`, `refactor`, `review`, `explore`, …).
+
+Ask one question per unresolved branch. If the human is unavailable, emit a Markdown questionnaire and stop at ConfirmationGate.
+
+**STOP here. Show the classification and wait for confirmation before running the destination workflow.**
+
+---
+
+## Completion
+
+Do not implement. Hand the human a destination slash command and a partial Task Card.

package/presets/claude/gates/pre-commit/GATE.md

@@ -0,0 +1,136 @@
+# Pre-commit Gate: Typecheck and Test
+
+Este gate instala un hook `pre-commit` que ejecuta `bun run typecheck` y `bun run test` antes de permitir commits en el repositorio. Si cualquiera de estos comandos falla, el commit es bloqueado.
+
+## Cuándo usar
+
+**Para agentes**: Integra este gate en flujos de desarrollo local cuando quieras garantizar que los cambios typecheck correctamente y pasan los tests antes de ser cometidos.
+
+**Para equipos**: Utiliza este gate como barrera de calidad local (sin dependencias externas) para prevenir commits con errores de tipado o tests fallidos.
+
+## Instalación
+
+### Paso 1: Descarga el script
+
+El script está embebido abajo (sección "Script Installer").
+
+### Paso 2: Ejecuta en la raíz de tu proyecto
+
+Desde la raíz del repositorio (o cualquier subdirectorio), extrae el bloque ```bash de este archivo y ejecuta:
+
+    bash << 'SCRIPT_EOF'
+    #!/bin/bash
+    set -e
+    # [contenido del bloque bash de abajo]
+    SCRIPT_EOF
+
+O, más simplemente, guarda el script en un archivo temporal y ejecútalo:
+
+    curl -s https://raw.githubusercontent.com/.../ | bash
+
+### Paso 3: Verifica
+
+Después de la instalación, debería verse:
+
+    Pre-commit hook installed successfully.
+
+## Script Installer
+
+```bash
+#!/bin/bash
+set -e
+
+# Resolver git directory dinámicamente (worktree-safe)
+GIT_DIR=$(git rev-parse --git-dir)
+HOOK_PATH="$GIT_DIR/hooks/pre-commit"
+
+# Detectar Husky o lint-staged en package.json
+if grep -q '"husky"' package.json 2>/dev/null || grep -q '"lint-staged"' package.json 2>/dev/null; then
+  echo "Warning: Husky or lint-staged detected in package.json. Installation skipped."
+  exit 0
+fi
+
+# Verificar si un pre-commit hook ya existe
+if [ -f "$HOOK_PATH" ]; then
+  echo "Warning: Pre-commit hook already exists at $HOOK_PATH. Not overwriting."
+  exit 0
+fi
+
+# Crear directorio hooks si no existe
+mkdir -p "$GIT_DIR/hooks"
+
+# Escribir el hook pre-commit
+cat > "$HOOK_PATH" << 'HOOK_EOF'
+#!/bin/bash
+bun run typecheck || exit 1
+bun run test || exit 1
+HOOK_EOF
+
+# Hacer el hook ejecutable
+chmod +x "$HOOK_PATH"
+
+echo "Pre-commit hook installed successfully."
+```
+
+## Notas de implementación
+
+- **Sin dependencias externas**: El script no instala Husky, lint-staged, ni ninguna otra herramienta. Solo escribe un archivo shell y configura permisos.
+- **Resolución dinámica de git dir**: Usa `git rev-parse --git-dir` para localizar el directorio correcto, incluso en worktrees.
+- **Detección de conflictos**: Si Husky o lint-staged ya está en `package.json`, el script avisa y no instala para evitar conflictos.
+- **Protección de hooks existentes**: Si ya existe un `.git/hooks/pre-commit`, el script no lo sobrescribe.
+- **Solo Bun**: El hook ejecuta `bun run typecheck` y `bun run test`. Asegúrate de que estos scripts están definidos en `package.json`.
+
+## Verificación
+
+Después de instalar, verifica que el hook está en su lugar.
+
+Para verificar, ejecuta:
+
+    ls -la .git/hooks/pre-commit
+
+Debe mostrar algo como:
+
+    -rwxr-xr-x  user  group  ... .git/hooks/pre-commit
+
+Luego, intenta hacer un commit. Si hay errores de tipo o tests fallidos, el commit será bloqueado:
+
+    git add .
+    git commit -m "test"
+    # Si typecheck o test falla, verás el error y el commit será abortado.
+
+## Troubleshooting
+
+### "Warning: Pre-commit hook already exists"
+
+Ya hay un hook pre-commit. Revisa su contenido:
+
+    cat .git/hooks/pre-commit
+
+Si quieres reemplazarlo, bórralo y ejecuta el script nuevamente:
+
+    rm .git/hooks/pre-commit
+    bash /path/to/installer
+
+### "Warning: Husky or lint-staged detected"
+
+Tu proyecto usa Husky o lint-staged. Este gate no se instala para evitar conflictos. Si quieres usar este gate, remove Husky/lint-staged de `package.json` y ejecuta de nuevo.
+
+### Hook no se ejecuta al hacer commit
+
+Verifica que el hook es ejecutable:
+
+    chmod +x .git/hooks/pre-commit
+
+Verifica que `bun run typecheck` y `bun run test` existen en `package.json`:
+
+    cat package.json | grep -A 5 '"scripts"'
+
+### "command not found: bun"
+
+Bun no está instalado o no está en PATH. Instala Bun desde https://bun.sh o configura PATH adecuadamente.
+
+## Adicional: Desinstalación
+
+Para remover el hook, simplemente bórralo:
+
+    rm .git/hooks/pre-commit

package/presets/claude/settings.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
   "env": {
     "CLAUDE_CODE_ATTRIBUTION_HEADER": "0",
-    "CLAUDE_CODE_DISABLE_1M_CONTEXT": "1",
+    "CLAUDE_CODE_DISABLE_1M_CONTEXT": "0",
     "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1",
     "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
     "CLAUDE_CODE_DISABLE_TERMINAL_TITLE": "1",
@@ -13,7 +13,7 @@
     "CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT": "1",
     "ENABLE_TOOL_SEARCH": "auto",
     "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80",
-    "CLAUDE_CODE_SUBPROCESS_ENV_SCRUB": "1",
+    "CLAUDE_CODE_SUBPROCESS_ENV_SCRUB": "0",
     "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
     "MAX_THINKING_TOKENS": "24000",
@@ -85,20 +85,6 @@
       "Bash(docker compose ps*)",
       "Bash(docker compose logs*)",
       "Read(**)",
-      "Write(./src/**)",
-      "Write(./app/**)",
-      "Write(./pages/**)",
-      "Write(./components/**)",
-      "Write(./lib/**)",
-      "Write(./tests/**)",
-      "Write(./test/**)",
-      "Write(./__tests__/**)",
-      "Write(./prisma/**)",
-      "Write(./drizzle/**)",
-      "Write(./public/**)",
-      "Write(./styles/**)",
-      "Write(./scripts/**)",
-      "Write(./docs/**)",
       "Edit(**)",
       "WebFetch(*)"
     ],
@@ -144,34 +130,18 @@
       "Read(~/.ssh/**)",
       "Read(~/.aws/**)",
       "Read(~/.gnupg/**)",
-      "Write(./.env)",
-      "Write(./.env.*)",
-      "Write(./**/.env)",
       "Edit(./.env)",
       "Edit(./.env.*)",
       "Edit(./**/.env)"
     ],
     "ask": [
-      "Bash(git push*)",
       "Bash(git push --force*)",
       "Bash(git reset --hard*)",
-      "Bash(npm install*)",
-      "Bash(npm i *)",
-      "Bash(pnpm install*)",
-      "Bash(pnpm add *)",
-      "Bash(yarn add *)",
-      "Bash(pip install*)",
       "Bash(docker run*)",
       "Bash(docker compose up*)",
-      "Bash(docker compose down*)",
-      "Bash(./gradlew build*)",
-      "Bash(./gradlew bootRun*)",
-      "Bash(mvn install*)",
-      "Bash(mvn deploy*)",
-      "Bash(vercel*)",
-      "Bash(npx vercel*)"
+      "Bash(docker compose down*)"
     ],
-    "defaultMode": "acceptEdits",
+    "defaultMode": "bypassPermissions",
     "disableBypassPermissionsMode": "disable"
   },
   "hooks": {
@@ -200,7 +170,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '(\\.env|secrets/|id_rsa|\\.pem|\\.key)\\b' && echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '(cat|less|more|head|tail|cp |mv |scp )'; then echo 'Bloqueado: intento de leer archivos sensibles' >&2; exit 2; fi"
+            "command": "if echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '(\\.env|secrets/|id_rsa|\\.pem|\\.key)\\b' && echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '(cat|less|more|head|tail|cp |mv |scp )'; then echo 'Bloqueado: intento de leer archivos sensibles' >&2; exit 2; elif echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '^\\s*git\\s+(push|reset\\s+--hard)' || echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '^\\s*git\\s+clean\\s+(-[a-z]*f[a-z]*|--force)' || echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '^\\s*git\\s+branch\\s+(-D|--delete\\s+--force)' || echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '^\\s*git\\s+checkout\\s+(-f|--force|--discard-changes|--theirs|--ours|-\\s|-$)' || echo \"$CLAUDE_TOOL_INPUT_COMMAND\" | grep -qE '^\\s*git\\s+restore\\s+(-f|--force|--discard-changes|--theirs|--ours)'; then echo \"Bloqueado: El agente no tiene autoridad sobre este comando.\" >&2; exit 2; fi"
           }
         ]
       }
@@ -240,17 +210,9 @@
       "allowLocalBinding": true
     },
     "filesystem": {
-      "denyRead": [
-        "~/.ssh",
-        "~/.aws",
-        "~/.gnupg",
-        "./.env",
-        "./.env.*"
-      ]
+      "denyRead": ["~/.ssh", "~/.aws", "~/.gnupg", "./.env", "./.env.*"]
     },
-    "excludedCommands": [
-      "docker *"
-    ]
+    "excludedCommands": ["docker *"]
   },
   "extraKnownMarketplaces": {
     "agricidaniel-claude-seo": {
@@ -264,7 +226,7 @@
   "feedbackSurveyRate": 0,
   "spinnerTipsEnabled": false,
   "alwaysThinkingEnabled": true,
-  "effortLevel": "xhigh",
+  "effortLevel": "medium",
   "awaySummaryEnabled": false,
   "showClearContextOnPlanAccept": true,
   "autoUpdatesChannel": "stable",

package/presets/claude/skills/evaluation/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: evaluation
+description:
+  Agent scorecard criteria, outcome tracking, model profiles, and evaluation CLI.
+  Use when running /cc:scorecard or measuring deliverable quality.
+---
+
+# Evaluation Skill
+
+## Scorecard criteria (8 weighted)
+
+See `docs/agent-scorecard.md`. Pass threshold: weighted score >= 2.0, no criterion at 0.
+
+## CLI
+
+```bash
+npx cc-codeconductor scorecard create --task BC-001 --from-diff
+npx cc-codeconductor scorecard record --task BC-001 --verdict PASS --score 2.5
+npx cc-codeconductor scorecard list
+npx cc-codeconductor scorecard aggregate
+npx cc-codeconductor scorecard models
+npx cc-codeconductor scorecard regression
+npx cc-codeconductor scorecard matrix
+npx cc-codeconductor scorecard compare-models
+npx cc-codeconductor scorecard prompt-diff 0.4.0 0.5.0 --agent architect
+```
+
+## Outcome tracking
+
+Append-only: `.codeconductor/evaluation/outcomes.jsonl`
+
+Record after each phase (openspec) and after review gate with agent, model, verdict, optional cost/tokens.
+
+## Execution profiles
+
+`.codeconductor/evaluation/execution-profile.yml` — `balanced`, `quality`, `economical`.
+
+Use `scorecard models` before OpenSpec execute loop to show phase → agent → model.
+
+## Verdicts
+
+PASS / REVISE / REJECT — see scorecard calculator rules in docs.