@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/cli/invoke.js

@@ -1,9 +1,7 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { gatesFrom, Keiyaku, NoGitWorldError, Repo, settings, SettingsError, worktreeHooksFrom } from "../index.js";
-import { kanshi, selectKanshi } from "../kanshi/index.js";
+import { AkumaWorldScopeError, gatesFrom, Keiyaku, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
+import { kanshi, selectKanshi, selectRegion } from "../kanshi/index.js";
 import { resolveActor } from "./actor.js";
-import { resultFromMutationCall } from "./accepted.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";
@@ -11,10 +9,53 @@ 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 { isBlankInput } from "./usage.js";
 import { 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)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+function selectedStdinDiagnostic(command) {
+    switch (command.command) {
+        case "bind":
+        case "amend":
+        case "arc":
+            return `${command.command} requires a nonblank stdin document`;
+        case "review":
+            return command.summaryFromStdin === true ? "review requires a nonblank summary" : undefined;
+        case "call":
+        case "tell":
+            return command.prompt.kind === "stdin" ? `${command.command} requires a nonblank prompt` : undefined;
+        case "task":
+            switch (command.stdin) {
+                case "document": return "task add requires a nonblank stdin document";
+                case "compose": return "task compose requires a nonblank stdin document";
+                case "body": return "task update --body requires a nonblank value";
+                case "append": return "task update --append requires a nonblank value";
+                case "note": return "task update --note requires a nonblank value";
+                default: return undefined;
+            }
+        default:
+            return undefined;
+    }
+}
+async function withAcquiredStdin(command, runtime) {
+    const diagnostic = selectedStdinDiagnostic(command);
+    if (diagnostic === undefined)
+        return runtime;
+    const bytes = await (runtime.readStdin ?? readStdin)();
+    if (isBlankInput(bytes))
+        throw new CliUsageError(diagnostic);
+    return { ...runtime, readStdin: async () => bytes };
+}
 function settingsAt(root, environment) {
     const home = environment.KEIYAKU_HOME?.trim();
-    return settings({ root, ...(home === undefined || home.length === 0 ? {} : { home }) });
+    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
 }
 function selectedGates(value, name) {
     try {
@@ -36,6 +77,16 @@ function selectedHooks(value) {
         throw error;
     }
 }
+function selectedGitPolicy(value) {
+    try {
+        return requireBranchesToBeUpToDateFrom({ settings: value });
+    }
+    catch (error) {
+        if (error instanceof SettingsError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
 function actorFromEdge(actor, environment) {
     let resolved;
     try {
@@ -46,88 +97,84 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
-function repoAt(coordinate) {
-    return coordinate === undefined ? Repo.at() : Repo.at({ path: coordinate });
-}
 async function selectContract(repo, selector, scope) {
     if (selector !== undefined && !selector.startsWith("@"))
         return contractFromInput(repo, selector);
     const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
     return contractFromInput(repo, id);
 }
-async function invokeBind(parsed, repo, edge, configuration, hooks) {
-    const markdown = edge.readStdin();
+async function bindDraftReceipt(establishWorld, markdown) {
+    try {
+        return preserveBindDraft(await establishWorld(), markdown);
+    }
+    catch (error) {
+        return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+async function invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld }) {
+    const markdown = await edge.readStdin();
     const gates = selectedGates(configuration, parsed.gates);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    return resultFromMutationCall("bind", () => bindFromCommand({
-        command: parsed,
-        repo,
-        markdown,
-        gates,
-        ...(actor === undefined ? {} : { actor }),
-        hooks,
-    }), {
-        project: (result) => {
-            const bound = result.facts.find((fact) => fact.kind === "bind");
+    try {
+        const result = await resultFromMutationCall("bind", () => bindFromCommand({
+            command: parsed,
+            repo,
+            markdown,
+            gates,
+            ...(actor === undefined ? {} : { actor }),
+            hooks,
+        }), (accepted) => {
+            const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
                 throw new Error("accepted bind is missing its bind fact");
-            return { target: bound.data.coordinates.target ?? null };
-        },
-    });
+            return acceptedBind(accepted, bound.data.coordinates.target ?? null);
+        });
+        if (result.kind !== "refused")
+            return result;
+        return { ...result, draft: await bindDraftReceipt(establishWorld, markdown) };
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        throw new BindDraftError(error, await bindDraftReceipt(establishWorld, markdown));
+    }
 }
-function unavailableDiff(delivery) {
-    return {
-        reason: "git-unavailable",
-        snapshotId: delivery.snapshotId,
-        changeId: delivery.changeId,
-    };
+function deliverRefusal(refusal) {
+    if (typeof refusal !== "object" || refusal === null || !("kind" in refusal) || refusal.kind !== "dirty-workspace") {
+        return refusal;
+    }
+    const submodules = "submodules" in refusal && Array.isArray(refusal.submodules) ? refusal.submodules : [];
+    return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
 }
-async function invokeDeliver(parsed, seat) {
+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,
-        project: (result) => ({
-            obligations: {
-                ...(result.value.verification === undefined ? {} : { verification: result.value.verification }),
-                ...(result.value.placement === undefined ? {} : { placement: result.value.placement }),
-                ...(result.value.leak === undefined ? {} : { leak: result.value.leak }),
-            },
-        }),
+        projectRefusal: deliverRefusal,
     });
 }
 async function invokeReview(parsed, seat, readStdin) {
-    const summary = parsed.summaryFromStdin === true ? readStdin() : parsed.summary;
+    const summary = parsed.summaryFromStdin === true ? await readStdin() : parsed.summary;
     return resultFromMutationCall("review", () => seat.contract.review({
         verdict: parsed.verdict,
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
         ...(summary === undefined ? {} : { summary }),
         hooks: seat.hooks,
-    }), {
-        coordinate: seat.id,
-        project: (result) => ({
-            obligations: result.value.placement === undefined ? {} : { placement: result.value.placement },
-        }),
-    });
+    }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
 }
-async function invokeAudit(parsed, seat) {
-    const delivery = parsed.showDiffBody ? await seat.contract.delivery() : null;
-    return resultFromMutationCall("audit", () => seat.contract.audit({ ...(seat.actor === undefined ? {} : { actor: seat.actor }), hooks: seat.hooks }), {
-        coordinate: seat.id,
-        project: async (result) => {
-            let renderedDiff;
-            if (parsed.showDiffBody && delivery !== null) {
-                const diff = await delivery.diff();
-                renderedDiff = diff === null ? unavailableDiff(delivery) : diff;
-            }
-            return {
-                report: result.value,
-                ...(renderedDiff === undefined ? {} : { diff: renderedDiff }),
-            };
-        },
-    });
+async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
+    return resultFromMutationCall("audit", () => seat.contract.audit({
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        includeDirty: parsed.includeDirty,
+        showDiff: parsed.showDiff,
+        requireBranchesToBeUpToDate,
+        hooks: seat.hooks,
+    }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
 }
 async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
     const { id, contract } = await selectContract(repo, parsed.contract, scope);
@@ -135,77 +182,192 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
     const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
     switch (parsed.command) {
         case "amend": {
-            const markdown = edge.readStdin();
+            const markdown = await edge.readStdin();
             const gates = parsed.gates === undefined
                 ? undefined
                 : selectedGates(configuration, parsed.gates);
-            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), { coordinate: id });
+            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
-            return invokeDeliver(parsed, seat);
+            return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
         case "review":
             return invokeReview(parsed, seat, edge.readStdin);
         case "arc": {
-            const markdown = edge.readStdin();
+            const markdown = await edge.readStdin();
             return resultFromMutationCall("arc", () => contract.arc({
                 markdown,
                 ...(actor === undefined ? {} : { actor }),
                 hooks,
-            }), { coordinate: id });
+            }), (result) => acceptedArc(result, id), { coordinate: id });
         }
         case "abandon":
             return resultFromMutationCall("abandon", () => contract.abandon({
                 ...(actor === undefined ? {} : { actor }),
                 ...(parsed.note === undefined ? {} : { note: parsed.note }),
                 hooks,
-            }), { coordinate: id });
+            }), (result) => acceptedAbandon(result, id), { coordinate: id });
         case "audit":
-            return invokeAudit(parsed, seat);
+            return invokeAudit(parsed, seat, selectedGitPolicy(configuration));
         default:
             return parsed;
     }
 }
-async function invokeAkumaCommand(parsed, path, configuration, edge) {
+async function invokeAkumaCommand(parsed, input) {
+    const { path, executionCwd, repo, configuration, edge } = input;
     if (parsed.command === "call" && parsed.contract !== undefined) {
-        const selected = contractFromInput(repoAt(path), parsed.contract);
+        if (repo === undefined)
+            throw new Error("call with Contract requires a resolved Repo");
+        const selected = contractFromInput(repo, parsed.contract);
         return await invokeAkuma(parsed, {
             path,
+            ...(executionCwd === undefined ? {} : { executionCwd }),
             settings: configuration,
             contract: selected.contract,
             readStdin: edge.readStdin,
         });
     }
-    if (parsed.command === "fork") {
-        let repo;
+    return await invokeAkuma(parsed, {
+        path,
+        ...(executionCwd === undefined ? {} : { executionCwd }),
+        settings: configuration,
+        ...(repo === undefined ? {} : { repo }),
+        readStdin: edge.readStdin,
+    });
+}
+async function invokeAkumaFromEdge(parsed, input) {
+    try {
+        return await invokeAkumaCommand(parsed, input);
+    }
+    catch (error) {
+        if (error instanceof AkumaWorldScopeError)
+            throw error;
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+async function akumaWorldFor(parsed, located, candidate, establish) {
+    const world = parsed.command === "call" ? candidate ?? await establish() : located;
+    if (world === null)
+        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+    return world;
+}
+async function invokeCatalog(parsed, world, repo, edge) {
+    try {
+        if (parsed.query.kind === "contracts") {
+            if (repo === undefined)
+                throw new Error("Contract catalog requires a resolved Repo");
+            return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, repo }) };
+        }
+        if (parsed.query.kind === "archetypes") {
+            return {
+                kind: "catalog",
+                catalog: await Keiyaku.ls({ query: parsed.query, settings: await settingsAt(undefined, edge.environment) }),
+            };
+        }
+        if (world === null)
+            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+        if (parsed.query.kind === "tasks") {
+            return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, path: world }) };
+        }
+        return { kind: "catalog", catalog: await Keiyaku.ls({ query: parsed.query, path: world }) };
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
+async function invokeStatus(parsed, world, repo, edge) {
+    const configuration = await settingsAt(world ?? undefined, edge.environment);
+    if (parsed.akuma === true) {
+        if (world === null)
+            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+        return invokeAkumaStatus(world, parsed.contract, configuration, undefined, repo);
+    }
+    if (parsed.contract === undefined) {
+        const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+        return { kind: "status", report, selection: "world" };
+    }
+    if (parsed.contract.startsWith("@")) {
+        try {
+            const address = await resolveNamedAddress({
+                path: world,
+                selector: parsed.contract,
+                contracts: repo === undefined ? [] : (await Keiyaku.list({ repo })).rows,
+            });
+            if (address.kind === "akuma") {
+                if (world === null)
+                    throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+                return invokeAkumaStatus(world, address.id, configuration, parsed.contract, repo);
+            }
+            const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+            return { kind: "status", report: selectKanshi({ report, contract: address.id }), selection: "contract" };
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                throw new CliUsageError(error.message);
+            throw error;
+        }
+    }
+    const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
+    const contract = resolveKanshiContract(report, parsed.contract);
+    return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
+}
+async function invokeRegion(parsed, world, repo) {
+    const read = async (region) => {
         try {
-            repo = repoAt(path);
+            return await kanshi({ world, repo, region });
         }
         catch (error) {
-            if (!(error instanceof NoGitWorldError))
-                throw error;
+            if (error instanceof TypeError)
+                throw new CliUsageError(error.message);
+            throw error;
         }
-        return await invokeAkuma(parsed, {
-            path,
-            settings: configuration,
-            ...(repo === undefined ? {} : { repo }),
-            readStdin: edge.readStdin,
-        });
+    };
+    if (parsed.contract === undefined) {
+        const selection = parsed.path !== undefined
+            ? { kind: "path", path: parsed.path }
+            : parsed.overlap ? { kind: "overlap" } : { kind: "declarations" };
+        const report = await read(selection);
+        return { kind: "region", region: report.region ?? { kind: "absent" } };
+    }
+    const report = await read({ kind: "declarations" });
+    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}`);
+    }
+    if (report.region?.kind !== "present" || report.region.value.kind !== "declarations") {
+        return { kind: "region", region: report.region ?? { kind: "absent" } };
     }
-    return await invokeAkuma(parsed, { path, settings: configuration, readStdin: edge.readStdin });
+    const selection = parsed.overlap ? { kind: "overlap", contract } : { kind: "contract", contract };
+    return { kind: "region", region: { kind: "present", value: selectRegion({ declarations: report.region.value.declarations, selection }) } };
 }
+// eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
-    const coordinate = invocation.cwd ?? runtime.cwd;
+    const coordinates = await resolveCliCoordinates({
+        ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        command: invocation.command,
+    });
+    const { cwd, repo, world, candidateWorld, establishWorld } = coordinates;
     const edge = {
         environment: runtime.environment ?? process.env,
-        readStdin: runtime.readStdin ?? (() => readFileSync(0, "utf8")),
+        readStdin: runtime.readStdin ?? readStdin,
     };
     const parsed = invocation.command;
     if (parsed.command === "settings") {
-        return { kind: "settings", value: settingsAt(resolve(coordinate ?? "."), edge.environment) };
+        return { kind: "settings", value: await settingsAt(world ?? undefined, edge.environment) };
     }
     if (parsed.command === "task") {
         try {
-            return await invokeTask(parsed, { ...(coordinate === undefined ? {} : { path: coordinate }), readStdin: edge.readStdin });
+            return await invokeTask(parsed, {
+                world,
+                establish: coordinates.establishWorld,
+                readStdin: edge.readStdin,
+                ...(runtime.actor === undefined ? {} : { actor: runtime.actor }),
+            });
         }
         catch (error) {
             if (error instanceof TypeError)
@@ -214,24 +376,33 @@ async function invokeParsed(invocation, runtime) {
         }
     }
     if (isParsedAkumaCommand(parsed)) {
-        const path = resolve(coordinate ?? ".");
-        const configuration = settingsAt(path, edge.environment);
-        return await invokeAkumaCommand(parsed, path, configuration, edge);
+        const akumaWorld = await akumaWorldFor(parsed, world, candidateWorld, coordinates.establishWorld);
+        const configuration = await settingsAt(akumaWorld, edge.environment);
+        return await invokeAkumaFromEdge(parsed, {
+            path: akumaWorld,
+            ...(parsed.command === "call" && parsed.contract !== undefined && invocation.cwd === undefined
+                ? {}
+                : { executionCwd: cwd }),
+            ...(repo === undefined ? {} : { repo }),
+            configuration,
+            edge,
+        });
     }
-    if (parsed.command === "status") {
-        if (parsed.akuma === true) {
-            return invokeAkumaStatus(coordinate ?? ".", parsed.contract);
-        }
-        const report = await kanshi(coordinate === undefined ? {} : { path: coordinate });
-        if (parsed.contract === undefined)
-            return { kind: "status", report, selection: "world" };
-        const contract = resolveKanshiContract(report, parsed.contract);
-        return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
-    }
-    const repo = repoAt(coordinate);
-    const scope = coordinate ?? repo.root;
-    const configuration = settingsAt(repo.root, edge.environment);
+    if (parsed.command === "ls")
+        return await invokeCatalog(parsed, world, repo, edge);
+    if (parsed.command === "status")
+        return await invokeStatus(parsed, world, repo, edge);
+    if (repo === undefined)
+        throw new Error(`${parsed.command} requires a resolved Repo`);
+    if (parsed.command === "region")
+        return invokeRegion(parsed, world, repo);
+    const scope = cwd;
+    const configuration = await settingsAt(world ?? undefined, edge.environment);
     const hooks = selectedHooks(configuration);
+    if (parsed.command === "show") {
+        const selected = await selectContract(repo, parsed.contract, scope);
+        return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
+    }
     switch (parsed.command) {
         case "reconcile": {
             if (parsed.contract === undefined) {
@@ -241,20 +412,28 @@ async function invokeParsed(invocation, runtime) {
             return { kind: "observation", command: "reconcile", ...await contract.reconcile({ hooks, retryHooks: parsed.retryHooks }) };
         }
         case "bind":
-            return invokeBind(parsed, repo, edge, configuration, hooks);
+            return invokeBind({ parsed, repo, edge, configuration, hooks, establishWorld });
         default:
             return invokeExisting({ parsed, repo, edge, scope, configuration, hooks });
     }
 }
-async function invokeInstall(command, runtime) {
-    return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+function withResolvedTaskActor(command, runtime) {
+    if (command.command !== "task" || (command.action !== "add" && command.action !== "compose"))
+        return runtime;
+    const actor = actorFromEdge(typeof command.flags.actor === "string" ? command.flags.actor : undefined, runtime.environment ?? process.env);
+    return actor === undefined ? runtime : { ...runtime, actor };
 }
 export async function invoke(invocation, runtime = {}) {
     try {
         const command = invocation.command;
+        assertExplicitRepoUse(command, invocation.repo);
         if (command.command === "install")
-            return await invokeInstall(command, runtime);
-        return await invokeParsed({ ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }), command }, runtime);
+            return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+        return await invokeParsed({
+            ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+            ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+            command,
+        }, await withAcquiredStdin(command, withResolvedTaskActor(command, runtime)));
     }
     catch (error) {
         if (error instanceof CliUsageError && error.projection === undefined) {

package/build/src/cli/main.js

@@ -1,12 +1,20 @@
+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, renderAkumaJson, renderAkumaText } from "./render/akuma.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") {
@@ -16,13 +24,17 @@ function writeTask(command, result) {
         process.stdout.write(result.draft);
     }
     else
-        process.stdout.write(`${renderTaskText(command, result)}\n`);
+        process.stdout.write(`${renderTaskText(command, result, context)}\n`);
     return taskExitCode(result);
 }
 function writeAkuma(command, result) {
-    const output = command.output === "json" ? renderAkumaJson(command, result) : renderAkumaText(command, result);
-    const rawLast = command.command === "history" && command.last && command.output === "text";
-    process.stdout.write(rawLast ? output : `${output}\n`);
+    const output = command.output === "json" ? renderAkumaJson(command, 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) {
@@ -34,6 +46,18 @@ function renderHelp(coordinate) {
         case "akuma": return renderAkumaHelp(coordinate.action);
     }
 }
+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;
@@ -52,6 +76,15 @@ function writeResult(command, result) {
         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, {
@@ -61,19 +94,33 @@ function writeResult(command, result) {
     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 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 result = await invoke(parsed, { cwd: process.cwd() });
         return writeResult(parsed.command, result);
     }
     catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return error instanceof CliUsageError ? 1 : 3;
+        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;
     }
 }