@astrosheep/keiyaku 4.6.19 → 4.6.21

package/build/src/akuma-body.js

@@ -1,128 +1,23 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody, recordPluginDiagnostic, } from "./akuma/body.js";
-import { worldRootForAkumaPaths } from "./akuma/identity.js";
-import { composeRequestCommands } from "./akuma/request-wire.js";
-import { localExecutionContext } from "./akuma/requests.js";
-import { selectionRequestPort } from "./akuma/selection-owner-port.js";
-import { selectionRequestCommands } from "./akuma/selection-request.js";
-import { composeContractLibrary } from "./library/contract-composition.js";
-import { contractRequestCommands } from "./library/contract-operations.js";
-import { createKeiyakuHandle } from "./library/keiyaku.js";
-import { Repo } from "./library/repo.js";
-import { settings } from "./settings.js";
-import { Debts } from "./debt/index.js";
-import { debtMutationRequestCommands } from "./debt/mutation.js";
-import { World } from "./world.js";
-import { readSoul } from "./akuma/heart/index.js";
-async function contractDependencies(repoRoot, processConfiguration) {
-    const repo = await Repo.at({
-        path: repoRoot,
-        ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
-    });
-    if (repo.root !== repoRoot)
-        throw new TypeError("forwarded Contract repoRoot must equal the canonical primary worktree");
-    const world = await World.prove(repo.root);
-    const configuration = await settings({
-        root: world,
-        ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
-    });
-    return [repo, configuration];
-}
-function contractChannel(repo, contractId, requester, configuration) {
-    return composeContractLibrary(localExecutionContext(), createKeiyakuHandle, {
-        settings: configuration,
-        actor: requester,
-    }).select({
-        repo,
-        id: contractId,
-    });
-}
-function contractUpstream(processConfiguration) {
-    return {
-        previewDelivery: async (input) => {
-            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await contractChannel(repo, input.contractId, input.requester, configuration).previewDelivery({
-                includeDirty: input.includeDirty,
-                showDiff: input.showDiff,
-                signal: input.signal,
-            }, input.observe === undefined ? undefined : { observe: input.observe });
-        },
-        deliver: async (input) => {
-            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await contractChannel(repo, input.contractId, input.requester, configuration).deliver({
-                includeDirty: input.includeDirty,
-                materializeConflict: input.materializeConflict,
-                ...(input.message === undefined ? {} : { message: input.message }),
-                ...(input.overwrite === undefined ? {} : { overwrite: input.overwrite }),
-                signal: input.signal,
-            }, input.observe === undefined ? undefined : { observe: input.observe });
-        },
-        review: async (input) => {
-            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
-            return await contractChannel(repo, input.contractId, input.requester, configuration).review({
-                verdict: input.verdict,
-                ...(input.summary === undefined ? {} : { summary: input.summary }),
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                signal: input.signal,
-            }, input.observe === undefined ? undefined : { observe: input.observe });
-        },
-    };
-}
-const DEBT_LIFECYCLE = {
-    done: async (handle, input) => await handle.done(input),
-    drop: async (handle, input) => await handle.drop(input),
-};
-/**
- * The upper Body edge composes the forced-local Debts SDK the descriptor
- * execution entries consume. Each ability is one ordinary local product
- * operation; no generic debt(request) dispatcher is introduced here.
- */
-function debtMutationRequestPort() {
-    return {
-        add: async ({ world, options }) => await Debts.of(world).add(options),
-        addDocument: async ({ world, document }) => await Debts.of(world).addDocument(document),
-        update: async ({ world, id, options }) => await Debts.of(world).debt({ id }).update(options),
-        lifecycle: async ({ world, verb, id, note, signal }) => await DEBT_LIFECYCLE[verb](Debts.of(world).debt({ id }), {
-            ...(note === undefined ? {} : { note }),
-            ...(signal === undefined ? {} : { signal }),
-        }),
-        batch: async ({ world, verb, ids, note, signal }) => await Debts.of(world).batch({
-            verb,
-            ids,
-            ...(note === undefined ? {} : { note }),
-            ...(signal === undefined ? {} : { signal }),
-        }),
-    };
-}
-export async function externalRequestCommandsFor(launch, processConfiguration) {
-    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
-    const servingBody = launch.seed?.id ?? (await readSoul(launch.paths))?.id;
-    return {
-        world,
-        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, (message) => {
-            void recordPluginDiagnostic(launch.paths, "outcome observation", message);
-        }, servingBody)), contractRequestCommands(contractUpstream(processConfiguration)), debtMutationRequestCommands(debtMutationRequestPort())),
-    };
-}
-function bodyProcessConfiguration() {
-    const mappedHome = process.env.KEIYAKU_HOME?.trim();
-    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
-    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
-        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
-    }
-    return {
-        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
-        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
-    };
-}
+import { driveAkumaBody } from "./akuma/body.js";
+import { bodyLaunchSchema } from "./akuma/body-launch.js";
+import { LEASH_HELD_EXIT, spawnAkumaBody } from "./akuma/detached-body.js";
+import { externalRequestCommandsFor, bodyProcessConfiguration } from "./body-requests.js";
 async function runBodyEntrypoint() {
     const encoded = process.argv[2];
     if (encoded === undefined)
         throw new TypeError("Akuma body launch payload is missing");
     const launch = bodyLaunchSchema.parse(JSON.parse(Buffer.from(encoded, "base64url").toString("utf8")));
-    const { world, commands } = await externalRequestCommandsFor(launch, bodyProcessConfiguration());
-    if ((await runAkumaBody(launch, world, commands)) === "held")
+    const spawn = spawnAkumaBody;
+    const { world, commands, executionAssociation } = await externalRequestCommandsFor(launch, bodyProcessConfiguration(), spawn);
+    if ((await driveAkumaBody(launch, undefined, {
+        world,
+        externalCommands: commands,
+        executionAssociation,
+        spawn,
+        requestSpawn: spawn,
+    })) === "held")
         process.exitCode = LEASH_HELD_EXIT;
 }
 /** Only the spawned entrypoint launches a Body; importing this module composes commands without side effects. */

package/build/src/body-host.d.ts

@@ -0,0 +1,28 @@
+import type { BodyLauncher } from "./akuma/body-launch.js";
+export type AkumaHostOptions = Readonly<{
+    /** Detached by default. In-process Bodies share this Node runtime's lifetime. */
+    hosting?: "detached" | "in-process";
+    /** Plugin diagnostics produced in this host, never remote Body logs. */
+    reportDiagnostic?: (message: string) => void;
+}>;
+declare class ScopedAkumaHost {
+    #private;
+    static launcher(scope: ScopedAkumaHost): BodyLauncher;
+    readonly hosting: "in-process";
+    readonly reportDiagnostic?: (message: string) => void;
+    constructor(options?: Pick<AkumaHostOptions, "reportDiagnostic">);
+    /** Stop only this scope's exact launches. Hung/failed retirement rejects; no identity-wide kill is issued. */
+    close(): Promise<void>;
+}
+/** An ephemeral capability, not an Akuma identity set or persisted hosting policy. */
+export type AkumaHostScope = ScopedAkumaHost;
+export declare const AkumaHost: Readonly<{
+    /** Create an in-process launch scope. Pass the scope itself as the public host option. */
+    inProcess(options?: Pick<AkumaHostOptions, "reportDiagnostic">): AkumaHostScope;
+}>;
+/** Capture host capabilities once, independently of observation and request routing. */
+export declare function captureAkumaHost(host?: AkumaHostOptions): Readonly<{
+    spawn: BodyLauncher;
+    reportDiagnostic?: (message: string) => void;
+}>;
+export {};

package/build/src/body-host.js

@@ -0,0 +1,86 @@
+import { setMaxListeners } from "node:events";
+import { spawnAkumaBody } from "./akuma/detached-body.js";
+import { launchInProcessBody } from "./akuma/in-process-body.js";
+import { bodyProcessConfiguration, externalRequestCommandsFor } from "./body-requests.js";
+function inProcessLauncher(scopeSignal, enroll) {
+    const spawn = (launch) => {
+        scopeSignal?.throwIfAborted();
+        const pending = launchInProcessBody(launch, async (signal) => {
+            signal.throwIfAborted();
+            const { world, commands, executionAssociation } = await externalRequestCommandsFor(launch, bodyProcessConfiguration(), spawnAkumaBody);
+            return { world, externalCommands: commands, executionAssociation, spawn, requestSpawn: spawnAkumaBody };
+        }, undefined, scopeSignal);
+        // Every launch, including automatic succession, enrols before yielding.
+        enroll?.(pending);
+        return pending;
+    };
+    return spawn;
+}
+const inProcessBody = inProcessLauncher();
+class ScopedAkumaHost {
+    static launcher(scope) {
+        return scope.#launch;
+    }
+    hosting = "in-process";
+    reportDiagnostic;
+    #controller = new AbortController();
+    #active = new Set();
+    #failures = [];
+    #closing;
+    #launch;
+    constructor(options) {
+        setMaxListeners(0, this.#controller.signal);
+        const reportDiagnostic = captureAkumaHost(options).reportDiagnostic;
+        if (reportDiagnostic !== undefined)
+            this.reportDiagnostic = reportDiagnostic;
+        this.#launch = inProcessLauncher(this.#controller.signal, (pending) => {
+            const done = pending.then((child) => child.completed);
+            this.#active.add(done);
+            void done.then(() => this.#active.delete(done), (error) => {
+                this.#active.delete(done);
+                this.#failures.push(error);
+            });
+        });
+        Object.freeze(this);
+    }
+    /** Stop only this scope's exact launches. Hung/failed retirement rejects; no identity-wide kill is issued. */
+    close() {
+        if (this.#closing !== undefined)
+            return this.#closing;
+        this.#controller.abort(new Error("Akuma host scope is closed"));
+        this.#closing = (async () => {
+            await Promise.allSettled([...this.#active]);
+            if (this.#failures.length)
+                throw new AggregateError(this.#failures, "Akuma host scope retirement failed");
+        })();
+        return this.#closing;
+    }
+}
+export const AkumaHost = Object.freeze({
+    /** Create an in-process launch scope. Pass the scope itself as the public host option. */
+    inProcess(options) {
+        return new ScopedAkumaHost(options);
+    },
+});
+/** Capture host capabilities once, independently of observation and request routing. */
+export function captureAkumaHost(host) {
+    if (host !== undefined && (typeof host !== "object" || host === null || Array.isArray(host)))
+        throw new TypeError("Akuma host options must be an object");
+    const unknown = Object.keys(host ?? {}).find((key) => key !== "reportDiagnostic" && key !== "hosting");
+    if (unknown !== undefined)
+        throw new TypeError(`Akuma host options has unknown field: ${unknown}`);
+    const hosting = host?.hosting;
+    if (hosting !== undefined && hosting !== "detached" && hosting !== "in-process")
+        throw new TypeError("Akuma host hosting must be detached or in-process");
+    const reportDiagnostic = host?.reportDiagnostic;
+    if (reportDiagnostic !== undefined && typeof reportDiagnostic !== "function")
+        throw new TypeError("Akuma host reportDiagnostic must be a function");
+    return Object.freeze({
+        spawn: host instanceof ScopedAkumaHost
+            ? ScopedAkumaHost.launcher(host)
+            : hosting === "in-process"
+                ? inProcessBody
+                : spawnAkumaBody,
+        ...(reportDiagnostic === undefined ? {} : { reportDiagnostic }),
+    });
+}

package/build/src/body-requests.d.ts

@@ -0,0 +1,13 @@
+import type { BodyLaunch, BodyLauncher } from "./akuma/body-launch.js";
+import { World } from "./world.js";
+import type { ExecutionAssociationReader } from "./akuma/execution-instructions.js";
+export type BodyProcessConfiguration = Readonly<{
+    home?: string;
+    gitPath?: string;
+}>;
+export declare function externalRequestCommandsFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration, spawn: BodyLauncher): Promise<Readonly<{
+    world: Awaited<ReturnType<typeof World.prove>>;
+    commands: Readonly<Record<string, import("./akuma/request-wire.js").ErasedRequestCommand>>;
+    executionAssociation: ExecutionAssociationReader;
+}>>;
+export declare function bodyProcessConfiguration(): BodyProcessConfiguration;

package/build/src/body-requests.js

@@ -0,0 +1,131 @@
+import { worldRootForAkumaPaths } from "./akuma/identity.js";
+import { composeRequestCommands } from "./akuma/request-wire.js";
+import { localExecutionContext } from "./akuma/requests.js";
+import { selectionRequestPort } from "./akuma/selection-owner-port.js";
+import { selectionRequestCommands } from "./akuma/selection-request.js";
+import { composeContractLibrary } from "./library/contract-composition.js";
+import { contractRequestCommands } from "./library/contract-operations.js";
+import { createKeiyakuHandle } from "./library/keiyaku.js";
+import { Repo } from "./library/repo.js";
+import { settings } from "./settings.js";
+import { Debts } from "./debt/index.js";
+import { debtMutationRequestCommands } from "./debt/mutation.js";
+import { World } from "./world.js";
+import { readSoul } from "./akuma/heart/index.js";
+import { readDispatch } from "./dispatch/index.js";
+import { NoGitWorldError, repositoryAt } from "./git/repository.js";
+async function contractDependencies(repoRoot, processConfiguration) {
+    const repo = await Repo.at({
+        path: repoRoot,
+        ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+    });
+    if (repo.root !== repoRoot)
+        throw new TypeError("forwarded Contract repoRoot must equal the canonical primary worktree");
+    const world = await World.prove(repo.root);
+    const configuration = await settings({
+        root: world,
+        ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+    });
+    return [repo, configuration];
+}
+function contractChannel(repo, contractId, requester, configuration) {
+    return composeContractLibrary(localExecutionContext(), createKeiyakuHandle, {
+        settings: configuration,
+        actor: requester,
+    }).select({
+        repo,
+        id: contractId,
+    });
+}
+function contractUpstream(processConfiguration) {
+    return {
+        previewDelivery: async (input) => {
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
+            return await contractChannel(repo, input.contractId, input.requester, configuration).previewDelivery({
+                includeDirty: input.includeDirty,
+                showDiff: input.showDiff,
+                signal: input.signal,
+            }, input.observe === undefined ? undefined : { observe: input.observe });
+        },
+        deliver: async (input) => {
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
+            return await contractChannel(repo, input.contractId, input.requester, configuration).deliver({
+                includeDirty: input.includeDirty,
+                materializeConflict: input.materializeConflict,
+                ...(input.message === undefined ? {} : { message: input.message }),
+                ...(input.overwrite === undefined ? {} : { overwrite: input.overwrite }),
+                signal: input.signal,
+            }, input.observe === undefined ? undefined : { observe: input.observe });
+        },
+        review: async (input) => {
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
+            return await contractChannel(repo, input.contractId, input.requester, configuration).review({
+                verdict: input.verdict,
+                ...(input.summary === undefined ? {} : { summary: input.summary }),
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                signal: input.signal,
+            }, input.observe === undefined ? undefined : { observe: input.observe });
+        },
+    };
+}
+const DEBT_LIFECYCLE = {
+    done: async (handle, input) => await handle.done(input),
+    drop: async (handle, input) => await handle.drop(input),
+};
+/**
+ * The upper Body edge composes the forced-local Debts SDK the descriptor
+ * execution entries consume. Each ability is one ordinary local product
+ * operation; no generic debt(request) dispatcher is introduced here.
+ */
+function debtMutationRequestPort() {
+    return {
+        add: async ({ world, options }) => await Debts.of(world).add(options),
+        addDocument: async ({ world, document }) => await Debts.of(world).addDocument(document),
+        update: async ({ world, id, options }) => await Debts.of(world).debt({ id }).update(options),
+        lifecycle: async ({ world, verb, id, note, signal }) => await DEBT_LIFECYCLE[verb](Debts.of(world).debt({ id }), {
+            ...(note === undefined ? {} : { note }),
+            ...(signal === undefined ? {} : { signal }),
+        }),
+        batch: async ({ world, verb, ids, note, signal }) => await Debts.of(world).batch({
+            verb,
+            ids,
+            ...(note === undefined ? {} : { note }),
+            ...(signal === undefined ? {} : { signal }),
+        }),
+    };
+}
+export async function externalRequestCommandsFor(launch, processConfiguration, spawn) {
+    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
+    const servingBody = launch.seed?.id ?? (await readSoul(launch.paths))?.id;
+    return {
+        world,
+        executionAssociation: async () => {
+            if (servingBody !== undefined) {
+                try {
+                    const dispatch = await readDispatch(await repositoryAt(world), servingBody);
+                    if (dispatch !== null)
+                        return { contractId: dispatch.contractId };
+                }
+                catch (error) {
+                    if (!(error instanceof NoGitWorldError)) {
+                        console.error(`Keiyaku execution association unavailable for ${servingBody}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            const contractId = launch.completion?.contractId;
+            return contractId === undefined ? undefined : { contractId };
+        },
+        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, spawn, servingBody)), contractRequestCommands(contractUpstream(processConfiguration)), debtMutationRequestCommands(debtMutationRequestPort())),
+    };
+}
+export function bodyProcessConfiguration() {
+    const mappedHome = process.env.KEIYAKU_HOME?.trim();
+    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
+    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
+        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
+    }
+    return {
+        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
+        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
+    };
+}

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

@@ -24,10 +24,14 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     mode: "wait" | "detach";
     timeoutMs?: number;
     allowed?: AllowedActions;
+    writableDirectories?: readonly string[];
+    bare?: boolean;
     schema?: string;
 }> & Readonly<{
     prompt?: AkumaPromptSource;
-}>) | Readonly<{
+}>) | (Readonly<{
+    command: "report";
+}> & Prompted) | Readonly<{
     command: "kill";
     akuma: readonly string[];
 }> | Readonly<{
@@ -58,10 +62,13 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
 }> | (Readonly<{
     command: "fork";
     at: string;
+    bare?: boolean;
 }> & Addressed));
 export type InvokedAkumaCommand = Exclude<ParsedAkumaCommand, {
     command: "history";
     contract: string;
+} | {
+    command: "report";
 }>;
 export type AkumaAction = ParsedAkumaCommand["command"];
 export declare function isAkumaAction(value: string | undefined): value is AkumaAction;

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

@@ -9,6 +9,14 @@ const SET_SELECTORS = '(<aku/...> | @alias | <kei/...> | "aku/<name-pattern>/<he
 const SET_DETAILS = "Globs contain * and use lowercase hex digits or * in the suffix. --repo requires at least one Contract (kei/...) selector.";
 const SCHEMA_DETAILS = "--schema supplies a JSON Schema answer contract to the provider; on observation the CLI parses JSON but does not independently validate schema conformance.";
 const AKUMA_COMMAND_SPECS = {
+    report: {
+        arity: 1,
+        stdin: true,
+        flags: { json: "boolean" },
+        usage: "report (<text> | -) [--json]",
+        purpose: "Record progress in the invoking Akuma's Heart without ending work.",
+        details: "Give one nonblank text argument, or - to read stdin. Requires explicit Akuma, World, Body and Turn execution declarations; no recipient or parent forwarding. Recorded means persisted, not received.",
+    },
     call: {
         arity: 1,
         stdin: true,
@@ -17,18 +25,23 @@ const AKUMA_COMMAND_SPECS = {
             alias: "value",
             wait: "value",
             allowed: "repeat",
+            "add-dir": "repeat",
+            bare: "boolean",
             json: "boolean",
             schema: "value",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--repo <path>] [--workdir <path>] [--alias <name>] [--allowed <product.action>]... [--schema <file>] [--wait <duration>] [<prompt> | -]",
+        usage: "call <akuma-name> [--contract <kei/...>] [--repo <path>] [--workdir <path>] [--alias <name>] [--allowed <product.action>]... [--add-dir <path>]... [--bare] [--schema <file>] [--wait <duration>] [<prompt> | -]",
         purpose: "Call an Akuma into the world.",
         details: [
             "Use keiyaku ls aku/ to find visible Akuma names; hidden definitions can still be called by name.",
             "Omit the prompt to birth without a Tell; otherwise give <prompt> as one argument, or use - to read stdin.",
             "--schema and --wait require a prompt.",
+            "--bare omits Keiyaku's runtime instruction section for this birth and its later execution; personality, tools, permissions, and report remain unchanged.",
+            "Generic ACP needs --bare: it has no verified native runtime-instruction channel. Existing sessions without the section are not retrofitted; ordinary resume retains existing native instructions.",
             "By default, call returns after birth and optional first Tell admission; --wait also waits for its first answer, up to the given duration.",
             "--contract records an association, not the work or execution directory; include the Contract and worktree context in the prompt as needed. --repo requires --contract.",
             "--workdir selects where the Akuma works; relative paths resolve from the invocation directory selected by -C/--cwd, or the process cwd when omitted. Without --workdir, the invocation directory is used.",
+            "--add-dir explicitly grants another existing writable directory to Codex native workspace-write tools; repeat for multiple roots. Relative paths resolve from the invocation directory. Other sandbox modes, permission profiles, and providers refuse nonempty grants instead of broadening policy. Existing network policy and writable roots are preserved. This is separate from --allowed product actions and never grants the repo or Home automatically.",
             "--alias <name> gives the new Akuma the selector @name instead of aku/<id>; an existing @name is reassigned to this Akuma.",
             `Default actions: ${DEFAULT_ALLOWED_ACTIONS.join(", ")}.`,
             ...(EXTRA_ALLOWED_ACTIONS.length === 0
@@ -108,10 +121,13 @@ const AKUMA_COMMAND_SPECS = {
     fork: {
         arity: 1,
         stdin: false,
-        flags: { at: "value", json: "boolean" },
-        usage: "fork <aku/...|@alias> --at <historyId> [--repo <path>]",
+        flags: { at: "value", bare: "boolean", json: "boolean" },
+        usage: "fork <aku/...|@alias> --at <historyId> [--bare] [--repo <path>]",
         purpose: "Create a new Akuma from an answered turn.",
-        details: "--at takes a retained answered turn id (turn/<n>); find its historyId in paged keiyaku history <aku/...|@alias> --json. Fork also requires a retained provider fork point.",
+        details: [
+            "--at takes a retained answered turn id (turn/<n>); find its historyId in paged keiyaku history <aku/...|@alias> --json. Fork also requires a retained provider fork point.",
+            "A fork inherits bare; --bare additionally omits only the child's Keiyaku runtime instructions.",
+        ].join("\n"),
     },
     kill: {
         arity: "one-or-more",
@@ -126,7 +142,9 @@ export function isAkumaAction(value) {
     return value !== undefined && Object.hasOwn(AKUMA_COMMAND_SPECS, value);
 }
 export function isParsedAkumaCommand(command) {
-    return isAkumaAction(command.command) && !("contract" in command && command.command === "history");
+    return (isAkumaAction(command.command) &&
+        command.command !== "report" &&
+        !("contract" in command && command.command === "history"));
 }
 export function renderAkumaRootRows() {
     return Object.entries(AKUMA_COMMAND_SPECS).map(([action, spec]) => `  ${action.padEnd(10)} ${spec.purpose}`);
@@ -256,7 +274,7 @@ function parseAddressed(action, rawSelectors, flags, output, fail) {
     }
     const akuma = rawSelectors[0];
     const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
-    return { command: action, akuma, at, output };
+    return { command: action, akuma, at, ...(flags.bare === true ? { bare: true } : {}), output };
 }
 function parsePrompted(action, positionals, stdin, fail) {
     if (positionals.length === 0)
@@ -338,11 +356,21 @@ function parseCall(flags, archetype, prompt, output, fail) {
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(allowed === undefined ? {} : { allowed }),
+        ...(flags["add-dir"] === undefined ? {} : { writableDirectories: flags["add-dir"] }),
+        ...(flags.bare === true ? { bare: true } : {}),
         ...(schema === undefined ? {} : { schema }),
         ...(prompt === undefined ? {} : { prompt }),
         output,
     };
 }
+function parseReport(positionals, stdin, output, fail) {
+    if (stdin ? positionals.length !== 0 : positionals.length !== 1)
+        fail("report requires one text argument or stdin, not both");
+    const value = positionals[0];
+    if (value !== undefined && value.trim() === "")
+        fail("report requires nonblank text");
+    return { command: "report", output, prompt: stdin ? { kind: "stdin" } : { kind: "argument", value: value } };
+}
 export function parseAkumaCommand(argv) {
     const candidate = argv[0];
     if (!isAkumaAction(candidate))
@@ -354,6 +382,8 @@ export function parseAkumaCommand(argv) {
     };
     const { flags, positionals, stdin } = scanArgs(argv, scanSpec(action, spec), fail);
     const output = flags.json === true ? "json" : "text";
+    if (action === "report")
+        return parseReport(positionals, stdin !== undefined, output, fail);
     if (action === "call" || action === "tell" || action === "ask") {
         const parsed = parsePrompted(action, positionals, stdin !== undefined, fail);
         return action === "call"

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

@@ -106,6 +106,8 @@ async function runCall(command, input) {
         ...(input.contract === undefined ? {} : { contract: input.contract }),
         ...(command.alias === undefined ? {} : { alias: command.alias }),
         ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
+        ...(input.writableDirectories === undefined ? {} : { writableDirectories: input.writableDirectories }),
+        ...(command.bare === undefined ? {} : { bare: command.bare }),
         ...(schema === undefined ? {} : { schema }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     };
@@ -267,6 +269,7 @@ async function runFork(command, input) {
         ...(caller === undefined ? {} : { caller }),
         akuma: command.akuma,
         at: command.at,
+        ...(command.bare === undefined ? {} : { bare: command.bare }),
         ...(input.repo === undefined ? {} : { repo: input.repo }),
     });
     return emit(command.output, receipt, () => renderForkText(receipt), forkOutcome(receipt));
@@ -299,6 +302,13 @@ async function callExecutionCwd(command, cwd, workdir) {
 async function akumaInput(command, coordinates, workdir, runtime) {
     const path = await akumaWorld(command, coordinates);
     const executionCwd = await callExecutionCwd(command, coordinates.cwd, workdir);
+    const writableDirectories = command.command !== "call" || command.writableDirectories === undefined
+        ? undefined
+        : await Promise.all(command.writableDirectories.map((path) => {
+            if (path.trim() === "")
+                throw new TypeError("--add-dir requires a nonblank directory");
+            return canonicalBirthCwd(resolve(coordinates.cwd, path));
+        }));
     const execution = runtime.execution;
     const home = command.command === "call" ? runtime.home : undefined;
     const configuration = command.command === "call" ? await settingsAt(path, home) : undefined;
@@ -310,6 +320,7 @@ async function akumaInput(command, coordinates, workdir, runtime) {
     return {
         path,
         ...(executionCwd === undefined ? {} : { executionCwd }),
+        ...(writableDirectories === undefined ? {} : { writableDirectories }),
         ...(home === undefined ? {} : { home }),
         ...(configuration === undefined ? {} : { settings: configuration }),
         ...(contract === undefined ? {} : { contract }),

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

@@ -0,0 +1,6 @@
+import type { CliRuntime } from "../runtime.js";
+import { type CliOutcome } from "../streams.js";
+import type { ParsedAkumaCommand } from "./akuma-grammar.js";
+export declare function runReport(command: Extract<ParsedAkumaCommand, {
+    command: "report";
+}>, runtime: CliRuntime): Promise<CliOutcome>;

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

@@ -0,0 +1,31 @@
+import { Akuma } from "../../index.js";
+import { akumaCallerFromEnvironment } from "../akuma-caller.js";
+import { emit, writeStderr } from "../streams.js";
+import { CliUsageError } from "../usage.js";
+function executionSequence(environment, key) {
+    const value = environment[key];
+    if (value === undefined || !/^[1-9][0-9]*$/u.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new CliUsageError(`report requires an explicit positive execution coordinate: ${key}`);
+    return Number(value);
+}
+export async function runReport(command, runtime) {
+    const text = command.prompt.kind === "stdin" ? await runtime.readStdin() : command.prompt.value;
+    if (text.trim() === "")
+        throw new CliUsageError("report requires nonblank text");
+    const environment = runtime.environment;
+    if (environment.KEIYAKU_ACTOR_ID === undefined || environment.KEIYAKU_ACTOR_WORLD === undefined)
+        throw new CliUsageError("report requires explicit KEIYAKU_ACTOR_ID and KEIYAKU_ACTOR_WORLD");
+    const bodySequence = executionSequence(environment, "KEIYAKU_BODY_SEQUENCE");
+    const turnSequence = executionSequence(environment, "KEIYAKU_TURN_SEQUENCE");
+    const caller = await akumaCallerFromEnvironment(environment);
+    if (caller?.kind !== "akuma")
+        throw new CliUsageError("report requires explicit Akuma identity");
+    const result = await Akuma.select(caller.world, caller.akuId, { reportDiagnostic: writeStderr }).report(text, {
+        bodySequence,
+        turnSequence,
+        signal: runtime.signal,
+    });
+    return emit(command.output, result, () => result.kind === "recorded"
+        ? `recorded ${caller.akuId} report/${result.report.sequence} · body/${bodySequence} · turn/${turnSequence}`
+        : `refused report · ${result.reason}`, result.kind === "recorded" ? "accepted" : "refused");
+}

package/build/src/cli/parse.js

@@ -129,6 +129,7 @@ export function commandRepoPolicy(command) {
                 use: command.contract === undefined ? "none" : "required",
                 acceptsExplicit: command.contract !== undefined,
             };
+        case "report":
         case "settings":
         case "nuke":
         case "debt":