@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/cli/accepted.js

@@ -1,48 +1,86 @@
 import { KeiyakuRefused, KeiyakuRetry, } from "../index.js";
-function hasOverlaps(value) {
-    return "overlaps" in value;
+function acceptedFacts(result) {
+    return result.facts.map((fact) => ({
+        contract: fact.contract,
+        entry: fact.entry,
+        kind: fact.kind,
+    }));
 }
-function hasOverlapFailure(value) {
-    return "overlapFailure" in value;
-}
-function hasDocumentDiff(value) {
-    return "documentDiff" in value && typeof value.documentDiff === "string";
-}
-function resultFromMutation(verb, result, options) {
-    const acceptedContract = options.coordinate ?? result.facts[0]?.contract;
-    if (acceptedContract === undefined)
+function acceptedEnvelope(result, coordinate) {
+    const contract = coordinate ?? result.facts[0]?.contract;
+    if (contract === undefined)
         throw new Error("accepted mutation is missing its contract identity");
+    const firstLag = result.lags[0];
     return {
         kind: "accepted",
-        verb,
-        contract: acceptedContract,
+        contract,
         head: result.head,
-        facts: result.facts.map((fact) => ({
-            contract: fact.contract,
-            entry: fact.entry,
-            kind: fact.kind,
-        })),
+        facts: acceptedFacts(result),
         effects: result.effects,
         settlement: result.settlement,
-        ...(options.target === undefined ? {} : { target: options.target }),
-        ...options.obligations,
-        ...(hasOverlaps(result) ? { overlaps: result.overlaps } : {}),
-        ...(hasOverlapFailure(result) ? { overlapFailure: result.overlapFailure } : {}),
-        ...(hasDocumentDiff(result) ? { diff: result.documentDiff } : {}),
-        ...(options.report === undefined ? {} : { report: options.report }),
-        ...(options.workspace === undefined ? {} : { workspace: options.workspace }),
-        ...(options.diff === undefined ? {} : { diff: options.diff }),
-        ...(result.lags.length === 0 ? {} : { lag: result.lags }),
+        ...(result.lags.length === 0 || firstLag === undefined ? {} : { lag: [firstLag, ...result.lags.slice(1)] }),
+    };
+}
+function acceptedRegion(result) {
+    if (result.overlapFailure !== undefined)
+        return { overlapFailure: result.overlapFailure };
+    return { overlaps: result.overlaps };
+}
+export function acceptedBind(result, target) {
+    return {
+        ...acceptedEnvelope(result, undefined),
+        verb: "bind",
+        target,
+        ...acceptedRegion(result),
+    };
+}
+export function acceptedAmend(result, coordinate) {
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "amend",
+        diff: result.documentDiff,
+        ...acceptedRegion(result),
+    };
+}
+export function acceptedDeliver(result, coordinate) {
+    const value = result.value;
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "deliver",
+        ...(value.verification === undefined ? {} : { verification: value.verification }),
+        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
+        ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
+        ...(value.leak === undefined ? {} : { leak: value.leak }),
+    };
+}
+export function acceptedReview(result, coordinate) {
+    const value = result.value;
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "review",
+        ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+    };
+}
+export function acceptedArc(result, coordinate) {
+    return { ...acceptedEnvelope(result, coordinate), verb: "arc" };
+}
+export function acceptedAbandon(result, coordinate) {
+    return { ...acceptedEnvelope(result, coordinate), verb: "abandon" };
+}
+export function acceptedAudit(result, coordinate) {
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "audit",
+        report: result.value,
+        ...(result.cleanup === undefined ? {} : { cleanup: result.cleanup }),
+        ...(result.leak === undefined ? {} : { leak: result.leak }),
     };
 }
-export async function resultFromMutationCall(verb, call, options = {}) {
+export async function resultFromMutationCall(verb, call, project, options = {}) {
     try {
-        const result = await call();
-        const projected = options.project === undefined ? {} : await options.project(result);
-        return resultFromMutation(verb, result, {
-            ...projected,
-            ...(options.coordinate === undefined ? {} : { coordinate: options.coordinate }),
-        });
+        return project(await call());
     }
     catch (error) {
         if (error instanceof KeiyakuRefused) {

package/build/src/cli/actor.js

@@ -1,4 +1,4 @@
-const PROJECTION_ID_ENV = "KEIYAKU_PROJECTION_ID";
+const ACTOR_ID_ENV = "KEIYAKU_ACTOR_ID";
 /** Resolve optional caller testimony from the current CLI edge vocabulary. */
 export function resolveActor(input = {}) {
     if (input.actor !== undefined) {
@@ -6,6 +6,6 @@ export function resolveActor(input = {}) {
             throw new TypeError("actor must be a nonblank string");
         return input.actor;
     }
-    const projectionId = input.env?.[PROJECTION_ID_ENV];
-    return projectionId !== undefined && projectionId.trim().length > 0 ? projectionId : undefined;
+    const actorId = input.env?.[ACTOR_ID_ENV];
+    return actorId !== undefined && actorId.trim().length > 0 ? actorId : undefined;
 }

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -7,6 +7,7 @@ export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
     result: CallResult;
+    world: WorldRoot;
 }> | Readonly<{
     kind: "akuma";
     action: "status";
@@ -66,12 +67,12 @@ export type AkumaInvocationResult = Readonly<{
 }>;
 type InvokeInput = Readonly<{
     path: WorldRoot;
-    executionCwd: string;
+    executionCwd?: string;
     settings: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
-    readStdin(): string;
+    readStdin(): Promise<string>;
 }>;
 export declare function invokeAkuma(command: ParsedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
-export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, settings: Settings, alias?: string, repo?: Repo): AkumaInvocationResult;
+export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, settings: Settings, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
 export {};

package/build/src/cli/commands/akuma-invoke.js

@@ -2,6 +2,9 @@ import { Keiyaku, } from "../../index.js";
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
+async function promptBody(command, input) {
+    return command.prompt.kind === "stdin" ? await input.readStdin() : command.prompt.value;
+}
 async function invokeWait(command, input) {
     const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
     return {
@@ -19,7 +22,7 @@ async function invokeWait(command, input) {
     };
 }
 async function invokeTell(command, input) {
-    const body = input.readStdin();
+    const body = await promptBody(command, input);
     if (command.interrupt) {
         const result = await Keiyaku.interrupt({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
         const alias = inputAlias(command.akuma);
@@ -29,14 +32,15 @@ async function invokeTell(command, input) {
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
 }
-function invokeHistory(command, input) {
-    const result = Keiyaku.history({
+async function invokeHistory(command, input) {
+    const result = await Keiyaku.history({
         path: input.path,
         akuma: command.akuma,
         settings: input.settings,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(command.before === undefined ? {} : { before: command.before }),
         ...(command.since === undefined ? {} : { since: command.since }),
+        ...(command.limit === undefined ? {} : { limit: command.limit }),
         last: command.last,
     });
     return {
@@ -82,31 +86,32 @@ async function invokeKill(command, input) {
 export async function invokeAkuma(command, input) {
     switch (command.command) {
         case "call": {
+            const body = await promptBody(command, input);
             const result = await Keiyaku.call({
                 path: input.path,
                 archetype: command.archetype,
-                body: input.readStdin(),
+                body,
                 settings: input.settings,
-                cwd: input.executionCwd,
+                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
                 mode: command.mode,
                 ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
             });
-            return { kind: "akuma", action: "call", result };
+            return { kind: "akuma", action: "call", result, world: input.path };
         }
         case "wait": return await invokeWait(command, input);
         case "tell": return await invokeTell(command, input);
-        case "history": return invokeHistory(command, input);
+        case "history": return await invokeHistory(command, input);
         case "fork": return await invokeFork(command, input);
         case "kill": return await invokeKill(command, input);
     }
 }
-export function invokeAkumaStatus(path, akuma, settings, alias, repo) {
+export async function invokeAkumaStatus(path, akuma, settings, alias, repo) {
     return {
         kind: "akuma",
         action: "status",
-        status: Keiyaku.status({ path, akuma, settings, ...(repo === undefined ? {} : { repo }) }),
+        status: await Keiyaku.status({ path, akuma, settings, ...(repo === undefined ? {} : { repo }) }),
         ...(alias === undefined ? {} : { alias }),
     };
 }

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

@@ -5,14 +5,23 @@ type Output = Readonly<{
 type Addressed = Readonly<{
     akuma: string;
 }>;
-export type ParsedAkumaCommand = Output & (Readonly<{
+export type AkumaPromptSource = Readonly<{
+    kind: "argument";
+    value: string;
+}> | Readonly<{
+    kind: "stdin";
+}>;
+type Prompted = Readonly<{
+    prompt: AkumaPromptSource;
+}>;
+export type ParsedAkumaCommand = Output & ((Readonly<{
     command: "call";
     archetype: string;
     contract?: string;
     alias?: AkumaAlias;
     mode: "wait" | "detach";
     timeoutMs?: number;
-}> | Readonly<{
+}> & Prompted) | Readonly<{
     command: "kill";
     akuma: readonly string[];
 }> | Readonly<{
@@ -23,11 +32,12 @@ export type ParsedAkumaCommand = Output & (Readonly<{
 }> | (Readonly<{
     command: "tell";
     interrupt: boolean;
-}> & Addressed) | (Readonly<{
+}> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;
     before?: number;
     since?: number;
+    limit?: number;
 }> & Addressed) | (Readonly<{
     command: "fork";
     at: string;

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

@@ -1,4 +1,4 @@
-import { CliUsageError, usageLine } from "../usage.js";
+import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
 import { archetypeName, parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
@@ -9,13 +9,19 @@ const AKUMA_COMMAND_SPECS = {
         flags: {
             contract: "value",
             alias: "value",
-            wait: "boolean",
-            timeout: "value",
+            wait: "value",
             detach: "boolean",
             json: "boolean",
         },
-        usage: "call <akuma> [--contract <kei/...>] [--alias @name] [--wait [--timeout <duration>] | -d | --detach] [--json] -",
-        purpose: "Call an Akuma from an Archetype and stdin body.",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        purpose: "Birth an Akuma from <akuma-name> with one prompt.",
+        details: [
+            "Give <prompt> as one argument, or use final - to read stdin.",
+            "Default: --wait 5m. An explicit --wait replaces that duration; -d and --detach return after birth.",
+            "--contract dispatches the born Akuma to that Contract.",
+            "--alias assigns the world-local @name selector to the born Akuma.",
+            "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
+        ].join("\n"),
     },
     wait: {
         arity: "one-or-more",
@@ -28,14 +34,18 @@ const AKUMA_COMMAND_SPECS = {
         arity: 1,
         stdin: true,
         flags: { interrupt: "boolean", json: "boolean" },
-        usage: "tell <aku/...> [--interrupt] [--json] -",
-        purpose: "Record and wake one Akuma, optionally putting down its current Body first.",
+        usage: "tell <aku/...|@alias> [--interrupt] [--json] (<prompt> | -)",
+        purpose: "Send one prompt to an existing Akuma and wake it.",
+        details: [
+            "Give <prompt> as one argument, or use final - to read stdin.",
+            "--interrupt ends the current Body before recording the prompt and waking its successor.",
+        ].join("\n"),
     },
     history: {
         arity: 1,
         stdin: false,
-        flags: { before: "value", since: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...> [--before <index> | --since <index> | --last] [--json]",
+        flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
         purpose: "Read the persistent execution history or the last answer.",
     },
     fork: {
@@ -64,7 +74,7 @@ export function renderAkumaRootRows() {
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];
-    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
 }
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
@@ -84,14 +94,14 @@ function stringFlag(value, diagnostic, fail) {
         fail(diagnostic);
     return value;
 }
-function parseDuration(raw, fail) {
+function parseDuration(raw, option, fail) {
     if (typeof raw !== "string")
-        fail("--timeout requires an integer duration with unit ms, s, m, or h");
+        fail(`${option} requires an integer duration with unit ms, s, m, or h`);
     const duration = decodeDuration(raw);
     if (duration.kind === "invalid")
-        fail("--timeout requires an integer duration with unit ms, s, m, or h");
+        fail(`${option} requires an integer duration with unit ms, s, m, or h`);
     if (duration.kind === "overflow")
-        fail("--timeout duration exceeds the safe millisecond range");
+        fail(`${option} duration exceeds the safe millisecond range`);
     return duration.milliseconds;
 }
 function scanAkuma(action, argv, fail) {
@@ -113,8 +123,11 @@ function scanAkuma(action, argv, fail) {
                 fail("duplicate option: --detach");
             flags.detach = true;
         }
-        else if (!token.startsWith("--"))
+        else if (!token.startsWith("--")) {
+            if (isBlankInput(token))
+                fail(`${action} requires a nonblank value`);
             positionals.push(token);
+        }
         else {
             const name = token.slice(2);
             const kind = spec.flags[name];
@@ -129,6 +142,8 @@ function scanAkuma(action, argv, fail) {
                 if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
                     fail(`${token} requires a value`);
                 }
+                if (isBlankInput(value))
+                    fail(`${token} requires a nonblank value`);
                 flags[name] = value;
                 index += 1;
             }
@@ -181,42 +196,57 @@ function parseWait(rawSelectors, flags, output, fail) {
         command: "wait",
         akuma: rawSelectors.map((value) => validateSet(value, fail)),
         ...(completion === undefined ? {} : { completion }),
-        ...(flags.timeout === undefined ? {} : { timeoutMs: parseDuration(flags.timeout, fail) }),
+        ...(flags.timeout === undefined ? {} : { timeoutMs: parseDuration(flags.timeout, "--timeout", fail) }),
         output,
     };
 }
 function parseHistory(akuma, flags, output, fail) {
     if (flags.before !== undefined && flags.since !== undefined)
         fail("history --before and --since are mutually exclusive");
-    if (flags.last === true && (flags.before !== undefined || flags.since !== undefined)) {
-        fail("history --last cannot be combined with --before or --since");
+    if (flags.last === true && (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined)) {
+        fail("history --last cannot be combined with --before, --since, or --limit");
     }
+    const limit = flags.limit === undefined ? undefined : positiveIndex(flags.limit, "--limit", fail);
+    if (limit !== undefined && limit > 5_000)
+        fail("--limit must be no greater than 5000");
     return {
         command: "history",
         akuma,
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
         ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
+        ...(limit === undefined ? {} : { limit }),
         output,
     };
 }
 function parseAddressed(action, rawSelectors, flags, output, fail) {
     if (action === "kill")
         return { command: action, akuma: rawSelectors.map((value) => validateSet(value, fail)), output };
-    if (action === "tell") {
-        return { command: action, akuma: validateDirect(rawSelectors[0], fail), interrupt: flags.interrupt === true, output };
-    }
     if (action === "wait")
         return parseWait(rawSelectors, flags, output, fail);
     const akuma = validateDirect(rawSelectors[0], fail);
     if (action === "history")
         return parseHistory(akuma, flags, output, fail);
     const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
-    if (at.trim().length === 0)
-        fail("fork requires --at <historyId>");
     return { command: action, akuma, at, output };
 }
-function parseCall(flags, positionals, output, fail) {
+function parsePrompted(action, positionals, stdin, fail) {
+    if (positionals.length < 1 || positionals.length > 2)
+        fail(`${action} has invalid positional arguments`);
+    const argument = positionals[1];
+    if (stdin && argument !== undefined)
+        fail(`${action} accepts either a prompt argument or stdin, not both`);
+    if (!stdin && argument === undefined)
+        fail(`${action} requires a prompt argument or stdin`);
+    return {
+        subject: positionals[0],
+        prompt: stdin ? { kind: "stdin" } : { kind: "argument", value: argument },
+    };
+}
+function parseTell(flags, subject, prompt, output, fail) {
+    return { command: "tell", akuma: validateDirect(subject, fail), interrupt: flags.interrupt === true, prompt, output };
+}
+function parseCall(flags, archetype, prompt, output, fail) {
     let alias;
     if (flags.alias !== undefined) {
         try {
@@ -226,19 +256,18 @@ function parseCall(flags, positionals, output, fail) {
             fail(error instanceof Error ? error.message : "invalid Akuma alias");
         }
     }
-    if (flags.detach === true && flags.wait === true)
+    if (flags.detach === true && flags.wait !== undefined)
         fail("call --wait and --detach are mutually exclusive");
-    if (flags.detach === true && flags.timeout !== undefined)
-        fail("call --timeout and --detach are mutually exclusive");
     const mode = flags.detach === true ? "detach" : "wait";
-    const timeoutMs = flags.timeout === undefined ? undefined : parseDuration(flags.timeout, fail);
+    const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
     return {
         command: "call",
-        archetype: positionals[0],
+        archetype,
         ...(typeof flags.contract === "string" ? { contract: flags.contract } : {}),
         ...(alias === undefined ? {} : { alias }),
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        prompt,
         output,
     };
 }
@@ -250,13 +279,17 @@ export function parseAkumaCommand(argv) {
     const spec = AKUMA_COMMAND_SPECS[action];
     const fail = (message) => { throw new CliUsageError(message, renderAkumaUsage(action)); };
     const { flags, positionals, stdin } = scanAkuma(action, argv, fail);
+    const output = flags.json === true ? "json" : "text";
+    if (action === "call" || action === "tell") {
+        const parsed = parsePrompted(action, positionals, stdin, fail);
+        return action === "call"
+            ? parseCall(flags, parsed.subject, parsed.prompt, output, fail)
+            : parseTell(flags, parsed.subject, parsed.prompt, output, fail);
+    }
     if (spec.arity === "one-or-more" ? positionals.length === 0 : positionals.length !== spec.arity) {
         fail(`${action} has invalid positional arguments`);
     }
-    if (stdin !== spec.stdin)
-        fail(`${action} ${spec.stdin ? "requires" : "reads no"} stdin`);
-    const output = flags.json === true ? "json" : "text";
-    if (action === "call")
-        return parseCall(flags, positionals, output, fail);
+    if (stdin)
+        fail(`${action} reads no stdin`);
     return parseAddressed(action, positionals, flags, output, fail);
 }

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

@@ -6,6 +6,7 @@ export type ContractCommandSpec = Readonly<{
     usage: string;
     purpose: string;
 }>;
+export declare const AMEND_MINIMAL_STDIN_HELP: string;
 export declare const CONTRACT_COMMAND_SPECS: {
     readonly bind: {
         readonly positional: "none";
@@ -57,7 +58,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly summary: "value";
             readonly json: "boolean";
         };
-        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) [--summary <text>] [--actor <actor>] [--json] [-]";
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]";
         readonly purpose: "Record one review verdict.";
     };
     readonly arc: {
@@ -105,19 +106,20 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly flags: {
             readonly json: "boolean";
         };
-        readonly usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<archetype>/ [--json]\n       keiyaku ls aku/*/* [--json]";
+        readonly usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]";
         readonly purpose: "List one identity directory.";
     };
     readonly audit: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
-            readonly "show-diff-body": "boolean";
+            readonly "include-dirty": "boolean";
+            readonly diff: "boolean";
             readonly actor: "value";
             readonly json: "boolean";
         };
-        readonly usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]";
-        readonly purpose: "Audit one Contract without mutation.";
+        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]";
+        readonly purpose: "Ask what candidate preparation, Verification, and target placement would do.";
     };
     readonly reconcile: {
         readonly positional: "optional";
@@ -138,5 +140,16 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly usage: "settings [--json]";
         readonly purpose: "Read user and project Settings resources.";
     };
+    readonly region: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly overlap: "boolean";
+            readonly path: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "region [<contract>] [--overlap] [--json]\n       region --path <repo-relative-path> [--json]";
+        readonly purpose: "Read active declared Contract Regions.";
+    };
 };
 export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;

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

@@ -1,14 +1,20 @@
+export const AMEND_MINIMAL_STDIN_HELP = [
+    "minimal stdin:",
+    "  ## Replace: Design",
+    "  <complete replacement>",
+].join("\n");
 export const CONTRACT_COMMAND_SPECS = {
     bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "value", json: "boolean" }, usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Create one Contract from stdin Markdown." },
     amend: { positional: "optional", stdin: "required", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Apply stdin amendment operations to one Contract." },
     deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--actor <actor>] [--json]", purpose: "Deliver one Contract candidate." },
-    review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) [--summary <text>] [--actor <actor>] [--json] [-]", purpose: "Record one review verdict." },
+    review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]", purpose: "Record one review verdict." },
     arc: { positional: "optional", stdin: "required", flags: { actor: "value", json: "boolean" }, usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -", purpose: "Record stdin arc Markdown for one Contract." },
     abandon: { positional: "optional", stdin: "none", flags: { actor: "value", note: "value", json: "boolean" }, usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]", purpose: "Abandon one Contract with an optional note." },
     status: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "status [<contract>|@name|<aku/...>] [--json]", purpose: "Read the world status board or one Contract projection." },
     show: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "show [<contract>|@<contract>] [--json]", purpose: "Read one Contract guidance projection." },
-    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<archetype>/ [--json]\n       keiyaku ls aku/*/* [--json]", purpose: "List one identity directory." },
-    audit: { positional: "optional", stdin: "none", flags: { "show-diff-body": "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]", purpose: "Audit one Contract without mutation." },
+    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]", purpose: "List one identity directory." },
+    audit: { positional: "optional", stdin: "none", flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]", purpose: "Ask what candidate preparation, Verification, and target placement would do." },
     reconcile: { positional: "optional", stdin: "none", flags: { "retry-hooks": "boolean", json: "boolean" }, usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]", purpose: "Reconcile one Contract or the invocation world." },
     settings: { positional: "none", stdin: "none", flags: { json: "boolean" }, usage: "settings [--json]", purpose: "Read user and project Settings resources." },
+    region: { positional: "optional", stdin: "none", flags: { overlap: "boolean", path: "value", json: "boolean" }, usage: "region [<contract>] [--overlap] [--json]\n       region --path <repo-relative-path> [--json]", purpose: "Read active declared Contract Regions." },
 };

package/build/src/cli/commands/task-invoke.d.ts

@@ -1,11 +1,24 @@
-import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDependencyTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskUpdateResult } from "../../task/index.js";
+import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDecompositionTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskQueryResult, type TaskUpdateResult } from "../../task/index.js";
 import type { ParsedTaskCommand } from "./task.js";
 import type { WorldRoot } from "../../world.js";
-export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskDependencyTree | TaskDoctorReport | TaskNamespaceResult;
+export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskNamespaceResult | TaskWorldObservation;
+type TaskWorldRead = TaskList | BlockedTaskList | TaskQueryResult | TaskDoctorReport;
+export type TaskWorldObservation = Readonly<{
+    kind: "present";
+    value: TaskWorldRead;
+}> | Readonly<{
+    kind: "absent";
+}> | Readonly<{
+    kind: "failed";
+    failure: Readonly<{
+        message: string;
+    }>;
+}>;
 type TaskInput = Readonly<{
     world: WorldRoot | null;
-    establish(): WorldRoot;
-    readStdin(): string;
+    establish(): Promise<WorldRoot>;
+    readStdin(): Promise<string>;
+    actor?: string;
 }>;
 export declare function invokeTask(command: ParsedTaskCommand, input: TaskInput): Promise<TaskInvocationResult>;
 export {};