@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,4 +1,89 @@
-export function renderRefusal(result) {
-    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
-    return `refused ${result.verb}${contract} ${JSON.stringify(result.refusal)}`;
+import { displayColumns, gitShortStat, renderOpaqueBlock, safeText } from "./terminal.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wrap(lines, text, indent, columns) {
+    lines.push(...renderOpaqueBlock(text, indent, columns));
+}
+function collectionLines(name, members, indent, columns) {
+    if (members.length === 0)
+        return renderOpaqueBlock(`${name} 0`, indent, columns);
+    return [
+        ...renderOpaqueBlock(name, indent, columns),
+        ...members.flatMap((member) => renderOpaqueBlock(member, `${indent}│ `, columns)),
+    ];
+}
+function skipAddressedContract(addressed, contractId) {
+    return addressed !== undefined && contractId === addressed;
+}
+function refusalIdentity(refusal, addressed) {
+    const contractId = "contractId" in refusal ? refusal.contractId : undefined;
+    return skipAddressedContract(addressed, contractId) ? undefined : contractId;
+}
+function refusalHead(kind, identity, details) {
+    return [kind, identity === undefined ? undefined : `contractId=${identity}`, ...details]
+        .filter((part) => part !== undefined).join(" ");
+}
+function renderDirtyRefusal(refusal, indent, columns, identity) {
+    const lines = [];
+    wrap(lines, refusalHead(refusal.kind, identity, []), indent, columns);
+    for (const name of ["staged", "unstaged", "untracked", "submodules"]) {
+        lines.push(...collectionLines(name, refusal[name], indent, columns));
+    }
+    wrap(lines, gitShortStat(refusal.shortStat), indent, columns);
+    if (refusal.option !== undefined) {
+        wrap(lines, `option ${refusal.option.flag} ${refusal.option.available ? "available" : "unavailable"}`, indent, columns);
+    }
+    return lines;
+}
+export function renderRefusalFacts(refusal, indent, columns, addressed) {
+    const identity = refusalIdentity(refusal, addressed);
+    if (refusal.kind === "dirty-workspace")
+        return renderDirtyRefusal(refusal, indent, columns, identity);
+    if (refusal.kind === "integration-failed") {
+        const lines = [
+            ...renderOpaqueBlock(refusalHead(refusal.kind, identity, [`reason=${refusal.reason}`, `targetHead=${refusal.targetHead}`]), indent, columns),
+        ];
+        if (refusal.conflictPaths !== undefined)
+            lines.push(...collectionLines("conflictPaths", refusal.conflictPaths, indent, columns));
+        return lines;
+    }
+    if (refusal.kind === "integration-unsupported") {
+        return renderOpaqueBlock(refusalHead(refusal.kind, identity, [`requiredGit=${refusal.requiredGit}`]), indent, columns);
+    }
+    if (refusal.kind === "checkout-not-followable") {
+        const lines = [...renderOpaqueBlock(refusalHead(refusal.kind, identity, [`target=${refusal.target}`, `path=${refusal.path}`, `reason=${refusal.reason}`]), indent, columns)];
+        lines.push(...collectionLines("paths", refusal.paths, indent, columns));
+        return lines;
+    }
+    if (refusal.kind === "workspace-not-on-target") {
+        return renderOpaqueBlock(refusalHead(refusal.kind, identity, [`target=${refusal.target}`, `branch=${refusal.branch}`]), indent, columns);
+    }
+    if (refusal.kind === "here-target-mismatch") {
+        return renderOpaqueBlock(`here-target-mismatch target=${refusal.target} branch=${refusal.branch}`, indent, columns);
+    }
+    if (refusal.kind === "here-worktree-appointed") {
+        return renderOpaqueBlock(refusalHead(refusal.kind, undefined, [refusal.contract === undefined ? "" : `contract=${refusal.contract}`, `path=${refusal.path}`]), indent, columns);
+    }
+    return renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns);
+}
+export function renderRefusal(result, context) {
+    const columns = context?.columns ?? 80;
+    const base = `! ${result.verb} refused`;
+    const lines = result.contract === undefined
+        ? [base]
+        : displayColumns(`${base} — ${result.contract}`) <= columns
+            ? [`${base} — ${result.contract}`]
+            : [`${base} —`, `  ${safeText(result.contract)}`];
+    if (isRecord(result.refusal) && typeof result.refusal.kind === "string") {
+        lines.push(...renderRefusalFacts(result.refusal, "   ", columns, result.contract));
+    }
+    const output = lines.join("\n");
+    return result.draft === undefined ? output : `${output}\n${renderBindDraftReceipt(result.draft)}`;
+}
+export function renderBindDraftReceipt(receipt) {
+    return [
+        ...(receipt.path === undefined ? [] : [`draft preserved: ${receipt.path}`]),
+        ...(receipt.warning === undefined ? [] : [`warning: ${receipt.warning}`]),
+    ].join("\n");
 }

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

@@ -0,0 +1,2 @@
+import type { RegionRead, Section } from "../../kanshi/index.js";
+export declare function renderRegionText(section: Section<RegionRead>): string;

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

@@ -0,0 +1,17 @@
+function rows(section) {
+    if (section.kind === "absent")
+        return [];
+    if (section.kind === "failed")
+        return [`region failed ${section.failure.message}`];
+    const value = section.value;
+    if (value.kind === "declarations")
+        return value.declarations.map((declaration) => `region ${declaration.contract} ${declaration.patterns.join(" ")}`);
+    if (value.kind === "contract")
+        return [`region ${value.declaration.contract} ${value.declaration.patterns.join(" ")}`];
+    if (value.kind === "path")
+        return value.matches.map((match) => `path ${value.path} ${match.contract} ${match.pattern}`);
+    return value.intersections.flatMap((intersection) => intersection.patterns.map((pattern) => `overlap ${intersection.left} ${pattern.left} ~ ${intersection.right} ${pattern.right}`));
+}
+export function renderRegionText(section) {
+    return rows(section).join("\n");
+}

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

@@ -1,6 +1,7 @@
 import type { TaskCompositionResult } from "../../task/index.js";
 import type { TaskInvocationResult } from "../commands/task-invoke.js";
 import type { ParsedTaskCommand } from "../commands/task.js";
-export declare function renderTaskText(command: ParsedTaskCommand, result: TaskInvocationResult): string;
+import { type TextRenderContext } from "./terminal.js";
+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

@@ -1,93 +1,256 @@
-function row(value) {
-    const disposition = "disposition" in value ? value.disposition : value.state;
-    return `${value.id} - P${value.priority} - ${disposition} - ${value.title}`;
+import { outcomeLines, receiptPayload } from "./receipt.js";
+import { displayColumns, renderTextBlock, safeText } from "./terminal.js";
+const DEFAULT_CONTEXT = { columns: 80, color: false };
+function isWorldObservation(result) {
+    return typeof result === "object" && result !== null
+        && "kind" in result
+        && (result.kind === "present" || result.kind === "absent" || result.kind === "failed");
 }
-function changes(values) {
-    return values.map((change) => change.documentDiff).filter((diff) => diff.length > 0).join("\n");
+function markFor(word) {
+    if (word === "in_progress")
+        return "●";
+    if (word === "ready" || word === "open")
+        return "○";
+    if (word === "blocked" || word === "missing")
+        return "!";
+    if (word === "on_hold")
+        return "·";
+    if (word === "done")
+        return "✓";
+    if (word === "drop")
+        return "×";
+    return "?";
 }
-function failure(result) {
-    return result.kind === "retry" ? `retry ${JSON.stringify(result.reason)}` : `refused ${JSON.stringify(result.refusal)}`;
+function priorityText(priority) {
+    return priority === null ? "P?" : `P${priority}`;
 }
-function renderRows(result) {
+function scanUnit(id, priority, word) {
+    return `${markFor(word)} ${id} · ${priorityText(priority)} ${word}`;
+}
+function entityLines(entity, columns, indent = "") {
+    const scan = `${indent}${scanUnit(entity.id, entity.priority, entity.word)}`;
+    if (entity.title === null || entity.title.length === 0)
+        return [scan];
+    const title = safeText(entity.title);
+    const inline = `${scan} — ${title}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return [`${scan} —`, ...renderTextBlock(title, `${indent}  `, columns)];
+}
+function listEntity(item) {
+    return { id: item.id, priority: item.priority, word: item.disposition, title: item.title };
+}
+function stateEntity(task) {
+    return { id: task.id, priority: "priority" in task && task.priority !== undefined ? task.priority : null, word: task.state, title: task.title };
+}
+function projectRefusal(refusal) {
+    if (refusal.kind === "task-missing")
+        return { line: `task-missing ${refusal.taskId}` };
+    if (refusal.kind === "invalid-lifecycle-transition") {
+        return { line: `invalid-lifecycle-transition ${refusal.taskId} ${refusal.state} ${refusal.verb}` };
+    }
+    if (refusal.kind === "invalid-namespace-context")
+        return { line: `invalid-namespace-context ${refusal.path}` };
+    if (refusal.kind === "relation-owned-by-other") {
+        return { line: `relation-owned-by-other ${refusal.taskId} ${refusal.related} ${refusal.declaringTask}` };
+    }
+    return { line: refusal.kind, diagnostic: refusal.diagnostic };
+}
+function appendDiagnostic(lines, diagnostic) {
+    if (diagnostic !== undefined)
+        receiptPayload(lines, "diagnostic", diagnostic);
+}
+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 facts = projectRefusal(result.refusal);
+    lines.push(facts.line);
+    appendDiagnostic(lines, facts.diagnostic);
+    return lines.join("\n");
+}
+function edge(label, ref, mark) {
+    const prefix = mark === undefined ? `  ${label}` : `  ${mark} ${label}`;
+    return `${prefix} ${ref.id} · ${ref.state}`;
+}
+function pageHeading(view, page) {
+    if (page.truncated)
+        return `${view} ${page.returned} of ${page.total} · limit ${page.returned}`;
+    return `${view} ${page.returned}`;
+}
+function renderListRow(item, columns) {
+    const lines = [...entityLines(listEntity(item), columns)];
+    if ("blockers" in item) {
+        for (const blocker of item.blockers)
+            lines.push(`  needs ${blocker.id} · ${blocker.state}`);
+    }
+    return lines;
+}
+function renderRows(command, result, columns) {
     if (result.kind !== "accepted")
-        return failure(result);
-    return result.value.map((item) => {
-        const blockers = "blockers" in item ? item.blockers.map((blocker) => blocker.id).join(", ") : undefined;
-        return `${row(item)}${blockers === undefined ? "" : ` <- ${blockers}`}`;
-    }).join("\n");
+        return renderFailure(command.action, result, columns);
+    const view = command.action === "ls" ? "tasks" : command.action;
+    return [pageHeading(view, result.value), ...result.value.rows.flatMap((item) => renderListRow(item, columns))].join("\n");
 }
-function renderShow(result) {
+function renderShow(result, columns) {
     if ("kind" in result)
-        return result.kind === "accepted" ? row(result.value) : failure(result);
-    const task = result.task, lines = [
-        row(task), `namespace: ${task.namespace.join("/") || "root"}`,
-        `createdAt: ${task.createdAt}`, `updatedAt: ${task.updatedAt}`, `note: ${task.note}`,
+        return result.kind === "accepted" ? entityLines(stateEntity(result.value), columns).join("\n") : renderFailure("show", result, columns);
+    const task = result.task;
+    const lines = [
+        ...entityLines(stateEntity(task), columns),
+        ...renderTextBlock(`created ${task.createdAt} · updated ${task.updatedAt}`, "", columns),
+        ...(task.createdBy === undefined ? [] : [`created-by ${task.createdBy}`]),
     ];
-    for (const [label, values] of [
-        ["needs", task.needs], ["blockers", result.blockers.map((item) => item.id)], ["blocks", result.blocks.map((item) => item.id)],
-        ["children", result.children.map((item) => item.id)], ["supersedes", task.supersedes],
-        ["superseded by", result.supersededBy.map((item) => item.id)], ["related", result.related.map((item) => item.id)],
-    ])
-        if (values.length > 0)
-            lines.push(`${label}: ${values.join(", ")}`);
-    if (task.parent !== null)
-        lines.push(`parent: ${task.parent}`);
+    for (const need of result.needs.filter((item) => !item.released))
+        lines.push(edge("needs", need, "!"));
+    for (const need of result.needs.filter((item) => item.released))
+        lines.push(edge("needs", need, "✓"));
+    for (const item of result.blocks)
+        lines.push(edge("blocks", item));
+    if (result.parent !== null)
+        lines.push(edge("parent", result.parent));
+    for (const item of result.children)
+        lines.push(edge("child", item));
+    for (const item of result.supersedes)
+        lines.push(edge("supersedes", item));
+    for (const item of result.supersededBy)
+        lines.push(edge("superseded-by", item));
+    for (const item of result.related)
+        lines.push(edge("related", item));
+    if (task.note.length > 0)
+        receiptPayload(lines, "note", task.note);
     if (task.body.length > 0)
-        lines.push("", task.body);
+        receiptPayload(lines, "body", task.body);
     return lines.join("\n");
 }
-function treeLines(node, depth = 0) {
-    const marker = node.cycle ? "cycle" : node.reference ? "reference" : node.task.state;
-    const line = `${"  ".repeat(depth)}${node.task.id} - ${node.task.priority === null ? "P?" : `P${node.task.priority}`} - ${marker}${node.task.title === null ? "" : ` - ${node.task.title}`}`;
-    return [line, ...node.needs.flatMap((child) => treeLines(child, depth + 1))];
+function treeLines(node, columns, depth = 0) {
+    const indent = "  ".repeat(depth);
+    if (node.cycle === true)
+        return [`${indent}! ${node.task.id} · cycle`];
+    return [
+        ...entityLines(stateEntity(node.task), columns, indent),
+        ...node.children.flatMap((child) => treeLines(child, columns, depth + 1)),
+    ];
 }
 function doctorIssue(issue) {
     if (issue.kind === "missing-target")
-        return `${issue.taskId}: ${issue.relation} target missing: ${issue.target}`;
+        return `! missing-target ${issue.taskId} ${issue.relation} ${issue.target}`;
     if (issue.kind === "self-relation")
-        return `${issue.taskId}: self ${issue.relation}`;
-    return `${issue.relation} cycle: ${issue.tasks.join(" -> ")}`;
+        return `! self-relation ${issue.taskId} ${issue.relation}`;
+    return `! cycle ${issue.relation} ${issue.tasks.join(" ")}`;
 }
-export function renderTaskText(command, result) {
+function renderDoctor(report) {
+    if (report.issues.length === 0)
+        return "healthy";
+    const noun = report.issues.length === 1 ? "issue" : "issues";
+    return [`${report.issues.length} ${noun}`, ...report.issues.map(doctorIssue)].join("\n");
+}
+function renderAcceptedMutation(verb, task, columns, documentDiff) {
+    const lines = [
+        ...outcomeLines("✓", verb, "accepted", task.id, columns),
+        ...entityLines(stateEntity(task), columns),
+    ];
+    if (documentDiff !== undefined)
+        receiptPayload(lines, "diff", documentDiff);
+    return lines.join("\n");
+}
+function renderMutation(command, result, columns) {
+    if (result.kind !== "accepted")
+        return renderFailure(command.action, result, columns);
+    if (command.action !== "update") {
+        return renderAcceptedMutation(command.action, result.value, columns);
+    }
+    const value = result.value;
+    return renderAcceptedMutation(command.action, value.task, columns, value.documentDiff);
+}
+function renderBatchItem(verb, item) {
+    if (item.outcome.kind === "accepted")
+        return `✓ ${verb} ${item.id}`;
+    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}`];
+    appendDiagnostic(lines, facts.diagnostic);
+    return lines.join("\n");
+}
+function renderBatch(verb, batch) {
+    return batch.items.map((item) => renderBatchItem(verb, item)).join("\n");
+}
+function composeDiffs(lines, changes) {
+    for (const change of changes)
+        receiptPayload(lines, `diff ${change.taskId}`, change.documentDiff);
+}
+function stoppedLines(stopped) {
+    if (stopped.kind === "retry")
+        return [`? stopped ${stopped.reason}`];
+    const facts = projectRefusal(stopped);
+    const lines = [`! stopped ${facts.line}`];
+    appendDiagnostic(lines, facts.diagnostic);
+    return lines;
+}
+function renderCompose(result, columns) {
+    if (result.kind === "incomplete")
+        return "";
+    if (result.kind !== "accepted")
+        return renderFailure("compose", result, columns);
+    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`];
+    composeDiffs(lines, result.documentChanges);
+    return lines.join("\n");
+}
+export function renderTaskText(command, result, context = DEFAULT_CONTEXT) {
+    if (isWorldObservation(result)) {
+        if (result.kind === "absent")
+            return "task world absent";
+        if (result.kind === "failed") {
+            const lines = ["task world failed"];
+            receiptPayload(lines, "diagnostic", result.failure.message);
+            return lines.join("\n");
+        }
+        result = result.value;
+    }
+    return renderTaskValue(command, result, context.columns);
+}
+function renderTaskValue(command, result, columns) {
     if (command.action === "show")
-        return renderShow(result);
-    if (command.action === "ls" || command.action === "ready" || command.action === "blocked")
-        return renderRows(result);
+        return renderShow(result, columns);
+    if (command.action === "ls" || command.action === "ready" || command.action === "blocked" || command.action === "query") {
+        return renderRows(command, result, columns);
+    }
     if (command.action === "tree") {
         const tree = result;
-        return tree.kind === "accepted" ? treeLines(tree.value).join("\n") : failure(tree);
-    }
-    if (command.action === "doctor") {
-        const report = result;
-        return report.issues.length === 0 ? "healthy" : report.issues.map(doctorIssue).join("\n");
+        return tree.kind === "accepted" ? treeLines(tree.value, columns).join("\n") : renderFailure(command.action, tree, columns);
     }
+    if (command.action === "doctor")
+        return renderDoctor(result);
     if (command.action === "namespace") {
         const namespace = result;
-        return namespace.kind === "accepted" ? namespace.value.join("/") || "root" : failure(namespace);
-    }
-    if (command.action === "compose") {
-        const composition = result;
-        return composition.kind === "accepted" ? changes(composition.documentChanges) : composition.kind === "incomplete" ? "" : failure(composition);
+        if (namespace.kind !== "accepted")
+            return renderFailure(command.action, namespace, columns);
+        return `namespace ${namespace.value.length === 0 ? "root" : namespace.value.join("/")}`;
     }
+    if (command.action === "compose")
+        return renderCompose(result, columns);
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {
-        const batch = result;
-        return batch.items.map((item) => item.outcome.kind === "accepted" ? `accepted ${item.id}` : `${item.id}: ${failure(item.outcome)}`).join("\n");
-    }
-    const mutation = result;
-    if (mutation.kind !== "accepted")
-        return failure(mutation);
-    if (command.action === "update") {
-        const value = mutation.value;
-        return [row(value.task), value.documentDiff].filter((line) => line.length > 0).join("\n");
+        return renderBatch(command.action, result);
     }
-    return row(mutation.value);
+    return renderMutation(command, result, columns);
 }
 export function renderTaskIncompleteDiagnostic(result) {
     if (result.kind !== "incomplete")
         return "";
-    return [`incomplete ${JSON.stringify(result.stopped)}`, changes(result.documentChanges)].filter((line) => line.length > 0).join("\n");
+    const lines = [`! compose incomplete · ${result.documentChanges.length} admitted`, ...stoppedLines(result.stopped)];
+    composeDiffs(lines, result.documentChanges);
+    return lines.join("\n");
 }
 export function taskExitCode(result) {
+    if (isWorldObservation(result)) {
+        if (result.kind === "absent")
+            return 1;
+        if (result.kind === "failed")
+            return 3;
+        result = result.value;
+    }
     if (typeof result === "object" && result !== null && "issues" in result)
         return result.issues.length === 0 ? 0 : 1;
     if (typeof result === "object" && result !== null && "items" in result) {

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

@@ -2,9 +2,29 @@ export type TextRenderContext = Readonly<{
     columns: number;
     color: boolean;
 }>;
+export type GitShortStat = Readonly<{
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}>;
+export declare function gitShortStat(stat: GitShortStat): string;
 export declare function displayColumns(value: string): number;
+export declare function takeDisplayColumns(value: string, maximum: number): Readonly<{
+    text: string;
+    rest: string;
+}>;
+export declare function truncateDisplayText(value: string, maximum: number): string;
+export declare function truncateMiddleDisplayText(value: string, maximum: number): string;
+export declare function renderBoundedTextBlock(value: string, input: Readonly<{
+    first: string;
+    continuation: string;
+    columns: number;
+    lines?: number;
+    truncated?: boolean;
+}>): readonly string[];
 export declare function safeText(value: string): string;
 export declare function renderFacts(primary: string, facts: readonly string[], columns: number): readonly string[];
 export declare function renderTextBlock(value: string, indent: string, columns: number): readonly string[];
+export declare function renderOpaqueBlock(value: string, indent: string, columns: number): readonly string[];
 export declare function renderVoiceRuler(left: string, right: string, columns: number): string;
 export declare function tone(value: string, kind: "dim" | "alert", color: boolean): string;

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

@@ -1,3 +1,17 @@
+export function gitShortStat(stat) {
+    const files = stat.filesChanged === 1 ? "1 file changed" : `${stat.filesChanged} files changed`;
+    const parts = [files];
+    if (stat.insertions === 1)
+        parts.push("1 insertion(+)");
+    else if (stat.insertions !== 0)
+        parts.push(`${stat.insertions} insertions(+)`);
+    if (stat.deletions === 1)
+        parts.push("1 deletion(-)");
+    else if (stat.deletions !== 0)
+        parts.push(`${stat.deletions} deletions(-)`);
+    return parts.join(", ");
+}
+const GRAPHEMES = new Intl.Segmenter("und", { granularity: "grapheme" });
 const WIDE_RANGES = [
     [0x1100, 0x115f], [0x2329, 0x232a], [0x2e80, 0xa4cf], [0xac00, 0xd7a3],
     [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60],
@@ -19,6 +33,80 @@ export function displayColumns(value) {
         columns += characterColumns(character);
     return columns;
 }
+export function takeDisplayColumns(value, maximum) {
+    const characters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
+    let columns = 0;
+    let index = 0;
+    for (; index < characters.length; index += 1) {
+        const width = displayColumns(characters[index]);
+        if (columns + width > maximum)
+            break;
+        columns += width;
+    }
+    return { text: characters.slice(0, index).join(""), rest: characters.slice(index).join("") };
+}
+export function truncateDisplayText(value, maximum) {
+    const clean = safeText(value);
+    if (displayColumns(clean) <= maximum)
+        return clean;
+    if (maximum <= 0)
+        return "";
+    if (maximum === 1)
+        return "…";
+    return `${takeDisplayColumns(clean, maximum - 1).text.replace(/…+$/u, "")}…`;
+}
+export function truncateMiddleDisplayText(value, maximum) {
+    const clean = safeText(value);
+    if (displayColumns(clean) <= maximum)
+        return clean;
+    if (maximum <= 0)
+        return "";
+    if (maximum === 1)
+        return "…";
+    const available = maximum - 1;
+    const headColumns = Math.ceil(available / 2);
+    const tailColumns = available - headColumns;
+    const head = takeDisplayColumns(clean, headColumns).text.replace(/…+$/u, "");
+    const characters = [...GRAPHEMES.segment(clean)].map(({ segment }) => segment);
+    let tailStart = characters.length;
+    let used = 0;
+    while (tailStart > 0) {
+        const candidate = characters[tailStart - 1];
+        const width = displayColumns(candidate);
+        if (used + width > tailColumns)
+            break;
+        used += width;
+        tailStart -= 1;
+    }
+    return `${head}…${characters.slice(tailStart).join("").replace(/^…+/u, "")}`;
+}
+export function renderBoundedTextBlock(value, input) {
+    const maximumLines = input.lines ?? 3;
+    let rest = safeText(value).replace(/\s+/gu, " ").trim();
+    const lines = [];
+    for (let index = 0; index < maximumLines && rest.length > 0; index += 1) {
+        const prefix = index === 0 ? input.first : input.continuation;
+        const budget = Math.max(1, input.columns - displayColumns(prefix));
+        if (index === maximumLines - 1) {
+            const force = input.truncated === true || displayColumns(rest) > budget;
+            lines.push(`${prefix}${force ? truncateDisplayText(`${rest}…`, budget) : rest}`);
+            rest = "";
+            break;
+        }
+        if (displayColumns(rest) <= budget) {
+            lines.push(`${prefix}${input.truncated === true ? truncateDisplayText(`${rest}…`, budget) : rest}`);
+            rest = "";
+            break;
+        }
+        const taken = takeDisplayColumns(rest, budget);
+        let split = taken.text.lastIndexOf(" ");
+        if (split < Math.floor(taken.text.length / 2))
+            split = taken.text.length;
+        lines.push(`${prefix}${taken.text.slice(0, split).trimEnd()}`);
+        rest = `${taken.text.slice(split)}${taken.rest}`.trimStart();
+    }
+    return lines.length === 0 ? [input.first.trimEnd()] : lines;
+}
 export function safeText(value) {
     return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => /\s/u.test(character) ? " " : "�");
 }
@@ -62,6 +150,39 @@ export function renderTextBlock(value, indent, columns) {
     lines.push(current);
     return lines;
 }
+export function renderOpaqueBlock(value, indent, columns) {
+    let rest = safeText(value);
+    if (rest.length === 0)
+        return [indent.trimEnd()];
+    const continuation = `${indent}  `;
+    const lines = [];
+    let prefix = indent;
+    while (rest.length > 0) {
+        const budget = columns - displayColumns(prefix);
+        if (budget <= 0) {
+            if (prefix === continuation) {
+                lines.push(`${prefix}${rest}`);
+                break;
+            }
+            lines.push(prefix.trimEnd());
+            prefix = continuation;
+            continue;
+        }
+        if (displayColumns(rest) <= budget) {
+            lines.push(`${prefix}${rest}`);
+            break;
+        }
+        const taken = takeDisplayColumns(rest, budget);
+        if (taken.text.length === 0) {
+            lines.push(`${prefix}${rest}`);
+            break;
+        }
+        lines.push(`${prefix}${taken.text}`);
+        rest = taken.rest;
+        prefix = continuation;
+    }
+    return lines;
+}
 export function renderVoiceRuler(left, right, columns) {
     const width = Math.max(20, Math.min(80, columns));
     const occupied = displayColumns(left) + displayColumns(right) + 2;

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

@@ -2,14 +2,22 @@ import { renderObservation } from "./board.js";
 import { renderAccepted, renderRetry } from "./contract.js";
 import { renderKanshiText } from "./kanshi.js";
 import { renderRefusal } from "./refusal.js";
+import { renderCatalogText } from "./catalog.js";
+import { renderRegionText } from "./region.js";
 export function renderText(result, context) {
+    if (result.kind === "guidance")
+        return result.guidance;
     if (result.kind === "status")
         return renderKanshiText(result.report, context, result.selection);
+    if (result.kind === "catalog")
+        return renderCatalogText(result.catalog);
+    if (result.kind === "region")
+        return renderRegionText(result.region);
     if (result.kind === "accepted")
-        return renderAccepted(result);
+        return renderAccepted(result, context);
     if (result.kind === "refused")
-        return renderRefusal(result);
+        return renderRefusal(result, context);
     if (result.kind === "retry")
-        return renderRetry(result);
+        return renderRetry(result, context);
     return renderObservation(result);
 }