@astrosheep/keiyaku 4.5.19 → 4.5.21

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}`;
@@ -53,13 +53,13 @@ export function appendHookPayload(lines, failure) {
         return;
     if (failure.stdout.length > 0)
         receiptPayload(lines, "stdout", failure.stdout);
-    if (failure.stderr.length > 0)
+    if (failure.stderr !== undefined && failure.stderr.length > 0)
         receiptPayload(lines, "stderr", failure.stderr);
 }
 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;

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

@@ -12,6 +12,16 @@ export function gitShortStat(stat) {
     return parts.join(", ");
 }
 const GRAPHEMES = new Intl.Segmenter("und", { granularity: "grapheme" });
+const NON_ASCII = /[^\x20-\x7e]/u;
+const MARK = /\p{Mark}/u;
+const PICTOGRAPHIC = /\p{Extended_Pictographic}/u;
+const EMOJI_DEFAULT = /\p{Emoji_Presentation}/u;
+const ZWJ = 0x200d;
+const TEXT_PRESENTATION = 0xfe0e;
+const EMOJI_PRESENTATION = 0xfe0f;
+const REGIONAL_FIRST = 0x1f1e6;
+const REGIONAL_LAST = 0x1f1ff;
+const ZERO_WIDTH = new Set([0x200b, 0x200c, 0x200d, 0x200e, 0x200f, 0x2060, 0xfeff]);
 const WIDE_RANGES = [
     [0x1100, 0x115f],
     [0x2329, 0x232a],
@@ -25,33 +35,59 @@ const WIDE_RANGES = [
     [0x1f300, 0x1faff],
     [0x20000, 0x3fffd],
 ];
-function characterColumns(character) {
-    const point = character.codePointAt(0);
-    if (point === undefined || point === 0 || /\p{Mark}/u.test(character) || point === 0xfe0f)
+/** Columns one code point occupies when its grapheme cluster gives it no wider form. */
+function baseColumns(point) {
+    if (point === 0 || point < 0x20 || (point >= 0x7f && point < 0xa0))
         return 0;
-    if (point < 0x20 || (point >= 0x7f && point < 0xa0))
+    if (ZERO_WIDTH.has(point) || MARK.test(String.fromCodePoint(point)))
         return 0;
     if (point === 0x303f)
         return 1;
     return WIDE_RANGES.some(([first, last]) => point >= first && point <= last) ? 2 : 1;
 }
+/**
+ * Columns one grapheme cluster occupies. A cluster is one terminal cell group even
+ * when it is built from many code points, so ZWJ sequences, flags, keycaps and
+ * variation selectors never count the width of their parts.
+ */
+function graphemeColumns(cluster) {
+    const points = [...cluster].map((character) => character.codePointAt(0));
+    if (points.every((point) => point === EMOJI_PRESENTATION || point === TEXT_PRESENTATION))
+        return 0;
+    const first = points[0];
+    if (points.length > 1 && points.every((point) => point >= REGIONAL_FIRST && point <= REGIONAL_LAST))
+        return 2;
+    // A presentation selector decides a text-default symbol: text stays narrow, emoji widens it.
+    if (points.includes(TEXT_PRESENTATION))
+        return baseColumns(first);
+    if (points.includes(EMOJI_PRESENTATION))
+        return 2;
+    // A joined pictographic sequence is one wide cluster; a plain text symbol is not.
+    if (points.includes(ZWJ) && PICTOGRAPHIC.test(cluster))
+        return 2;
+    if (EMOJI_DEFAULT.test(cluster))
+        return 2;
+    return baseColumns(first);
+}
 export function displayColumns(value) {
+    if (!NON_ASCII.test(value))
+        return value.length;
     let columns = 0;
-    for (const character of value)
-        columns += characterColumns(character);
+    for (const { segment } of GRAPHEMES.segment(value))
+        columns += graphemeColumns(segment);
     return columns;
 }
 export function takeDisplayColumns(value, maximum) {
-    const characters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
+    const clusters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
     let columns = 0;
     let index = 0;
-    for (; index < characters.length; index += 1) {
-        const width = displayColumns(characters[index]);
+    for (; index < clusters.length; index += 1) {
+        const width = graphemeColumns(clusters[index]);
         if (columns + width > maximum)
             break;
         columns += width;
     }
-    return { text: characters.slice(0, index).join(""), rest: characters.slice(index).join("") };
+    return { text: clusters.slice(0, index).join(""), rest: clusters.slice(index).join("") };
 }
 export function truncateDisplayText(value, maximum) {
     const clean = safeText(value);
@@ -210,10 +246,6 @@ export function tone(value, kind, color) {
     const code = kind === "dim" ? 2 : kind === "recent" ? 32 : kind === "attention" ? 33 : 31;
     return `\u001b[${code}m${value}\u001b[0m`;
 }
-export function boundedActivity(value, columns, prefix) {
-    const budget = Math.max(1, columns - displayColumns(prefix));
-    return `activity "${truncateDisplayText(value, Math.max(1, budget - displayColumns('activity ""')))}` + `"`;
-}
 export function plumbFacts(facts, columns) {
     const lines = [];
     let current = "  ";
@@ -255,7 +287,7 @@ export function entityLines(entity) {
     ];
 }
 export function renderSectionBlock({ name, rows, hasMore = false, }) {
-    const lines = [`[ ${name} ]`, "", ...rows.flat()];
+    const lines = [`${name}`, "", ...rows.flat()];
     if (hasMore)
         lines.push("…");
     return lines;

package/build/src/cli/result.d.ts

@@ -46,6 +46,7 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
         path: string;
     }>;
     target: string | null;
+    warnings?: readonly string[];
     completion?: never;
     verification?: never;
     verificationReuse?: never;

package/build/src/cli/runtime.d.ts

@@ -1,5 +1,7 @@
 import type { TaskInvocationResult } from "./commands/task-invoke.js";
 import type { ParsedCommand, ParsedExecution } from "./parse.js";
+import type { ExecutionEvent } from "../library/execution.js";
+export declare function writeExecutionProgress(events: AsyncIterable<ExecutionEvent>, stream?: NodeJS.WritableStream): Promise<void>;
 export declare function writeTask(command: Extract<ParsedCommand, {
     command: "task";
 }>, result: TaskInvocationResult): Promise<number>;