@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/cli/render/errors.js

@@ -6,6 +6,40 @@ import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { ACTOR_IDENTITY, TOOL_NAMES, BUILTIN_AGENT_NAMES } from "../../keiyaku.js";
 import { buildErrorResponse } from "./misc.js";
 import { addressCarrierFromError } from "../../core/addressing.js";
+function renderScopeViolation(evidence) {
+    if (evidence.outcome === "no-positive-match") {
+        return `  ${evidence.path}\n    no positive pattern matched`;
+    }
+    const decisions = evidence.patterns.map((decision) => {
+        const isDecisive = evidence.decisivePattern?.index === decision.index
+            && evidence.decisivePattern?.pattern === decision.pattern;
+        const effectLabel = decision.effect === "exclude" ? "excluded" : "included";
+        if (isDecisive) {
+            return `    ${decision.pattern} → decisive (${effectLabel})`;
+        }
+        return `    ${decision.pattern} → ${effectLabel}`;
+    });
+    return `  ${evidence.path}\n${decisions.join("\n")}`;
+}
+/** CLI face for scope_violation facts. Preserves pre-migration multi-line bytes. */
+export function renderScopeAuditMessage(scope, evidence) {
+    const count = evidence.length;
+    const fileLabel = count === 1 ? "file" : "files";
+    const body = evidence.map(renderScopeViolation).join("\n\n");
+    return [
+        `scope violation — ${count} ${fileLabel} outside declared scope:`,
+        "",
+        body,
+        "",
+        `declared scope: ${scope.join("  ")}`,
+    ].join("\n");
+}
+function renderErrorMessage(error) {
+    if (isFlowError(error) && error.facts?.kind === "scope_violation") {
+        return renderScopeAuditMessage(error.facts.scope, error.facts.violations);
+    }
+    return asMessage(error);
+}
 export function classifyCliError(error) {
     if (isFlowError(error)) {
         return { errorType: "keiyaku_error", errorCode: error.code };
@@ -26,7 +60,7 @@ async function getAvailableActorNames(cwd, fallback) {
     }
 }
 export async function handleCliError(input) {
-    const message = asMessage(input.error);
+    const message = renderErrorMessage(input.error);
     appendDebugLog(`${input.logLabel} error: ${message}`, { cwd: input.cwd, section: "script" });
     const availableActorNames = await getAvailableActorNames(input.cwd, BUILTIN_AGENT_NAMES);
     const hints = pickHintsFromError(input.error, {
@@ -42,6 +76,7 @@ export async function handleCliError(input) {
         message,
         hints,
         review: isFlowError(input.error) ? input.error.review : undefined,
+        facts: isFlowError(input.error) ? input.error.facts : undefined,
         errorType,
         errorCode,
         addressCarrier: addressCarrierFromError(input.error),

package/build/cli/render/format.js

@@ -212,6 +212,10 @@ function truncateStructuredObject(data, parentKey) {
     }
     return truncated;
 }
+/**
+ * Final serialization boundary for command payloads: optional responsePath stamp
+ * plus structured truncation. Callers supply a named *Payload that is JsonObject-compatible.
+ */
 export function buildPayload(data, responsePath) {
     const dataWithPath = responsePath ? { ...data, responsePath } : data;
     const truncatedData = truncateStructuredObject(dataWithPath);

package/build/cli/render/kanshi.js

@@ -4,9 +4,6 @@ function shortHead(hash) {
         return "????????";
     return hash.slice(0, 7);
 }
-function compactWhitespace(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
 function arcSparkline(arcs) {
     if (arcs <= 0)
         return "";
@@ -35,31 +32,28 @@ export function renderKanshiBoard(status) {
     const head = shortHead(status.defaultHead);
     if (status.contracts.length === 0) {
         if (status.targetFilter !== null) {
-            return `現世 ${head} · target ${status.targetFilter}\nno commissions on target ${status.targetFilter}\n`;
+            return `現世 ${head} · target selected\nno commissions on selected target\n`;
         }
         return `現世 ${head} 无在飞契约\n`;
     }
     const header = status.targetFilter !== null
-        ? `現世 ${head} · target ${status.targetFilter}`
+        ? `現世 ${head} · target selected`
         : `現世 ${head}`;
     const lines = [header, ""];
     for (const contract of status.contracts) {
         const glyph = kanshiGlyph(contract);
-        const name = contract.slug;
+        const name = contract.place ? `${contract.slug} @${contract.place}` : contract.slug;
         const spark = arcSparkline(contract.arcs);
         const facts = [];
         const lifecycle = contract.state.state;
         if (lifecycle === "bound" || lifecycle === "active" || lifecycle === "petitioned") {
             facts.push(lifecycle);
         }
-        if (contract.place) {
-            facts.push(`@${contract.place}`);
-        }
-        const arcObjective = compactWhitespace(contract.currentArc.objective || "(no arc objective)");
         const arcMark = contract.currentArc.state === "open"
             ? `a${contract.currentArc.number}+`
             : `a${contract.currentArc.number}`;
-        facts.push(`${arcMark} ${arcObjective}`);
+        facts.push(contract.title);
+        facts.push(arcMark);
         facts.push(`next ${contract.nextStep.detail}`);
         const age = formatAgeMs(contract.lastActiveMs);
         if (age)
@@ -99,7 +93,7 @@ export function renderKanshiBoard(status) {
                 lines.push(`  ! seat ${diagnostic.seat} duplicated with ${diagnostic.with} · ordered by contract id`);
                 continue;
             }
-            lines.push(`  ! target mismatch · petitioned ${diagnostic.petitioned} · derived ${diagnostic.derived}`);
+            lines.push("  ! target mismatch");
         }
     }
     return `${lines.join("\n")}\n`;

package/build/cli/render/kill.js

@@ -0,0 +1,9 @@
+import { textResponse } from "./shared.js";
+/** Default kill acceptance: intent landed; wait is still required for the terminal face. */
+export function buildKillAcceptedResponse(projectionId) {
+    return textResponse(`✓ kill ${projectionId}\n» keiyaku wait ${projectionId}`);
+}
+/** Kill against an already-terminal generation. */
+export function buildKillAlreadyClosedResponse(projectionId) {
+    return textResponse(`· ${projectionId} already closed`);
+}

package/build/cli/render/misc.js

@@ -2,19 +2,22 @@ import { assembleResponse, buildPayload, buildSection, colorizeErrorStatus, FORM
 import { RESPONSE_MARKERS } from "./response-style.js";
 import { formatReview, HINTS_LIST_MAX_ITEMS, REVIEW_SECTION_TITLE, toReviewPayload, } from "./shared.js";
 import { prependAddressReceipt, renderAddressCarrier } from "./address.js";
+import { commissionSlug } from "../../core/ids.js";
 export function buildErrorResponse(input) {
     const shouldRaiseProtocolError = input.errorType === "runtime_error";
     const text = buildErrorText(input);
+    const payload = {
+        error: {
+            code: input.errorCode,
+            message: input.message,
+            hints: input.hints,
+            ...(input.review ? { review: toReviewPayload(input.review) } : {}),
+            ...(input.facts ? { facts: input.facts } : {}),
+        },
+    };
     const response = {
         text,
-        payload: {
-            error: {
-                code: input.errorCode,
-                message: input.message,
-                hints: input.hints,
-                ...(input.review ? { review: toReviewPayload(input.review) } : {}),
-            },
-        },
+        payload,
     };
     if (shouldRaiseProtocolError) {
         response.isError = true;
@@ -23,21 +26,61 @@ export function buildErrorResponse(input) {
 }
 function buildErrorText(input) {
     const errorSection = buildSection("Error", input.message);
+    const recoverySection = input.facts?.kind === "renew_conflict"
+        ? buildSection("Recovery", [
+            "Conflicting paths:",
+            ...input.facts.conflictPaths.map((filePath) => `  ${filePath}`),
+            ...(input.facts.conflictPathCapture.status === "failed"
+                ? [`Conflict-path capture failed: ${input.facts.conflictPathCapture.diagnostic}`]
+                : []),
+            "Delivery branch and worktree were restored; no ledger writes were appended.",
+        ].join("\n"))
+        : null;
     const reviewSection = input.review ? buildSection(REVIEW_SECTION_TITLE, formatReview(input.review)) : null;
-    const hintsSection = buildSection("Hints", formatHints(input.hints, { maxItems: HINTS_LIST_MAX_ITEMS, maxItemChars: FORMAT_LIST_MAX_ITEM_CHARS }));
-    const body = assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, reviewSection, hintsSection].filter((section) => section !== null));
+    const commissionedCarrier = input.addressCarrier && !("expected" in input.addressCarrier)
+        && input.addressCarrier.binding.kind === "commission"
+        ? input.addressCarrier
+        : undefined;
+    const recoveryAddress = commissionedCarrier
+        ? `@${commissionedCarrier.place.display ?? commissionSlug(commissionedCarrier.binding.commissionId)}`
+        : input.facts?.kind === "renew_session"
+            ? `@${commissionSlug(input.facts.commission)}`
+            : undefined;
+    const nextActionSection = input.facts?.kind === "renew_session" && recoveryAddress
+        ? buildSection("Next action", input.facts.nextAction === "resolve-conflicts"
+            ? [
+                "Resolve and stage the conflicting delivery with ordinary Git, then:",
+                `» keiyaku ${recoveryAddress} renew --continue`,
+                "Or restore the pre-renew delivery:",
+                `» keiyaku ${recoveryAddress} renew --abort`,
+            ]
+            : input.facts.nextAction === "continue-or-abort" ? [
+                `» keiyaku ${recoveryAddress} renew --continue`,
+                `» keiyaku ${recoveryAddress} renew --abort`,
+            ] : [`» keiyaku ${recoveryAddress} renew --abort`])
+        : null;
+    const hints = input.facts?.kind === "renew_session"
+        ? []
+        : formatHints(input.hints, { maxItems: HINTS_LIST_MAX_ITEMS, maxItemChars: FORMAT_LIST_MAX_ITEM_CHARS });
+    if (input.facts?.kind === "renew_conflict") {
+        hints.push("your old head survives:", `» git log ${input.facts.recoveryRef}`);
+    }
+    const hintsSection = buildSection("Hints", hints);
+    const body = assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, recoverySection, nextActionSection, reviewSection, hintsSection].filter((section) => section !== null));
     return input.addressCarrier ? `${renderAddressCarrier(input.addressCarrier)}\n${body}` : body;
 }
 export function buildHelpResponse(input) {
+    const payload = {};
     return {
         text: input.text,
-        payload: buildPayload({}),
+        payload: buildPayload(payload),
     };
 }
 export function buildLogResponse(result) {
     const { address: _address, ...resultData } = result;
+    const payload = resultData;
     return prependAddressReceipt({
         text: result.markdown,
-        payload: buildPayload(resultData),
+        payload: buildPayload(payload),
     }, result.address);
 }

package/build/cli/render/petition.js

@@ -1,16 +1,26 @@
+import { commissionSlug } from "../../core/ids.js";
 import { shortCommitHash } from "../../git/commits.js";
 import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnings, } from "./format.js";
 import { DIFF_OVERVIEW_SECTION_TITLE, RESPONSE_MARKERS, WARNING_SECTION_TITLE } from "./response-style.js";
-import { BRANCH_LABEL, INFO_BRANCH_MAX_CHARS, INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, } from "./shared.js";
+import { INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, } from "./shared.js";
 import { prependAddressReceipt } from "./address.js";
+function formatPetitionSealSource(source) {
+    return source.arc === null
+        ? `no open arc · fence ${source.fence}`
+        : `a${source.arc} · fence ${source.fence}▸HEAD`;
+}
 export function buildPetitionPreviewResponse(preview, json) {
+    const source = formatPetitionSealSource(preview.arc.source);
+    const payload = {
+        ...preview,
+        arc: { source },
+    };
     const failed = preview.gates.filter((gate) => gate.result === "failed").length;
     const text = json
-        ? JSON.stringify(preview)
+        ? JSON.stringify(payload)
         : [
-            `contract ${preview.contract}`,
-            `target ${preview.target}`,
-            `arc ${preview.arc.source}`,
+            `contract ${commissionSlug(preview.contract)}`,
+            `arc ${source}`,
             ...preview.gates.map((gate) => {
                 if (gate.result === "not_evaluated")
                     return `gate ${gate.name} · not evaluated`;
@@ -22,35 +32,30 @@ export function buildPetitionPreviewResponse(preview, json) {
         ].join("\n");
     return {
         text,
-        payload: preview,
+        payload,
         ...(failed > 0 ? { exitCode: 1 } : {}),
     };
 }
 export function buildPetitionClaimResponse(result, input) {
     const { status: _status, address: _address, ...resultData } = result;
+    const payload = resultData;
     const renderedCommit = result.commit ? shortCommitHash(result.commit) : undefined;
     const commitSuffix = renderedCommit ? ` [${renderedCommit}]` : "";
-    const summary = result.deletedBranch
-        ? `Merged '${result.deletedBranch}' into '${result.mergedInto}'${commitSuffix}. Deleted feature branch.`
-        : `Merged contract into '${result.mergedInto}'${commitSuffix}.`;
+    const summary = `Claimed contract${commitSuffix}.`;
     const diffSection = result.diff ? buildSection(DIFF_OVERVIEW_SECTION_TITLE, result.diff) : null;
     const ledgerSection = result.ledgerView ? buildSection("Ledger", result.ledgerView) : null;
     const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
     const infoLines = [
         ...formatMaybe("Result", result.result, INFO_COMMIT_MAX_CHARS),
-        ...formatMaybe("Title", input.title, INFO_BRANCH_MAX_CHARS),
+        ...formatMaybe("Title", input.title),
         ...formatMaybe("Plea", input.plea, INFO_PLEA_MAX_CHARS),
         ...formatMaybe("Commit", renderedCommit, INFO_COMMIT_MAX_CHARS),
-        ...formatMaybe("Merged Into", result.mergedInto, INFO_BRANCH_MAX_CHARS),
-        ...formatMaybe("Deleted Branch", result.deletedBranch, INFO_BRANCH_MAX_CHARS),
-        ...formatMaybe(BRANCH_LABEL, result.currentBranch, INFO_BRANCH_MAX_CHARS),
-        ...formatMaybe("Base Branch", result.baseBranch, INFO_BRANCH_MAX_CHARS),
         "Claim Gates: settlement requirements satisfied.",
         ...formatMaybe("Oath", input.oath, INFO_PLEA_MAX_CHARS),
     ];
     const text = assembleResponse(`${RESPONSE_MARKERS.claim} Keiyaku Fulfilled (Claim)`, summary, [ledgerSection, diffSection, warningSection].filter((section) => section !== null), infoLines);
     return prependAddressReceipt({
         text,
-        payload: buildPayload(resultData),
+        payload: buildPayload(payload),
     }, result.address);
 }

package/build/cli/render/projection-activity.js

@@ -41,6 +41,9 @@ function compactTokens(value) {
 }
 function warningText(row) {
     const warning = row.warning;
+    if (warning.reason === "rate-limit") {
+        return `provider rate limit exhausted${row.count > 1 ? ` (${row.count})` : ""}`;
+    }
     if (warning.reason === "retry") {
         const status = warning.errorStatus === null ? "no response" : String(warning.errorStatus);
         return `provider retrying ${warning.attempt}/${warning.maxRetries} · retry in ${formatTimelineDuration(warning.retryDelayMs)} · status ${status}${row.count > 1 ? ` (${row.count})` : ""}`;

package/build/cli/render/shared.js

@@ -1,15 +1,16 @@
-import * as path from "node:path";
-import * as fs from "node:fs";
 import { KEIYAKU_FILE } from "../../keiyaku.js";
+import { commissionSlug, formatCommissionCoordinate } from "../../core/ids.js";
 import { assembleResponse, buildSection, DISPLAY_TEXT_MAX_CHARS, FORMAT_LIST_MAX_ITEM_CHARS, FORMAT_LIST_MAX_ITEMS, formatMaybe, formatWarnings, shellQuote, truncateForDisplay, } from "./format.js";
 import { WARNING_SECTION_TITLE } from "./response-style.js";
 import { prependAddressReceipt } from "./address.js";
 export function textResponse(text) {
+    const payload = {};
     return {
         text,
-        payload: {},
+        payload,
     };
 }
+/** Carrier boundary: data must already be a named command payload assignable to JsonObject. */
 export function coreTextResponse(text, data) {
     return {
         text,
@@ -20,30 +21,61 @@ export async function renderCoreResult(work, render) {
     return render(await work);
 }
 export function buildBindDraftResponse(draftPath) {
-    return coreTextResponse(`Draft saved to ${draftPath}.`, { draftPath });
+    const payload = { draftPath };
+    return coreTextResponse(`Draft saved to ${draftPath}.`, payload);
 }
 export function buildBindResponse(result, cwd) {
-    const displayRoot = result.workspace === "worktree" && fs.existsSync(cwd) ? fs.realpathSync.native(cwd) : cwd;
-    return coreTextResponse([
-        `Bound ${result.id}.`,
-        `workspace: ${result.workspace}`,
-        `path: ${result.worktreePath}`,
-        `ref: ${result.ref}`,
-        ...(result.warnings.length > 0 ? ["Warnings:", ...result.warnings.map((warning) => `- ${warning}`)] : []),
-        ...(result.workspace === "worktree" ? [`next: cd ${path.relative(displayRoot, result.worktreePath) || "."}`] : []),
-    ].join("\n"), {
+    void cwd;
+    const overlapsByCounterparty = new Map();
+    for (const overlap of result.scopeOverlaps) {
+        const counterparty = overlap.contracts[1];
+        const group = overlapsByCounterparty.get(counterparty);
+        if (group)
+            group.push(overlap);
+        else
+            overlapsByCounterparty.set(counterparty, [overlap]);
+    }
+    const overlapWarnings = [...overlapsByCounterparty.entries()].map(([contractId, overlaps]) => renderScopeOverlapGroup(commissionSlug(contractId), overlaps));
+    const place = result.place;
+    const payload = {
         id: result.id,
         ref: result.ref,
         worktreePath: result.worktreePath,
         workspace: result.workspace,
+        place: result.place,
+        target: result.target,
         ledgerHead: result.ledgerHead,
-        warnings: result.warnings,
+        warnings: overlapWarnings,
+        scopeOverlaps: result.scopeOverlaps,
         ...(result.branch ? { branch: result.branch } : {}),
+    };
+    return coreTextResponse([
+        `Bound${place ? ` @${place}` : ""} · commission ${result.id} · target ${result.target}`,
+        ...(overlapWarnings.length > 0 ? ["Warnings:", ...overlapWarnings] : []),
+    ].join("\n"), payload);
+}
+function renderScopeOverlapGroup(contractAddr, overlaps) {
+    const pairs = overlaps.map((overlap) => {
+        const [nextPattern, existingPattern] = overlap.patterns;
+        const evidence = overlap.kind === "potential"
+            ? "potential; no current tracked path proves it"
+            : `concrete; ${overlap.paths.count} current tracked path${overlap.paths.count === 1 ? "" : "s"}: ${overlap.paths.preview.join(", ")}${overlap.paths.truncated ? ", …" : ""}`;
+        return `  ${nextPattern} × ${existingPattern} (${evidence})`;
     });
+    return [
+        `▲ scope overlap with ${contractAddr}:`,
+        ...pairs,
+        `  consider --after ${contractAddr}`,
+    ].join("\n");
 }
 export function buildForfeitResponse(result) {
     const { address: _address, ...resultData } = result;
-    const base = `Forfeited ${result.contractId}.`;
+    const payload = resultData;
+    const place = result.address.binding.kind === "commission"
+        ? (result.address.place?.display ?? null)
+        : null;
+    const coordinate = formatCommissionCoordinate({ commissionId: result.contractId, place });
+    const base = `Forfeited ${coordinate}.`;
     const warnings = [
         ...(result.cleanup.worktreeRemoveFailure
             ? [
@@ -52,18 +84,22 @@ export function buildForfeitResponse(result) {
             : []),
         ...(result.cleanup.branchDeleteFailure
             ? [
-                `Could not delete contract branch ${result.cleanup.branchDeleteFailure.name}: ${result.cleanup.branchDeleteFailure.reason}`,
+                `Could not delete contract branch: ${redactBranchReference(result.cleanup.branchDeleteFailure.reason, result.cleanup.branchDeleteFailure.name)}`,
             ]
             : []),
     ];
     if (warnings.length === 0) {
-        return prependAddressReceipt(coreTextResponse(base, resultData), result.address);
+        return prependAddressReceipt(coreTextResponse(base, payload), result.address);
     }
     const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(warnings));
-    return prependAddressReceipt(coreTextResponse(assembleResponse(base, "", [warningSection].filter((section) => section !== null)), resultData), result.address);
+    return prependAddressReceipt(coreTextResponse(assembleResponse(base, "", [warningSection].filter((section) => section !== null)), payload), result.address);
+}
+function redactBranchReference(message, branch) {
+    return message
+        .replaceAll(`refs/heads/${branch}`, "contract branch")
+        .replaceAll(branch, "contract branch");
 }
 export const RULES_SECTION_MAX_CHARS = 5000;
-export const BRANCH_LABEL = "Workspace";
 export const INFO_SECTION_TITLE = "Info";
 export const HINTS_SECTION_TITLE = "Hints";
 export const REVIEW_SECTION_TITLE = "Review";
@@ -125,12 +161,15 @@ export function formatDurableReviveCommand(input) {
         ? `keiyaku revive ${input.artifactId} --repo ${shellQuote(input.repositoryCoordinate)}`
         : `keiyaku revive ${input.artifactId}`;
 }
+export function formatTellCommand(projectionId, body) {
+    return `keiyaku tell ${projectionId} [--wait DURATION] ${body}`;
+}
 export function projectionRejoinHintLines(projectionId) {
     return [
         "Come back for the result:",
         `  » keiyaku wait ${projectionId} [--timeout DURATION]`,
         "Steer it while it works:",
-        `  » keiyaku tell ${projectionId} "your words"`,
+        `  » ${formatTellCommand(projectionId, '"your words"')}`,
     ];
 }
 export function formatCallNextAction(input) {
@@ -142,7 +181,7 @@ export function formatCallNextAction(input) {
             "The akuma is back.",
             ...(input.artifactId ? [`record: ${input.artifactId}`] : []),
             "talk to it:",
-            `  » keiyaku tell ${input.projection.alias ?? input.projection.id} "your words"`,
+            `  » ${formatTellCommand(input.projection.alias ?? input.projection.id, '"your words"')}`,
         ].join("\n");
     }
     return "» keiyaku status";

package/build/cli/render/skills.js

@@ -0,0 +1,10 @@
+/** Skills install success receipt: target rows plus optional warning block. */
+export function renderSkillsInstallReceipt(result) {
+    return [
+        "Installed official Keiyaku skills:",
+        ...result.targets.map((target) => `- ${target.path} -> ${target.source} (${target.status})`),
+        ...(result.warnings.length > 0
+            ? ["", "## Warning", ...result.warnings.map((warning) => `- ${warning}`)]
+            : []),
+    ].join("\n");
+}

package/build/cli/render/status.js

@@ -3,6 +3,8 @@ import { shortCommitHash } from "../../git/commits.js";
 import { formatAgeMs } from "./format.js";
 import { renderKanshiBoard } from "./kanshi.js";
 import { renderProjectionActivitySummary, } from "./projection-activity.js";
+import { renderTerminalFailureFace, terminalFailureCodeSuffix } from "./terminal-failure.js";
+import { formatTellCommand } from "./shared.js";
 export const STATUS_DISEASES_SECTION_TITLE = "Diseases";
 export const STATUS_PROJECTION_SECTION_TITLE = "akuma";
 export const STATUS_CLAIM_RECEIPTS_SECTION_TITLE = "claim receipts";
@@ -42,13 +44,26 @@ function renderTaskStatusSection(tasks) {
         tasks.blocked > 0 ? `${tasks.blocked} blocked` : undefined,
     ].filter((segment) => segment !== undefined);
     const lines = [`tasks · ${segments.join(" / ")}`];
-    lines.push(...tasks.topTasks.map((task) => `  ${task.id.slice(0, 9)} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · ${task.title}`));
+    lines.push(...tasks.topTasks.map((task) => `  ${task.id} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · ${task.title}`));
+    if (tasks.omitted > 0) {
+        lines.push(`  · +${tasks.omitted} more · shown in_progress then ready; each by priority, created, id`);
+    }
     return `${lines.join("\n")}\n`;
 }
+function projectionDiagnosticDetail(diagnostic) {
+    if (diagnostic.kind === "oversized-projection-file" && diagnostic.fileName) {
+        return `${diagnostic.fileName} exceeds status read limit · newest complete events retained`;
+    }
+    return diagnostic.detail ?? diagnostic.kind;
+}
 function renderProjectionDiagnostics(row) {
-    if (row.diagnostics.length === 0)
-        return "";
-    return ` · diag ${row.diagnostics.map((diagnostic) => diagnostic.detail).join("; ")}`;
+    const details = row.diagnostics.map(projectionDiagnosticDetail);
+    return details.length > 0 ? ` · diag ${details.join("; ")}` : "";
+}
+function terminalFailureSuffix(row) {
+    return row.terminalFailure
+        ? ` · ${terminalFailureCodeSuffix(row.terminalFailure.code)}`
+        : "";
 }
 function renderProjectionOmission(board) {
     if (!board.omitted)
@@ -61,14 +76,17 @@ function renderProjectionOmission(board) {
     return `  · +${board.omitted.total} not shown (${counts.join(" · ")}) — keiyaku status --all`;
 }
 function renderProjectionAge(row) {
+    const age = formatAgeMs(row.activityAgeMs);
     if (row.state === "done")
-        return "done";
+        return age ? `done ${age}` : "done";
     if (row.state === "killed")
-        return "killed";
+        return age ? `killed ${age}` : "killed";
     if (row.state === "dismissed")
-        return "dismissed";
+        return age ? `dismissed ${age}` : "dismissed";
     if (row.state === "failed")
-        return "failed";
+        return age ? `failed ${age}` : "failed";
+    if (row.state === "dead")
+        return age ? `dead ${age}` : "dead";
     if (row.state === "startup-timeout")
         return "startup timed out";
     if (row.state === "unknown")
@@ -117,18 +135,19 @@ function renderProjectionRow(row) {
     let heading;
     if (row.state === "startup-timeout" || row.state === "unknown") {
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else if (row.state === "minting") {
-        heading = `  ${glyph} ${identity.padEnd(18)} (minting)${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity.padEnd(18)} (minting)${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
         const age = renderProjectionAge(row).padEnd(9);
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     const activity = renderProjectionActivityLine(row);
-    return activity ? [heading, activity] : [heading];
+    const drillDown = row.terminalFailure ? [`      » keiyaku wait ${row.alias ?? row.id}`] : [];
+    return activity ? [heading, activity, ...drillDown] : [heading, ...drillDown];
 }
 function isTerminalProjectionStatus(row) {
     return row.state === "done"
@@ -143,14 +162,18 @@ export function renderProjectionFilteredStatus(board, projectionId) {
     const row = board.projections?.rows.find((candidate) => candidate.id === projectionId);
     if (!row)
         return `${heading}\nno projections on projection ${projectionId}\n`;
+    if (row.state === "failed" || row.terminalFailure) {
+        // Same face bytes as wait; CLI success write supplies the final newline.
+        return renderTerminalFailureFace(projectionId, row.terminalFailure).join("\n");
+    }
     const lines = [heading, "", ...renderProjectionRow(row), ""];
     if (!isTerminalProjectionStatus(row))
-        lines.push(`» keiyaku tell ${projectionId} "..."`);
+        lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
     lines.push(`» keiyaku wait ${projectionId}`);
     return `${lines.join("\n")}\n`;
 }
 export function renderProjectionStatusSection(board) {
-    if (!board || board.rows.length === 0)
+    if (!board || (board.rows.length === 0 && !board.omitted))
         return "";
     const lines = board.rows.flatMap(renderProjectionRow);
     const omission = renderProjectionOmission(board);