cclaw-cli 0.46.14 → 0.47.0

package/dist/content/examples.js

@@ -713,6 +713,14 @@ const DOMAIN_LABELS = {
     library: "Library / SDK",
     "data-pipeline": "Data pipeline / ETL"
 };
+export const RESEARCH_FLEET_USAGE_EXAMPLE = [
+    "Before drafting `03-design.md`, run `research/research-fleet.md` once and",
+    "capture all four lenses in `.cclaw/artifacts/02a-research.md`.",
+    "Dispatch semantics by harness: Claude/Cursor = parallel subagents in one turn;",
+    "OpenCode/Codex = sequential role-switch with explicit announcements.",
+    "Design must include a `Research Fleet Synthesis` section that maps each",
+    "lens to concrete architecture decisions and risks."
+].join(" ");
 const STAGE_DOMAIN_SAMPLES = {
     brainstorm: [
         {
@@ -759,6 +767,11 @@ const STAGE_DOMAIN_SAMPLES = {
         }
     ],
     design: [
+        {
+            domain: "web",
+            label: "Parallel research fleet handoff",
+            body: RESEARCH_FLEET_USAGE_EXAMPLE
+        },
         {
             domain: "web",
             label: "Architecture note",

package/dist/content/harnesses-doc.js

@@ -58,6 +58,17 @@ Fallback legend:
 - \`role-switch\` — in-session role announce + delegation-log entry with evidenceRefs (OpenCode, Codex).
 - \`waiver\` — no parity path; reserved for harnesses that cannot role-switch (none shipped).
 
+## Parallel research dispatch semantics
+
+Design-stage research fleet uses the same parity model:
+
+- **Claude / Cursor**: dispatch all four research lenses in one turn
+  (stack, features, architecture, pitfalls) and synthesize into
+  \`.cclaw/artifacts/02a-research.md\`.
+- **OpenCode / Codex**: execute the same four lenses via sequential
+  role-switch, each with explicit announce -> execute -> evidence trail.
+  This preserves auditability when native parallel dispatch is unavailable.
+
 ## Semantic hook event coverage
 
 | Event | Claude | Cursor | OpenCode | Codex |

package/dist/content/learnings.d.ts

@@ -1,6 +1,7 @@
 /**
  * Canonical required JSONL field order (matches strict validator keys).
- * Optional keys (for now: `source`) may be appended after these required fields.
+ * Optional keys (for now: `source`, `severity`) may be appended after these
+ * required fields.
  * Exported for tests and any programmatic writer that wants a stable base shape.
  */
 export declare const KNOWLEDGE_JSONL_FIELDS: readonly ["type", "trigger", "action", "confidence", "domain", "stage", "origin_stage", "origin_feature", "frequency", "universality", "maturity", "created", "first_seen_ts", "last_seen_ts", "project"];

package/dist/content/learnings.js

@@ -11,7 +11,8 @@ const LEARN_SKILL_NAME = "learnings";
 const LEARN_SKILL_DESCRIPTION = "Project-scoped knowledge store: append and query rule/pattern/lesson/compound entries in the canonical JSONL file at .cclaw/knowledge.jsonl. Strict schema, append-only, machine-queryable.";
 /**
  * Canonical required JSONL field order (matches strict validator keys).
- * Optional keys (for now: `source`) may be appended after these required fields.
+ * Optional keys (for now: `source`, `severity`) may be appended after these
+ * required fields.
  * Exported for tests and any programmatic writer that wants a stable base shape.
  */
 export const KNOWLEDGE_JSONL_FIELDS = [
@@ -74,7 +75,7 @@ Do not invent alternate stores (no markdown mirror, no SQLite, no per-stage file
 
 Exactly one JSON object per line. Required fields must appear in the order:
 \`type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`.
-Optional field \`source\` may be appended after \`project\`.
+Optional fields \`source\` and \`severity\` may be appended after \`project\`.
 
 \`\`\`json
 {"type":"pattern","trigger":"when reviewing external payloads","action":"parse through zod before touching service layer","confidence":"high","domain":"api","stage":"review","origin_stage":"review","origin_feature":"payload-hardening","frequency":1,"universality":"project","maturity":"raw","created":"2026-04-14T12:00:00Z","first_seen_ts":"2026-04-14T12:00:00Z","last_seen_ts":"2026-04-14T12:00:00Z","project":"cclaw"}
@@ -98,6 +99,7 @@ Optional field \`source\` may be appended after \`project\`.
 | \`last_seen_ts\` | ISO 8601 UTC string | yes | Last re-confirmed timestamp. |
 | \`project\` | string \\| null | yes | Repo or scope name. Use \`null\` when the entry crosses projects. |
 | \`source\` | \`"stage" \\| "retro" \\| "compound" \\| "ideate" \\| "manual" \\| null\` | no | Origin channel for the entry when known. |
+| \`severity\` | \`"critical" \\| "important" \\| "suggestion"\` | no | Priority signal for compound lifts; \`critical\` enables single-hit override in \`/cc-ops compound\`. |
 
 Rules:
 - No other fields beyond the table above. Extra keys are forbidden and MUST be rejected by any writer.
@@ -170,7 +172,7 @@ Do not edit source code from this command. Only operate on \`${KNOWLEDGE_PATH}\`
 |---|---|---|
 | (default) | — | Show recent knowledge entries (tail of JSONL, pretty-printed). |
 | \`search\` | \`<query>\` | Stream-filter the JSONL for matching \`trigger\`, \`action\`, \`domain\`, \`project\`. |
-| \`add\` | — | Append one JSON line (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) with the strict JSONL schema (15 required fields + optional \`source\`). |
+| \`add\` | — | Append one JSON line (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) with the strict JSONL schema (15 required fields + optional \`source\` / \`severity\`). |
 | \`curate\` | — | Hand off to the **knowledge-curation** skill: read-only audit + soft-archive plan when the file exceeds the curation threshold. |
 `;
 }

package/dist/content/observe.d.ts

@@ -12,7 +12,8 @@ export declare function promptGuardScript(options?: PromptGuardOptions): string;
 export interface WorkflowGuardOptions {
     workflowGuardMode?: "advisory" | "strict";
     tddEnforcementMode?: "advisory" | "strict";
-    tddTestGlobs?: string[];
+    tddTestPathPatterns?: string[];
+    tddProductionPathPatterns?: string[];
 }
 export declare function workflowGuardScript(options?: WorkflowGuardOptions): string;
 export declare function contextMonitorScript(): string;

package/dist/content/observe.js

@@ -156,9 +156,12 @@ exit 0
 export function workflowGuardScript(options = {}) {
     const workflowGuardMode = options.workflowGuardMode === "strict" ? "strict" : "advisory";
     const tddEnforcementMode = options.tddEnforcementMode === "strict" ? "strict" : "advisory";
-    const tddTestGlobs = options.tddTestGlobs && options.tddTestGlobs.length > 0
-        ? options.tddTestGlobs.join(",")
-        : "**/*.test.*,**/*.spec.*,**/test/**";
+    const tddTestPathPatterns = options.tddTestPathPatterns && options.tddTestPathPatterns.length > 0
+        ? options.tddTestPathPatterns.join(",")
+        : "**/*.test.*,**/tests/**,**/__tests__/**";
+    const tddProductionPathPatterns = options.tddProductionPathPatterns && options.tddProductionPathPatterns.length > 0
+        ? options.tddProductionPathPatterns.join(",")
+        : "";
     return `#!/usr/bin/env bash
 # cclaw workflow guard hook — generated by cclaw sync
 # Enforces stage-aware command discipline and recent flow-state read hygiene.
@@ -166,7 +169,8 @@ set -uo pipefail
 WORKFLOW_GUARD_MODE="\${CCLAW_WORKFLOW_GUARD_MODE:-${workflowGuardMode}}"
 MAX_FLOW_READ_AGE_SEC="\${CCLAW_WORKFLOW_GUARD_MAX_AGE_SEC:-1800}"
 TDD_ENFORCEMENT_MODE="${tddEnforcementMode}"
-TDD_TEST_GLOBS="${tddTestGlobs}"
+TDD_TEST_PATH_PATTERNS="${tddTestPathPatterns}"
+TDD_PRODUCTION_PATH_PATTERNS="${tddProductionPathPatterns}"
 
 ${RUNTIME_SHELL_DETECT_ROOT}
 
@@ -425,34 +429,153 @@ is_preimplementation_stage() {
   esac
 }
 
+normalize_payload_path() {
+  local raw="$1"
+  local normalized="$raw"
+  normalized=$(printf '%s' "$normalized" | tr '\\\\' '/')
+  normalized=$(printf '%s' "$normalized" | tr '[:upper:]' '[:lower:]')
+  normalized="\${normalized#./}"
+  printf '%s' "$normalized"
+}
+
+extract_payload_paths() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$INPUT" | jq -r '
+      [.. | objects | (.path?, .file_path?, .filepath?) | select(type == "string" and length > 0)]
+      | unique
+      | .[]
+    ' 2>/dev/null || printf ''
+    return 0
+  fi
+  if command -v python3 >/dev/null 2>&1; then
+    INPUT_JSON="$INPUT" python3 - <<'PY'
+import json
+import os
+
+def visit(node, acc):
+    if isinstance(node, dict):
+        for key in ("path", "file_path", "filepath"):
+            value = node.get(key)
+            if isinstance(value, str) and value.strip():
+                acc.add(value.strip())
+        for value in node.values():
+            visit(value, acc)
+    elif isinstance(node, list):
+        for value in node:
+            visit(value, acc)
+
+try:
+    payload = json.loads(os.environ.get("INPUT_JSON", "{}"))
+except Exception:
+    payload = {}
+
+items = set()
+visit(payload, items)
+for value in sorted(items):
+    print(value)
+PY
+    return 0
+  fi
+  printf ''
+  return 0
+}
+
+matches_path_patterns() {
+  local candidate="$1"
+  local patterns_csv="$2"
+  [ -n "$candidate" ] || return 1
+  [ -n "$patterns_csv" ] || return 1
+  local old_ifs="$IFS"
+  IFS=','
+  for pattern in $patterns_csv; do
+    local normalized_pattern
+    normalized_pattern=$(normalize_payload_path "$pattern")
+    [ -n "$normalized_pattern" ] || continue
+    case "$candidate" in
+      $normalized_pattern)
+        IFS="$old_ifs"
+        return 0
+        ;;
+    esac
+  done
+  IFS="$old_ifs"
+  return 1
+}
+
+is_code_like_path() {
+  local candidate="$1"
+  printf '%s' "$candidate" | grep -Eq '\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|cs|swift)$'
+}
+
 is_tdd_test_payload() {
   local text="$1"
-  if printf '%s' "$text" | grep -Eq '/tests?/|\\.test\\.|\\.spec\\.'; then
-    return 0
+  local payload_paths="$2"
+  if [ -n "$payload_paths" ]; then
+    while IFS= read -r raw_path; do
+      [ -n "$raw_path" ] || continue
+      local normalized
+      normalized=$(normalize_payload_path "$raw_path")
+      if matches_path_patterns "$normalized" "$TDD_TEST_PATH_PATTERNS"; then
+        return 0
+      fi
+    done <<< "$payload_paths"
   fi
-  if printf '%s' "$TDD_TEST_GLOBS" | grep -Eq '.' && printf '%s' "$text" | grep -Eq '(test|spec)'; then
+  if printf '%s' "$text" | grep -Eq '/tests?/|/__tests__/|\\.test\\.'; then
     return 0
   fi
   return 1
 }
 
-is_tdd_runtime_write_payload() {
+is_tdd_production_path() {
+  local normalized="$1"
+  [ -n "$normalized" ] || return 1
+  if printf '%s' "$normalized" | grep -Eq '(^|/)\\.cclaw/'; then
+    return 1
+  fi
+  if matches_path_patterns "$normalized" "$TDD_TEST_PATH_PATTERNS"; then
+    return 1
+  fi
+  if [ -n "$TDD_PRODUCTION_PATH_PATTERNS" ]; then
+    matches_path_patterns "$normalized" "$TDD_PRODUCTION_PATH_PATTERNS"
+    return $?
+  fi
+  is_code_like_path "$normalized"
+  return $?
+}
+
+is_tdd_production_write_payload() {
   local text="$1"
+  local payload_paths="$2"
+  if [ -n "$payload_paths" ]; then
+    while IFS= read -r raw_path; do
+      [ -n "$raw_path" ] || continue
+      local normalized
+      normalized=$(normalize_payload_path "$raw_path")
+      if is_tdd_production_path "$normalized"; then
+        return 0
+      fi
+    done <<< "$payload_paths"
+    return 1
+  fi
+  if [ -n "$TDD_PRODUCTION_PATH_PATTERNS" ]; then
+    return 1
+  fi
   if printf '%s' "$text" | grep -Eq '\\.cclaw/'; then
     return 1
   fi
   if ! printf '%s' "$text" | grep -Eq '\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|cs|swift)'; then
     return 1
   fi
-  if is_tdd_test_payload "$text"; then
+  if is_tdd_test_payload "$text" ""; then
     return 1
   fi
   return 0
 }
 
-has_open_red_cycle() {
+tdd_cycle_counts() {
   if [ ! -f "$TDD_LOG_FILE" ] || [ ! -s "$TDD_LOG_FILE" ]; then
-    return 1
+    printf '0:0'
+    return 0
   fi
   local red_count="0"
   local green_count="0"
@@ -512,12 +635,37 @@ PY
   fi
   [ -n "$red_count" ] || red_count="0"
   [ -n "$green_count" ] || green_count="0"
+  printf '%s:%s' "$red_count" "$green_count"
+}
+
+has_open_red_cycle() {
+  local counts
+  counts=$(tdd_cycle_counts)
+  local red_count="\${counts%%:*}"
+  local green_count="\${counts##*:}"
   if [ "$red_count" -gt "$green_count" ]; then
     return 0
   fi
   return 1
 }
 
+tdd_cycle_state() {
+  local counts
+  counts=$(tdd_cycle_counts)
+  local red_count="\${counts%%:*}"
+  local green_count="\${counts##*:}"
+  if [ "$red_count" -le 0 ]; then
+    printf 'need_red'
+    return 0
+  fi
+  if [ "$red_count" -gt "$green_count" ]; then
+    printf 'red_open'
+    return 0
+  fi
+  printf 'green_done'
+  return 0
+}
+
 detect_target_stage() {
   local text="$1"
   for stage in brainstorm scope design spec plan tdd review ship; do
@@ -546,6 +694,11 @@ FLOW_COMMAND_INVOKED=0
 if is_flow_progression_command "$PAYLOAD_LOWER"; then
   FLOW_COMMAND_INVOKED=1
 fi
+MUTATION_PATHS=""
+if is_mutating_tool "$TOOL_LOWER"; then
+  MUTATION_PATHS=$(extract_payload_paths)
+fi
+TDD_CYCLE_STATE="unknown"
 if [ -n "$TARGET_STAGE" ] && [ "$CURRENT_STAGE" != "none" ]; then
   CURRENT_IDX=$(stage_index "$CURRENT_STAGE")
   TARGET_IDX=$(stage_index "$TARGET_STAGE")
@@ -583,8 +736,13 @@ if is_preimplementation_stage "$CURRENT_STAGE" && is_mutating_tool "$TOOL_LOWER"
 fi
 
 if [ "$CURRENT_STAGE" = "tdd" ] && is_mutating_tool "$TOOL_LOWER"; then
-  if is_tdd_runtime_write_payload "$PAYLOAD_LOWER"; then
-    if ! has_open_red_cycle; then
+  if is_tdd_production_write_payload "$PAYLOAD_LOWER" "$MUTATION_PATHS"; then
+    if has_open_red_cycle; then
+      TDD_CYCLE_STATE="red_open"
+    else
+      TDD_CYCLE_STATE=$(tdd_cycle_state)
+    fi
+    if [ "$TDD_CYCLE_STATE" = "need_red" ]; then
       if [ -n "$REASONS" ]; then
         REASONS="$REASONS,tdd_write_without_open_red"
       else
@@ -659,7 +817,9 @@ PY
 fi
 
 if [ -n "$REASONS" ]; then
-  if printf '%s' "$REASONS" | grep -Eq 'direct_flow_state_edit'; then
+  if printf '%s' "$REASONS" | grep -Eq 'tdd_write_without_open_red'; then
+    NOTE="Cclaw workflow guard: Write a failing test first before editing production files during tdd stage (state=\${TDD_CYCLE_STATE})."
+  elif printf '%s' "$REASONS" | grep -Eq 'direct_flow_state_edit'; then
     NOTE="Cclaw workflow guard: direct flow-state edit bypasses the canonical stage-complete helper (\${REASONS}). Prefer: bash ${RUNTIME_ROOT}/hooks/stage-complete.sh <stage>. In strict mode this is blocked."
   else
     NOTE="Cclaw workflow guard: detected potential flow violation (\${REASONS}). Re-read ${RUNTIME_ROOT}/state/flow-state.json, avoid source edits before tdd stage, and enforce RED -> GREEN -> REFACTOR discipline inside tdd."

package/dist/content/stage-schema.js

@@ -1,4 +1,5 @@
 import { COMMAND_FILE_ORDER } from "../constants.js";
+import { FLOW_TRACKS, TRACK_STAGES } from "../types.js";
 import { BRAINSTORM, SCOPE, DESIGN, SPEC, PLAN, TDD, REVIEW, SHIP } from "./stages/index.js";
 import { tddStageForTrack } from "./stages/tdd.js";
 const REQUIRED_GATE_IDS = {
@@ -266,15 +267,27 @@ export function nextCclawCommand(stage) {
 }
 export function buildTransitionRules() {
     const rules = [];
-    for (const schema of orderedStageSchemas()) {
-        if (schema.next === "done") {
-            continue;
+    const seen = new Set();
+    // Derive transitions from every track so medium/quick (which skip stages)
+    // get their neighbour edges registered alongside the standard chain.
+    // Previously only the standard track produced rules, so `canTransition`
+    // returned false for legitimate medium/quick transitions (e.g. brainstorm
+    // -> spec on medium) even though `nextStage` correctly advanced them.
+    for (const track of FLOW_TRACKS) {
+        const ordered = TRACK_STAGES[track];
+        for (let i = 0; i < ordered.length - 1; i += 1) {
+            const from = ordered[i];
+            const to = ordered[i + 1];
+            const key = `${from}->${to}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            rules.push({
+                from,
+                to,
+                guards: stageGateIds(from, track)
+            });
         }
-        rules.push({
-            from: schema.stage,
-            to: schema.next,
-            guards: stageGateIds(schema.stage)
-        });
     }
     // Review can explicitly route back to TDD when the verdict is BLOCKED.
     rules.push({

package/dist/content/stages/design.js

@@ -118,9 +118,7 @@ export const DESIGN = {
         "No performance budget for critical path",
         "Batching multiple design issues into one question",
         "Agreeing with user's architecture choice without evaluating alternatives",
-        "Hedging every recommendation with 'it depends' instead of taking a position",
         "No NOT-in-scope output section",
-        "No What-already-exists output section",
         "Design decisions made without reading the actual code first"
     ],
     policyNeedles: [

package/dist/content/utility-skills.js

@@ -1469,7 +1469,7 @@ For each lens, write either a knowledge entry **or** the explicit string
 ## Output protocol
 
 For every harvested insight, append one strict-schema JSON line to
-\`.cclaw/knowledge.jsonl\` (fields: \`type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`).
+\`.cclaw/knowledge.jsonl\` (fields: \`type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`; optional: \`source\`, \`severity\`).
 See the \`learnings\` skill for the canonical shape. Choose \`type\`:
 
 - \`compound\` for process/speed accelerators.

package/dist/delegation.js

@@ -126,6 +126,13 @@ export async function appendDelegation(projectRoot, entry) {
         if (!Array.isArray(stamped.evidenceRefs)) {
             stamped.evidenceRefs = [];
         }
+        // Idempotency: if a caller (or a retried hook) tries to append a row
+        // with a spanId that already exists in the ledger, treat it as a no-op
+        // instead of growing the log with duplicate entries that subsequent
+        // delegation checks would mis-count.
+        if (prior.entries.some((existing) => existing.spanId === stamped.spanId)) {
+            return;
+        }
         const ledger = {
             runId: activeRunId,
             entries: [...prior.entries, stamped]
@@ -201,11 +208,19 @@ export async function checkMandatoryDelegations(projectRoot, stage) {
         if (hasWaived) {
             waived.push(agent);
         }
-        // Under role-switch fallback, a `completed` row is only credible if it
-        // carries at least one evidenceRef — otherwise the agent might have
-        // claimed role-switch satisfaction without showing its work.
+        // Evidence gating for `completed` rows has two triggers:
+        //   1. The aggregate expected mode is role-switch (no isolated harness
+        //      available), so every completion implicitly ran as role-switch.
+        //   2. Any completed row is explicitly stamped `fulfillmentMode:
+        //      "role-switch"` — even in a mixed install. This closes the loop
+        //      where a Codex session logs a role-switch completion inside a
+        //      claude+codex project: the aggregate expectedMode is "isolated"
+        //      (claude wins), so the role-switch row would previously sail
+        //      through without evidenceRefs.
+        const hasExplicitRoleSwitchRow = completedRows.some((e) => e.fulfillmentMode === "role-switch");
+        const evidenceRequired = expectedMode === "role-switch" || hasExplicitRoleSwitchRow;
         if (hasCompleted &&
-            expectedMode === "role-switch" &&
+            evidenceRequired &&
             !completedRows.some((e) => Array.isArray(e.evidenceRefs) && e.evidenceRefs.length > 0)) {
             missingEvidence.push(agent);
         }

package/dist/gate-evidence.js

@@ -266,7 +266,12 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
                             .map((line) => line.trim())
                             .filter((line) => line.length > 0)
                             .filter((line) => !/^\|?(?:[-:\s|])+$/u.test(line));
-                        const nonPlaceholder = meaningfulLines.filter((line) => !/\b(?:TODO|TBD|FIXME|pending|<fill-in>)\b/iu.test(line));
+                        // `<fill-in>` needs its own check because `\b` does not match
+                        // around `<`/`>` (non-word characters), so the previous combined
+                        // pattern `\b(?:...|<fill-in>)\b` silently never matched placeholder
+                        // templates that used angle-bracket form.
+                        const nonPlaceholder = meaningfulLines.filter((line) => !/\b(?:TODO|TBD|FIXME|pending)\b/iu.test(line) &&
+                            !/<fill-in>/iu.test(line));
                         if (nonPlaceholder.length === 0) {
                             missingSections.push(`${section} (empty or placeholder)`);
                         }

package/dist/install.d.ts

@@ -12,9 +12,9 @@ export declare function syncCclaw(projectRoot: string): Promise<void>;
  * stamps are rewritten so the on-disk config reflects the installed CLI.
  *
  * Shape preservation: if the user previously hand-authored advanced keys
- * (e.g. `tddTestGlobs`, `trackHeuristics`, `sliceReview`), those stay in the
- * yaml. If their existing config is minimal, the upgrade keeps it minimal —
- * advanced knobs are never silently added.
+ * (e.g. `tdd`, `compound`, `trackHeuristics`, `sliceReview`), those stay in
+ * the yaml. If their existing config is minimal, the upgrade keeps it
+ * minimal — advanced knobs are never silently added.
  */
 export declare function upgradeCclaw(projectRoot: string): Promise<void>;
 export declare function uninstallCclaw(projectRoot: string): Promise<void>;

package/dist/install.js

@@ -245,7 +245,9 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "using-git-worktrees", "SKILL.md"), featureCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "tdd-cycle-log", "SKILL.md"), tddLogCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-retro", "SKILL.md"), retroCommandSkillMarkdown());
-    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-compound", "SKILL.md"), compoundCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-compound", "SKILL.md"), compoundCommandSkillMarkdown({
+        recurrenceThreshold: config?.compound?.recurrenceThreshold
+    }));
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-rewind", "SKILL.md"), rewindCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-archive", "SKILL.md"), archiveCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
@@ -306,7 +308,7 @@ async function writeSkills(projectRoot, config) {
         await writeFileSafe(runtimePath(projectRoot, ...playbookDirSegments, harnessPlaybookFileName(harness)), harnessPlaybookMarkdown(harness));
     }
 }
-async function writeUtilityCommands(projectRoot) {
+async function writeUtilityCommands(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "ideate.md"), ideateCommandContract());
@@ -319,7 +321,9 @@ async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "feature.md"), featureCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "tdd-log.md"), tddLogCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "retro.md"), retroCommandContract());
-    await writeFileSafe(runtimePath(projectRoot, "commands", "compound.md"), compoundCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "compound.md"), compoundCommandContract({
+        recurrenceThreshold: config.compound?.recurrenceThreshold
+    }));
     await writeFileSafe(runtimePath(projectRoot, "commands", "archive.md"), archiveCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "rewind.md"), rewindCommandContract());
 }
@@ -627,7 +631,8 @@ async function writeHooks(projectRoot, config) {
     await writeFileSafe(path.join(hooksDir, "workflow-guard.sh"), workflowGuardScript({
         workflowGuardMode: config.strictness ?? "advisory",
         tddEnforcementMode: config.tddEnforcement ?? "advisory",
-        tddTestGlobs: config.tddTestGlobs
+        tddTestPathPatterns: config.tdd?.testPathPatterns ?? config.tddTestGlobs,
+        tddProductionPathPatterns: config.tdd?.productionPathPatterns
     }));
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
     const opencodePluginSource = opencodePluginJs();
@@ -1146,7 +1151,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await cleanLegacyArtifacts(projectRoot);
     await cleanStaleFiles(projectRoot);
     await writeCommandContracts(projectRoot);
-    await writeUtilityCommands(projectRoot);
+    await writeUtilityCommands(projectRoot, config);
     await writeSkills(projectRoot, config);
     await writeContextModes(projectRoot);
     await writeArtifactTemplates(projectRoot);
@@ -1195,9 +1200,9 @@ export async function syncCclaw(projectRoot) {
  * stamps are rewritten so the on-disk config reflects the installed CLI.
  *
  * Shape preservation: if the user previously hand-authored advanced keys
- * (e.g. `tddTestGlobs`, `trackHeuristics`, `sliceReview`), those stay in the
- * yaml. If their existing config is minimal, the upgrade keeps it minimal —
- * advanced knobs are never silently added.
+ * (e.g. `tdd`, `compound`, `trackHeuristics`, `sliceReview`), those stay in
+ * the yaml. If their existing config is minimal, the upgrade keeps it
+ * minimal — advanced knobs are never silently added.
  */
 export async function upgradeCclaw(projectRoot) {
     const advancedKeysPresent = await detectAdvancedKeys(projectRoot);