cclaw-cli 0.12.0 → 0.13.0

package/dist/content/observe.js

@@ -153,18 +153,25 @@ fi
 exit 0
 `;
 }
-export function workflowGuardScript() {
+export function workflowGuardScript(options = {}) {
+    const tddEnforcementMode = options.tddEnforcementMode === "strict" ? "strict" : "advisory";
+    const tddTestGlobs = options.tddTestGlobs && options.tddTestGlobs.length > 0
+        ? options.tddTestGlobs.join(",")
+        : "**/*.test.*,**/*.spec.*,**/test/**";
     return `#!/usr/bin/env bash
 # cclaw workflow guard hook — generated by cclaw sync
 # Enforces stage-aware command discipline and recent flow-state read hygiene.
 set -uo pipefail
 WORKFLOW_GUARD_MODE="\${CCLAW_WORKFLOW_GUARD_MODE:-advisory}"
 MAX_FLOW_READ_AGE_SEC="\${CCLAW_WORKFLOW_GUARD_MAX_AGE_SEC:-1800}"
+TDD_ENFORCEMENT_MODE="${tddEnforcementMode}"
+TDD_TEST_GLOBS="${tddTestGlobs}"
 
 ${RUNTIME_SHELL_DETECT_ROOT}
 
 STATE_DIR="$ROOT/${RUNTIME_ROOT}/state"
 FLOW_STATE_FILE="$STATE_DIR/flow-state.json"
+TDD_LOG_FILE="$STATE_DIR/tdd-cycle-log.jsonl"
 GUARD_STATE_FILE="$STATE_DIR/workflow-guard.json"
 GUARD_LOG="$STATE_DIR/workflow-guard.jsonl"
 mkdir -p "$STATE_DIR" 2>/dev/null || true
@@ -234,9 +241,11 @@ NOW_EPOCH=$(date +%s 2>/dev/null || echo "0")
 REASONS=""
 
 CURRENT_STAGE="none"
+CURRENT_RUN="active"
 if [ -f "$FLOW_STATE_FILE" ]; then
   if command -v jq >/dev/null 2>&1; then
     CURRENT_STAGE=$(jq -r '.currentStage // "none"' "$FLOW_STATE_FILE" 2>/dev/null || echo "none")
+    CURRENT_RUN=$(jq -r '.activeRunId // "active"' "$FLOW_STATE_FILE" 2>/dev/null || echo "active")
   elif command -v python3 >/dev/null 2>&1; then
     CURRENT_STAGE=$(python3 - "$FLOW_STATE_FILE" <<'PY'
 import json
@@ -252,6 +261,21 @@ except Exception:
     pass
 print(stage)
 PY
+)
+    CURRENT_RUN=$(python3 - "$FLOW_STATE_FILE" <<'PY'
+import json
+import sys
+run_id = "active"
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+        parsed = json.load(fh)
+    value = parsed.get("activeRunId")
+    if isinstance(value, str) and value:
+        run_id = value
+except Exception:
+    pass
+print(run_id)
+PY
 )
   fi
 fi
@@ -325,6 +349,99 @@ is_preimplementation_stage() {
   esac
 }
 
+is_tdd_test_payload() {
+  local text="$1"
+  if printf '%s' "$text" | grep -Eq '/tests?/|\\.test\\.|\\.spec\\.'; then
+    return 0
+  fi
+  if printf '%s' "$TDD_TEST_GLOBS" | grep -Eq '.' && printf '%s' "$text" | grep -Eq '(test|spec)'; then
+    return 0
+  fi
+  return 1
+}
+
+is_tdd_runtime_write_payload() {
+  local text="$1"
+  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
+    return 1
+  fi
+  return 0
+}
+
+has_open_red_cycle() {
+  if [ ! -f "$TDD_LOG_FILE" ] || [ ! -s "$TDD_LOG_FILE" ]; then
+    return 1
+  fi
+  local red_count="0"
+  local green_count="0"
+  if command -v jq >/dev/null 2>&1; then
+    red_count=$(jq -r --arg run "$CURRENT_RUN" 'select((.runId // $run) == $run and .phase == "red") | .phase' "$TDD_LOG_FILE" 2>/dev/null | wc -l | tr -d ' ' || echo "0")
+    green_count=$(jq -r --arg run "$CURRENT_RUN" 'select((.runId // $run) == $run and .phase == "green") | .phase' "$TDD_LOG_FILE" 2>/dev/null | wc -l | tr -d ' ' || echo "0")
+  elif command -v python3 >/dev/null 2>&1; then
+    red_count=$(python3 - "$TDD_LOG_FILE" "$CURRENT_RUN" <<'PY'
+import json
+import sys
+count = 0
+run_id = sys.argv[2]
+with open(sys.argv[1], "r", encoding="utf-8") as fh:
+    for raw in fh:
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            parsed = json.loads(raw)
+        except Exception:
+            continue
+        if not isinstance(parsed, dict):
+            continue
+        if str(parsed.get("runId", run_id)) != run_id:
+            continue
+        if parsed.get("phase") == "red":
+            count += 1
+print(count)
+PY
+)
+    green_count=$(python3 - "$TDD_LOG_FILE" "$CURRENT_RUN" <<'PY'
+import json
+import sys
+count = 0
+run_id = sys.argv[2]
+with open(sys.argv[1], "r", encoding="utf-8") as fh:
+    for raw in fh:
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            parsed = json.loads(raw)
+        except Exception:
+            continue
+        if not isinstance(parsed, dict):
+            continue
+        if str(parsed.get("runId", run_id)) != run_id:
+            continue
+        if parsed.get("phase") == "green":
+            count += 1
+print(count)
+PY
+)
+  else
+    red_count=$(grep -ci '"phase"[[:space:]]*:[[:space:]]*"red"' "$TDD_LOG_FILE" 2>/dev/null || echo "0")
+    green_count=$(grep -ci '"phase"[[:space:]]*:[[:space:]]*"green"' "$TDD_LOG_FILE" 2>/dev/null || echo "0")
+  fi
+  [ -n "$red_count" ] || red_count="0"
+  [ -n "$green_count" ] || green_count="0"
+  if [ "$red_count" -gt "$green_count" ]; then
+    return 0
+  fi
+  return 1
+}
+
 detect_target_stage() {
   local text="$1"
   for stage in brainstorm scope design spec plan tdd review ship; do
@@ -373,6 +490,18 @@ if is_preimplementation_stage "$CURRENT_STAGE" && is_mutating_tool "$TOOL_LOWER"
   fi
 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 [ -n "$REASONS" ]; then
+        REASONS="$REASONS,tdd_write_without_open_red"
+      else
+        REASONS="tdd_write_without_open_red"
+      fi
+    fi
+  fi
+fi
+
 if is_preimplementation_stage "$CURRENT_STAGE" && ! is_plan_mode_safe_tool "$TOOL_LOWER"; then
   if ! is_mutating_tool "$TOOL_LOWER"; then
     if ! printf '%s' "$PAYLOAD_LOWER" | grep -Eq '\.cclaw/' && ! is_cclaw_cli_payload "$PAYLOAD_LOWER"; then
@@ -438,7 +567,7 @@ PY
 fi
 
 if [ -n "$REASONS" ]; then
-  NOTE="Cclaw workflow guard: detected potential flow violation (\${REASONS}). Re-read ${RUNTIME_ROOT}/state/flow-state.json, avoid source edits before tdd stage, and continue from current stage ordering."
+  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."
   if command -v jq >/dev/null 2>&1; then
     ENTRY=$(jq -n -c \
       --arg ts "$TS" \
@@ -458,6 +587,9 @@ if [ -n "$REASONS" ]; then
   if printf '%s' "$REASONS" | grep -Eq 'implementation_write_before_'; then
     SHOULD_BLOCK="true"
   fi
+  if printf '%s' "$REASONS" | grep -Eq 'tdd_write_without_open_red' && [ "$TDD_ENFORCEMENT_MODE" = "strict" ]; then
+    SHOULD_BLOCK="true"
+  fi
   if [ "$WORKFLOW_GUARD_MODE" = "strict" ] || [ "$SHOULD_BLOCK" = "true" ]; then
     printf '[cclaw] %s (blocked by workflow guard)\n' "$NOTE" >&2
     exit 1

package/dist/content/retro-command.d.ts

@@ -0,0 +1,2 @@
+export declare function retroCommandContract(): string;
+export declare function retroCommandSkillMarkdown(): string;

package/dist/content/retro-command.js

@@ -0,0 +1,77 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const RETRO_SKILL_FOLDER = "flow-retro";
+const RETRO_SKILL_NAME = "flow-retro";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function retroArtifactPath() {
+    return `${RUNTIME_ROOT}/artifacts/09-retro.md`;
+}
+function knowledgePath() {
+    return `${RUNTIME_ROOT}/knowledge.jsonl`;
+}
+export function retroCommandContract() {
+    return `# /cc-retro
+
+## Purpose
+
+Mandatory retrospective gate before archive once ship is complete.
+
+## HARD-GATE
+
+- Do not mark retro complete without writing \`${retroArtifactPath()}\`.
+- Do not finish retro without appending at least one \`type=compound\` entry into \`${knowledgePath()}\`.
+
+## Algorithm
+
+1. Read \`${flowStatePath()}\`; confirm ship stage is complete for current run.
+2. Synthesize retrospective artifact \`${retroArtifactPath()}\` with:
+   - what slowed this run
+   - what accelerated this run
+   - concrete repeatable rule for next run
+3. Append >=1 strict-schema JSONL entry to \`${knowledgePath()}\` with:
+   - \`type: "compound"\`
+   - \`stage: "ship"\` or \`"retro"\`
+4. Update flow-state \`retro\` block:
+   - \`required: true\`
+   - \`completedAt: <ISO>\`
+   - \`compoundEntries: <count>\`
+5. Report completion summary and remind user that \`cclaw archive\` is now unblocked.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${RETRO_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function retroCommandSkillMarkdown() {
+    return `---
+name: ${RETRO_SKILL_NAME}
+description: "Run mandatory retrospective and record compound knowledge before archive."
+---
+
+# /cc-retro
+
+## HARD-GATE
+
+Archive must remain blocked until retro artifact exists and compound knowledge was appended.
+
+## Protocol
+
+1. Confirm ship completion from \`${flowStatePath()}\`.
+2. Create/update \`${retroArtifactPath()}\` with concise retrospective sections:
+   - outcomes
+   - bottlenecks
+   - reusable acceleration patterns
+3. Append at least one \`compound\` knowledge entry into \`${knowledgePath()}\`.
+4. Update \`flow-state.json.retro\` with completion timestamp + compound count.
+5. Print explicit completion line:
+   - \`retro gate: complete\`
+   - \`compound entries added: <N>\`
+
+## Validation
+
+- \`${retroArtifactPath()}\` exists and is non-empty.
+- \`${knowledgePath()}\` contains >=1 valid \`compound\` line.
+- \`retro.completedAt\` is set in flow-state.
+`;
+}

package/dist/content/rewind-command.d.ts

@@ -0,0 +1,3 @@
+export declare function rewindCommandContract(): string;
+export declare function rewindAcknowledgeCommandContract(): string;
+export declare function rewindCommandSkillMarkdown(): string;

package/dist/content/rewind-command.js

@@ -0,0 +1,120 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const REWIND_SKILL_FOLDER = "flow-rewind";
+const REWIND_SKILL_NAME = "flow-rewind";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function artifactsPath() {
+    return `${RUNTIME_ROOT}/artifacts`;
+}
+function rewindLogPath() {
+    return `${RUNTIME_ROOT}/state/rewind-log.jsonl`;
+}
+export function rewindCommandContract() {
+    return `# /cc-rewind
+
+## Purpose
+
+Rewind active flow to an earlier stage and atomically invalidate downstream work.
+
+## HARD-GATE
+
+- Never rewind without preserving downstream artifact history.
+- Mark downstream stages as stale; do not leave completedStages pointing to invalidated work.
+- Record a rewind reason in \`${rewindLogPath()}\`.
+
+## Inputs
+
+\`/cc-rewind <target-stage> [reason]\`
+
+## Algorithm
+
+1. Read \`${flowStatePath()}\` and current track.
+2. Validate \`target-stage\` belongs to the active track and is not ahead of current stage.
+3. Compute downstream stages to invalidate (all stages after target that were completed or current).
+4. Archive downstream artifacts into \`${artifactsPath()}/_rewind-archive/<rewind-id>/\`.
+5. Rename active downstream artifacts to \`*.stale.md\`.
+6. Update flow-state:
+   - \`currentStage = target-stage\`
+   - trim \`completedStages\` to stages before target-stage
+   - clear gate evidence/catalog for target-stage and downstream
+   - mark downstream entries in \`staleStages\`
+   - append \`rewinds[]\` record
+7. Append JSON line to \`${rewindLogPath()}\`.
+
+## Output
+
+- Rewind id
+- from -> to stage
+- Invalidated stages list
+- Number of stale artifacts
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${REWIND_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function rewindAcknowledgeCommandContract() {
+    return `# /cc-rewind-ack
+
+## Purpose
+
+Acknowledge and clear stale-stage markers after downstream work is intentionally redone.
+
+## Input
+
+\`/cc-rewind-ack <stage>\`
+
+## HARD-GATE
+
+- Only clear stale marker for the requested stage.
+- Never modify completedStages from this command.
+
+## Algorithm
+
+1. Read \`${flowStatePath()}\`.
+2. If \`staleStages.<stage>\` is missing, report no-op.
+3. Remove \`staleStages.<stage>\`.
+4. Write updated flow-state.
+5. Print remaining stale stages (if any).
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${REWIND_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function rewindCommandSkillMarkdown() {
+    return `---
+name: ${REWIND_SKILL_NAME}
+description: "Rewind active flow stage safely and acknowledge stale invalidations."
+---
+
+# /cc-rewind + /cc-rewind-ack
+
+## HARD-GATE
+
+Rewind is an atomic state transition. Never leave flow-state half-updated (for example currentStage changed but stale markers/artifact archive missing).
+
+## Protocol
+
+### rewind
+1. Validate target stage belongs to current track and is upstream.
+2. Archive downstream artifacts under \`${artifactsPath()}/_rewind-archive/<rewind-id>/\`.
+3. Mark downstream artifacts as stale (\`*.stale.md\`).
+4. Reset downstream gate catalog and guard evidence.
+5. Record \`rewinds[]\` and \`staleStages\` in flow-state.
+6. Append rewind entry into \`${rewindLogPath()}\`.
+
+### rewind-ack
+1. Load flow-state stale map.
+2. Remove exactly one stale stage marker.
+3. Report remaining stale stages.
+
+## Validation checklist
+
+- \`${flowStatePath()}\` remains valid JSON.
+- \`currentStage\` equals requested rewind target.
+- invalidated stages are absent from \`completedStages\`.
+- archived copies exist for each moved artifact.
+`;
+}

package/dist/content/status-command.js

@@ -19,6 +19,9 @@ function checkpointPath() {
 function stageActivityPath() {
     return `${RUNTIME_ROOT}/state/stage-activity.jsonl`;
 }
+function snapshotPath() {
+    return `${RUNTIME_ROOT}/state/flow-state.snapshot.json`;
+}
 /**
  * Command contract for /cc-status — a read-only snapshot command.
  * Does not mutate state. Always safe to run.
@@ -30,8 +33,8 @@ export function statusCommandContract() {
 
 ## Purpose
 
-**Read-only snapshot of the cclaw run.** Shows track, current stage, completed stages,
-gate coverage, mandatory delegations, and the top 3 knowledge highlights.
+**Read-only visual snapshot of the cclaw run.** Shows progress bar, current stage,
+gate coverage, delegation status, stale markers, and top knowledge highlights.
 
 This command **never mutates state**. Use it at session start to orient, or at any
 time to answer "where are we?" without advancing the flow.
@@ -41,6 +44,7 @@ time to answer "where are we?" without advancing the flow.
 - **Do not** use \`/cc-status\` output to infer gate completion for decisions — cite
   artifact evidence via \`/cc-next\` when advancing.
 - **Do not** mutate \`${flowPath}\` or delegation log from this command.
+- **Do not** rewrite \`${snapshotPath()}\` from this command (use \`/cc-diff\`).
 
 ## Algorithm
 
@@ -54,38 +58,32 @@ time to answer "where are we?" without advancing the flow.
    - Otherwise scan \`${stageActivityPath()}\` from the end for the first entry whose \`stage\` matches \`currentStage\` and use its \`ts\`.
    - Compute the duration as \`now - signalTimestamp\` and render compactly: \`<X>m\`, \`<X>h<Y>m\`, or \`<X>d<Y>h\`.
    - If no signal exists, render \`(unknown)\`.
-5. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
+5. Optionally read **\`${snapshotPath()}\`** to compute gate delta versus prior baseline:
+   - If missing or invalid, render \`delta: (baseline unavailable; run /cc-diff)\`.
+6. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
    (by trailing timestamp or source marker).
-6. Emit the status block described below. Do **not** load any stage skill.
+7. Emit the visual status block described below. Do **not** load any stage skill.
+
+## Visual markers
+
+Default UTF markers: \`✓\` passed, \`▶\` current, \`○\` pending, \`⊘\` skipped, \`⏸\` stale, \`✗\` blocked.  
+ASCII fallback (no UTF locale): \`[x]\`, \`[>]\`, \`[ ]\`, \`[-]\`, \`[=]\`, \`[!]\`.
 
 ## Status Block Format
 
 \`\`\`
 cclaw status
-  track:            <quick|standard>
-  current stage:    <stage>     (<N>/<total> in track)
-  time in stage:    <Xd Yh | Yh Zm | Zm | unknown>
-  context mode:     <activeMode>     (default | execution | review | incident | …)
-  completed stages: <list or "none">
-  skipped stages:   <list or "none">
-
-  gates:
-    passed:   <count> of <required>
-    blocked:  <count>
-    unmet:    <list of gate ids>
-
-  delegations (current stage):
-    required:  <list>
-    completed: <list>
-    pending:   <list>
-
-  knowledge highlights:
-    - <latest entry summary line>
-    - <second entry summary line>
-    - <third entry summary line>
-
-  next action:
-    /cc-next  (advance or resume current stage)
+  flow:   <track> · run=<runId> · feature=<feature-id>
+  stage:  <stage> (<N>/<total>) · time <Xd|XhYm|Xm|unknown> · mode <activeMode>
+  bar:    [✓ brainstorm] [✓ scope] [▶ design] [○ spec] [○ plan] [○ tdd] [○ review] [○ ship]
+  gates:  now <passed>/<required> · blocked <count> · delta <summary or baseline-unavailable>
+  delegations: [✓ <role>] [○ <role>] ...
+  stale:  <list or none>
+  knowledge:
+    - <latest entry summary>
+    - <second entry summary>
+    - <third entry summary>
+  next: /cc-next · /cc-tree · /cc-diff
 \`\`\`
 
 ## Anti-patterns
@@ -93,6 +91,7 @@ cclaw status
 - Inventing gate status without reading \`${flowPath}\`.
 - Reporting delegations as satisfied when the log says \`pending\`.
 - Advancing the stage from \`/cc-status\` — progression belongs to \`/cc-next\`.
+- Hiding stale stages; stale markers must be surfaced directly in the status line.
 
 ## Primary skill
 
@@ -107,7 +106,7 @@ export function statusCommandSkillMarkdown() {
     const delegationPath = delegationLogPath();
     return `---
 name: ${STATUS_SKILL_NAME}
-description: "Read-only snapshot of the cclaw flow: track, stage, gate coverage, delegations, knowledge highlights. Never mutates state."
+description: "Read-only visual snapshot of the cclaw flow with progress bar, gate delta, delegations, and stale markers."
 ---
 
 # /cc-status — Flow Status Snapshot
@@ -120,7 +119,7 @@ advancing or mutating anything. Safe to run at any point.
 ## HARD-GATE
 
 Do **not** mutate \`${flowPath}\` or \`${delegationPath}\` from this skill. This is
-a read-only command.
+a read-only command. Do **not** update \`${snapshotPath()}\` here.
 
 ## Algorithm
 
@@ -131,19 +130,28 @@ a read-only command.
    - Prefer \`${checkpointPath()}\` when \`stage === currentStage\` and \`timestamp\` parses as ISO 8601.
    - Else scan \`${stageActivityPath()}\` from tail for the most recent entry whose \`stage === currentStage\`; use its \`ts\`.
    - Render \`<X>d<Y>h\`, \`<X>h<Y>m\`, \`<X>m\`, or \`(unknown)\`.
-5. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
-6. For each gate in \`stageGateCatalog[currentStage].required\`:
+5. Try reading \`${snapshotPath()}\` for gate delta:
+   - If available, compare current stage \`passed\` / \`blocked\` sets against baseline.
+   - If unavailable, render \`delta: (baseline unavailable; run /cc-diff)\`.
+6. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
+7. For each gate in \`stageGateCatalog[currentStage].required\`:
    - Satisfied if present in \`passed\` and absent from \`blocked\`.
-7. Build and print the status block (see command contract for layout).
-8. Suggest the next action:
+8. Build and print the visual status block:
+   - stage header
+   - one-line progress bar with per-stage markers
+   - gate summary + delta
+   - delegation row
+   - stale stage row
+9. Suggest the next action:
    - If current stage has unmet gates → \`/cc-next\` to resume.
    - If current stage is complete → \`/cc-next\` to advance (or report "Flow complete" if terminal).
 
 ## Output Guidelines
 
-- Keep output compact (≤ 25 lines) — status, not narrative.
+- Keep output compact (≤ 30 lines) — status, not narrative.
 - Report counts, not full artifact contents.
 - If any data source is missing or corrupt, say so explicitly rather than guessing.
+- Include \`/cc-tree\` for deep structure and \`/cc-diff\` for before/after map in the final line.
 
 ## Anti-patterns
 

package/dist/content/tdd-log-command.d.ts

@@ -0,0 +1,2 @@
+export declare function tddLogCommandContract(): string;
+export declare function tddLogCommandSkillMarkdown(): string;

package/dist/content/tdd-log-command.js

@@ -0,0 +1,75 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const TDD_LOG_SKILL_FOLDER = "tdd-cycle-log";
+const TDD_LOG_SKILL_NAME = "tdd-cycle-log";
+function logPath() {
+    return `${RUNTIME_ROOT}/state/tdd-cycle-log.jsonl`;
+}
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+export function tddLogCommandContract() {
+    return `# /cc-tdd-log
+
+## Purpose
+
+Record explicit RED/GREEN/REFACTOR evidence used by workflow guard and doctor checks.
+
+## HARD-GATE
+
+- Every implementation write in tdd must be preceded by a logged RED event.
+- Use append-only JSONL at \`${logPath()}\`; never rewrite prior lines.
+
+## Subcommands
+
+- \`/cc-tdd-log red <slice> <command> [note]\`
+- \`/cc-tdd-log green <slice> <command> [note]\`
+- \`/cc-tdd-log refactor <slice> <command> [note]\`
+- \`/cc-tdd-log show\`
+
+## Log Schema
+
+Each JSON line must include:
+- \`ts\` (ISO timestamp)
+- \`runId\` (from flow-state)
+- \`stage\` (usually \`tdd\`)
+- \`slice\` (e.g. \`S-1\`)
+- \`phase\` (\`red\` | \`green\` | \`refactor\`)
+- \`command\`
+- optional: \`files\`, \`exitCode\`, \`note\`
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${TDD_LOG_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function tddLogCommandSkillMarkdown() {
+    return `---
+name: ${TDD_LOG_SKILL_NAME}
+description: "Append RED/GREEN/REFACTOR entries into tdd-cycle-log.jsonl for guard/doctor enforcement."
+---
+
+# /cc-tdd-log
+
+## HARD-GATE
+
+Do not fake RED evidence. A \`red\` entry must correspond to a failing test command.
+
+## Protocol
+
+1. Read \`${flowStatePath()}\` and capture \`activeRunId\` + \`currentStage\`.
+2. Build JSON entry:
+   - \`ts\`: now ISO
+   - \`runId\`: activeRunId
+   - \`stage\`: currentStage
+   - \`slice\`: user-provided slice id
+   - \`phase\`: red|green|refactor
+   - \`command\`: test command or refactor verification command
+3. Append one line to \`${logPath()}\`.
+4. \`show\`: print the last 20 lines grouped by slice.
+
+## Validation
+
+- File remains valid JSONL (one JSON object per line).
+- For each slice, first phase must be \`red\`.
+`;
+}

package/dist/content/templates.js

@@ -480,11 +480,41 @@ Execution rule: complete and verify each wave before starting the next wave.
 - SHIPPED | SHIPPED_WITH_EXCEPTIONS | BLOCKED
 - Exceptions (if any):
 
-## Compound Step
-_Optional retrospective. The goal is to make the **next** feature faster, not to evaluate this one._
-_If you have nothing to add, write the explicit line: \`No compound insight this run.\`_
-- Insight: <one short line about what should accelerate the next run>
-- Action: append one strict-schema JSON line with \`"type":"compound"\` to \`.cclaw/knowledge.jsonl\` capturing the insight (fields: type, trigger, action, confidence, domain, stage, created, project)
+## Retro Gate Handoff
+- Run \`/cc-retro\` before archive.
+- Retro artifact path: \`.cclaw/artifacts/09-retro.md\`
+- Archive remains blocked until retro gate is complete.
+`,
+    "09-retro.md": `# Retro Artifact
+
+## Run Summary
+- Flow track:
+- Scope delivered:
+- Main outcome:
+
+## Friction Log
+| Category | What slowed us down | Evidence | Prevention rule |
+|---|---|---|---|
+|  |  |  |  |
+
+## Acceleration Log
+| Category | What helped | Evidence | Reuse trigger |
+|---|---|---|---|
+|  |  |  |  |
+
+## Compound Decisions
+| Insight | Trigger pattern | Action rule for next run |
+|---|---|---|
+|  |  |  |
+
+## Knowledge Writes
+- Compound entries appended to \`.cclaw/knowledge.jsonl\`: <N>
+- Entry ids / timestamps:
+
+## Retro Completion
+- RETRO_COMPLETE: yes
+- Completed at (UTC):
+- Notes:
 `
 };
 export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook

package/dist/content/tree-command.d.ts

@@ -0,0 +1,2 @@
+export declare function treeCommandContract(): string;
+export declare function treeCommandSkillMarkdown(): string;