@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,14 +1,38 @@
-import type { TaskInvocationResult } from "./commands/task-invoke.js";
-import type { ParsedCommand, ParsedExecution } from "./parse.js";
-import type { ExecutionEvent } from "../library/execution.js";
-export declare function writeExecutionProgress(events: AsyncIterable<ExecutionEvent>, stream?: NodeJS.WritableStream): Promise<void>;
-export declare function writeTask(command: Extract<ParsedCommand, {
-    command: "task";
-}>, result: TaskInvocationResult): Promise<number>;
+import { type LibraryExecution } from "../akuma/requests.js";
+import type { ActorId } from "../index.js";
+import type { ExecutionObserver } from "../protocol/execution-observation.js";
+import { type ParsedCommand, type ParsedInvocation } from "./parse.js";
+export type ParsedCommandInvocation = Extract<ParsedInvocation, {
+    command: ParsedCommand;
+}>;
+type ExecutionProgressDriver = Readonly<{
+    observe: ExecutionObserver;
+    finish: () => Promise<void>;
+}>;
+/** Everything one invocation's leaves need at the process edge; Product JSON never sees this. */
+export type CliRuntime = Readonly<{
+    environment: NodeJS.ProcessEnv;
+    execution: LibraryExecution;
+    home?: string;
+    readStdin: () => Promise<string>;
+    signal: AbortSignal;
+    progress: () => Promise<ExecutionProgressDriver>;
+    actor?: ActorId;
+}>;
+export type CliRuntimeInput = Readonly<{
+    cwd?: string;
+    environment?: NodeJS.ProcessEnv;
+    readStdin?: () => Promise<string>;
+    actor?: ActorId;
+    signal?: AbortSignal;
+}>;
+/** Builds the one live progress observer for an invocation; the leaf owns when it finishes. */
+export declare function writeExecutionProgress(stream?: NodeJS.WritableStream): Promise<ExecutionProgressDriver>;
 type AkumaFailureProjection = Readonly<{
     body: string;
     exitCode: 1 | 3;
 }>;
+/** Projection of one native Akuma addressing/observation failure into its stated refusal body. */
 export declare function akumaFailureProjection(error: unknown, command: ParsedCommand): Promise<AkumaFailureProjection | undefined>;
-export declare function runCliCommand(invocation: ParsedExecution): Promise<number>;
+export declare function runCliCommand(invocation: ParsedCommandInvocation, input?: CliRuntimeInput): Promise<number>;
 export {};

package/build/src/cli/runtime.js

@@ -1,14 +1,46 @@
-import { isParsedAkumaCommand } from "./commands/akuma.js";
-import { CliUsageError, usageGuideForCommand } from "./parse.js";
-import { renderUsageMessage } from "./usage.js";
+import { AkumaNotBornError, AkumaObservationError } from "../akuma/akuma-errors.js";
+import { AkumaArchetypeError } from "../akuma/archetype.js";
+import { AKUMA_REQUESTS_ENV } from "../akuma/provider.js";
+import { bodyRequestExecution, localExecutionContext } from "../akuma/requests.js";
+import { AkumaAddressError, AkumaWorldScopeError } from "../library/address.js";
+import { encodeFailureWire, KeiyakuError } from "../library/outcome.js";
+import { isParsedAkumaCommand, runAkumaCommand } from "./commands/akuma.js";
+import { admitBindMarkdown, runContractCommand, runContractHistoryCommand } from "./commands/contract.js";
+import { installExitCode, installHarnesses, renderInstallText, } from "./commands/install.js";
+import { runTaskCommand } from "./commands/task.js";
+import { resolveInvocationCoordinates } from "./coordinates.js";
+import { BindDraftError } from "./draft.js";
+import { assertExplicitRepoUse, CliUsageError, usageGuideForCommand, } from "./parse.js";
+import { createExecutionProgressRenderer } from "./render/execution-progress.js";
+import { executionFailureLines } from "./render/receipt.js";
+import { renderRefusal, renderStructuredRefusal } from "./render/refusal.js";
 import { DEFAULT_CLI_COLUMNS, safeText } from "./render/terminal.js";
-function writeCliStream(stream, body) {
-    stream.write(body.endsWith("\n") ? body : `${body}\n`);
+import { displayContext, writeJson, writeStderr, writeStdout } from "./streams.js";
+function processStdin() {
+    return (async () => {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        return Buffer.concat(chunks).toString("utf8");
+    })();
 }
-export async function writeExecutionProgress(events, stream = process.stderr) {
-    const { renderExecutionProgress } = await import("./render/execution-progress.js");
+function memoized(reader) {
+    let value;
+    return () => (value ??= reader());
+}
+function executionForEnvironment(environment) {
+    return environment[AKUMA_REQUESTS_ENV] === undefined
+        ? localExecutionContext()
+        : bodyRequestExecution({ directory: environment[AKUMA_REQUESTS_ENV] });
+}
+function homeFromEnvironment(environment) {
+    const mapped = environment.KEIYAKU_HOME?.trim();
+    return mapped === undefined || mapped.length === 0 ? undefined : mapped;
+}
+/** Builds the one live progress observer for an invocation; the leaf owns when it finishes. */
+export async function writeExecutionProgress(stream = process.stderr) {
     const terminal = stream;
-    await renderExecutionProgress(events, {
+    const renderer = createExecutionProgressRenderer({
         stream: terminal,
         context: {
             columns: terminal.isTTY === true && Number.isInteger(terminal.columns)
@@ -17,8 +49,11 @@ export async function writeExecutionProgress(events, stream = process.stderr) {
             color: false,
         },
     });
+    return { observe: (event) => renderer.observe(event), finish: () => renderer.finish() };
 }
-function cliCancellation() {
+function cliCancellation(signal) {
+    if (signal !== undefined)
+        return { signal, close: () => undefined };
     const controller = new AbortController();
     const cancel = () => controller.abort(new Error("CLI cancellation requested"));
     process.once("SIGINT", cancel);
@@ -31,133 +66,48 @@ function cliCancellation() {
         },
     };
 }
-export async function writeTask(command, result) {
-    const { renderTaskIncompleteDiagnostic, renderTaskText, taskExitCode } = await import("./render/task.js");
-    const context = {
-        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns)
-            ? process.stdout.columns
-            : DEFAULT_CLI_COLUMNS,
-        color: false,
-    };
-    if (command.output === "json")
-        writeCliStream(process.stdout, JSON.stringify(result));
-    else if (command.action === "compose" &&
-        typeof result === "object" &&
-        result !== null &&
-        "kind" in result &&
-        result.kind === "incomplete") {
-        const diagnostic = renderTaskIncompleteDiagnostic(result);
-        if (diagnostic.length > 0)
-            writeCliStream(process.stderr, diagnostic);
-        process.stdout.write(result.draft);
-    }
-    else
-        writeCliStream(process.stdout, renderTaskText(command, result, context));
-    return taskExitCode(result);
-}
-function displayContext() {
-    return {
-        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns)
-            ? process.stdout.columns
-            : DEFAULT_CLI_COLUMNS,
-        color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
-    };
+/** Bind's document admission runs before coordinate resolution so a malformed document refuses first. */
+async function admitBindInput(command, invocation, runtime, processCwd) {
+    if (command.command !== "bind" || command.forkOf !== undefined)
+        return;
+    await admitBindMarkdown({
+        markdown: await runtime.readStdin(),
+        processCwd,
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+    });
 }
-async function writeAkuma(command, result) {
-    const { renderAkumaJson, akumaExitCode, akumaRawAnswer, renderAkumaText } = await import("./render/akuma.js");
-    const output = command.output === "json" ? renderAkumaJson(result) : renderAkumaText(command, result, displayContext());
-    const exact = command.output === "text" &&
-        (akumaRawAnswer(result) !== undefined ||
-            (command.command === "history" && command.last && result.action === "history" && result.mode === "last"));
-    if (exact)
-        process.stdout.write(output);
+async function runInstall(command, environment) {
+    const result = await installHarnesses(command.harnesses, environment);
+    if (command.output === "json")
+        writeJson(result);
     else
-        writeCliStream(process.stdout, output);
-    return akumaExitCode(result);
-}
-function isAkumaOutput(command, result) {
-    if (isParsedAkumaCommand(command))
-        return true;
-    return (command.command === "status" &&
-        typeof result === "object" &&
-        result !== null &&
-        "kind" in result &&
-        result.kind === "akuma");
-}
-function invocationJson(result) {
-    switch (result.kind) {
-        case "guidance":
-            return { contract: result.contract, guidance: result.guidance };
-        case "catalog":
-            return result.catalog;
-        case "nuke":
-            return result.result;
-        case "region":
-            return result.region;
-        case "contract-history":
-            return result.history;
-        case "status":
-            return result.report;
-        case "status-set":
-            return result.entries;
-        default:
-            return result;
-    }
-}
-async function invocationExitCode(result) {
-    if (result.kind === "nuke")
-        return (await import("./render/nuke.js")).nukeExitCode(result.result);
-    if (result.kind === "observation") {
-        const { worldObservationFailureText } = await import("./render/board.js");
-        return worldObservationFailureText(result) === undefined ? 0 : 1;
-    }
-    return result.kind === "refused" ? 1 : result.kind === "retry" ? 2 : 0;
-}
-async function writeResult(command, result) {
-    if (command.command === "install") {
-        const { installExitCode, renderInstallText } = await import("./commands/install.js");
-        const value = result;
-        writeCliStream(process.stdout, command.output === "json" ? JSON.stringify(value) : renderInstallText(value));
-        return installExitCode(value);
-    }
-    if (command.command === "task")
-        return await writeTask(command, result);
-    if (command.command === "settings") {
-        const { renderSettingsText, settingsJsonValue } = await import("./render/settings.js");
-        const value = result.value;
-        writeCliStream(process.stdout, command.output === "json"
-            ? JSON.stringify(settingsJsonValue(value))
-            : renderSettingsText(value, displayContext().columns));
-        return 0;
-    }
-    if (isAkumaOutput(command, result))
-        return await writeAkuma(command, result);
-    const contractResult = result;
-    const { renderText } = await import("./render/text.js");
-    const json = command.output === "json";
-    const body = json ? JSON.stringify(invocationJson(contractResult)) : renderText(contractResult, displayContext());
-    writeCliStream(process.stdout, body);
-    return invocationExitCode(contractResult);
+        writeStdout(renderInstallText(result));
+    return installExitCode(result);
 }
+/** Projection of one native Akuma addressing/observation failure into its stated refusal body. */
 export async function akumaFailureProjection(error, command) {
-    const [{ AkumaNotBornError, AkumaObservationError }, { AkumaAddressError, AkumaWorldScopeError }] = await Promise.all([import("../akuma/akuma-errors.js"), import("../library/address.js")]);
     if (error instanceof AkumaNotBornError) {
         return {
-            body: command.output === "json" ? error.message : `× Akuma not found  ${safeText(error.id)}`,
+            body: command.output === "json"
+                ? error.message
+                : renderStructuredRefusal(command.command, "Akuma not found", [`id  ${safeText(error.id)}`], usageGuideForCommand(command)),
             exitCode: 1,
         };
     }
     if (error instanceof AkumaAddressError) {
         const body = error.refusal.kind === "akuma-alias-not-found"
-            ? `× Akuma alias not found  ${safeText(error.refusal.alias)}`
-            : `× invalid Akuma  ${safeText(error.refusal.selector)}`;
+            ? renderStructuredRefusal(command.command, "Akuma alias not found", [`alias  ${safeText(error.refusal.alias)}`], usageGuideForCommand(command))
+            : renderStructuredRefusal(command.command, "invalid Akuma address", [`selector  ${safeText(error.refusal.selector)}`], usageGuideForCommand(command));
         return { body: command.output === "json" ? error.message : body, exitCode: 1 };
     }
     if (error instanceof AkumaWorldScopeError) {
         return {
             body: command.output === "json"
                 ? JSON.stringify(error.refusal)
-                : error.refusal.ids.map((id) => `× Akuma not in this World  ${safeText(id)}`).join("\n"),
+                : renderStructuredRefusal(command.command, "Akuma not in this World", [
+                    `ids  ${error.refusal.ids.map((id) => safeText(id)).join(" · ")}`,
+                    `world  ${safeText(error.refusal.world)}`,
+                ], usageGuideForCommand(command)),
             exitCode: 1,
         };
     }
@@ -175,60 +125,102 @@ async function commandFailureText(error, command) {
     const diagnostic = error instanceof Error ? error.message : String(error);
     if (command.output === "json" || error instanceof CliUsageError)
         return diagnostic;
-    const { KeiyakuRefused } = await import("../library/refusal.js");
-    if (error instanceof KeiyakuRefused) {
-        if (error.refusal.kind === "contract-missing") {
-            return renderUsageMessage(diagnostic, {
-                ...usageGuideForCommand(command),
-                given: error.refusal.contractId,
-            }, "selector");
+    if (error instanceof AkumaArchetypeError) {
+        if (command.command === "call") {
+            return renderStructuredRefusal("call", `Akuma not found · ${safeText(error.archetype)}`, ["available  keiyaku ls aku/"], usageGuideForCommand(command));
+        }
+        return `× ${command.command} failed\n  reason  ${safeText(error.message)}`;
+    }
+    return `× ${command.command} failed\n  reason  ${safeText(diagnostic)}`;
+}
+function writeBindDraftFailure(error, command) {
+    const refusal = {
+        kind: "invalid-document",
+        diagnostic: error.original instanceof Error ? error.original.message : String(error.original),
+    };
+    if (command.output === "json")
+        writeJson({ kind: "refused", operation: "bind", refusal, draft: error.draft });
+    else
+        writeStdout(renderRefusal({ operation: "bind", refusal }, error.draft, displayContext()));
+    return error.original instanceof CliUsageError ? 64 : 1;
+}
+async function writeFailure(error, command) {
+    if (error instanceof BindDraftError)
+        return writeBindDraftFailure(error, command);
+    if (error instanceof KeiyakuError) {
+        const diagnostic = error.message;
+        if (command.output === "json")
+            writeJson(encodeFailureWire(error));
+        else if (error.outcome !== undefined) {
+            writeStdout(executionFailureLines(error.outcome, error.category, diagnostic, displayContext().columns).join("\n"));
         }
-        const { renderRefusalFacts } = await import("./render/refusal.js");
-        return [`× ${command.command} refused`, ...renderRefusalFacts(error.refusal, "  ", displayContext().columns)].join("\n");
+        else
+            writeStderr(`× ${command.command} failed\n  reason  ${safeText(diagnostic)}`);
+        return 3;
+    }
+    const akumaFailure = await akumaFailureProjection(error, command);
+    if (akumaFailure !== undefined) {
+        writeStderr(akumaFailure.body);
+        return akumaFailure.exitCode;
     }
-    return `× ${command.command} failed\n  diagnostic  ${safeText(diagnostic)}`;
+    if (error instanceof AkumaArchetypeError && command.command === "call") {
+        if (command.output === "json")
+            writeJson({
+                kind: "refused",
+                diagnostic: "Akuma not found",
+                archetype: error.archetype,
+                available: "keiyaku ls aku/",
+            });
+        else
+            writeStdout(renderStructuredRefusal("call", `Akuma not found · ${safeText(error.archetype)}`, ["available  keiyaku ls aku/"], usageGuideForCommand(command)));
+        return 1;
+    }
+    if (command.output === "json")
+        writeJson(encodeFailureWire(error));
+    else
+        writeStderr(await commandFailureText(error, command));
+    return error instanceof CliUsageError ? 64 : 3;
 }
-export async function runCliCommand(invocation) {
+export async function runCliCommand(invocation, input = {}) {
     const command = invocation.command;
-    const cancellation = cliCancellation();
+    assertExplicitRepoUse(command, invocation.repo);
+    const environment = input.environment ?? process.env;
+    const home = homeFromEnvironment(environment);
+    const cancellation = cliCancellation(input.signal);
+    let progress;
+    const runtime = {
+        environment,
+        execution: executionForEnvironment(environment),
+        ...(home === undefined ? {} : { home }),
+        readStdin: memoized(input.readStdin ?? processStdin),
+        signal: cancellation.signal,
+        progress: () => (progress ??= writeExecutionProgress()),
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    };
     try {
-        const { invoke } = await import("./invoke.js");
-        const result = await invoke(invocation, {
-            cwd: process.cwd(),
-            signal: cancellation.signal,
-            progress: writeExecutionProgress,
-        });
-        return await writeResult(command, result);
+        if (command.command === "install")
+            return await runInstall(command, environment);
+        await admitBindInput(command, invocation, runtime, input.cwd ?? process.cwd());
+        const coordinates = await resolveInvocationCoordinates({
+            processCwd: input.cwd ?? process.cwd(),
+            ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+            ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+            ...(invocation.workdir === undefined ? {} : { workdir: invocation.workdir }),
+            command,
+        }, environment);
+        if (command.command === "task")
+            return await runTaskCommand(command, coordinates, runtime);
+        if (isParsedAkumaCommand(command))
+            return await runAkumaCommand(command, coordinates, invocation.workdir, runtime);
+        if (command.command === "history" && "contract" in command)
+            return await runContractHistoryCommand(command, coordinates);
+        return await runContractCommand(command, coordinates, runtime);
     }
     catch (error) {
-        const { executionReceipt } = await import("../library/execution-result.js");
-        const receipt = executionReceipt(error);
-        if (receipt !== undefined) {
-            const diagnostic = error instanceof Error ? error.message : String(error);
-            const { postAdmissionFailureCategory } = await import("../library/refusal.js");
-            const category = postAdmissionFailureCategory(error);
-            const { executionFailureLines } = await import("./render/receipt.js");
-            writeCliStream(process.stdout, command.output === "json"
-                ? JSON.stringify({ kind: "execution-failed", category, diagnostic, receipt })
-                : executionFailureLines(receipt, category, diagnostic, displayContext().columns).join("\n"));
-            return 3;
-        }
-        const akumaFailure = await akumaFailureProjection(error, command);
-        if (akumaFailure !== undefined) {
-            writeCliStream(process.stderr, akumaFailure.body);
-            return akumaFailure.exitCode;
-        }
-        if (command.command === "bind") {
-            const { BindDraftError } = await import("./draft.js");
-            if (error instanceof BindDraftError) {
-                writeCliStream(process.stderr, await commandFailureText(error.original, command));
-                const { renderBindDraftReceipt } = await import("./render/refusal.js");
-                writeCliStream(process.stderr, renderBindDraftReceipt(error.draft));
-                return error.original instanceof CliUsageError ? 1 : 3;
-            }
+        if (error instanceof CliUsageError && error.guide === undefined) {
+            throw new CliUsageError(error.diagnostic, usageGuideForCommand(command));
         }
-        writeCliStream(process.stderr, await commandFailureText(error, command));
-        return error instanceof CliUsageError ? 1 : 3;
+        return await writeFailure(error, command);
     }
     finally {
         cancellation.close();

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

@@ -1,11 +1,14 @@
-import { Keiyaku, type ContractBoard, type ContractId, type Repo } from "../index.js";
 import { type ExecutionContext } from "../akuma/requests.js";
+import type { ContractBoard, ContractId, Keiyaku, Repo } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
-export type SelectedContract = Readonly<{
+type SelectedContract = Readonly<{
     id: ContractId;
     contract: Keiyaku;
 }>;
 export declare function contractFromInput(repo: Repo, value: string, execution?: ExecutionContext): SelectedContract;
 export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
+/** Resolve one explicit, short, or worktree-contextual selector to its Contract id. */
+export declare function resolveContractId(repo: Repo, selector: string | undefined, scope: string): Promise<ContractId>;
 export declare function canonicalContractSelector(selector: string): ContractId;
 export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;
+export {};

package/build/src/cli/selectors.js

@@ -1,7 +1,8 @@
 import { resolve } from "node:path";
-import { identitySegments } from "../identity/coordinates.js";
-import { Keiyaku } from "../index.js";
 import { localExecutionContext } from "../akuma/requests.js";
+import { identitySegments } from "../identity/coordinates.js";
+import { composeContractLibrary } from "../library/contract-composition.js";
+import { createKeiyakuHandle } from "../library/keiyaku.js";
 import { CliUsageError } from "./parse.js";
 function selectorError(message) {
     throw new CliUsageError(message);
@@ -16,7 +17,7 @@ function activeManagedCandidates(rows) {
 export function contractFromInput(repo, value, execution = localExecutionContext()) {
     try {
         const id = value;
-        return { id, contract: Keiyaku.with({ execution }).select({ repo, id }) };
+        return { id, contract: composeContractLibrary(execution, createKeiyakuHandle).select({ repo, id }) };
     }
     catch (error) {
         selectorError(error instanceof Error ? error.message : String(error));
@@ -49,6 +50,13 @@ export function resolveContextualContract(board, selector, scope) {
         return resolveShortContract(board.rows, selector);
     return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
 }
+/** Resolve one explicit, short, or worktree-contextual selector to its Contract id. */
+export async function resolveContractId(repo, selector, scope) {
+    if (selector !== undefined && !selector.startsWith("@"))
+        return contractFromInput(repo, selector).id;
+    const { listKeiyaku } = await import("../library/contract-composition.js");
+    return resolveContextualContract(await listKeiyaku({ repo }), selector, scope);
+}
 export function canonicalContractSelector(selector) {
     try {
         identitySegments({ family: "kei", value: selector });

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

@@ -0,0 +1,11 @@
+import { type TextRenderContext } from "./render/terminal.js";
+/** Append one complete line to a process stream unless the body already ends with a newline. */
+export declare function writeCliStream(stream: NodeJS.WritableStream, body: string): void;
+export declare function writeStdout(body: string): void;
+export declare function writeStderr(body: string): void;
+/** The product-result presentation context, measured from the stream that carries the result. */
+export declare function displayContext(): TextRenderContext;
+/** The live-progress context, measured from stderr where activity rows are written. */
+export declare function resultContext(): TextRenderContext;
+/** One JSON product answer, verbatim from the native value. */
+export declare function writeJson(value: unknown): void;

package/build/src/cli/streams.js

@@ -0,0 +1,32 @@
+import { DEFAULT_CLI_COLUMNS } from "./render/terminal.js";
+/** Append one complete line to a process stream unless the body already ends with a newline. */
+export function writeCliStream(stream, body) {
+    stream.write(body.endsWith("\n") ? body : `${body}\n`);
+}
+export function writeStdout(body) {
+    writeCliStream(process.stdout, body);
+}
+export function writeStderr(body) {
+    writeCliStream(process.stderr, body);
+}
+/** The product-result presentation context, measured from the stream that carries the result. */
+export function displayContext() {
+    return {
+        columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns)
+            ? process.stdout.columns
+            : DEFAULT_CLI_COLUMNS,
+        color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+    };
+}
+/** The live-progress context, measured from stderr where activity rows are written. */
+export function resultContext() {
+    const tty = process.stderr.isTTY === true;
+    return {
+        columns: tty && Number.isInteger(process.stderr.columns) ? process.stderr.columns : DEFAULT_CLI_COLUMNS,
+        color: tty && process.env.NO_COLOR === undefined,
+    };
+}
+/** One JSON product answer, verbatim from the native value. */
+export function writeJson(value) {
+    writeStdout(JSON.stringify(value));
+}

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

@@ -11,6 +11,8 @@ export declare function acceptsFromUsage(usage: string): string;
 export declare function commandGuide(commandPath: string, usage: string): CliUsageGuide;
 export declare function unknownCommandGuide(guide: CliUsageGuide, given: string): CliUsageGuide;
 export declare function renderUsageMessage(diagnostic: string, guide?: CliUsageGuide, kind?: "usage" | "selector"): string;
+/** The acceptance grammar tail shared by usage and substantive refusals. */
+export declare function usageAcceptanceLines(guide: CliUsageGuide): readonly string[];
 export declare class CliUsageError extends Error {
     readonly diagnostic: string;
     readonly guide?: CliUsageGuide | undefined;

package/build/src/cli/usage.js

@@ -34,23 +34,27 @@ export function unknownCommandGuide(guide, given) {
 }
 export function renderUsageMessage(diagnostic, guide, kind = "usage") {
     if (guide === undefined) {
-        return `× ${kind}\n  diagnostic  ${diagnostic}`;
+        return `× ${kind}\n  reason  ${diagnostic}`;
     }
     const lines = [`× ${kind}  ${guide.scope}`];
     if (!guide.hideDiagnostic && diagnostic.length > 0) {
-        lines.push(`  diagnostic  ${diagnostic}`);
+        lines.push(`  reason  ${diagnostic}`);
     }
     if (guide.given !== undefined) {
         lines.push(`  given  ${guide.given}`);
     }
-    const accepts = guide.accepts.split("\n");
-    lines.push(`  accepts  ${accepts[0]}`);
-    for (const part of accepts.slice(1)) {
-        lines.push(`           ${part}`);
-    }
-    lines.push(`  help  ${guide.help}`);
+    lines.push(...usageAcceptanceLines(guide));
     return lines.join("\n");
 }
+/** The acceptance grammar tail shared by usage and substantive refusals. */
+export function usageAcceptanceLines(guide) {
+    const accepts = guide.accepts.split("\n");
+    return [
+        `  accepts  ${accepts[0]}`,
+        ...accepts.slice(1).map((part) => `           ${part}`),
+        `  help  ${guide.help}`,
+    ];
+}
 export class CliUsageError extends Error {
     diagnostic;
     guide;

package/build/src/contract-guidance.js

@@ -89,7 +89,7 @@ export const CONTRACT_REVIEWER_SKILL = [
     "",
     "`keiyaku review` records a verdict on the whole Contract.",
     "",
-    "Record `--satisfied` when you have verified two things and hold the evidence: the current worktree meets every Criterion, and the result actually achieves what the Objective set out to do. Criteria are the written checks; the Objective is the intent behind them — work that passes every check but misses the intent is not satisfied. If a delivered candidate, prerequisites, and all declared gates are in place, the Contract is claimed immediately and cannot be reopened.",
+    "Record `--satisfied` when you have verified two things and hold the evidence: the current worktree meets every Criterion, and the result actually achieves what the Objective set out to do. Criteria are the written checks; the Objective is the intent behind them — work that passes every check but misses the intent is not satisfied. If a delivered candidate, prerequisites, and all declared gates are in place, the Contract is accepted immediately and cannot be reopened.",
     "",
     "Record `--unsatisfied` when any Criterion is unmet, the work is incomplete, or the result does not achieve the Objective's intent — and state what is missing.",
     "",
@@ -117,13 +117,9 @@ function renderArc(arc) {
         "",
         arc.title.trimEnd(),
         "",
-        "### Objective",
+        "### Body",
         "",
-        arc.objective.trimEnd(),
-        "",
-        "### Brief",
-        "",
-        arc.brief.trimEnd(),
+        arc.body.replace(/^(?:\r?\n)+/u, "").trimEnd(),
     ].join("\n");
 }
 const FULFILLMENT = [

package/build/src/contract-worktree.d.ts

@@ -1,35 +1,27 @@
-import { type DerivedFileAction } from "./coordination/durable-file.js";
-import { type ContractId, type ContractState } from "./core/facts/types.js";
+import { z } from "zod";
+import { type ContractState } from "./core/facts/types.js";
 import { type GitRepository } from "./git/process.js";
 import { type PlaceRegister } from "./workspace-place.js";
-export type ContractAppointment = Readonly<{
-    kind: "absent";
-    path: string;
-}> | Readonly<{
-    kind: "appointed";
-    path: string;
-    contract: ContractId;
-}> | Readonly<{
-    kind: "invalid";
-    path: string;
-}>;
-export type ContractFileEffect = Readonly<{
-    kind: "contract-file";
-    path: string;
-    action: DerivedFileAction | "removed";
-}>;
-export type ContractFileLag = Readonly<{
-    kind: "contract-file-failed";
-    worktree: string;
-    path: string;
-    diagnostic: string;
-}>;
-export declare function decodeContractFileLag(value: unknown): ContractFileLag;
+export declare const contractFileEffectSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"contract-file">;
+    path: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        unchanged: "unchanged";
+        removed: "removed";
+    }>;
+}, z.core.$strict>;
+export type ContractFileEffect = z.infer<typeof contractFileEffectSchema>;
+export declare const contractFileLagSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"contract-file-failed">;
+    worktree: z.ZodString;
+    path: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>;
+export type ContractFileLag = z.infer<typeof contractFileLagSchema>;
 export type ContractWorktreeResult = Readonly<{
     effects: readonly ContractFileEffect[];
     lag: readonly ContractFileLag[];
 }>;
-export declare function readContractAppointment(repository: GitRepository): Promise<ContractAppointment>;
-export declare function withContractWorktreeAppointment<T>(repository: GitRepository, action: () => T | Promise<T>): Promise<T>;
-export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
 export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister, _onConflict?: (diagnostic: string) => never): Promise<ContractWorktreeResult>;