@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/cli/commands/contract-grammar.d.ts

@@ -44,7 +44,7 @@ export type ParsedDeliver = Output & Readonly<{
     materializeConflict: boolean;
     overwrite: boolean;
 }>;
-export type ParsedReview = Output & Readonly<{
+export type ParsedReview = Output & Actor & Readonly<{
     command: "review";
     contract?: string;
     verdict: "satisfied" | "unsatisfied";
@@ -66,11 +66,23 @@ export type ParsedStatus = Output & (Readonly<{
     selectors?: readonly string[];
     akuma?: never;
     guidance?: true;
+    category?: never;
+    limit?: never;
 }> | Readonly<{
     command: "status";
     contract: string;
     akuma: true;
     guidance?: never;
+    category?: never;
+    limit?: never;
+}> | Readonly<{
+    command: "status";
+    category: StatusCategory;
+    limit?: number;
+    contract?: never;
+    selectors?: never;
+    akuma?: never;
+    guidance?: never;
 }>);
 export type ParsedLs = Output & Readonly<{
     command: "ls";
@@ -108,5 +120,6 @@ export type ParsedContractParts = Readonly<{
     actor?: string;
 }>;
 export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
+export type StatusCategory = "akuma" | "contract";
 export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
 export {};

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

@@ -123,32 +123,65 @@ function parseReview(parts) {
         verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
         ...(summary === undefined ? {} : { summary }),
         ...(parts.stdin ? { summaryFromStdin: true } : {}),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         output: parts.output,
     };
 }
-function parseStatus(parts) {
-    const guidance = parts.flags.guidance === true;
-    if (guidance) {
-        const selected = parts.positionals[0];
-        if (parts.positionals.length > 1)
-            refuse("status", "--guidance accepts at most one Contract selector");
-        if (selected?.startsWith("aku/") === true)
-            refuse("status", "--guidance cannot select an Akuma");
-        return {
-            command: "status",
-            ...(selected === undefined ? {} : { contract: selected }),
-            guidance: true,
-            output: parts.output,
-        };
+// Only these fixed category forms are status selectors.
+const STATUS_CATEGORY_SELECTORS = new Map([
+    ["aku", "akuma"],
+    ["aku/", "akuma"],
+    ["aku/*", "akuma"],
+    ["kei", "contract"],
+    ["kei/", "contract"],
+    ["kei/*", "contract"],
+]);
+function rejectStatusGlobs(positionals) {
+    for (const selector of positionals) {
+        if (!STATUS_CATEGORY_SELECTORS.has(selector) && !selector.startsWith("@") && /[*?\[\]]/u.test(selector))
+            refuse("status", `unsupported status glob: ${selector}`);
     }
+}
+function parseStatusGuidance(parts, limit) {
+    if (limit !== undefined)
+        refuse("status", "--limit is not valid with --guidance");
+    const selected = parts.positionals[0];
+    if (selected !== undefined && STATUS_CATEGORY_SELECTORS.has(selected))
+        refuse("status", "--guidance cannot select a category");
+    if (parts.positionals.length > 1)
+        refuse("status", "--guidance accepts at most one Contract selector");
+    if (selected?.startsWith("aku/") === true)
+        refuse("status", "--guidance cannot select an Akuma");
+    if (selected !== undefined && !selected.startsWith("@") && /[*?\[\]]/u.test(selected))
+        refuse("status", `unsupported status glob: ${selected}`);
+    return {
+        command: "status",
+        ...(selected === undefined ? {} : { contract: selected }),
+        guidance: true,
+        output: parts.output,
+    };
+}
+function parseStatus(parts) {
+    const limit = listLimit(parts, "status");
+    if (parts.flags.guidance === true)
+        return parseStatusGuidance(parts, limit);
+    rejectStatusGlobs(parts.positionals);
     if (parts.positionals.length > 1) {
+        if (limit !== undefined)
+            refuse("status", "--limit is valid only for one category selector");
+        if (parts.positionals.some((selector) => STATUS_CATEGORY_SELECTORS.has(selector)))
+            refuse("status", "a category selector cannot combine with other selectors");
         return { command: "status", selectors: parts.positionals, output: parts.output };
     }
-    const contract = parts.positionals[0];
-    if (contract?.startsWith("aku/") === true) {
-        return { command: "status", contract, akuma: true, output: parts.output };
-    }
-    return { command: "status", ...(contract === undefined ? {} : { contract }), output: parts.output };
+    const selected = parts.positionals[0];
+    const category = selected === undefined ? undefined : STATUS_CATEGORY_SELECTORS.get(selected);
+    if (category !== undefined)
+        return { command: "status", category, ...(limit === undefined ? {} : { limit }), output: parts.output };
+    if (limit !== undefined)
+        refuse("status", "--limit is valid only for a category selector");
+    if (selected?.startsWith("aku/") === true)
+        return { command: "status", contract: selected, akuma: true, output: parts.output };
+    return { command: "status", ...(selected === undefined ? {} : { contract: selected }), output: parts.output };
 }
 function parseRegion(parts) {
     const contract = parts.positionals[0];
@@ -172,10 +205,10 @@ function akumaCatalogQuery(query, parts) {
         ...(limit === undefined ? {} : { limit: Number(limit) }),
     };
 }
-function listLimit(parts) {
+function listLimit(parts, command = "ls") {
     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");
+        refuse(command, "--limit requires a positive safe integer");
     return limit === undefined ? undefined : Number(limit);
 }
 function taskCatalogQuery(path, limit) {

package/build/src/cli/commands/contract-help.d.ts

@@ -1,8 +1,8 @@
-type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
+import type { ScanFlagKind } from "../scan.js";
 export type ContractCommandSpec = Readonly<{
     positional: "none" | "optional";
     stdin: "none" | "optional" | "required";
-    flags: Readonly<Record<string, ContractFlagKind>>;
+    flags: Readonly<Record<string, ScanFlagKind>>;
     usage: string;
     purpose: string;
     details?: string;
@@ -15,7 +15,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly actor: "value";
             readonly task: "value";
             readonly target: "value";
-            readonly after: "repeat-value";
+            readonly after: "repeat";
             readonly gates: "raw-value";
             readonly "fork-of": "value";
             readonly json: "boolean";
@@ -29,7 +29,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly stdin: "optional";
         readonly flags: {
             readonly actor: "value";
-            readonly after: "repeat-value";
+            readonly after: "repeat";
             readonly "clear-after": "boolean";
             readonly gates: "raw-value";
             readonly json: "boolean";
@@ -56,12 +56,13 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "optional";
         readonly flags: {
+            readonly actor: "value";
             readonly satisfied: "boolean";
             readonly unsatisfied: "boolean";
             readonly summary: "value";
             readonly json: "boolean";
         };
-        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -)";
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>]";
         readonly purpose: "Record whether a Contract meets its acceptance criteria.";
         readonly details: string;
     };
@@ -92,9 +93,10 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly stdin: "none";
         readonly flags: {
             readonly guidance: "boolean";
+            readonly limit: "value";
             readonly json: "boolean";
         };
-        readonly usage: "status [<contract>|@name|<aku/...>]...\nstatus --guidance [<contract>|@<contract>]";
+        readonly usage: "status [<contract>|@name|<aku/...>]...\nstatus (aku|aku/|aku/*) [--limit <count>]\nstatus (kei|kei/|kei/*) [--limit <count>]\nstatus --guidance [<contract>|@<contract>]";
         readonly purpose: "Show the world overview or selected Contract and Akuma status.";
         readonly details: string;
     };
@@ -156,7 +158,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
-            readonly path: "repeat-value";
+            readonly path: "repeat";
             readonly json: "boolean";
         };
         readonly usage: "region [<contract>]\nregion --path <pattern> [--path <pattern> ...]";
@@ -166,4 +168,3 @@ export declare const CONTRACT_COMMAND_SPECS: {
 };
 export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;
 export declare function renderContractHelp(command: ContractCommand): string;
-export {};

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

@@ -7,7 +7,7 @@ export const CONTRACT_COMMAND_SPECS = {
             actor: "value",
             task: "value",
             target: "value",
-            after: "repeat-value",
+            after: "repeat",
             gates: "raw-value",
             "fork-of": "value",
             json: "boolean",
@@ -47,6 +47,7 @@ export const CONTRACT_COMMAND_SPECS = {
             "A pattern containing whitespace binds with a warning. A fence carries no",
             "info string or exactly 'txt'.",
             "",
+            "Verification runs only with the verified gate; without it the section is inert text.",
             "Verification uses one or more closed bash, zsh, or pwsh fences. Its fence",
             "may add timeout=<integer><ms|s|m|h>; the section contains no other prose.",
             "Unknown ## sections are retained as extensions; reserved section names are refused.",
@@ -55,7 +56,7 @@ export const CONTRACT_COMMAND_SPECS = {
     amend: {
         positional: "optional",
         stdin: "optional",
-        flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "raw-value", json: "boolean" },
+        flags: { actor: "value", after: "repeat", "clear-after": "boolean", gates: "raw-value", json: "boolean" },
         usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [-]",
         purpose: "Change a Contract's document, prerequisites, or acceptance gates.",
         details: [
@@ -91,6 +92,7 @@ export const CONTRACT_COMMAND_SPECS = {
         purpose: "Submit work for a Contract and integrate it when its requirements are met.",
         details: [
             "The Contract, not the current Arc, sets what delivery must satisfy. An Arc records progress; it does not narrow acceptance.",
+            "With the verified gate, delivery runs Verification or reuses current satisfied evidence.",
             "Verification, integration, and cleanup progress appears on stderr; stdout contains one final result.",
             "By default, delivery uses HEAD. --include-dirty includes all non-ignored worktree changes, staged or not; it leaves your branch and index unchanged, so staging or committing is unnecessary.",
             "Repeating delivery with unchanged work resumes unfinished verification or integration. Changed work replaces the candidate.",
@@ -107,8 +109,8 @@ export const CONTRACT_COMMAND_SPECS = {
     review: {
         positional: "optional",
         stdin: "optional",
-        flags: { satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
-        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -)",
+        flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
+        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>]",
         purpose: "Record whether a Contract meets its acceptance criteria.",
         details: [
             "A review checks the whole Contract, not just one Arc. After delivery it checks the candidate; before delivery it checks the current Contract and worktree, but cannot integrate.",
@@ -141,12 +143,16 @@ export const CONTRACT_COMMAND_SPECS = {
     status: {
         positional: "optional",
         stdin: "none",
-        flags: { guidance: "boolean", json: "boolean" },
-        usage: "status [<contract>|@name|<aku/...>]...\nstatus --guidance [<contract>|@<contract>]",
+        flags: { guidance: "boolean", limit: "value", json: "boolean" },
+        usage: "status [<contract>|@name|<aku/...>]...\nstatus (aku|aku/|aku/*) [--limit <count>]\nstatus (kei|kei/|kei/*) [--limit <count>]\nstatus --guidance [<contract>|@<contract>]",
         purpose: "Show the world overview or selected Contract and Akuma status.",
         details: [
             "Akuma entries show the directory each Akuma was started in.",
             "",
+            "aku, aku/, and aku/* show the recent Akuma board; kei, kei/, and kei/* show the",
+            "recent active Contract board. --limit bounds the board to that many recent rows",
+            "(default 10). The Contract category requires a Repo; the Akuma category does not.",
+            "",
             "--guidance reads one Contract's guidance instead of status. It accepts one Contract",
             "selector or the installed Contract selection context, and refuses an Akuma, plural,",
             "or world selection before the read.",
@@ -173,6 +179,7 @@ export const CONTRACT_COMMAND_SPECS = {
         details: [
             "--include-dirty checks all non-ignored worktree changes, staged or not.",
             "--show-diff includes the proposed candidate diff when one can be prepared.",
+            "Verification runs only with the verified gate; without it the section is inert text.",
             "Content identity names the change's content hash, never a commit; it survives rebase and Git cannot look it up.",
             "Progress appears on stderr; stdout contains one final result.",
         ].join("\n"),
@@ -203,7 +210,7 @@ export const CONTRACT_COMMAND_SPECS = {
     region: {
         positional: "optional",
         stdin: "none",
-        flags: { path: "repeat-value", json: "boolean" },
+        flags: { path: "repeat", json: "boolean" },
         usage: "region [<contract>]\nregion --path <pattern> [--path <pattern> ...]",
         purpose: "Show declared Contract write patterns — all, one Contract's, or those overlapping given paths.",
         details: "Check overlap before starting parallel work.",

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

@@ -1,7 +1,7 @@
 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 { kanshi, kanshiCategory, 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";
@@ -14,14 +14,14 @@ 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 { renderKanshiCategoryText, 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 { displayContext, emit, writeJson, writeStdout } from "../streams.js";
 import { CliUsageError, isBlankInput } from "../usage.js";
 import { amendFromCommand } from "./amend.js";
 import { bindFromCommand } from "./bind.js";
@@ -120,11 +120,8 @@ function renderContractAnswer(answer, project, context) {
     }
 }
 async function finishContractAnswer(answer, output, project) {
-    if (output === "json")
-        writeJson(answer);
-    else
-        writeStdout(renderContractAnswer(answer, project, displayContext()));
-    return contractExitCode(answer);
+    const text = () => renderContractAnswer(answer, project, displayContext());
+    return emit(output, answer, text, contractExitCode(answer));
 }
 async function selectedContract(repo, selector, scope) {
     const id = await resolveContractId(repo, selector, scope);
@@ -187,11 +184,8 @@ async function runBind(command, input, library) {
         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;
+        const text = () => renderRefusal(refusedInvocation(answer), draft, displayContext());
+        return emit(command.output, answer, text, 1);
     }
     catch (error) {
         if (error instanceof Error && "executionReceipt" in error)
@@ -247,6 +241,7 @@ async function runReview(command, runtime, seat) {
         answer = await seat.contract.review({
             verdict: command.verdict,
             ...(summary === undefined ? {} : { summary }),
+            ...(seat.actor === undefined ? {} : { actor: seat.actor }),
             ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
         }, { ...(driver === undefined ? {} : { observe: driver.observe }) });
     }
@@ -265,11 +260,8 @@ async function runArc(command, runtime, seat) {
         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 refused = { kind: "refused", operation: "arc", contract: seat.id, refusal };
+        return emit(command.output, refused, () => renderRefusal(refused, undefined, displayContext()), 1);
     }
     const answer = await seat.contract.arc({
         markdown,
@@ -325,11 +317,7 @@ function statusRefusal(operation, 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;
+    return emit(output, settingsJsonValue(value), () => renderSettingsText(value, displayContext().columns), 0);
 }
 async function runNuke(command, coordinates) {
     if (coordinates.world === null)
@@ -338,11 +326,7 @@ async function runNuke(command, coordinates) {
         world: coordinates.world,
         ...(command.confirm === undefined ? {} : { confirm: command.confirm }),
     });
-    if (command.output === "json")
-        writeJson(result);
-    else
-        writeStdout(renderNukeText(result));
-    return nukeExitCode(result);
+    return emit(command.output, result, () => renderNukeText(result), nukeExitCode(result));
 }
 async function runLs(command, coordinates, home) {
     const query = command.query;
@@ -351,11 +335,7 @@ async function runLs(command, coordinates, home) {
             repo: requiredRepo(coordinates),
             ...(query.limit === undefined ? {} : { limit: query.limit }),
         });
-        if (command.output === "json")
-            writeJson(list);
-        else
-            writeStdout(renderContractCatalogue(list));
-        return 0;
+        return emit(command.output, list, () => renderContractCatalogue(list), 0);
     }
     if (query.kind === "archetypes") {
         const list = await listArchetypeDefinitions({
@@ -363,11 +343,7 @@ async function runLs(command, coordinates, home) {
             ...(query.limit === undefined ? {} : { limit: query.limit }),
             ...(home === undefined ? {} : { home }),
         });
-        if (command.output === "json")
-            writeJson(list);
-        else
-            writeStdout(renderArchetypeCatalogue(list));
-        return 0;
+        return emit(command.output, list, () => renderArchetypeCatalogue(list), 0);
     }
     if (coordinates.world === null)
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
@@ -379,21 +355,13 @@ async function runLs(command, coordinates, home) {
         });
         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;
+        return emit(command.output, listed, () => renderTaskCatalogue(listed.value, query.namespace ?? []), 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;
+    return emit(command.output, listed, () => renderAkumaCatalogue(listed, query.archetype ?? null), 0);
 }
 async function readAkumaStatus(akuma, alias, coordinates) {
     if (coordinates.world === null)
@@ -437,17 +405,10 @@ async function runStatusGuidance(command, coordinates) {
     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;
+        const refusal = statusRefusal("status", selected.id);
+        return emit(command.output, null, () => renderRefusal(refusal, undefined, displayContext()), 1);
     }
-    if (command.output === "json")
-        writeJson(guidance);
-    else
-        writeStdout(guidance);
-    return 0;
+    return emit(command.output, guidance, () => guidance, 0);
 }
 async function runStatusSelection(command, coordinates) {
     const selectors = command.selectors;
@@ -474,63 +435,43 @@ async function runStatusSelection(command, coordinates) {
         if (command.output === "text")
             blocks.push(resolved.project());
     }
-    if (command.output === "json")
-        writeJson(values);
-    else
-        writeStdout(blocks.join("\n\n"));
-    return 0;
+    return emit(command.output, values, () => blocks.join("\n\n"), 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;
-    }
+async function runStatusCategory(command, coordinates) {
+    if (command.category === "contract")
+        requiredRepo(coordinates);
+    const report = await kanshiCategory({
+        world: coordinates.world,
+        ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
+        category: command.category,
+        ...(command.limit === undefined ? {} : { limit: command.limit }),
+    });
+    return emit(command.output, report, () => renderKanshiCategoryText(report, displayContext()), 0);
+}
+async function runStatusIdentity(command, coordinates) {
     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;
+        return emit(command.output, report, () => renderKanshiText(report, displayContext(), "world"), 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;
+        return emit(command.output, resolved.value, () => resolved.project(), 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;
+            const refusal = statusRefusal("status", contract);
+            return emit(command.output, refusal.refusal, () => renderRefusal(refusal, undefined, displayContext()), 1);
         }
-        if (command.output === "json")
-            writeJson(report);
-        else
-            writeStdout(renderKanshiText(report, displayContext(), "contract"));
-        return 0;
+        return emit(command.output, report, () => renderKanshiText(report, displayContext(), "contract"), 0);
     }
     const report = await kanshi({
         world: coordinates.world,
@@ -538,28 +479,31 @@ async function runStatus(command, coordinates) {
     });
     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;
+    return emit(command.output, selected, () => renderKanshiText(selected, displayContext(), "contract"), 0);
+}
+async function runStatus(command, coordinates) {
+    if (command.guidance === true)
+        return await runStatusGuidance(command, coordinates);
+    if (command.category !== undefined)
+        return await runStatusCategory(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);
+        return emit(command.output, resolved.value, () => resolved.project(), 0);
+    }
+    return await runStatusIdentity(command, coordinates);
 }
 async function runRegion(command, coordinates) {
     const repo = requiredRepo(coordinates);
-    const emit = (section) => {
-        if (command.output === "json")
-            writeJson(section);
-        else
-            writeStdout(renderRegionText(section));
-        return 0;
-    };
+    const emitSection = (section) => emit(command.output, section, () => renderRegionText(section), 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" });
+        return emitSection(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" });
+        return emitSection(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") {
@@ -574,8 +518,8 @@ async function runRegion(command, coordinates) {
         return 1;
     }
     if (report.region?.kind !== "present" || report.region.value.kind !== "declarations")
-        return emit(report.region ?? { kind: "absent" });
-    return emit({
+        return emitSection(report.region ?? { kind: "absent" });
+    return emitSection({
         kind: "present",
         value: selectRegion({
             declarations: report.region.value.declarations,
@@ -595,11 +539,7 @@ export async function runContractHistoryCommand(command, coordinates) {
             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;
+    return emit(command.output, history, () => renderContractHistory(history, { full: command.full }), 0);
 }
 async function runReconcile(command, coordinates, execution, home) {
     const repo = requiredRepo(coordinates);

package/build/src/cli/commands/install.d.ts

@@ -1,12 +1,12 @@
 import type { ProcessInput, ProcessOutcome } from "../../runtime/proc/run.js";
-export declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
-export type HarnessName = (typeof HARNESS_NAMES)[number];
+declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
+type HarnessName = (typeof HARNESS_NAMES)[number];
 export type ParsedInstallCommand = Readonly<{
     command: "install";
     harnesses: readonly HarnessName[];
     output: "text" | "json";
 }>;
-export type HarnessInstallResult = Readonly<{
+type HarnessInstallResult = Readonly<{
     harness: HarnessName;
     status: "installed" | "failed";
     diagnostic?: string;
@@ -15,12 +15,12 @@ export type InstallInvocationResult = Readonly<{
     kind: "install";
     results: readonly HarnessInstallResult[];
 }>;
-export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
+type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
 export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
 export declare const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
 export declare function renderInstallHelp(): string;
-export declare function installAssetsRoot(): string;
 export declare function installHarnesses(harnesses: readonly HarnessName[], environment: NodeJS.ProcessEnv, runner?: InstallRunner): Promise<InstallInvocationResult>;
 export declare function renderInstallText(result: InstallInvocationResult): string;
 export declare function installExitCode(result: InstallInvocationResult): number;
+export {};