@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/cli/render/status.js

@@ -1,33 +1,13 @@
 import { formatSettingsDiseases } from "../../config/settings/disease.js";
 import { shortCommitHash } from "../../git/commits.js";
 import { formatAgeMs } from "./format.js";
-import { renderKanshiBoard } from "./kanshi.js";
+import { renderAkumaRosterBoard, renderKanshiBoard } from "./kanshi.js";
 import { renderProjectionActivitySummary, } from "./projection-activity.js";
-import { renderTerminalFailureFace, terminalFailureCodeSuffix } from "./terminal-failure.js";
+import { terminalFailureCodeSuffix } from "./terminal-failure.js";
 import { formatTellCommand } from "./shared.js";
+import { projectionStatusIndicator } from "./status-indicator.js";
 export const STATUS_DISEASES_SECTION_TITLE = "Diseases";
 export const STATUS_PROJECTION_SECTION_TITLE = "akuma";
-function projectionGlyph(state) {
-    switch (state) {
-        case "out":
-            return "●";
-        case "lost":
-            return "○";
-        case "done":
-            return "◎";
-        case "dismissed":
-            return "×";
-        case "dead":
-            return "✕";
-        case "minting":
-            return "…";
-        case "startup-timeout":
-            return "!";
-        case "unknown":
-        case "incompatible":
-            return "?";
-    }
-}
 export function renderSettingsDiseasesSection(diseases, taskDiseases = []) {
     if (diseases.length === 0 && taskDiseases.length === 0)
         return "";
@@ -72,7 +52,7 @@ function terminalFailureSuffix(row) {
 function renderProjectionOmission(board) {
     if (!board.omitted)
         return undefined;
-    const counts = ["failed", "dead", "done", "killed", "dismissed"]
+    const counts = ["failed", "dead", "done", "killed", "dismissed", "incompatible"]
         .flatMap((state) => {
         const count = board.omitted?.byState[state] ?? 0;
         return count > 0 ? [`${count} ${state}`] : [];
@@ -80,26 +60,15 @@ function renderProjectionOmission(board) {
     return counts.length > 0 ? `+ ${counts.join(" · ")}` : undefined;
 }
 function renderProjectionAge(row) {
-    const duration = formatAgeMs(row.durationMs) ?? "?";
-    const activity = formatAgeMs(row.activityAgeMs) ?? "?";
-    const facts = `dur ${duration} · active ${activity}`;
-    if (row.state === "done")
-        return `done · ${facts}`;
-    if (row.state === "killed")
-        return `killed · ${facts}`;
-    if (row.state === "dismissed")
-        return `dismissed · ${facts}`;
-    if (row.state === "failed")
-        return `failed · ${facts}`;
-    if (row.state === "dead")
-        return `dead · ${facts}`;
-    if (row.state === "startup-timeout")
-        return `startup timed out · ${facts}`;
-    if (row.state === "unknown")
-        return `unknown · ${facts}`;
-    if (row.state === "incompatible")
-        return "incompatible history";
-    return facts;
+    const duration = formatAgeMs(row.durationMs);
+    const activity = formatAgeMs(row.activityAgeMs);
+    const terminalAge = formatAgeMs(row.terminalAgeMs);
+    const facts = [
+        ...(terminalAge ? [`terminal ${terminalAge} ago`] : []),
+        ...(duration ? [`${isTerminalProjectionStatus(row) ? "ran" : "observed for"} ${duration}`] : []),
+        ...(activity ? [`last activity ${activity} ago`] : []),
+    ];
+    return [row.state, ...facts].join(" · ");
 }
 function renderProjectionTellCounts(row) {
     const { inbox, inflight, submitted, seen, consumed } = row.tellCounts;
@@ -131,30 +100,24 @@ function renderProjectionActivityLine(row) {
         ...(row.workspaceRoot ? { workspaceRoot: row.workspaceRoot } : {}),
     });
 }
-function renderProjectionRow(row) {
-    const glyph = row.state === "killed"
-        ? "×"
-        : projectionGlyph(row.state === "failed"
-            ? "lost"
-            : row.state === "startup-timeout"
-                ? "minting"
-                : row.state);
+function renderProjectionRow(row, includeDrillDown = true, includeIdentity = true) {
     const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
+    const prefix = includeIdentity
+        ? `${projectionStatusIndicator(row.state)} ${identity} · `
+        : `${projectionStatusIndicator(row.state)} `;
     let heading;
     if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible") {
-        const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${prefix}${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else if (row.state === "minting") {
-        heading = `  ${glyph} ${identity.padEnd(18)} (minting) · ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${prefix}${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
         const age = renderProjectionAge(row);
-        const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${prefix}${age}${renderProjectionTellCounts(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     const activity = renderProjectionActivityLine(row);
-    const drillDown = row.terminalFailure ? [`      » keiyaku wait ${row.alias ?? row.id}`] : [];
+    const drillDown = includeDrillDown && row.terminalFailure ? [`      » keiyaku wait ${row.id}`] : [];
     return activity ? [heading, activity, ...drillDown] : [heading, ...drillDown];
 }
 function isTerminalProjectionStatus(row) {
@@ -167,47 +130,114 @@ function isTerminalProjectionStatus(row) {
 }
 export function renderProjectionFilteredStatus(board, projectionId) {
     const head = board.defaultHead ? shortCommitHash(board.defaultHead) : "(no HEAD)";
-    const heading = `現世 ${head} · projection ${projectionId}`;
-    const row = board.projections?.rows.find((candidate) => candidate.id === projectionId);
+    const row = board.projections?.rows[0];
     if (!row)
-        return `${heading}\nno projections on projection ${projectionId}\n`;
-    if (row.state === "failed" || row.terminalFailure) {
-        const lines = [...renderTerminalFailureFace(projectionId, row.terminalFailure), "", `» keiyaku wait ${projectionId}`];
-        return lines.join("\n");
-    }
-    const lines = [heading, "", ...renderProjectionRow(row), ""];
+        return `現世 ${head} · projection ${projectionId}\nunknown projection ${projectionId}\n`;
+    const identity = row.alias ? `${row.identity.canonicalId} (${row.alias})` : row.identity.canonicalId;
+    const heading = `現世 ${head} · projection ${identity}`;
+    const moved = row.addressedBy?.aliasMovedTo
+        ? [`${row.addressedBy.token} has since moved to ${row.addressedBy.aliasMovedTo}`]
+        : [];
+    const lines = [heading, "", ...renderProjectionRow(row, false, false), ""];
+    lines.push(...moved);
     if (row.observation.compatibility === "incompatible") {
         return `${lines.join("\n")}\n`;
     }
     if (isTerminalProjectionStatus(row)) {
-        lines.push(`» keiyaku wait ${projectionId}`);
-        return lines.join("\n");
+        if (row.terminalAnswer?.text) {
+            if (row.responseArtifact?.state === "none") {
+                lines.push("nothing written to disk", row.terminalAnswer.text);
+            }
+            else {
+                const answer = row.terminalAnswer.text.split("\n");
+                lines.push(...answer.slice(0, 4));
+                if (answer.length > 4) {
+                    lines.push(row.responseArtifact?.state === "retained"
+                        ? `… answer continues in ${row.responseArtifact.path}`
+                        : `… +${answer.length - 4} more lines`);
+                }
+                else if (row.responseArtifact?.state === "retained") {
+                    lines.push(`response: ${row.responseArtifact.path}`);
+                }
+            }
+        }
+        else if (row.responseArtifact?.state === "retained") {
+            lines.push(`response: ${row.responseArtifact.path}`);
+        }
+        return `${lines.join("\n")}\n`;
     }
-    lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
-    lines.push(`» keiyaku wait ${projectionId}`);
+    const commandAddress = row.addressedBy?.kind === "alias" && !row.addressedBy.aliasMovedTo
+        ? row.addressedBy.token
+        : row.identity.canonicalId;
+    lines.push(`» ${formatTellCommand(commandAddress, '"..."')}`);
+    lines.push(`» keiyaku wait ${commandAddress}`);
     return `${lines.join("\n")}\n`;
 }
 export function renderProjectionStatusSection(board) {
     if (!board || (board.rows.length === 0 && !board.omitted))
         return "";
-    const lines = board.rows.flatMap(renderProjectionRow);
+    const lines = board.rows.flatMap((row) => renderProjectionRow(row));
     const omission = renderProjectionOmission(board);
     if (omission)
         lines.push(omission);
-    return `${STATUS_PROJECTION_SECTION_TITLE}\n${lines.join("\n")}\n`;
+    const total = board.rows.length + (board.omitted?.total ?? 0);
+    return `${STATUS_PROJECTION_SECTION_TITLE} ${board.rows.length}/${total}\n${lines.join("\n")}\n`;
 }
 /**
  * Status mouth: kanshi board plus optional diseases section.
  * Healthy boards (no diseases) are byte-identical to renderKanshiBoard alone.
  */
 export function renderStatusBoard(board) {
-    const boardText = renderKanshiBoard(board);
     const taskDiseaseText = [
         ...(board.tasks?.diseases ?? []).map((disease) => disease.message),
         ...(board.tasks?.diagnostic ? [board.tasks.diagnostic] : []),
     ];
     const diseasesText = renderSettingsDiseasesSection(board.diseases, taskDiseaseText);
-    if (diseasesText === "")
-        return boardText;
-    return `${[boardText.trimEnd(), diseasesText.trimEnd()].join("\n\n")}\n`;
+    return renderKanshiBoard(board, diseasesText === "" ? [] : [diseasesText.trimEnd()]);
+}
+export function renderAkumaRosterStatus(board) {
+    return renderAkumaRosterBoard(board);
+}
+function statusJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new TypeError("Status payload numbers must be finite");
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(statusJsonValue);
+    if (value instanceof Map || value instanceof Set) {
+        throw new TypeError("Status payload collections must be converted explicitly");
+    }
+    if (typeof value === "object") {
+        const entries = [];
+        for (const [key, item] of Object.entries(value)) {
+            if (item !== undefined)
+                entries.push([key, statusJsonValue(item)]);
+        }
+        return Object.fromEntries(entries);
+    }
+    throw new TypeError(`Status payload contains unsupported ${typeof value}`);
+}
+/** One JSON-safe status DTO shared by human and JSON command responses. */
+export function buildStatusPayload(board) {
+    return {
+        contracts: statusJsonValue(board.contracts),
+        contractsObservable: board.contractsObservable,
+        commissionPlaces: statusJsonValue(Object.fromEntries(board.commissionPlaces)),
+        projections: statusJsonValue(board.projections),
+        queueLength: board.queueLength,
+        ...(board.defaultBranch === undefined ? {} : { defaultBranch: board.defaultBranch }),
+        ...(board.defaultHead === undefined ? {} : { defaultHead: board.defaultHead }),
+        diseases: statusJsonValue(board.diseases),
+        targetFilter: board.targetFilter,
+        ...(board.commissionFilter === undefined ? {} : { commissionFilter: board.commissionFilter }),
+        ...(board.tasks === undefined ? {} : { tasks: statusJsonValue(board.tasks) }),
+    };
+}
+export function renderStatusJson(payload) {
+    return `${JSON.stringify(payload)}\n`;
 }

package/build/cli/render/success-response.js

@@ -11,6 +11,12 @@ function responseData(response) {
         return {};
     return payload;
 }
+const AKUMA_JSON_COMMANDS = new Set(["call", "tell", "wait", "fork"]);
+export function serializeAkumaSuccessResponse(command, flags, response) {
+    return flags.json && AKUMA_JSON_COMMANDS.has(command)
+        ? `${JSON.stringify(responseData(response))}\n`
+        : undefined;
+}
 function isCallProjectionFacts(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -25,10 +31,17 @@ function conversationalFooter(response) {
     if (response.address) {
         const projection = data.projection;
         const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
-        const receiptArtifactId = typeof data.revivedArtifactId === "string"
-            ? data.revivedArtifactId
+        const receiptArtifactId = typeof data.sourceArtifactId === "string"
+            ? data.sourceArtifactId
             : typeof data.artifactId === "string" ? data.artifactId : undefined;
         lines.push(renderResolvedAddressReceipt(response.address, { artifactId: receiptArtifactId, projectionId: projectionFacts?.id }));
+        if (typeof data.sourceArtifactId === "string" && typeof data.artifactId === "string") {
+            lines.push([
+                typeof data.sourceProjectionId === "string" ? `source projection ${data.sourceProjectionId}` : undefined,
+                "conversation continued",
+                `response artifact ${data.artifactId}`,
+            ].filter((part) => part !== undefined).join(" · "));
+        }
     }
     const responsePath = typeof data.responsePath === "string" ? data.responsePath : undefined;
     const agent = typeof data.agent === "string" ? data.agent : undefined;
@@ -56,9 +69,11 @@ function conversationalFooter(response) {
     return lines.join("\n");
 }
 export async function writeSuccessResponse(command, flags, response) {
-    // Plain tell is always silent; tell --wait owns the ordinary wait response.
-    if (command === "tell" && flags.timeoutMs === undefined)
+    const json = serializeAkumaSuccessResponse(command, flags, response);
+    if (json !== undefined) {
+        await writeCliOutput(process.stdout, json);
         return;
+    }
     if (command === "bind" && flags.dryRun) {
         // Canonical Markdown already ends with exactly one newline.
         await writeCliOutput(process.stdout, responseText(response));
@@ -66,7 +81,7 @@ export async function writeSuccessResponse(command, flags, response) {
             await writeCliOutput(process.stderr, `${response.stderr}\n`);
         return;
     }
-    if (command !== "revive") {
+    if (command !== "fork") {
         await writeCliOutput(process.stdout, `${responseText(response)}\n`);
         return;
     }

package/build/cli/render/task.js

@@ -7,14 +7,14 @@ export function deriveTaskDisplay(task) {
     const display = deriveStructuredTaskDisplay(task);
     return display === "bound" ? `bound(${shortContractId(task.contractId)})` : display;
 }
-function renderTaskRowWithId(task, id) {
-    return `${id} · ${task.namespace ?? "hub"} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
+function renderTaskRowWithCoordinate(task, coordinate) {
+    return `${coordinate} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
 }
 export function renderTaskListRow(task) {
-    return renderTaskRowWithId(task, task.coordinate);
+    return renderTaskRowWithCoordinate(task, task.coordinate);
 }
 export function renderTaskMutationRow(task) {
-    return renderTaskRowWithId(task, task.coordinate);
+    return renderTaskRowWithCoordinate(task, task.coordinate);
 }
 export function renderTaskUpdate(result) {
     const lines = [renderTaskMutationRow(result.task)];
@@ -75,7 +75,6 @@ function renderTaskDetails(task) {
     const released = new Set(task.releasedNeeds);
     return [
         `${task.coordinate} · ${task.title}`,
-        `namespace: ${task.namespace ?? "(hub)"}`,
         `state: ${deriveTaskDisplay(task)}`,
         `priority: ${task.pri}`,
         ...(task.needs.length === 0 ? [] : [`needs: ${task.needs.map((id) => `${id}${released.has(id) ? " (dropped)" : ""}`).join(", ")}`]),
@@ -88,6 +87,7 @@ function renderTaskDetails(task) {
         `created: ${task.createdAt} by ${task.creator}`,
         "",
         task.body,
+        ...task.notes.flatMap((note) => ["", `${note.timestamp} · ${note.actor}`, note.text]),
     ];
 }
 function renderTreeNode(node, prefix, last) {
@@ -147,6 +147,7 @@ export function taskJson(task) {
         createdAt: task.createdAt,
         updatedAt: task.updatedAt ?? task.createdAt,
         creator: task.creator,
+        notes: task.notes.map((note) => ({ ...note })),
     };
 }
 function taskTreeNodeJson(node) {

package/build/cli/render/tell.js

@@ -1,5 +1,11 @@
-import { textResponse } from "./shared.js";
-/** Accepted plain tell: zero stdout/stderr bytes. */
-export function buildSilentTellResponse() {
-    return textResponse("");
+import { coreTextResponse } from "./shared.js";
+/** Tell returns after mailbox acceptance; it never claims consumption. */
+export function buildTellAcceptedResponse(projectionId, inputToken, alias) {
+    const payload = {
+        state: "accepted",
+        canonicalId: projectionId,
+        inputToken,
+        ...(alias ? { alias } : {}),
+    };
+    return coreTextResponse(`${projectionId}${alias ? ` (${alias})` : ""} heard.`, payload);
 }

package/build/cli/render/tool-command-normalization.js

@@ -0,0 +1,137 @@
+/**
+ * Unwrap only complete provider transport launchers. This is deliberately not
+ * a shell parser: uncertainty preserves the persisted command's presentation.
+ */
+const HORIZONTAL_WHITESPACE = new Set([" ", "\t"]);
+const UNSUPPORTED_UNQUOTED = new Set(["$", "`", "|", "&", ";", "<", ">", "(", ")"]);
+const POWERSHELL_OPTION_FLAGS = new Set(["-nologo", "-noprofile"]);
+const POWERSHELL_COMMAND_FLAGS = new Set(["-command", "-c"]);
+function isAbsoluteExecutable(value) {
+    return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function executableName(value) {
+    const segments = value.split(/[\\/]/);
+    return segments[segments.length - 1].toLowerCase();
+}
+function isBashOrZsh(value) {
+    const name = executableName(value);
+    return (value === "bash" || value === "zsh" || isAbsoluteExecutable(value))
+        && (name === "bash" || name === "zsh");
+}
+function isPowerShell(value) {
+    const name = executableName(value);
+    return (value.toLowerCase() === "powershell" || value.toLowerCase() === "pwsh" || isAbsoluteExecutable(value))
+        && (name === "powershell" || name === "powershell.exe" || name === "pwsh" || name === "pwsh.exe");
+}
+/**
+ * Read only a conservative argv-shaped command line. Newlines are supported
+ * inside a quoted argument but not as outer command syntax.
+ */
+function parseTransportArgv(command) {
+    const argv = [];
+    let index = 0;
+    while (index < command.length) {
+        while (HORIZONTAL_WHITESPACE.has(command[index]))
+            index += 1;
+        if (index === command.length)
+            break;
+        if (command[index] === "\n" || command[index] === "\r")
+            return undefined;
+        let value = "";
+        let consumed = false;
+        while (index < command.length && !HORIZONTAL_WHITESPACE.has(command[index])) {
+            const character = command[index];
+            if (character === "\n" || character === "\r" || UNSUPPORTED_UNQUOTED.has(character))
+                return undefined;
+            if (character === "'") {
+                const end = command.indexOf("'", index + 1);
+                if (end < 0)
+                    return undefined;
+                value += command.slice(index + 1, end);
+                index = end + 1;
+                consumed = true;
+                continue;
+            }
+            if (character === '"') {
+                index += 1;
+                consumed = true;
+                let closed = false;
+                while (index < command.length) {
+                    const quoted = command[index];
+                    if (quoted === '"') {
+                        index += 1;
+                        closed = true;
+                        break;
+                    }
+                    if (quoted === "$")
+                        return undefined;
+                    if (quoted === "`")
+                        return undefined;
+                    if (quoted === "\\") {
+                        const next = command[index + 1];
+                        if (next === undefined || next === "\n" || next === "\r")
+                            return undefined;
+                        if (next === '"' || next === "\\" || next === "$" || next === "`") {
+                            value += next;
+                        }
+                        else {
+                            value += `\\${next}`;
+                        }
+                        index += 2;
+                        continue;
+                    }
+                    value += quoted;
+                    index += 1;
+                }
+                if (!closed)
+                    return undefined;
+                continue;
+            }
+            if (character === "\\") {
+                const next = command[index + 1];
+                if (next === undefined || next === "\n" || next === "\r")
+                    return undefined;
+                value += next;
+                index += 2;
+                consumed = true;
+                continue;
+            }
+            value += character;
+            index += 1;
+            consumed = true;
+        }
+        if (!consumed)
+            return undefined;
+        argv.push(value);
+    }
+    return argv;
+}
+function unwrapBashOrZsh(argv) {
+    const [shell, flag, script] = argv;
+    if (argv.length !== 3 || !shell || !script || !isBashOrZsh(shell))
+        return undefined;
+    return flag === "-c" || flag === "-lc" ? script : undefined;
+}
+function unwrapPowerShell(argv) {
+    const [shell, ...arguments_] = argv;
+    if (!shell || !isPowerShell(shell) || arguments_.length < 2)
+        return undefined;
+    const options = new Set();
+    for (let index = 0; index < arguments_.length - 1; index += 1) {
+        const flag = arguments_[index].toLowerCase();
+        if (POWERSHELL_COMMAND_FLAGS.has(flag)) {
+            return index === arguments_.length - 2 && arguments_[index + 1] ? arguments_[index + 1] : undefined;
+        }
+        if (!POWERSHELL_OPTION_FLAGS.has(flag) || options.has(flag))
+            return undefined;
+        options.add(flag);
+    }
+    return undefined;
+}
+/** Return a display subject only when the full transport shape is unambiguous. */
+export function normalizeToolCommand(command) {
+    const argv = parseTransportArgv(command);
+    if (!argv)
+        return command;
+    return unwrapBashOrZsh(argv) ?? unwrapPowerShell(argv) ?? command;
+}

package/build/cli/render/tool-presentation.js

@@ -1,4 +1,5 @@
 import { compactText } from "./compact-text.js";
+import { normalizeToolCommand } from "./tool-command-normalization.js";
 export function activitySemanticClass(call) {
     switch (call.kind) {
         case "run": return "run";
@@ -24,7 +25,7 @@ function rangeText(call) {
 }
 function subject(call, presentPath) {
     switch (call.kind) {
-        case "run": return compactText(call.description ?? `$ ${call.command}`);
+        case "run": return compactText(call.description ?? `$ ${normalizeToolCommand(call.command)}`);
         case "read": return presentPath(call.path);
         case "search": return `“${compactText(call.query)}”`;
         case "other": return compactText(call.display);

package/build/cli/render/verification.js

@@ -0,0 +1,23 @@
+import { buildPayload } from "./format.js";
+import { coreTextResponse } from "./shared.js";
+function humanLines(model) {
+    return `${model.runId}\n${model.phase}`;
+}
+/** Canonical Verification CLI renderer: one model drives human text and JSON. */
+export function renderVerificationCli(model, json) {
+    const payload = buildPayload(model);
+    const output = coreTextResponse(json ? JSON.stringify(payload) : humanLines(model), payload);
+    return model.operation === "wait" && model.phase === "timeout" ? { ...output, exitCode: 124 } : output;
+}
+export function verificationStatusModel(run) {
+    return { operation: "status", runId: run.id, phase: run.terminal?.status ?? "running", run };
+}
+export function verificationWaitModel(runId, terminal) {
+    return { operation: "wait", runId, phase: terminal.status, terminal };
+}
+export function verificationWaitTimeoutModel(runId) {
+    return { operation: "wait", runId, phase: "timeout" };
+}
+export function verificationCancelModel(runId, accepted) {
+    return { operation: "cancel", runId, phase: accepted ? "accepted" : "already-terminal-or-missing", accepted };
+}