@astrosheep/keiyaku 4.0.4 → 4.0.6

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/receipt.js

@@ -59,6 +59,32 @@ export function reuseLines(reuse, columns) {
         return [];
     return renderOpaqueBlock(`reuse verification ${reuse.entry} ${reuse.verdict}`, "   ", columns);
 }
+function prerequisiteRows(stop, columns) {
+    if (!("refusal" in stop) || stop.refusal?.kind !== "prerequisites-unsatisfied")
+        return [];
+    const lines = [];
+    for (const prerequisite of stop.refusal.unmet) {
+        receiptRow(lines, " ", "prerequisite", [
+            { text: prerequisite.contractId, opaque: true },
+            { text: "·" },
+            { text: prerequisite.state },
+        ], columns);
+    }
+    return lines;
+}
+function targetMovedDetail(stop) {
+    if ("integratedAt" in stop) {
+        return [
+            { text: stop.target, opaque: true },
+            { text: `${stop.integratedAt} -> ${stop.observed}`, opaque: true },
+            { text: `attempts=${stop.attempts}` },
+        ];
+    }
+    return [
+        { text: stop.target, opaque: true },
+        { text: `${stop.expected} -> ${stop.observed}`, opaque: true },
+    ];
+}
 export function stopLines(label, stop, columns, addressed) {
     const detail = [];
     if ("refusal" in stop && stop.refusal !== undefined) {
@@ -76,12 +102,13 @@ export function stopLines(label, stop, columns, addressed) {
             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 });
+            detail.push(...targetMovedDetail(stop));
         }
     }
     const lines = [];
     const state = label === "verification" ? "failed" : "blocked";
     receiptRow(lines, "!", label, [{ text: state }, { text: "·" }, ...detail], columns);
+    lines.push(...prerequisiteRows(stop, columns));
     if ("failure" in stop && stop.failure === "environment-failure" && "command" in stop) {
         appendHookPayload(lines, stop.detail);
     }

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/terminal.d.ts

@@ -23,8 +23,6 @@ export declare function renderBoundedTextBlock(value: string, input: Readonly<{
     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

@@ -110,28 +110,6 @@ export function renderBoundedTextBlock(value, input) {
 export function safeText(value) {
     return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => /\s/u.test(character) ? " " : "�");
 }
-export function renderFacts(primary, facts, columns) {
-    const head = safeText(primary);
-    const clean = facts.map(safeText);
-    if (clean.length === 0)
-        return [head];
-    const inline = `${head}  ${clean.join(" · ")}`;
-    if (displayColumns(inline) <= columns)
-        return [inline];
-    const lines = [head];
-    let current = "  ";
-    for (const fact of clean) {
-        const candidate = current === "  " ? `${current}${fact}` : `${current} · ${fact}`;
-        if (current !== "  " && displayColumns(candidate) > columns) {
-            lines.push(current);
-            current = `  ${fact}`;
-        }
-        else
-            current = candidate;
-    }
-    lines.push(current);
-    return lines;
-}
 export function renderTextBlock(value, indent, columns) {
     const words = safeText(value).trim().split(/\s+/u).filter((word) => word.length > 0);
     if (words.length === 0)
@@ -183,13 +161,6 @@ export function renderOpaqueBlock(value, indent, columns) {
     }
     return lines;
 }
-export function renderVoiceRuler(left, right, columns) {
-    const width = Math.max(20, Math.min(80, columns));
-    const occupied = displayColumns(left) + displayColumns(right) + 2;
-    if (occupied >= width)
-        return `${left}\n${"─".repeat(Math.max(1, width - displayColumns(right) - 1))} ${right}`;
-    return `${left} ${"─".repeat(width - occupied)} ${right}`;
-}
 export function tone(value, kind, color) {
     if (!color)
         return value;

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);
 }

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

@@ -1,8 +1,9 @@
-import type { AuditReport, ContractHistory, ContractId, Fact, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
+import type { AuditReport, ContractHistory, ContractId, Delivery, Fact, IntegrationConflictMaterialized, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
 import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
 import type { RegionObservation } from "../library/region.js";
+import type { NukeResult } from "../index.js";
 export type BindDraftReceipt = Readonly<{
     path: string;
     warning?: string;
@@ -11,11 +12,19 @@ export type BindDraftReceipt = Readonly<{
     warning: string;
 }>;
 export type Effect = ReconcileReport["effects"][number];
-export type AcceptedFact = Readonly<{
+type AcceptedFactEnvelope = Readonly<{
     contract: ContractId;
     entry: string;
-    kind: Fact["kind"];
 }>;
+export type AcceptedFact = (AcceptedFactEnvelope & Readonly<{
+    kind: Exclude<Fact["kind"], "reintegrated">;
+    data?: never;
+}>) | (AcceptedFactEnvelope & Readonly<{
+    kind: "reintegrated";
+    data: Extract<Fact, {
+        kind: "reintegrated";
+    }>["data"];
+}>);
 export type Lag = ReconcileReport["lag"][number];
 type MutationEnvelope = Pick<MutationResult<unknown>, "head" | "effects" | "settlement">;
 export type AcceptedEnvelope = Readonly<{
@@ -31,8 +40,10 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     verb: "bind";
     workspace: "worktree" | "here";
     target: string | null;
+    completion?: never;
     verification?: never;
     verificationReuse?: never;
+    verificationSummary?: never;
     placement?: never;
     cleanup?: never;
     leak?: never;
@@ -47,8 +58,10 @@ export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     verb: "amend";
     diff: string;
     target?: never;
+    completion?: never;
     verification?: never;
     verificationReuse?: never;
+    verificationSummary?: never;
     placement?: never;
     cleanup?: never;
     leak?: never;
@@ -61,9 +74,11 @@ export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
 }> & RegionObservation;
 export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     verb: "deliver";
+    completion?: Delivery["completion"];
     verificationVerdict?: "satisfied" | "unsatisfied";
     verification?: VerificationStop;
     verificationReuse?: VerificationReuse;
+    verificationSummary?: string;
     placement?: PlacementStop;
     cleanup?: MutationResult<unknown>["cleanup"];
     leak?: MutationResult<unknown>["leak"];
@@ -80,18 +95,20 @@ export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
 export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
     verb: "review";
     verdict: "satisfied" | "unsatisfied";
+    completion?: Delivery["completion"];
+    verificationVerdict?: "satisfied" | "unsatisfied";
+    verification?: VerificationStop;
+    verificationReuse?: VerificationReuse;
+    verificationSummary?: string;
     placement?: PlacementStop;
     workspace?: Review["workspace"];
+    cleanup?: MutationResult<unknown>["cleanup"];
+    leak?: MutationResult<unknown>["leak"];
     target?: never;
-    verification?: never;
-    verificationReuse?: never;
-    cleanup?: never;
-    leak?: never;
     overlaps?: never;
     overlapFailure?: never;
     report?: never;
     diff?: never;
-    verificationVerdict?: never;
     chapter?: never;
     note?: never;
 }>;
@@ -102,8 +119,10 @@ export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
         title: string;
     }>;
     target?: never;
+    completion?: never;
     verification?: never;
     verificationReuse?: never;
+    verificationSummary?: never;
     placement?: never;
     cleanup?: never;
     leak?: never;
@@ -120,8 +139,10 @@ export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     verb: "abandon";
     note?: string;
     target?: never;
+    completion?: never;
     verification?: never;
     verificationReuse?: never;
+    verificationSummary?: never;
     placement?: never;
     cleanup?: never;
     leak?: never;
@@ -140,8 +161,10 @@ export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     cleanup?: MutationResult<unknown>["cleanup"];
     leak?: MutationResult<unknown>["leak"];
     target?: never;
+    completion?: never;
     verification?: never;
     verificationReuse?: never;
+    verificationSummary?: never;
     placement?: never;
     overlaps?: never;
     overlapFailure?: never;
@@ -193,5 +216,9 @@ export type ContractHistoryResult = Readonly<{
     kind: "contract-history";
     history: ContractHistory;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult;
+export type NukeInvocationResult = Readonly<{
+    kind: "nuke";
+    result: NukeResult;
+}>;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult | NukeInvocationResult | IntegrationConflictMaterialized;
 export {};

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

@@ -0,0 +1,2 @@
+import type { ParsedExecution } from "./parse.js";
+export declare function runCliCommand(invocation: ParsedExecution): Promise<number>;

package/build/src/cli/runtime.js

@@ -0,0 +1,140 @@
+import { isParsedAkumaCommand } from "./commands/akuma.js";
+import { CliUsageError } from "./parse.js";
+function invocationStart(command) {
+    if (command.output === "json")
+        return undefined;
+    if (command.command === "bind")
+        return "⧖ preparing keiyaku";
+    if (command.command === "deliver")
+        return "⧖ delivering";
+    if (command.command === "audit")
+        return "⧖ auditing";
+    if (command.command === "reconcile")
+        return "⧖ reconciling";
+    return command.command === "install" ? "⧖ installing skills" : undefined;
+}
+async function writeTask(command, result) {
+    const { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } = await import("./render/task.js");
+    const context = {
+        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+        color: false,
+    };
+    if (command.output === "json")
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    else if (command.action === "compose" && typeof result === "object" && result !== null && "kind" in result && result.kind === "incomplete") {
+        const diagnostic = renderTaskIncompleteDiagnostic(result);
+        if (diagnostic.length > 0)
+            process.stderr.write(`${diagnostic}\n`);
+        process.stdout.write(result.draft);
+    }
+    else
+        process.stdout.write(`${renderTaskText(command, result, context)}\n`);
+    return taskExitCode(result);
+}
+async function writeAkuma(command, result) {
+    const { renderAkumaJson, akumaExitCode, akumaRawAnswer, renderAkumaText } = await import("./render/akuma.js");
+    const output = command.output === "json" ? renderAkumaJson(result) : renderAkumaText(command, result, {
+        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+        color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+    });
+    const raw = command.output === "text" && ((command.command === "history" && command.last) || akumaRawAnswer(result) !== undefined);
+    process.stdout.write(raw ? output : `${output}\n`);
+    return akumaExitCode(result);
+}
+async function writeResult(command, result) {
+    if (command.command === "install") {
+        const { installExitCode, renderInstallText } = await import("./commands/install.js");
+        const value = result;
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(value) : renderInstallText(value)}\n`);
+        return installExitCode(value);
+    }
+    if (command.command === "task")
+        return await writeTask(command, result);
+    if (command.command === "settings") {
+        const { renderSettingsText, settingsJsonValue } = await import("./render/settings.js");
+        const value = result.value;
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(settingsJsonValue(value)) : renderSettingsText(value)}\n`);
+        return 0;
+    }
+    if (typeof result === "object" && result !== null && "kind" in result && result.kind === "contract-history") {
+        const { renderText } = await import("./render/text.js");
+        const history = result.history;
+        const output = command.output === "json" ? JSON.stringify(history) : renderText(result);
+        process.stdout.write(`${output}\n`);
+        return 0;
+    }
+    const akumaResult = typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma";
+    if (isParsedAkumaCommand(command))
+        return await writeAkuma(command, result);
+    if (akumaResult && command.command === "status")
+        return await writeAkuma(command, result);
+    const contractResult = result;
+    if (contractResult.kind === "guidance") {
+        if (command.output === "json")
+            process.stdout.write(`${JSON.stringify({ contract: contractResult.contract, guidance: contractResult.guidance })}\n`);
+        else
+            process.stdout.write(contractResult.guidance.endsWith("\n") ? contractResult.guidance : `${contractResult.guidance}\n`);
+        return 0;
+    }
+    if (contractResult.kind === "catalog") {
+        const { renderCatalogText } = await import("./render/catalog.js");
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(contractResult.catalog) : renderCatalogText(contractResult.catalog)}\n`);
+        return 0;
+    }
+    if (contractResult.kind === "nuke") {
+        const { nukeExitCode } = await import("./render/nuke.js");
+        const { renderText } = await import("./render/text.js");
+        const output = command.output === "json" ? JSON.stringify(contractResult.result) : renderText(contractResult);
+        process.stdout.write(`${output}\n`);
+        return nukeExitCode(contractResult.result);
+    }
+    if (contractResult.kind === "region") {
+        const { renderText } = await import("./render/text.js");
+        process.stdout.write(`${command.output === "json" ? JSON.stringify(contractResult.region) : renderText(contractResult)}\n`);
+        return 0;
+    }
+    const { renderText } = await import("./render/text.js");
+    const output = command.output === "json"
+        ? JSON.stringify(contractResult.kind === "status" ? contractResult.report : contractResult)
+        : renderText(contractResult, {
+            columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
+            color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+        });
+    process.stdout.write(`${output}\n`);
+    return contractResult.kind === "refused" ? 1 : contractResult.kind === "retry" ? 2 : 0;
+}
+function writeWorldScopeRefusal(error, output) {
+    const body = output === "json" ? JSON.stringify(error.refusal) : `${error.refusal.kind} ${error.refusal.world} ${error.refusal.ids.join(" ")}`;
+    process.stderr.write(`${body}\n`);
+    return 1;
+}
+export async function runCliCommand(invocation) {
+    const command = invocation.command;
+    try {
+        const start = invocationStart(command);
+        const { invoke } = await import("./invoke.js");
+        const result = await invoke(invocation, {
+            cwd: process.cwd(),
+            ...(start === undefined ? {} : { onOperationStart: () => { process.stderr.write(`${start}\n`); } }),
+        });
+        return await writeResult(command, result);
+    }
+    catch (error) {
+        if (command.command !== "install") {
+            const { AkumaWorldScopeError } = await import("../library/address.js");
+            if (error instanceof AkumaWorldScopeError)
+                return writeWorldScopeRefusal(error, command.output);
+        }
+        if (command.command === "bind") {
+            const { BindDraftError } = await import("./draft.js");
+            if (error instanceof BindDraftError) {
+                process.stderr.write(`${error.original instanceof Error ? error.original.message : String(error.original)}\n`);
+                const { renderBindDraftReceipt } = await import("./render/refusal.js");
+                process.stderr.write(`${renderBindDraftReceipt(error.draft)}\n`);
+                return error.original instanceof CliUsageError ? 1 : 3;
+            }
+        }
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return error instanceof CliUsageError ? 1 : 3;
+    }
+}

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

@@ -3,7 +3,5 @@ export declare class CliUsageError extends Error {
     readonly projection?: string | undefined;
     constructor(diagnostic: string, projection?: string | undefined);
 }
-export declare const JSON_AUTOMATION_HELP = "--json is only for automation script input/output and should not be used for daily interactive use.";
-export declare function withJsonAutomationHelp(help: string): string;
 export declare function isBlankInput(value: string): boolean;
 export declare function usageLine(usage: string): string;

package/build/src/cli/usage.js

@@ -8,10 +8,6 @@ export class CliUsageError extends Error {
         this.name = "CliUsageError";
     }
 }
-export const JSON_AUTOMATION_HELP = "--json is only for automation script input/output and should not be used for daily interactive use.";
-export function withJsonAutomationHelp(help) {
-    return help.includes("--json") ? `${help}\n\n${JSON_AUTOMATION_HELP}` : help;
-}
 export function isBlankInput(value) {
     return value.trim().length === 0;
 }

package/build/src/contract-worktree.d.ts

@@ -1,7 +1,28 @@
 import { type DerivedFileAction } from "./coordination/durable-file.js";
 import { type ContractId, type ContractState } from "./core/facts/types.js";
-import { type GitRepository } from "./git/repository.js";
+import { type GitRepository } from "./git/process.js";
 import { type PlaceRegister } from "./workspace-place.js";
+export type ContractAppointment = Readonly<{
+    kind: "absent";
+    path: string;
+}> | Readonly<{
+    kind: "appointed";
+    path: string;
+    contract: ContractId;
+}> | Readonly<{
+    kind: "invalid";
+    path: string;
+}>;
+export type HereContractWorkspaceObservation = Readonly<{
+    kind: "appointed";
+    path: string;
+}> | Readonly<{
+    kind: "unappointed";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+    cause?: "duplicate" | "observation";
+}>;
 export declare function renderContractGuidance(state: ContractState): string;
 export type ContractFileEffect = Readonly<{
     kind: "contract-file";
@@ -18,18 +39,9 @@ export type ContractWorktreeResult = Readonly<{
     effects: readonly ContractFileEffect[];
     lag: readonly ContractFileLag[];
 }>;
-export type ContractAppointment = Readonly<{
-    kind: "absent";
-    path: string;
-}> | Readonly<{
-    kind: "appointed";
-    path: string;
-    contract: ContractId;
-}> | Readonly<{
-    kind: "invalid";
-    path: string;
-}>;
 export declare function readContractAppointment(repository: GitRepository): Promise<ContractAppointment>;
+/** Fold existing here appointments over all registered worktrees for one Contract. */
+export declare function resolveHereContractWorkspace(repository: GitRepository, contract: ContractId): Promise<HereContractWorkspaceObservation>;
 export type ContractReservation = Readonly<{
     kind: "reserved";
     path: string;
@@ -40,5 +52,8 @@ export type ContractReservation = Readonly<{
 export declare function reserveContractWorktree(repository: GitRepository, contract: ContractId): Promise<ContractReservation>;
 export declare function withContractWorktreeAppointment<T>(repository: GitRepository, action: () => T | Promise<T>): Promise<T>;
 export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
-export declare function removeContractWorktreeAppointment(repository: GitRepository, contract: ContractId): Promise<void>;
-export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister): Promise<ContractWorktreeResult>;
+/** Remove matching here appointments and their exact generated support from registered worktrees. */
+export declare function nukeHereAppointments(repository: GitRepository): Promise<void>;
+/** Validate the existing Contract-worktree coordination lock before releasing it. */
+export declare function nukeContractWorktreeLock(repository: GitRepository): Promise<void>;
+export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister, onConflict?: (diagnostic: string) => never): Promise<ContractWorktreeResult>;