@astrosheep/keiyaku 4.5.20 → 4.5.21

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

@@ -1,5 +1,7 @@
-import { boundedActivity, elapsedMilliseconds, entityLines, identityLine, plumbFacts, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { snapshotActivityLines } from "./akuma-activity.js";
+import { elapsedMilliseconds, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
 const NARROW_COLUMNS = 72;
+const ACTIVITY_INDENT = "  ";
 function mostRecentTimestamp(...values) {
     return values.reduce((latest, value) => {
         if (value === null || value === undefined)
@@ -24,40 +26,27 @@ function akumaStatusTone(row, observedAt) {
 function akumaMark(life) {
     return life === "running"
         ? "●"
-        : life === "stillborn"
-            ? "!"
-            : life === "asleep"
-                ? "○"
-                : life === "killed"
-                    ? "✕"
+        : life === "asleep"
+            ? "○"
+            : life === "killed"
+                ? "×"
+                : life === "stranded" || life === "stillborn" || life === "untidy"
+                    ? "!"
                     : "?";
 }
-function activitySnapshotLine(row) {
-    const snapshot = row.snapshot;
-    if (snapshot === undefined)
-        return undefined;
-    const latest = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : [])).at(-1);
-    if (latest === undefined) {
-        if (snapshot.kind !== "idle" || snapshot.outcome === undefined)
-            return undefined;
-        return snapshot.outcome.outcome.kind === "answered"
-            ? snapshot.outcome.outcome.answer
-            : snapshot.outcome.outcome.diagnostic;
-    }
-    if (latest.kind === "tool")
-        return latest.name;
-    return "text" in latest ? latest.text : "activity";
+/** 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}`);
 }
 function akumaLabel(row) {
     const aliases = row.aliases ?? [];
     return aliases.length === 0 ? "" : `(${aliases.join(" ")})`;
 }
 function endpointFact(id, observed) {
-    return observed === "missing"
-        ? `-> ${id} (missing)`
-        : observed === "unavailable"
-            ? `-> ${id} (unavailable)`
-            : `-> ${id}`;
+    // A bounded or failed Contract read leaves the disposition unknown; a parenthetical that
+    // cannot name the reason is absent, while a complete read that established absence says so.
+    return observed === "missing" ? `${id} (missing)` : id;
 }
 function renderAkuma(report, context) {
     const section = report.akuma;
@@ -66,25 +55,26 @@ function renderAkuma(report, context) {
     if (section.kind === "failed")
         return ["AKUMA // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     const rows = section.value.rows;
+    if (rows.length === 0)
+        return [];
     const rowLines = rows.map((row) => {
         const statusTone = akumaStatusTone(row, report.observedAt);
         const mark = statusTone === null ? akumaMark(row.life) : tone(akumaMark(row.life), statusTone, context.color);
         const lifeAt = "lifeAt" in row ? row.lifeAt : null;
-        const life = `${row.life} · ${formatAge(lifeAt, report.observedAt)}`;
-        const activity = "lastActivityAt" in row && row.lastActivityAt !== null
-            ? [`activity ${formatAge(row.lastActivityAt, report.observedAt)}`]
-            : [];
+        const lifeAge = formatAge(lifeAt, report.observedAt);
+        const life = `${row.life} · ${lifeAge}`;
+        const activityAge = "lastActivityAt" in row && row.lastActivityAt !== null ? formatAge(row.lastActivityAt, report.observedAt) : null;
+        const activity = activityAge === null || activityAge === lifeAge ? [] : [`activity ${activityAge}`];
         const key = row.life === "stranded" && "strandedReason" in row && row.strandedReason === "resume-unsupported"
             ? [life, ...activity, "resume unsupported"]
             : [life, ...activity];
-        const relation = row.contract === undefined ? ["unbound"] : [endpointFact(row.contract.id, row.contract.observed)];
-        const snapshot = activitySnapshotLine(row);
+        const relation = row.contract === undefined ? [] : [endpointFact(row.contract.id, row.contract.observed)];
+        const snapshot = row.snapshot;
+        const snapshotLines = snapshot === undefined ? [] : latestActivityLines(snapshot, context);
         const aliases = akumaLabel(row);
         if (context.columns > NARROW_COLUMNS) {
             const lines = [identityLine(mark, row.id, `${aliases} · ${[...key, ...relation].join(" · ")}`.trim())];
-            return snapshot === undefined
-                ? lines
-                : [...lines, ...plumbFacts([boundedActivity(snapshot, context.columns, "  ")], context.columns)];
+            return [...lines, ...snapshotLines];
         }
         const identity = aliases.length === 0 ? row.id : `${row.id} ${aliases}`;
         const lines = entityLines({
@@ -95,9 +85,7 @@ function renderAkuma(report, context) {
             facts: [...key.slice(1), ...relation],
             context,
         });
-        return snapshot === undefined
-            ? lines
-            : [...lines, ...plumbFacts([boundedActivity(snapshot, context.columns, "  ")], context.columns)];
+        return [...lines, ...snapshotLines];
     });
     const rendered = renderSectionBlock({
         name: "AKUMA",

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

@@ -1,6 +1,7 @@
 import { abbreviateGitIds, afterWording, candidateFact, dependentWording, displayGitId, gateFact, gitIdsInRow, mergeSummary, verificationFact, targetFacts, } from "./contract-observation.js";
 import { 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 { dispositionText } from "./task.js";
 const REVIEW_ATTENTION_MS = 15 * 60 * 1_000;
 const PENDING_ATTENTION_MS = 60 * 60 * 1_000;
 function contractHasError(row) {
@@ -26,22 +27,22 @@ function contractMark(row) {
     if (row.phase === "claimed")
         return "✓";
     if (row.phase === "abandoned")
-        return "✕";
+        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")
-        return "○";
+    if (row.phase === "waiting" || row.phase === "tendered")
+        return "⧗";
     return "●";
 }
 function taskMark(row) {
     if (row.disposition === "done")
         return "✓";
     if (row.disposition === "drop")
-        return "✕";
+        return "×";
     if (row.disposition === "on_hold")
         return "⧗";
     return row.disposition === "in_progress" ? "●" : row.disposition === "blocked" ? "‖" : "○";
@@ -93,7 +94,9 @@ function linkedTask(report, taskId) {
     if (report.tasks.kind !== "present")
         return `! ${taskId} · unavailable`;
     const task = report.tasks.value.rows.find((candidate) => candidate.id === taskId);
-    return task === undefined ? `! ${taskId} · unavailable` : `${taskMark(task)} ${task.id} · ${task.disposition}`;
+    return task === undefined
+        ? `! ${taskId} · unavailable`
+        : `${taskMark(task)} ${task.id} · ${dispositionText(task.disposition)}`;
 }
 function linkedAkuma(report, id, aliases) {
     const alias = aliases.length === 0 ? "" : ` (${aliases.join(" ")})`;
@@ -139,13 +142,10 @@ function linkedAkumaSummary(row, report) {
         facts.push(`${row.fleet.length - known.length} unavailable`);
     return facts.join(" · ");
 }
-function semanticBlock(name, facts, _context) {
+function semanticBlock(_name, facts, _context) {
     if (facts.length === 0)
         return [];
-    const lines = [`  ${name}`];
-    for (const fact of facts)
-        lines.push(`    ${safeText(fact)}`);
-    return lines;
+    return facts.map((fact) => `  ${safeText(fact)}`);
 }
 function namespaceTaskFacts(row) {
     if (row.namespaceTasks === undefined)
@@ -155,7 +155,7 @@ function namespaceTaskFacts(row) {
     if (row.namespaceTasks.kind === "failed") {
         return [`failed ${row.namespaceTasks.failure.message}`];
     }
-    return row.namespaceTasks.value.map((task) => `${taskMark(task)} ${task.id} · ${task.disposition} · P${task.priority} · ${task.title}`);
+    return row.namespaceTasks.value.map((task) => `${taskMark(task)} ${task.id} · ${dispositionText(task.disposition)} · P${task.priority} · ${task.title}`);
 }
 function renderSelectedContractRow(row, report, context, abbreviations) {
     const title = row.title ?? "title unavailable";
@@ -195,7 +195,7 @@ function renderSelectedContractRow(row, report, context, abbreviations) {
     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.continue)} · reads worktree bytes, not index`);
+        lines.push(`  deliver  ${safeText(observation.merge.recovery.deliver)} · reads worktree bytes, not index`);
     }
     return lines;
 }
@@ -218,7 +218,7 @@ function renderWorldContractRow(row, report, context) {
     const contractFacts = [
         candidateFact(row.delivery),
         ...targetFacts(row, gitAbbreviations(report)),
-        ...(row.worktreePath === null ? [] : [`worktree  ${row.worktreePath}`]),
+        ...[],
         ...(linkedAkumaSummary(row, report) === undefined ? [] : [linkedAkumaSummary(row, report)]),
         ...row.after.map(afterWording),
         ...(row.dependents.length === 0 ? [] : [`dependents  ${row.dependents.map(dependentWording).join(" · ")}`]),
@@ -245,6 +245,8 @@ function renderContracts(report, context) {
         return ["CONTRACTS // absent", "", "  contracts absent"];
     if (section.kind === "failed")
         return ["CONTRACTS // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
+    if (section.value.rows.length === 0)
+        return [];
     const rendered = renderSectionBlock({
         name: "CONTRACTS",
         rows: section.value.rows.map((row) => renderWorldContractRow(row, report, context)),
@@ -263,27 +265,37 @@ function renderSelectedContract(report, context) {
         ? ["  keiyaku absent"]
         : renderSelectedContractRow(row, report, context, gitAbbreviations(report));
 }
+function taskFailureFact(failure) {
+    return failure.coordinate === undefined ? failure.message : `${failure.coordinate} · failed ${failure.message}`;
+}
 function renderTasks(report, context) {
     const section = report.tasks;
     if (section.kind === "absent")
         return ["TASKS // absent", "", "  tasks absent"];
     if (section.kind === "failed")
-        return ["TASKS // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
+        return [
+            "TASKS // unavailable",
+            "",
+            tone(`! ${safeText(taskFailureFact(section.failure))}`, "alert", context.color),
+        ];
     const rows = section.value.rows;
+    if (rows.length === 0)
+        return [];
     const rowLines = rows.map((row) => {
-        const relation = row.contract === undefined ? ["unbound"] : [endpointFact(row.contract.id, row.contract.observed)];
+        const relation = row.contract === undefined ? [] : [endpointFact(row.contract.id, row.contract.observed)];
         const childFacts = row.children === undefined ? [] : [`children ${row.children.live} live · ${row.children.total} total`];
         const blockerFacts = (row.blockers ?? []).map((blocker) => `blocked ${blocker.id}`);
+        const association = relation.length === 0 ? "" : ` · ${relation.join(" · ")}`;
         if (context.columns > NARROW_COLUMNS) {
             return [
-                identityLine(taskMark(row), row.id, `· ${row.disposition} · P${row.priority} · ${row.title} · ${relation.join(" · ")}`),
+                identityLine(taskMark(row), row.id, `· ${dispositionText(row.disposition)} · P${row.priority} · ${row.title}${association}`),
                 ...plumbFacts([...childFacts, ...blockerFacts], context.columns),
             ];
         }
         return entityLines({
             mark: taskMark(row),
             identity: row.id,
-            state: `${row.disposition} · P${row.priority}`,
+            state: `${dispositionText(row.disposition)} · P${row.priority}`,
             title: row.title,
             facts: [...relation, ...childFacts, ...blockerFacts],
             context,
@@ -301,13 +313,8 @@ function renderTasks(report, context) {
 export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
     if (selection === "contract")
         return renderSelectedContract(report, context).join("\n");
-    return [
-        `${tone("契", "alert", context.color)} KEIYAKU // WORLD`,
-        "",
-        ...renderContracts(report, context),
-        "",
-        ...renderAkuma(report, context),
-        "",
-        ...renderTasks(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");
 }

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

@@ -5,7 +5,7 @@ export function renderNukeText(result) {
     if (result.kind === "success") {
         return [`✓ nuke  ${result.world}`, ...seatClose].join("\n");
     }
-    return [`✕ nuke  ${result.world}`, `  diagnostic  ${result.diagnostic}`, ...seatClose].join("\n");
+    return [`× nuke  ${result.world}`, `  diagnostic  ${result.diagnostic}`, ...seatClose].join("\n");
 }
 export function nukeExitCode(result) {
     return result.kind === "failed" ? 2 : 0;

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

@@ -10,7 +10,7 @@ type HookFailure = Extract<Lag, {
 }>["failure"];
 export declare function receiptRow(lines: string[], mark: string, label: string, segments: readonly ReceiptSegment[], columns: number): void;
 export declare function receiptPayload(lines: string[], label: string, payload: string): void;
-export declare function outcomeLines(mark: "✓" | "✕" | "!" | "?", verb: string, word: "accepted" | "refused" | "retry", contract: string | undefined, columns?: number): string[];
+export declare function outcomeLines(mark: "✓" | "×" | "!" | "?", verb: string, word: "accepted" | "refused" | "retry", contract: string | undefined, columns?: number): string[];
 export declare function titleLines(mark: string, title: string, contract: string, columns?: number): string[];
 export declare function hookFailureSummary(failure: HookFailure): string;
 export declare function appendHookPayload(lines: string[], failure: HookFailure): void;

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

@@ -21,7 +21,7 @@ export function receiptRow(lines, mark, label, segments, columns) {
     lines.push(current);
 }
 export function receiptPayload(lines, label, payload) {
-    lines.push(label, "", payload, "");
+    lines.push(label, ...renderOpaqueBlock(payload, "  ", 80), "");
 }
 export function outcomeLines(mark, verb, word, contract, columns = 80) {
     const base = `${mark} ${verb} ${word}`;
@@ -59,7 +59,7 @@ export function appendHookPayload(lines, failure) {
 export function reuseLines(reuse, columns) {
     if (reuse === undefined)
         return [];
-    return renderOpaqueBlock(`reuse verification ${reuse.entry} ${reuse.verdict}`, "   ", columns);
+    return renderOpaqueBlock(`reuse  verified · ${reuse.verdict} · ${reuse.entry}`, "  ", columns);
 }
 function prerequisiteRows(stop, columns) {
     if (!("refusal" in stop) || stop.refusal?.kind !== "prerequisites-unsatisfied")
@@ -131,10 +131,10 @@ function refusalEvidence(stop, columns) {
             recovery !== null &&
             "materialize" in recovery &&
             typeof recovery.materialize === "string" &&
-            "continue" in recovery &&
-            typeof recovery.continue === "string") {
+            "deliver" in recovery &&
+            typeof recovery.deliver === "string") {
             receiptRow(lines, " ", "materialize", [{ text: recovery.materialize }], columns);
-            receiptRow(lines, " ", "deliver", [{ text: recovery.continue }], columns);
+            receiptRow(lines, " ", "deliver", [{ text: recovery.deliver }], columns);
         }
     }
     else if (refusal.kind === "integration-unsupported") {

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

@@ -7,9 +7,12 @@ function wrap(lines, text, indent, columns) {
 }
 function collectionLines(name, members, indent) {
     if (members.length === 0)
-        return [`${indent}${name}  0`];
+        return [];
     return [`${indent}${name}`, ...members.map((member) => `${indent}  ${safeText(member)}`)];
 }
+function shortGitId(value) {
+    return /^[0-9a-f]{40}$/iu.test(value) ? value.slice(0, 7) : value;
+}
 function skipAddressedContract(addressed, contractId) {
     return addressed !== undefined && contractId === addressed;
 }
@@ -66,7 +69,7 @@ export function renderRefusalFacts(refusal, indent, columns, addressed) {
             lines.push(...collectionLines("conflicts", refusal.conflictPaths, indent));
         if ("recovery" in refusal && refusal.recovery !== undefined) {
             lines.push(`${indent}materialize  ${safeText(refusal.recovery.materialize)}`);
-            lines.push(`${indent}deliver  ${safeText(refusal.recovery.continue)}`);
+            lines.push(`${indent}deliver  ${safeText(refusal.recovery.deliver)}`);
         }
         return lines;
     }
@@ -90,7 +93,7 @@ export function renderRefusalFacts(refusal, indent, columns, addressed) {
 }
 export function renderRefusal(result, context) {
     const columns = context?.columns ?? 80;
-    const base = `✕ ${result.verb} refused`;
+    const base = `× ${result.verb} refused`;
     const lines = result.contract === undefined
         ? [base]
         : displayColumns(`${base}  ${result.contract}`) <= columns
@@ -106,14 +109,14 @@ export function renderConflictMaterialized(result, _context) {
     const indent = "  ";
     return [
         "! integration-conflict-materialized",
-        `${indent}target  ${safeText(result.targetHead)}`,
-        `${indent}recorded  no delivery`,
+        `${indent}target  ${shortGitId(result.targetHead)}`,
+        `${indent}delivery  none`,
         `${indent}index  unmerged`,
         `${indent}saved  worktree bytes before projection`,
-        `${indent}handoff base  ${safeText(result.handoffBase)}`,
+        `${indent}handoff base  ${shortGitId(result.handoffBase)}`,
         ...collectionLines("conflicts", result.conflictPaths, indent),
         `${indent}workspace  ${safeText(result.workspace.path)}`,
-        `${indent}deliver  ${safeText(result.recovery.continue)} · reads worktree bytes, not index`,
+        `${indent}deliver  ${safeText(result.recovery.deliver)} · reads worktree bytes, not index`,
     ].join("\n");
 }
 export function renderBindDraftReceipt(receipt) {

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

@@ -14,7 +14,7 @@ function rows(section) {
     if (section.kind === "absent")
         return [];
     if (section.kind === "failed")
-        return [`✕ region`, `  diagnostic  ${section.failure.message}`];
+        return [`× region`, `  diagnostic  ${section.failure.message}`];
     const value = section.value;
     if (value.kind === "declarations") {
         if (value.declarations.length === 0)

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

@@ -1,5 +1,15 @@
 import { displayColumns, renderTextBlock } from "./terminal.js";
-import { fieldName, namedValueLines } from "./value.js";
+import { fieldName } from "./value.js";
+function settingValueLines(name, value, indent) {
+    const secret = /(?:key|token|secret|password|credential)/iu.test(name);
+    if (secret && value !== undefined && value !== null && String(value).length > 0)
+        return [`${indent}${fieldName(name)}  [redacted]`];
+    if (value === null || typeof value !== "object")
+        return [`${indent}${fieldName(name)}  ${String(value)}`];
+    if (Array.isArray(value))
+        return value.flatMap((item, index) => settingValueLines(`${name}.${index}`, item, indent));
+    return Object.entries(value).flatMap(([key, item]) => settingValueLines(`${name}.${key}`, item, indent));
+}
 function namespaceNames(value) {
     return [
         ...new Set([value.scopes.user, value.scopes.project].flatMap((scope) => (scope.kind === "read" ? scope.namespaces : []))),
@@ -38,7 +48,7 @@ export function renderSettingsText(value, columns = 80) {
         }
         for (const entry of view.entries) {
             lines.push(`    entry  ${fieldName(entry.name)} · ${entry.source}${entry.shadows ? " · shadows user" : ""}`);
-            lines.push(...namedValueLines("value", entry.value, "      "));
+            lines.push(...settingValueLines("value", entry.value, "      "));
         }
     }
     return lines.join("\n");

package/build/src/cli/render/status-line.d.ts

@@ -0,0 +1,30 @@
+export type StatusLineStream = NodeJS.WritableStream & Readonly<{
+    isTTY?: boolean;
+}>;
+type IntervalHandle = ReturnType<typeof setInterval>;
+export type StatusLineOptions = Readonly<{
+    now?: () => number;
+    intervalMs?: number;
+    schedule?: (tick: () => void, every: number) => IntervalHandle;
+    cancel?: (handle: IntervalHandle) => void;
+}>;
+/** A terminal-only, ephemeral line. It owns neither execution nor its outcome. */
+export declare class StatusLine {
+    private readonly stream;
+    readonly isTTY: boolean;
+    private readonly now;
+    private readonly intervalMs;
+    private readonly schedule;
+    private readonly cancel;
+    private timer;
+    private format;
+    private startedAt;
+    constructor(stream: StatusLineStream, options?: StatusLineOptions);
+    show(format: (elapsedMs: number) => string): void;
+    writeBlock(lines: readonly string[]): void;
+    finish(line: string): void;
+    private redraw;
+    private erase;
+    private stop;
+}
+export {};

package/build/src/cli/render/status-line.js

@@ -0,0 +1,58 @@
+/** A terminal-only, ephemeral line. It owns neither execution nor its outcome. */
+export class StatusLine {
+    stream;
+    isTTY;
+    now;
+    intervalMs;
+    schedule;
+    cancel;
+    timer;
+    format;
+    startedAt;
+    constructor(stream, options = {}) {
+        this.stream = stream;
+        this.isTTY = stream.isTTY === true;
+        this.now = options.now ?? (() => performance.now());
+        this.intervalMs = options.intervalMs ?? 1_000;
+        this.schedule = options.schedule ?? ((tick, every) => setInterval(tick, every));
+        this.cancel = options.cancel ?? ((handle) => clearInterval(handle));
+    }
+    show(format) {
+        if (!this.isTTY)
+            return;
+        this.format = format;
+        this.startedAt ??= this.now();
+        this.redraw();
+        this.timer ??= this.schedule(() => this.redraw(), this.intervalMs);
+    }
+    writeBlock(lines) {
+        if (lines.length === 0)
+            return;
+        if (this.isTTY)
+            this.erase();
+        this.stream.write(`${lines.join("\n")}\n`);
+        if (this.isTTY && this.format !== undefined)
+            this.redraw();
+    }
+    finish(line) {
+        if (!this.isTTY)
+            return;
+        this.erase();
+        this.stop();
+        this.stream.write(`${line}\n`);
+    }
+    redraw() {
+        if (!this.isTTY || this.format === undefined || this.startedAt === undefined)
+            return;
+        this.stream.write(`\r\u001b[2K${this.format(Math.max(0, this.now() - this.startedAt))}`);
+    }
+    erase() {
+        if (this.isTTY && this.format !== undefined)
+            this.stream.write("\r\u001b[2K");
+    }
+    stop() {
+        if (this.timer !== undefined)
+            this.cancel(this.timer);
+        this.timer = undefined;
+    }
+}

package/build/src/cli/render/status-set.js

@@ -13,7 +13,7 @@ export function renderStatusSetText(result, context) {
                 status: entry.status,
                 ...(entry.alias === undefined ? {} : { alias: entry.alias }),
             }, context);
-        return [`status  ${entry.selector}`, body].join("\n");
+        return body;
     })
         .join("\n\n");
 }

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

@@ -3,6 +3,8 @@ import type { TaskInvocationResult } from "../commands/task-invoke.js";
 import type { ParsedTaskCommand } from "../commands/task.js";
 import { type TextRenderContext } from "./terminal.js";
 export declare function taskMark(word: string): string;
+/** Task dispositions and relation states are snake_case facts; people read them as words. */
+export declare function dispositionText(word: string): string;
 export declare function renderTaskText(command: ParsedTaskCommand, result: TaskInvocationResult, context?: TextRenderContext): string;
 export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
 export declare function taskExitCode(result: TaskInvocationResult): number;

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

@@ -21,16 +21,20 @@ export function taskMark(word) {
     if (word === "done")
         return "✓";
     if (word === "drop")
-        return "✕";
+        return "×";
     return "?";
 }
+/** Task dispositions and relation states are snake_case facts; people read them as words. */
+export function dispositionText(word) {
+    return word.replaceAll("_", " ");
+}
 function priorityText(priority) {
     return priority === null ? "P?" : `P${priority}`;
 }
 function scanUnit(id, priority, word) {
     return word === undefined
         ? `${taskMark("ready")} ${id} · ${priorityText(priority)}`
-        : `${taskMark(word)} ${id} · ${word} · ${priorityText(priority)}`;
+        : `${taskMark(word)} ${id} · ${dispositionText(word)} · ${priorityText(priority)}`;
 }
 function entityLines(entity, columns, indent = "") {
     const scan = `${indent}${scanUnit(entity.id, entity.priority, entity.word)}${entity.facts === undefined ? "" : ` · ${entity.facts}`}`;
@@ -74,7 +78,7 @@ function renderFailure(verb, result, columns) {
     if (result.kind === "retry") {
         return [...outcomeLines("?", verb, "retry", undefined, columns), result.reason].join("\n");
     }
-    const lines = [...outcomeLines("✕", verb, "refused", undefined, columns)];
+    const lines = [...outcomeLines("×", verb, "refused", undefined, columns)];
     const facts = projectRefusal(result.refusal);
     lines.push(facts.line);
     appendDiagnostic(lines, facts.diagnostic);
@@ -85,7 +89,7 @@ function renderFailure(verb, result, columns) {
 }
 function edge(label, ref, mark) {
     const prefix = mark === undefined ? `  ${label}` : `  ${mark} ${label}`;
-    return `${prefix} ${ref.id} · ${ref.state}`;
+    return `${prefix} ${ref.id} · ${dispositionText(ref.state)}`;
 }
 function pageHeading(view) {
     return view;
@@ -120,7 +124,7 @@ function renderListRow(item, columns, omitDisposition) {
     const lines = [...entityLines(listEntity(item, omitDisposition), columns)];
     if ("blockers" in item) {
         for (const blocker of item.blockers)
-            lines.push(`  needs ${blocker.id} · ${blocker.state}`);
+            lines.push(`  needs ${blocker.id} · ${dispositionText(blocker.state)}`);
     }
     return lines;
 }
@@ -223,7 +227,7 @@ function renderBatchItem(verb, item) {
     if (item.outcome.kind === "retry")
         return `? ${verb}  ${item.id}  ${item.outcome.reason}`;
     const facts = projectRefusal(item.outcome.refusal);
-    const lines = [`✕ ${verb}  ${item.id}  ${facts.line}`];
+    const lines = [`× ${verb}  ${item.id}  ${facts.line}`];
     appendDiagnostic(lines, facts.diagnostic);
     return lines.join("\n");
 }
@@ -238,7 +242,7 @@ function stoppedLines(stopped) {
     if (stopped.kind === "retry")
         return [`? stopped ${stopped.reason}`];
     const facts = projectRefusal(stopped);
-    const lines = [`✕ stopped  ${facts.line}`];
+    const lines = [`× stopped  ${facts.line}`];
     appendDiagnostic(lines, facts.diagnostic);
     return lines;
 }

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

@@ -37,7 +37,6 @@ export type SemanticTone = "dim" | "recent" | "attention" | "alert";
 export declare const RECENT_TONE_MS: number;
 export declare function elapsedMilliseconds(source: string | null | undefined, observedAt: string): number | null;
 export declare function tone(value: string, kind: SemanticTone, color: boolean): string;
-export declare function boundedActivity(value: string, columns: number, prefix: string): string;
 export declare function plumbFacts(facts: readonly string[], columns: number): readonly string[];
 export declare function linkedEntityLines(facts: readonly string[], _columns: number): readonly string[];
 export declare function identityLine(mark: string, identity: string, extra?: string): string;