cclaw-cli 0.51.29 → 0.55.2

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 { IRON_LAWS } 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) {
@@ -16,32 +15,11 @@ 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",
-        command: "ideate",
-        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-idea.md",
+        skillName: "cc-idea",
+        command: "idea",
+        skillFolder: "flow-idea",
+        commandFile: "idea.md"
     },
     {
         fileName: "cc-cancel.md",
@@ -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 = {
@@ -193,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>; 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\".";
+            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 `npx cclaw-cli sync`; 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; 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\".";
+            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 `npx cclaw-cli sync`; record scheduled/launched/acknowledged/completed events with spanId+dispatchId before claiming fulfillmentMode: \"isolated\".";
     }
 }
 /**
@@ -322,6 +292,35 @@ export function harnessesByTier() {
         return tierOrder[harnessTier(a)] - tierOrder[harnessTier(b)];
     });
 }
+function ironLawsAgentsMdBlock() {
+    const enforcedLawIds = new Set([
+        "stop-clean-or-handoff",
+        "review-coverage-complete-before-ship"
+    ]);
+    const enforcedRows = IRON_LAWS
+        .filter((law) => enforcedLawIds.has(law.id))
+        .map((law) => `| \`${law.id}\` | ${law.rule} | ${law.enforcement} |`)
+        .join("\n");
+    const advisoryRows = IRON_LAWS
+        .filter((law) => !enforcedLawIds.has(law.id))
+        .map((law) => {
+        const appliesTo = law.appliesTo === "all" ? "all stages" : law.appliesTo.join(", ");
+        return `- \`${law.id}\` (applies to: ${appliesTo})`;
+    })
+        .join("\n");
+    return `### Iron Laws
+
+These rules are always-on. The hook-enforced runtime laws are:
+
+| ID | Rule | Enforced by |
+|---|---|---|
+${enforcedRows}
+
+Advisory laws are stage-owned through each stage's HARD-GATE block:
+
+${advisoryRows}
+`;
+}
 function agentsMdBlock() {
     return `${CCLAW_MARKER_START}
 ## Cclaw — Workflow Adapter
@@ -343,7 +342,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 +371,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-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\` | **Entry point.** No args = resume or progress current flow. With prompt = classify task and start the right flow. |
+| \`/cc-idea\` | **Idea mode.** Generates a ranked repo-improvement backlog before implementation. |
 | \`/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 +380,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 +401,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-idea\`, 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-idea\` / \`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.
@@ -420,9 +414,9 @@ Codex CLI v0.114+ (Mar 2026) **does** expose lifecycle hooks via
 \`.codex/hooks.json\`, gated by the \`[features] codex_hooks = true\` flag
 in \`~/.codex/config.toml\`. cclaw generates \`.codex/hooks.json\` on
 sync; if the feature flag is off, hooks are inert and cclaw's
-session-start rehydration simply does not fire. Run \`cclaw doctor\` to
+session-start rehydration simply does not fire. Run \`npx cclaw-cli sync\` to
 see if the flag is missing. \`.codex/commands/*\` is still unused by
-Codex CLI and is removed on every sync. Run \`cclaw doctor --explain\` for
+Codex CLI and is removed on every sync. Run \`npx cclaw-cli sync\` for
 hook coverage details (Bash-only \`PreToolUse\`/\`PostToolUse\`; other events are full).
 ${CCLAW_MARKER_END}`;
 }
@@ -484,14 +478,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":
+        case "idea":
             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 +503,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 +513,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 "idea":
+            return `Read-only repo-improvement idea mode for cclaw. Use when the user types \`/cc-idea\` or asks to "scan the repo for TODOs/tech debt", "generate a backlog", "brainstorm improvement ideas", or wants a ranked list of candidate ideas before committing to a single flow. Does not mutate \`.cclaw/state/flow-state.json\`.`;
         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:
@@ -609,7 +547,7 @@ under \`.agents/skills/${skillSlug}/\` so the user can either:
 
 Lifecycle hooks **are** available in Codex CLI v0.114+ (behind the
 \`[features] codex_hooks = true\` flag in \`~/.codex/config.toml\`) and
-cclaw installs a matching \`.codex/hooks.json\`; run \`cclaw doctor --explain\`
+cclaw installs a matching \`.codex/hooks.json\`; run \`npx cclaw-cli sync\`
 for the current hook surface and limitations.
 
 ## Protocol
@@ -633,7 +571,7 @@ for the current hook surface and limitations.
   unavailable or disabled, and then include non-empty \`evidenceRefs\`.
 - Codex's \`PreToolUse\` / \`PostToolUse\` hooks currently only intercept
   the \`Bash\` tool. \`Write\`, \`Edit\`, \`WebSearch\`, and MCP tool calls
-  are **not** gated by hooks — use \`cclaw doctor --explain\` for what cclaw
+  are **not** gated by hooks — use \`npx cclaw-cli sync\` for what cclaw
   substitutes with in-turn agent steps for those call classes.
 - Codex's \`SessionStart\` matcher only supports \`startup|resume\`. Claude
   and Cursor also fire on \`clear\` and \`compact\`, so mid-session
@@ -660,9 +598,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 +614,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);
+}