@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,137 +0,0 @@
-/**
- * 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-ledger-rollup.js

@@ -1,74 +0,0 @@
-import * as path from "node:path";
-import { activitySemanticClass } from "./tool-presentation.js";
-const CLASS_ORDER = ["run", "read", "write", "edit", "search", "tool"];
-export function presentLedgerPath(value, workspaceRoot) {
-    const candidate = value.trim();
-    if (!candidate)
-        return undefined;
-    if (!path.isAbsolute(candidate))
-        return candidate;
-    if (!workspaceRoot || !path.isAbsolute(workspaceRoot))
-        return candidate;
-    const relative = path.relative(workspaceRoot, candidate);
-    if (relative === "")
-        return ".";
-    if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`))
-        return candidate;
-    return relative.split(path.sep).join("/");
-}
-export function summarizeToolLedger(activities, turns, presentPath) {
-    const counts = new Map();
-    const files = new Map();
-    for (const row of activities) {
-        const semanticClass = activitySemanticClass(row.call);
-        counts.set(semanticClass, (counts.get(semanticClass) ?? 0) + 1);
-        if (row.call.kind !== "fileChange")
-            continue;
-        const pathDiffstat = row.call.changes.length === 1 && (row.call.omittedChanges ?? 0) === 0
-            ? row.result?.diffstat
-            : undefined;
-        for (const change of row.call.changes) {
-            if (change.op === "delete")
-                continue;
-            const visible = presentPath(change.path);
-            if (!visible)
-                continue;
-            const fileClass = change.op === "add" ? "write" : "edit";
-            const prior = files.get(visible);
-            if (prior) {
-                prior.semanticClass = fileClass;
-                prior.count += 1;
-                prior.allHaveDiffstat &&= pathDiffstat !== undefined;
-                prior.additions += pathDiffstat?.additions ?? 0;
-                prior.deletions += pathDiffstat?.deletions ?? 0;
-            }
-            else {
-                files.set(visible, {
-                    semanticClass: fileClass,
-                    count: 1,
-                    additions: pathDiffstat?.additions ?? 0,
-                    deletions: pathDiffstat?.deletions ?? 0,
-                    allHaveDiffstat: pathDiffstat !== undefined,
-                });
-            }
-        }
-    }
-    const visibleFiles = [...files].map(([visiblePath, file]) => ({
-        semanticClass: file.semanticClass,
-        path: visiblePath,
-        count: file.count,
-        ...(file.allHaveDiffstat ? { diffstat: { additions: file.additions, deletions: file.deletions } } : {}),
-    }));
-    const tokenFacts = turns.filter((turn) => turn.inputTokens !== undefined && turn.outputTokens !== undefined);
-    const costFacts = turns.filter((turn) => turn.costUsd !== undefined);
-    return {
-        counts: CLASS_ORDER.flatMap((semanticClass) => {
-            const count = counts.get(semanticClass);
-            return count === undefined ? [] : [{ semanticClass, count }];
-        }),
-        files: visibleFiles.slice(0, 10),
-        hiddenFileCount: Math.max(0, visibleFiles.length - 10),
-        ...(tokenFacts.length ? { tokens: tokenFacts.reduce((sum, turn) => sum + turn.inputTokens + turn.outputTokens, 0) } : {}),
-        ...(costFacts.length ? { costUsd: costFacts.reduce((sum, turn) => sum + turn.costUsd, 0) } : {}),
-    };
-}

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

@@ -1,98 +0,0 @@
-import { compactText } from "./compact-text.js";
-import { normalizeToolCommand } from "./tool-command-normalization.js";
-export function activitySemanticClass(call) {
-    switch (call.kind) {
-        case "run": return "run";
-        case "read": return "read";
-        case "search": return "search";
-        case "other": return "tool";
-        case "fileChange":
-            return call.changes.length > 1 || call.changes.some((change) => change.op === "add")
-                ? "write"
-                : "edit";
-    }
-}
-function rangeText(call) {
-    const offset = call.range?.offset;
-    const limit = call.range?.limit;
-    if (offset !== undefined && limit !== undefined && limit > 0)
-        return `L${offset}–${offset + limit - 1}`;
-    if (offset !== undefined)
-        return `from L${offset}`;
-    if (limit !== undefined && limit > 0)
-        return `${limit} lines`;
-    return undefined;
-}
-function subject(call, presentPath) {
-    switch (call.kind) {
-        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);
-        case "fileChange": {
-            const paths = call.changes.map((change) => presentPath(change.path));
-            if (paths.length === 1)
-                return paths[0];
-            if (paths.length > 1)
-                return `${paths.length + (call.omittedChanges ?? 0)} files · ${paths.join(", ")}`;
-            return call.omittedChanges ? `${call.omittedChanges} files` : "files";
-        }
-    }
-}
-export function presentToolActivity(input) {
-    const presentPath = input.presentPath ?? ((value) => value);
-    const range = input.call.kind === "read" ? rangeText(input.call) : undefined;
-    const primary = `${subject(input.call, presentPath)}${range ? ` · ${range}` : ""}`;
-    const message = input.result?.message ? compactText(input.result.message) : undefined;
-    let variableText = primary;
-    let fixedSuffix = "";
-    if (input.state === "unresolved") {
-        fixedSuffix = " — state unknown";
-    }
-    else if (input.state === "interrupted") {
-        fixedSuffix = " — never finished";
-    }
-    else if (input.state === "running") {
-        if (message)
-            variableText = `${primary} — ${message}`;
-        else
-            fixedSuffix = ` — ${input.duration ?? "0s"}…`;
-    }
-    else if (input.result?.status === "error") {
-        if (input.result.exitCode !== undefined) {
-            fixedSuffix = ` — exit ${input.result.exitCode}${input.call.kind === "run" && input.duration ? ` · ${input.duration}` : ""}`;
-        }
-        else {
-            variableText = `${primary}${message ? ` — error: ${message}` : " — error"}`;
-        }
-    }
-    else if (input.call.kind === "fileChange") {
-        if (input.result?.diffstat)
-            fixedSuffix = ` — +${input.result.diffstat.additions} −${input.result.diffstat.deletions}`;
-    }
-    else if (input.call.kind === "run") {
-        fixedSuffix = input.duration ? ` — ${input.duration}` : "";
-    }
-    else if (input.call.kind === "other") {
-        fixedSuffix = " — done";
-    }
-    if (input.truncated && !variableText.endsWith("…"))
-        variableText = `${variableText}…`;
-    return {
-        semanticClass: activitySemanticClass(input.call),
-        subject: primary,
-        variableText,
-        fixedSuffix,
-        error: input.result?.status === "error",
-    };
-}
-export function presentFoldedToolActivity(row, input, presentPath) {
-    return presentToolActivity({
-        call: row.call,
-        ...(row.result === undefined ? {} : { result: row.result }),
-        state: input.state,
-        ...(input.duration === undefined ? {} : { duration: input.duration }),
-        ...(row.truncated ? { truncated: true } : {}),
-        ...(presentPath === undefined ? {} : { presentPath }),
-    });
-}

package/build/cli/render/types.js

@@ -1,2 +0,0 @@
-;
-export {};

package/build/cli/render/verification.js

@@ -1,23 +0,0 @@
-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 };
-}

package/build/cli/render/wait.js

@@ -1,343 +0,0 @@
-import { formatTimelineDuration, renderPendingProjectionTell, renderProjectionActivity, } from "./projection-activity.js";
-import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
-import { coreTextResponse, formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
-import { renderTerminalFailureFace } from "./terminal-failure.js";
-function phaseState(phase) {
-    switch (phase) {
-        case "done": return "returned";
-        case "failed": return "dead";
-        case "lost": return "lost";
-        case "killed":
-        case "dismissed": return "dismissed";
-        case "startup-timeout": return "stalled";
-        case "unknown": return "unknown";
-        case "minting":
-        case "active":
-        case "quiescent": return "running";
-    }
-}
-function isTerminalPhase(phase) {
-    // `lost` is intentionally absent: it can be an observation failure without
-    // a verdict. Core marks the excluded lost-runner-verdict case explicitly.
-    return ["done", "failed", "killed", "dismissed"].includes(phase);
-}
-function waitStateText(snapshot) {
-    const idle = snapshot.activityAgeMs === undefined
-        ? formatTimelineDuration(snapshot.durationMs)
-        : formatTimelineDuration(snapshot.activityAgeMs);
-    return `up ${formatTimelineDuration(snapshot.durationMs)} · idle ${idle}`;
-}
-function projectionIdentityParts(projectionId) {
-    const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
-    return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
-}
-function waitHeader(projectionId, akuma, snapshot, maxColumns, alias) {
-    const state = waitStateText(snapshot);
-    const identity = projectionIdentityParts(projectionId);
-    // Slug often mirrors the Akuma name; print once when they are the same fact.
-    const description = identity.slug && akuma && identity.slug === akuma
-        ? identity.slug
-        : [identity.slug, akuma].filter(Boolean).join(" · ");
-    const descriptionBudget = Math.max(0, maxColumns - displayColumns(`${projectionId}${alias ? ` (${alias})` : ""} ·  ─ ${state}`));
-    const visibleDescription = truncateColumns(description, descriptionBudget);
-    const canonical = `${projectionId}${alias ? ` (${alias})` : ""}`;
-    const prefix = visibleDescription ? `${canonical} · ${visibleDescription}` : canonical;
-    const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
-    return `${prefix} ${"─".repeat(dashCount)} ${state}`;
-}
-function pendingTellRows(snapshot, maxColumns, orderOffset) {
-    return snapshot.tells.window.map((tell, index) => ({
-        line: renderPendingProjectionTell(tell, {
-            anchorMs: snapshot.observedAtMs,
-            maxColumns,
-        }),
-        at: tell.createdAt,
-        order: orderOffset + index,
-    }));
-}
-function orderFlowRows(rows) {
-    return rows.slice().sort((left, right) => {
-        const leftAt = Date.parse(left.at ?? "");
-        const rightAt = Date.parse(right.at ?? "");
-        const safeLeft = Number.isFinite(leftAt) ? leftAt : Number.POSITIVE_INFINITY;
-        const safeRight = Number.isFinite(rightAt) ? rightAt : Number.POSITIVE_INFINITY;
-        return safeLeft - safeRight || left.order - right.order;
-    });
-}
-function ledgerHint(projectionId, snapshot) {
-    const file = snapshot.eventLedgerFile ?? "events.jsonl";
-    return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
-}
-function recordForkLines(artifactId) {
-    return [
-        `record: ${artifactId}`,
-        "fork starts a new projection from the record:",
-        `  » keiyaku fork ${artifactId}`,
-    ];
-}
-function nextActionLines(projectionId, result, state) {
-    const snapshot = result.snapshot;
-    const address = projectionId;
-    if (state === "running") {
-        return [...projectionRejoinHintLines(address)];
-    }
-    if (state === "returned") {
-        return [
-            "The akuma is back.",
-            ...(snapshot.artifactId ? [`record: ${snapshot.artifactId}`] : []),
-            "talk to it:",
-            `  » ${formatTellCommand(projectionId, '"your words"')}`,
-        ];
-    }
-    if (result.state === "terminal" && (result.verdict.terminalFailure
-        || result.verdict.state === "failed"
-        || result.verdict.state === "launch-failed"
-        || result.verdict.state === "lost-runner")) {
-        return renderTerminalFailureFace(projectionId, result.verdict.terminalFailure);
-    }
-    if (snapshot.phase === "lost") {
-        return snapshot.artifactId
-            ? [
-                "The projection is lost — no terminal truth exists.",
-                ...recordForkLines(snapshot.artifactId),
-            ]
-            : [
-                "The projection is lost — no terminal truth exists.",
-                "no record survived — there is nothing to fork.",
-            ];
-    }
-    if (state === "stalled" || state === "unknown") {
-        return [ledgerHint(projectionId, snapshot), "» keiyaku status"];
-    }
-    return [];
-}
-function startupTimeoutResponse(projectionId, akuma) {
-    return {
-        ...textResponse([
-            `… ${akuma} · projection: ${projectionId} · startup timed out`,
-            "the launch was never adopted — no akuma exists",
-            "",
-            "the next wake retries the launch:",
-            `  » ${formatTellCommand(projectionId, '"your words"')}`,
-        ].join("\n")),
-        exitCode: 1,
-    };
-}
-function unknownResponse(projectionId, akuma, snapshot, maxColumns) {
-    const rendered = renderProjectionActivity(snapshot.activity, {
-        anchorMs: snapshot.observedAtMs,
-        state: "unknown",
-        showPlan: false,
-        showSilence: false,
-        showTerminalFiles: false,
-        ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-        maxColumns,
-        leadingOmittedCount: snapshot.activity.omittedSettledCount,
-    });
-    const historicalLines = rendered.lines.map((line) => line.replace(/[┆├]/, "│"));
-    return {
-        ...textResponse([
-            `? ${akuma} · projection: ${projectionId} · unknown`,
-            "the projection could not be observed",
-            "nothing is asserted — not alive, not dead",
-            ...historicalLines,
-            "",
-            "observation failed — look again:",
-            "  » keiyaku status",
-        ].join("\n")),
-        // CliOutput currently owns only the existing failure and interrupt codes.
-        // #615 requires a distinct unknown code; the owning exit-code surface must
-        // add it before this temporary existing failure code can be replaced.
-        exitCode: 1,
-    };
-}
-function identityUnavailableResponse(projectionId, diagnostic) {
-    return {
-        ...textResponse([
-            `? projection: ${projectionId} · unknown`,
-            "the projection could not be observed",
-            diagnostic,
-            "",
-            "observation failed — look again:",
-            "  » keiyaku status",
-        ].join("\n")),
-        exitCode: 1,
-    };
-}
-function returnedResponse(projectionId, result, alias) {
-    const identity = `${projectionId}${alias ? ` (${alias})` : ""}`;
-    const nextActions = nextActionLines(projectionId, result, "returned");
-    if (result.state === "terminal" && result.outcomeText) {
-        return textResponse([identity, `answer: ${result.outcomeText}`, ...nextActions].join("\n"));
-    }
-    return textResponse([identity, ...nextActions].join("\n"));
-}
-export function buildWaitResponse(projectionId, result, options = {}) {
-    const payload = {
-        canonicalId: projectionId,
-        ...(options.inputToken ? { inputToken: options.inputToken } : {}),
-        ...(options.alias ? { alias: options.alias } : {}),
-        result,
-    };
-    const withPayload = (response) => ({
-        ...response,
-        payload: payload,
-    });
-    if (result.state === "unknown") {
-        return withPayload({ ...identityUnavailableResponse(projectionId, result.diagnostic), exitCode: 4 });
-    }
-    // A plural deadline may observe a verdict whose timestamp is at or after
-    // the cutoff. The typed timeout result owns presentation in that case; the
-    // later terminal-looking snapshot must not turn it into a terminal face.
-    const snapshot = result.state === "timeout"
-        && (result.terminalSnapshot || isTerminalPhase(result.snapshot.phase))
-        ? { ...result.snapshot, phase: "active" }
-        : result.snapshot;
-    const maxColumns = Math.min(120, options.maxColumns ?? resolveLineColumns());
-    if (result.state === "terminal" && result.verdict.state === "killed") {
-        return withPayload({
-            ...textResponse(`× killed ${projectionId}`),
-            exitCode: 1,
-        });
-    }
-    if (snapshot.phase === "startup-timeout") {
-        return withPayload(startupTimeoutResponse(projectionId, result.pact.akuma));
-    }
-    if (snapshot.phase === "unknown") {
-        const response = unknownResponse(projectionId, result.pact.akuma, snapshot, maxColumns);
-        return result.state === "timeout"
-            ? withPayload({ ...response, exitCode: 124 })
-            : withPayload({ ...response, exitCode: 4 });
-    }
-    const state = phaseState(snapshot.phase);
-    if (state === "returned") {
-        return withPayload(returnedResponse(projectionId, result, options.alias));
-    }
-    const rendered = renderProjectionActivity(snapshot.activity, {
-        anchorMs: snapshot.observedAtMs,
-        state,
-        showPlan: false,
-        showSilence: false,
-        showTerminalFiles: false,
-        ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-        maxColumns,
-        leadingOmittedCount: snapshot.activity.omittedSettledCount,
-    });
-    const diagnosticLines = (snapshot.eventDiagnostics ?? [])
-        .map((diagnostic) => `‼ ${diagnostic.kind} · ${diagnostic.detail}`);
-    const activityRows = rendered.lines.map((line, index) => ({
-        line,
-        at: rendered.rowAts[index],
-        order: index,
-    }));
-    const flowLines = orderFlowRows([
-        ...activityRows,
-        ...pendingTellRows(snapshot, maxColumns, activityRows.length),
-    ]).map((row) => truncateColumns(row.line, maxColumns));
-    const lines = [
-        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns, options.alias),
-        ...diagnosticLines,
-        ...flowLines,
-    ];
-    const commandToken = options.inputToken && options.inputToken === options.alias
-        ? options.inputToken
-        : projectionId;
-    const nextActions = state === "running" && options.runningActions === false
-        ? []
-        : nextActionLines(commandToken, result, state);
-    if (nextActions.length > 0)
-        lines.push("");
-    lines.push(...nextActions);
-    const response = withPayload(coreTextResponse(lines.join("\n"), result));
-    if (result.state === "timeout")
-        return { ...response, exitCode: 124 };
-    if (snapshot.phase === "dismissed")
-        return { ...response, exitCode: 130 };
-    if (result.state === "lost") {
-        return { ...response, exitCode: 4 };
-    }
-    return response;
-}
-/** The plural face labels every member because a successful singleton face is answer-only. */
-export function buildProjectionWaitSetResponse(result) {
-    const rendered = result.results
-        .slice()
-        .sort((left, right) => waitTriage(left) - waitTriage(right)
-        || latestWaitActivity(right) - latestWaitActivity(left)
-        || terminalWaitTime(right) - terminalWaitTime(left)
-        || left.id.localeCompare(right.id))
-        .map((member) => ({
-        id: member.id,
-        result: member.result,
-        inputToken: member.inputToken,
-        alias: member.alias,
-        response: buildWaitResponse(member.id, member.result, {
-            alias: member.alias,
-            inputToken: member.inputToken,
-            runningActions: false,
-        }),
-    }));
-    const liveIds = rendered
-        .filter((member) => member.result.state === "timeout")
-        .map((member) => member.id);
-    const blocks = rendered.map(({ id, response }) => `${id}\n${response.text}`);
-    if (liveIds.length > 0) {
-        blocks.push([
-            "Come back for the result:",
-            `  » keiyaku wait ${rendered.filter((member) => member.result.state === "timeout").map((member) => member.inputToken ?? member.id).join(" ")} --${result.selection} [--timeout DURATION]`,
-            "Steer them while they work:",
-            `  » ${formatTellCommand("<projection-id>", '"your words"')}`,
-        ].join("\n"));
-    }
-    const text = blocks.join("\n\n");
-    const payload = {
-        selection: result.selection,
-        ...(result.selectedId ? { selectedId: result.selectedId } : {}),
-        results: rendered.map((member) => ({
-            canonicalId: member.id,
-            ...(member.inputToken ? { inputToken: member.inputToken } : {}),
-            ...(member.alias ? { alias: member.alias } : {}),
-            result: member.result,
-        })),
-    };
-    const response = coreTextResponse(text, payload);
-    const conditionSatisfied = result.selection === "any" && result.selectedId !== undefined;
-    const exitCode = rendered.reduce((current, { response }) => {
-        if (current === 130)
-            return current;
-        if (response.exitCode === 130)
-            return 130;
-        if (current === 4)
-            return current;
-        if (response.exitCode === 4)
-            return 4;
-        return response.exitCode === 124 && !conditionSatisfied ? 124 : current;
-    }, undefined);
-    const deadline = !conditionSatisfied && rendered.some((member) => member.result.state === "timeout");
-    return exitCode === undefined && !deadline ? response : { ...response, exitCode: exitCode ?? 124 };
-}
-function waitSnapshot(result) {
-    return result.state === "unknown" ? undefined : result.snapshot;
-}
-function waitTriage(member) {
-    const snapshot = waitSnapshot(member.result);
-    if (member.result.state === "unknown" || member.result.state === "lost")
-        return 0;
-    if (member.result.state === "terminal" && (member.result.verdict.terminalFailure || member.result.verdict.state !== "completed"))
-        return 0;
-    if ((snapshot?.eventDiagnostics?.length ?? 0) > 0)
-        return 0;
-    return member.result.state === "timeout" ? 1 : 2;
-}
-function latestWaitActivity(member) {
-    const snapshot = waitSnapshot(member.result);
-    if (!snapshot || member.result.state !== "timeout")
-        return Number.NEGATIVE_INFINITY;
-    return snapshot.observedAtMs - (snapshot.activityAgeMs ?? snapshot.durationMs);
-}
-function terminalWaitTime(member) {
-    if (member.result.state !== "terminal")
-        return Number.NEGATIVE_INFINITY;
-    const parsed = Date.parse(member.result.verdict.at);
-    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
-}