@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/cli/render/misc.js

@@ -2,19 +2,24 @@ 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 text = input.errorCode === "PROJECTION_INCOMPATIBLE"
+        ? `${colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`)}\n  ${input.message}`
+        : 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 +28,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})` : ""}`;
@@ -68,9 +71,19 @@ function summarizeProjectionToolLedger(activity, workspaceRoot) {
 function toolCountSegments(summary) {
     return summary.counts.map(({ semanticClass, count }) => `${count} ${rollupCountLabel(semanticClass)}`);
 }
+function projectionSummarySegments(summary) {
+    const segments = toolCountSegments(summary);
+    if (summary.tokens !== undefined) {
+        segments.push(`${compactTokens(summary.tokens)} tok`);
+    }
+    if (summary.costUsd !== undefined) {
+        segments.push(`$${summary.costUsd.toFixed(2)}`);
+    }
+    return segments;
+}
 export function renderProjectionActivitySummary(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = toolCountSegments(summary);
+    const segments = projectionSummarySegments(summary);
     if (segments.length === 0)
         return undefined;
     const spine = input.state === "dead" || input.state === "lost" ? "┆" : "│";
@@ -78,11 +91,7 @@ export function renderProjectionActivitySummary(activity, input) {
 }
 function renderTerminalRollup(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = [
-        ...toolCountSegments(summary),
-        ...(summary.tokens === undefined ? [] : [`${compactTokens(summary.tokens)} tok`]),
-        ...(summary.costUsd === undefined ? [] : [`$${summary.costUsd.toFixed(2)}`]),
-    ];
+    const segments = projectionSummarySegments(summary);
     const lines = input.diagnostic
         ? [fitVariableLine(`${elapsedLabel(input.anchorMs, input.diagnostic.at).padStart(TIME_GUTTER_WIDTH)}┆ ${"warning".padEnd(VERB_WIDTH)} `, compactText(input.diagnostic.text), input.maxColumns)]
         : [];

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";
@@ -23,6 +25,7 @@ function projectionGlyph(state) {
         case "startup-timeout":
             return "!";
         case "unknown":
+        case "incompatible":
             return "?";
     }
 }
@@ -42,38 +45,58 @@ 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"} · age ${formatAgeMs(task.ageMs)} · active ${formatAgeMs(task.activityAgeMs)} · ${task.title}`));
+    if (tasks.omitted > 0) {
+        lines.push(`  · +${tasks.omitted} more — keiyaku task ls`);
+    }
     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)
         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}`] : [];
     });
-    return `  · +${board.omitted.total} not shown (${counts.join(" · ")}) — keiyaku status --all`;
+    return `  · +${board.omitted.total} historical projections not shown (${counts.join(" · ")}) — keiyaku status --all`;
 }
 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";
+        return `done · ${facts}`;
     if (row.state === "killed")
-        return "killed";
+        return `killed · ${facts}`;
     if (row.state === "dismissed")
-        return "dismissed";
+        return `dismissed · ${facts}`;
     if (row.state === "failed")
-        return "failed";
+        return `failed · ${facts}`;
+    if (row.state === "dead")
+        return `dead · ${facts}`;
     if (row.state === "startup-timeout")
-        return "startup timed out";
+        return `startup timed out · ${facts}`;
     if (row.state === "unknown")
-        return "unknown";
-    return formatAgeMs(row.activityAgeMs) ?? "";
+        return `unknown · ${facts}`;
+    if (row.state === "incompatible")
+        return "incompatible history";
+    return facts;
 }
 function renderProjectionTellCounts(row) {
     const { inbox, inflight, submitted, consumed } = row.tellCounts;
@@ -93,10 +116,11 @@ function projectionActivityState(row) {
         case "out": return "running";
         case "startup-timeout": return "stalled";
         case "unknown": return "unknown";
+        case "incompatible": return "unknown";
     }
 }
 function renderProjectionActivityLine(row) {
-    if (row.state === "startup-timeout" || row.state === "unknown")
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible")
         return undefined;
     if (!row.activity)
         return undefined;
@@ -115,27 +139,29 @@ function renderProjectionRow(row) {
                 : row.state);
     const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
     let heading;
-    if (row.state === "startup-timeout" || row.state === "unknown") {
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible") {
         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) · ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
-        const age = renderProjectionAge(row).padEnd(9);
+        const age = renderProjectionAge(row);
         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"
         || row.state === "killed"
         || row.state === "dismissed"
         || row.state === "failed"
-        || row.state === "dead";
+        || row.state === "dead"
+        || row.state === "incompatible";
 }
 export function renderProjectionFilteredStatus(board, projectionId) {
     const head = board.defaultHead ? shortCommitHash(board.defaultHead) : "(no HEAD)";
@@ -143,14 +169,21 @@ 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 (row.observation.compatibility === "incompatible") {
+        return `${lines.join("\n")}\n`;
+    }
     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);

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

@@ -0,0 +1,78 @@
+import { repositoryCoordinateFromAddress } from "../commands/shared.js";
+import { writeCliOutput } from "../output-stream-error-policy.js";
+import { renderResolvedAddressReceipt } from "./address.js";
+import { formatCallNextAction } from "./shared.js";
+function responseText(response) {
+    return response.text;
+}
+function responseData(response) {
+    const payload = response.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload) || "error" in payload)
+        return {};
+    return payload;
+}
+function isCallProjectionFacts(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const facts = value;
+    return typeof facts.id === "string"
+        && (facts.phase === "active" || facts.phase === "done" || facts.phase === "failed"
+            || facts.phase === "dismissed" || facts.phase === "lost" || facts.phase === "quiescent");
+}
+function conversationalFooter(response) {
+    const data = responseData(response);
+    const lines = [];
+    if (response.address) {
+        const projection = data.projection;
+        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
+        const receiptArtifactId = typeof data.revivedArtifactId === "string"
+            ? data.revivedArtifactId
+            : typeof data.artifactId === "string" ? data.artifactId : undefined;
+        lines.push(renderResolvedAddressReceipt(response.address, { artifactId: receiptArtifactId, projectionId: projectionFacts?.id }));
+    }
+    const responsePath = typeof data.responsePath === "string" ? data.responsePath : undefined;
+    const agent = typeof data.agent === "string" ? data.agent : undefined;
+    const meta = data.meta && typeof data.meta === "object" && !Array.isArray(data.meta) ? data.meta : undefined;
+    const warnings = Array.isArray(meta?.warnings) ? meta.warnings.filter((warning) => typeof warning === "string") : [];
+    if (responsePath) {
+        lines.push(`Saved to ${responsePath}.`);
+    }
+    if (agent) {
+        lines.push(`Akuma: ${agent}`);
+    }
+    if (warnings.length > 0) {
+        lines.push("Warnings:", ...warnings.map((warning) => `- ${warning}`));
+    }
+    if (typeof data.summary === "string") {
+        const projection = data.projection;
+        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
+        const artifactId = typeof data.artifactId === "string" ? data.artifactId : undefined;
+        lines.push(formatCallNextAction({
+            projection: projectionFacts,
+            artifactId,
+            repositoryCoordinate: repositoryCoordinateFromAddress(response.address),
+        }));
+    }
+    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)
+        return;
+    if (command === "bind" && flags.dryRun) {
+        // Canonical Markdown already ends with exactly one newline.
+        await writeCliOutput(process.stdout, responseText(response));
+        return;
+    }
+    if (command !== "revive") {
+        await writeCliOutput(process.stdout, `${responseText(response)}\n`);
+        return;
+    }
+    const data = responseData(response);
+    const answer = typeof data.summary === "string" ? data.summary.trim() : responseText(response).trim();
+    const footer = conversationalFooter(response);
+    await writeCliOutput(process.stdout, `${answer}\n`);
+    if (footer) {
+        await writeCliOutput(process.stderr, `${footer}\n`);
+    }
+}