@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,11 +1,22 @@
 import { displayColumns, renderTextBlock, safeText, tone } from "./terminal.js";
-function contractMark(phase) {
-    if (phase === "claimed")
+const RULE = "─";
+const HORIZON = "───";
+const PLUMB = "  │ ";
+const PATH_PREFIX = `${PLUMB}↳ `;
+function contractMark(row) {
+    if (row.phase === "claimed")
         return "✓";
-    if (phase === "abandoned")
+    if (row.phase === "abandoned")
         return "×";
-    if (phase === "waiting" || phase === "pending-delivery")
-        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 "○";
     return "●";
 }
 function taskMark(row) {
@@ -14,18 +25,20 @@ function taskMark(row) {
     if (row.disposition === "drop")
         return "×";
     if (row.disposition === "on_hold")
-        return "‖";
+        return "⧗";
     if (row.disposition === "in_progress")
         return "●";
-    return row.disposition === "blocked" ? "⧗" : "○";
+    return row.disposition === "blocked" ? "‖" : "○";
 }
 function akumaMark(life) {
     if (life === "running")
         return "●";
     if (life === "stillborn")
         return "!";
-    if (life === "asleep" || life === "dead")
+    if (life === "asleep")
         return "○";
+    if (life === "killed")
+        return "×";
     return "?";
 }
 function gateMark(report) {
@@ -33,35 +46,111 @@ function gateMark(report) {
         return "?";
     return report.current.verdict === "satisfied" ? "✓" : "!";
 }
-function hotFirst(rows, hot) {
-    return [...rows.filter(hot), ...rows.filter((row) => !hot(row))];
+function formatAge(source, observedAt) {
+    if (source === null || source === undefined)
+        return "—";
+    const sourceMs = Date.parse(source);
+    const observedMs = Date.parse(observedAt);
+    if (sourceMs > observedMs)
+        return "future";
+    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`;
 }
-function wrapChain(parts, columns) {
-    if (parts.length === 0)
-        return [];
-    const lines = [];
-    let current = "  ";
-    for (const part of parts.map(safeText)) {
-        const candidate = current === "  " ? `${current}${part}` : `${current} · ${part}`;
-        if (current !== "  " && displayColumns(candidate) > columns) {
-            lines.push(current);
-            current = `  ${part}`;
-        }
-        else
-            current = candidate;
+function isLost(life) {
+    return life === "stranded" || life === "hung" || life === "untidy";
+}
+function branchName(target) {
+    if (target === null)
+        return null;
+    return target.startsWith("refs/heads/") ? target.slice("refs/heads/".length) : target;
+}
+function targetFacts(row) {
+    const name = branchName(row.target);
+    if (name === null)
+        return ["no target"];
+    const facts = [`target ${name}`];
+    if (row.targetLag.kind === "unknown")
+        facts.push("behind unknown");
+    if (row.targetLag.kind === "counted")
+        facts.push(`behind ${row.targetLag.behind}`);
+    if (row.targetObservation?.drift === true)
+        facts.push("drift");
+    return facts;
+}
+function workspaceState(row) {
+    const observation = row.workspaceObservation;
+    if (row.workspace === "here")
+        return `workspace here · ${observation.kind}`;
+    if (observation.kind === "unappointed")
+        return "worktree unappointed";
+    if (observation.kind === "unavailable")
+        return "worktree unavailable";
+    if (observation.kind === "clean")
+        return "worktree clean";
+    const counts = [
+        ...(observation.counts.staged > 0 ? [`staged ${observation.counts.staged}`] : []),
+        ...(observation.counts.unstaged > 0 ? [`unstaged ${observation.counts.unstaged}`] : []),
+        ...(observation.counts.untracked > 0 ? [`untracked ${observation.counts.untracked}`] : []),
+        ...(observation.counts.submodules > 0 ? [`submodules ${observation.counts.submodules}`] : []),
+    ];
+    return counts.length === 0 ? "worktree dirty" : `worktree dirty · ${counts.join(" · ")}`;
+}
+function showWorkspacePath(row, hot) {
+    if (row.workspace !== "worktree")
+        return false;
+    if (row.workspaceObservation.kind === "unappointed")
+        return false;
+    if (row.workspaceObservation.kind !== "clean")
+        return true;
+    return hot;
+}
+function contractHot(row) {
+    if (row.title === null)
+        return true;
+    if (row.phase === "pending-delivery")
+        return true;
+    if (row.holder.kind === "unavailable" || row.holder.kind === "held")
+        return true;
+    if (row.fleet.length > 0)
+        return true;
+    if (row.targetLag.kind === "counted" && row.targetLag.behind > 0)
+        return true;
+    if (row.workspaceObservation.kind !== "clean" && row.workspaceObservation.kind !== "unappointed") {
+        return true;
     }
-    lines.push(current);
-    return lines;
+    return row.gates.reports.some((report) => report.current.kind === "stale"
+        || (report.current.kind === "attested" && report.current.verdict === "unsatisfied"));
+}
+function taskHot(row) {
+    return row.disposition === "blocked" || row.disposition === "in_progress";
+}
+function akumaHot(row) {
+    if (row.life === "running" || row.life === "stillborn" || isLost(row.life))
+        return true;
+    return row.contract?.observed === "missing" || row.contract?.observed === "unavailable";
 }
-function wrapHeading(primary, facts, columns) {
-    const head = safeText(primary);
+function aperture(label, columns) {
+    const prefix = `──[ ${label} ]`;
+    const fill = Math.max(1, columns - displayColumns(prefix));
+    return `${prefix}${RULE.repeat(fill)}`;
+}
+function plumbFacts(facts, columns) {
+    const clean = facts.map(safeText).filter((fact) => fact.length > 0);
+    if (clean.length === 0)
+        return [];
     const lines = [];
-    let current = head;
-    for (const fact of facts.map(safeText)) {
-        const candidate = `${current} · ${fact}`;
-        if (displayColumns(candidate) > columns) {
+    let current = PLUMB;
+    for (const fact of clean) {
+        const candidate = current === PLUMB ? `${PLUMB}${fact}` : `${current} · ${fact}`;
+        if (current !== PLUMB && displayColumns(candidate) > columns) {
             lines.push(current);
-            current = `  ${fact}`;
+            current = `${PLUMB}${fact}`;
         }
         else
             current = candidate;
@@ -69,136 +158,190 @@ function wrapHeading(primary, facts, columns) {
     lines.push(current);
     return lines;
 }
-function renderGates(reports, context, includeSummaries) {
-    const lines = [...wrapChain(reports.map((report) => `${gateMark(report)} ${safeText(report.gate)}`), context.columns)];
+function plumbBlock(value, columns) {
+    return renderTextBlock(value, PLUMB, columns);
+}
+function plumbPath(path) {
+    return `${PATH_PREFIX}${safeText(path)}`;
+}
+function identityLine(mark, identity, extra = "") {
+    return extra.length === 0 ? `${mark} ${safeText(identity)}` : `${mark} ${safeText(identity)} ${safeText(extra)}`;
+}
+function renderGates(reports, observedAt, columns, includeSummaries) {
+    if (reports.length === 0)
+        return [];
+    const lines = [...plumbFacts([`gates: ${reports.map((report) => `${gateMark(report)} ${report.gate} ${formatAge(report.current.kind === "attested" ? report.current.at : null, observedAt)}`).join(" · ")}`], columns)];
     if (!includeSummaries)
         return lines;
     for (const report of reports) {
         if (report.current.kind !== "attested" || report.current.summary === undefined)
             continue;
-        lines.push(...renderTextBlock(`${safeText(report.gate)}: ${report.current.summary}`, "  ", context.columns)
-            .map((line) => tone(line, "dim", context.color)));
+        lines.push(...plumbBlock(`${report.gate}: ${report.current.summary}`, columns));
     }
     return lines;
 }
 function failure(name, section, context) {
-    return `${name} failed\n${tone(`! ${safeText(section.failure.message)}`, "alert", context.color)}`;
+    return [aperture(name, context.columns), `${tone(`! ${safeText(section.failure.message)}`, "alert", context.color)}`];
+}
+function sectionAbsent(name, columns) {
+    return [aperture(name, columns), `${PLUMB}${name.toLowerCase()} absent`];
+}
+function endpointFact(id, observed) {
+    if (observed === "missing")
+        return `-> ${id} (missing)`;
+    if (observed === "unavailable")
+        return `-> ${id} (unavailable)`;
+    return `-> ${id}`;
 }
 function renderContracts(report, context, selection) {
     const section = report.contracts;
     if (section.kind === "absent")
-        return "keiyaku absent";
+        return sectionAbsent("KEIYAKU", context.columns);
     if (section.kind === "failed")
-        return failure("keiyaku", section, context);
-    const rows = hotFirst(section.value.rows, (row) => row.phase === "waiting" || row.phase === "pending-delivery");
-    const lines = [`keiyaku ${rows.length}`];
+        return failure("KEIYAKU", section, context);
+    const rows = [
+        ...section.value.rows.filter(contractHot),
+        ...section.value.rows.filter((row) => !contractHot(row)),
+    ];
+    const lines = [aperture("KEIYAKU", context.columns)];
     for (const row of rows) {
-        const facts = [
-            row.workspace,
-            ...(row.candidate === null ? [] : [`candidate ${safeText(row.candidate).slice(0, 8)}`]),
-            ...(row.target === null ? [] : [`-> ${row.target}`]),
-        ];
-        lines.push(`${contractMark(row.phase)} ${safeText(row.id)} ${row.phase}`);
-        lines.push(...wrapChain(facts, context.columns));
-        lines.push(...renderGates(row.gates.reports, context, selection === "contract"));
+        const hot = contractHot(row);
+        const compact = !hot && selection !== "contract";
+        const title = row.title ?? "title unavailable";
+        const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
+        lines.push(identityLine(contractMark(row), row.id));
+        lines.push(...plumbFacts(compact
+            ? [title, phase, ...targetFacts(row)]
+            : [title], context.columns));
+        if (!compact)
+            lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
+        lines.push(...plumbFacts([workspaceState(row)], context.columns));
+        if (showWorkspacePath(row, hot || selection === "contract")
+            && row.workspaceObservation.kind !== "unappointed"
+            && row.workspaceObservation.location.kind === "worktree") {
+            lines.push(plumbPath(row.workspaceObservation.location.path));
+        }
+        lines.push(...renderGates(row.gates.reports, report.observedAt, context.columns, selection === "contract"));
+        if (row.holder.kind === "held")
+            lines.push(...plumbFacts([`task ${row.holder.taskId}`], context.columns));
+        if (row.holder.kind === "unavailable")
+            lines.push(...plumbFacts(["holder unavailable"], context.columns));
+        for (const attached of row.fleet) {
+            const aliases = attached.aliases.length === 0 ? "" : ` (${attached.aliases.join(" ")})`;
+            lines.push(...plumbFacts([`akuma ${attached.id}${aliases}`], context.columns));
+        }
     }
-    return lines.join("\n");
+    const attention = rows.filter(contractHot).length;
+    lines.push(aperture(`${rows.length} keiyaku · ${attention} attention`, context.columns));
+    return lines;
 }
 function renderTasks(report, context) {
     const section = report.tasks;
     if (section.kind === "absent")
-        return "task absent";
+        return sectionAbsent("TASK", context.columns);
     if (section.kind === "failed")
-        return failure("task", section, context);
-    const active = section.value.rows.filter((row) => row.disposition !== "done" && row.disposition !== "drop");
-    const ready = active.filter((row) => row.disposition === "ready").length;
-    const onHold = active.filter((row) => row.disposition === "on_hold").length;
-    const visible = hotFirst(active.filter((row) => row.disposition === "in_progress" || row.disposition === "blocked"), (row) => row.disposition === "blocked");
-    const lines = [...wrapHeading(`task ${active.length}`, [`${ready} ready`, `${onHold} held`], context.columns)];
-    for (const row of visible) {
-        const contract = row.contract === undefined ? [] : [`keiyaku ${row.contract.id} (${row.contract.observed})`];
-        lines.push(`${taskMark(row)} ${safeText(row.id)} ${row.disposition}`);
-        lines.push(...renderTextBlock(row.title, "  ", context.columns));
-        lines.push(...wrapChain([`P${row.priority}`, ...contract], context.columns));
-    }
-    return lines.join("\n");
-}
-function isLost(life) {
-    return life === "stranded" || life === "headless";
-}
-function akumaPriority(row) {
-    if (isLost(row.life) || row.life === "stillborn")
-        return 0;
-    return row.life === "running" ? 1 : 2;
-}
-function firstLine(value) {
-    return value.split(/[\r\n\u2028\u2029]/u, 1)[0] ?? "";
-}
-function truncateDisplay(value, columns) {
-    if (displayColumns(value) <= columns)
-        return value;
-    if (columns <= 0)
-        return "";
-    const ellipsis = "…";
-    if (columns <= displayColumns(ellipsis))
-        return ellipsis;
-    let result = "";
-    let used = 0;
-    for (const character of value) {
-        const width = displayColumns(character);
-        if (used + width + displayColumns(ellipsis) > columns)
-            break;
-        result += character;
-        used += width;
-    }
-    return `${result}${ellipsis}`;
-}
-function bornFacts(row) {
-    if (!("pending" in row) || (row.life !== "running" && !isLost(row.life)))
-        return [];
-    const confinement = row.confinement.kind === "unconfined"
-        ? ["unconfined"]
-        : row.confinement.writableRoots.map((root, index) => index === 0 ? `writes ${root}` : root);
-    return [
-        ...(row.pending.length === 0 ? [] : [`pending ${row.pending.length}`]),
-        ...confinement,
+        return failure("TASK", section, context);
+    const rows = [
+        ...section.value.rows.filter(taskHot),
+        ...section.value.rows.filter((row) => !taskHot(row)),
     ];
+    const lines = [aperture("TASK", context.columns)];
+    for (const row of rows) {
+        const compact = !taskHot(row);
+        lines.push(identityLine(taskMark(row), row.id));
+        const relation = row.contract === undefined
+            ? ["unbound"]
+            : [endpointFact(row.contract.id, row.contract.observed)];
+        const facts = [row.title, row.disposition, `P${row.priority}`, ...relation];
+        if (compact)
+            lines.push(...plumbFacts(facts, context.columns));
+        else {
+            lines.push(...plumbBlock(row.title, context.columns));
+            lines.push(...plumbFacts([row.disposition, `P${row.priority}`], context.columns));
+            for (const blocker of row.blockers ?? []) {
+                lines.push(...plumbFacts([`blocked by ${blocker.id}`], context.columns));
+            }
+            lines.push(...plumbFacts(relation, context.columns));
+        }
+    }
+    const attention = rows.filter(taskHot).length;
+    lines.push(aperture(`${rows.length} task · ${attention} attention`, context.columns));
+    return lines;
 }
-function stillbornEvidence(row, columns) {
-    if (row.life !== "stillborn" || !("seal" in row) || row.seal === undefined)
-        return null;
-    const prefix = "  seal ";
-    const evidence = safeText(firstLine(row.seal.evidence)).trim();
-    if (evidence.length === 0)
-        return null;
-    return `${prefix}${truncateDisplay(evidence, Math.max(0, columns - displayColumns(prefix)))}`;
+function akumaLabel(row) {
+    const aliases = row.aliases ?? [];
+    return aliases.length === 0 ? "" : `(${aliases.join(" ")})`;
 }
 function renderAkuma(report, context) {
     const section = report.akuma;
     if (section.kind === "absent")
-        return "akuma absent";
+        return sectionAbsent("FLEET", context.columns);
     if (section.kind === "failed")
-        return failure("akuma", section, context);
+        return failure("FLEET", section, context);
     const rows = [
-        ...section.value.rows.filter((row) => akumaPriority(row) === 0),
-        ...section.value.rows.filter((row) => akumaPriority(row) === 1),
-        ...section.value.rows.filter((row) => akumaPriority(row) === 2),
+        ...section.value.rows.filter(akumaHot),
+        ...section.value.rows.filter((row) => !akumaHot(row)),
     ];
-    const lines = [`akuma ${rows.length}`];
+    const lines = [aperture("FLEET", context.columns)];
     for (const row of rows) {
-        lines.push(`${akumaMark(row.life)} ${safeText(row.id)} ${row.life}`);
-        lines.push(...wrapChain(bornFacts(row), context.columns));
-        const evidence = stillbornEvidence(row, context.columns);
-        if (evidence !== null)
-            lines.push(evidence);
+        lines.push(identityLine(akumaMark(row.life), row.id, akumaLabel(row)));
+        const lifeAt = "lifeAt" in row ? row.lifeAt : null;
+        const life = `${row.life} · ${formatAge(lifeAt, report.observedAt)}`;
+        const key = row.life === "stranded" && "strandedReason" in row && row.strandedReason === "resume-unsupported"
+            ? [life, "resume unsupported"]
+            : [life];
+        const relation = row.contract === undefined
+            ? ["unbound"]
+            : [endpointFact(row.contract.id, row.contract.observed)];
+        if (!akumaHot(row))
+            lines.push(...plumbFacts([...key, ...relation], context.columns));
+        else {
+            lines.push(...plumbFacts(key, context.columns));
+            lines.push(...plumbFacts(relation, context.columns));
+        }
     }
-    return lines.join("\n");
+    const attention = rows.filter(akumaHot).length;
+    lines.push(aperture(`${rows.length} akuma · ${attention} attention`, context.columns));
+    return lines;
+}
+function sectionCount(name, section) {
+    if (section.kind === "present")
+        return `${section.value.rows.length} ${name}`;
+    return `${section.kind} ${name}`;
+}
+function worldCoordinate(report) {
+    const project = report.root;
+    const branch = report.branch?.startsWith("refs/heads/") === true
+        ? report.branch.slice("refs/heads/".length)
+        : report.branch;
+    const state = report.contracts.kind === "present" ? report.contracts.value.state ?? null : null;
+    return [project, branch, state].filter((part) => part !== null && part.length > 0).map(safeText).join(" ");
+}
+function splitHorizon(report, columns) {
+    if (report.root === null)
+        return ["✗ keiyaku world absent"];
+    const aggregate = [
+        sectionCount("keiyaku", report.contracts),
+        sectionCount("akuma", report.akuma),
+        sectionCount("task", report.tasks),
+    ].join(" · ");
+    const world = worldCoordinate(report);
+    const minimum = `kanshi ${HORIZON} ${aggregate} ${HORIZON} ${world}`;
+    if (displayColumns(minimum) > columns)
+        return [minimum];
+    const fill = columns - displayColumns(minimum);
+    const left = Math.floor(fill / 2);
+    const right = Math.ceil(fill / 2);
+    return [`kanshi ${HORIZON}${RULE.repeat(left)} ${aggregate} ${HORIZON}${RULE.repeat(right)} ${world}`];
 }
 export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
     return [
-        `kanshi ${safeText(report.root)}`,
-        renderContracts(report, context, selection),
-        renderTasks(report, context),
-        renderAkuma(report, context),
-    ].join("\n\n");
+        ...splitHorizon(report, context.columns),
+        "",
+        ...renderContracts(report, context, selection),
+        "",
+        ...renderTasks(report, context),
+        "",
+        ...renderAkuma(report, context),
+    ].join("\n");
 }

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

@@ -0,0 +1,19 @@
+import type { PlacementStop, VerificationReuse, VerificationStop } from "../../index.js";
+import type { AcceptedDeliverResult, Lag } from "../result.js";
+export type ReceiptSegment = Readonly<{
+    text: string;
+    opaque?: boolean;
+}>;
+type HookFailure = Extract<Lag, {
+    kind: "worktree-hook-failed";
+}>["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 hookFailureSummary(failure: HookFailure): string;
+export declare function appendHookPayload(lines: string[], failure: HookFailure): void;
+export declare function reuseLines(reuse: VerificationReuse | undefined, columns: number): readonly string[];
+export declare function stopLines(label: "verification" | "claim", stop: VerificationStop | PlacementStop, columns: number, addressed: string): readonly string[];
+export declare function cleanupLines(cleanup: NonNullable<AcceptedDeliverResult["cleanup"]>, columns: number): readonly string[];
+export declare function leakLines(leak: NonNullable<AcceptedDeliverResult["leak"]>, columns: number): readonly string[];
+export {};

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

@@ -0,0 +1,106 @@
+import { displayColumns, renderOpaqueBlock, safeText } from "./terminal.js";
+export function receiptRow(lines, mark, label, segments, columns) {
+    let current = `${mark} ${label}`;
+    for (const segment of segments) {
+        const text = segment.opaque === true ? safeText(segment.text) : segment.text;
+        const candidate = `${current} ${text}`;
+        if (displayColumns(candidate) <= columns) {
+            current = candidate;
+            continue;
+        }
+        if (current === `${mark} ${label}` && segment.opaque === true) {
+            lines.push(current);
+            current = `  ${text}`;
+            continue;
+        }
+        lines.push(current);
+        current = `  ${text}`;
+    }
+    lines.push(current);
+}
+export function receiptPayload(lines, label, payload) {
+    lines.push(label, "", payload, "");
+}
+export function outcomeLines(mark, verb, word, contract, columns = 80) {
+    const base = `${mark} ${verb} ${word}`;
+    if (contract === undefined)
+        return [base];
+    const inline = `${base} — ${contract}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return [`${base} —`, `  ${safeText(contract)}`];
+}
+export function hookFailureSummary(failure) {
+    if (failure.kind === "timeout" || failure.kind === "unknown-exit")
+        return failure.kind;
+    if (failure.kind === "spawn-error")
+        return failure.kind;
+    return `exit=${failure.code} · truncated=${failure.truncated}`;
+}
+export function appendHookPayload(lines, failure) {
+    if (failure.kind === "spawn-error")
+        receiptPayload(lines, "diagnostic", failure.diagnostic);
+    if (!("stdout" in failure))
+        return;
+    if (failure.stdout.length > 0)
+        receiptPayload(lines, "stdout", failure.stdout);
+    if (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);
+}
+export function stopLines(label, stop, columns, addressed) {
+    const detail = [];
+    if ("refusal" in stop && stop.refusal !== undefined) {
+        detail.push({ text: stop.refusal.kind });
+        if ("contractId" in stop.refusal && stop.refusal.contractId !== addressed) {
+            detail.push({ text: `contract=${stop.refusal.contractId}`, opaque: true });
+        }
+    }
+    else if ("retry" in stop && stop.retry !== undefined) {
+        detail.push({ text: stop.retry.kind });
+    }
+    else if ("failure" in stop) {
+        detail.push({ text: stop.failure });
+        if (stop.failure === "environment-failure" && "command" in stop) {
+            detail.push({ text: `command=${stop.command}` }, { text: hookFailureSummary(stop.detail), opaque: true });
+        }
+        else if (stop.failure === "target-moved") {
+            detail.push({ text: stop.target, opaque: true }, { text: `${stop.expected} -> ${stop.observed}`, opaque: true });
+        }
+    }
+    const lines = [];
+    receiptRow(lines, "!", label, detail, columns);
+    if ("failure" in stop && stop.failure === "environment-failure" && "command" in stop) {
+        appendHookPayload(lines, stop.detail);
+    }
+    if ("retry" in stop && stop.retry?.kind === "publication-failed") {
+        receiptPayload(lines, "diagnostic", stop.retry.diagnostic);
+    }
+    else if ("failure" in stop && "diagnostic" in stop) {
+        receiptPayload(lines, "diagnostic", stop.diagnostic);
+    }
+    return lines;
+}
+export function cleanupLines(cleanup, columns) {
+    const lines = [];
+    receiptRow(lines, "!", "cleanup", [
+        { text: cleanup.phase },
+        { text: `command=${cleanup.command}` },
+        { text: hookFailureSummary(cleanup.detail), opaque: true },
+    ], columns);
+    appendHookPayload(lines, cleanup.detail);
+    return lines;
+}
+export function leakLines(leak, columns) {
+    const lines = [];
+    receiptRow(lines, "!", "leak", [
+        { text: "worktree" },
+        { text: leak.path, opaque: true },
+    ], columns);
+    receiptPayload(lines, "diagnostic", leak.diagnostic);
+    return lines;
+}

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

@@ -1,2 +1,16 @@
-import type { RefusedResult } from "../result.js";
-export declare function renderRefusal(result: RefusedResult): string;
+import type { BindDraftReceipt, RefusedResult } from "../result.js";
+import type { KeiyakuRefusal } from "../../index.js";
+import { type TextRenderContext } from "./terminal.js";
+type DirtyWithOption = Extract<KeiyakuRefusal, {
+    kind: "dirty-workspace";
+}> & {
+    option?: Readonly<{
+        flag: string;
+        available: boolean;
+    }>;
+};
+export type RenderableRefusal = KeiyakuRefusal | DirtyWithOption;
+export declare function renderRefusalFacts(refusal: RenderableRefusal, indent: string, columns: number, addressed?: string): readonly string[];
+export declare function renderRefusal(result: RefusedResult, context?: TextRenderContext): string;
+export declare function renderBindDraftReceipt(receipt: BindDraftReceipt): string;
+export {};