cclaw-cli 0.51.29 → 0.51.30

package/dist/content/templates.js

@@ -1410,7 +1410,7 @@ alwaysApply: true
 
 Before responding to coding work:
 1. Read \`.cclaw/state/flow-state.json\`.
-2. Start with \`/cc\` or continue with \`/cc-next\`.
+2. Start with \`/cc\` or continue with \`/cc\`.
 3. If no software-stage flow applies, respond normally.
 
 ## Stage Order
@@ -1431,7 +1431,7 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 ## Command Surface
 
 - \`/cc\` = entry and resume.
-- \`/cc-next\` = only progression path.
+- \`/cc\` = only progression path.
 - Knowledge capture and recall use the \`learnings\` skill when requested.
 
 ## Verification Discipline

package/dist/doctor.js

@@ -982,21 +982,17 @@ export async function doctorChecks(projectRoot, options = {}) {
         const content = await fs.readFile(agentsFile, "utf8");
         const hasMarkers = content.includes(CCLAW_MARKER_START) && content.includes(CCLAW_MARKER_END);
         const hasCcCommand = content.includes("/cc");
-        const hasCcNext = content.includes("/cc-next");
         const hasCcIdeate = content.includes("/cc-ideate");
-        const hasCcView = content.includes("/cc-view");
-        const hasCcFinish = content.includes("/cc-finish");
         const hasCcCancel = content.includes("/cc-cancel");
+        const omitsFinish = !content.includes("/cc-finish");
         const hasVerification = content.includes("Verification Discipline");
         const hasMinimalMarker = content.includes("intentionally minimal for cross-project use");
         const hasMetaSkillPointer = content.includes(".cclaw/skills/using-cclaw/SKILL.md");
         agentsBlockOk = hasMarkers
             && hasCcCommand
-            && hasCcNext
             && hasCcIdeate
-            && hasCcView
-            && hasCcFinish
             && hasCcCancel
+            && omitsFinish
             && hasVerification
             && hasMinimalMarker
             && hasMetaSkillPointer;
@@ -1006,7 +1002,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: agentsBlockOk,
         details: `${agentsFile} must contain the managed cclaw marker block with routing, verification, and minimal detail pointer`
     });
-    for (const cmd of ["start", "next", "ideate", "view", "finish", "cancel"]) {
+    for (const cmd of ["start", "next", "ideate", "view", "cancel"]) {
         const cmdPath = path.join(projectRoot, RUNTIME_ROOT, "commands", `${cmd}.md`);
         checks.push({
             name: `utility_command:${cmd}`,
@@ -1024,7 +1020,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         checks.push({
             name: `stage_command:${stage}`,
             ok: stageCommandOk,
-            details: `${cmdPath} must be a thin shim to ${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md and /cc-next`
+            details: `${cmdPath} must be a thin shim to ${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md and /cc`
         });
     }
     // Utility skills
@@ -1032,7 +1028,6 @@ export async function doctorChecks(projectRoot, options = {}) {
         ["learnings", "learnings"],
         ["flow-ideate", "flow-ideate"],
         ["flow-view", "flow-view"],
-        ["flow-finish", "flow-finish"],
         ["flow-cancel", "flow-cancel"],
         ["subagent-dev", "sdd"],
         ["parallel-dispatch", "parallel-agents"],
@@ -1270,7 +1265,7 @@ export async function doctorChecks(projectRoot, options = {}) {
             cursorRuleOk =
                 content.includes("cclaw-managed-cursor-workflow-rule") &&
                     content.includes(".cclaw/state/flow-state.json") &&
-                    content.includes("/cc-next");
+                    content.includes("/cc");
         }
         checks.push({
             name: "rules:cursor:workflow",

package/dist/flow-state.d.ts

@@ -33,7 +33,7 @@ export interface RetroState {
  * Ship closeout substate machine.
  *
  * After ship completes, cclaw auto-chains retro → compound → archive.
- * Each step is interruptible: `/cc-next` reads `shipSubstate` and resumes
+ * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.

package/dist/flow-state.js

@@ -6,7 +6,7 @@ export const FLOW_STATE_SCHEMA_VERSION = 1;
  * Ship closeout substate machine.
  *
  * After ship completes, cclaw auto-chains retro → compound → archive.
- * Each step is interruptible: `/cc-next` reads `shipSubstate` and resumes
+ * Each step is interruptible: `/cc` reads `shipSubstate` and resumes
  * from the correct step even across sessions.
  *
  * - `idle` — ship not complete, or closeout not yet started.

package/dist/harness-adapters.d.ts

@@ -32,7 +32,7 @@ export type SubagentFallback =
  *   directories under a skills root (Codex CLI ≥0.89, Jan 2026). cclaw
  *   writes `<commandDir>/<skillName>/SKILL.md` and the agent invokes it
  *   either via `/use <skillName>` or via automatic description matching
- *   when the user's text mentions `/cc`, `/cc-next`, etc.
+ *   when the user's text mentions `/cc`, `/cc-ideate`, or `/cc-cancel`.
  */
 export type ShimKind = "command" | "skill";
 export interface HarnessAdapter {
@@ -47,7 +47,7 @@ export interface HarnessAdapter {
      * Root directory where cclaw writes `/cc*` entry points.
      *
      * - For `shimKind: "command"` this is the directory containing flat
-     *   markdown files (`<commandDir>/cc.md`, `<commandDir>/cc-next.md`, …).
+     *   markdown files (`<commandDir>/cc.md`, `<commandDir>/cc-ideate.md`, …).
      * - For `shimKind: "skill"` this is the skills root that contains
      *   per-skill subdirectories (`<commandDir>/<skillName>/SKILL.md`).
      */

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",
@@ -29,20 +21,6 @@ const UTILITY_SHIMS = [
         skillFolder: "flow-ideate",
         commandFile: "ideate.md"
     },
-    {
-        fileName: "cc-view.md",
-        skillName: "cc-view",
-        command: "view",
-        skillFolder: "flow-view",
-        commandFile: "view.md"
-    },
-    {
-        fileName: "cc-finish.md",
-        skillName: "cc-finish",
-        command: "finish",
-        skillFolder: "flow-finish",
-        commandFile: "finish.md"
-    },
     {
         fileName: "cc-cancel.md",
         skillName: "cc-cancel",
@@ -61,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 = {
@@ -343,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()}
@@ -372,11 +342,8 @@ 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-finish\` | **Successful closeout.** Archives a completed run after strict ship closeout gates. |
 | \`/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
@@ -384,8 +351,7 @@ 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. Use \`/cc-finish\` for completed runs and \`/cc-cancel\` for cancelled/abandoned runs.
-\`/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
 
@@ -406,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\`, \`/cc-finish\`, and \`/cc-cancel\`
-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.
@@ -484,14 +449,8 @@ 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 "finish":
-            return "This is a successful closeout utility, not a flow stage. It archives a completed run after ship closeout gates pass and records completed disposition semantics.";
         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:
@@ -515,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
@@ -569,14 +484,8 @@ 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 "finish":
-            return `Finish a completed cclaw run. Use when the user types \`/cc-finish\` or asks to finish, complete, close out, or archive a successful run. Runs cclaw archive with completed disposition after strict ship closeout gates.`;
         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:
@@ -660,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 {
@@ -679,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.js

@@ -10,7 +10,6 @@ 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 { finishCommandContract, finishCommandSkillMarkdown } from "./content/finish-command.js";
 import { cancelCommandContract, cancelCommandSkillMarkdown } from "./content/cancel-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
@@ -102,6 +101,7 @@ const DEPRECATED_AGENT_FILES = [
 ];
 const DEPRECATED_COMMAND_FILES = [
     "learn.md",
+    "finish.md",
     "status.md",
     "tree.md",
     "diff.md",
@@ -114,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"],
@@ -454,7 +455,6 @@ 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-finish", "SKILL.md"), finishCommandSkillMarkdown());
     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());
@@ -519,7 +519,6 @@ 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", "finish.md"), finishCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "cancel.md"), cancelCommandContract());
     for (const stage of FLOW_STAGES) {
         await writeFileSafe(runtimePath(projectRoot, "commands", `${stage}.md`), stageCommandShimMarkdown(stage));
@@ -1062,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;
@@ -1079,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;

package/dist/internal/advance-stage.js

@@ -1422,7 +1422,7 @@ async function runRewind(projectRoot, args, io) {
         nextActions: [
             `Re-run ${args.targetStage} stage work and update its artifact evidence.`,
             `Then run cclaw internal rewind --ack ${args.targetStage}.`,
-            "Continue with /cc-next after the stale marker is acknowledged."
+            "Continue with /cc after the stale marker is acknowledged."
         ]
     };
     await appendRewindLog(projectRoot, payload);