@astrosheep/keiyaku 4.0.5 → 4.0.6

package/build/src/cli/parse.js

@@ -1,12 +1,12 @@
-import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
-import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, } from "./commands/task.js";
+import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
-import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
-import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "./usage.js";
+import { AMEND_OPERATIONS_HELP, CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
+import { CliUsageError, isBlankInput, usageLine } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
 export function renderRootHelp() {
-    return withJsonAutomationHelp([
+    return [
         ROOT_USAGE,
         "",
         "global options:",
@@ -20,12 +20,12 @@ export function renderRootHelp() {
         "  task ...",
         "    Task coordination; see `keiyaku task --help`.",
         ...renderAkumaRootRows(),
-    ].join("\n"));
+    ].join("\n");
 }
 export function renderContractHelp(command) {
     const spec = CONTRACT_COMMAND_SPECS[command];
     const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
-    return withJsonAutomationHelp(command === "amend" ? `${help}\n\n${AMEND_MINIMAL_STDIN_HELP}` : help);
+    return command === "amend" ? `${help}\n\n${AMEND_OPERATIONS_HELP}` : help;
 }
 function contractUsage(command) {
     return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
@@ -39,6 +39,65 @@ export function renderCommandUsage(command) {
         return renderAkumaUsage(command.command);
     return contractUsage(command.command);
 }
+export function renderHelp(coordinate) {
+    switch (coordinate.kind) {
+        case "root": return renderRootHelp();
+        case "contract": return renderContractHelp(coordinate.command);
+        case "task": return renderTaskHelp(coordinate.action);
+        case "install": return renderInstallHelp();
+        case "akuma": return renderAkumaHelp(coordinate.action);
+    }
+}
+export function commandRepoPolicy(command) {
+    switch (command.command) {
+        case "bind":
+        case "amend":
+        case "deliver":
+        case "review":
+        case "arc":
+        case "abandon":
+        case "audit":
+        case "reconcile":
+        case "show":
+        case "region":
+            return { use: "required", acceptsExplicit: true };
+        case "ls":
+            return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
+        case "status":
+        case "tell":
+            return { use: "optional", acceptsExplicit: false };
+        case "history":
+            return "contract" in command
+                ? { use: "required", acceptsExplicit: true }
+                : { use: "optional", acceptsExplicit: false };
+        case "fork":
+            return { use: "optional", acceptsExplicit: true };
+        case "wait":
+        case "kill": {
+            const contractSelector = command.akuma.some((selector) => selector.startsWith("kei/"));
+            return { use: contractSelector ? "required" : "optional", acceptsExplicit: contractSelector };
+        }
+        case "call":
+            return {
+                use: command.contract === undefined ? "none" : "required",
+                acceptsExplicit: command.contract !== undefined,
+            };
+        case "settings":
+        case "nuke":
+        case "task":
+        case "install":
+            return { use: "none", acceptsExplicit: false };
+    }
+}
+function refuseUnusedRepo(command) {
+    if (command.command === "call")
+        throw new CliUsageError("--repo has no consumer without --contract");
+    throw new CliUsageError(`--repo has no consumer for ${command.command}`);
+}
+export function assertExplicitRepoUse(command, repo) {
+    if (repo !== undefined && !commandRepoPolicy(command).acceptsExplicit)
+        refuseUnusedRepo(command);
+}
 function optionalFlag(flags, name) {
     const value = flags[name];
     return typeof value === "string" ? value : undefined;
@@ -175,6 +234,7 @@ function parseDeliver(parts) {
         ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         ...(message === undefined ? {} : { message }),
         includeDirty: parts.flags["include-dirty"] === true,
+        materializeConflict: parts.flags["materialize-conflict"] === true,
         output: parts.output,
     };
 }
@@ -356,6 +416,10 @@ function parseCommand(parts) {
                 output: parts.output,
             };
         }
+        case "nuke": {
+            const confirm = optionalFlag(parts.flags, "confirm");
+            return { command: "nuke", ...(confirm === undefined ? {} : { confirm }), output: parts.output };
+        }
         case "settings": return { command: "settings", output: parts.output };
         case "region": return parseRegion(parts);
     }
@@ -379,9 +443,10 @@ export function parseArgv(argv) {
     const akuma = isAkumaAction(invocation.commandArgv[0])
         ? parseAkumaCommand(invocation.commandArgv)
         : undefined;
-    return {
+    const parsed = {
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
         command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
     };
+    return parsed;
 }

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

@@ -1,5 +1,5 @@
 import { toolRepr } from "./akuma-tool.js";
-import { displayColumns, renderBoundedTextBlock, renderTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
+import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
 const DEFAULT_CONTEXT = { columns: 80, color: false };
 const OPENING_STROKE = "─────";
 const TIME_WIDTH = 5;
@@ -30,7 +30,7 @@ function unobservedText(id, diagnostic) {
 }
 function lifeLabel(life) {
     if (life === "running")
-        return "● running";
+        return "● STILL RUNNING";
     if (life === "asleep")
         return "○ asleep";
     if (life === "killed")
@@ -70,7 +70,7 @@ function mark(row) {
             return "?";
         return row.state.status === "ok" ? "✓" : "!";
     }
-    return "·";
+    return "│";
 }
 function rowText(row) {
     if (row.kind === "said" || row.kind === "thought" || row.kind === "note" || row.kind === "call" || row.kind === "tell") {
@@ -160,47 +160,59 @@ function taskDispositionMark(disposition) {
         return "●";
     return disposition === "blocked" ? "‖" : "○";
 }
-function taskScanLine(row, indent = "") {
-    return `${indent}${taskDispositionMark(row.disposition)} ${row.id} · P${row.priority} ${row.disposition}`;
-}
-function changeOp(op) {
-    return op === "add" ? "write" : op === "delete" ? "delete" : "edit";
-}
-function renderReportedChangeLines(snapshot, columns) {
-    const lines = [`  changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`];
-    for (const change of snapshot.reportedChanges) {
-        const scan = `  ${changeOp(change.op)}`;
-        const path = safeText(change.path);
-        const stat = change.diffstat === undefined
-            ? ""
-            : ` — +${change.diffstat.added} -${change.diffstat.removed}`;
-        const inline = `${scan} ${path}${stat}`;
-        if (displayColumns(inline) <= columns)
-            lines.push(inline);
-        else
-            lines.push(`${scan}`, ...renderTextBlock(`${path}${stat}`, "    ", columns));
+function changeStat(group) {
+    let added = 0;
+    let removed = 0;
+    for (const change of group) {
+        if (change.diffstat === undefined)
+            return "+? -?";
+        added += change.diffstat.added;
+        removed += change.diffstat.removed;
     }
-    if (snapshot.reportedChangesOmitted > 0) {
-        lines.push(`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`);
+    return `+${added} -${removed}`;
+}
+function groupedChangeRows(changes) {
+    const groups = [];
+    const seen = new Map();
+    for (const change of changes) {
+        const index = seen.get(change.path);
+        if (index === undefined) {
+            seen.set(change.path, groups.length);
+            groups.push([change]);
+        }
+        else
+            groups[index].push(change);
     }
-    return lines;
+    return groups.map((group) => ({ path: group[0].path, stat: changeStat(group) }));
+}
+function renderReportedChangeLines(snapshot) {
+    const rows = groupedChangeRows(snapshot.reportedChanges);
+    const width = rows.reduce((max, row) => Math.max(max, row.stat.length), 0);
+    return [
+        `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
+        ...rows.map((row) => `  ${row.stat.padEnd(width)}  ${safeText(row.path)}`),
+        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`] : []),
+    ];
+}
+function renderTaskRow(row, columns) {
+    const prefix = `  ${taskDispositionMark(row.disposition)} ${row.id} · `;
+    const body = `${safeText(row.title)} · ${row.disposition} · P${row.priority}`;
+    const inline = `${prefix}${body}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return renderBoundedTextBlock(body, {
+        first: prefix,
+        continuation: "    ",
+        columns,
+        lines: Number.MAX_SAFE_INTEGER,
+    });
 }
 function renderTaskContextLines(created, columns) {
     if (created === undefined)
         return [];
     if (created.kind === "failed")
         return [`! tasks failed ${safeText(created.diagnostic)}`];
-    const lines = [`  tasks ${created.rows.length}`];
-    for (const row of created.rows) {
-        const scan = `  ${taskScanLine(row)}`;
-        const title = safeText(row.title);
-        const inline = `${scan} — ${title}`;
-        if (displayColumns(inline) <= columns)
-            lines.push(inline);
-        else
-            lines.push(`${scan} —`, ...renderTextBlock(title, "    ", columns));
-    }
-    return lines;
+    return [`tasks ${created.rows.length}`, ...created.rows.flatMap((row) => renderTaskRow(row, columns))];
 }
 function snapshotText(view, context, options = {}) {
     const snapshot = view.status.timeline;
@@ -215,14 +227,14 @@ function snapshotText(view, context, options = {}) {
         ...contractFacts(view.contract),
         ...(options.facts ?? []),
     ];
-    const footer = options.showLife === false ? [] : [`  ${lifeLabel(view.status.life)}`];
+    const footer = options.showLife === false ? [] : ["", lifeLabel(view.status.life)];
     return [
         ...snapshotHeading(view.status.id, options.alias, view.contract),
         ...facts,
         ...activity,
-        ...footer,
-        ...renderReportedChangeLines(snapshot, context.columns),
         ...renderTaskContextLines(view.createdTasks, context.columns),
+        ...renderReportedChangeLines(snapshot),
+        ...footer,
     ].join("\n");
 }
 function observationStageText(id, observation, context, options = {}) {
@@ -291,6 +303,9 @@ export function akumaRawAnswer(result) {
 function executionCwdLine(result) {
     return result.execution.source === "contract-worktree" ? [`cwd ${result.execution.cwd}`] : [];
 }
+function posixShellArgument(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
 function callText(result, context) {
     const alias = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : undefined;
     const contractId = result.result.dispatch.kind === "dispatched" ? result.result.dispatch.dispatch.contractId : undefined;
@@ -305,7 +320,7 @@ function callText(result, context) {
                 : { kind: "associated", contractId }), ...cwd, ...restraint, ...facts];
         if (!callFailed(result.result)) {
             const selector = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : result.result.akuma;
-            lines.push(`$ keiyaku -C ${result.world} wait ${selector} --timeout 5m`);
+            lines.push(`$ keiyaku -C ${posixShellArgument(result.world)} wait ${selector} --timeout 5m`);
         }
         return lines.join("\n");
     }

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

@@ -113,11 +113,20 @@ function acceptedRecord(result, columns) {
     const record = [];
     for (const fact of result.facts) {
         const contract = fact.contract === result.contract ? [] : [{ text: fact.contract, opaque: true }];
-        receiptRow(record, " ", "journal", [
-            ...contract,
-            { text: fact.entry, opaque: true },
-            { text: `· ${fact.kind}` },
-        ], columns);
+        receiptRow(record, " ", "journal", fact.kind === "reintegrated"
+            ? [
+                ...contract,
+                { text: fact.entry, opaque: true },
+                { text: "· reintegrated" },
+                { text: fact.data.predecessor, opaque: true },
+                { text: "->" },
+                { text: fact.data.snapshot, opaque: true },
+            ]
+            : [
+                ...contract,
+                { text: fact.entry, opaque: true },
+                { text: `· ${fact.kind}` },
+            ], columns);
     }
     receiptRow(record, " ", "head", [{ text: result.head, opaque: true }], columns);
     if (result.verb === "deliver") {
@@ -176,11 +185,36 @@ function recordBlock(result, columns) {
     const rows = [...acceptedRecord(result, columns), ...acceptedLagRows(result, columns)];
     return ["  record", ...indentRecord(rows)];
 }
-function verificationVerdictLine(verdict, columns) {
+function completionLines(result, columns) {
     const lines = [];
-    receiptRow(lines, verdict === "satisfied" ? "✓" : "!", "verification", [
-        { text: verdict === "satisfied" ? "passed" : "failed" },
+    const completion = result.completion;
+    if (completion === undefined)
+        return lines;
+    const verification = completion.verification;
+    receiptRow(lines, " ", "target", [
+        { text: "->" },
+        { text: completion.integration, opaque: true },
+        ...(verification?.verdict === "satisfied"
+            ? [{ text: `· verified (${verification.mode})` }]
+            : []),
     ], columns);
+    if (verification?.verdict === "unsatisfied") {
+        receiptRow(lines, "!", "verification", [
+            { text: "unsatisfied" },
+            { text: `(${verification.mode})` },
+        ], columns);
+        if (result.verificationSummary !== undefined) {
+            receiptPayload(lines, "  summary", result.verificationSummary);
+        }
+    }
+    return lines;
+}
+function movementLines(result, columns) {
+    const count = result.facts.filter((fact) => fact.kind === "reintegrated").length;
+    if (count === 0)
+        return [];
+    const lines = [];
+    receiptRow(lines, "~", "target", [{ text: `moved · re-integrated x${count}` }], columns);
     return lines;
 }
 function renderAcceptedBind(result, columns) {
@@ -201,51 +235,19 @@ function renderAcceptedAmend(result, columns) {
     lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
     return lines.join("\n");
 }
-function reintegrationLines(result, complete, columns) {
-    const reintegrated = result.facts.filter((fact) => fact.kind === "reintegrated");
-    if (reintegrated.length === 0)
-        return [];
-    const lines = [];
-    for (const fact of reintegrated) {
-        receiptRow(lines, " ", "re-integrated", [
-            { text: fact.data.predecessor, opaque: true },
-            { text: "->" },
-            { text: fact.data.snapshot, opaque: true },
-        ], columns);
-    }
-    if (result.verificationVerdict !== undefined) {
-        receiptRow(lines, " ", "verification re-run", [
-            { text: "·" },
-            { text: result.verificationVerdict },
-        ], columns);
-    }
-    if (complete) {
-        receiptRow(lines, " ", "target", [
-            { text: "->" },
-            { text: reintegrated.at(-1).data.snapshot, opaque: true },
-        ], columns);
-    }
-    return lines;
-}
 function renderAcceptedDeliver(result, columns) {
-    const complete = result.facts.some((fact) => fact.kind === "claimed");
+    const complete = result.completion !== undefined;
     const title = complete ? "delivered" : "deliver — not complete";
     const lines = titleLines("✓", title, result.contract, columns);
-    lines.push(...reintegrationLines(result, complete, columns));
+    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
     if (!complete)
         receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
     if (result.verification !== undefined) {
         lines.push(...stopLines("verification", result.verification, columns, result.contract));
     }
-    else if (result.verificationVerdict !== undefined) {
-        lines.push(...verificationVerdictLine(result.verificationVerdict, columns));
-    }
     if (!complete && result.placement !== undefined) {
         lines.push(...stopLines("completion", result.placement, columns, result.contract));
     }
-    else if (!complete && (result.verification !== undefined || result.verificationVerdict === "unsatisfied")) {
-        receiptRow(lines, "·", "completion", [{ text: "not attempted" }], columns);
-    }
     if (result.cleanup !== undefined)
         pushBlock(lines, cleanupLines(result.cleanup, columns));
     if (result.leak !== undefined)
@@ -254,12 +256,11 @@ function renderAcceptedDeliver(result, columns) {
     return lines.join("\n");
 }
 function renderAcceptedReview(result, columns) {
-    const complete = result.facts.some((fact) => fact.kind === "claimed");
-    const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
-    lines.push(...reintegrationLines(result, complete, columns));
-    receiptRow(lines, complete ? "✓" : "!", "contract", [
-        { text: complete ? "complete" : "not complete" },
-    ], columns);
+    const complete = result.completion !== undefined;
+    const lines = titleLines("✓", `review ${result.verdict} — ${complete ? "complete" : "not complete"}`, result.contract, columns);
+    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
+    if (!complete)
+        receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
     if (result.placement !== undefined) {
         lines.push(...stopLines("completion", result.placement, columns, result.contract));
     }

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

@@ -85,8 +85,13 @@ function targetFacts(row) {
 }
 function workspaceState(row) {
     const observation = row.workspaceObservation;
+    if (row.workspace === "here" && observation.kind === "failed") {
+        return `workspace here · failed · ${observation.diagnostic}`;
+    }
     if (row.workspace === "here")
         return `workspace here · ${observation.kind}`;
+    if (observation.kind === "failed")
+        return `worktree unavailable · ${observation.diagnostic}`;
     if (observation.kind === "unappointed")
         return "worktree unappointed";
     if (observation.kind === "unavailable")
@@ -106,7 +111,7 @@ function showWorkspacePath(row, hot) {
         return false;
     if (row.workspaceObservation.kind === "unappointed")
         return false;
-    if (row.workspaceObservation.kind !== "clean")
+    if (row.workspaceObservation.kind !== "clean" && row.workspaceObservation.kind !== "failed")
         return true;
     return hot;
 }
@@ -219,13 +224,15 @@ function renderContractRow(row, report, context, selection) {
     const compact = !hot && selection !== "contract";
     const title = row.title ?? "title unavailable";
     const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
+    const journal = `journal ${formatAge(row.lastJournalAt, report.observedAt)}`;
     const lines = [identityLine(contractMark(row), row.id)];
-    lines.push(...plumbFacts(compact ? [title, phase, ...targetFacts(row)] : [title], context.columns));
+    lines.push(...plumbFacts(compact ? [title, phase, journal, ...targetFacts(row)] : [title], context.columns));
     if (!compact)
-        lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
+        lines.push(...plumbFacts([phase, journal, ...targetFacts(row)], context.columns));
     lines.push(...plumbFacts([workspaceState(row)], context.columns));
     if (showWorkspacePath(row, hot || selection === "contract")
         && row.workspaceObservation.kind !== "unappointed"
+        && row.workspaceObservation.kind !== "failed"
         && row.workspaceObservation.location.kind === "worktree") {
         lines.push(plumbPath(row.workspaceObservation.location.path));
     }
@@ -320,9 +327,12 @@ function renderAkuma(report, context) {
         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 activity = "lastActivityAt" in row && row.lastActivityAt !== null
+            ? [`activity ${formatAge(row.lastActivityAt, report.observedAt)}`]
+            : [];
         const key = row.life === "stranded" && "strandedReason" in row && row.strandedReason === "resume-unsupported"
-            ? [life, "resume unsupported"]
-            : [life];
+            ? [life, ...activity, "resume unsupported"]
+            : [life, ...activity];
         const relation = row.contract === undefined
             ? ["unbound"]
             : [endpointFact(row.contract.id, row.contract.observed)];

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

@@ -0,0 +1,3 @@
+import type { NukeResult } from "../../index.js";
+export declare function renderNukeText(result: NukeResult): string;
+export declare function nukeExitCode(result: NukeResult): number;

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

@@ -0,0 +1,8 @@
+export function renderNukeText(result) {
+    return result.kind === "success"
+        ? `nuke success ${result.world}`
+        : `nuke failed ${result.world}\n${result.diagnostic}`;
+}
+export function nukeExitCode(result) {
+    return result.kind === "failed" ? 2 : 0;
+}

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

@@ -1,5 +1,5 @@
 import type { BindDraftReceipt, RefusedResult } from "../result.js";
-import type { KeiyakuRefusal } from "../../index.js";
+import type { IntegrationConflictMaterialized, KeiyakuRefusal } from "../../index.js";
 import { type TextRenderContext } from "./terminal.js";
 type DirtyWithOption = Extract<KeiyakuRefusal, {
     kind: "dirty-workspace";
@@ -12,5 +12,6 @@ type DirtyWithOption = Extract<KeiyakuRefusal, {
 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 renderConflictMaterialized(result: IntegrationConflictMaterialized, context?: TextRenderContext): string;
 export declare function renderBindDraftReceipt(receipt: BindDraftReceipt): string;
 export {};

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

@@ -38,6 +38,18 @@ function renderDirtyRefusal(refusal, indent, columns, identity) {
 }
 export function renderRefusalFacts(refusal, indent, columns, addressed) {
     const identity = refusalIdentity(refusal, addressed);
+    if (refusal.kind === "nuke-confirmation-mismatch") {
+        return [
+            ...renderOpaqueBlock(`nuke confirmation mismatch world=${refusal.world} confirmation=${refusal.confirmation}`, indent, columns),
+            ...renderOpaqueBlock(`keiyaku nuke --confirm ${refusal.world}`, indent, columns),
+        ];
+    }
+    if (refusal.kind === "nuke-confirmation-required") {
+        return [
+            ...renderOpaqueBlock(`nuke confirmation required world=${refusal.world}`, indent, columns),
+            ...renderOpaqueBlock(`keiyaku nuke --confirm ${refusal.world}`, indent, columns),
+        ];
+    }
     if (refusal.kind === "dirty-workspace")
         return renderDirtyRefusal(refusal, indent, columns, identity);
     if (refusal.kind === "integration-failed") {
@@ -46,8 +58,18 @@ export function renderRefusalFacts(refusal, indent, columns, addressed) {
         ];
         if (refusal.conflictPaths !== undefined)
             lines.push(...collectionLines("conflictPaths", refusal.conflictPaths, indent, columns));
+        if ("recovery" in refusal && refusal.recovery !== undefined) {
+            wrap(lines, `recovery materialize conflicts · ${refusal.recovery.materialize}`, indent, columns);
+            wrap(lines, `recovery continue after resolve and commit · ${refusal.recovery.continue}`, indent, columns);
+        }
         return lines;
     }
+    if (refusal.kind === "merge-state-present") {
+        return renderOpaqueBlock(refusalHead(refusal.kind, identity, [
+            `workspace=${refusal.workspace.kind}`,
+            `path=${refusal.workspace.path}`,
+        ]), indent, columns);
+    }
     if (refusal.kind === "integration-unsupported") {
         return renderOpaqueBlock(refusalHead(refusal.kind, identity, [`requiredGit=${refusal.requiredGit}`]), indent, columns);
     }
@@ -81,6 +103,15 @@ export function renderRefusal(result, context) {
     const output = lines.join("\n");
     return result.draft === undefined ? output : `${output}\n${renderBindDraftReceipt(result.draft)}`;
 }
+export function renderConflictMaterialized(result, context) {
+    const columns = context?.columns ?? 80;
+    const indent = "   ";
+    return [
+        ...renderOpaqueBlock(`integration-conflict-materialized targetHead=${result.targetHead}`, "", columns),
+        ...collectionLines("conflictPaths", result.conflictPaths, indent, columns),
+        ...renderOpaqueBlock(`workspace ${result.workspace.kind} ${result.workspace.path}`, indent, columns),
+    ].join("\n");
+}
 export function renderBindDraftReceipt(receipt) {
     return [
         ...(receipt.path === undefined ? [] : [`draft preserved: ${receipt.path}`]),

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

@@ -1,8 +1,9 @@
 import { renderObservation } from "./board.js";
 import { renderAccepted, renderContractHistory, renderRetry } from "./contract.js";
 import { renderKanshiText } from "./kanshi.js";
-import { renderRefusal } from "./refusal.js";
+import { renderConflictMaterialized, renderRefusal } from "./refusal.js";
 import { renderCatalogText } from "./catalog.js";
+import { renderNukeText } from "./nuke.js";
 import { renderRegionText } from "./region.js";
 export function renderText(result, context) {
     if (result.kind === "guidance")
@@ -15,11 +16,15 @@ export function renderText(result, context) {
         return renderContractHistory(result.history);
     if (result.kind === "region")
         return renderRegionText(result.region);
+    if (result.kind === "nuke")
+        return renderNukeText(result.result);
     if (result.kind === "accepted")
         return renderAccepted(result, context);
     if (result.kind === "refused")
         return renderRefusal(result, context);
     if (result.kind === "retry")
         return renderRetry(result, context);
+    if (result.kind === "integration-conflict-materialized")
+        return renderConflictMaterialized(result, context);
     return renderObservation(result);
 }