cclaw-cli 0.12.0 → 0.14.0

package/dist/cli.d.ts

@@ -14,6 +14,8 @@ interface ParsedArgs {
     doctorQuiet?: boolean;
     doctorOnly?: string[];
     archiveName?: string;
+    archiveSkipRetro?: boolean;
+    archiveSkipRetroReason?: string;
     showHelp?: boolean;
     showVersion?: boolean;
 }

package/dist/cli.js

@@ -39,6 +39,8 @@ Commands:
                     --quiet             Print only failing checks (and totals).
   archive    Move .cclaw/artifacts into .cclaw/runs/<date>-<slug> and reset flow state.
              Flags: --name=<feature>    Feature slug (default: inferred from 00-idea.md).
+                    --skip-retro       Bypass mandatory retro gate (requires --retro-reason).
+                    --retro-reason=<t> Reason for bypassing retro gate.
   upgrade    Refresh generated files in .cclaw without modifying user artifacts.
   uninstall  Remove .cclaw runtime and the generated harness shim files.
 
@@ -113,6 +115,17 @@ function buildInitSurfacePreview(harnesses) {
         ".cclaw/config.yaml",
         ".cclaw/commands/*.md",
         ".cclaw/skills/*/SKILL.md",
+        ".cclaw/contexts/*.md",
+        ".cclaw/templates/*",
+        ".cclaw/agents/*.md",
+        ".cclaw/hooks/*",
+        ".cclaw/rules/**",
+        ".cclaw/adapters/*.md",
+        ".cclaw/custom-skills/README.md",
+        ".cclaw/features/**",
+        ".cclaw/runs/**",
+        ".cclaw/artifacts/**",
+        ".cclaw/knowledge.jsonl",
         ".cclaw/state/*.json|*.jsonl",
         ".cclaw/references/**",
         "AGENTS.md (managed block)"
@@ -368,6 +381,14 @@ function parseArgs(argv) {
         }
         if (flag.startsWith("--name=")) {
             parsed.archiveName = flag.replace("--name=", "").trim();
+            continue;
+        }
+        if (flag === "--skip-retro") {
+            parsed.archiveSkipRetro = true;
+            continue;
+        }
+        if (flag.startsWith("--retro-reason=")) {
+            parsed.archiveSkipRetroReason = flag.replace("--retro-reason=", "").trim();
         }
     }
     return parsed;
@@ -466,7 +487,10 @@ async function runCommand(parsed, ctx) {
         return 0;
     }
     if (command === "archive") {
-        const archived = await archiveRun(ctx.cwd, parsed.archiveName);
+        const archived = await archiveRun(ctx.cwd, parsed.archiveName, {
+            skipRetro: parsed.archiveSkipRetro === true,
+            skipRetroReason: parsed.archiveSkipRetroReason
+        });
         const snapshotSummary = archived.snapshottedStateFiles.length > 0
             ? ` Snapshotted ${archived.snapshottedStateFiles.length} state file(s) under ${archived.archivePath}/state and wrote archive-manifest.json.`
             : "";

package/dist/config.js

@@ -15,8 +15,9 @@ const ALLOWED_CONFIG_KEYS = new Set([
     "version",
     "flowVersion",
     "harnesses",
-    "autoAdvance",
     "promptGuardMode",
+    "tddEnforcement",
+    "tddTestGlobs",
     "gitHookGuards",
     "defaultTrack",
     "languageRulePacks",
@@ -58,8 +59,9 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, defaultTrack
         version: CCLAW_VERSION,
         flowVersion: FLOW_VERSION,
         harnesses,
-        autoAdvance: false,
         promptGuardMode: "advisory",
+        tddEnforcement: "advisory",
+        tddTestGlobs: ["**/*.test.*", "**/*.spec.*", "**/test/**"],
         gitHookGuards: false,
         defaultTrack,
         languageRulePacks: []
@@ -77,8 +79,8 @@ export function createProfileConfig(profile, overrides = {}) {
             return {
                 ...base,
                 harnesses: overrides.harnesses ?? ["claude"],
-                autoAdvance: false,
                 promptGuardMode: "advisory",
+                tddEnforcement: "advisory",
                 gitHookGuards: false,
                 defaultTrack: overrides.defaultTrack ?? "medium",
                 languageRulePacks: overrides.languageRulePacks ?? []
@@ -87,8 +89,8 @@ export function createProfileConfig(profile, overrides = {}) {
             return {
                 ...base,
                 harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
-                autoAdvance: false,
                 promptGuardMode: "advisory",
+                tddEnforcement: "advisory",
                 gitHookGuards: false,
                 defaultTrack: overrides.defaultTrack ?? "standard",
                 languageRulePacks: overrides.languageRulePacks ?? []
@@ -97,8 +99,8 @@ export function createProfileConfig(profile, overrides = {}) {
             return {
                 ...base,
                 harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
-                autoAdvance: false,
                 promptGuardMode: "strict",
+                tddEnforcement: "strict",
                 gitHookGuards: true,
                 defaultTrack: overrides.defaultTrack ?? "standard",
                 languageRulePacks: overrides.languageRulePacks ?? [...LANGUAGE_RULE_PACKS]
@@ -140,8 +142,6 @@ export async function readConfig(projectRoot) {
     const harnesses = hasHarnessesField
         ? [...new Set(validatedHarnesses)]
         : DEFAULT_HARNESSES;
-    const autoAdvanceRaw = parsed.autoAdvance;
-    const autoAdvance = typeof autoAdvanceRaw === "boolean" ? autoAdvanceRaw : false;
     const promptGuardModeRaw = parsed.promptGuardMode;
     if (Object.prototype.hasOwnProperty.call(parsed, "promptGuardMode") &&
         promptGuardModeRaw !== "advisory" &&
@@ -149,6 +149,16 @@ export async function readConfig(projectRoot) {
         throw configValidationError(fullPath, `"promptGuardMode" must be "advisory" or "strict"`);
     }
     const promptGuardMode = promptGuardModeRaw === "strict" ? "strict" : "advisory";
+    const tddEnforcementRaw = parsed.tddEnforcement;
+    if (Object.prototype.hasOwnProperty.call(parsed, "tddEnforcement") &&
+        tddEnforcementRaw !== "advisory" &&
+        tddEnforcementRaw !== "strict") {
+        throw configValidationError(fullPath, `"tddEnforcement" must be "advisory" or "strict"`);
+    }
+    const tddEnforcement = tddEnforcementRaw === "strict" ? "strict" : "advisory";
+    const tddTestGlobsRaw = parsed.tddTestGlobs;
+    const tddTestGlobs = validateStringArray(tddTestGlobsRaw, "tddTestGlobs", fullPath)
+        ?? ["**/*.test.*", "**/*.spec.*", "**/test/**"];
     const gitHookGuardsRaw = parsed.gitHookGuards;
     if (Object.prototype.hasOwnProperty.call(parsed, "gitHookGuards") &&
         typeof gitHookGuardsRaw !== "boolean") {
@@ -244,8 +254,9 @@ export async function readConfig(projectRoot) {
         version: parsed.version ?? CCLAW_VERSION,
         flowVersion: parsed.flowVersion ?? FLOW_VERSION,
         harnesses,
-        autoAdvance,
         promptGuardMode,
+        tddEnforcement,
+        tddTestGlobs,
         gitHookGuards,
         defaultTrack,
         languageRulePacks,

package/dist/constants.d.ts

@@ -4,9 +4,9 @@ export declare const RUNTIME_ROOT = ".cclaw";
 export declare const CCLAW_VERSION = "0.1.1";
 export declare const FLOW_VERSION = "1.0.0";
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/features", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
 export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".codex/commands/cc-*.md", ".codex/commands/cc.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
-export declare const UTILITY_COMMANDS: readonly ["learn", "next", "status"];
+export declare const UTILITY_COMMANDS: readonly ["learn", "next", "view", "status", "tree", "diff", "ops", "feature", "tdd-log", "retro", "archive", "rewind", "rewind-ack"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
 export type UtilityCommand = (typeof UTILITY_COMMANDS)[number];

package/dist/constants.js

@@ -15,6 +15,7 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/contexts`,
     `${RUNTIME_ROOT}/templates`,
     `${RUNTIME_ROOT}/artifacts`,
+    `${RUNTIME_ROOT}/features`,
     `${RUNTIME_ROOT}/state`,
     `${RUNTIME_ROOT}/runs`,
     `${RUNTIME_ROOT}/rules`,
@@ -50,7 +51,21 @@ export const COMMAND_FILE_ORDER = [
     "review",
     "ship"
 ];
-export const UTILITY_COMMANDS = ["learn", "next", "status"];
+export const UTILITY_COMMANDS = [
+    "learn",
+    "next",
+    "view",
+    "status",
+    "tree",
+    "diff",
+    "ops",
+    "feature",
+    "tdd-log",
+    "retro",
+    "archive",
+    "rewind",
+    "rewind-ack"
+];
 export const SUBAGENT_SKILL_FOLDERS = [
     "subagent-dev",
     "parallel-dispatch"

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

@@ -0,0 +1,2 @@
+export declare function archiveCommandContract(): string;
+export declare function archiveCommandSkillMarkdown(): string;

package/dist/content/archive-command.js

@@ -0,0 +1,98 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const ARCHIVE_SKILL_FOLDER = "flow-archive";
+const ARCHIVE_SKILL_NAME = "flow-archive";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function runsPath() {
+    return `${RUNTIME_ROOT}/runs`;
+}
+function activeArtifactsPath() {
+    return `${RUNTIME_ROOT}/artifacts`;
+}
+export function archiveCommandContract() {
+    return `# /cc-archive
+
+## Purpose
+
+Archive the active cclaw run from inside the harness flow (agent-first finish).
+
+This command removes the user-facing CLI gap: users can stay in \`/cc-*\` flow and
+finish with \`/cc-archive\` after ship + retro are complete.
+
+## HARD-GATE
+
+- Do not archive a shipped run when retro is still incomplete.
+- Do not manually move files between \`${activeArtifactsPath()}\` and \`${runsPath()}\`.
+- Use the archive runtime so state snapshots + manifest stay consistent.
+
+## Inputs
+
+\`/cc-archive [--name=<slug>] [--skip-retro --retro-reason=<text>]\`
+
+## Algorithm
+
+1. Read \`${flowStatePath()}\`.
+2. If ship is complete and \`retro.completedAt\` is absent:
+   - block with explicit instruction: run \`/cc-retro\` first.
+3. Build archive command:
+   - base: \`npx cclaw archive\`
+   - optional: \`--name=<slug>\`
+   - optional override: \`--skip-retro --retro-reason=<text>\`
+4. Execute archive command in project root.
+5. Surface result:
+   - archive id/path,
+   - reset stage (brainstorm/spec depending on track default),
+   - knowledge curation hint when threshold exceeded.
+
+## Output format
+
+\`\`\`
+cclaw archive
+  status: archived
+  run: <archive-id>
+  path: .cclaw/runs/<archive-id>
+  next: /cc <new-idea>
+\`\`\`
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${ARCHIVE_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function archiveCommandSkillMarkdown() {
+    return `---
+name: ${ARCHIVE_SKILL_NAME}
+description: "Archive the active cclaw run from harness flow and reset runtime safely."
+---
+
+# /cc-archive
+
+## HARD-GATE
+
+Never simulate archive by hand-editing runtime files. Always execute the archive
+runtime command so state snapshots and manifest generation stay atomic.
+
+## Protocol
+
+1. Read \`${flowStatePath()}\`:
+   - confirm whether ship is completed,
+   - check \`retro.completedAt\` for post-ship runs.
+2. If ship complete and retro incomplete -> stop and direct user to \`/cc-retro\`.
+3. Build shell command:
+   - \`npx cclaw archive\`
+   - append \`--name=<slug>\` when provided
+   - append \`--skip-retro --retro-reason=<text>\` only when user explicitly requests skip
+4. Run command from repo root.
+5. Relay key lines from output:
+   - archive destination under \`${runsPath()}\`
+   - flow reset confirmation
+   - knowledge curation recommendation
+
+## Validation
+
+- \`${runsPath()}\` contains a new archive folder.
+- \`${activeArtifactsPath()}\` is reset for the next run.
+- \`${flowStatePath()}\` is valid JSON and points to the initial stage.
+`;
+}

package/dist/content/contracts.js

@@ -36,7 +36,7 @@ ${schema.hardGate}
 ${hydrationLines}
 4. Stream \`.cclaw/knowledge.jsonl\` and apply relevant JSON-line entries (strict schema: type, trigger, action, confidence, domain, stage, created, project).
 5. Write stage output to ${writeStepPaths}.
-6. Do NOT copy artifacts into \`.cclaw/runs/\`; archival is handled only by \`cclaw archive\`.
+6. Do NOT copy artifacts into \`.cclaw/runs/\`; archival is handled by \`/cc-archive\` (agent-facing wrapper over archive runtime).
 
 ## Gates
 ${gateIds}

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

@@ -0,0 +1,2 @@
+export declare function diffCommandContract(): string;
+export declare function diffCommandSkillMarkdown(): string;

package/dist/content/diff-command.js

@@ -0,0 +1,83 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const DIFF_SKILL_FOLDER = "flow-diff";
+const DIFF_SKILL_NAME = "flow-diff";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function snapshotPath() {
+    return `${RUNTIME_ROOT}/state/flow-state.snapshot.json`;
+}
+export function diffCommandContract() {
+    return `# /cc-diff
+
+## Purpose
+
+Show a visual before/after diff map for flow-state progression.
+
+## HARD-GATE
+
+- Compare against \`${snapshotPath()}\` first; do not overwrite baseline before rendering.
+- If no snapshot exists, initialize baseline and report "baseline created" explicitly.
+
+## Algorithm
+
+1. Read current state from \`${flowStatePath()}\`.
+2. Read baseline from \`${snapshotPath()}\` (if missing -> create baseline from current state and stop).
+3. Compute deltas:
+   - stage transition (\`from -> to\`)
+   - completed stage additions/removals
+   - skipped stage additions/removals
+   - stale stage additions/removals
+   - current-stage gate \`passed\` and \`blocked\` changes
+4. Render a compact diff map (added \`+\`, removed \`-\`, changed \`->\`).
+5. Persist current state back to \`${snapshotPath()}\` as new baseline with \`capturedAt\`.
+
+## Diff Map Format
+
+\`\`\`
+cclaw flow diff
+  stage: design -> spec
+  completed: +design
+  stale: -design
+  gates(spec): +spec_contract_complete  -spec_open_questions_closed
+  blocked(spec): +spec_trace_matrix_missing
+\`\`\`
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${DIFF_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function diffCommandSkillMarkdown() {
+    return `---
+name: ${DIFF_SKILL_NAME}
+description: "Compare current flow-state against saved snapshot and render gate/stage deltas."
+---
+
+# /cc-diff
+
+## HARD-GATE
+
+Never lose baseline visibility: render deltas before writing a new snapshot.
+
+## Protocol
+
+1. Read \`${flowStatePath()}\`.
+2. Read \`${snapshotPath()}\`.
+3. If snapshot missing:
+   - write baseline snapshot from current state,
+   - print \`flow diff baseline created\`,
+   - stop.
+4. Build deltas for stage, completed/skipped/stale sets, and current-stage gate arrays.
+5. Print a compact diff map with explicit \`+\`, \`-\`, and \`->\` markers.
+6. Write updated snapshot with:
+   - \`capturedAt\` (ISO)
+   - \`state\` (full current flow-state object)
+
+## Validation
+
+- Diff output must be deterministic for identical states ("no changes").
+- Snapshot file stays valid JSON after every run.
+- Do not suppress removed values; removals are first-class evidence.
+`;
+}

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

@@ -0,0 +1,2 @@
+export declare function featureCommandContract(): string;
+export declare function featureCommandSkillMarkdown(): string;

package/dist/content/feature-command.js

@@ -0,0 +1,120 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const FEATURE_SKILL_FOLDER = "feature-workspaces";
+const FEATURE_SKILL_NAME = "feature-workspaces";
+function activeFeaturePath() {
+    return `${RUNTIME_ROOT}/state/active-feature.json`;
+}
+function featuresRoot() {
+    return `${RUNTIME_ROOT}/features`;
+}
+function runtimeArtifactsPath() {
+    return `${RUNTIME_ROOT}/artifacts`;
+}
+function runtimeStatePath() {
+    return `${RUNTIME_ROOT}/state`;
+}
+export function featureCommandContract() {
+    return `# /cc-feature
+
+## Purpose
+
+Manage multi-feature workspaces without flow-state/artifact collisions.
+
+The active runtime remains:
+- \`${runtimeArtifactsPath()}\` (active artifacts)
+- \`${runtimeStatePath()}\` (active state)
+
+Feature snapshots live under \`${featuresRoot()}/<feature-id>/\`.
+
+## HARD-GATE
+
+- Never overwrite another feature snapshot silently.
+- Before switching feature, snapshot the current active runtime first.
+- Keep \`${activeFeaturePath()}\` as the single source of "current feature".
+
+## Subcommands
+
+### \`/cc-feature status\`
+Show active feature id and snapshot location.
+
+### \`/cc-feature list\`
+List all feature ids in \`${featuresRoot()}/\` (directory names).
+
+### \`/cc-feature new <feature-id>\`
+Create \`${featuresRoot()}/<feature-id>/artifacts\` and \`${featuresRoot()}/<feature-id>/state\`.
+
+Optional flag:
+- \`--clone-active\`: clone current active runtime into the new feature snapshot.
+
+### \`/cc-feature switch <feature-id>\`
+1. Snapshot current active runtime into \`${featuresRoot()}/<active>/\`.
+2. Restore target snapshot from \`${featuresRoot()}/<feature-id>/\` into active runtime:
+   - \`${runtimeArtifactsPath()}\`
+   - \`${runtimeStatePath()}\` (preserve \`active-feature.json\`)
+3. Update \`${activeFeaturePath()}\` with \`activeFeature=<feature-id>\`.
+
+If the target snapshot is empty, initialize runtime as a fresh flow.
+
+## Output
+
+Always print:
+- active feature before
+- active feature after
+- whether snapshot/restore changed files
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${FEATURE_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function featureCommandSkillMarkdown() {
+    return `---
+name: ${FEATURE_SKILL_NAME}
+description: "Manage cclaw multi-feature workspaces (status/list/new/switch) while preserving active flow runtime."
+---
+
+# /cc-feature — Feature Workspace Manager
+
+## HARD-GATE
+
+Do not switch feature by editing only \`active-feature.json\`. A valid switch must snapshot current runtime and restore target runtime.
+
+## Paths
+
+- Active pointer: \`${activeFeaturePath()}\`
+- Feature snapshots: \`${featuresRoot()}/<feature-id>/\`
+- Active runtime artifacts: \`${runtimeArtifactsPath()}\`
+- Active runtime state: \`${runtimeStatePath()}\`
+
+## Protocol
+
+### status
+1. Read \`${activeFeaturePath()}\`.
+2. Print active feature id and its snapshot folder.
+
+### list
+1. Enumerate directories in \`${featuresRoot()}/\`.
+2. Mark the active one.
+
+### new <feature-id> [--clone-active]
+1. Validate \`feature-id\` (lowercase slug, letters/numbers/dashes).
+2. Create snapshot dirs:
+   - \`${featuresRoot()}/<feature-id>/artifacts\`
+   - \`${featuresRoot()}/<feature-id>/state\`
+3. If \`--clone-active\`: copy active runtime artifacts/state into the new snapshot.
+4. Do not change active feature unless the user explicitly requests switch.
+
+### switch <feature-id>
+1. Read current active feature id.
+2. Snapshot current runtime into current feature snapshot.
+3. Restore target snapshot into active runtime.
+4. Update \`${activeFeaturePath()}\`.
+5. Report stage/run after restore (\`flow-state.json\`).
+
+## Safety checks
+
+- If target feature does not exist: block and suggest \`/cc-feature new <id>\`.
+- If snapshot copy fails: abort switch, keep current active feature unchanged.
+- Preserve global pointer file \`active-feature.json\` when restoring state.
+`;
+}

package/dist/content/harnesses-doc.js

@@ -65,7 +65,18 @@ All harnesses receive the same utility commands:
 
 - \`/cc\` - flow entry and resume
 - \`/cc-next\` - stage progression
+- \`/cc-view\` - read-only router for status/tree/diff
 - \`/cc-learn\` - knowledge capture/lookup
+- \`/cc-status\` - read-only visual flow snapshot
+- \`/cc-tree\` - deep flow tree (stages, artifacts, stale markers)
+- \`/cc-diff\` - before/after flow-state diff map
+- \`/cc-ops\` - operations router for feature/tdd-log/retro/archive/rewind
+- \`/cc-feature\` - multi-feature workspace management
+- \`/cc-tdd-log\` - explicit RED/GREEN/REFACTOR evidence log
+- \`/cc-retro\` - mandatory retrospective gate before archive
+- \`/cc-archive\` - archive active run from harness flow
+- \`/cc-rewind\` - rewind flow and invalidate downstream stages
+- \`/cc-rewind-ack\` - clear stale stage markers after redo
 
 Stage order remains canonical:
 \`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship\`

package/dist/content/hooks.js

@@ -45,6 +45,7 @@ set -euo pipefail
 ${DETECT_ROOT}
 
 STATE_FILE="$ROOT/${RUNTIME_ROOT}/state/flow-state.json"
+ACTIVE_FEATURE_FILE="$ROOT/${RUNTIME_ROOT}/state/active-feature.json"
 CHECKPOINT_FILE="$ROOT/${RUNTIME_ROOT}/state/checkpoint.json"
 ACTIVITY_FILE="$ROOT/${RUNTIME_ROOT}/state/stage-activity.jsonl"
 SUGGESTION_MEMORY_FILE="$ROOT/${RUNTIME_ROOT}/state/suggestion-memory.json"
@@ -59,13 +60,16 @@ META_SKILL="$ROOT/${RUNTIME_ROOT}/skills/${META_SKILL_NAME}/SKILL.md"
 STAGE="none"
 COMPLETED="0"
 ACTIVE_RUN="none"
+ACTIVE_FEATURE="default"
 ACTIVE_CONTEXT_MODE="default"
+STALE_STAGES=""
 CONTEXT_MODE_NOTE=""
 if [ -f "$STATE_FILE" ]; then
   if command -v jq >/dev/null 2>&1; then
     STAGE=$(jq -r '.currentStage // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
     COMPLETED=$(jq -r '(.completedStages | length) // 0' "$STATE_FILE" 2>/dev/null || echo "0")
     ACTIVE_RUN=$(jq -r '.activeRunId // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
+    STALE_STAGES=$(jq -r '(.staleStages // {} | keys | join(", "))' "$STATE_FILE" 2>/dev/null || echo "")
   else
     if command -v python3 >/dev/null 2>&1; then
       STAGE=$(python3 - "$STATE_FILE" <<'PY'
@@ -115,6 +119,22 @@ except Exception:
     pass
 print(run)
 PY
+)
+      STALE_STAGES=$(python3 - "$STATE_FILE" <<'PY'
+import json
+import sys
+value = ""
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    stale = data.get("staleStages", {})
+    if isinstance(stale, dict):
+        keys = [k for k, v in stale.items() if isinstance(v, dict)]
+        value = ", ".join(keys)
+except Exception:
+    pass
+print(value)
+PY
 )
     else
       STAGE=$(grep -o '"currentStage"[[:space:]]*:[[:space:]]*"[^"]*"' "$STATE_FILE" 2>/dev/null | head -1 | sed 's/.*"\\([^"]*\\)"$/\\1/' || echo "none")
@@ -129,6 +149,28 @@ PY
   fi
 fi
 
+if [ -f "$ACTIVE_FEATURE_FILE" ]; then
+  if command -v jq >/dev/null 2>&1; then
+    ACTIVE_FEATURE=$(jq -r '.activeFeature // "default"' "$ACTIVE_FEATURE_FILE" 2>/dev/null || echo "default")
+  elif command -v python3 >/dev/null 2>&1; then
+    ACTIVE_FEATURE=$(python3 - "$ACTIVE_FEATURE_FILE" <<'PY'
+import json
+import sys
+feature = "default"
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    value = data.get("activeFeature")
+    if isinstance(value, str) and value:
+        feature = value
+except Exception:
+    pass
+print(feature)
+PY
+)
+  fi
+fi
+
 if [ -f "$CONTEXT_MODE_FILE" ]; then
   if command -v jq >/dev/null 2>&1; then
     ACTIVE_CONTEXT_MODE=$(jq -r '.activeMode // "default"' "$CONTEXT_MODE_FILE" 2>/dev/null || echo "default")
@@ -415,7 +457,7 @@ if [ -n "$ROUTING_MISSING" ]; then
 fi
 
 # --- Build context message ---
-CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN). Active artifacts: ${RUNTIME_ROOT}/artifacts/. Learnings: $LEARNINGS_COUNT entries."
+CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN, feature=$ACTIVE_FEATURE). Active artifacts: ${RUNTIME_ROOT}/artifacts/. Feature snapshots: ${RUNTIME_ROOT}/features/$ACTIVE_FEATURE/. Learnings: $LEARNINGS_COUNT entries."
 if [ -n "$VERSION_NOTE" ]; then
   CTX="$CTX
 $VERSION_NOTE"
@@ -452,6 +494,10 @@ if [ -n "$STAGE_SUGGESTION" ]; then
 $STAGE_SUGGESTION
 To disable suggestions persistently set ${RUNTIME_ROOT}/state/suggestion-memory.json -> enabled=false."
 fi
+if [ -n "$STALE_STAGES" ]; then
+  CTX="$CTX
+Stale stages pending acknowledgement: $STALE_STAGES (use /cc-rewind-ack <stage> after redo)."
+fi
 if [ -n "$KNOWLEDGE_DIGEST" ]; then
   CTX="$CTX
 Knowledge digest (top relevant entries):
@@ -696,7 +742,7 @@ if [ "$CHECKPOINT_WRITTEN" -eq 0 ]; then
   CHECKPOINT_NOTE="Checkpoint update failed. Review ${RUNTIME_ROOT}/state/checkpoint.json manually."
 fi
 
-RUN_SYNC_NOTE="Run metadata sync removed; active artifacts stay in ${RUNTIME_ROOT}/artifacts until cclaw archive."
+RUN_SYNC_NOTE="Run metadata sync removed; active artifacts stay in ${RUNTIME_ROOT}/artifacts until /cc-archive (or cclaw archive runtime)."
 
 # --- Escape for JSON ---
 ${ESCAPE_FN}

package/dist/content/learnings.d.ts

@@ -6,5 +6,3 @@ export declare const KNOWLEDGE_JSONL_FIELDS: readonly ["type", "trigger", "actio
 export declare function learnSkillMarkdown(): string;
 export declare function learnCommandContract(): string;
 export declare function selfImprovementBlock(stageName: string): string;
-export declare function learningsSearchPreamble(stage: string): string;
-export declare function learningsAgentsMdBlock(): string;