@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/body/decode.js

@@ -1,29 +1,12 @@
 import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
-import { parseToAST } from "../markdown/parse.js";
-import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+import { decodeDocumentEnvelope } from "./envelope.js";
+import { directChildren, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
 import { CONTRACT_SECTIONS, RESERVED_SECTIONS } from "./shape.js";
 import { decodeRegion, RegionDocumentError } from "./region.js";
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 function refusal(message) {
     throw new TypeError(message);
 }
-function nonblankRaw(document, node) {
-    return rawSlice(document, node.span).trim().length > 0;
-}
-function topLevelSections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
-}
-function indexedSections(document) {
-    const sections = new Map();
-    for (const section of topLevelSections(document)) {
-        const title = normalizeTitle(section.title);
-        if (sections.has(title))
-            refusal(`duplicate contract section '${section.title}'`);
-        sections.set(title, section);
-    }
-    return sections;
-}
 function requireSections(sections) {
     for (const [name, spec] of Object.entries(CONTRACT_SECTIONS)) {
         if (spec.required && !sections.has(name))
@@ -72,14 +55,6 @@ function criteria(document, section) {
         return { title, body };
     });
 }
-function rejectUnownedBytes(document, title) {
-    if (title.children.some((node) => nonblankRaw(document, node))) {
-        refusal("contract title may not contain content before the first H2 section");
-    }
-    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
-    if (stray.length > 0)
-        refusal("contract document contains content outside an H1 or H2 section");
-}
 function verification(document, section) {
     try {
         return decodeVerificationDeclarations(document, section);
@@ -91,22 +66,14 @@ function verification(document, section) {
     }
 }
 export function decodeContractDocument(source) {
-    let document;
+    let envelope;
     try {
-        document = parseToAST(source);
+        envelope = decodeDocumentEnvelope(source, "contract");
     }
     catch (error) {
         refusal(error instanceof Error ? error.message : String(error));
     }
-    if (document.frontmatter !== undefined)
-        refusal("contract document may not contain frontmatter");
-    const titles = indexedHeadings(indexDocument(document), { level: 1 })
-        .filter((node) => node.type === "section");
-    if (titles.length !== 1)
-        refusal("contract document requires exactly one H1 title");
-    const title = titles[0];
-    rejectUnownedBytes(document, title);
-    const sections = indexedSections(document);
+    const { document, title, sections, sectionNodes } = envelope;
     requireSections(sections);
     for (const name of RESERVED_SECTIONS) {
         if (sections.has(name))
@@ -131,7 +98,6 @@ export function decodeContractDocument(source) {
         verification: verificationSection === undefined ? [] : verification(document, verificationSection),
         extensions,
     };
-    const sectionNodes = topLevelSections(document);
     const segments = sectionNodes.map((section) => mintDocumentSegmentKey(document.source, section.span));
     return {
         ...body,

package/build/src/body/envelope.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentNode, SectionNode } from "../markdown/types.js";
+export declare function decodeDocumentEnvelope(source: string, kind: "arc" | "contract"): Readonly<{
+    document: DocumentNode;
+    title: SectionNode;
+    sections: ReadonlyMap<string, SectionNode>;
+    sectionNodes: readonly SectionNode[];
+}>;

package/build/src/body/envelope.js

@@ -0,0 +1,37 @@
+import { parseToAST } from "../markdown/parse.js";
+import { indexDocument, indexedHeadings, normalizeTitle, rawSlice } from "../markdown/query.js";
+function refusal(message) {
+    throw new TypeError(message);
+}
+function nonblankRaw(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function topLevelSections(document) {
+    return indexedHeadings(indexDocument(document), { level: 2 })
+        .filter((node) => node.type === "section");
+}
+export function decodeDocumentEnvelope(source, kind) {
+    const document = parseToAST(source);
+    if (document.frontmatter !== undefined)
+        refusal(`${kind} document may not contain frontmatter`);
+    const titles = indexedHeadings(indexDocument(document), { level: 1 })
+        .filter((node) => node.type === "section");
+    if (titles.length !== 1)
+        refusal(`${kind} document requires exactly one H1 title`);
+    const title = titles[0];
+    if (title.children.some((node) => nonblankRaw(document, node))) {
+        refusal(`${kind} title may not contain content before the first H2 section`);
+    }
+    if (document.children.some((node) => node.type !== "section" && nonblankRaw(document, node))) {
+        refusal(`${kind} document contains content outside an H1 or H2 section`);
+    }
+    const sectionNodes = topLevelSections(document);
+    const sections = new Map();
+    for (const section of sectionNodes) {
+        const name = normalizeTitle(section.title);
+        if (sections.has(name))
+            refusal(`duplicate ${kind} section '${section.title}'`);
+        sections.set(name, section);
+    }
+    return { document, title, sections, sectionNodes };
+}

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

@@ -5,7 +5,10 @@ type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
     projectRefusal?: (refusal: unknown) => unknown;
 }>;
-export declare function acceptedBind(result: BindResult, target: string | null): AcceptedBindResult;
+export declare function acceptedBind(result: BindResult, coordinates: Readonly<{
+    workspace: "worktree" | "here";
+    target?: string;
+}>): AcceptedBindResult;
 export declare function acceptedAmend(result: AmendResult, coordinate: ContractId): AcceptedAmendResult;
 export declare function acceptedDeliver(result: MutationResult<Delivery>, coordinate: ContractId): AcceptedDeliverResult;
 export declare function acceptedReview(result: MutationResult<Review>, coordinate: ContractId): AcceptedReviewResult;

package/build/src/cli/accepted.js

@@ -1,10 +1,11 @@
 import { KeiyakuRefused, KeiyakuRetry, } from "../index.js";
 function acceptedFacts(result) {
-    return result.facts.map((fact) => ({
-        contract: fact.contract,
-        entry: fact.entry,
-        kind: fact.kind,
-    }));
+    return result.facts.map((fact) => fact.kind === "reintegrated"
+        ? { contract: fact.contract, entry: fact.entry, kind: fact.kind, data: fact.data }
+        : { contract: fact.contract, entry: fact.entry, kind: fact.kind });
+}
+function attestationFor(facts, gate) {
+    return facts.findLast((fact) => fact.kind === "attestation" && fact.data.gate === gate);
 }
 function acceptedEnvelope(result, coordinate) {
     const contract = coordinate ?? result.facts[0]?.contract;
@@ -26,11 +27,12 @@ function acceptedRegion(result) {
         return { overlapFailure: result.overlapFailure };
     return { overlaps: result.overlaps };
 }
-export function acceptedBind(result, target) {
+export function acceptedBind(result, coordinates) {
     return {
         ...acceptedEnvelope(result, undefined),
         verb: "bind",
-        target,
+        workspace: coordinates.workspace,
+        target: coordinates.target ?? null,
         ...acceptedRegion(result),
     };
 }
@@ -44,9 +46,12 @@ export function acceptedAmend(result, coordinate) {
 }
 export function acceptedDeliver(result, coordinate) {
     const value = result.value;
+    const attestation = attestationFor(result.facts, "verified");
+    const verificationVerdict = attestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "deliver",
+        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
@@ -56,18 +61,43 @@ export function acceptedDeliver(result, coordinate) {
 }
 export function acceptedReview(result, coordinate) {
     const value = result.value;
+    const reviewAttestation = attestationFor(result.facts, "reviewed");
+    if (reviewAttestation === undefined)
+        throw new Error("accepted review is missing its attestation fact");
+    const verificationAttestation = attestationFor(result.facts, "verified");
+    const verificationVerdict = verificationAttestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "review",
+        verdict: reviewAttestation.data.verdict,
+        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
+        ...(value.verification === undefined ? {} : { verification: value.verification }),
+        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
         ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
+        ...(value.leak === undefined ? {} : { leak: value.leak }),
     };
 }
 export function acceptedArc(result, coordinate) {
-    return { ...acceptedEnvelope(result, coordinate), verb: "arc" };
+    const arc = result.facts.find((fact) => fact.kind === "arc");
+    if (arc === undefined)
+        throw new Error("accepted arc is missing its arc fact");
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "arc",
+        chapter: { seq: arc.data.seq, title: arc.data.title },
+    };
 }
 export function acceptedAbandon(result, coordinate) {
-    return { ...acceptedEnvelope(result, coordinate), verb: "abandon" };
+    const abandoned = result.facts.find((fact) => fact.kind === "abandoned");
+    if (abandoned === undefined)
+        throw new Error("accepted abandon is missing its abandoned fact");
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "abandon",
+        ...(abandoned.data.note === undefined ? {} : { note: abandoned.data.note }),
+    };
 }
 export function acceptedAudit(result, coordinate) {
     return {

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

@@ -1,8 +1,8 @@
 import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
-import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaStatusView, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
+import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
-import type { ParsedAkumaCommand } from "./akuma.js";
+import type { InvokedAkumaCommand } from "./akuma.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -11,7 +11,7 @@ export type AkumaInvocationResult = Readonly<{
 }> | Readonly<{
     kind: "akuma";
     action: "status";
-    status: AkumaStatusView;
+    status: AkumaObservation;
     alias?: string;
 }> | Readonly<{
     kind: "akuma";
@@ -67,12 +67,13 @@ export type AkumaInvocationResult = Readonly<{
 }>;
 type InvokeInput = Readonly<{
     path: WorldRoot;
-    executionCwd?: string;
-    settings: Settings;
+    statedCwd?: string;
+    home?: string;
+    settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
     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): Promise<AkumaInvocationResult>;
+export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
+export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
 export {};

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

@@ -13,7 +13,6 @@ async function invokeWait(command, input) {
         result: await Keiyaku.wait({
             path: input.path,
             akuma: command.akuma,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
             ...(command.completion === undefined ? {} : { completion: command.completion }),
             ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
@@ -24,11 +23,21 @@ async function invokeWait(command, input) {
 async function invokeTell(command, input) {
     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 result = await Keiyaku.interrupt({
+            path: input.path,
+            akuma: command.akuma,
+            body,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+        });
         const alias = inputAlias(command.akuma);
         return { kind: "akuma", action: "tell", mode: "interrupt", result, body, ...(alias === undefined ? {} : { alias }) };
     }
-    const result = await Keiyaku.tell({ path: input.path, akuma: command.akuma, settings: input.settings, body, ...(input.repo === undefined ? {} : { repo: input.repo }) });
+    const result = await Keiyaku.tell({
+        path: input.path,
+        akuma: command.akuma,
+        body,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+    });
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
 }
@@ -36,7 +45,6 @@ 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 }),
@@ -64,7 +72,6 @@ async function invokeFork(command, input) {
             path: input.path,
             akuma: command.akuma,
             at: command.at,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
         }),
     };
@@ -77,7 +84,6 @@ async function invokeKill(command, input) {
         result: await Keiyaku.kill({
             path: input.path,
             akuma: command.akuma,
-            settings: input.settings,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
         }),
         ...(alias === undefined ? {} : { alias }),
@@ -91,12 +97,14 @@ export async function invokeAkuma(command, input) {
                 path: input.path,
                 archetype: command.archetype,
                 body,
-                settings: input.settings,
-                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
+                ...(input.home === undefined ? {} : { home: input.home }),
+                ...(input.settings === undefined ? {} : { settings: input.settings }),
+                ...(input.statedCwd === undefined ? {} : { cwd: input.statedCwd }),
                 mode: command.mode,
                 ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
+                ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
             });
             return { kind: "akuma", action: "call", result, world: input.path };
         }
@@ -107,11 +115,11 @@ export async function invokeAkuma(command, input) {
         case "kill": return await invokeKill(command, input);
     }
 }
-export async function invokeAkumaStatus(path, akuma, settings, alias, repo) {
+export async function invokeAkumaStatus(path, akuma, alias, repo) {
     return {
         kind: "akuma",
         action: "status",
-        status: await Keiyaku.status({ path, akuma, settings, ...(repo === undefined ? {} : { repo }) }),
+        status: await Keiyaku.status({ path, akuma, ...(repo === undefined ? {} : { repo }) }),
         ...(alias === undefined ? {} : { alias }),
     };
 }

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

@@ -1,4 +1,5 @@
 import { type AkumaAlias } from "../../identity/selector.js";
+import { type AllowedActions } from "../../akuma/allowed.js";
 type Output = Readonly<{
     output: "text" | "json";
 }>;
@@ -21,6 +22,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     alias?: AkumaAlias;
     mode: "wait" | "detach";
     timeoutMs?: number;
+    allowed?: AllowedActions;
 }> & Prompted) | Readonly<{
     command: "kill";
     akuma: readonly string[];
@@ -38,15 +40,22 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     before?: number;
     since?: number;
     limit?: number;
-}> & Addressed) | (Readonly<{
+}> & Addressed) | Readonly<{
+    command: "history";
+    contract: string;
+}> | (Readonly<{
     command: "fork";
     at: string;
 }> & Addressed));
+export type InvokedAkumaCommand = Exclude<ParsedAkumaCommand, {
+    command: "history";
+    contract: string;
+}>;
 export type AkumaAction = ParsedAkumaCommand["command"];
 export declare function isAkumaAction(value: string | undefined): value is AkumaAction;
 export declare function isParsedAkumaCommand(command: Readonly<{
     command: string;
-}>): command is ParsedAkumaCommand;
+}>): command is InvokedAkumaCommand;
 export declare function renderAkumaRootRows(): readonly string[];
 export declare function renderAkumaHelp(action: AkumaAction): string;
 export declare function renderAkumaUsage(action: AkumaAction): string;

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

@@ -2,6 +2,7 @@ import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "
 import { archetypeName, parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
+import { decodeAllowedActions } from "../../akuma/allowed.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
         arity: 1,
@@ -11,15 +12,17 @@ const AKUMA_COMMAND_SPECS = {
             alias: "value",
             wait: "value",
             detach: "boolean",
+            allowed: "repeatable",
             json: "boolean",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--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.",
+            "Repeated --allowed replaces the Archetype list; --allowed none selects an empty list.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
     },
@@ -45,8 +48,8 @@ const AKUMA_COMMAND_SPECS = {
         arity: 1,
         stdin: false,
         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.",
+        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
+        purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
         arity: 1,
@@ -67,7 +70,7 @@ export function isAkumaAction(value) {
     return value !== undefined && Object.hasOwn(AKUMA_COMMAND_SPECS, value);
 }
 export function isParsedAkumaCommand(command) {
-    return isAkumaAction(command.command);
+    return isAkumaAction(command.command) && !("contract" in command && command.command === "history");
 }
 export function renderAkumaRootRows() {
     return Object.values(AKUMA_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]);
@@ -80,11 +83,11 @@ export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
 export function parseAkumaCatalogPath(value) {
-    if (value === "aku/")
+    if (value === "aku" || value === "aku/")
         return { kind: "archetypes" };
     if (value === "aku/*/*")
         return { kind: "akuma" };
-    const match = /^aku\/(.+)\/$/u.exec(value);
+    const match = /^aku\/([^/]+)\/?$/u.exec(value);
     if (match === null)
         return null;
     return { kind: "akuma", archetype: archetypeName(match[1]) };
@@ -104,6 +107,29 @@ function parseDuration(raw, option, fail) {
         fail(`${option} duration exceeds the safe millisecond range`);
     return duration.milliseconds;
 }
+function scanNamedOption(input, flags, fail) {
+    const token = input.argv[input.index];
+    const name = token.slice(2);
+    const kind = input.spec.flags[name];
+    if (kind === undefined)
+        fail(`option ${token} is not valid for ${input.action}`);
+    if (kind !== "repeatable" && flags[name] !== undefined)
+        fail(`duplicate option: ${token}`);
+    if (kind === "boolean") {
+        flags[name] = true;
+        return input.index;
+    }
+    const value = input.argv[input.index + 1];
+    if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
+        fail(`${token} requires a value`);
+    }
+    if (isBlankInput(value))
+        fail(`${token} requires a nonblank value`);
+    flags[name] = kind === "repeatable"
+        ? [...(Array.isArray(flags[name]) ? flags[name] : []), value]
+        : value;
+    return input.index + 1;
+}
 function scanAkuma(action, argv, fail) {
     const spec = AKUMA_COMMAND_SPECS[action];
     const flags = {};
@@ -129,24 +155,7 @@ function scanAkuma(action, argv, fail) {
             positionals.push(token);
         }
         else {
-            const name = token.slice(2);
-            const kind = spec.flags[name];
-            if (kind === undefined)
-                fail(`option ${token} is not valid for ${action}`);
-            if (flags[name] !== undefined)
-                fail(`duplicate option: ${token}`);
-            if (kind === "boolean")
-                flags[name] = true;
-            else {
-                const value = argv[index + 1];
-                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;
-            }
+            index = scanNamedOption({ action, spec, argv, index }, flags, fail);
         }
     }
     return { flags, positionals, stdin };
@@ -200,7 +209,13 @@ function parseWait(rawSelectors, flags, output, fail) {
         output,
     };
 }
-function parseHistory(akuma, flags, output, fail) {
+function parseHistory(selector, flags, output, fail) {
+    if (selector.startsWith("kei/")) {
+        if (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined || flags.last === true) {
+            fail("history kei/... does not accept --before, --since, --limit, or --last");
+        }
+        return { command: "history", contract: selector, output };
+    }
     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 || flags.limit !== undefined)) {
@@ -211,7 +226,7 @@ function parseHistory(akuma, flags, output, fail) {
         fail("--limit must be no greater than 5000");
     return {
         command: "history",
-        akuma,
+        akuma: validateDirect(selector, fail),
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
         ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
@@ -224,9 +239,13 @@ function parseAddressed(action, rawSelectors, flags, output, fail) {
         return { command: action, akuma: rawSelectors.map((value) => validateSet(value, fail)), output };
     if (action === "wait")
         return parseWait(rawSelectors, flags, output, fail);
+    if (action === "history") {
+        const selector = rawSelectors[0];
+        if (selector.includes("*"))
+            fail("history accepts one complete aku/..., @alias, or kei/... selector");
+        return parseHistory(selector, 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);
     return { command: action, akuma, at, output };
 }
@@ -246,6 +265,24 @@ function parsePrompted(action, positionals, stdin, fail) {
 function parseTell(flags, subject, prompt, output, fail) {
     return { command: "tell", akuma: validateDirect(subject, fail), interrupt: flags.interrupt === true, prompt, output };
 }
+function parseAllowedFlag(raw, fail) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        fail("--allowed requires a value");
+    const selected = raw;
+    if (selected.includes("none")) {
+        if (selected.length !== 1)
+            fail("--allowed none cannot be combined with another value");
+        return [];
+    }
+    try {
+        return decodeAllowedActions(selected, "--allowed");
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : "invalid --allowed action");
+    }
+}
 function parseCall(flags, archetype, prompt, output, fail) {
     let alias;
     if (flags.alias !== undefined) {
@@ -260,6 +297,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         fail("call --wait and --detach are mutually exclusive");
     const mode = flags.detach === true ? "detach" : "wait";
     const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
+    const allowed = parseAllowedFlag(flags.allowed, fail);
     return {
         command: "call",
         archetype,
@@ -267,6 +305,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         ...(alias === undefined ? {} : { alias }),
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(allowed === undefined ? {} : { allowed }),
         prompt,
         output,
     };

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

@@ -4,7 +4,7 @@ type AmendCommandInput = Readonly<{
     command: ParsedAmend;
     repo: Repo;
     contract: Keiyaku;
-    markdown: string;
+    markdown?: string;
     gates: readonly Gate[] | undefined;
     actor?: ActorId;
     hooks?: WorktreeHooks;

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

@@ -4,7 +4,7 @@ export function amendFromCommand({ command, repo, contract, markdown, gates, act
         ? []
         : command.after?.map((id) => contractFromInput(repo, id).id);
     return contract.amend({
-        markdown,
+        ...(markdown === undefined ? {} : { markdown }),
         ...(actor === undefined ? {} : { actor }),
         ...(hooks === undefined ? {} : { hooks }),
         ...(after === undefined ? {} : { after }),

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

@@ -1,4 +1,4 @@
-export type ContractFlagKind = "boolean" | "value" | "repeat-value";
+export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
 export type ContractCommandSpec = Readonly<{
     positional: "none" | "optional";
     stdin: "none" | "optional" | "required";
@@ -17,24 +17,24 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly target: "value";
             readonly here: "boolean";
             readonly after: "repeat-value";
-            readonly gates: "value";
+            readonly gates: "raw-value";
             readonly json: "boolean";
         };
-        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] -";
         readonly purpose: "Create one Contract from stdin Markdown.";
     };
     readonly amend: {
         readonly positional: "optional";
-        readonly stdin: "required";
+        readonly stdin: "optional";
         readonly flags: {
             readonly actor: "value";
             readonly after: "repeat-value";
             readonly "clear-after": "boolean";
-            readonly gates: "value";
+            readonly gates: "raw-value";
             readonly json: "boolean";
         };
-        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -";
-        readonly purpose: "Apply stdin amendment operations to one Contract.";
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]";
+        readonly purpose: "Amend one Contract's document operations or structured terms.";
     };
     readonly deliver: {
         readonly positional: "optional";
@@ -106,7 +106,7 @@ 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/<akuma>/ [--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: {