cclaw-cli 0.51.28 → 0.51.30

package/dist/harness-adapters.js

@@ -1,11 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { RUNTIME_ROOT, STAGE_TO_SKILL_FOLDER } from "./constants.js";
+import { RUNTIME_ROOT } from "./constants.js";
 import { conversationLanguagePolicyMarkdown } from "./content/language-policy.js";
 import { CCLAW_AGENTS, agentMarkdown } from "./content/core-agents.js";
 import { ironLawsAgentsMdBlock } from "./content/iron-laws.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
-import { FLOW_STAGES } from "./types.js";
 export const CCLAW_MARKER_START = "<!-- cclaw-start -->";
 export const CCLAW_MARKER_END = "<!-- cclaw-end -->";
 function escapeRegExp(value) {
@@ -15,13 +14,6 @@ const RUNTIME_AGENTS_BLOCK_SOURCE = `${escapeRegExp(CCLAW_MARKER_START)}[\\s\\S]
 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",
-        skillName: "cc-next",
-        command: "next",
-        skillFolder: "flow-next-step",
-        commandFile: "next.md"
-    },
     {
         fileName: "cc-ideate.md",
         skillName: "cc-ideate",
@@ -30,11 +22,11 @@ const UTILITY_SHIMS = [
         commandFile: "ideate.md"
     },
     {
-        fileName: "cc-view.md",
-        skillName: "cc-view",
-        command: "view",
-        skillFolder: "flow-view",
-        commandFile: "view.md"
+        fileName: "cc-cancel.md",
+        skillName: "cc-cancel",
+        command: "cancel",
+        skillFolder: "flow-cancel",
+        commandFile: "cancel.md"
     }
 ];
 /** Skill-kind shim name for the root `/cc` entry point. */
@@ -47,25 +39,17 @@ const LEGACY_CODEX_SKILL_PREFIX = "cclaw-cc";
  * harness command directories so `/cc-learn` etc. do not linger.
  */
 const LEGACY_HARNESS_SHIMS = ["cc-learn.md"];
-function stageShimFileName(stage) {
-    return `cc-${stage}.md`;
-}
-function stageShimSkillName(stage) {
-    return `cc-${stage}`;
-}
 export function harnessShimFileNames() {
     return [
         "cc.md",
-        ...UTILITY_SHIMS.map((shim) => shim.fileName),
-        ...FLOW_STAGES.map((stage) => stageShimFileName(stage))
+        ...UTILITY_SHIMS.map((shim) => shim.fileName)
     ];
 }
 /** Skill folder names cclaw writes under `<commandDir>` for skill-kind harnesses. */
 export function harnessShimSkillNames() {
     return [
         ENTRY_SHIM_SKILL_NAME,
-        ...UTILITY_SHIMS.map((shim) => shim.skillName),
-        ...FLOW_STAGES.map((stage) => stageShimSkillName(stage))
+        ...UTILITY_SHIMS.map((shim) => shim.skillName)
     ];
 }
 export const HARNESS_ADAPTERS = {
@@ -179,9 +163,9 @@ export function harnessDispatchSurface(harnessId) {
         case "cursor":
             return "Use Cursor Subagent/Task with a generic subagent_type (explore for read-only mapping, generalPurpose for broader work, shell/browser-use when specifically needed) and paste the cclaw role prompt; record fulfillmentMode: \"generic-dispatch\" with evidenceRefs.";
         case "opencode":
-            return "Use OpenCode subagents: invoke the generated .opencode/agents/<agent>.md agent via Task or @<agent>; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
+            return "Use OpenCode subagents: invoke the generated .opencode/agents/<agent>.md agent via Task or @<agent>; if agents or plugin registration are missing, run `cclaw sync` and check opencode.json(.c) plugin registration with `cclaw doctor --explain`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
         case "codex":
-            return "Use Codex native subagents: ask Codex to spawn the generated .codex/agents/<agent>.toml agent(s) by name; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
+            return "Use Codex native subagents: ask Codex to spawn the generated .codex/agents/<agent>.toml agent(s) by name; if hooks are inert, set `[features] codex_hooks = true` in ~/.codex/config.toml or rerun init/sync repair, then `cclaw doctor --explain`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
     }
 }
 /**
@@ -329,7 +313,7 @@ Treat quality as a hard requirement, not style preference:
 
 Before responding to a coding request:
 1. Read \`.cclaw/state/flow-state.json\` for the current stage.
-2. Use \`/cc\` to start or \`/cc-next\` to continue the flow.
+2. Use \`/cc\` to start, resume, or continue the flow.
 3. If no stage applies, respond normally.
 
 ${ironLawsAgentsMdBlock()}
@@ -358,18 +342,16 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 
 | 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\` | **Entry point.** No args = resume or progress current flow. With prompt = classify task and start the right flow. |
 | \`/cc-ideate\` | **Ideate mode.** Generates a ranked repo-improvement backlog before implementation. |
-| \`/cc-view\` | **Read-only router.** Unified entry for status/tree/diff views. |
+| \`/cc-cancel\` | **Non-completion closeout.** Archives a cancelled/abandoned run with a required reason. |
 
 Knowledge capture and curation run automatically as part of stage completion
 protocols via the internal \`learnings\` skill — no user-facing command.
 Reusable entries land in \`.cclaw/knowledge.jsonl\` as strict JSONL with
 \`type\`, \`trigger\`, \`action\`, and \`origin_run\` metadata.
 
-**Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship, then closeout: retro > compound > archive.
-\`/cc-next\` loads the right stage skill automatically and also drives post-ship closeout. Gates must pass before handoff.
+**Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship, then closeout: retro > compound > archive. Use \`/cc\` to keep moving through normal work and post-ship closeout; use \`/cc-cancel\` for cancelled/abandoned runs. Gates must pass before handoff.
 
 ### Verification Discipline
 
@@ -390,12 +372,11 @@ If the same approach fails three times in a row (same command, same finding, sam
 ### Codex users
 
 OpenAI Codex CLI has **no native \`/cc\` slash command** (custom prompts
-were deprecated in v0.89, Jan 2026). The \`/cc\`, \`/cc-next\`,
-\`/cc-ideate\`, \`/cc-view\` tokens above describe intent — in
-Codex they map onto skills cclaw installs at
+were deprecated in v0.89, Jan 2026). The \`/cc\`, \`/cc-ideate\`, and
+\`/cc-cancel\` tokens above describe intent — in Codex they map onto skills cclaw installs at
 \`.agents/skills/cc*/SKILL.md\`. Activate one of two ways:
 
-- Type \`/use cc\` (or \`cc-next\`, etc.) at Codex's prompt.
+- Type \`/use cc\` (or \`cc-ideate\` / \`cc-cancel\`) at Codex's prompt.
 - Type \`/cc …\` as plain text — Codex matches the skill \`description\`
   frontmatter (which spells out the token verbatim) and loads the right
   skill body automatically.
@@ -468,12 +449,10 @@ function utilityShimBehavior(command) {
     switch (command) {
         case "cc":
             return "This is the entry command, not a flow stage. It may initialize or resume flow state after confirmation.";
-        case "next":
-            return "This is the progression command, not a flow stage. It may advance stages and post-ship closeout through managed helpers.";
         case "ideate":
             return "This is an ideation command, not a flow stage. It may write ideation artifacts/seeds but does not advance flow state.";
-        case "view":
-            return "This is a read-only view command, not a flow stage. It never mutates flow state.";
+        case "cancel":
+            return "This is a non-completion closeout utility, not a flow stage. It requires a reason and archives cancelled or abandoned work without presenting it as completed.";
         default:
             return "This is a utility command, not a flow stage.";
     }
@@ -495,50 +474,6 @@ Load and execute:
 ${utilityShimBehavior(command)}
 `;
 }
-function stageShimContent(harness, stage) {
-    const shimName = stageShimSkillName(stage);
-    const skillPath = `${RUNTIME_ROOT}/skills/${STAGE_TO_SKILL_FOLDER[stage]}/SKILL.md`;
-    return `---
-name: ${shimName}
-description: Generated shim for ${harness}. Flow stage pointer; normal advancement uses /cc-next.
-source: generated-by-cclaw
----
-
-# cclaw ${stage}
-
-This is a thin compatibility shim for the \`${stage}\` flow stage.
-
-Load and follow the authoritative stage skill:
-
-- \`${skillPath}\`
-
-Normal stage resume and advancement uses \`/cc-next\`. Use \`/cc-next\` to read
-\`.cclaw/state/flow-state.json\`, select the active stage, and advance only after
-that stage's gates pass. Do not duplicate the stage protocol here.
-`;
-}
-function codexStageSkillMarkdown(stage) {
-    const skillName = stageShimSkillName(stage);
-    const skillPath = `${RUNTIME_ROOT}/skills/${STAGE_TO_SKILL_FOLDER[stage]}/SKILL.md`;
-    return `---
-name: ${skillName}
-description: Thin cclaw stage shim for /cc-${stage}. Load ${skillPath}; normal stage resume and advancement uses /cc-next.
-source: generated-by-cclaw
----
-
-# cclaw /cc-${stage} (Codex adapter)
-
-This is a thin compatibility shim for the \`${stage}\` flow stage.
-
-Load and follow the authoritative stage skill:
-
-- \`${skillPath}\`
-
-Normal stage resume and advancement uses \`/cc-next\`. Use \`/cc-next\` to read
-\`.cclaw/state/flow-state.json\`, select the active stage, and advance only after
-that stage's gates pass. Do not duplicate the stage protocol here.
-`;
-}
 /**
  * Frontmatter `description` that triggers the skill when the user types any
  * of the classic cclaw slash-tokens. Codex's skill matcher runs on the skill
@@ -549,12 +484,10 @@ function codexSkillDescription(command) {
     switch (command) {
         case "cc":
             return `Entry point for the cclaw track-aware workflow ending in ship plus auto-closeout (retro → compound → archive). Use whenever the user types \`/cc\`, \`/cclaw\`, or asks to "start the flow", "begin cclaw", "kick off the workflow", "classify this task", or wants to start/resume a non-trivial software change. No args = resume the active stage from \`.cclaw/state/flow-state.json\`. With a prompt = classify and pick a track (quick/medium/standard).`;
-        case "next":
-            return `Advance the cclaw flow to the next stage or post-ship closeout substate. Use when the user types \`/cc-next\` or asks to "move to the next stage", "continue the flow", "advance cclaw", "progress the workflow", or when the current stage skill reports completion and gates have passed.`;
         case "ideate":
             return `Read-only repo-improvement ideate mode for cclaw. Use when the user types \`/cc-ideate\` or asks to "ideate", "scan the repo for TODOs/tech debt", "generate a backlog", or wants a ranked list of candidate ideas before committing to a single flow. Does not mutate \`.cclaw/state/flow-state.json\`.`;
-        case "view":
-            return `Read-only router for cclaw flow views. Use when the user types \`/cc-view\`, \`/cc-view status\`, \`/cc-view tree\`, \`/cc-view diff\`, or asks to "show cclaw status", "show the flow tree", "diff flow state", or wants a snapshot without mutation.`;
+        case "cancel":
+            return `Cancel or abandon the active cclaw run. Use when the user types \`/cc-cancel\` or asks to cancel, abandon, stop, discard, or reset an unfinished run. Requires a reason and archives with cancelled/abandoned disposition.`;
         default:
             return `Generated cclaw skill for ${command}.`;
     }
@@ -636,9 +569,6 @@ async function writeCommandKindShims(commandDir, harness) {
     for (const shim of UTILITY_SHIMS) {
         await writeFileSafe(path.join(commandDir, shim.fileName), utilityShimContent(harness, shim.command, shim.skillFolder, shim.commandFile));
     }
-    for (const stage of FLOW_STAGES) {
-        await writeFileSafe(path.join(commandDir, stageShimFileName(stage)), stageShimContent(harness, stage));
-    }
     for (const legacy of LEGACY_HARNESS_SHIMS) {
         const legacyPath = path.join(commandDir, legacy);
         try {
@@ -655,9 +585,6 @@ async function writeSkillKindShims(commandDir) {
     for (const shim of UTILITY_SHIMS) {
         await writeFileSafe(path.join(commandDir, shim.skillName, "SKILL.md"), codexSkillMarkdown(shim.command, shim.skillName, shim.skillFolder, shim.commandFile));
     }
-    for (const stage of FLOW_STAGES) {
-        await writeFileSafe(path.join(commandDir, stageShimSkillName(stage), "SKILL.md"), codexStageSkillMarkdown(stage));
-    }
 }
 /**
  * Legacy codex surfaces cclaw wrote before v0.39.0 that Codex CLI never

package/dist/harness-selection.d.ts

@@ -0,0 +1,31 @@
+import { type CliContext, type HarnessId } from "./types.js";
+export type HarnessSelectionAnswer = {
+    kind: "accept";
+} | {
+    kind: "all";
+} | {
+    kind: "toggle";
+    indexes: number[];
+} | {
+    kind: "invalid";
+    message: string;
+};
+export interface HarnessChecklistState {
+    choices: readonly HarnessId[];
+    selected: readonly HarnessId[];
+    cursor: number;
+    message?: string;
+}
+export type HarnessChecklistOutcome = "confirm" | "cancel";
+export interface HarnessChecklistUpdate {
+    state: HarnessChecklistState;
+    outcome?: HarnessChecklistOutcome;
+}
+export declare function parseHarnessSelectionAnswer(raw: string, total?: 4): HarnessSelectionAnswer;
+export declare function createHarnessChecklistState(selected: readonly HarnessId[], choices?: readonly HarnessId[]): HarnessChecklistState;
+export declare function updateHarnessChecklistState(state: HarnessChecklistState, key: string): HarnessChecklistUpdate;
+export declare function promptHarnessSelectionChecklist(defaults: {
+    harnesses: HarnessId[];
+    detectedHarnesses?: HarnessId[];
+    currentHarnesses?: HarnessId[];
+}, ctx: CliContext, label?: string): Promise<HarnessId[]>;

package/dist/harness-selection.js

@@ -0,0 +1,214 @@
+import { createInterface } from "node:readline/promises";
+import process from "node:process";
+import { HARNESS_ADAPTERS } from "./harness-adapters.js";
+import { HARNESS_IDS } from "./types.js";
+export function parseHarnessSelectionAnswer(raw, total = HARNESS_IDS.length) {
+    const answer = raw.trim().toLowerCase();
+    if (answer.length === 0)
+        return { kind: "accept" };
+    if (answer === "all")
+        return { kind: "all" };
+    if (answer === "none") {
+        return { kind: "invalid", message: "Zero harnesses is not supported. Select at least one harness." };
+    }
+    const parts = answer.split(",").map((part) => part.trim()).filter(Boolean);
+    const indexes = parts.map((part) => Number.parseInt(part, 10));
+    if (indexes.some((value) => !Number.isInteger(value) || value < 1 || value > total)) {
+        return { kind: "invalid", message: `Invalid selection. Use numbers 1-${total}, comma-separated.` };
+    }
+    return { kind: "toggle", indexes };
+}
+export function createHarnessChecklistState(selected, choices = HARNESS_IDS) {
+    const validSelected = choices.filter((harness) => selected.includes(harness));
+    return {
+        choices,
+        selected: validSelected.length > 0 ? validSelected : choices.slice(),
+        cursor: 0
+    };
+}
+function moveCursor(state, delta) {
+    const next = (state.cursor + delta + state.choices.length) % state.choices.length;
+    return { ...state, cursor: next, message: undefined };
+}
+function toggleCurrent(state) {
+    const current = state.choices[state.cursor];
+    if (!current)
+        return state;
+    const selected = state.selected.includes(current)
+        ? state.selected.filter((harness) => harness !== current)
+        : [...state.selected, current];
+    return { ...state, selected: state.choices.filter((harness) => selected.includes(harness)), message: undefined };
+}
+export function updateHarnessChecklistState(state, key) {
+    if (key === "\u0003" || key === "\u001b") {
+        return { state: { ...state, message: "Cancelled." }, outcome: "cancel" };
+    }
+    if (key === "\u001b[A" || key === "k" || key === "K") {
+        return { state: moveCursor(state, -1) };
+    }
+    if (key === "\u001b[B" || key === "j" || key === "J") {
+        return { state: moveCursor(state, 1) };
+    }
+    if (key === " ") {
+        return { state: toggleCurrent(state) };
+    }
+    if (key === "a" || key === "A") {
+        return { state: { ...state, selected: state.choices.slice(), message: undefined } };
+    }
+    if (key === "\r" || key === "\n") {
+        if (state.selected.length === 0) {
+            return { state: { ...state, message: "Select at least one harness." } };
+        }
+        return { state, outcome: "confirm" };
+    }
+    return { state };
+}
+function selectedHarnessPreview(harnesses) {
+    return harnesses.length > 0 ? harnesses.join(", ") : "none";
+}
+function harnessLabel(harness) {
+    const adapter = HARNESS_ADAPTERS[harness];
+    const tier = adapter ? `${adapter.reality.declaredSupport}, ${adapter.capabilities.hookSurface} hooks` : "supported";
+    return `${harness} (${tier})`;
+}
+function renderChecklist(state, defaults, ctx, label) {
+    const detected = new Set(defaults.detectedHarnesses ?? []);
+    const current = new Set(defaults.currentHarnesses ?? []);
+    const defaultSet = new Set(defaults.defaultHarnesses ?? []);
+    ctx.stdout.write("\x1b[2J\x1b[H");
+    ctx.stdout.write(`${label}\n`);
+    ctx.stdout.write(`Detected: ${selectedHarnessPreview(defaults.detectedHarnesses ?? [])}\n`);
+    ctx.stdout.write(`Current: ${selectedHarnessPreview(defaults.currentHarnesses ?? [])}\n`);
+    ctx.stdout.write("Use Up/Down or k/j to move, Space to toggle, a to select all, Enter to confirm, Esc to cancel.\n\n");
+    state.choices.forEach((harness, index) => {
+        const adapter = HARNESS_ADAPTERS[harness];
+        const markers = [
+            detected.has(harness) ? "detected" : "",
+            current.has(harness) ? "current" : "",
+            defaultSet.has(harness) ? "default" : ""
+        ].filter(Boolean).join(", ");
+        const pointer = index === state.cursor ? ">" : " ";
+        const checked = state.selected.includes(harness) ? "x" : " ";
+        ctx.stdout.write(`${pointer} [${checked}] ${harnessLabel(harness)} -> ${adapter.commandDir}${markers ? ` (${markers})` : ""}\n`);
+    });
+    if (state.message) {
+        ctx.stdout.write(`\n${state.message}\n`);
+    }
+}
+function rawModeAvailable(ctx) {
+    return Boolean(process.stdin.isTTY &&
+        ctx.stdout.isTTY &&
+        typeof process.stdin.setRawMode === "function");
+}
+async function promptHarnessSelectionRaw(defaults, ctx, label) {
+    let state = createHarnessChecklistState(defaults.harnesses);
+    const input = process.stdin;
+    const wasRaw = Boolean(input.isRaw);
+    let settle;
+    let rejectSelection;
+    const done = new Promise((resolve, reject) => {
+        settle = resolve;
+        rejectSelection = reject;
+    });
+    const onData = (chunk) => {
+        const key = chunk.toString("utf8");
+        const update = updateHarnessChecklistState(state, key);
+        state = update.state;
+        renderChecklist(state, {
+            detectedHarnesses: defaults.detectedHarnesses,
+            currentHarnesses: defaults.currentHarnesses,
+            defaultHarnesses: defaults.harnesses
+        }, ctx, label);
+        if (update.outcome === "confirm") {
+            settle?.(HARNESS_IDS.filter((harness) => state.selected.includes(harness)));
+        }
+        else if (update.outcome === "cancel") {
+            rejectSelection?.(new Error("Harness selection cancelled."));
+        }
+    };
+    try {
+        input.setRawMode?.(true);
+        input.resume();
+        input.on("data", onData);
+        renderChecklist(state, {
+            detectedHarnesses: defaults.detectedHarnesses,
+            currentHarnesses: defaults.currentHarnesses,
+            defaultHarnesses: defaults.harnesses
+        }, ctx, label);
+        return await done;
+    }
+    finally {
+        input.off("data", onData);
+        input.setRawMode?.(wasRaw);
+        if (!wasRaw)
+            input.pause();
+        ctx.stdout.write("\n");
+    }
+}
+async function promptHarnessSelectionText(defaults, ctx, label) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: ctx.stdout
+    });
+    const defaultSet = new Set(defaults.harnesses);
+    const selected = new Set(defaults.harnesses.length > 0 ? defaults.harnesses : HARNESS_IDS);
+    const detected = new Set(defaults.detectedHarnesses ?? []);
+    const current = new Set(defaults.currentHarnesses ?? []);
+    const printMenu = () => {
+        ctx.stdout.write(`\n${label}\n`);
+        ctx.stdout.write(`Detected: ${selectedHarnessPreview(defaults.detectedHarnesses ?? [])}\n`);
+        ctx.stdout.write(`Current: ${selectedHarnessPreview(defaults.currentHarnesses ?? [])}\n`);
+        ctx.stdout.write("Supported harnesses and target paths:\n");
+        HARNESS_IDS.forEach((harness, index) => {
+            const adapter = HARNESS_ADAPTERS[harness];
+            const markers = [
+                detected.has(harness) ? "detected" : "",
+                current.has(harness) ? "current" : "",
+                defaultSet.has(harness) ? "default" : ""
+            ].filter(Boolean).join(", ");
+            const checked = selected.has(harness) ? "x" : " ";
+            ctx.stdout.write(`  ${index + 1}. [${checked}] ${harnessLabel(harness)} -> ${adapter.commandDir}${markers ? ` (${markers})` : ""}\n`);
+        });
+        ctx.stdout.write("Enter numbers to toggle (for example 1,3), 'all', or press Enter to accept.\n");
+    };
+    try {
+        while (true) {
+            printMenu();
+            const answer = await rl.question(`Selected [${[...selected].join(",") || "select at least one"}]: `);
+            const parsedAnswer = parseHarnessSelectionAnswer(answer);
+            if (parsedAnswer.kind === "accept") {
+                if (selected.size === 0) {
+                    ctx.stdout.write("Select at least one harness.\n");
+                    continue;
+                }
+                return HARNESS_IDS.filter((harness) => selected.has(harness));
+            }
+            if (parsedAnswer.kind === "all") {
+                HARNESS_IDS.forEach((harness) => selected.add(harness));
+                continue;
+            }
+            if (parsedAnswer.kind === "invalid") {
+                ctx.stdout.write(`${parsedAnswer.message}\n`);
+                continue;
+            }
+            for (const index of parsedAnswer.indexes) {
+                const harness = HARNESS_IDS[index - 1];
+                if (!harness)
+                    continue;
+                if (selected.has(harness))
+                    selected.delete(harness);
+                else
+                    selected.add(harness);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptHarnessSelectionChecklist(defaults, ctx, label = "Harness selection") {
+    if (rawModeAvailable(ctx)) {
+        return promptHarnessSelectionRaw(defaults, ctx, label);
+    }
+    return promptHarnessSelectionText(defaults, ctx, label);
+}

package/dist/install.d.ts

@@ -4,8 +4,11 @@ export interface InitOptions {
     harnesses?: HarnessId[];
     track?: FlowTrack;
 }
+export interface SyncOptions {
+    harnesses?: HarnessId[];
+}
 export declare function initCclaw(options: InitOptions): Promise<void>;
-export declare function syncCclaw(projectRoot: string): Promise<void>;
+export declare function syncCclaw(projectRoot: string, options?: SyncOptions): Promise<void>;
 /**
  * Refresh generated files in `.cclaw/` without touching user-authored
  * artifacts, state, or custom config keys. Only the `version` + `flowVersion`

package/dist/install.js

@@ -10,6 +10,7 @@ import { stageCommandShimMarkdown } from "./content/stage-command.js";
 import { ideateCommandContract, ideateCommandSkillMarkdown } from "./content/ideate-command.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { viewCommandContract, viewCommandSkillMarkdown } from "./content/view-command.js";
+import { cancelCommandContract, cancelCommandSkillMarkdown } from "./content/cancel-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { ironLawRuntimeDocument, ironLawsSkillMarkdown } from "./content/iron-laws.js";
@@ -26,6 +27,7 @@ import { SUBAGENT_CONTEXT_SKILLS } from "./content/subagent-context-skills.js";
 import { CCLAW_AGENTS } from "./content/core-agents.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
+import { ManagedResourceSession, setActiveManagedResourceSession } from "./managed-resources.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
 import { HARNESS_ADAPTERS, harnessShimFileNames, syncHarnessShims, removeCclawFromAgentsMd } from "./harness-adapters.js";
 import { validateHookDocument } from "./hook-schema.js";
@@ -99,6 +101,7 @@ const DEPRECATED_AGENT_FILES = [
 ];
 const DEPRECATED_COMMAND_FILES = [
     "learn.md",
+    "finish.md",
     "status.md",
     "tree.md",
     "diff.md",
@@ -111,6 +114,7 @@ const DEPRECATED_COMMAND_FILES = [
     "rewind.md"
 ];
 const DEPRECATED_SKILL_FILES = [
+    ["flow-finish", "SKILL.md"],
     ["flow-ops", "SKILL.md"],
     ["tdd-cycle-log", "SKILL.md"],
     ["flow-retro", "SKILL.md"],
@@ -451,6 +455,7 @@ async function writeSkills(projectRoot, config) {
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-ideate", "SKILL.md"), ideateCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-start", "SKILL.md"), startCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-view", "SKILL.md"), viewCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-cancel", "SKILL.md"), cancelCommandSkillMarkdown());
     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());
@@ -514,6 +519,7 @@ async function writeEntryCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "ideate.md"), ideateCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "view.md"), viewCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "cancel.md"), cancelCommandContract());
     for (const stage of FLOW_STAGES) {
         await writeFileSafe(runtimePath(projectRoot, "commands", `${stage}.md`), stageCommandShimMarkdown(stage));
     }
@@ -1055,13 +1061,8 @@ async function cleanLegacyArtifacts(projectRoot) {
 }
 async function cleanStaleFiles(projectRoot) {
     const expectedShimFiles = new Set(harnessShimFileNames());
+    const expectedShimSkills = new Set(harnessShimFileNames().map((fileName) => fileName.replace(/\.md$/u, "")));
     for (const adapter of Object.values(HARNESS_ADAPTERS)) {
-        // Skill-kind shims (Codex) live in per-skill directories, not flat
-        // markdown files, so the regex-based stale sweep below would never
-        // match them anyway. The legacy `.codex/commands/` cleanup happens in
-        // `cleanupLegacyCodexSurfaces` inside syncHarnessShims().
-        if (adapter.shimKind === "skill")
-            continue;
         const commandDir = path.join(projectRoot, adapter.commandDir);
         if (!(await exists(commandDir)))
             continue;
@@ -1072,6 +1073,16 @@ async function cleanStaleFiles(projectRoot) {
         catch {
             entries = [];
         }
+        if (adapter.shimKind === "skill") {
+            for (const entry of entries) {
+                if (!/^cc(?:-.*)?$/u.test(entry))
+                    continue;
+                if (expectedShimSkills.has(entry))
+                    continue;
+                await fs.rm(path.join(commandDir, entry), { recursive: true, force: true });
+            }
+            continue;
+        }
         for (const entry of entries) {
             if (!/^cc(?:-.*)?\.md$/u.test(entry))
                 continue;
@@ -1085,6 +1096,8 @@ async function cleanStaleFiles(projectRoot) {
 }
 async function materializeRuntime(projectRoot, config, forceStateReset, operation = "sync") {
     const sentinelPath = await writeInitSentinel(projectRoot, operation);
+    const managedSession = await ManagedResourceSession.create({ projectRoot, operation });
+    setActiveManagedResourceSession(managedSession);
     try {
         const harnesses = config.harnesses;
         await ensureStructure(projectRoot);
@@ -1105,14 +1118,21 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
         await syncHarnessShims(projectRoot, harnesses);
         await writeCursorWorkflowRule(projectRoot, harnesses);
         await ensureGitignore(projectRoot);
+        await managedSession.commit();
         await fs.unlink(sentinelPath).catch(() => undefined);
     }
     catch (error) {
         // Leave the sentinel in place so doctor can surface the interrupted run.
         throw error;
     }
+    finally {
+        setActiveManagedResourceSession(null);
+    }
 }
 export async function initCclaw(options) {
+    if (options.harnesses !== undefined && options.harnesses.length === 0) {
+        throw new Error("Select at least one harness.");
+    }
     const baseConfig = createDefaultConfig(options.harnesses, options.track);
     // Best-effort auto-detect: a Node project gets `typescript`, a Go module
     // gets `go`, etc. Skipped entirely when the project root has no manifests.
@@ -1127,7 +1147,10 @@ export async function initCclaw(options) {
     await writeConfig(options.projectRoot, config, { mode: "minimal" });
     await materializeRuntime(options.projectRoot, config, true, "init");
 }
-export async function syncCclaw(projectRoot) {
+export async function syncCclaw(projectRoot, options = {}) {
+    if (options.harnesses !== undefined && options.harnesses.length === 0) {
+        throw new Error("Select at least one harness.");
+    }
     const configExists = await exists(configPath(projectRoot));
     let config = await readConfig(projectRoot);
     if (!configExists) {
@@ -1138,11 +1161,21 @@ export async function syncCclaw(projectRoot) {
         // Fall back to the previous default (config.harnesses) if no markers
         // are found so brand-new projects still bootstrap cleanly.
         const detected = await detectHarnesses(projectRoot);
-        const harnesses = detected.length > 0 ? detected : config.harnesses;
+        const harnesses = options.harnesses ?? (detected.length > 0 ? detected : config.harnesses);
         const defaultConfig = createDefaultConfig(harnesses);
         await writeConfig(projectRoot, defaultConfig);
         config = defaultConfig;
     }
+    else if (options.harnesses !== undefined) {
+        config = {
+            ...config,
+            harnesses: options.harnesses
+        };
+        await writeConfig(projectRoot, config, {
+            mode: "minimal",
+            advancedKeysPresent: await detectAdvancedKeys(projectRoot)
+        });
+    }
     await materializeRuntime(projectRoot, config, false, "sync");
 }
 /**
@@ -1156,8 +1189,12 @@ export async function syncCclaw(projectRoot) {
  * minimal — advanced knobs are never silently added.
  */
 export async function upgradeCclaw(projectRoot) {
+    const configExists = await exists(configPath(projectRoot));
     const advancedKeysPresent = await detectAdvancedKeys(projectRoot);
-    const existing = await readConfig(projectRoot);
+    const detectedHarnesses = configExists ? [] : await detectHarnesses(projectRoot);
+    const existing = configExists
+        ? await readConfig(projectRoot)
+        : createDefaultConfig(detectedHarnesses.length > 0 ? detectedHarnesses : undefined);
     const upgraded = {
         ...existing,
         version: CCLAW_VERSION,
@@ -1332,7 +1369,7 @@ export async function uninstallCclaw(projectRoot) {
     try {
         const entries = await fs.readdir(codexSkillsRoot);
         for (const entry of entries) {
-            if (/^(?:cclaw-)?cc(?:-(?:next|view|ops|ideate|brainstorm|scope|design|spec|plan|tdd|review|ship))?$/u.test(entry)) {
+            if (/^(?:cclaw-)?cc(?:-(?:next|view|finish|cancel|ops|ideate|brainstorm|scope|design|spec|plan|tdd|review|ship))?$/u.test(entry)) {
                 await fs.rm(path.join(codexSkillsRoot, entry), { recursive: true, force: true });
             }
         }