@astrosheep/keiyaku 4.0.5 → 4.1.0

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

@@ -1,4 +1,4 @@
-import { Repo } from "../index.js";
+import { Repo } from "../library/repo.js";
 import { type WorldRoot } from "../world.js";
 import { type ParsedCommand } from "./parse.js";
 export type CliCoordinates = Readonly<{
@@ -7,6 +7,10 @@ export type CliCoordinates = Readonly<{
     repo?: Repo;
     world: WorldRoot | null;
     candidateWorld: WorldRoot | null;
+    taskContext: Readonly<{
+        directory: string;
+        boundary: string;
+    }>;
     establishWorld: () => Promise<WorldRoot>;
 }>;
 export type CliCoordinateInput = Readonly<{
@@ -16,5 +20,4 @@ export type CliCoordinateInput = Readonly<{
     gitPath?: string;
     command: ParsedCommand;
 }>;
-export declare function assertExplicitRepoUse(command: ParsedCommand, repo: string | undefined): void;
 export declare function resolveCliCoordinates(input: CliCoordinateInput): Promise<CliCoordinates>;

package/build/src/cli/coordinates.js

@@ -1,8 +1,8 @@
 import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
-import { NoGitWorldError, Repo } from "../index.js";
+import { NoGitWorldError, Repo } from "../library/repo.js";
 import { World, WorldError } from "../world.js";
-import { CliUsageError } from "./parse.js";
+import { CliUsageError, commandRepoPolicy } from "./parse.js";
 async function canonicalInvocationCwd(input) {
     try {
         return await realpath(input);
@@ -24,55 +24,6 @@ async function discoverRepoAt(coordinate, gitPath) {
         throw error;
     }
 }
-function repoPolicy(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 "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 && !repoPolicy(command).acceptsExplicit)
-        refuseUnusedRepo(command);
-}
 function repoFor(use, discovery) {
     if (use === "none")
         return undefined;
@@ -114,14 +65,16 @@ export async function resolveCliCoordinates(input) {
         ? invocationRepo
         : await discoverRepoAt(resolve(cwd, input.repo), input.gitPath);
     const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
-    const repo = repoFor(repoPolicy(input.command).use, selectedRepo);
+    const repo = repoFor(commandRepoPolicy(input.command).use, selectedRepo);
     const world = await resolveWorld(cwd, worldRepo);
+    const boundary = worldRepo === undefined ? world.root ?? world.candidate ?? cwd : worldRepo.cwd;
     return {
         cwd,
         cwdSource: input.cwd === undefined ? "process" : "input",
         ...(repo === undefined ? {} : { repo }),
         world: world.root,
         candidateWorld: world.candidate,
+        taskContext: { directory: cwd, boundary },
         establishWorld: world.establish,
     };
 }

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,21 +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 { injectedBodyRequests } from "../akuma/requests.js";
-import { EMPTY_WORKTREE_HOOKS } from "../library/configuration.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)
@@ -56,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, names) {
-    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }));
+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;
@@ -94,12 +83,15 @@ function gitPathFromEdge(environment) {
     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);
     }
@@ -109,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,
@@ -132,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));
     }
 }
@@ -143,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 }),
@@ -164,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,
@@ -186,7 +197,9 @@ async function invokeExisting(input) {
             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,
@@ -198,25 +211,28 @@ async function invokeExisting(input) {
             }), (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;
     }
@@ -227,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)
@@ -254,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");
@@ -282,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" };
@@ -291,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,
@@ -299,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" };
         }
@@ -312,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",
@@ -320,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 });
@@ -342,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}`);
@@ -355,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() };
@@ -362,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 };
         }
@@ -372,6 +400,7 @@ async function invokeContractHistory(repo, contract) {
 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 }),
@@ -379,7 +408,7 @@ async function invokeParsed(invocation, runtime) {
         ...(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,
@@ -390,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);
@@ -428,14 +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") && injectedBodyRequests() !== null) {
+    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() };
@@ -466,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;
     }
 }