@vincemakes/kiso-code 0.1.20 → 0.1.22

package/dist/resume.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 手感批 B4 (pure move) — resume: the RECOVERY flow (Area 2/7). The body
+ * moved verbatim from index.ts.
+ */
+import type { AgentSession } from "@vincemakes/kiso-runtime";
+import { type LineInput } from "./state.js";
+/**
+ * Resume = the RECOVERY flow (Area 2/7): uncertain executions are decided,
+ * the interrupted run is continued via session.resume() — never faked with
+ * a new prompt. An optional prompt afterwards starts a genuinely new turn.
+ * E 组: SIGINT aborts the run being resumed; every exit path closes the
+ * session store so no lock is left behind.
+ */
+export declare function resume(session: AgentSession, prompt: string | undefined, faux: boolean, input: LineInput): Promise<void>;

package/dist/resume.js

@@ -0,0 +1,104 @@
+/**
+ * 手感批 B4 (pure move) — resume: the RECOVERY flow (Area 2/7). The body
+ * moved verbatim from index.ts.
+ */
+import { kUnit } from "@vincemakes/kiso-tui";
+import { getMode } from "./mode.js";
+import { agentModel, dock } from "./state.js";
+import { pendingAsk, resolveUncertains } from "./trust-ui.js";
+import { failOnFauxExhaustion } from "./faux-glue.js";
+import { consumeRun, estimateCtxRatio, startStatusSpinner } from "./chat.js";
+/**
+ * Resume = the RECOVERY flow (Area 2/7): uncertain executions are decided,
+ * the interrupted run is continued via session.resume() — never faked with
+ * a new prompt. An optional prompt afterwards starts a genuinely new turn.
+ * E 组: SIGINT aborts the run being resumed; every exit path closes the
+ * session store so no lock is left behind.
+ */
+export async function resume(session, prompt, faux, input) {
+    let currentRun = null;
+    let cancelled = false;
+    let turnNo = 0;
+    // v3 §03: the two-state status bar (see chat — same shapes).
+    let runUsage = { in: null, out: null, cache: null, known: false };
+    let runGlyph = "▖";
+    let runStart = Date.now();
+    const statusCb = (u, ctx) => {
+        runUsage = u;
+        if (!dock.active)
+            return;
+        const pct = Number.isFinite(ctx) ? Math.round((1 - ctx) * 100) : null;
+        const out = runUsage.out !== null ? ` ↓ ${kUnit(runUsage.out)} tokens` : "";
+        dock.setStatus(`${runGlyph} working ${Math.max(1, Math.round((Date.now() - runStart) / 1000))}s${out} · esc to interrupt · ctx left ~${pct}%`);
+    };
+    const paintIdle = () => {
+        if (!dock.active)
+            return;
+        const ratio = estimateCtxRatio(session);
+        const pct = Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
+        dock.setStatus(`▸ ${getMode()} · /mode to switch · ${agentModel} · ctx left ~${pct}%`);
+    };
+    const withRun = async (run) => {
+        currentRun = run;
+        runStart = Date.now();
+        runUsage = { in: null, out: null, cache: null, known: false };
+        const stopSpinner = startStatusSpinner((g) => {
+            runGlyph = g;
+            statusCb(runUsage, estimateCtxRatio(session));
+        });
+        try {
+            turnNo += 1;
+            const last = await consumeRun(session, run, input, turnNo, faux, null, statusCb);
+            failOnFauxExhaustion(last, faux, input);
+        }
+        finally {
+            stopSpinner();
+            paintIdle();
+            currentRun = null;
+        }
+    };
+    input.onSigint(() => {
+        if (currentRun) {
+            // 八: Ctrl+C cancels the pending question AND the run.
+            console.log("\n[aborting run]");
+            pendingAsk?.();
+            currentRun.abort();
+        }
+        else if (!cancelled) {
+            // 第四轮(对抗): also unblock a pending startup question — the
+            // readline close alone would leave ask() hanging forever.
+            // 第五轮(P2-2): the cancellation is recorded so the recovery is
+            // NOT started afterwards — Ctrl+C exits cleanly.
+            cancelled = true;
+            console.log("\n[exit requested]");
+            pendingAsk?.();
+            input.close();
+        }
+    });
+    input.onEot(() => {
+        if (!currentRun && !cancelled && input.line() === "") {
+            cancelled = true;
+            console.log("\n[exit requested]");
+            input.close();
+        }
+    });
+    input.onEscape(() => {
+        if (currentRun) {
+            console.log("\n[aborting run]");
+            pendingAsk?.();
+            currentRun.abort();
+        }
+    });
+    try {
+        await resolveUncertains(session, input, () => cancelled);
+        if (!cancelled) {
+            await withRun(session.resume());
+            if (prompt !== undefined && prompt !== "") {
+                await withRun(session.run(prompt));
+            }
+        }
+    }
+    finally {
+        input.close();
+    }
+}

package/dist/state.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 手感批 B4 — the CLI's shared process state. The module split (dispatch/
+ * chat/resume/trust-ui/faux-glue) is a PURE MOVE: every piece that more
+ * than one module touches lives here as a live ESM binding. index.ts
+ * creates the mutable ones (setBody / setAgentModel / setExtensionLists);
+ * the moved modules read and mutate at call time.
+ */
+import { Dock, type Body } from "@vincemakes/kiso-tui";
+import type { KisoExtension } from "@vincemakes/kiso-runtime";
+/** 发现#11: KISO_HOME is the ONE root — every default path derives from
+ *  it (sessions, trust, extensions, mcp config, skills). The dedicated
+ *  env vars (KISO_EXTENSIONS_DIR / KISO_MCP_CONFIG / KISO_SKILLS_DIR)
+ *  still override their own path; nothing hard-codes ~/.kiso anymore. */
+export declare function kisoHome(): string;
+export declare function sessionsDir(): string;
+/** E1: the extension scan directory — KISO_EXTENSIONS_DIR overrides. */
+export declare function extensionsDir(): string;
+/**
+ * v2c — the interactive input source. TTYs use the raw-mode Editor (the
+ * self-drawn input row — width-aware, the CJK-drift root cause retired,
+ * editor.ts); everything else keeps readline exactly as v2b (pipe bytes
+ * unchanged). ask()/chat()/resume() talk to this, never to a concrete
+ * source.
+ */
+export interface LineInput {
+    onLine(cb: (line: string) => void): void;
+    onSigint(cb: () => void): void;
+    onEot(cb: () => void): void;
+    onEscape(cb: () => void): void;
+    question(query: string, cb: (answer: string) => void): void;
+    cancelQuestion(): void;
+    emitLine(line: string): void;
+    line(): string;
+    clearLine(): void;
+    prompt(): void;
+    close(): void;
+    readonly closed: Promise<void>;
+}
+/** v2b: the bottom-anchored UI — docked only on a color TTY; pipes and
+ *  NO_COLOR stay the v2a line mode byte-for-byte. Created at load, like
+ *  the pre-split module-scope const. */
+export declare const dock: Dock;
+/** v2d: the body renderer — the ONE writer of the stdout scroll region
+ *  (the frozen area + the active tail). Pipes run it in passthrough (the
+ *  v2b/v2c line-mode bytes, byte-for-byte). Created in main; closed on
+ *  every exit path. */
+export declare let body: Body;
+export declare function setBody(value: Body): void;
+/** v2d: body output routes through the cell renderer — the single writer.
+ *  bodyLog adds the trailing newline; internal newlines are preserved. */
+export declare function bodyLog(text: string): void;
+/** The model name for the status bar — set by makeAgent. */
+export declare let agentModel: string;
+export declare function setAgentModel(value: string): void;
+/** E1: the extensions loaded by makeAgent — their names feed the banner. */
+export declare let loadedExtensions: readonly KisoExtension[];
+/** E1: the USER-level extensions alone — the banner's unmarked part (E3:
+ *  loadedExtensions later includes the project-level ones too). */
+export declare let userExtensions: readonly KisoExtension[];
+/** E3: the PROJECT-level extensions (loaded after the trust gate) — the
+ *  banner distinguishes them from the user-level ones. */
+export declare let projectExtensions: readonly KisoExtension[];
+export declare function setExtensionLists(user: readonly KisoExtension[], project: readonly KisoExtension[], loaded: readonly KisoExtension[]): void;
+/** E3: temp artifacts of the mcp/skills merge — removed on exit. */
+export declare const mergedTempPaths: string[];
+/** The CLI's own version — read from the package.json next to the build. */
+export declare const VERSION: string;
+/** 十: a question cancelled by Ctrl+C — NEVER the empty string, which is a
+ *  real user answer (the empty line). The empty answer and the cancellation
+ *  are distinct facts. */
+export declare const CANCELLED: unique symbol;

package/dist/state.js

@@ -0,0 +1,78 @@
+/**
+ * 手感批 B4 — the CLI's shared process state. The module split (dispatch/
+ * chat/resume/trust-ui/faux-glue) is a PURE MOVE: every piece that more
+ * than one module touches lives here as a live ESM binding. index.ts
+ * creates the mutable ones (setBody / setAgentModel / setExtensionLists);
+ * the moved modules read and mutate at call time.
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Dock } from "@vincemakes/kiso-tui";
+/** 发现#11: KISO_HOME is the ONE root — every default path derives from
+ *  it (sessions, trust, extensions, mcp config, skills). The dedicated
+ *  env vars (KISO_EXTENSIONS_DIR / KISO_MCP_CONFIG / KISO_SKILLS_DIR)
+ *  still override their own path; nothing hard-codes ~/.kiso anymore. */
+export function kisoHome() {
+    return process.env.KISO_HOME ?? join(homedir(), ".kiso");
+}
+export function sessionsDir() {
+    return join(kisoHome(), "sessions");
+}
+/** E1: the extension scan directory — KISO_EXTENSIONS_DIR overrides. */
+export function extensionsDir() {
+    return process.env.KISO_EXTENSIONS_DIR ?? join(kisoHome(), "extensions");
+}
+/** v2b: the bottom-anchored UI — docked only on a color TTY; pipes and
+ *  NO_COLOR stay the v2a line mode byte-for-byte. Created at load, like
+ *  the pre-split module-scope const. */
+export const dock = new Dock();
+/** v2d: the body renderer — the ONE writer of the stdout scroll region
+ *  (the frozen area + the active tail). Pipes run it in passthrough (the
+ *  v2b/v2c line-mode bytes, byte-for-byte). Created in main; closed on
+ *  every exit path. */
+export let body;
+export function setBody(value) {
+    body = value;
+}
+/** v2d: body output routes through the cell renderer — the single writer.
+ *  bodyLog adds the trailing newline; internal newlines are preserved. */
+export function bodyLog(text) {
+    body.raw(text.split("\n"));
+}
+/** The model name for the status bar — set by makeAgent. */
+export let agentModel = "faux";
+export function setAgentModel(value) {
+    agentModel = value;
+}
+/** E1: the extensions loaded by makeAgent — their names feed the banner. */
+export let loadedExtensions = [];
+/** E1: the USER-level extensions alone — the banner's unmarked part (E3:
+ *  loadedExtensions later includes the project-level ones too). */
+export let userExtensions = [];
+/** E3: the PROJECT-level extensions (loaded after the trust gate) — the
+ *  banner distinguishes them from the user-level ones. */
+export let projectExtensions = [];
+export function setExtensionLists(user, project, loaded) {
+    userExtensions = user;
+    projectExtensions = project;
+    loadedExtensions = loaded;
+}
+/** E3: temp artifacts of the mcp/skills merge — removed on exit. */
+export const mergedTempPaths = [];
+/** The CLI's own version — read from the package.json next to the build. */
+export const VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"));
+        return pkg.version ?? "?";
+    }
+    catch {
+        // a packed CLI without a readable package.json still works
+        return "?";
+    }
+})();
+/** 十: a question cancelled by Ctrl+C — NEVER the empty string, which is a
+ *  real user answer (the empty line). The empty answer and the cancellation
+ *  are distinct facts. */
+export const CANCELLED = Symbol("kiso-question-cancelled");

package/dist/trust-ui.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 手感批 B4 (pure move) — the human-facing question UI: the E3 project
+ * trust gate (ADR-0037), the mcp/skills env merges, the generic ask()
+ * (approvals, trust, uncertain resolutions), and the uncertain-execution
+ * decisions. All bodies moved verbatim from index.ts.
+ */
+import { type ProjectArtifacts } from "@vincemakes/kiso-runtime";
+import type { AgentSession } from "@vincemakes/kiso-runtime";
+import { CANCELLED, type LineInput } from "./state.js";
+/** v2a: the interactive prompt — blue, the identity accent. readline owns
+ *  the echo of what the user types; we own the prompt's color. (v2c: the
+ *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
+ *  pipe bytes must not change.) */
+export declare function interactivePrompt(): string;
+/**
+ * Ask the human a question. Non-interactive stdin (piped, CI) cannot wait
+ * forever: approvals auto-deny and uncertain executions auto-abandon, both
+ * printed loudly — never silently ignored, never hung (Area 7).
+ *
+ * 八/十: the question is ABORTABLE — a pending rl.question is registered in
+ * `pendingAsk` and the SIGINT handler resolves it with the CANCELLED
+ * sentinel. The rl.question callback is NOT left dangling: an input that
+ * arrives after the cancellation is re-emitted as a fresh "line" — it
+ * becomes the next user turn instead of being swallowed by the dead
+ * question.
+ */
+export declare let pendingAsk: (() => void) | null;
+export declare function ask(input: LineInput, question: string): Promise<string | typeof CANCELLED>;
+/**
+ * E3 — the project-level trust gate (ADR-0037): capability is trusted by
+ * content digest, not by directory. Runs BEFORE any extension loads — the
+ * mcp/skills merges must be in the env before the user-level extensions are
+ * loaded (the mcp factory reads KISO_MCP_CONFIG at load time, the skills
+ * extension scans KISO_SKILLS_DIR at load time).
+ *
+ * Verdicts: granted → load; refused → never load, never re-ask (refused is
+ * sticky — re-evaluate by deleting the trust line or changing a file); no
+ * record → only a HUMAN may decide, TTY only — non-TTY refuses with one
+ * stderr line. Returns the artifacts on grant, null on anything else.
+ */
+export declare function resolveProjectTrust(input: LineInput): Promise<ProjectArtifacts | null>;
+/**
+ * E3 — merge the project's mcp.json and skills into the env BEFORE the
+ * extension load. A server name in BOTH configs is a LOUD error (a silent
+ * override would be a supply-chain surprise); a skill name in both merges
+ * with project-wins and a stderr note. Exported for tests.
+ */
+export declare function applyProjectMerges(artifacts: ProjectArtifacts): void;
+/** Decide every uncertain execution with the human (r)erun/(a)bandon. */
+export declare function resolveUncertains(session: AgentSession, input: LineInput, isCancelled: () => boolean): Promise<void>;

package/dist/trust-ui.js

@@ -0,0 +1,218 @@
+/**
+ * 手感批 B4 (pure move) — the human-facing question UI: the E3 project
+ * trust gate (ADR-0037), the mcp/skills env merges, the generic ask()
+ * (approvals, trust, uncertain resolutions), and the uncertain-execution
+ * decisions. All bodies moved verbatim from index.ts.
+ */
+import { existsSync, mkdtempSync, readFileSync, readdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { escapeTerminal, palette } from "@vincemakes/kiso-tui";
+import { projectArtifacts, recordTrust, trustFor } from "@vincemakes/kiso-runtime";
+import { CANCELLED, bodyLog, dock, kisoHome, mergedTempPaths } from "./state.js";
+/** v2a: the interactive prompt — blue, the identity accent. readline owns
+ *  the echo of what the user types; we own the prompt's color. (v2c: the
+ *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
+ *  pipe bytes must not change.) */
+export function interactivePrompt() {
+    const p = palette();
+    return `${p.blue}you> ${p.reset}`;
+}
+/**
+ * Ask the human a question. Non-interactive stdin (piped, CI) cannot wait
+ * forever: approvals auto-deny and uncertain executions auto-abandon, both
+ * printed loudly — never silently ignored, never hung (Area 7).
+ *
+ * 八/十: the question is ABORTABLE — a pending rl.question is registered in
+ * `pendingAsk` and the SIGINT handler resolves it with the CANCELLED
+ * sentinel. The rl.question callback is NOT left dangling: an input that
+ * arrives after the cancellation is re-emitted as a fresh "line" — it
+ * becomes the next user turn instead of being swallowed by the dead
+ * question.
+ */
+export let pendingAsk = null;
+export function ask(input, question) {
+    if (!process.stdin.isTTY) {
+        console.log(`[non-interactive — no human to ask: ${question}]`);
+        return Promise.resolve("");
+    }
+    // v2b: docked — the question takes over the status position, the
+    // answer lands at the input line. v2c: a TTY without a dock (rows < 4)
+    // prints the question into the body — the editor cannot show it.
+    if (dock.active) {
+        dock.showQuestion(question);
+    }
+    else {
+        bodyLog(question);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        pendingAsk = () => {
+            if (settled)
+                return;
+            settled = true;
+            pendingAsk = null;
+            input.cancelQuestion();
+            resolve(CANCELLED); // the run is aborting — the question is dead
+        };
+        // v2b: docked — the question reads at the input line, whose prompt
+        // is the same blue you> (the editor's brick row; the readline path
+        // passes the plain question). An empty prompt would start readline
+        // at column 1 while the dock renders "you> " — the typed answer
+        // would land on the prompt and drift (probe-confirmed).
+        input.question(dock.active ? interactivePrompt() : question, (answer) => {
+            if (settled) {
+                // The question was cancelled; this line is a NEW user turn.
+                input.emitLine(answer);
+                return;
+            }
+            settled = true;
+            pendingAsk = null;
+            if (dock.active)
+                dock.clearQuestion();
+            resolve(answer);
+        });
+    });
+}
+/**
+ * E3 — the project-level trust gate (ADR-0037): capability is trusted by
+ * content digest, not by directory. Runs BEFORE any extension loads — the
+ * mcp/skills merges must be in the env before the user-level extensions are
+ * loaded (the mcp factory reads KISO_MCP_CONFIG at load time, the skills
+ * extension scans KISO_SKILLS_DIR at load time).
+ *
+ * Verdicts: granted → load; refused → never load, never re-ask (refused is
+ * sticky — re-evaluate by deleting the trust line or changing a file); no
+ * record → only a HUMAN may decide, TTY only — non-TTY refuses with one
+ * stderr line. Returns the artifacts on grant, null on anything else.
+ */
+export async function resolveProjectTrust(input) {
+    const artifacts = await projectArtifacts(process.cwd());
+    if (artifacts === null)
+        return null; // no .kiso artifacts — nothing to gate
+    const record = trustFor(artifacts.root, artifacts.digest);
+    if (record?.decision === "granted") {
+        applyProjectMerges(artifacts);
+        return artifacts;
+    }
+    if (record?.decision === "refused")
+        return null; // refused is sticky — no re-ask
+    // First discovery — list every artifact (file name + digest short
+    // prefix) and ask the human ONCE.
+    if (!process.stdin.isTTY) {
+        console.error(`[project .kiso] found ${artifacts.files.length} artifact(s) in ${artifacts.root} — not trusted, not loaded (run kiso interactively once to decide)`);
+        return null;
+    }
+    // v2c: the shared input (the editor on a TTY) reads the answer; the
+    // dock shows the question at the status position.
+    bodyLog(`[project .kiso] ${artifacts.root}`);
+    for (const f of artifacts.files) {
+        bodyLog(`  ${f.path}  (${f.digest.slice(0, 6)})`);
+    }
+    const answer = await ask(input, `trust this project's .kiso? (y/n) `);
+    const granted = answer !== CANCELLED && answer.trim().toLowerCase().startsWith("y");
+    recordTrust({ root: artifacts.root, digest: artifacts.digest, decision: granted ? "granted" : "refused" });
+    if (!granted)
+        return null;
+    applyProjectMerges(artifacts);
+    return artifacts;
+}
+/**
+ * E3 — merge the project's mcp.json and skills into the env BEFORE the
+ * extension load. A server name in BOTH configs is a LOUD error (a silent
+ * override would be a supply-chain surprise); a skill name in both merges
+ * with project-wins and a stderr note. Exported for tests.
+ */
+export function applyProjectMerges(artifacts) {
+    if (artifacts.files.some((f) => f.kind === "mcp"))
+        applyMcpMerge(artifacts.root);
+    if (artifacts.files.some((f) => f.kind === "skill"))
+        applySkillsMerge(artifacts.root);
+}
+/** Read an mcp.json with the mcp extension's tolerance: absent/unreadable →
+ *  {}, present-but-broken → throw (the loader convention). */
+function readMcpConfig(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`[project .kiso] cannot parse ${path}: ${err.message}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`[project .kiso] ${path} must be an object with an mcpServers map`);
+    }
+    return parsed;
+}
+/** Merge user-level + project-level mcp.json into one temp file and point
+ *  KISO_MCP_CONFIG at it — the mcp extension reads it at load time. */
+function applyMcpMerge(root) {
+    const userPath = process.env.KISO_MCP_CONFIG ?? join(kisoHome(), "mcp.json");
+    const user = readMcpConfig(userPath);
+    const project = readMcpConfig(join(root, "mcp.json"));
+    const userServers = user.mcpServers ?? {};
+    const projectServers = project.mcpServers ?? {};
+    if (Object.keys(projectServers).length === 0)
+        return; // nothing to merge
+    for (const name of Object.keys(projectServers)) {
+        if (name in userServers) {
+            throw new Error(`[project .kiso] mcp server "${name}" exists in both the user-level and the project-level mcp.json`);
+        }
+    }
+    const merged = { mcpServers: { ...userServers, ...projectServers } };
+    const temp = join(tmpdir(), `kiso-mcp-merged-${process.pid}.json`);
+    writeFileSync(temp, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+    process.env.KISO_MCP_CONFIG = temp;
+    mergedTempPaths.push(temp);
+}
+/** Merge user-level + project-level skills into one temp scan dir (project
+ *  skill dirs symlinked first; a name in both → project wins + a stderr
+ *  note) and point KISO_SKILLS_DIR at it — the skills extension's existing
+ *  scan reads it at load time and per read_skill call. */
+function applySkillsMerge(root) {
+    const userDir = process.env.KISO_SKILLS_DIR ?? join(kisoHome(), "skills");
+    const projectDir = join(root, "skills");
+    const merged = mkdtempSync(join(tmpdir(), "kiso-skills-"));
+    mergedTempPaths.push(merged);
+    for (const dir of readdirSyncSafe(projectDir)) {
+        symlinkSync(join(projectDir, dir), join(merged, dir)); // project wins on collision
+    }
+    for (const dir of readdirSyncSafe(userDir)) {
+        const target = join(merged, dir);
+        if (existsSync(target)) {
+            console.error(`[project .kiso] skill "${dir}" exists in both user and project skills — project wins`);
+            continue;
+        }
+        symlinkSync(join(userDir, dir), target);
+    }
+    process.env.KISO_SKILLS_DIR = merged;
+}
+function readdirSyncSafe(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return []; // no skills dir on either level = nothing to merge
+    }
+}
+/** Decide every uncertain execution with the human (r)erun/(a)bandon. */
+export async function resolveUncertains(session, input, isCancelled) {
+    for (const uncertain of session.uncertainExecutions()) {
+        const answer = await ask(input, `⚠ interrupted execution: ${escapeTerminal(uncertain.name)} (${uncertain.executionId}) — did it apply? (r)erun / (a)bandon: `);
+        if (isCancelled() || answer === CANCELLED) {
+            // 十: a cancellation NEVER records a verdict — the execution
+            // stays uncertain and durable; no rerun/abandoned is fabricated.
+            return;
+        }
+        const resolution = answer.trim().toLowerCase().startsWith("r") ? "rerun" : "abandoned";
+        await session.resolveUncertain(uncertain.executionId, resolution);
+        console.log(`  ${resolution}\n`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "kiso CLI — the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
@@ -18,13 +18,13 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@vincemakes/kiso-core": "0.1.20",
-    "@vincemakes/kiso-evals": "0.1.20",
-    "@vincemakes/kiso-provider-anthropic": "0.1.20",
-    "@vincemakes/kiso-provider-openai": "0.1.20",
-    "@vincemakes/kiso-runtime": "0.1.20",
-    "@vincemakes/kiso-tools-node": "0.1.20",
-    "@vincemakes/kiso-tui": "0.1.20"
+    "@vincemakes/kiso-core": "0.1.21",
+    "@vincemakes/kiso-evals": "0.1.21",
+    "@vincemakes/kiso-provider-anthropic": "0.1.21",
+    "@vincemakes/kiso-provider-openai": "0.1.21",
+    "@vincemakes/kiso-runtime": "0.1.21",
+    "@vincemakes/kiso-tools-node": "0.1.21",
+    "@vincemakes/kiso-tui": "0.1.21"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",