@astrosheep/keiyaku 4.0.5 → 4.1.0

package/build/src/akuma/nuke.js

@@ -0,0 +1,152 @@
+import { lstat, readdir, rm } from "node:fs/promises";
+import { nukeAliases } from "../alias/index.js";
+import { CONTROL_RESPONSE_MS } from "./body.js";
+import { HeldAkumaLeash, readHeart, readKill, requestStop, } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, } from "./identity.js";
+const POLL_MS = 25;
+async function hasAkumaCustody(paths) {
+    try {
+        const value = await lstat(paths.heart);
+        return value.isFile() && !value.isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return false;
+    }
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(POLL_MS);
+    }
+}
+async function stopRunningAkuma(entry) {
+    const request = await requestStop(entry.paths, new Date().toISOString());
+    const leash = await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+    if (leash === null)
+        throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+    try {
+        if (request.kind === "already-killed" || request.kind === "already-stopped")
+            return leash;
+        if (await readKill(entry.paths, request.body.sequence) !== null)
+            return leash;
+        const current = await readHeart(entry.paths);
+        if (current.latestBody?.sequence !== request.body.sequence) {
+            if (await readKill(entry.paths, request.body.sequence) !== null)
+                return leash;
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        if (current.latestBody.end !== "put-down") {
+            await leash.clearStop(entry.paths);
+            throw new Error(`Akuma ${entry.id} could not be stopped: untidy`);
+        }
+        if (await leash.settleStop(entry.paths, request.body.sequence) === null) {
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        return leash;
+    }
+    catch (error) {
+        leash.release();
+        throw error;
+    }
+}
+async function removeRegularFile(path) {
+    try {
+        const value = await lstat(path);
+        if (value.isFile() && !value.isSymbolicLink())
+            await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function removeAkumaEntry(entry) {
+    for (const path of [entry.paths.heart, entry.paths.log,
+        `${entry.paths.heart}-wal`, `${entry.paths.heart}-shm`]) {
+        await removeRegularFile(path);
+    }
+}
+async function nukeAkumaEntries(world) {
+    const runRoot = akumaRunRoot(world);
+    let names;
+    try {
+        names = (await readdir(runRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            names = [];
+        else
+            throw error;
+    }
+    const entries = [];
+    for (const name of names) {
+        let physical;
+        try {
+            physical = akuIdFromDirectoryName(name);
+        }
+        catch {
+            // The run root can contain bytes not produced by Keiyaku. Preserve them.
+            continue;
+        }
+        const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+        if (!(await hasAkumaCustody(paths)))
+            continue;
+        entries.push({ id: physical.id, paths });
+    }
+    return entries;
+}
+export async function stopAkuma(world) {
+    const entries = await nukeAkumaEntries(world);
+    const held = [];
+    try {
+        for (const entry of entries) {
+            const snapshot = await readHeart(entry.paths);
+            const leash = snapshot.soul !== null && snapshot.latestBody?.end === undefined
+                ? await stopRunningAkuma(entry)
+                : await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+            if (leash === null)
+                throw new Error(`Akuma ${entry.id} could not be verified stopped`);
+            try {
+                const after = await readHeart(entry.paths);
+                if (after.soul === null || after.latestBody?.end !== undefined) {
+                    held.push(leash);
+                    continue;
+                }
+                throw new Error(`Akuma ${entry.id} stopped without a durable end`);
+            }
+            catch (error) {
+                leash.release();
+                throw error;
+            }
+        }
+        return async () => {
+            try {
+                await nukeAliases(world);
+                for (const entry of entries)
+                    await removeAkumaEntry(entry);
+            }
+            finally {
+                for (const leash of held.reverse())
+                    leash.release();
+            }
+        };
+    }
+    finally {
+        if (held.length !== entries.length) {
+            for (const leash of held.reverse())
+                leash.release();
+        }
+    }
+}

package/build/src/akuma/provider-recipe.d.ts

@@ -1,9 +1,11 @@
+export type SystemPromptMode = "append" | "replace";
 export type ProviderOptions = Readonly<{
     model?: string;
     effort?: string;
     readonly?: true;
     network?: "disabled" | "enabled";
     systemPrompt?: string;
+    systemPromptMode?: SystemPromptMode;
 }>;
 export type ReadonlyRestraint = Readonly<{
     enforcement: "native";

package/build/src/akuma/provider-recipe.js

@@ -34,12 +34,22 @@ export function decodeProviderOptions(value) {
         throw new TypeError("provider option network must be disabled, enabled");
     }
     const systemPrompt = optionText(options, "systemPrompt", "allow");
+    const systemPromptMode = options.systemPromptMode;
+    if (systemPromptMode !== undefined) {
+        if (systemPromptMode !== "append" && systemPromptMode !== "replace") {
+            throw new TypeError("provider option systemPromptMode must be append, replace");
+        }
+        if (systemPrompt === undefined) {
+            throw new TypeError("provider option systemPromptMode requires systemPrompt");
+        }
+    }
     return Object.freeze({
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
         ...(options.readonly === undefined ? {} : { readonly: true }),
         ...(network === undefined ? {} : { network }),
         ...(systemPrompt === undefined ? {} : { systemPrompt }),
+        ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
     });
 }
 export function decodeReadonlyRestraint(value) {

package/build/src/akuma/provider.d.ts

@@ -121,8 +121,10 @@ export type Session = Readonly<{
     events: AsyncIterable<AgentEvent>;
     receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
-    /** Fulfills after every adapter-owned OS child or native session is disposed. */
+    /** Requests graceful adapter-owned cancellation. */
     abort(): Promise<void>;
+    /** Fulfills only after forced adapter-owned disposal is proved. */
+    forceDispose(): Promise<void>;
     tell?(tell: Readonly<{
         id: string;
         text: string;

package/build/src/akuma/providers/acp/config.d.ts

@@ -0,0 +1,10 @@
+import type { SystemPromptMode } from "../../provider-recipe.js";
+export type AcpExecutionConfig = Readonly<{
+    argvBefore: readonly string[];
+    argvAfter: readonly string[];
+    modelArg?: string;
+    effortArg?: string;
+    systemPromptArg?: string;
+    systemPromptMode?: SystemPromptMode;
+}>;
+export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;

package/build/src/akuma/providers/acp/config.js

@@ -0,0 +1,45 @@
+function argumentName(value, key) {
+    const selected = value[key];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
+    }
+    return selected;
+}
+export function decodeAcpConfig(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("ACP provider config must be an object");
+    }
+    const config = value;
+    const unknown = Object.keys(config)
+        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg", "systemPromptMode"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
+    if (!Array.isArray(config.argvBefore)
+        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
+    }
+    if (!Array.isArray(config.argvAfter)
+        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
+    }
+    const modelArg = argumentName(config, "modelArg");
+    const effortArg = argumentName(config, "effortArg");
+    const systemPromptArg = argumentName(config, "systemPromptArg");
+    const systemPromptMode = config.systemPromptMode;
+    if (systemPromptMode !== undefined && systemPromptMode !== "append" && systemPromptMode !== "replace") {
+        throw new TypeError("ACP provider config systemPromptMode must be append, replace");
+    }
+    if (systemPromptMode !== undefined && systemPromptArg === undefined) {
+        throw new TypeError("ACP provider config systemPromptMode requires systemPromptArg");
+    }
+    return Object.freeze({
+        argvBefore: Object.freeze([...config.argvBefore]),
+        argvAfter: Object.freeze([...config.argvAfter]),
+        ...(modelArg === undefined ? {} : { modelArg }),
+        ...(effortArg === undefined ? {} : { effortArg }),
+        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
+        ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
+    });
+}

package/build/src/akuma/providers/acp/core.d.ts

@@ -1,16 +1,19 @@
-import * as acp from "@agentclientprotocol/sdk";
+import type * as AcpSdk from "@agentclientprotocol/sdk";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { type ProviderAdapter, type Session } from "../../provider.js";
 import { type AcpToolInterpreter, type AcpToolUpdate } from "./events.js";
 export type { AcpToolInterpreter, AcpToolUpdate };
 export type AcpStartInput = Parameters<ProviderAdapter["start"]>[0] | Parameters<NonNullable<ProviderAdapter["resume"]>>[0];
+export type AcpSessionMeta = Readonly<Record<string, unknown>>;
 export type AcpDependencies = Readonly<{
     spawnProcess?: typeof spawnStdioProcess;
     interpretTool?: AcpToolInterpreter;
+    freshSessionMeta?: AcpSessionMeta;
+    loadSessionMeta?: AcpSessionMeta;
 }>;
 export type AcpLiveSession = Readonly<{
     session: Session;
-    agent: acp.ClientContext;
+    agent: AcpSdk.ClientContext;
     sessionId: string;
     open(): boolean;
 }>;

package/build/src/akuma/providers/acp/core.js

@@ -1,10 +1,9 @@
-import * as acp from "@agentclientprotocol/sdk";
 import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
 import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
-function diagnostic(error) {
+function diagnostic(acp, error) {
     if (!(error instanceof Error))
         return String(error);
     if (!(error instanceof acp.RequestError) || error.data === undefined)
@@ -18,7 +17,7 @@ function diagnostic(error) {
     }
     return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
 }
-function createAcpClient(onUpdate) {
+function createAcpClient(acp, onUpdate) {
     return acp.client({ name: "keiyaku" })
         .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
 }
@@ -29,7 +28,10 @@ function promptResult(response) {
     }
     return { kind: "failed", diagnostic: `ACP prompt ended ${response.stopReason}` };
 }
-async function establishSession(agent, input) {
+function requestMeta(meta) {
+    return meta === undefined || Object.keys(meta).length === 0 ? {} : { _meta: meta };
+}
+async function establishSession(acp, agent, input, dependencies) {
     const initialized = await agent.request(acp.methods.agent.initialize, {
         protocolVersion: acp.PROTOCOL_VERSION,
         clientInfo: { name: "keiyaku", version: "4" },
@@ -38,15 +40,24 @@ async function establishSession(agent, input) {
         throw new Error("ACP agent does not advertise session/load");
     }
     if (input.session.kind === "fresh") {
-        return (await agent.request(acp.methods.agent.session.new, { cwd: input.cwd, mcpServers: [] })).sessionId;
+        return (await agent.request(acp.methods.agent.session.new, {
+            cwd: input.cwd,
+            mcpServers: [],
+            ...requestMeta(dependencies.freshSessionMeta),
+        })).sessionId;
     }
     const sessionId = input.session.coordinate.sessionId;
     if (sessionId === undefined)
         throw new Error("ACP resume coordinate has no session id");
-    await agent.request(acp.methods.agent.session.load, { cwd: input.cwd, mcpServers: [], sessionId });
+    await agent.request(acp.methods.agent.session.load, {
+        cwd: input.cwd,
+        mcpServers: [],
+        sessionId,
+        ...requestMeta(dependencies.loadSessionMeta),
+    });
     return sessionId;
 }
-function createAcpTurn(connection, interpret) {
+function createAcpTurn(acp, connection, interpret) {
     const events = new AgentEventChannel();
     let state = EMPTY_ACP_EVENT_STATE;
     let terminal = false;
@@ -66,7 +77,7 @@ function createAcpTurn(connection, interpret) {
         terminal = true;
         let completionResult = result;
         const failCleanup = (error) => {
-            completionResult = { kind: "failed", diagnostic: `ACP cleanup failed: ${diagnostic(error)}` };
+            completionResult = { kind: "failed", diagnostic: `ACP cleanup failed: ${diagnostic(acp, error)}` };
         };
         try {
             await cleanup();
@@ -96,11 +107,12 @@ function createAcpTurn(connection, interpret) {
         open: () => !terminal,
     };
 }
-function beginAcpPrompt(agent, child, turn, sessionId, input) {
+function beginAcpPrompt(context, child, turn, sessionId, input) {
+    const { acp, agent } = context;
     void agent.request(acp.methods.agent.session.prompt, {
         sessionId,
         prompt: [{ type: "text", text: input.body }, ...input.launchTells.map(({ text }) => ({ type: "text", text }))],
-    }).then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(error) }, () => child.endInputAndDrain()));
+    }).then((response) => turn.finish(promptResult(response), () => child.endInputAndDrain()), (error) => turn.finish({ kind: "failed", diagnostic: diagnostic(acp, error) }, () => child.endInputAndDrain()));
     void child.exited.then((exit) => turn.finish({
         kind: "failed",
         diagnostic: exit.stderr || `ACP process exited${exit.code === null ? "" : ` with code ${exit.code}`}`,
@@ -115,16 +127,23 @@ function beginAcpPrompt(agent, child, turn, sessionId, input) {
                 await agent.notify(acp.methods.agent.session.cancel, { sessionId });
             }
             catch (error) {
-                result = { kind: "failed", diagnostic: diagnostic(error) };
+                result = { kind: "failed", diagnostic: diagnostic(acp, error) };
             }
             if (!turn.open())
                 await child.close(true);
             else
                 await turn.finish(result, () => child.close(true));
         },
+        forceDispose: async () => {
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish({ kind: "failed", diagnostic: "ACP turn force-disposed" }, () => child.close(true));
+        },
     };
 }
 export async function startAcpSession(launch, input, dependencies = {}) {
+    const acp = await import("@agentclientprotocol/sdk");
     const signal = input.signal ?? new AbortController().signal;
     signal.throwIfAborted();
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
@@ -138,15 +157,15 @@ export async function startAcpSession(launch, input, dependencies = {}) {
     });
     let sessionId;
     let turn;
-    const connection = createAcpClient((notification) => {
+    const connection = createAcpClient(acp, (notification) => {
         if (notification.sessionId === sessionId)
             turn.update(notification.update);
     }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
-    turn = createAcpTurn(connection, dependencies.interpretTool);
+    turn = createAcpTurn(acp, connection, dependencies.interpretTool);
     try {
-        sessionId = await abortable(establishSession(connection.agent, input), signal);
+        sessionId = await abortable(establishSession(acp, connection.agent, input, dependencies), signal);
         turn.events.emit({ type: "session", coordinate: { sessionId } });
-        const session = beginAcpPrompt(connection.agent, child, turn, sessionId, input);
+        const session = beginAcpPrompt({ acp, agent: connection.agent }, child, turn, sessionId, input);
         return { session, agent: connection.agent, sessionId, open: turn.open };
     }
     catch (error) {
@@ -155,7 +174,7 @@ export async function startAcpSession(launch, input, dependencies = {}) {
             await child.close(true);
         }
         catch (cleanup) {
-            throw new Error(`${diagnostic(error)}; ACP cleanup failed: ${diagnostic(cleanup)}`, { cause: error });
+            throw new Error(`${diagnostic(acp, error)}; ACP cleanup failed: ${diagnostic(acp, cleanup)}`, { cause: error });
         }
         turn.events.end();
         throw error;

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

@@ -1,12 +1,5 @@
 import type { ProviderAdapter } from "../../provider.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type AcpDependencies } from "./core.js";
-export type AcpExecutionConfig = Readonly<{
-    argvBefore: readonly string[];
-    argvAfter: readonly string[];
-    modelArg?: string;
-    effortArg?: string;
-    systemPromptArg?: string;
-}>;
-export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;
+export { decodeAcpConfig, type AcpExecutionConfig } from "./config.js";
 export declare function createAcpProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -1,41 +1,6 @@
+import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
-function argumentName(value, key) {
-    const selected = value[key];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || selected.trim().length === 0) {
-        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
-    }
-    return selected;
-}
-export function decodeAcpConfig(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new TypeError("ACP provider config must be an object");
-    }
-    const config = value;
-    const unknown = Object.keys(config)
-        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
-    if (!Array.isArray(config.argvBefore)
-        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
-    }
-    if (!Array.isArray(config.argvAfter)
-        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
-    }
-    const modelArg = argumentName(config, "modelArg");
-    const effortArg = argumentName(config, "effortArg");
-    const systemPromptArg = argumentName(config, "systemPromptArg");
-    return Object.freeze({
-        argvBefore: Object.freeze([...config.argvBefore]),
-        argvAfter: Object.freeze([...config.argvAfter]),
-        ...(modelArg === undefined ? {} : { modelArg }),
-        ...(effortArg === undefined ? {} : { effortArg }),
-        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
-    });
-}
+export { decodeAcpConfig } from "./config.js";
 function optionAdmission(options, config) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "ACP provider does not support the network option" };
@@ -46,8 +11,14 @@ function optionAdmission(options, config) {
     if (options.effort !== undefined && config.effortArg === undefined) {
         return { kind: "refused", diagnostic: "ACP provider has no effort argument mapping" };
     }
-    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0 && config.systemPromptArg === undefined) {
-        return { kind: "refused", diagnostic: "ACP provider has no systemPrompt argument mapping" };
+    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
+        if (config.systemPromptArg === undefined) {
+            return { kind: "refused", diagnostic: "ACP provider has no systemPrompt argument mapping" };
+        }
+        if (options.systemPromptMode !== undefined
+            && options.systemPromptMode !== (config.systemPromptMode ?? "replace")) {
+            return { kind: "refused", diagnostic: "ACP provider systemPromptMode does not match the configured argument mode" };
+        }
     }
     return {
         kind: "admitted",

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

@@ -19,7 +19,7 @@ export type ClaudeSdk = Readonly<{
         sessionId: string;
     }>>;
 }>;
-export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: ClaudeExecution): ProviderAdapter;
+export declare function createClaudeProvider(loadOrExecution?: (() => Promise<ClaudeSdk>) | ClaudeExecution, execution?: ClaudeExecution): ProviderAdapter;
 export declare const claudeProvider: Readonly<{
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{

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

@@ -74,7 +74,9 @@ function claudeQueryOptions(input, execution, abortController) {
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0 ? {} : {
-            systemPrompt: { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
+            systemPrompt: input.options.systemPromptMode === "replace"
+                ? input.options.systemPrompt
+                : { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
         }),
         ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
     };
@@ -269,15 +271,22 @@ async function driveClaude(load, execution, drive) {
         },
         async abort() {
             shutDown(new Error("Claude query aborted"));
+            await observed.completion;
+        },
+        async forceDispose() {
+            shutDown(new Error("Claude query force-disposed"));
+            await observed.completion;
         },
     };
 }
-export function createClaudeProvider(load, execution = {}) {
+export function createClaudeProvider(loadOrExecution = async () => await import("@anthropic-ai/claude-agent-sdk"), execution = {}) {
+    const load = typeof loadOrExecution === "function" ? loadOrExecution : async () => await import("@anthropic-ai/claude-agent-sdk");
+    const selectedExecution = typeof loadOrExecution === "function" ? execution : loadOrExecution;
     return {
         admitOptions: admitClaudeOptions,
-        fork: (input) => forkClaude(load, execution, input),
-        start: (input) => driveClaude(load, execution, input),
-        resume: (input) => driveClaude(load, execution, input),
+        fork: (input) => forkClaude(load, selectedExecution, input),
+        start: (input) => driveClaude(load, selectedExecution, input),
+        resume: (input) => driveClaude(load, selectedExecution, input),
     };
 }
 export const claudeProvider = createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"));

package/build/src/akuma/providers/codex-app-server/index.js

@@ -66,7 +66,10 @@ async function admitTurn(server, input, state, events, config) {
         ...(config === undefined ? {} : { config }),
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0
-            ? {} : { developerInstructions: input.options.systemPrompt }),
+            ? {}
+            : input.options.systemPromptMode === "replace"
+                ? { baseInstructions: input.options.systemPrompt }
+                : { developerInstructions: input.options.systemPrompt }),
     };
     if (input.session.kind === "fresh") {
         state.threadId = threadId(await server.request("thread/start", threadParams));
@@ -182,6 +185,11 @@ async function startCodex(execution, input) {
         events,
         completion,
         abort: () => abortTurn(server, state, finish),
+        forceDispose: async () => {
+            if (!state.settled)
+                settle({ kind: "failed", diagnostic: "codex app-server force-disposed" });
+            await server.close(true);
+        },
         tell: (tell) => steerTurn(server, state, tell),
     };
 }

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

@@ -10,7 +10,7 @@ function object(value) {
 }
 function nativeName(update) {
     const wire = update;
-    return nonblank(update.name) ?? nonblank(wire.toolName);
+    return nonblank(update.name) ?? nonblank(update.title) ?? nonblank(wire.toolName);
 }
 function readCall(name, input) {
     if (name !== "read_file" && name !== "hashline_read")
@@ -71,7 +71,9 @@ function optionAdmission(options) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Grok Build does not support the network option" };
     }
-    if (options.systemPrompt !== undefined && options.systemPrompt.length > 0) {
+    if (options.systemPrompt !== undefined
+        && options.systemPrompt.length > 0
+        && options.systemPromptMode === undefined) {
         return { kind: "refused", diagnostic: "Grok Build does not support the systemPrompt option" };
     }
     return {
@@ -85,6 +87,17 @@ function optionAdmission(options) {
         }),
     };
 }
+function grokSessionMeta(options) {
+    if (options.systemPrompt === undefined || options.systemPrompt.length === 0)
+        return {};
+    if (options.systemPromptMode === "append")
+        return { freshSessionMeta: { rules: options.systemPrompt } };
+    if (options.systemPromptMode === "replace") {
+        const meta = { systemPromptOverride: options.systemPrompt };
+        return { freshSessionMeta: meta, loadSessionMeta: meta };
+    }
+    return {};
+}
 function argv(execution, options) {
     if (execution.executable === undefined)
         throw new Error("Grok Build provider execution requires executable");
@@ -129,6 +142,7 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
         return withInterject(await startAcpSession(launch, input, {
             ...dependencies,
             interpretTool: interpretGrokTool,
+            ...grokSessionMeta(input.options),
         }));
     };
     return {

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

@@ -1,6 +1,7 @@
 import type { ProviderAdapter } from "../provider.js";
 import { type ProviderExecution } from "../provider-recipe.js";
-export declare function resolveProviderExecution(input: unknown): Readonly<{
+export declare function decodeProviderExecution(input: unknown): ProviderExecution;
+export declare function resolveProviderExecution(input: unknown): Promise<Readonly<{
     execution: ProviderExecution;
     adapter: ProviderAdapter;
-}>;
+}>>;