@astrosheep/keiyaku 4.0.4 → 4.0.6

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

@@ -1,9 +1,10 @@
-import { type ActorId, type ContractId, type Settings } from "../index.js";
-import { type AkumaInvocationResult } from "./commands/akuma-invoke.js";
-import { type InstallInvocationResult } from "./commands/install.js";
-import { type TaskInvocationResult } from "./commands/task-invoke.js";
+import type { AkumaInvocationResult } from "./commands/akuma-invoke.js";
+import type { InstallInvocationResult } from "./commands/install.js";
+import type { TaskInvocationResult } from "./commands/task-invoke.js";
 import { type ParsedExecution } from "./parse.js";
 import type { InvocationResult } from "./result.js";
+import type { ActorId, ContractId } from "../index.js";
+import type { Settings } from "../settings.js";
 export type { AcceptedFact, InvocationResult, Lag } from "./result.js";
 type InvokeRuntime = Readonly<{
     cwd?: string;

package/build/src/cli/invoke.js

@@ -1,19 +1,7 @@
-import { AkumaWorldScopeError, gatesFrom, Keiyaku, KeiyakuRefused, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom, } from "../index.js";
-import { kanshi, observeKanshi, selectKanshi, selectRegion, } from "../kanshi/index.js";
 import { resolveActor } from "./actor.js";
-import { acceptedAbandon, acceptedAmend, acceptedArc, acceptedAudit, acceptedBind, acceptedDeliver, acceptedReview, resultFromMutationCall, } from "./accepted.js";
-import { amendFromCommand } from "./commands/amend.js";
-import { invokeAkuma, invokeAkumaStatus } from "./commands/akuma-invoke.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
-import { bindFromCommand } from "./commands/bind.js";
-import { installHarnesses } from "./commands/install.js";
-import { invokeTask } from "./commands/task-invoke.js";
-import { CliUsageError, renderCommandUsage } from "./parse.js";
+import { assertExplicitRepoUse, CliUsageError, renderCommandUsage, } from "./parse.js";
 import { isBlankInput } from "./usage.js";
-import { canonicalContractSelector, contractFromInput, resolveContextualContract, resolveKanshiContract, } from "./selectors.js";
-import { resolveNamedAddress } from "../library/address.js";
-import { assertExplicitRepoUse, resolveCliCoordinates } from "./coordinates.js";
-import { BindDraftError, preserveBindDraft } from "./draft.js";
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -54,24 +42,27 @@ async function withAcquiredStdin(command, runtime) {
         throw new CliUsageError(diagnostic);
     return { ...runtime, readStdin: async () => bytes };
 }
-function settingsAt(root, home) {
+async function settingsAt(root, home) {
+    const { settings } = await import("../settings.js");
     return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined ? {} : { home }) });
 }
-function consumeSettings(run) {
+function consumeSettings(run, ErrorType) {
     try {
         return run();
     }
     catch (error) {
-        if (error instanceof SettingsError)
+        if (error instanceof ErrorType)
             throw new CliUsageError(error.message);
         throw error;
     }
 }
-function selectedGates(value, name) {
-    return consumeSettings(() => gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) }));
+async function selectedGates(value, names) {
+    const { gatesFrom, SettingsError } = await import("../library/configuration.js");
+    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }), SettingsError);
 }
-function selectedGitPolicy(value) {
-    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }));
+async function selectedGitPolicy(value) {
+    const { requireBranchesToBeUpToDateFrom, SettingsError } = await import("../library/configuration.js");
+    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }), SettingsError);
 }
 function actorFromEdge(actor, environment) {
     let resolved;
@@ -83,13 +74,24 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
+function gitPathFromEdge(environment) {
+    const value = environment.KEIYAKU_GIT_PATH;
+    if (value === undefined)
+        return undefined;
+    if (value.trim().length === 0)
+        throw new CliUsageError("KEIYAKU_GIT_PATH requires a nonblank value");
+    return value;
+}
 async function selectContract(repo, selector, scope) {
+    const { contractFromInput, resolveContextualContract } = await import("./selectors.js");
     if (selector !== undefined && !selector.startsWith("@"))
         return contractFromInput(repo, selector);
+    const { Keiyaku } = await import("../library/keiyaku.js");
     const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
     return contractFromInput(repo, id);
 }
 async function bindDraftReceipt(establishWorld, markdown) {
+    const { preserveBindDraft } = await import("./draft.js");
     try {
         return preserveBindDraft(await establishWorld(), markdown);
     }
@@ -99,8 +101,10 @@ async function bindDraftReceipt(establishWorld, markdown) {
 }
 async function invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld }) {
     const markdown = await edge.readStdin();
-    const gates = selectedGates(configuration, parsed.gates);
+    const gates = await selectedGates(configuration, parsed.gates);
     const actor = actorFromEdge(parsed.actor, edge.environment);
+    const { bindFromCommand } = await import("./commands/bind.js");
+    const { acceptedBind, resultFromMutationCall } = await import("./accepted.js");
     try {
         const result = await resultFromMutationCall("bind", () => bindFromCommand({
             command: parsed,
@@ -122,6 +126,7 @@ async function invokeBind({ parsed, repo, edge, configuration, hooks, establishW
     catch (error) {
         if (!(error instanceof TypeError))
             throw error;
+        const { BindDraftError } = await import("./draft.js");
         throw new BindDraftError(error, await bindDraftReceipt(establishWorld, markdown));
     }
 }
@@ -133,19 +138,34 @@ function deliverRefusal(refusal) {
     return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
 }
 async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
-    return resultFromMutationCall("deliver", () => seat.contract.deliver({
-        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
-        ...(parsed.message === undefined ? {} : { message: parsed.message }),
-        requireBranchesToBeUpToDate,
-        includeDirty: parsed.includeDirty,
-        hooks: seat.hooks,
-    }), (result) => acceptedDeliver(result, seat.id), {
-        coordinate: seat.id,
-        projectRefusal: deliverRefusal,
-    });
+    const { acceptedDeliver } = await import("./accepted.js");
+    try {
+        const delivered = await seat.contract.deliver({
+            ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+            ...(parsed.message === undefined ? {} : { message: parsed.message }),
+            requireBranchesToBeUpToDate,
+            includeDirty: parsed.includeDirty,
+            materializeConflict: parsed.materializeConflict,
+            hooks: seat.hooks,
+        });
+        if (!("facts" in delivered))
+            return delivered;
+        return acceptedDeliver(delivered, seat.id);
+    }
+    catch (error) {
+        const { KeiyakuRefused, KeiyakuRetry } = await import("../library/keiyaku.js");
+        if (error instanceof KeiyakuRefused) {
+            return { kind: "refused", verb: "deliver", contract: seat.id, refusal: deliverRefusal(error.refusal) };
+        }
+        if (error instanceof KeiyakuRetry) {
+            return { kind: "retry", verb: "deliver", contract: seat.id, detail: error.reason };
+        }
+        throw error;
+    }
 }
 async function invokeReview(parsed, seat, readStdin) {
     const summary = parsed.summaryFromStdin === true ? await readStdin() : parsed.summary;
+    const { acceptedReview, resultFromMutationCall } = await import("./accepted.js");
     return resultFromMutationCall("review", () => seat.contract.review({
         verdict: parsed.verdict,
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
@@ -154,6 +174,7 @@ async function invokeReview(parsed, seat, readStdin) {
     }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
 }
 async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
+    const { acceptedAudit, resultFromMutationCall } = await import("./accepted.js");
     return resultFromMutationCall("audit", () => seat.contract.audit({
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
         includeDirty: parsed.includeDirty,
@@ -162,16 +183,23 @@ async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
         hooks: seat.hooks,
     }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
 }
-async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
+async function existingSeat({ parsed, repo, edge, scope, hooks }) {
     const { id, contract } = await selectContract(repo, parsed.contract, scope);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+    return { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+}
+async function invokeExisting(input) {
+    const { parsed, repo, edge, configuration, hooks } = input;
+    const seat = await existingSeat(input);
+    const { id, contract, actor } = seat;
     switch (parsed.command) {
         case "amend": {
             const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
             const gates = parsed.gates === undefined
                 ? undefined
-                : selectedGates(configuration, parsed.gates);
+                : await selectedGates(configuration, parsed.gates);
+            const { amendFromCommand } = await import("./commands/amend.js");
+            const { acceptedAmend, resultFromMutationCall } = await import("./accepted.js");
             return resultFromMutationCall("amend", () => amendFromCommand({
                 command: parsed,
                 repo,
@@ -183,25 +211,28 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
             }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
-            return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
+            return invokeDeliver(parsed, seat, await selectedGitPolicy(configuration));
         case "review":
             return invokeReview(parsed, seat, edge.readStdin);
         case "arc": {
             const markdown = await edge.readStdin();
+            const { acceptedArc, resultFromMutationCall } = await import("./accepted.js");
             return resultFromMutationCall("arc", () => contract.arc({
                 markdown,
                 ...(actor === undefined ? {} : { actor }),
                 hooks,
             }), (result) => acceptedArc(result, id), { coordinate: id });
         }
-        case "abandon":
+        case "abandon": {
+            const { acceptedAbandon, resultFromMutationCall } = await import("./accepted.js");
             return resultFromMutationCall("abandon", () => contract.abandon({
                 ...(actor === undefined ? {} : { actor }),
                 ...(parsed.note === undefined ? {} : { note: parsed.note }),
                 hooks,
             }), (result) => acceptedAbandon(result, id), { coordinate: id });
+        }
         case "audit":
-            return invokeAudit(parsed, seat, selectedGitPolicy(configuration));
+            return invokeAudit(parsed, seat, await selectedGitPolicy(configuration));
         default:
             return parsed;
     }
@@ -212,18 +243,21 @@ async function invokeAkumaFromEdge(parsed, input) {
         if (parsed.command === "call" && parsed.contract !== undefined && repo === undefined) {
             throw new Error("call with Contract requires a resolved Repo");
         }
+        const { invokeAkuma } = await import("./commands/akuma-invoke.js");
+        const contract = parsed.command === "call" && parsed.contract !== undefined
+            ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract).contract
+            : undefined;
         return await invokeAkuma(parsed, {
             path,
             ...(statedCwd === undefined ? {} : { statedCwd }),
             ...(home === undefined ? {} : { home }),
             ...(configuration === undefined ? {} : { settings: configuration }),
-            ...(parsed.command === "call" && parsed.contract !== undefined
-                ? { contract: contractFromInput(repo, parsed.contract).contract }
-                : repo === undefined ? {} : { repo }),
+            ...(contract === undefined ? repo === undefined ? {} : { repo } : { contract }),
             readStdin: edge.readStdin,
         });
     }
     catch (error) {
+        const { AkumaWorldScopeError } = await import("../library/address.js");
         if (error instanceof AkumaWorldScopeError)
             throw error;
         if (error instanceof TypeError)
@@ -239,6 +273,7 @@ async function akumaWorldFor(parsed, located, candidate, establish) {
 }
 async function invokeCatalog(parsed, world, repo, home) {
     try {
+        const { Keiyaku } = await import("../library/keiyaku.js");
         if (parsed.query.kind === "contracts") {
             if (repo === undefined)
                 throw new Error("Contract catalog requires a resolved Repo");
@@ -267,8 +302,9 @@ async function invokeStatus(parsed, world, repo) {
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-        return invokeAkumaStatus(world, parsed.contract, undefined, repo);
+        return (await import("./commands/akuma-invoke.js")).invokeAkumaStatus(world, parsed.contract, undefined, repo);
     }
+    const { kanshi, observeKanshi, selectKanshi } = await import("../kanshi/index.js");
     if (parsed.contract === undefined) {
         const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
         return { kind: "status", report, selection: "world" };
@@ -276,6 +312,7 @@ async function invokeStatus(parsed, world, repo) {
     if (parsed.contract.startsWith("@")) {
         try {
             const observation = await observeKanshi({ world, ...(repo === undefined ? {} : { repo }) });
+            const { resolveNamedAddress } = await import("../library/address.js");
             const address = resolveNamedAddress({
                 selector: parsed.contract,
                 report: observation.report,
@@ -284,7 +321,7 @@ async function invokeStatus(parsed, world, repo) {
             if (address.kind === "akuma") {
                 if (world === null)
                     throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-                return invokeAkumaStatus(world, address.id, parsed.contract, repo);
+                return (await import("./commands/akuma-invoke.js")).invokeAkumaStatus(world, address.id, parsed.contract, repo);
             }
             return { kind: "status", report: selectKanshi({ report: observation.report, contract: address.id }), selection: "contract" };
         }
@@ -297,6 +334,7 @@ async function invokeStatus(parsed, world, repo) {
     if (parsed.contract.startsWith("kei/")) {
         if (repo === undefined)
             throw new CliUsageError("cannot select a contract while the Contract world is absent");
+        const { canonicalContractSelector } = await import("./selectors.js");
         const contract = canonicalContractSelector(parsed.contract);
         return {
             kind: "status",
@@ -305,10 +343,12 @@ async function invokeStatus(parsed, world, repo) {
         };
     }
     const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+    const { resolveKanshiContract } = await import("./selectors.js");
     const contract = resolveKanshiContract(report, parsed.contract);
     return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
 }
 async function invokeRegion(parsed, world, repo) {
+    const { kanshi, selectRegion } = await import("../kanshi/index.js");
     const read = async (region) => {
         try {
             return await kanshi({ world, repo, region });
@@ -327,6 +367,7 @@ async function invokeRegion(parsed, world, repo) {
         return { kind: "region", region: report.region ?? { kind: "absent" } };
     }
     const report = await read({ kind: "declarations" });
+    const { resolveKanshiContract } = await import("./selectors.js");
     const contract = resolveKanshiContract(report, parsed.contract);
     if (report.contracts.kind !== "present" || report.contracts.value.rows.every((row) => row.id !== contract || row.disposition !== "active")) {
         throw new CliUsageError(`unknown contract selector: ${parsed.contract}`);
@@ -340,6 +381,7 @@ async function invokeRegion(parsed, world, repo) {
 async function invokeContractHistory(repo, contract) {
     if (repo === undefined)
         throw new Error("history kei/... requires a resolved Repo");
+    const { contractFromInput } = await import("./selectors.js");
     const selected = contractFromInput(repo, contract);
     try {
         return { kind: "contract-history", history: await selected.contract.history() };
@@ -347,6 +389,7 @@ async function invokeContractHistory(repo, contract) {
     catch (error) {
         if (error instanceof TypeError)
             throw new CliUsageError(error.message);
+        const { KeiyakuRefused } = await import("../library/keiyaku.js");
         if (error instanceof KeiyakuRefused) {
             return { kind: "refused", verb: "history", contract: selected.id, refusal: error.refusal };
         }
@@ -355,13 +398,17 @@ async function invokeContractHistory(repo, contract) {
 }
 // eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
+    const environment = runtime.environment ?? process.env;
+    const gitPath = gitPathFromEdge(environment);
+    const { resolveCliCoordinates } = await import("./coordinates.js");
     const coordinates = await resolveCliCoordinates({
         ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        ...(gitPath === undefined ? {} : { gitPath }),
         command: invocation.command,
     });
-    const { cwd, cwdSource, repo, world, candidateWorld, establishWorld } = coordinates;
+    const { cwd, cwdSource, repo, world, candidateWorld, establishWorld, taskContext } = coordinates;
     const edge = {
         environment: runtime.environment ?? process.env,
         readStdin: runtime.readStdin ?? readStdin,
@@ -372,20 +419,19 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "settings") {
         return { kind: "settings", value: await settingsAt(world ?? undefined, home) };
     }
+    if (parsed.command === "nuke") {
+        return await (await import("./commands/nuke.js")).invokeNuke(parsed, world);
+    }
     if (parsed.command === "task") {
-        try {
-            return await invokeTask(parsed, {
-                world,
-                establish: coordinates.establishWorld,
-                readStdin: edge.readStdin,
-                ...(runtime.actor === undefined ? {} : { actor: runtime.actor }),
-            });
-        }
-        catch (error) {
-            if (error instanceof TypeError)
-                throw new CliUsageError(error.message);
-            throw error;
-        }
+        const actor = runtime.actor ?? actorFromEdge(typeof parsed.flags.actor === "string" ? parsed.flags.actor : undefined, edge.environment);
+        return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
+            parsed,
+            world,
+            context: taskContext,
+            establish: coordinates.establishWorld,
+            readStdin: edge.readStdin,
+            actor,
+        });
     }
     if (parsed.command === "history" && "contract" in parsed)
         return await invokeContractHistory(repo, parsed.contract);
@@ -410,8 +456,16 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     const scope = cwd;
+    if ((parsed.command === "deliver" || parsed.command === "review") && (await import("../akuma/requests.js")).injectedBodyRequests() !== null) {
+        const { EMPTY_WORKTREE_HOOKS } = await import("../library/configuration.js");
+        const seat = await existingSeat({ parsed, repo, edge, scope, hooks: EMPTY_WORKTREE_HOOKS });
+        return parsed.command === "deliver"
+            ? await invokeDeliver(parsed, seat, false)
+            : await invokeReview(parsed, seat, edge.readStdin);
+    }
     const configuration = await settingsAt(world ?? undefined, home);
-    const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }));
+    const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
+    const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }), SettingsError);
     if (parsed.command === "show") {
         const selected = await selectContract(repo, parsed.contract, scope);
         return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
@@ -442,7 +496,7 @@ export async function invoke(invocation, runtime = {}) {
         assertExplicitRepoUse(command, invocation.repo);
         if (command.command === "install") {
             runtime.onOperationStart?.();
-            return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+            return (await import("./commands/install.js")).installHarnesses(command.harnesses, runtime.environment ?? process.env);
         }
         const acquiredRuntime = await withAcquiredStdin(command, withResolvedTaskActor(command, runtime));
         runtime.onOperationStart?.();

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

@@ -1,3 +1 @@
-import { type ParsedCommand } from "./parse.js";
-export declare function invocationStart(command: ParsedCommand): string | undefined;
 export declare function main(argv?: readonly string[]): Promise<number>;

package/build/src/cli/main.js

@@ -1,151 +1,15 @@
-import { AkumaWorldScopeError } from "../index.js";
-import { CliUsageError, parseArgv, renderContractHelp, renderRootHelp, } from "./parse.js";
-import { renderText } from "./render/text.js";
-import { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } from "./render/task.js";
-import { akumaExitCode, akumaRawAnswer, renderAkumaJson, renderAkumaText } from "./render/akuma.js";
-import { isParsedAkumaCommand, renderAkumaHelp } from "./commands/akuma.js";
-import { installExitCode, renderInstallHelp, renderInstallText } from "./commands/install.js";
-import { renderTaskHelp } from "./commands/task.js";
-import { renderSettingsText, settingsJsonValue } from "./render/settings.js";
-import { renderCatalogText } from "./render/catalog.js";
-import { BindDraftError } from "./draft.js";
-import { renderBindDraftReceipt } from "./render/refusal.js";
-function writeTask(command, result) {
-    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);
-}
-function writeAkuma(command, result) {
-    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);
-}
-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 invocationStart(command) {
-    if (command.output === "json")
-        return undefined;
-    switch (command.command) {
-        case "bind": return "⧖ preparing keiyaku";
-        case "deliver": return "⧖ delivering";
-        case "audit": return "⧖ auditing";
-        case "reconcile": return "⧖ reconciling";
-        case "install": return "⧖ installing skills";
-        default: return undefined;
-    }
-}
-function writeGuidance(command, result) {
-    if (command.output === "json")
-        process.stdout.write(`${JSON.stringify({ contract: result.contract, guidance: result.guidance })}\n`);
-    else
-        process.stdout.write(result.guidance.endsWith("\n") ? result.guidance : `${result.guidance}\n`);
-    return 0;
-}
-function writeCatalog(command, result) {
-    process.stdout.write(`${command.output === "json" ? JSON.stringify(result.catalog) : renderCatalogText(result.catalog)}\n`);
-    return 0;
-}
-// eslint-disable-next-line complexity -- output dispatch is the single CLI presentation boundary.
-function writeResult(command, result) {
-    if (command.command === "install") {
-        const value = result;
-        process.stdout.write(`${command.output === "json" ? JSON.stringify(value) : renderInstallText(value)}\n`);
-        return installExitCode(value);
-    }
-    if (command.command === "task")
-        return writeTask(command, result);
-    if (command.command === "settings") {
-        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 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 writeAkuma(command, result);
-    }
-    if (akumaResult && command.command === "status") {
-        return writeAkuma(command, result);
-    }
-    const contractResult = result;
-    if (contractResult.kind === "guidance")
-        return writeGuidance(command, contractResult);
-    if (contractResult.kind === "catalog")
-        return writeCatalog(command, contractResult);
-    if (contractResult.kind === "region") {
-        const output = command.output === "json" ? JSON.stringify(contractResult.region) : renderText(contractResult);
-        process.stdout.write(`${output}\n`);
-        return 0;
-    }
-    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;
-}
+import { CliUsageError, parseArgv, renderHelp } from "./parse.js";
 export async function main(argv = process.argv.slice(2)) {
-    let output = "text";
     try {
         const parsed = parseArgv(argv);
         if ("help" in parsed) {
             process.stdout.write(`${renderHelp(parsed.help)}\n`);
             return 0;
         }
-        output = parsed.command.output;
-        const { invoke } = await import("./invoke.js");
-        const start = invocationStart(parsed.command);
-        const result = await invoke(parsed, {
-            cwd: process.cwd(),
-            ...(start === undefined ? {} : { onOperationStart: () => { process.stderr.write(`${start}\n`); } }),
-        });
-        return writeResult(parsed.command, result);
+        return await (await import("./runtime.js")).runCliCommand(parsed);
     }
     catch (error) {
-        if (error instanceof AkumaWorldScopeError)
-            return writeWorldScopeRefusal(error, output);
-        const original = error instanceof BindDraftError ? error.original : error;
-        process.stderr.write(`${original instanceof Error ? original.message : String(original)}\n`);
-        if (error instanceof BindDraftError)
-            process.stderr.write(`${renderBindDraftReceipt(error.draft)}\n`);
-        return 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/parse.d.ts

@@ -1,6 +1,6 @@
 import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
 import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
-import type { CatalogQuery } from "../index.js";
+import type { CatalogQuery } from "../library/catalog.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
 import { type ContractCommand as Command } from "./commands/contract.js";
 export { CliUsageError } from "./usage.js";
@@ -8,6 +8,7 @@ export type { Command };
 export declare function renderRootHelp(): string;
 export declare function renderContractHelp(command: Command): string;
 export declare function renderCommandUsage(command: ParsedCommand): string;
+export declare function renderHelp(coordinate: CliHelpCoordinate): string;
 type Output = Readonly<{
     output: "text" | "json";
 }>;
@@ -20,14 +21,14 @@ export type ParsedBind = Output & Actor & Readonly<{
     target?: string;
     workspace?: "here";
     after?: readonly string[];
-    gates?: string;
+    gates?: readonly string[];
 }>;
 export type ParsedAmend = Output & Actor & Readonly<{
     command: "amend";
     contract?: string;
     after?: readonly string[];
     clearAfter?: true;
-    gates?: string;
+    gates?: readonly string[];
     stdin?: true;
 }>;
 export type ParsedDeliver = Output & Actor & Readonly<{
@@ -35,6 +36,7 @@ export type ParsedDeliver = Output & Actor & Readonly<{
     contract?: string;
     message?: string;
     includeDirty: boolean;
+    materializeConflict: boolean;
 }>;
 export type ParsedReview = Output & Actor & Readonly<{
     command: "review";
@@ -77,6 +79,10 @@ type ParsedReconcile = Output & Readonly<{
     contract?: string;
     retryHooks: boolean;
 }>;
+export type ParsedNuke = Output & Readonly<{
+    command: "nuke";
+    confirm?: string;
+}>;
 export type ParsedSettings = Output & Readonly<{
     command: "settings";
 }>;
@@ -89,7 +95,7 @@ export type ParsedRegion = Output & Readonly<{
 export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | (Output & Readonly<{
     command: "show";
     contract?: string;
-}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+}>) | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{
@@ -112,4 +118,11 @@ export type ParsedExecution = Readonly<{
 export type ParsedInvocation = ParsedExecution | Readonly<{
     help: CliHelpCoordinate;
 }>;
+type RepoUse = "none" | "optional" | "required";
+export type CommandRepoPolicy = Readonly<{
+    use: RepoUse;
+    acceptsExplicit: boolean;
+}>;
+export declare function commandRepoPolicy(command: ParsedCommand): CommandRepoPolicy;
+export declare function assertExplicitRepoUse(command: ParsedCommand, repo: string | undefined): void;
 export declare function parseArgv(argv: readonly string[]): ParsedInvocation;