@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,268 +1,656 @@
-import { archetypeName } from "../../akuma/identity.js";
-import { parseTaskNamespaceSelector } from "../../task/catalog.js";
-import { CliUsageError, commandGuide } from "../usage.js";
-import { CONTRACT_COMMAND_SPECS } from "./contract-help.js";
-export { CONTRACT_COMMAND_SPECS, renderContractHelp, renderContractUsage, } from "./contract-help.js";
-function parseAkumaCatalogPath(value) {
-    if (value === "aku" || value === "aku/")
-        return { kind: "archetypes" };
-    if (value === "aku/*/*")
-        return { kind: "akuma" };
-    const match = /^aku\/([^/]+)\/?$/u.exec(value);
-    if (match === null)
-        return null;
-    return { kind: "akuma", archetype: archetypeName(match[1]) };
-}
-function optionalFlag(flags, name) {
-    const value = flags[name];
-    return typeof value === "string" ? value : undefined;
-}
-function refuse(command, message) {
-    throw new CliUsageError(message, commandGuide(command, CONTRACT_COMMAND_SPECS[command].usage));
-}
-function parseGateNames(parts, command) {
-    const value = optionalFlag(parts.flags, "gates");
-    if (value === undefined)
+import { listArchetypeDefinitions } from "../../akuma/archetype.js";
+import { executionChannel } from "../../akuma/requests.js";
+import { Akumas, Keiyaku, KeiyakuError, nuke } from "../../index.js";
+import { kanshi, observeKanshi, selectKanshi, selectRegion } from "../../kanshi/index.js";
+import { resolveNamedAddress } from "../../library/address.js";
+import { composeContractLibrary, observeKeiyaku } from "../../library/contract-composition.js";
+import { validateArcMarkdown, validateContractMarkdown } from "../../library/input.js";
+import { createKeiyakuHandle } from "../../library/keiyaku.js";
+import { SettingsError, settings } from "../../settings.js";
+import { Tasks } from "../../task/index.js";
+import { actorFromEdge } from "../actor.js";
+import { resolveInvocationCwd } from "../coordinates.js";
+import { BindDraftError, preserveBindDraft } from "../draft.js";
+import { snapshotText } from "../render/akuma-activity.js";
+import { renderAkumaCatalogue, renderArchetypeCatalogue, renderContractCatalogue, renderTaskCatalogue, } from "../render/catalog.js";
+import { renderAccepted, renderContractHistory, renderRetry } from "../render/contract.js";
+import { renderKanshiText } from "../render/kanshi.js";
+import { nukeExitCode, renderNukeText } from "../render/nuke.js";
+import { reconcileHasFailure, renderReconcile } from "../render/reconcile.js";
+import { renderConflictMaterialized, renderRefusal } from "../render/refusal.js";
+import { renderRegionText } from "../render/region.js";
+import { renderSettingsText, settingsJsonValue } from "../render/settings.js";
+import { canonicalContractSelector, contractFromInput, resolveContractId, resolveKanshiContract, } from "../selectors.js";
+import { displayContext, writeJson, writeStdout } from "../streams.js";
+import { CliUsageError, isBlankInput } from "../usage.js";
+import { amendFromCommand } from "./amend.js";
+import { bindFromCommand } from "./bind.js";
+function requiredRepo(coordinates) {
+    if (coordinates.repo === undefined)
+        throw new CliUsageError("this command requires a resolved Repo");
+    return coordinates.repo;
+}
+async function settingsAt(root, home) {
+    return settings({
+        ...(root === undefined ? {} : { root }),
+        ...(home === undefined ? {} : { home }),
+    });
+}
+/**
+ * The process edge loads one Settings value and hands it to the private composition.
+ * A forwarded audit/deliver/review is served by its parent, which loads its own.
+ */
+async function contractSettings(command, execution, world, home) {
+    const forwarded = executionChannel(execution).kind === "body-request" &&
+        (command.command === "audit" || command.command === "deliver" || command.command === "review");
+    if (forwarded)
         return undefined;
-    if (value === "")
-        return [];
-    const names = value.split(",");
-    if (names.some((name) => name.length === 0)) {
-        refuse(command, '--gates requires comma-separated names or "" to clear gates');
-    }
-    return names;
-}
-function parseBind(parts) {
-    const forkOf = optionalFlag(parts.flags, "fork-of");
-    if (forkOf !== undefined) {
-        if (parts.stdin)
-            refuse("bind", "fork bind reads no stdin");
-        for (const option of ["task", "after", "gates"]) {
-            if (parts.flags[option] !== undefined)
-                refuse("bind", `--${option} is not valid with --fork-of`);
-        }
-        const target = optionalFlag(parts.flags, "target");
-        return {
-            command: "bind",
-            forkOf,
-            ...(target === undefined ? {} : { target }),
-            ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-            output: parts.output,
-        };
-    }
-    if (!parts.stdin)
-        refuse("bind", "bind requires stdin");
-    const task = optionalFlag(parts.flags, "task");
-    const target = optionalFlag(parts.flags, "target");
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    const gates = parseGateNames(parts, "bind");
-    return {
-        command: "bind",
-        ...(task === undefined ? {} : { task }),
-        ...(target === undefined ? {} : { target }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        output: parts.output,
-    };
+    return await settingsAt(world ?? undefined, home);
 }
-function parseAmend(parts) {
-    const contract = parts.positionals[0];
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    if (parts.flags["clear-after"] === true && after.length > 0)
-        refuse("amend", "--clear-after and --after are mutually exclusive");
-    const gates = parseGateNames(parts, "amend");
-    if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
-        refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
-    }
-    return {
-        command: "amend",
-        ...(contract === undefined ? {} : { contract }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        ...(parts.stdin ? { stdin: true } : {}),
-        output: parts.output,
-    };
+function draftWarning(error) {
+    return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
 }
-function parseDeliver(parts) {
-    const contract = parts.positionals[0];
-    const message = optionalFlag(parts.flags, "message");
-    return {
-        command: "deliver",
-        ...(contract === undefined ? {} : { contract }),
-        ...(message === undefined ? {} : { message }),
-        includeDirty: parts.flags["include-dirty"] === true,
-        materializeConflict: parts.flags["materialize-conflict"] === true,
-        overwrite: parts.flags.overwrite === true,
-        output: parts.output,
-    };
+/** Preserve a refused bind draft at the invocation cwd; coordinates are not yet available. */
+async function bindDraftReceiptAtCwd(input, markdown) {
+    try {
+        return await preserveBindDraft(await resolveInvocationCwd(input), markdown);
+    }
+    catch (error) {
+        if (error instanceof Error && "executionReceipt" in error)
+            throw error;
+        return draftWarning(error);
+    }
 }
-function parseReview(parts) {
-    if (Number(parts.flags.satisfied === true) + Number(parts.flags.unsatisfied === true) !== 1) {
-        refuse("review", "review requires exactly one verdict flag");
+/**
+ * The one bind-document admission that runs before coordinate resolution, so a malformed document
+ * refuses as a draft-bearing refusal instead of a later Repo/Git failure. Reads the memoized stdin.
+ */
+export async function admitBindMarkdown(input) {
+    if (isBlankInput(input.markdown))
+        throw new CliUsageError("bind requires a nonblank stdin document");
+    try {
+        validateContractMarkdown(input.markdown);
     }
-    const summary = optionalFlag(parts.flags, "summary");
-    if (parts.stdin === (summary !== undefined)) {
-        refuse("review", "review requires exactly one of --summary <text> or stdin '-'");
+    catch (error) {
+        if (error instanceof Error && "executionReceipt" in error)
+            throw error;
+        if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
+            throw error;
+        throw new BindDraftError(error, await bindDraftReceiptAtCwd(input, input.markdown));
     }
-    const contract = parts.positionals[0];
-    return {
-        command: "review",
-        ...(contract === undefined ? {} : { contract }),
-        verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
-        ...(summary === undefined ? {} : { summary }),
-        ...(parts.stdin ? { summaryFromStdin: true } : {}),
-        output: parts.output,
-    };
 }
-function parseStatus(parts) {
-    if (parts.positionals.length > 1) {
-        return { command: "status", selectors: parts.positionals, output: parts.output };
+async function bindDraftReceipt(world, markdown) {
+    try {
+        return await preserveBindDraft(await world(), markdown);
     }
-    const contract = parts.positionals[0];
-    if (contract?.startsWith("aku/") === true) {
-        return { command: "status", contract, akuma: true, output: parts.output };
+    catch (error) {
+        if (error instanceof Error && "executionReceipt" in error)
+            throw error;
+        return draftWarning(error);
     }
-    return { command: "status", ...(contract === undefined ? {} : { contract }), output: parts.output };
 }
-function parseRegion(parts) {
-    const contract = parts.positionals[0];
-    const pathFlag = parts.flags.path;
-    const paths = pathFlag === undefined ? undefined : Array.isArray(pathFlag) ? pathFlag : [pathFlag];
-    if (paths !== undefined && contract !== undefined)
-        refuse("region", "--path cannot combine with a contract");
+function refusedInvocation(answer, project) {
+    const refusal = project === undefined ? answer.refusal : project(answer.refusal);
     return {
-        command: "region",
-        ...(contract === undefined ? {} : { contract }),
-        ...(paths === undefined ? {} : { paths: paths }),
-        output: parts.output,
+        operation: answer.operation,
+        ...(answer.contract === undefined ? {} : { contract: answer.contract }),
+        refusal,
     };
 }
-function akumaCatalogQuery(query, parts) {
-    const limit = optionalFlag(parts.flags, "limit");
-    if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
-        refuse("ls", "--limit requires a positive safe integer");
+/** The CLI's own presentation of a refused dirty delivery: the available opt-in is not SDK evidence. */
+function deliverRefusalProjection(refusal) {
+    if (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 } };
+}
+function contractExitCode(answer) {
+    return answer.kind === "refused" ? 1 : answer.kind === "retry" ? 2 : 0;
+}
+function renderContractAnswer(answer, project, context) {
+    switch (answer.kind) {
+        case "handoff":
+            return renderConflictMaterialized(answer.value, context);
+        case "refused":
+            return renderRefusal(refusedInvocation(answer, project), undefined, context);
+        case "retry":
+            return renderRetry(answer, context);
+        case "accepted":
+            return renderAccepted(answer, context);
+    }
+}
+async function finishContractAnswer(answer, output, project) {
+    if (output === "json")
+        writeJson(answer);
+    else
+        writeStdout(renderContractAnswer(answer, project, displayContext()));
+    return contractExitCode(answer);
+}
+async function selectedContract(repo, selector, scope) {
+    const id = await resolveContractId(repo, selector, scope);
+    return { id, contract: contractFromInput(repo, id).contract };
+}
+async function existingSeat(command, coordinates, runtime, library) {
+    const repo = requiredRepo(coordinates);
+    const id = await resolveContractId(repo, command.contract, coordinates.cwd);
+    const actor = "actor" in command ? actorFromEdge(command.actor, runtime.environment) : undefined;
     return {
-        ...query,
-        ...(limit === undefined ? {} : { limit: Number(limit) }),
+        id,
+        contract: library.select({ repo, id }),
+        ...(actor === undefined ? {} : { actor }),
     };
 }
-function listLimit(parts) {
-    const limit = optionalFlag(parts.flags, "limit");
-    if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
-        refuse("ls", "--limit requires a positive safe integer");
-    return limit === undefined ? undefined : Number(limit);
-}
-function taskCatalogQuery(path, limit) {
-    if (path === "task" || path === "task/") {
-        return { kind: "tasks", namespace: [], ...(limit === undefined ? {} : { limit }) };
-    }
-    if (!path.startsWith("task/"))
-        return null;
-    if (!path.endsWith("/"))
-        refuse("ls", `invalid Task namespace selector: ${path}`);
-    const body = path.slice("task/".length, -1);
-    if (body.length === 0 || body.split("/").some((segment) => segment.length === 0))
-        refuse("ls", `invalid Task namespace selector: ${path}`);
+/** One composition for every mutation leaf; gates, hooks, and freshness derive lazily inside it. */
+async function contractLibrary(command, execution, configuration, runtime) {
+    const actor = executionChannel(execution).kind === "local" && ["audit", "deliver", "review"].includes(command.command)
+        ? actorFromEdge(undefined, runtime.environment)
+        : undefined;
+    return composeContractLibrary(execution, createKeiyakuHandle, {
+        ...(configuration === undefined ? {} : { settings: configuration }),
+        ...(actor === undefined ? {} : { actor }),
+    });
+}
+async function runBind(command, input, library) {
+    const { coordinates, runtime } = input;
+    const repo = requiredRepo(coordinates);
+    const actor = actorFromEdge(command.actor, runtime.environment);
+    if (command.forkOf !== undefined) {
+        const answer = await bindFromCommand({
+            command,
+            repo,
+            library,
+            ...(actor === undefined ? {} : { actor }),
+        });
+        return await finishContractAnswer(answer, command.output);
+    }
+    const markdown = await runtime.readStdin();
+    if (isBlankInput(markdown))
+        throw new CliUsageError("bind requires a nonblank stdin document");
     try {
-        const namespace = parseTaskNamespaceSelector(path);
-        return { kind: "tasks", namespace, ...(limit === undefined ? {} : { limit }) };
+        validateContractMarkdown(markdown);
     }
     catch (error) {
-        refuse("ls", error instanceof Error ? error.message : `invalid Task namespace selector: ${path}`);
-    }
-}
-function parseLs(parts) {
-    const path = parts.positionals[0];
-    const limit = listLimit(parts);
-    const taskQuery = taskCatalogQuery(path, limit);
-    if (taskQuery !== null)
-        return { command: "ls", query: taskQuery, output: parts.output };
-    if (path === "kei" || path === "kei/") {
-        return {
-            command: "ls",
-            query: { kind: "contracts", ...(limit === undefined ? {} : { limit }) },
-            output: parts.output,
-        };
+        if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
+            throw error;
+        throw new BindDraftError(error, await bindDraftReceipt(coordinates.establishWorld, markdown));
     }
     try {
-        const query = parseAkumaCatalogPath(path);
-        if (query === null)
-            refuse("ls", "ls requires a supported identity directory selector");
-        return { command: "ls", query: akumaCatalogQuery(query, parts), output: parts.output };
+        const answer = await bindFromCommand({
+            command,
+            repo,
+            library,
+            markdown,
+            ...(actor === undefined ? {} : { actor }),
+        });
+        if (answer.kind !== "refused")
+            return await finishContractAnswer(answer, command.output);
+        const draft = await bindDraftReceipt(coordinates.establishWorld, markdown);
+        if (command.output === "json")
+            writeJson(answer);
+        else
+            writeStdout(renderRefusal(refusedInvocation(answer), draft, displayContext()));
+        return 1;
     }
     catch (error) {
-        if (error instanceof CliUsageError)
+        if (error instanceof Error && "executionReceipt" in error)
             throw error;
-        refuse("ls", error instanceof Error ? error.message : "invalid ls directory");
+        // A selected Settings namespace failure is the Contract owner's invalid input, not a bad draft.
+        if (error instanceof KeiyakuError && error.category === "invalid-input" && error.cause instanceof SettingsError)
+            throw error;
+        if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
+            throw error;
+        throw new BindDraftError(error, await bindDraftReceipt(coordinates.establishWorld, markdown));
     }
 }
-export function parseContractCommand(parts) {
-    switch (parts.command) {
-        case "bind":
-            return parseBind(parts);
+async function runAmend(command, input, seat) {
+    const { coordinates, runtime } = input;
+    const markdown = command.stdin === true ? await runtime.readStdin() : undefined;
+    if (markdown !== undefined && isBlankInput(markdown))
+        throw new CliUsageError("amend requires a nonblank stdin document");
+    const answer = await amendFromCommand({
+        command,
+        repo: requiredRepo(coordinates),
+        contract: seat.contract,
+        ...(markdown === undefined ? {} : { markdown }),
+        ...(command.gates === undefined ? {} : { gates: command.gates }),
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+    });
+    return await finishContractAnswer(answer, command.output);
+}
+async function runDeliver(command, runtime, seat) {
+    const driver = command.output === "text" ? await runtime.progress() : undefined;
+    let answer;
+    try {
+        answer = await seat.contract.deliver({
+            ...(command.message === undefined ? {} : { message: command.message }),
+            includeDirty: command.includeDirty,
+            materializeConflict: command.materializeConflict,
+            overwrite: command.overwrite,
+            ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
+        }, { ...(driver === undefined ? {} : { observe: driver.observe }) });
+    }
+    finally {
+        if (driver !== undefined)
+            await driver.finish().catch(() => undefined);
+    }
+    return await finishContractAnswer(answer, command.output, deliverRefusalProjection);
+}
+async function runReview(command, runtime, seat) {
+    const summary = command.summaryFromStdin === true ? await runtime.readStdin() : command.summary;
+    if (command.summaryFromStdin === true && isBlankInput(summary ?? ""))
+        throw new CliUsageError("review requires a nonblank summary");
+    const driver = command.output === "text" ? await runtime.progress() : undefined;
+    let answer;
+    try {
+        answer = await seat.contract.review({
+            verdict: command.verdict,
+            ...(summary === undefined ? {} : { summary }),
+            ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
+        }, { ...(driver === undefined ? {} : { observe: driver.observe }) });
+    }
+    finally {
+        if (driver !== undefined)
+            await driver.finish().catch(() => undefined);
+    }
+    return await finishContractAnswer(answer, command.output);
+}
+async function runArc(command, runtime, seat) {
+    const markdown = await runtime.readStdin();
+    try {
+        validateArcMarkdown(markdown);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
+            throw error;
+        const refusal = { kind: "invalid-document", diagnostic: error.message };
+        if (command.output === "json")
+            writeJson({ kind: "refused", operation: "arc", contract: seat.id, refusal });
+        else
+            writeStdout(renderRefusal({ operation: "arc", contract: seat.id, refusal }, undefined, displayContext()));
+        return 1;
+    }
+    const answer = await seat.contract.arc({
+        markdown,
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+    });
+    return await finishContractAnswer(answer, command.output);
+}
+async function runAbandon(command, seat) {
+    const answer = await seat.contract.abandon({
+        ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        ...(command.note === undefined ? {} : { note: command.note }),
+    });
+    return await finishContractAnswer(answer, command.output);
+}
+async function runAudit(command, runtime, seat) {
+    const driver = command.output === "text" ? await runtime.progress() : undefined;
+    let answer;
+    try {
+        answer = await seat.contract.audit({
+            includeDirty: command.includeDirty,
+            showDiff: command.showDiff,
+            ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
+        }, { ...(driver === undefined ? {} : { observe: driver.observe }) });
+    }
+    finally {
+        if (driver !== undefined)
+            await driver.finish().catch(() => undefined);
+    }
+    return await finishContractAnswer(answer, command.output, deliverRefusalProjection);
+}
+async function runContractMutation(command, input) {
+    const library = await contractLibrary(command, input.execution, input.configuration, input.runtime);
+    if (command.command === "bind")
+        return await runBind(command, input, library);
+    const seat = await existingSeat(command, input.coordinates, input.runtime, library);
+    switch (command.command) {
         case "amend":
-            return parseAmend(parts);
+            return await runAmend(command, input, seat);
         case "deliver":
-            return parseDeliver(parts);
+            return await runDeliver(command, input.runtime, seat);
         case "review":
-            return parseReview(parts);
-        case "arc": {
-            const contract = parts.positionals[0];
-            return {
-                command: "arc",
-                ...(contract === undefined ? {} : { contract }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "abandon": {
-            const contract = parts.positionals[0];
-            const note = optionalFlag(parts.flags, "note");
-            return {
-                command: "abandon",
-                ...(contract === undefined ? {} : { contract }),
-                ...(note === undefined ? {} : { note }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "status":
-            return parseStatus(parts);
-        case "show": {
-            const contract = parts.positionals[0];
-            return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
-        }
-        case "ls":
-            return parseLs(parts);
-        case "audit": {
-            const contract = parts.positionals[0];
-            return {
-                command: "audit",
-                ...(contract === undefined ? {} : { contract }),
-                includeDirty: parts.flags["include-dirty"] === true,
-                showDiff: parts.flags["show-diff"] === true,
-                output: parts.output,
-            };
-        }
-        case "reconcile": {
-            const contract = parts.positionals[0];
-            return {
-                command: "reconcile",
-                ...(contract === undefined ? {} : { contract }),
-                retryHooks: parts.flags["retry-hooks"] === true,
-                output: parts.output,
-            };
+            return await runReview(command, input.runtime, seat);
+        case "arc":
+            return await runArc(command, input.runtime, seat);
+        case "abandon":
+            return await runAbandon(command, seat);
+        case "audit":
+            return await runAudit(command, input.runtime, seat);
+    }
+}
+function statusRefusal(operation, contract) {
+    return { operation, contract, refusal: { kind: "contract-missing", contractId: contract } };
+}
+async function runSettings(coordinates, home, output) {
+    const value = await settingsAt(coordinates.world ?? undefined, home);
+    if (output === "json")
+        writeJson(settingsJsonValue(value));
+    else
+        writeStdout(renderSettingsText(value, displayContext().columns));
+    return 0;
+}
+async function runNuke(command, coordinates) {
+    if (coordinates.world === null)
+        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+    const result = await nuke({
+        world: coordinates.world,
+        ...(command.confirm === undefined ? {} : { confirm: command.confirm }),
+    });
+    if (command.output === "json")
+        writeJson(result);
+    else
+        writeStdout(renderNukeText(result));
+    return nukeExitCode(result);
+}
+async function runLs(command, coordinates, home) {
+    const query = command.query;
+    if (query.kind === "contracts") {
+        const list = await Keiyaku.with().list({
+            repo: requiredRepo(coordinates),
+            ...(query.limit === undefined ? {} : { limit: query.limit }),
+        });
+        if (command.output === "json")
+            writeJson(list);
+        else
+            writeStdout(renderContractCatalogue(list));
+        return 0;
+    }
+    if (query.kind === "archetypes") {
+        const list = await listArchetypeDefinitions({
+            ...(coordinates.world === null ? {} : { project: coordinates.world }),
+            ...(query.limit === undefined ? {} : { limit: query.limit }),
+            ...(home === undefined ? {} : { home }),
+        });
+        if (command.output === "json")
+            writeJson(list);
+        else
+            writeStdout(renderArchetypeCatalogue(list));
+        return 0;
+    }
+    if (coordinates.world === null)
+        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+    if (query.kind === "tasks") {
+        const listed = await Tasks.of(coordinates.world).list({
+            selection: "all",
+            namespace: query.namespace ?? [],
+            ...(query.limit === undefined ? {} : { limit: query.limit }),
+        });
+        if (listed.kind !== "accepted")
+            throw new Error("Task list did not return an accepted observation");
+        if (command.output === "json")
+            writeJson(listed);
+        else
+            writeStdout(renderTaskCatalogue(listed.value, query.namespace ?? []));
+        return 0;
+    }
+    const listed = await Akumas.of(coordinates.world).list({
+        ...(query.archetype === undefined ? {} : { archetype: query.archetype }),
+        ...(query.limit === undefined ? {} : { limit: query.limit }),
+    });
+    if (command.output === "json")
+        writeJson(listed);
+    else
+        writeStdout(renderAkumaCatalogue(listed, query.archetype ?? null));
+    return 0;
+}
+async function readAkumaStatus(akuma, alias, coordinates) {
+    if (coordinates.world === null)
+        throw new CliUsageError("no Keiyaku world contains the Akuma selector");
+    const status = await Akumas.of(coordinates.world).status({
+        akuma,
+        ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+    });
+    return {
+        value: status,
+        project: () => snapshotText(status, displayContext(), ...(alias === undefined ? [{}] : [{ alias }])),
+    };
+}
+async function readContractStatus(selector, coordinates, named) {
+    const repo = requiredRepo(coordinates);
+    if (selector !== undefined && selector.startsWith("@")) {
+        if (named === undefined)
+            throw new CliUsageError("cannot resolve a named status selector");
+        const address = resolveNamedAddress({ selector, report: named.report, aliases: named.aliases });
+        if (address.kind === "akuma")
+            throw new CliUsageError("named status selector resolved to an Akuma");
+        const report = await kanshi({ world: coordinates.world, repo, contract: address.id });
+        return { value: report, project: () => renderKanshiText(report, displayContext(), "contract") };
+    }
+    const contract = selector === undefined ? undefined : canonicalContractSelector(selector);
+    const report = await kanshi({ world: coordinates.world, repo, ...(contract === undefined ? {} : { contract }) });
+    return { value: report, project: () => renderKanshiText(report, displayContext(), "contract") };
+}
+async function namedStatus(selector, coordinates, named) {
+    if (named === undefined)
+        throw new CliUsageError("cannot resolve a named status selector");
+    const address = resolveNamedAddress({ selector, report: named.report, aliases: named.aliases });
+    if (address.kind === "akuma")
+        return await readAkumaStatus(address.id, selector, coordinates);
+    return await readContractStatus(address.id, coordinates, named);
+}
+async function runStatusGuidance(command, coordinates) {
+    const repo = coordinates.repo;
+    if (repo === undefined)
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    const selected = await selectedContract(repo, command.contract, coordinates.cwd);
+    const guidance = await selected.contract.guidance();
+    if (guidance === null) {
+        if (command.output === "json")
+            writeJson(null);
+        else
+            writeStdout(renderRefusal(statusRefusal("status", selected.id), undefined, displayContext()));
+        return 1;
+    }
+    if (command.output === "json")
+        writeJson(guidance);
+    else
+        writeStdout(guidance);
+    return 0;
+}
+async function runStatusSelection(command, coordinates) {
+    const selectors = command.selectors;
+    if (selectors.length < 2)
+        throw new CliUsageError("status requires at least two selectors");
+    if (selectors.some((selector) => !selector.startsWith("aku/") && !selector.startsWith("@")) &&
+        coordinates.repo === undefined)
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    const named = selectors.some((selector) => selector.startsWith("@"))
+        ? await observeKanshi({
+            world: coordinates.world,
+            ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+        })
+        : undefined;
+    const values = [];
+    const blocks = [];
+    for (const selector of selectors) {
+        const resolved = selector.startsWith("aku/")
+            ? await readAkumaStatus(selector, undefined, coordinates)
+            : selector.startsWith("@")
+                ? await namedStatus(selector, coordinates, named)
+                : await readContractStatus(selector, coordinates, named);
+        values.push(resolved.value);
+        if (command.output === "text")
+            blocks.push(resolved.project());
+    }
+    if (command.output === "json")
+        writeJson(values);
+    else
+        writeStdout(blocks.join("\n\n"));
+    return 0;
+}
+async function runStatus(command, coordinates) {
+    if (command.guidance === true)
+        return await runStatusGuidance(command, coordinates);
+    if ("selectors" in command && command.selectors !== undefined)
+        return await runStatusSelection({ ...command, selectors: command.selectors }, coordinates);
+    if (command.akuma === true && command.contract !== undefined) {
+        const resolved = await readAkumaStatus(command.contract, undefined, coordinates);
+        if (command.output === "json")
+            writeJson(resolved.value);
+        else
+            writeStdout(resolved.project());
+        return 0;
+    }
+    if (command.contract === undefined) {
+        const report = await kanshi({
+            world: coordinates.world,
+            ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+        });
+        if (command.output === "json")
+            writeJson(report);
+        else
+            writeStdout(renderKanshiText(report, displayContext(), "world"));
+        return 0;
+    }
+    if (command.contract.startsWith("@")) {
+        const resolved = await namedStatus(command.contract, coordinates, await observeKanshi({
+            world: coordinates.world,
+            ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+        }));
+        if (command.output === "json")
+            writeJson(resolved.value);
+        else
+            writeStdout(resolved.project());
+        return 0;
+    }
+    if (command.contract.startsWith("kei/")) {
+        const repo = requiredRepo(coordinates);
+        const contract = canonicalContractSelector(command.contract);
+        const report = await kanshi({ world: coordinates.world, repo, contract });
+        if (report.contracts.kind === "present" && report.contracts.value.rows.length === 0) {
+            if (command.output === "json")
+                writeJson(statusRefusal("status", contract).refusal);
+            else
+                writeStdout(renderRefusal(statusRefusal("status", contract), undefined, displayContext()));
+            return 1;
         }
-        case "nuke": {
-            const confirm = optionalFlag(parts.flags, "confirm");
-            return { command: "nuke", ...(confirm === undefined ? {} : { confirm }), output: parts.output };
+        if (command.output === "json")
+            writeJson(report);
+        else
+            writeStdout(renderKanshiText(report, displayContext(), "contract"));
+        return 0;
+    }
+    const report = await kanshi({
+        world: coordinates.world,
+        ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+    });
+    const contract = resolveKanshiContract(report, command.contract);
+    const selected = selectKanshi({ report, contract });
+    if (command.output === "json")
+        writeJson(selected);
+    else
+        writeStdout(renderKanshiText(selected, displayContext(), "contract"));
+    return 0;
+}
+async function runRegion(command, coordinates) {
+    const repo = requiredRepo(coordinates);
+    const emit = (section) => {
+        if (command.output === "json")
+            writeJson(section);
+        else
+            writeStdout(renderRegionText(section));
+        return 0;
+    };
+    if (command.paths !== undefined) {
+        const report = await kanshi({ world: coordinates.world, repo, region: { kind: "path", patterns: command.paths } });
+        return emit(report.region ?? { kind: "absent" });
+    }
+    const report = await kanshi({ world: coordinates.world, repo, region: { kind: "declarations" } });
+    if (command.contract === undefined)
+        return emit(report.region ?? { kind: "absent" });
+    const contract = resolveKanshiContract(report, command.contract);
+    const observed = await observeKeiyaku({ repo, id: contract });
+    if (observed.kind === "missing" || observed.row.phase === "claimed" || observed.row.phase === "abandoned") {
+        const refusal = {
+            kind: observed.kind === "missing" ? "contract-missing" : "terminal",
+            contractId: contract,
+        };
+        if (command.output === "json")
+            writeJson(refusal);
+        else
+            writeStdout(renderRefusal({ operation: "region", contract, refusal }, undefined, displayContext()));
+        return 1;
+    }
+    if (report.region?.kind !== "present" || report.region.value.kind !== "declarations")
+        return emit(report.region ?? { kind: "absent" });
+    return emit({
+        kind: "present",
+        value: selectRegion({
+            declarations: report.region.value.declarations,
+            selection: { kind: "contract", contract },
+        }),
+    });
+}
+export async function runContractHistoryCommand(command, coordinates) {
+    const repo = requiredRepo(coordinates);
+    const selected = contractFromInput(repo, command.contract);
+    const history = await selected.contract.history();
+    if (history === null) {
+        const refusal = { kind: "contract-missing", contractId: selected.id };
+        if (command.output === "json")
+            writeJson(refusal);
+        else
+            writeStdout(renderRefusal({ operation: "history", contract: selected.id, refusal }, undefined, displayContext()));
+        return 1;
+    }
+    if (command.output === "json")
+        writeJson(history);
+    else
+        writeStdout(renderContractHistory(history, { full: command.full }));
+    return 0;
+}
+async function runReconcile(command, coordinates, execution, home) {
+    const repo = requiredRepo(coordinates);
+    const configuration = await contractSettings(command, execution, coordinates.world, home);
+    const library = composeContractLibrary(execution, createKeiyakuHandle, {
+        ...(configuration === undefined ? {} : { settings: configuration }),
+    });
+    let report;
+    if (command.contract === undefined) {
+        report = await library.reconcile({ repo, retryHooks: command.retryHooks });
+    }
+    else {
+        const selected = await selectedContract(repo, command.contract, coordinates.cwd);
+        const observed = await observeKeiyaku({ repo, id: selected.id });
+        if (observed.kind === "missing") {
+            if (command.output === "json")
+                writeJson(statusRefusal("reconcile", selected.id).refusal);
+            else
+                writeStdout(renderRefusal(statusRefusal("reconcile", selected.id), undefined, displayContext()));
+            return 1;
         }
+        report = await library.reconcile({ repo, contract: selected.id, retryHooks: command.retryHooks });
+    }
+    if (command.output === "json")
+        writeJson(report);
+    else
+        writeStdout(renderReconcile(report, displayContext()));
+    return reconcileHasFailure(report) ? 1 : 0;
+}
+export async function runContractCommand(command, coordinates, runtime) {
+    const execution = runtime.execution;
+    const home = runtime.home;
+    switch (command.command) {
         case "settings":
-            return { command: "settings", output: parts.output };
+            return await runSettings(coordinates, home, command.output);
+        case "nuke":
+            return await runNuke(command, coordinates);
+        case "ls":
+            return await runLs(command, coordinates, home);
+        case "status":
+            return await runStatus(command, coordinates);
         case "region":
-            return parseRegion(parts);
+            return await runRegion(command, coordinates);
+        case "reconcile":
+            return await runReconcile(command, coordinates, execution, home);
+        default: {
+            const configuration = await contractSettings(command, execution, coordinates.world, home);
+            return await runContractMutation(command, {
+                coordinates,
+                runtime,
+                execution,
+                ...(configuration === undefined ? {} : { configuration }),
+            });
+        }
     }
 }