@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/akuma/{body-turn.js → turn-drive.js}

@@ -1,90 +1,8 @@
 import { abortableDelay } from "./abort.js";
 import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
-import { encodeAgentEvent, } from "./provider.js";
-import { BodyRequestPump, } from "./request-serve.js";
-const BODY_CONTROL_OBSERVATION_MS = 100;
-export const CONTROL_RESPONSE_MS = 1_000;
-export class BodySupervisor {
-    paths;
-    bodySequence;
-    leash;
-    signal;
-    controller = new AbortController();
-    finished = new AbortController();
-    observer;
-    waiter;
-    observation;
-    stopping;
-    constructor(paths, bodySequence, leash, observation) {
-        this.paths = paths;
-        this.bodySequence = bodySequence;
-        this.leash = leash;
-        this.signal = this.controller.signal;
-        this.observation = observation;
-        this.observer = this.observe();
-    }
-    static async open(paths, bodySequence, leash) {
-        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
-    }
-    get reason() { return this.stopping; }
-    current() { return this.observation; }
-    async recordHung(diagnostic, at) {
-        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
-    }
-    async refresh() {
-        this.publish(await readHeart(this.paths));
-        return this.observation;
-    }
-    next(after) {
-        if (this.observation !== after)
-            return Promise.resolve(this.observation);
-        return new Promise((resolve) => { this.waiter = resolve; });
-    }
-    cancel(reason) {
-        if (this.stopping !== undefined)
-            return;
-        this.stopping = reason;
-        this.controller.abort(new Error(reason === "control"
-            ? "Akuma Body interrupted by durable control"
-            : "Akuma Heart disappeared"));
-        this.waiter?.(this.observation);
-        this.waiter = undefined;
-    }
-    async close() {
-        this.finished.abort();
-        await this.observer;
-        this.waiter = undefined;
-    }
-    publish(snapshot) {
-        this.observation = snapshot;
-        this.waiter?.(snapshot);
-        this.waiter = undefined;
-    }
-    async observe() {
-        for (;;) {
-            const snapshot = this.observation;
-            if (!await heartExists(this.paths))
-                return this.cancel("heart-gone");
-            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
-                return this.cancel("control");
-            }
-            try {
-                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
-            }
-            catch {
-                return;
-            }
-            try {
-                await this.refresh();
-            }
-            catch (error) {
-                if (await heartExists(this.paths))
-                    throw error;
-                return this.cancel("heart-gone");
-            }
-        }
-    }
-}
+import { encodeAgentEvent } from "./provider.js";
+import { BodyRequestPump } from "./request-serve.js";
+import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
     let tail = Promise.resolve();
     let failed = false;
@@ -119,18 +37,16 @@ async function failedTurnSetup(input, turnSequence, requests, cancelDrive, error
     try {
         await requests.close();
     }
-    catch { /* Preserve the setup or pump failure. */ }
+    catch {
+        /* Preserve the setup or pump failure. */
+    }
     input.supervisor.signal.removeEventListener("abort", cancelDrive);
     if (input.supervisor.signal.aborted) {
         if (input.supervisor.reason === "heart-gone")
             throw error;
         return { kind: "stopped" };
     }
-    return {
-        kind: "failed",
-        turnSequence,
-        diagnostic: error instanceof Error ? error.message : String(error),
-    };
+    return { kind: "failed", turnSequence, diagnostic: error instanceof Error ? error.message : String(error) };
 }
 async function writeProviderEvent(input, active, event) {
     if (input.supervisor.signal.aborted)
@@ -145,11 +61,7 @@ async function writeProviderEvent(input, active, event) {
             admittedAt: at,
         });
     }
-    await appendActivity(input.paths, {
-        turnSequence: active.turnSequence,
-        event: encodeAgentEvent(event),
-        at,
-    });
+    await appendActivity(input.paths, { turnSequence: active.turnSequence, event: encodeAgentEvent(event), at });
 }
 async function startTurnDrive(input) {
     const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
@@ -206,7 +118,7 @@ async function startTurnDrive(input) {
             }
             return { kind: "stopped" };
         }
-        if (input.launchTells.length > 0) {
+        if (input.launchTells.length > 0)
             await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
@@ -214,7 +126,6 @@ async function startTurnDrive(input) {
                 fence: selected.admission.fence,
                 deliveredAt: input.now(),
             })));
-        }
         void selected.completion.then(() => requests.stopAdmission());
         return {
             turnSequence: turn.sequence,
@@ -255,7 +166,9 @@ async function retireProviderCustody(input, turnSequence, drive) {
                 at,
             });
         }
-        catch { /* Undisposed provider custody still owns the leash. */ }
+        catch {
+            /* Undisposed provider custody still owns the leash. */
+        }
     }
     await breakBody(input.paths, { sequence: input.bodySequence, end: "broke-off", at: input.now() });
     return { kind: "hung" };
@@ -291,14 +204,16 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
             const submission = await tellLive({ id: tell.id, text: tell.body });
             if (!mayWrite() || submission.kind === "turn-ended")
                 return "turn-ended";
-            await recordTellDeliveries(input.paths, [{
+            await recordTellDeliveries(input.paths, [
+                {
                     tellId: tell.id,
                     route: "live",
                     turnSequence,
                     fence: submission.fence,
                     receipt: drive.receipts === undefined ? "unavailable" : "required",
                     deliveredAt: input.now(),
-                }]);
+                },
+            ]);
             return "accepted";
         });
         if (outcome === "turn-ended")
@@ -400,7 +315,9 @@ async function consumeTurnDrive(input, active) {
         try {
             await requests.close();
         }
-        catch { /* Preserve the first pump failure. */ }
+        catch {
+            /* Preserve the first pump failure. */
+        }
         active.releaseDriveSignal();
         if (retirement.kind === "hung")
             return retirement;
@@ -416,7 +333,7 @@ export async function driveTurn(input) {
         active = started;
     }
     catch (error) {
-        if (!await heartExists(input.paths)) {
+        if (!(await heartExists(input.paths))) {
             input.supervisor.cancel("heart-gone");
             return { kind: "stopped" };
         }

package/build/src/akuma-body.js

@@ -1,8 +1,8 @@
-import { runAkumaBody } from "./akuma/body.js";
+import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
-import { executeKillAkuma, executeTellAkuma, executeWaitAkuma, } from "./library/fleet.js";
-import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom, } from "./library/configuration.js";
-import { executeForwardedDeliver, executeForwardedReview, } from "./library/contract.js";
+import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./library/fleet.js";
+import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom } from "./library/configuration.js";
+import { executeForwardedDeliver, executeForwardedReview } from "./library/contract.js";
 import { Repo } from "./library/repo.js";
 import { settings } from "./settings.js";
 import { executeTaskMutation } from "./task/mutation.js";
@@ -95,4 +95,5 @@ const configuration = {
     ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
     ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
 };
-await runAkumaBody(launch, upstreamFor(launch, configuration));
+if ((await runAkumaBody(launch, upstreamFor(launch, configuration))) === "held")
+    process.exitCode = LEASH_HELD_EXIT;

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

@@ -1,2 +1,5 @@
 import type { DecodedContractDocument } from "./types.js";
-export declare function applyAmendDocument(source: string, current: DecodedContractDocument): string;
+export declare function applyAmendDocument(source: string, current: DecodedContractDocument): Readonly<{
+    document: string;
+    changedSections: ReadonlySet<string>;
+}>;

package/build/src/body/amend.js

@@ -1,6 +1,6 @@
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 import { parseToAST } from "../markdown/parse.js";
-import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent } from "../markdown/query.js";
+import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
 import { decodeRegion, RegionDocumentError } from "./region.js";
 import { contractSectionName, RESERVED_SECTIONS } from "./shape.js";
 import { renderAmendedContractBody } from "./render.js";
@@ -11,8 +11,7 @@ function nonblank(document, node) {
     return rawSlice(document, node.span).trim().length > 0;
 }
 function sections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
+    return indexedHeadings(indexDocument(document), { level: 2 }).filter((node) => node.type === "section");
 }
 function operationSections(document) {
     if (document.frontmatter !== undefined)
@@ -59,7 +58,10 @@ function criteria(document, section) {
         if (title.length === 0 || seen.has(key))
             refusal("criteria operation contains duplicate or empty titles");
         seen.add(key);
-        const body = rawSlice(document, { start: heading.span.end, end: headings[index + 1]?.span.start ?? section.span.end });
+        const body = rawSlice(document, {
+            start: heading.span.end,
+            end: headings[index + 1]?.span.start ?? section.span.end,
+        });
         if (body.trim().length === 0)
             refusal(`criterion '${title}' operation body is empty`);
         return { title, body };
@@ -201,7 +203,10 @@ function applyAppend(body, operation, document) {
     if (index < 0)
         refusal(`unknown extension '${operation.target}'`);
     const extension = body.extensions[index];
-    body.extensions[index] = { ...extension, content: appendText(extension.content, prose(document, operation.section, "extension")) };
+    body.extensions[index] = {
+        ...extension,
+        content: appendText(extension.content, prose(document, operation.section, "extension")),
+    };
 }
 function applyReplace(body, operation, document) {
     const target = contractSectionName(operation.target);
@@ -276,5 +281,8 @@ function apply(source, current) {
 }
 export function applyAmendDocument(source, current) {
     const result = apply(source, current);
-    return renderAmendedContractBody(current.document.bytes, result.body, result.changed);
+    return {
+        document: renderAmendedContractBody(current.document.bytes, result.body, result.changed),
+        changedSections: result.changed,
+    };
 }

package/build/src/body/decode.js

@@ -1,6 +1,6 @@
 import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
 import { decodeDocumentEnvelope } from "./envelope.js";
-import { directChildren, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.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";
@@ -103,9 +103,7 @@ export function decodeContractDocument(source) {
         ...body,
         document: { bytes: source, key: mintDocumentKey(source) },
         segments,
-        verificationSegment: verificationSection === undefined
-            ? null
-            : mintDocumentSegmentKey(document.source, verificationSection.span),
+        verificationSegment: verificationSection === undefined ? null : mintDocumentSegmentKey(document.source, verificationSection.span),
     };
 }
 export function verificationDefinition(document) {

package/build/src/body/envelope.js

@@ -7,15 +7,13 @@ 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");
+    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");
+    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];

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

@@ -2,7 +2,6 @@ import type { DocumentNode, SectionNode } from "../markdown/types.js";
 export declare class RegionDocumentError extends Error {
     constructor(message: string);
 }
-export declare function assertCanonicalRegionPath(path: string): void;
+export declare function assertRegionPattern(pattern: string): string;
 export declare function decodeRegion(document: DocumentNode, section: SectionNode): readonly string[];
 export declare function regionsOverlap(mine: readonly string[], theirs: readonly string[]): readonly [string, string][];
-export declare function regionPatternsMatchPath(patterns: readonly string[], path: string): readonly string[];

package/build/src/body/region.js

@@ -39,68 +39,8 @@ function compileRegionPattern(pattern) {
     const canonical = directory ? [...segments.slice(0, -1), "**"] : segments;
     return { source, segments: canonical.map((segment) => compileSegment(segment, pattern)) };
 }
-export function assertCanonicalRegionPath(path) {
-    if (path.length === 0 || /[\r\n\0]/u.test(path) || path.startsWith("/") || path.endsWith("/")) {
-        refusal(`Region path '${path}' must be a canonical repository-relative path`);
-    }
-    if (path.split("/").some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-        refusal(`Region path '${path}' must be a canonical repository-relative path`);
-    }
-}
-function segmentMatchesPath(pattern, path) {
-    const queue = [[0, 0]];
-    const visited = new Set();
-    let cursor = 0;
-    while (cursor < queue.length) {
-        const [patternIndex, pathIndex] = queue[cursor++];
-        const key = `${patternIndex}:${pathIndex}`;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        if (patternIndex === pattern.length && pathIndex === path.length)
-            return true;
-        const character = pattern[patternIndex];
-        if (character === "*") {
-            queue.push([patternIndex + 1, pathIndex]);
-            if (pathIndex < path.length)
-                queue.push([patternIndex, pathIndex + 1]);
-            continue;
-        }
-        if (character === "?") {
-            if (pathIndex < path.length)
-                queue.push([patternIndex + 1, pathIndex + 1]);
-            continue;
-        }
-        if (character !== undefined && character === path[pathIndex])
-            queue.push([patternIndex + 1, pathIndex + 1]);
-    }
-    return false;
-}
-function patternMatchesPath(pattern, path) {
-    const queue = [[0, 0]];
-    const visited = new Set();
-    let cursor = 0;
-    while (cursor < queue.length) {
-        const [patternIndex, pathIndex] = queue[cursor++];
-        const key = `${patternIndex}:${pathIndex}`;
-        if (visited.has(key))
-            continue;
-        visited.add(key);
-        if (patternIndex === pattern.length && pathIndex === path.length)
-            return true;
-        const segment = pattern[patternIndex];
-        if (segment?.kind === "deep") {
-            queue.push([patternIndex + 1, pathIndex]);
-            if (pathIndex < path.length)
-                queue.push([patternIndex, pathIndex + 1]);
-            continue;
-        }
-        if (segment === undefined || path[pathIndex] === undefined)
-            continue;
-        if (segmentMatchesPath(segment.characters, Array.from(path[pathIndex])))
-            queue.push([patternIndex + 1, pathIndex + 1]);
-    }
-    return false;
+export function assertRegionPattern(pattern) {
+    return compileRegionPattern(pattern).source;
 }
 function segmentTransition(characters, index) {
     const character = characters[index];
@@ -199,11 +139,3 @@ export function regionsOverlap(mine, theirs) {
     }
     return overlaps;
 }
-export function regionPatternsMatchPath(patterns, path) {
-    assertCanonicalRegionPath(path);
-    const pathSegments = path.split("/");
-    return patterns
-        .map((pattern) => compileRegionPattern(pattern))
-        .filter((pattern) => patternMatchesPath(pattern.segments, pathSegments))
-        .map((pattern) => pattern.source);
-}

package/build/src/body/render.js

@@ -38,7 +38,9 @@ function arcSection(arc) {
     ].join("\n\n");
 }
 export function renderContractBody(body, currentArc) {
-    const criteria = body.criteria.map((criterion) => `### ${criterion.title}\n\n${content(criterion.body)}`).join("\n\n");
+    const criteria = body.criteria
+        .map((criterion) => `### ${criterion.title}\n\n${content(criterion.body)}`)
+        .join("\n\n");
     const verification = body.verification.map(verificationFence).join("\n\n");
     return [
         `# ${body.title}`,
@@ -50,25 +52,28 @@ export function renderContractBody(body, currentArc) {
         ...(verification.length === 0 ? [] : [section(CONTRACT_SECTIONS.verification.title, verification)]),
         ...body.extensions.map((extension) => section(extension.title, extension.content)),
         ...(currentArc === undefined ? [] : [arcSection(currentArc)]),
-    ].join("\n\n").concat("\n");
+    ]
+        .join("\n\n")
+        .concat("\n");
 }
 function sections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
+    return indexedHeadings(indexDocument(document), { level: 2 }).filter((node) => node.type === "section");
 }
 export function renderAmendedContractBody(currentSource, body, changedSections) {
     const current = parseToAST(currentSource);
     const renderedSource = renderContractBody(body);
     const rendered = parseToAST(renderedSource);
     const currentSections = sections(current);
-    const preserved = new Map(currentSections.map((node) => [
-        normalizeTitle(node.title),
-        rawSlice(current, node.span),
-    ]));
+    const preserved = new Map(currentSections.map((node) => [normalizeTitle(node.title), rawSlice(current, node.span)]));
     const first = currentSections[0];
     const prefix = first === undefined ? currentSource : currentSource.slice(0, first.span.start);
-    return prefix + sections(rendered).map((node) => {
-        const name = normalizeTitle(node.title);
-        return changedSections.has(name) ? rawSlice(rendered, node.span) : preserved.get(name) ?? rawSlice(rendered, node.span);
-    }).join("");
+    return (prefix +
+        sections(rendered)
+            .map((node) => {
+            const name = normalizeTitle(node.title);
+            return changedSections.has(name)
+                ? rawSlice(rendered, node.span)
+                : (preserved.get(name) ?? rawSlice(rendered, node.span));
+        })
+            .join(""));
 }

package/build/src/body/shape.js

@@ -6,13 +6,7 @@ export const CONTRACT_SECTIONS = {
     criteria: { title: "Criteria", required: true },
     verification: { title: "Verification", required: false },
 };
-export const RESERVED_SECTIONS = new Set([
-    "gates",
-    "pipeline",
-    "after",
-    "arc",
-    "fulfillment",
-]);
+export const RESERVED_SECTIONS = new Set(["gates", "pipeline", "after", "arc", "fulfillment"]);
 export function contractSectionName(title) {
     for (const name of Object.keys(CONTRACT_SECTIONS)) {
         if (CONTRACT_SECTIONS[name].title === title)

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

@@ -6,7 +6,7 @@ type MutationCallOptions = Readonly<{
     projectRefusal?: (refusal: unknown) => unknown;
 }>;
 export declare function acceptedBind(result: BindResult, coordinates: Readonly<{
-    workspace: "worktree" | "here";
+    workspace: "worktree";
     target?: string;
 }>): AcceptedBindResult;
 export declare function acceptedAmend(result: AmendResult, coordinate: ContractId): AcceptedAmendResult;

package/build/src/cli/accepted.js

@@ -27,6 +27,13 @@ function acceptedRegion(result) {
         return { overlapFailure: result.overlapFailure };
     return { overlaps: result.overlaps };
 }
+function acceptedAmendRegion(result) {
+    if (result.overlapFailure !== undefined)
+        return { overlapFailure: result.overlapFailure };
+    if (result.overlaps !== undefined)
+        return { overlaps: result.overlaps };
+    return {};
+}
 export function acceptedBind(result, coordinates) {
     return {
         ...acceptedEnvelope(result, undefined),
@@ -41,7 +48,7 @@ export function acceptedAmend(result, coordinate) {
         ...acceptedEnvelope(result, coordinate),
         verb: "amend",
         diff: result.documentDiff,
-        ...acceptedRegion(result),
+        ...acceptedAmendRegion(result),
     };
 }
 export function acceptedDeliver(result, coordinate) {

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

@@ -30,7 +30,14 @@ async function invokeTell(command, input) {
             ...(input.repo === undefined ? {} : { repo: input.repo }),
         });
         const alias = inputAlias(command.akuma);
-        return { kind: "akuma", action: "tell", mode: "interrupt", result, body, ...(alias === undefined ? {} : { alias }) };
+        return {
+            kind: "akuma",
+            action: "tell",
+            mode: "interrupt",
+            result,
+            body,
+            ...(alias === undefined ? {} : { alias }),
+        };
     }
     const result = await Keiyaku.tell({
         path: input.path,
@@ -109,11 +116,16 @@ export async function invokeAkuma(command, input) {
             });
             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 await invokeHistory(command, input);
-        case "fork": return await invokeFork(command, input);
-        case "kill": return await invokeKill(command, input);
+        case "wait":
+            return await invokeWait(command, input);
+        case "tell":
+            return await invokeTell(command, input);
+        case "history":
+            return await invokeHistory(command, input);
+        case "fork":
+            return await invokeFork(command, input);
+        case "kill":
+            return await invokeKill(command, input);
     }
 }
 export async function invokeAkumaStatus(path, akuma, alias, repo) {

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

@@ -60,11 +60,5 @@ export declare function isParsedAkumaCommand(command: Readonly<{
 export declare function renderAkumaRootRows(): readonly string[];
 export declare function renderAkumaHelp(action: AkumaAction): string;
 export declare function renderAkumaUsage(action: AkumaAction): string;
-export declare function parseAkumaCatalogPath(value: string): Readonly<{
-    kind: "archetypes";
-} | {
-    kind: "akuma";
-    archetype?: string;
-}> | null;
 export declare function parseAkumaCommand(argv: readonly string[]): ParsedAkumaCommand;
 export {};

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

@@ -1,5 +1,5 @@
 import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
-import { archetypeName, parseAkuId } from "../../akuma/identity.js";
+import { 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";
@@ -19,12 +19,12 @@ const AKUMA_COMMAND_SPECS = {
         usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<prompt> | -)",
         purpose: "Birth an Akuma from <akuma-name> with one prompt.",
         details: [
-            "Give <prompt> as one argument, or use final - to read stdin.",
+            "Give <prompt> as one argument, or use - 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.",
             "--readonly adds the one-way read-only birth restriction.",
-            "Repeated --allowed replaces the Archetype list; --allowed none selects an empty list.",
+            "Repeated --allowed adds actions to the Archetype defaults.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
     },
@@ -42,7 +42,7 @@ const AKUMA_COMMAND_SPECS = {
         usage: "tell <aku/...|@alias> [--interrupt] (<prompt> | -)",
         purpose: "Send one prompt to an existing Akuma and wake it.",
         details: [
-            "Give <prompt> as one argument, or use final - to read stdin.",
+            "Give <prompt> as one argument, or use - to read stdin.",
             "--interrupt ends the current Body before recording the prompt and waking its successor.",
         ].join("\n"),
     },
@@ -84,16 +84,6 @@ export function renderAkumaHelp(action) {
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
-export function parseAkumaCatalogPath(value) {
-    if (value === "aku" || value === "aku/")
-        return { kind: "archetypes" };
-    if (value === "aku/*/*")
-        return { kind: "akuma" };
-    const match = /^aku\/([^/]+)\/?$/u.exec(value);
-    if (match === null)
-        return null;
-    return { kind: "akuma", archetype: archetypeName(match[1]) };
-}
 function stringFlag(value, diagnostic, fail) {
     if (typeof value !== "string")
         fail(diagnostic);
@@ -127,9 +117,7 @@ function scanNamedOption(input, flags, fail) {
     }
     if (isBlankInput(value))
         fail(`${token} requires a nonblank value`);
-    flags[name] = kind === "repeatable"
-        ? [...(Array.isArray(flags[name]) ? flags[name] : []), value]
-        : value;
+    flags[name] = kind === "repeatable" ? [...(Array.isArray(flags[name]) ? flags[name] : []), value] : value;
     return input.index + 1;
 }
 function scanAkuma(action, argv, fail) {
@@ -140,8 +128,10 @@ function scanAkuma(action, argv, fail) {
     for (let index = 1; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === "-") {
-            if (stdin || index !== argv.length - 1 || !spec.stdin)
+            if (!spec.stdin)
                 fail(`stdin marker '-' is not valid for ${action}`);
+            if (stdin)
+                fail("stdin marker '-' may appear only once");
             stdin = true;
         }
         else if (token === "-d") {
@@ -273,11 +263,6 @@ function parseAllowedFlag(raw, fail) {
     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");
     }
@@ -319,7 +304,9 @@ export function parseAkumaCommand(argv) {
         throw new CliUsageError(`unknown command: ${candidate ?? ""}`);
     const action = candidate;
     const spec = AKUMA_COMMAND_SPECS[action];
-    const fail = (message) => { throw new CliUsageError(message, renderAkumaUsage(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") {

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

@@ -1,5 +1,5 @@
 import { type ActorId, type Gate, type Keiyaku, type Repo, type WorktreeHooks } from "../../index.js";
-import type { ParsedAmend } from "../parse.js";
+import type { ParsedAmend } from "./contract.js";
 type AmendCommandInput = Readonly<{
     command: ParsedAmend;
     repo: Repo;
@@ -9,5 +9,5 @@ type AmendCommandInput = Readonly<{
     actor?: ActorId;
     hooks?: WorktreeHooks;
 }>;
-export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
+export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, hooks, }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
 export {};