@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/render/execution-progress.d.ts

@@ -1,8 +1,12 @@
-import type { ExecutionEvent } from "../../library/execution.js";
-import { type TextRenderContext } from "./terminal.js";
+import type { ExecutionObservation } from "../../protocol/execution-observation.js";
 import { type StatusLineOptions, type StatusLineStream } from "./status-line.js";
-/** Sparse rendering for consumers that do not own a live stream. */
-export declare function executionProgressLines(event: ExecutionEvent, context: TextRenderContext): readonly string[];
+import { type TextRenderContext } from "./terminal.js";
+/**
+ * Sparse rendering for consumers that do not own a live stream. Admitted facts and phase stages are not durable
+ * output: the receipt names admitted facts once, and a stage start is a live-frame claim that must never freeze
+ * into scrollback. Only completed verification facts and bounded live output survive here.
+ */
+export declare function executionProgressLines(event: ExecutionObservation, context: TextRenderContext): readonly string[];
 export type ExecutionProgressOptions = StatusLineOptions & Readonly<{
     stream: StatusLineStream;
     context: TextRenderContext;
@@ -18,10 +22,18 @@ export declare class ExecutionProgressRenderer {
     private phaseUnknown;
     private readonly liveOutput;
     constructor(input: ExecutionProgressOptions);
-    consume(event: ExecutionEvent): Promise<void>;
+    consume(event: ExecutionObservation): Promise<void>;
     finish(): void;
     private consumeVerification;
     private write;
     private finalMark;
 }
-export declare function renderExecutionProgress(events: AsyncIterable<ExecutionEvent>, input: ExecutionProgressOptions): Promise<void>;
+/**
+ * One renderer fed directly by the invocation's observer; events keep transport order through a
+ * serialization chain, and a dead destination still aborts the live frame. There is no subscription
+ * queue and no second state machine.
+ */
+export declare function createExecutionProgressRenderer(input: ExecutionProgressOptions): Readonly<{
+    observe(event: ExecutionObservation): void;
+    finish(): Promise<void>;
+}>;

package/build/src/cli/render/execution-progress.js

@@ -1,5 +1,5 @@
-import { renderOpaqueBlock, safeText } from "./terminal.js";
 import { StatusLine } from "./status-line.js";
+import { renderOpaqueBlock, safeText } from "./terminal.js";
 const LIVE_OUTPUT_BYTES = 4 * 1024;
 function boundedUtf8Prefix(value, maximumBytes = LIVE_OUTPUT_BYTES) {
     let bytes = 0;
@@ -22,9 +22,6 @@ function phaseDetail(observation) {
         return `declaration ${observation.index ?? "?"}/${observation.total ?? "?"}`;
     return observation.name === undefined ? observation.phase : `${observation.phase} · ${safeText(observation.name)}`;
 }
-function phaseStartLine(observation) {
-    return `● ${[phaseDetail(observation), ...(observation.cwd === undefined ? [] : [safeText(observation.cwd)])].join(" · ")}`;
-}
 function phaseMark(outcome) {
     if (outcome === undefined)
         return "?";
@@ -115,21 +112,21 @@ class VerificationLiveOutput {
         return lines;
     }
 }
-/** Sparse rendering for consumers that do not own a live stream. */
+/**
+ * Sparse rendering for consumers that do not own a live stream. Admitted facts and phase stages are not durable
+ * output: the receipt names admitted facts once, and a stage start is a live-frame claim that must never freeze
+ * into scrollback. Only completed verification facts and bounded live output survive here.
+ */
 export function executionProgressLines(event, context) {
     switch (event.kind) {
         case "admitted":
-            return [`✓ admitted ${event.fact.kind} · ${event.contractId}`];
-        case "verification":
-            return event.observation.kind === "output"
-                ? outputLines(event.observation, context)
-                : [
-                    event.observation.state === "started"
-                        ? phaseStartLine(event.observation)
-                        : phaseFinishLine(event.observation),
-                ];
         case "stage":
-            return [`${event.state === "started" ? "●" : "✓"} ${event.stage}`];
+            return [];
+        case "verification": {
+            if (event.observation.kind === "output")
+                return outputLines(event.observation, context);
+            return event.observation.state === "started" ? [] : [phaseFinishLine(event.observation)];
+        }
         case "progress-dropped":
             return [`progress dropped ${event.count} event${event.count === 1 ? "" : "s"}`];
     }
@@ -179,8 +176,6 @@ export class ExecutionProgressRenderer {
             this.verificationStartedAt ??= (this.input.now ?? (() => performance.now()))();
             if (this.status.isTTY)
                 this.status.show((duration) => `verify  ● ${phaseDetail(observation)} · ${elapsed(duration)}`);
-            else
-                await this.write([phaseStartLine(observation)]);
             return;
         }
         await this.write(this.liveOutput.finish(this.input.context));
@@ -211,22 +206,30 @@ export class ExecutionProgressRenderer {
         return this.phaseFailed || this.declarationFailed ? "×" : this.phaseUnknown ? "?" : "✓";
     }
 }
-export async function renderExecutionProgress(events, input) {
+/**
+ * One renderer fed directly by the invocation's observer; events keep transport order through a
+ * serialization chain, and a dead destination still aborts the live frame. There is no subscription
+ * queue and no second state machine.
+ */
+export function createExecutionProgressRenderer(input) {
     const renderer = new ExecutionProgressRenderer(input);
     const destination = watchDestination(input.stream);
-    const iterator = events[Symbol.asyncIterator]();
-    try {
-        for (;;) {
-            const next = await Promise.race([iterator.next(), destination.promise]);
-            if (next.done === true)
-                break;
-            await renderer.consume(next.value);
-        }
-        renderer.finish();
-    }
-    finally {
-        destination.detach();
-    }
+    let chain = Promise.resolve();
+    return {
+        observe: (event) => {
+            chain = chain.then(() => renderer.consume(event));
+            chain.catch(() => undefined);
+        },
+        finish: async () => {
+            try {
+                await Promise.race([destination.promise, chain]);
+                renderer.finish();
+            }
+            finally {
+                destination.detach();
+            }
+        },
+    };
 }
 /** Reject when the destination dies while the producer is still owned. */
 function watchDestination(stream) {

package/build/src/cli/render/kanshi-akuma.d.ts

@@ -1,8 +1,7 @@
 import type { KanshiReport } from "../../kanshi/index.js";
 import { type TextRenderContext } from "./terminal.js";
 declare const NARROW_COLUMNS = 72;
-declare function akumaMark(life: string): string;
 declare function endpointFact(id: string, observed: string | undefined): string;
 declare function renderAkuma(report: KanshiReport, context: TextRenderContext): readonly string[];
 declare function formatAge(source: string | null | undefined, observedAt: string): string;
-export { akumaMark, endpointFact, formatAge, NARROW_COLUMNS, renderAkuma };
+export { endpointFact, formatAge, NARROW_COLUMNS, renderAkuma };

package/build/src/cli/render/kanshi-akuma.js

@@ -1,5 +1,6 @@
 import { snapshotActivityLines } from "./akuma-activity.js";
-import { elapsedMilliseconds, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { akumaMark } from "./marks.js";
+import { ageText, elapsedMilliseconds, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
 const NARROW_COLUMNS = 72;
 const ACTIVITY_INDENT = "  ";
 function mostRecentTimestamp(...values) {
@@ -23,21 +24,10 @@ function akumaStatusTone(row, observedAt) {
         return "recent";
     return null;
 }
-function akumaMark(life) {
-    return life === "running"
-        ? "●"
-        : life === "asleep"
-            ? "○"
-            : life === "killed"
-                ? "×"
-                : life === "stranded" || life === "stillborn" || life === "untidy"
-                    ? "!"
-                    : "?";
-}
 /** Bounded latest semantic entry, rendered by the same activity renderer as a targeted snapshot. */
 function latestActivityLines(snapshot, context) {
     const bounded = { ...context, columns: Math.max(1, context.columns - ACTIVITY_INDENT.length) };
-    return snapshotActivityLines(snapshot, bounded, { latest: true }).map((line) => `${ACTIVITY_INDENT}${line}`);
+    return snapshotActivityLines(snapshot, bounded, { latest: true, tailAnswer: true }).map((line) => `${ACTIVITY_INDENT}${line}`);
 }
 function akumaLabel(row) {
     const aliases = row.aliases ?? [];
@@ -98,17 +88,6 @@ function renderAkuma(report, context) {
 function formatAge(source, observedAt) {
     if (source === null || source === undefined)
         return "—";
-    const sourceMs = Date.parse(source);
-    const observedMs = Date.parse(observedAt);
-    if (sourceMs > observedMs)
-        return "now";
-    const seconds = Math.floor((observedMs - sourceMs) / 1_000);
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+    return ageText(source, observedAt);
 }
-export { akumaMark, endpointFact, formatAge, NARROW_COLUMNS, renderAkuma };
+export { endpointFact, formatAge, NARROW_COLUMNS, renderAkuma };

package/build/src/cli/render/kanshi.js

@@ -1,10 +1,13 @@
-import { abbreviateGitIds, afterWording, candidateIntegrationFacts, dependentWording, displayGitId, gateFact, gitIdsInRow, mergeSummary, targetFacts, } from "./contract-observation.js";
-import { DEFAULT_CLI_COLUMNS, entityLines, elapsedMilliseconds, identityLine, plumbFacts, RECENT_TONE_MS, renderSectionBlock, linkedEntityLines, safeText, tone, } from "./terminal.js";
-import { akumaMark, endpointFact, formatAge, NARROW_COLUMNS, renderAkuma } from "./kanshi-akuma.js";
+import { abbreviateGitIds, afterWording, progressStrip, displayGitId, gateFact, gitIdsInRow, lifecycleWord, mergeSummary, targetMovementFacts, verificationFact, } from "./contract-observation.js";
+import { DEFAULT_CLI_COLUMNS, entityLines, elapsedMilliseconds, identityLine, plumbFacts, RECENT_TONE_MS, renderBoundedPayload, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { endpointFact, formatAge, NARROW_COLUMNS, renderAkuma } from "./kanshi-akuma.js";
+import { contractMark, taskDispositionMark } from "./marks.js";
 import { dispositionText } from "./task.js";
 const REVIEW_ATTENTION_MS = 15 * 60 * 1_000;
 const PENDING_ATTENTION_MS = 60 * 60 * 1_000;
 function contractHasError(row) {
+    if (row.phase === "claimed" || row.phase === "abandoned")
+        return row.title === null;
     return (row.title === null ||
         row.gates.reports.some((report) => report.current.kind === "attested" && report.current.verdict === "unsatisfied") ||
         row.targetLag.kind === "unknown" ||
@@ -16,37 +19,13 @@ function contractStatusTone(row, observedAt) {
     if (contractHasError(row))
         return "alert";
     const phaseAge = elapsedMilliseconds(row.phaseAt, observedAt);
-    if (row.phase === "tendered" && phaseAge !== null && phaseAge >= REVIEW_ATTENTION_MS)
+    if (row.phase === "delivered" && phaseAge !== null && phaseAge >= REVIEW_ATTENTION_MS)
         return "attention";
-    if ((row.phase === "waiting" || row.phase === "bound") && phaseAge !== null && phaseAge >= PENDING_ATTENTION_MS)
+    if (row.phase === "bound" && phaseAge !== null && phaseAge >= PENDING_ATTENTION_MS)
         return "attention";
     const journalAge = elapsedMilliseconds(row.lastJournalAt, observedAt);
     return journalAge !== null && journalAge <= RECENT_TONE_MS ? "recent" : null;
 }
-function contractMark(row) {
-    if (row.phase === "claimed")
-        return "✓";
-    if (row.phase === "abandoned")
-        return "×";
-    if (row.title === null)
-        return "?";
-    if (row.gates.reports.some((report) => report.current.kind === "attested" && report.current.verdict === "unsatisfied"))
-        return "!";
-    if (row.targetLag.kind === "unknown")
-        return "?";
-    if (row.phase === "waiting" || row.phase === "tendered")
-        return "⧗";
-    return "●";
-}
-function taskMark(row) {
-    if (row.disposition === "done")
-        return "✓";
-    if (row.disposition === "drop")
-        return "×";
-    if (row.disposition === "on_hold")
-        return "⧗";
-    return row.disposition === "in_progress" ? "●" : row.disposition === "blocked" ? "‖" : "○";
-}
 function gitAbbreviations(report) {
     const ids = [];
     if (report.contracts.kind !== "present")
@@ -71,24 +50,9 @@ function workspaceState(row) {
         .map(([name, count]) => `${name} ${count}`);
     return counts.length === 0 ? "workspace  dirty" : `workspace  dirty · ${counts.join(" · ")}`;
 }
-function mergeFacts(row, selected, abbreviations) {
-    const observation = row.workspaceObservation;
-    const summary = mergeSummary(observation);
-    if (summary === undefined ||
-        (observation.kind !== "clean" && observation.kind !== "dirty") ||
-        observation.merge === null)
-        return [];
-    if (!selected)
-        return [summary];
-    const paths = observation.merge.unmergedPaths;
-    return [
-        summary,
-        `merge head  ${displayGitId(observation.merge.head, abbreviations)}`,
-        ...(paths.length === 0 ? ["unmerged paths  none"] : paths.map((path) => `unmerged path  ${path}`)),
-        ...(observation.merge.handoffBase === undefined
-            ? []
-            : ["saved  worktree bytes before projection", `handoff base  ${observation.merge.handoffBase}`]),
-    ];
+function mergeFacts(row) {
+    const summary = mergeSummary(row.workspaceObservation);
+    return summary === undefined ? [] : [summary];
 }
 function linkedTask(report, taskId) {
     if (report.tasks.kind !== "present")
@@ -96,50 +60,31 @@ function linkedTask(report, taskId) {
     const task = report.tasks.value.rows.find((candidate) => candidate.id === taskId);
     return task === undefined
         ? `! ${taskId} · unavailable`
-        : `${taskMark(task)} ${task.id} · ${dispositionText(task.disposition)}`;
-}
-function linkedAkuma(report, id, aliases) {
-    const alias = aliases.length === 0 ? "" : ` (${aliases.join(" ")})`;
-    if (report.akuma.kind !== "present")
-        return `! ${id}${alias} · unavailable`;
-    const akuma = report.akuma.value.rows.find((candidate) => candidate.id === id);
-    return akuma === undefined
-        ? `! ${id}${alias} · unavailable`
-        : `${akumaMark(akuma.life)} ${id}${alias} · ${akuma.life} · ${formatAge("lifeAt" in akuma ? akuma.lifeAt : null, report.observedAt)}`;
+        : `${taskDispositionMark(task.disposition)} ${task.id} · ${dispositionText(task.disposition)}`;
 }
 function isTerminalAkuma(life) {
     return life === "killed" || life === "stillborn";
 }
-function linkedFacts(row, report) {
-    const linked = [];
-    if (row.holder.kind === "held")
-        linked.push(linkedTask(report, row.holder.taskId));
-    if (row.holder.kind === "unavailable")
-        linked.push("! task · unavailable");
-    for (const attached of row.fleet)
-        linked.push(linkedAkuma(report, attached.id, attached.aliases));
-    return linked;
-}
 function linkedAkumaSummary(row, report) {
-    if (row.fleet.length === 0)
+    if (row.roster.length === 0)
         return undefined;
     if (report.akuma.kind !== "present")
         return "akuma  unavailable";
     const byId = new Map(report.akuma.value.rows.map((akuma) => [akuma.id, akuma]));
-    const known = row.fleet
+    const known = row.roster
         .map((attached) => byId.get(attached.id))
         .filter((akuma) => akuma !== undefined);
     if (known.length === 0)
-        return `akuma  ${row.fleet.length} · unavailable`;
+        return `akuma  ${row.roster.length} · unavailable`;
     const live = known.filter((akuma) => !isTerminalAkuma(akuma.life)).length;
     const terminal = known.length - live;
-    const facts = [`akuma  ${row.fleet.length}`];
+    const facts = [`akuma  ${row.roster.length}`];
     if (live > 0)
         facts.push(`${live} live`);
     if (terminal > 0)
         facts.push(`${terminal} terminal`);
-    if (known.length < row.fleet.length)
-        facts.push(`${row.fleet.length - known.length} unavailable`);
+    if (known.length < row.roster.length)
+        facts.push(`${row.roster.length - known.length} unavailable`);
     return facts.join(" · ");
 }
 function semanticBlock(_name, facts, _context) {
@@ -147,15 +92,48 @@ function semanticBlock(_name, facts, _context) {
         return [];
     return facts.map((fact) => `  ${safeText(fact)}`);
 }
-function namespaceTaskFacts(row) {
-    if (row.namespaceTasks === undefined)
-        return [];
-    if (row.namespaceTasks.kind === "absent")
+function payload(label, text, context) {
+    return renderBoundedPayload({
+        text,
+        first: `  ${label}  `,
+        continuation: "    │ ",
+        columns: context.columns,
+        maxLines: 3,
+        quote: "“",
+        openQuote: false,
+        truncated: false,
+    });
+}
+function liveAlarms(row, report) {
+    return [
+        ...mergeFacts(row),
+        ...(row.holder.kind === "unavailable" ? ["task unavailable"] : []),
+        ...(row.holder.kind === "held" && linkedTask(report, row.holder.taskId).startsWith("!")
+            ? ["task unavailable"]
+            : []),
+        ...(row.issue === undefined ? [] : ["pending reconciliation"]),
+        ...(row.workspaceObservation.kind === "failed" || row.workspaceObservation.kind === "unavailable"
+            ? [workspaceState(row)]
+            : []),
+    ].map((alarm) => `! ${alarm}`);
+}
+function terminalFacts(row, context, abbreviations) {
+    if (row.phase === "abandoned")
+        return row.abandonNote === undefined ? [] : payload("note", row.abandonNote, context);
+    const integration = row.delivery?.integration.snapshot;
+    const review = row.gates.reports.find((gate) => gate.gate === "reviewed");
+    return [
+        ...(integration === undefined ? [] : [`landed  ${displayGitId(integration, abbreviations)}`]),
+        ...(review?.current.kind === "attested" && review.current.summary !== undefined
+            ? payload("review", review.current.summary, context)
+            : []),
+    ];
+}
+function staleVerificationFacts(row) {
+    if (row.verification?.kind !== "recorded" || row.verification.snapshot === row.delivery?.integration.snapshot)
         return [];
-    if (row.namespaceTasks.kind === "failed") {
-        return [`failed ${row.namespaceTasks.failure.message}`];
-    }
-    return row.namespaceTasks.value.map((task) => `${taskMark(task)} ${task.id} · ${dispositionText(task.disposition)} · P${task.priority} · ${task.title}`);
+    const fact = verificationFact(row.verification);
+    return fact === undefined ? [] : [fact];
 }
 function renderSelectedContractRow(row, report, context, abbreviations) {
     const title = row.title ?? "title unavailable";
@@ -164,66 +142,69 @@ function renderSelectedContractRow(row, report, context, abbreviations) {
         ...entityLines({
             mark: statusTone === null ? contractMark(row) : tone(contractMark(row), statusTone, context.color),
             identity: row.id,
-            state: `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`,
+            state: `${lifecycleWord(row.phase)} · ${formatAge(row.phaseAt, report.observedAt)}`,
             title,
             facts: [],
             context,
         }),
     ];
-    lines.push(...semanticBlock("after", row.after.map(afterWording), context));
-    lines.push(...semanticBlock("dependents", row.dependents.map(dependentWording), context));
-    const gateFacts = row.gates.reports.flatMap((gate) => [
-        `${gateFact(gate)}${gate.current.kind === "attested" ? ` · ${formatAge(gate.current.at, report.observedAt)}` : ""}`,
-        ...(gate.current.kind === "attested" && gate.current.summary !== undefined
-            ? [`summary  ${gate.gate} · ${gate.current.summary}`]
-            : []),
-    ]);
-    lines.push(...semanticBlock("gates", gateFacts, context));
-    lines.push(...semanticBlock("candidate/integration", candidateIntegrationFacts(row.delivery, row.verification, abbreviations), context));
-    lines.push(...semanticBlock("target", targetFacts(row, abbreviations), context));
-    const workspaceFacts = [workspaceState(row)];
-    if (row.workspaceObservation.kind !== "unappointed" &&
-        row.workspaceObservation.kind !== "failed" &&
-        row.workspaceObservation.location.kind === "worktree") {
-        workspaceFacts.push(`worktree  ${row.workspaceObservation.location.path}`);
+    if (row.phase === "claimed" || row.phase === "abandoned") {
+        const outcome = terminalFacts(row, context, abbreviations);
+        lines.push(...outcome.map((fact) => (fact.startsWith("  ") ? fact : `  ${safeText(fact)}`)));
+        return lines;
     }
-    lines.push(...semanticBlock("workspace/merge", [...workspaceFacts, ...mergeFacts(row, true, abbreviations)], context));
-    const attachments = [...linkedFacts(row, report)];
-    if (row.issue !== undefined)
-        lines.push(...plumbFacts([`lag  target-checkout-retained · ${row.issue.target}`], context.columns));
-    lines.push(...linkedEntityLines(attachments, context.columns));
-    lines.push(...semanticBlock("namespace tasks", namespaceTaskFacts(row), context));
-    const observation = row.workspaceObservation;
-    if ((observation.kind === "clean" || observation.kind === "dirty") && observation.merge?.recovery !== undefined) {
-        lines.push(`  deliver  ${safeText(observation.merge.recovery.deliver)} · reads worktree bytes, not index`);
+    if (row.phase === "bound") {
+        lines.push(...semanticBlock("gates", row.gates.reports.map(gateFact), context));
+        lines.push(...semanticBlock("prerequisites", row.after.filter((edge) => edge.endpoint.kind !== "claimed").map(afterWording), context));
+        lines.push(...semanticBlock("ball", [progressStrip(row)], context));
+        const akuma = linkedAkumaSummary(row, report);
+        if (akuma !== undefined)
+            lines.push(...semanticBlock("akuma", [akuma], context));
+        if (row.worktreePath !== null)
+            lines.push(...semanticBlock("worktree", [`worktree  ${row.worktreePath}`], context));
+    }
+    else {
+        lines.push(...semanticBlock("ball", [progressStrip(row)], context));
+        lines.push(...semanticBlock("prerequisites", row.after.filter((edge) => edge.endpoint.kind !== "claimed").map(afterWording), context));
+        if (row.delivery !== null) {
+            lines.push(...semanticBlock("candidate", [
+                `candidate  ${displayGitId(row.delivery.tenderSnapshot, abbreviations)}`,
+                `integration result  ${displayGitId(row.delivery.integration.snapshot, abbreviations)}${row.verification?.kind === "recorded" && row.verification.snapshot === row.delivery.integration.snapshot ? ` · verification ${row.verification.verdict}` : ""}${row.targetObservation?.drift === true ? " · target moved since" : ""}`,
+                ...(row.targetObservation?.drift === true ? targetMovementFacts(row, abbreviations) : []),
+            ], context));
+        }
+        lines.push(...semanticBlock("verification", staleVerificationFacts(row), context));
+        const deniedReview = row.gates.reports.find((gate) => gate.gate === "reviewed" && gate.current.kind === "attested" && gate.current.verdict === "unsatisfied");
+        lines.push(...semanticBlock("gates", row.gates.reports
+            .filter((gate) => gate !== deniedReview || gate.current.kind !== "attested" || gate.current.summary === undefined)
+            .map(gateFact), context));
+        if (deniedReview?.current.kind === "attested" && deniedReview.current.summary !== undefined)
+            lines.push(...payload("review  ×", deniedReview.current.summary, context));
     }
+    lines.push(...semanticBlock("alarms", liveAlarms(row, report), context));
     return lines;
 }
 function renderWorldContractRow(row, report, context) {
     const title = row.title ?? "title unavailable";
     const abbreviations = gitAbbreviations(report);
-    const contractFacts = [
-        ...candidateIntegrationFacts(row.delivery, row.verification, abbreviations),
-        ...targetFacts(row, abbreviations),
-        ...[],
-        ...(linkedAkumaSummary(row, report) === undefined ? [] : [linkedAkumaSummary(row, report)]),
-        ...row.after.map(afterWording),
-        ...(row.dependents.length === 0 ? [] : [`dependents  ${row.dependents.map(dependentWording).join(" · ")}`]),
-        ...row.gates.reports.map(gateFact),
-    ];
-    const linkedFacts = [
-        ...(row.holder.kind === "held" ? [linkedTask(report, row.holder.taskId)] : []),
-        ...(row.holder.kind === "unavailable" ? ["! task · unavailable"] : []),
-    ];
+    const contractFacts = row.phase === "claimed" || row.phase === "abandoned"
+        ? terminalFacts(row, context, abbreviations)
+            .filter((fact) => !fact.startsWith("  "))
+            .slice(0, 1)
+        : [
+            progressStrip(row),
+            ...(linkedAkumaSummary(row, report) === undefined ? [] : [linkedAkumaSummary(row, report)]),
+            ...liveAlarms(row, report),
+        ];
     const statusTone = contractStatusTone(row, report.observedAt);
     return entityLines({
         mark: statusTone === null ? contractMark(row) : tone(contractMark(row), statusTone, context.color),
         identity: row.id,
-        state: `${row.phase} · ${formatAge(row.lastJournalAt, report.observedAt)}`,
+        state: formatAge(row.phaseAt, report.observedAt),
         title,
         facts: contractFacts,
         context,
-    }).concat(linkedEntityLines(linkedFacts, context.columns));
+    });
 }
 function renderContracts(report, context) {
     const section = report.contracts;
@@ -274,12 +255,12 @@ function renderTasks(report, context) {
         const association = relation.length === 0 ? "" : ` · ${relation.join(" · ")}`;
         if (context.columns > NARROW_COLUMNS) {
             return [
-                identityLine(taskMark(row), row.id, `· ${dispositionText(row.disposition)} · P${row.priority} · ${row.title}${association}`),
+                identityLine(taskDispositionMark(row.disposition), row.id, `· ${dispositionText(row.disposition)} · P${row.priority} · ${row.title}${association}`),
                 ...plumbFacts([...childFacts, ...blockerFacts], context.columns),
             ];
         }
         return entityLines({
-            mark: taskMark(row),
+            mark: taskDispositionMark(row.disposition),
             identity: row.id,
             state: `${dispositionText(row.disposition)} · P${row.priority}`,
             title: row.title,
@@ -299,8 +280,6 @@ function renderTasks(report, context) {
 export function renderKanshiText(report, context = { columns: DEFAULT_CLI_COLUMNS, color: false }, selection = "world") {
     if (selection === "contract")
         return renderSelectedContract(report, context).join("\n");
-    return [renderContracts(report, context), renderAkuma(report, context), renderTasks(report, context)]
-        .filter((block) => block.length > 0)
-        .map((block) => block.join("\n"))
-        .join("\n\n");
+    const blocks = [renderContracts(report, context), renderAkuma(report, context), renderTasks(report, context)].filter((block) => block.length > 0);
+    return blocks.length === 0 ? "○ world empty" : blocks.map((block) => block.join("\n")).join("\n\n");
 }

package/build/src/cli/render/marks.d.ts

@@ -0,0 +1,13 @@
+import type { AkumaLife } from "../../akuma/heart/index.js";
+import type { ContractRow } from "../../protocol/read/status.js";
+import type { TaskDisposition } from "../../task/board.js";
+import type { TaskState } from "../../task/document.js";
+export type TaskMarkWord = TaskDisposition | TaskState | "missing";
+/** Akuma life marks are one vocabulary; render surfaces consume and never re-derive them. */
+export declare function akumaMark(life: AkumaLife | "unborn" | "stillborn"): string;
+/** Contract board marks weigh phase, gates, and target knowledge in one fixed order. */
+export declare function contractMark(row: ContractRow): string;
+/** The board's derived dispositions have their own exhaustive source lock. */
+export declare function taskDispositionMark(disposition: TaskDisposition): string;
+/** Document states and missing references reuse the board marks where they overlap. */
+export declare function taskMark(word: TaskMarkWord): string;

package/build/src/cli/render/marks.js

@@ -0,0 +1,74 @@
+function unreachable(value) {
+    throw new Error(`unhandled Task mark word: ${String(value)}`);
+}
+/** Akuma life marks are one vocabulary; render surfaces consume and never re-derive them. */
+export function akumaMark(life) {
+    switch (life) {
+        case "running":
+            return "●";
+        case "asleep":
+        case "unborn":
+            return "○";
+        case "stranded":
+        case "untidy":
+        case "stillborn":
+            return "!";
+        case "killed":
+            return "×";
+        case "hung":
+            return "?";
+        default:
+            return unreachable(life);
+    }
+}
+/** Contract board marks weigh phase, gates, and target knowledge in one fixed order. */
+export function contractMark(row) {
+    if (row.phase === "claimed")
+        return "✓";
+    if (row.phase === "abandoned")
+        return "×";
+    if (row.title === null)
+        return "?";
+    if (row.gates.reports.some((gate) => gate.current.kind === "attested" && gate.current.verdict === "unsatisfied"))
+        return "!";
+    if (row.targetLag.kind === "unknown")
+        return "?";
+    return "⧗";
+}
+/** The board's derived dispositions have their own exhaustive source lock. */
+export function taskDispositionMark(disposition) {
+    switch (disposition) {
+        case "ready":
+            return "○";
+        case "blocked":
+            return "‖";
+        case "in_progress":
+            return "●";
+        case "on_hold":
+            return "⧗";
+        case "done":
+            return "✓";
+        case "drop":
+            return "×";
+        default:
+            return unreachable(disposition);
+    }
+}
+/** Document states and missing references reuse the board marks where they overlap. */
+export function taskMark(word) {
+    switch (word) {
+        case "open":
+            return "○";
+        case "missing":
+            return "!";
+        case "ready":
+        case "blocked":
+        case "in_progress":
+        case "on_hold":
+        case "done":
+        case "drop":
+            return taskDispositionMark(word);
+        default:
+            return unreachable(word);
+    }
+}