@astrosheep/keiyaku 4.0.5 → 4.1.0

package/build/src/akuma/providers/index.js

@@ -1,50 +1,50 @@
 import { decodeProviderRecipe } from "../provider-recipe.js";
-import { createAcpProvider, decodeAcpConfig } from "./acp/index.js";
-import { claudeProvider, createClaudeProvider } from "./claude/index.js";
-import { createCodexAppServerProvider } from "./codex-app-server/index.js";
-import { createGrokBuildProvider } from "./grok-build/index.js";
-import { createOpencodeProvider } from "./opencode-sdk/index.js";
-import { createPiProvider } from "./pi/index.js";
-const PROVIDERS = {
-    claude: claudeProvider,
-};
-function providerConfig(execution) {
-    const { config, kind } = execution;
-    if (kind === "claude-agent-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
-    if (kind === "opencode-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by opencode-sdk");
-    if (kind === "acp")
-        return decodeAcpConfig(config);
-    return config;
+import { decodeAcpConfig } from "./acp/config.js";
+export function decodeProviderExecution(input) {
+    const decoded = decodeProviderRecipe(input);
+    if ((decoded.kind === "claude-agent-sdk" || decoded.kind === "opencode-sdk") && decoded.config !== undefined) {
+        throw new TypeError(`provider execution config is unsupported by ${decoded.kind}`);
+    }
+    if (decoded.kind === "pi") {
+        if (decoded.executable !== undefined || decoded.config !== undefined) {
+            throw new TypeError("Pi provider does not support executable or config");
+        }
+        if (decoded.env !== undefined && Object.keys(decoded.env).length > 0) {
+            throw new TypeError("env injection not supported for provider pi");
+        }
+    }
+    if (decoded.kind === "grok-build" && decoded.config !== undefined) {
+        throw new TypeError("Grok Build does not support execution config");
+    }
+    const config = decoded.kind === "acp" ? decodeAcpConfig(decoded.config) : decoded.config;
+    return Object.freeze({
+        name: decoded.name,
+        kind: decoded.kind,
+        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
+        ...(config === undefined ? {} : { config }),
+        ...(decoded.env === undefined ? {} : { env: decoded.env }),
+    });
 }
-function adapterFor(execution) {
+async function adapterFor(execution) {
     if (execution.kind === "acp")
-        return createAcpProvider(execution);
+        return (await import("./acp/index.js")).createAcpProvider(execution);
     if (execution.kind === "claude-agent-sdk") {
+        const { claudeProvider, createClaudeProvider } = await import("./claude/index.js");
         return execution.executable === undefined && execution.env === undefined
-            ? PROVIDERS.claude
-            : createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"), execution);
+            ? claudeProvider
+            : createClaudeProvider(execution);
     }
     if (execution.kind === "codex-app-server")
-        return createCodexAppServerProvider(execution);
+        return (await import("./codex-app-server/index.js")).createCodexAppServerProvider(execution);
     if (execution.kind === "grok-build")
-        return createGrokBuildProvider(execution);
+        return (await import("./grok-build/index.js")).createGrokBuildProvider(execution);
     if (execution.kind === "opencode-sdk")
-        return createOpencodeProvider(execution);
+        return (await import("./opencode-sdk/index.js")).createOpencodeProvider(execution);
     if (execution.kind === "pi")
-        return createPiProvider(execution);
+        return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }
-export function resolveProviderExecution(input) {
-    const decoded = decodeProviderRecipe(input);
-    const config = providerConfig(decoded);
-    const execution = Object.freeze({
-        name: decoded.name,
-        kind: decoded.kind,
-        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
-        ...(config === undefined ? {} : { config }),
-        ...(decoded.env === undefined ? {} : { env: decoded.env }),
-    });
-    return Object.freeze({ execution, adapter: adapterFor(execution) });
+export async function resolveProviderExecution(input) {
+    const execution = decodeProviderExecution(input);
+    return Object.freeze({ execution, adapter: await adapterFor(execution) });
 }

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -24,6 +24,9 @@ function opencodeSessionId(coordinateValue) {
 function admit(options) {
     if (options.network !== undefined)
         throw new Error("OpenCode does not support explicit network");
+    if (options.systemPromptMode === "replace") {
+        throw new Error("OpenCode V1 does not support replacing the native system prompt");
+    }
     if (options.model !== undefined)
         parseModel(options.model);
 }
@@ -195,6 +198,11 @@ function terminalSettlement(events, close) {
     });
     return { completion, finish };
 }
+async function forceDisposeOpencode(abortController, close, finish) {
+    abortController.abort();
+    await close();
+    await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
+}
 async function drive(execution, input, loader) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -256,6 +264,7 @@ async function drive(execution, input, loader) {
                 void session.abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true }).catch(() => undefined);
                 await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
             },
+            forceDispose: () => forceDisposeOpencode(abortController, closeOnce, finish),
         };
     }
     catch (error) {

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -1,4 +1,4 @@
-import { type OpencodeClient } from "@opencode-ai/sdk";
+import type { OpencodeClient } from "@opencode-ai/sdk";
 import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -1,7 +1,6 @@
 import net from "node:net";
 import { abortable } from "../../abort.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
-import { createOpencodeClient } from "@opencode-ai/sdk";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
 export function parseModel(model) {
     const slash = model.indexOf("/");
@@ -50,6 +49,7 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         env: { ...process.env, ...execution.env },
         log: `${cwd}/.opencode.log`,
     });
+    const { createOpencodeClient } = await import("@opencode-ai/sdk");
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
     try {
         await waitReady(client, cwd, signal);

package/build/src/akuma/providers/pi/index.d.ts

@@ -1,4 +1,4 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{

package/build/src/akuma/providers/pi/index.js

@@ -1,4 +1,3 @@
-import { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { abortable } from "../../abort.js";
 import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
@@ -33,7 +32,9 @@ async function piCreateOptions(sdk, input) {
     const resourceLoader = input.options.systemPrompt === undefined ? undefined : new sdk.DefaultResourceLoader({
         cwd: input.cwd,
         agentDir: sdk.getAgentDir(),
-        systemPromptOverride: () => input.options.systemPrompt,
+        ...(input.options.systemPromptMode === "append"
+            ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
+            : { systemPromptOverride: () => input.options.systemPrompt }),
     });
     await resourceLoader?.reload();
     const sessionManager = input.session.kind === "fresh"
@@ -41,6 +42,14 @@ async function piCreateOptions(sdk, input) {
         : "sessionFile" in input.session.coordinate
             ? sdk.SessionManager.open(input.session.coordinate.sessionFile)
             : (() => { throw new Error("Pi resume requires sessionFile"); })();
+    const customTools = input.requests === undefined || input.options.readonly === true
+        ? undefined
+        : [(await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
+                spawnHook: (context) => ({
+                    ...context,
+                    env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                }),
+            })];
     return {
         cwd: input.cwd,
         sessionManager,
@@ -48,20 +57,19 @@ async function piCreateOptions(sdk, input) {
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
-        ...(input.requests === undefined || input.options.readonly === true
-            ? {}
-            : { customTools: [createBashToolDefinition(input.cwd, {
-                        spawnHook: (context) => ({
-                            ...context,
-                            env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
-                        }),
-                    })] }),
+        ...(customTools === undefined ? {} : { customTools }),
     };
 }
 async function createPiSession(sdk, input, signal) {
     const setup = piCreateOptions(sdk, input).then(async (options) => await sdk.createAgentSession(options));
     return await abortable(setup, signal, (created) => created.session.dispose());
 }
+function forceDisposePi(dispose, settle, setAborting) {
+    setAborting();
+    dispose();
+    settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
+    return Promise.resolve();
+}
 async function drivePi(sdk, input, signal) {
     const created = await createPiSession(sdk, input, signal);
     const native = created.session;
@@ -155,6 +163,7 @@ async function drivePi(sdk, input, signal) {
             })();
             return abortRequest;
         },
+        forceDispose: () => forceDisposePi(dispose, settle, () => { aborting = true; }),
     };
 }
 function piSessionFile(coordinate) {
@@ -170,8 +179,17 @@ async function forkPi(sdk, input) {
         throw new Error("Pi fork did not create a distinct child session file");
     return { session: { sessionFile: child } };
 }
-const defaultSdk = { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager };
-export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = async () => defaultSdk) {
+async function loadPiSdk() {
+    const sdk = await import("@earendil-works/pi-coding-agent");
+    return {
+        createAgentSession: sdk.createAgentSession,
+        DefaultResourceLoader: sdk.DefaultResourceLoader,
+        getAgentDir: sdk.getAgentDir,
+        ModelRuntime: sdk.ModelRuntime,
+        SessionManager: sdk.SessionManager,
+    };
+}
+export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = loadPiSdk) {
     if (execution.executable !== undefined || execution.config !== undefined) {
         throw new TypeError("Pi provider does not support executable or config");
     }

package/build/src/akuma/request-serve.d.ts

@@ -41,6 +41,7 @@ export type UpstreamExecutionPort = Readonly<{
     deliver(input: ContractCall & Readonly<{
         message?: string;
         includeDirty: boolean;
+        materializeConflict: boolean;
     }>): Promise<Readonly<{
         result: unknown;
         deliveryFactId?: string;

package/build/src/akuma/request-serve.js

@@ -222,6 +222,7 @@ async function executeDeliver(input, request) {
         contractId: request.contractId,
         ...(request.message === undefined ? {} : { message: request.message }),
         includeDirty: request.includeDirty,
+        materializeConflict: request.materializeConflict,
         requester: request.requester,
         signal: input.signal,
     });
@@ -303,12 +304,8 @@ async function serveUpstream(input) {
     try {
         const served = await execute(input, request);
         outcome = { kind: "returned", result: served.result };
-        if (served.service === undefined) {
-            fact = await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference");
-            await projectReceipt(input.directory, fact);
-            return;
-        }
-        service = served.service;
+        if (served.service !== undefined)
+            service = served.service;
     }
     catch (error) {
         outcome = { kind: "failed", failure: failure(error) };
@@ -368,37 +365,40 @@ export class BodyRequestPump {
         return new BodyRequestPump(input);
     }
     async run() {
-        try {
-            while (!this.closeSignal.signal.aborted) {
-                for (const name of await requestFiles(this.directory)) {
-                    if (this.closeSignal.signal.aborted)
-                        return;
-                    const id = name.slice(0, -".request.json".length);
-                    if (this.handled.has(id))
-                        continue;
-                    const claim = decodeClaim(await readFile(join(this.directory, name), "utf8"), id);
-                    if (claim !== null && !this.admissionClosed) {
-                        await serve({
-                            directory: this.directory,
-                            claim,
-                            ...this.input,
-                            signal: this.executionSignal.signal,
-                            admissionOpen: () => !this.admissionClosed,
-                        });
-                    }
+        while (!this.closeSignal.signal.aborted) {
+            for (const name of await requestFiles(this.directory)) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                const id = name.slice(0, -".request.json".length);
+                if (this.handled.has(id))
+                    continue;
+                const path = join(this.directory, name);
+                const claim = decodeClaim(await readFile(path, "utf8"), id);
+                if (claim === null) {
+                    await rm(path, { force: true });
                     this.handled.add(id);
+                    continue;
                 }
-                try {
-                    await abortableDelay(POLL_MS, this.closeSignal.signal);
+                if (!this.admissionClosed) {
+                    await serve({
+                        directory: this.directory,
+                        claim,
+                        ...this.input,
+                        signal: this.executionSignal.signal,
+                        admissionOpen: () => !this.admissionClosed,
+                    });
                 }
-                catch {
+                this.handled.add(id);
+            }
+            try {
+                await abortableDelay(POLL_MS, this.closeSignal.signal);
+            }
+            catch (error) {
+                if (this.closeSignal.signal.aborted)
                     return;
-                }
+                throw error;
             }
         }
-        catch {
-            // Request transport loss is recovered from Heart on the next Body.
-        }
     }
     async close() {
         this.stopAdmission();

package/build/src/akuma/request-wire.d.ts

@@ -1,11 +1,11 @@
 import { type AkuId } from "./identity.js";
 import { decodeProviderOptions, type ReadonlyRestraint } from "./provider-recipe.js";
-import { resolveProviderExecution } from "./providers/index.js";
+import { decodeProviderExecution } from "./providers/index.js";
 import { type TaskMutationAction, type TaskMutationRequest } from "../task/mutation.js";
 export type RequestRecipe = Readonly<{
     description?: string;
     allowed: readonly string[];
-    provider: ReturnType<typeof resolveProviderExecution>["execution"];
+    provider: ReturnType<typeof decodeProviderExecution>;
     options: ReturnType<typeof decodeProviderOptions>;
     readonly?: ReadonlyRestraint;
 }>;
@@ -43,6 +43,7 @@ export type DeliverRequestClaim = Readonly<{
     contractId: string;
     message?: string;
     includeDirty: boolean;
+    materializeConflict: boolean;
 }>;
 export type ReviewRequestClaim = Readonly<{
     id: string;

package/build/src/akuma/request-wire.js

@@ -4,7 +4,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { decodeAllowedActions } from "./allowed.js";
 import { archetypeName, parseAkuId } from "./identity.js";
 import { decodeProviderOptions, decodeReadonlyRestraint, } from "./provider-recipe.js";
-import { resolveProviderExecution } from "./providers/index.js";
+import { decodeProviderExecution } from "./providers/index.js";
 import { decodeTaskMutationRequest, isTaskMutationAction, } from "../task/mutation.js";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 function object(value) {
@@ -69,7 +69,7 @@ export function decodeRecipe(value) {
         return Object.freeze({
             ...(recipe.description === undefined ? {} : { description: recipe.description }),
             allowed: decodeAllowedActions(recipe.allowed),
-            provider: resolveProviderExecution(recipe.provider).execution,
+            provider: decodeProviderExecution(recipe.provider),
             options,
             ...(readonly === undefined ? {} : { readonly }),
         });
@@ -153,6 +153,7 @@ function decodeDeliver(id, payload) {
     const valid = exactKeys(payload, [
         "contractId",
         "includeDirty",
+        "materializeConflict",
         "repoRoot",
         ...(payload.message === undefined ? [] : ["message"]),
     ]);
@@ -161,6 +162,7 @@ function decodeDeliver(id, payload) {
         && selected !== null
         && absolute(payload.repoRoot)
         && typeof payload.includeDirty === "boolean"
+        && typeof payload.materializeConflict === "boolean"
         && (payload.message === undefined
             || (typeof payload.message === "string"
                 && payload.message.trim().length > 0))
@@ -170,6 +172,7 @@ function decodeDeliver(id, payload) {
             repoRoot: payload.repoRoot,
             contractId: selected,
             includeDirty: payload.includeDirty,
+            materializeConflict: payload.materializeConflict,
             ...(payload.message === undefined
                 ? {}
                 : { message: payload.message }),

package/build/src/akuma-body.js

@@ -48,6 +48,7 @@ export function upstreamFor(launch, processConfiguration) {
                 requester: input.requester,
                 ...(input.message === undefined ? {} : { message: input.message }),
                 includeDirty: input.includeDirty,
+                materializeConflict: input.materializeConflict,
                 requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
                 hooks: worktreeHooksFrom({ settings: configuration }),
                 signal: input.signal,
@@ -81,4 +82,17 @@ export function upstreamFor(launch, processConfiguration) {
         }),
     };
 }
-await runAkumaBody(upstreamFor);
+const encoded = process.argv[2];
+if (encoded === undefined)
+    throw new TypeError("Akuma body launch payload is missing");
+const launch = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+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");
+}
+const configuration = {
+    ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
+    ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
+};
+await runAkumaBody(launch, upstreamFor(launch, configuration));

package/build/src/alias/index.d.ts

@@ -9,6 +9,7 @@ export type AliasMove = Readonly<{
     alias: AliasBinding;
     previous: AkuId | null;
 }>;
+export declare function nukeAliases(world: WorldRoot): Promise<void>;
 export declare function readAliases(world: WorldRoot): Promise<readonly AliasBinding[]>;
 export declare function resolveAlias(world: WorldRoot, value: AkumaAlias): Promise<AkuId | null>;
 export declare function moveAlias(input: Readonly<{

package/build/src/alias/index.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, unlink } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { parseAkuId } from "../akuma/identity.js";
 import { replaceFileDurably } from "../coordination/durable-file.js";
@@ -77,6 +77,39 @@ async function read(path) {
         throw error;
     }
 }
+async function regularFile(path) {
+    try {
+        const value = await lstat(path);
+        if (!value.isFile() || value.isSymbolicLink())
+            throw new Error(`Alias custody is not a regular file: ${path}`);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function nukeAliases(world) {
+    const location = paths(world);
+    const initialAuthority = await regularFile(location.authority);
+    const initialLock = await regularFile(location.lock);
+    if (!initialAuthority && !initialLock)
+        return;
+    const held = await acquireSqliteTransactionLock({ path: location.lock, mode: "immediate" });
+    try {
+        // Alias writers use this same custody lock. Observe after acquiring it so
+        // an authority committed by a prior holder is part of this reset sweep.
+        const authorityPresent = await regularFile(location.authority);
+        if (authorityPresent) {
+            await read(location.authority);
+            await unlink(location.authority);
+        }
+    }
+    finally {
+        held.close();
+    }
+}
 export async function readAliases(world) {
     return await read(paths(world).authority);
 }

package/build/src/body/amend.js

@@ -151,15 +151,6 @@ function applyRemove(body, operation, document) {
     body.extensionIndexes.delete(normalizeTitle(operation.target));
 }
 function applyUpdate(body, operation, document) {
-    if (operation.target.startsWith("Criterion ")) {
-        const title = operation.target.slice("Criterion ".length);
-        const index = criterionIndex(body, title);
-        if (index < 0)
-            refusal(`unknown criterion '${title}'`);
-        const criterion = body.criteria[index];
-        body.criteria[index] = { ...criterion, body: prose(document, operation.section, "criterion") };
-        return;
-    }
     const index = extensionIndex(body, operation.target);
     if (index < 0)
         refusal(`unknown extension '${operation.target}'`);

package/build/src/body/region.js

@@ -175,8 +175,8 @@ function patternsOverlap(left, right) {
 }
 export function decodeRegion(document, section) {
     const blocks = directChildren(section, "code_block");
-    if (blocks.length !== 1 || !blocks[0].closed || blocks[0].info.length > 0) {
-        refusal("Region must contain one closed fence without an info string");
+    if (blocks.length !== 1 || !blocks[0].closed || (blocks[0].info !== "" && blocks[0].info !== "txt")) {
+        refusal("Region must contain one closed fence with no info string or the exact 'txt' info string");
     }
     const other = section.children.filter((node) => node !== blocks[0] && nonblank(document, node));
     if (other.length > 0)

package/build/src/cli/accepted.js

@@ -51,10 +51,13 @@ export function acceptedDeliver(result, coordinate) {
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "deliver",
+        ...(value.completion === undefined ? {} : { completion: value.completion }),
         ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
+        ...(value.verificationSummary === undefined ? {} : { verificationSummary: value.verificationSummary }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.continuation === undefined ? {} : { continuation: value.continuation }),
         ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
         ...(value.leak === undefined ? {} : { leak: value.leak }),
     };
@@ -70,10 +73,13 @@ export function acceptedReview(result, coordinate) {
         ...acceptedEnvelope(result, coordinate),
         verb: "review",
         verdict: reviewAttestation.data.verdict,
+        ...(value.completion === undefined ? {} : { completion: value.completion }),
         ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
+        ...(value.verificationSummary === undefined ? {} : { verificationSummary: value.verificationSummary }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
+        ...(value.continuation === undefined ? {} : { continuation: value.continuation }),
         ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
         ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
         ...(value.leak === undefined ? {} : { leak: value.leak }),

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

@@ -102,6 +102,7 @@ export async function invokeAkuma(command, input) {
                 ...(input.statedCwd === undefined ? {} : { cwd: input.statedCwd }),
                 mode: command.mode,
                 ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
+                ...(command.readonly === undefined ? {} : { readonly: command.readonly }),
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),

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

@@ -22,6 +22,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     alias?: AkumaAlias;
     mode: "wait" | "detach";
     timeoutMs?: number;
+    readonly?: true;
     allowed?: AllowedActions;
 }> & Prompted) | Readonly<{
     command: "kill";

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

@@ -1,4 +1,4 @@
-import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "../usage.js";
+import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
 import { archetypeName, parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
@@ -12,16 +12,18 @@ const AKUMA_COMMAND_SPECS = {
             alias: "value",
             wait: "value",
             detach: "boolean",
+            readonly: "boolean",
             allowed: "repeatable",
             json: "boolean",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        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.",
             "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.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
@@ -30,14 +32,14 @@ const AKUMA_COMMAND_SPECS = {
         arity: "one-or-more",
         stdin: false,
         flags: { any: "boolean", all: "boolean", timeout: "value", json: "boolean" },
-        usage: "wait <akuma-selector>... [--any | --all] [--timeout <duration>] [--json]",
+        usage: "wait <akuma-selector>... [--any | --all] [--timeout <duration>]",
         purpose: "Wait for one Akuma or an explicitly selected Akuma set.",
     },
     tell: {
         arity: 1,
         stdin: true,
         flags: { interrupt: "boolean", json: "boolean" },
-        usage: "tell <aku/...|@alias> [--interrupt] [--json] (<prompt> | -)",
+        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.",
@@ -48,21 +50,21 @@ const AKUMA_COMMAND_SPECS = {
         arity: 1,
         stdin: false,
         flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
+        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last]",
         purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
         arity: 1,
         stdin: false,
         flags: { at: "value", json: "boolean" },
-        usage: "fork <aku/...> --at <historyId> [--json]",
+        usage: "fork <aku/...> --at <historyId>",
         purpose: "Fork one Akuma at a retained answered history point.",
     },
     kill: {
         arity: "one-or-more",
         stdin: false,
         flags: { json: "boolean" },
-        usage: "kill <akuma-selector>... [--json]",
+        usage: "kill <akuma-selector>...",
         purpose: "Put down the current Body of an Akuma selector snapshot.",
     },
 };
@@ -77,7 +79,7 @@ export function renderAkumaRootRows() {
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];
-    return withJsonAutomationHelp(`${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`);
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
 }
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
@@ -305,6 +307,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         ...(alias === undefined ? {} : { alias }),
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(flags.readonly === true ? { readonly: true } : {}),
         ...(allowed === undefined ? {} : { allowed }),
         prompt,
         output,