cclaw-cli 0.12.0 → 0.13.0

package/dist/harness-adapters.js

@@ -11,6 +11,68 @@ function escapeRegExp(value) {
 const RUNTIME_AGENTS_BLOCK_SOURCE = `${escapeRegExp(CCLAW_MARKER_START)}[\\s\\S]*?${escapeRegExp(CCLAW_MARKER_END)}`;
 const RUNTIME_AGENTS_BLOCK_PATTERN = new RegExp(RUNTIME_AGENTS_BLOCK_SOURCE, "u");
 const RUNTIME_AGENTS_BLOCK_GLOBAL_PATTERN = new RegExp(RUNTIME_AGENTS_BLOCK_SOURCE, "gu");
+const UTILITY_SHIMS = [
+    {
+        fileName: "cc-next.md",
+        command: "next",
+        skillFolder: "flow-next-step",
+        commandFile: "next.md"
+    },
+    {
+        fileName: "cc-learn.md",
+        command: "learn",
+        skillFolder: "learnings",
+        commandFile: "learn.md"
+    },
+    {
+        fileName: "cc-status.md",
+        command: "status",
+        skillFolder: "flow-status",
+        commandFile: "status.md"
+    },
+    {
+        fileName: "cc-tree.md",
+        command: "tree",
+        skillFolder: "flow-tree",
+        commandFile: "tree.md"
+    },
+    {
+        fileName: "cc-diff.md",
+        command: "diff",
+        skillFolder: "flow-diff",
+        commandFile: "diff.md"
+    },
+    {
+        fileName: "cc-feature.md",
+        command: "feature",
+        skillFolder: "feature-workspaces",
+        commandFile: "feature.md"
+    },
+    {
+        fileName: "cc-tdd-log.md",
+        command: "tdd-log",
+        skillFolder: "tdd-cycle-log",
+        commandFile: "tdd-log.md"
+    },
+    {
+        fileName: "cc-retro.md",
+        command: "retro",
+        skillFolder: "flow-retro",
+        commandFile: "retro.md"
+    },
+    {
+        fileName: "cc-rewind.md",
+        command: "rewind",
+        skillFolder: "flow-rewind",
+        commandFile: "rewind.md"
+    },
+    {
+        fileName: "cc-rewind-ack.md",
+        command: "rewind-ack",
+        skillFolder: "flow-rewind",
+        commandFile: "rewind-ack.md"
+    }
+];
 export const HARNESS_ADAPTERS = {
     claude: {
         id: "claude",
@@ -98,13 +160,21 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 5. Contextual utility skills.
 6. Training priors.
 
-### Commands (3 total)
+### Commands
 
 | Command | Purpose |
 |---|---|
 | \`/cc\` | **Entry point.** No args = resume current stage. With prompt = classify task and start the right flow. |
 | \`/cc-next\` | **Progression.** Advances to the next stage when current is complete. |
 | \`/cc-learn\` | **Cross-cutting.** Capture or review project knowledge (append-only JSONL). |
+| \`/cc-status\` | **Read-only.** Visual snapshot with progress bar, gate delta, and delegations. |
+| \`/cc-tree\` | **Read-only.** Deep flow tree for stages, artifacts, and stale markers. |
+| \`/cc-diff\` | **Delta map.** Compare current flow-state with saved baseline snapshot. |
+| \`/cc-feature\` | **Workspace.** Manage active feature snapshots for parallel tracks. |
+| \`/cc-tdd-log\` | **Evidence.** Record RED/GREEN/REFACTOR cycle events for enforcement. |
+| \`/cc-retro\` | **Learning gate.** Mandatory retrospective before archive after ship. |
+| \`/cc-rewind\` | **Recovery.** Rewind flow to an earlier stage and invalidate downstream work. |
+| \`/cc-rewind-ack\` | **Recovery.** Clear stale-stage markers after redo. |
 
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
 \`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.
@@ -213,9 +283,9 @@ export async function syncHarnessShims(projectRoot, harnesses) {
         const commandDir = path.join(projectRoot, adapter.commandDir);
         await ensureDir(commandDir);
         await writeFileSafe(path.join(commandDir, "cc.md"), utilityShimContent(harness, "cc", "flow-start", "start.md"));
-        await writeFileSafe(path.join(commandDir, "cc-next.md"), utilityShimContent(harness, "next", "flow-next-step", "next.md"));
-        await writeFileSafe(path.join(commandDir, "cc-learn.md"), utilityShimContent(harness, "learn", "learnings", "learn.md"));
-        await writeFileSafe(path.join(commandDir, "cc-status.md"), utilityShimContent(harness, "status", "flow-status", "status.md"));
+        for (const shim of UTILITY_SHIMS) {
+            await writeFileSafe(path.join(commandDir, shim.fileName), utilityShimContent(harness, shim.command, shim.skillFolder, shim.commandFile));
+        }
     }
     await syncAgentFiles(projectRoot);
     await syncAgentsMd(projectRoot, harnesses);

package/dist/install.js

@@ -10,6 +10,12 @@ import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { statusCommandContract, statusCommandSkillMarkdown } from "./content/status-command.js";
+import { treeCommandContract, treeCommandSkillMarkdown } from "./content/tree-command.js";
+import { diffCommandContract, diffCommandSkillMarkdown } from "./content/diff-command.js";
+import { featureCommandContract, featureCommandSkillMarkdown } from "./content/feature-command.js";
+import { tddLogCommandContract, tddLogCommandSkillMarkdown } from "./content/tdd-log-command.js";
+import { retroCommandContract, retroCommandSkillMarkdown } from "./content/retro-command.js";
+import { rewindAcknowledgeCommandContract, rewindCommandContract, rewindCommandSkillMarkdown } from "./content/rewind-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, preCompactScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
@@ -197,6 +203,12 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-start", "SKILL.md"), startCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-status", "SKILL.md"), statusCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-tree", "SKILL.md"), treeCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-diff", "SKILL.md"), diffCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "feature-workspaces", "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-rewind", "SKILL.md"), rewindCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "parallel-dispatch", "SKILL.md"), parallelAgentsSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
@@ -250,6 +262,13 @@ async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "start.md"), startCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "status.md"), statusCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "tree.md"), treeCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "diff.md"), diffCommandContract());
+    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", "rewind.md"), rewindCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "rewind-ack.md"), rewindAcknowledgeCommandContract());
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -550,7 +569,10 @@ async function writeHooks(projectRoot, config) {
     await writeFileSafe(path.join(hooksDir, "prompt-guard.sh"), promptGuardScript({
         strictMode: config.promptGuardMode === "strict"
     }));
-    await writeFileSafe(path.join(hooksDir, "workflow-guard.sh"), workflowGuardScript());
+    await writeFileSafe(path.join(hooksDir, "workflow-guard.sh"), workflowGuardScript({
+        tddEnforcementMode: config.tddEnforcement ?? "advisory",
+        tddTestGlobs: config.tddTestGlobs
+    }));
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
     const opencodePluginSource = opencodePluginJs();
     await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
@@ -760,13 +782,13 @@ Drop this section if no hard rule applies. Keep it crisp:
 async function ensureSessionStateFiles(projectRoot) {
     const stateDir = runtimePath(projectRoot, "state");
     await ensureDir(stateDir);
+    const flow = await readFlowState(projectRoot);
     const activityPath = path.join(stateDir, "stage-activity.jsonl");
     if (!(await exists(activityPath))) {
         await writeFileSafe(activityPath, "");
     }
     const checkpointPath = path.join(stateDir, "checkpoint.json");
     if (!(await exists(checkpointPath))) {
-        const flow = await readFlowState(projectRoot);
         const initialCheckpoint = {
             stage: flow.currentStage,
             runId: flow.activeRunId,
@@ -800,6 +822,17 @@ async function ensureSessionStateFiles(projectRoot) {
     if (!(await exists(preambleLogPath))) {
         await writeFileSafe(preambleLogPath, "");
     }
+    const tddCycleLogPath = path.join(stateDir, "tdd-cycle-log.jsonl");
+    if (!(await exists(tddCycleLogPath))) {
+        await writeFileSafe(tddCycleLogPath, "");
+    }
+    const flowSnapshotPath = path.join(stateDir, "flow-state.snapshot.json");
+    if (!(await exists(flowSnapshotPath))) {
+        await writeFileSafe(flowSnapshotPath, `${JSON.stringify({
+            capturedAt: new Date().toISOString(),
+            state: flow
+        }, null, 2)}\n`);
+    }
 }
 async function writeRulebook(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "rules", "RULES.md"), RULEBOOK_MARKDOWN);

package/dist/policy.js

@@ -90,6 +90,27 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },
+        { file: runtimeFile("commands/status.md"), needle: "bar:", name: "utility_command:status:visual_bar" },
+        { file: runtimeFile("commands/status.md"), needle: "/cc-tree · /cc-diff", name: "utility_command:status:tree_diff_link" },
+        { file: runtimeFile("commands/tree.md"), needle: "## Algorithm", name: "utility_command:tree:algorithm" },
+        { file: runtimeFile("skills/flow-tree/SKILL.md"), needle: "## Protocol", name: "utility_skill:tree:protocol" },
+        { file: runtimeFile("skills/flow-tree/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:tree:hard_gate" },
+        { file: runtimeFile("commands/diff.md"), needle: "## Algorithm", name: "utility_command:diff:algorithm" },
+        { file: runtimeFile("skills/flow-diff/SKILL.md"), needle: "## Protocol", name: "utility_skill:diff:protocol" },
+        { file: runtimeFile("skills/flow-diff/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:diff:hard_gate" },
+        { file: runtimeFile("commands/feature.md"), needle: "## Subcommands", name: "utility_command:feature:subcommands" },
+        { file: runtimeFile("skills/feature-workspaces/SKILL.md"), needle: "## Protocol", name: "utility_skill:feature:protocol" },
+        { file: runtimeFile("skills/feature-workspaces/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:feature:hard_gate" },
+        { file: runtimeFile("commands/tdd-log.md"), needle: "## Subcommands", name: "utility_command:tdd_log:subcommands" },
+        { file: runtimeFile("skills/tdd-cycle-log/SKILL.md"), needle: "## Protocol", name: "utility_skill:tdd_log:protocol" },
+        { file: runtimeFile("skills/tdd-cycle-log/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:tdd_log:hard_gate" },
+        { file: runtimeFile("commands/retro.md"), needle: "## Algorithm", name: "utility_command:retro:algorithm" },
+        { file: runtimeFile("skills/flow-retro/SKILL.md"), needle: "## Protocol", name: "utility_skill:retro:protocol" },
+        { file: runtimeFile("skills/flow-retro/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:retro:hard_gate" },
+        { file: runtimeFile("commands/rewind.md"), needle: "## Algorithm", name: "utility_command:rewind:algorithm" },
+        { file: runtimeFile("commands/rewind-ack.md"), needle: "## Algorithm", name: "utility_command:rewind_ack:algorithm" },
+        { file: runtimeFile("skills/flow-rewind/SKILL.md"), needle: "## Protocol", name: "utility_skill:rewind:protocol" },
+        { file: runtimeFile("skills/flow-rewind/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:rewind:hard_gate" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Status Contract", name: "utility_skill:sdd:status_contract" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "Implementer", name: "utility_skill:sdd:implementer_template" },
@@ -158,6 +179,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("hooks/prompt-guard.sh"), needle: "write_to_cclaw_runtime", name: "hooks:guard:risky_write_advisory" },
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
         { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_jump_", name: "hooks:workflow_guard:stage_jump_reason" },
+        { file: runtimeFile("hooks/workflow-guard.sh"), needle: "tdd_write_without_open_red", name: "hooks:workflow_guard:tdd_red_first" },
         { file: runtimeFile("hooks/context-monitor.sh"), needle: "remaining is", name: "hooks:context:threshold_warning" },
         { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" },
         { file: runtimeFile("hooks/session-start.sh"), needle: "Knowledge digest", name: "hooks:session_start:knowledge_digest" },

package/dist/runs.d.ts

@@ -22,6 +22,7 @@ export interface ArchiveRunResult {
     archivePath: string;
     archivedAt: string;
     featureName: string;
+    activeFeature: string;
     resetState: FlowState;
     snapshottedStateFiles: string[];
     /** Knowledge curation hint: total active entries + soft threshold (50). */
@@ -31,20 +32,46 @@ export interface ArchiveRunResult {
         overThreshold: boolean;
         knowledgePath: string;
     };
+    retro: {
+        required: boolean;
+        completed: boolean;
+        skipped: boolean;
+        skipReason?: string;
+        compoundEntries: number;
+    };
 }
 export interface ArchiveManifest {
     version: 1;
     archiveId: string;
     archivedAt: string;
     featureName: string;
+    activeFeature: string;
     sourceRunId: string;
     sourceCurrentStage: FlowStage;
     sourceCompletedStages: FlowStage[];
     snapshottedStateFiles: string[];
+    retro: ArchiveRunResult["retro"];
+}
+export interface RewindRunOptions {
+    to: FlowStage;
+    reason?: string;
+}
+export interface RewindRunResult {
+    rewindId: string;
+    from: FlowStage;
+    to: FlowStage;
+    invalidatedStages: FlowStage[];
+    staleArtifacts: string[];
+    archivePath: string;
+    nextState: FlowState;
 }
 interface EnsureRunSystemOptions {
     createIfMissing?: boolean;
 }
+export interface ArchiveRunOptions {
+    skipRetro?: boolean;
+    skipRetroReason?: string;
+}
 export declare class CorruptFlowStateError extends Error {
     readonly statePath: string;
     readonly quarantinedPath: string;
@@ -54,7 +81,12 @@ export declare function readFlowState(projectRoot: string): Promise<FlowState>;
 export declare function writeFlowState(projectRoot: string, state: FlowState, options?: WriteFlowStateOptions): Promise<void>;
 export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
-export declare function archiveRun(projectRoot: string, featureName?: string): Promise<ArchiveRunResult>;
+export declare function archiveRun(projectRoot: string, featureName?: string, options?: ArchiveRunOptions): Promise<ArchiveRunResult>;
+export declare function rewindRun(projectRoot: string, options: RewindRunOptions): Promise<RewindRunResult>;
+export declare function acknowledgeStaleStage(projectRoot: string, stage: FlowStage): Promise<{
+    acknowledged: boolean;
+    remaining: FlowStage[];
+}>;
 /**
  * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
  * non-empty line that parses as JSON with the required `type` field belonging to the