@astrosheep/keiyaku 4.0.6 → 4.1.1

package/build/src/akuma/provider.js

@@ -87,9 +87,9 @@ function decodeDiffstat(value) {
 }
 function decodeFileChangeMember(value) {
     const change = object(value);
-    if (change === null || (change.op !== "add" && change.op !== "update"
-        && change.op !== "delete" && change.op !== "unspecified")
-        || typeof change.path !== "string")
+    if (change === null ||
+        (change.op !== "add" && change.op !== "update" && change.op !== "delete" && change.op !== "unspecified") ||
+        typeof change.path !== "string")
         return null;
     const diffstat = decodeDiffstat(change.diffstat);
     if (diffstat === null)
@@ -114,12 +114,18 @@ function decodeToolCall(value) {
     if (call === null)
         return null;
     switch (call.kind) {
-        case "run": return decodeRunCall(call);
-        case "read": return decodeReadCall(call);
-        case "search": return decodeSearchCall(call);
-        case "fileChange": return decodeFileChangeCall(call);
-        case "other": return decodeOtherCall(call);
-        default: return null;
+        case "run":
+            return decodeRunCall(call);
+        case "read":
+            return decodeReadCall(call);
+        case "search":
+            return decodeSearchCall(call);
+        case "fileChange":
+            return decodeFileChangeCall(call);
+        case "other":
+            return decodeOtherCall(call);
+        default:
+            return null;
     }
 }
 function decodeToolResult(value) {
@@ -143,13 +149,26 @@ function decodeToolEvent(event) {
         return null;
     const call = decodeToolCall(event.call);
     if (call !== null && event.phase === "started" && event.result === undefined) {
-        return { type: "tool", phase: "started", id: event.id, name: event.name, call,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            type: "tool",
+            phase: "started",
+            id: event.id,
+            name: event.name,
+            call,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     const result = decodeToolResult(event.result);
     if (call !== null && event.phase === "completed" && result !== null) {
-        return { type: "tool", phase: "completed", id: event.id, name: event.name, call, result,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            type: "tool",
+            phase: "completed",
+            id: event.id,
+            name: event.name,
+            call,
+            result,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     return null;
 }
@@ -159,15 +178,20 @@ function decodeTypedEvent(type, event) {
     const truncated = event.truncated === true ? { truncated: true } : {};
     switch (type) {
         case "assistant":
-        case "thought": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "note": return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
-        case "unknown": return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
+        case "thought":
+            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "note":
+            return typeof event.text === "string" ? { type, text: event.text, ...truncated } : null;
+        case "unknown":
+            return typeof event.kind === "string" ? { type, kind: event.kind, ...truncated } : null;
         case "session": {
             const coordinate = decodeResumeCoordinate(event.coordinate);
             return coordinate === null ? null : { type, coordinate };
         }
-        case "tool": return decodeToolEvent(event);
-        default: return type;
+        case "tool":
+            return decodeToolEvent(event);
+        default:
+            return type;
     }
 }
 export function decodeAgentEvent(value) {
@@ -181,37 +205,49 @@ export function decodeAgentEvent(value) {
 }
 function boundedToolCall(call) {
     switch (call.kind) {
-        case "run": return { value: { kind: call.kind, command: boundedEventText(call.command) }, truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT };
-        case "read": return {
-            value: {
-                kind: call.kind,
-                path: boundedEventText(call.path),
-                ...(call.offset === undefined ? {} : { offset: call.offset }),
-                ...(call.limit === undefined ? {} : { limit: call.limit }),
-            },
-            truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT,
-        };
-        case "search": return {
-            value: {
-                kind: call.kind,
-                query: boundedEventText(call.query),
-                ...(call.scope === undefined ? {} : { scope: call.scope }),
-                ...(call.path === undefined ? {} : { path: boundedEventText(call.path) }),
-                ...(call.glob === undefined ? {} : { glob: boundedEventText(call.glob) }),
-            },
-            truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT
-                || (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT)
-                || (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
-        };
-        case "fileChange": return {
-            value: {
-                kind: call.kind,
-                changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
-            },
-            truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
-        };
-        case "other": return { value: { kind: call.kind, display: boundedEventText(call.display) }, truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT };
-        default: return call;
+        case "run":
+            return {
+                value: { kind: call.kind, command: boundedEventText(call.command) },
+                truncated: call.command.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        case "read":
+            return {
+                value: {
+                    kind: call.kind,
+                    path: boundedEventText(call.path),
+                    ...(call.offset === undefined ? {} : { offset: call.offset }),
+                    ...(call.limit === undefined ? {} : { limit: call.limit }),
+                },
+                truncated: call.path.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        case "search":
+            return {
+                value: {
+                    kind: call.kind,
+                    query: boundedEventText(call.query),
+                    ...(call.scope === undefined ? {} : { scope: call.scope }),
+                    ...(call.path === undefined ? {} : { path: boundedEventText(call.path) }),
+                    ...(call.glob === undefined ? {} : { glob: boundedEventText(call.glob) }),
+                },
+                truncated: call.query.length > AGENT_EVENT_TEXT_LIMIT ||
+                    (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT) ||
+                    (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
+            };
+        case "fileChange":
+            return {
+                value: {
+                    kind: call.kind,
+                    changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
+                },
+                truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
+            };
+        case "other":
+            return {
+                value: { kind: call.kind, display: boundedEventText(call.display) },
+                truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT,
+            };
+        default:
+            return call;
     }
 }
 function boundedToolResult(result) {
@@ -230,22 +266,28 @@ export function encodeAgentEvent(event) {
         ...(changed || ("truncated" in event && event.truncated === true) ? { truncated: true } : {}),
     });
     switch (event.type) {
-        case "session": return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
-        case "assistant": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
-        case "thought": return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
-        case "note": return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
-        case "unknown": return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
+        case "session":
+            return { type: event.type, coordinate: encodeResumeCoordinate(event.coordinate) };
+        case "assistant":
+            return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "thought":
+            return marked({ type: event.type, text: boundedThoughtText(event.text) }, event.text.length > AGENT_THOUGHT_TEXT_LIMIT);
+        case "note":
+            return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
+        case "unknown":
+            return marked({ type: event.type, kind: boundedEventText(event.kind) }, event.kind.length > AGENT_EVENT_TEXT_LIMIT);
         case "tool": {
             const call = boundedToolCall(event.call);
             const name = boundedEventText(event.name);
             const result = event.phase === "completed" ? boundedToolResult(event.result) : undefined;
-            return marked(event.phase === "started" ? {
-                type: event.type,
-                id: event.id,
-                phase: event.phase,
-                name,
-                call: call.value,
-            }
+            return marked(event.phase === "started"
+                ? {
+                    type: event.type,
+                    id: event.id,
+                    phase: event.phase,
+                    name,
+                    call: call.value,
+                }
                 : {
                     type: event.type,
                     id: event.id,
@@ -255,7 +297,8 @@ export function encodeAgentEvent(event) {
                     result: result.value,
                 }, name !== event.name || call.truncated || result?.truncated === true);
         }
-        default: return event;
+        default:
+            return event;
     }
 }
 export function boundedEventText(value) {

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

@@ -1,8 +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

@@ -12,26 +12,33 @@ export function decodeAcpConfig(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));
+    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)) {
+    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)) {
+    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,18 +17,23 @@ function diagnostic(error) {
     }
     return data.length === 0 ? `${error.message} [${error.code}]` : `${error.message} [${error.code}]: ${data}`;
 }
-function createAcpClient(onUpdate) {
-    return acp.client({ name: "keiyaku" })
+function createAcpClient(acp, onUpdate) {
+    return acp
+        .client({ name: "keiyaku" })
         .onNotification(acp.methods.client.session.update, ({ params }) => onUpdate(params));
 }
 function promptResult(response) {
-    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens"
-        || response.stopReason === "max_turn_requests") {
+    if (response.stopReason === "end_turn" ||
+        response.stopReason === "max_tokens" ||
+        response.stopReason === "max_turn_requests") {
         return { kind: "answered", answer: "" };
     }
     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,20 +42,31 @@ 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;
     let resolveCompletion;
-    const completion = new Promise((resolve) => { resolveCompletion = resolve; });
+    const completion = new Promise((resolve) => {
+        resolveCompletion = resolve;
+    });
     const update = (next) => {
         if (terminal)
             return;
@@ -66,7 +81,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();
@@ -84,9 +99,7 @@ function createAcpTurn(connection, interpret) {
         for (const event of flushed.events)
             events.emit(event);
         events.end();
-        resolveCompletion(completionResult.kind === "answered"
-            ? { ...completionResult, answer: flushed.state.answer }
-            : completionResult);
+        resolveCompletion(completionResult.kind === "answered" ? { ...completionResult, answer: flushed.state.answer } : completionResult);
     };
     return {
         events,
@@ -96,11 +109,17 @@ function createAcpTurn(connection, interpret) {
         open: () => !terminal,
     };
 }
-function beginAcpPrompt(agent, child, turn, sessionId, input) {
-    void agent.request(acp.methods.agent.session.prompt, {
+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()));
+        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(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,7 +134,7 @@ 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);
@@ -131,6 +150,7 @@ function beginAcpPrompt(agent, child, turn, sessionId, input) {
     };
 }
 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)({
@@ -144,15 +164,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) {
@@ -161,7 +181,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/events.js

@@ -13,9 +13,7 @@ export function flushAcpEvents(state, boundary = []) {
     };
 }
 function appendBlock(state, type, text, messageId) {
-    const newAssistantMessage = type === "assistant"
-        && messageId !== undefined
-        && state.assistantMessageId !== messageId;
+    const newAssistantMessage = type === "assistant" && messageId !== undefined && state.assistantMessageId !== messageId;
     const flushed = state.open === null || (state.open.type === type && !newAssistantMessage)
         ? { events: [], state }
         : flushAcpEvents(state);
@@ -23,12 +21,8 @@ function appendBlock(state, type, text, messageId) {
         events: flushed.events,
         state: {
             ...flushed.state,
-            answer: type === "assistant"
-                ? `${newAssistantMessage ? "" : flushed.state.answer}${text}`
-                : flushed.state.answer,
-            assistantMessageId: type === "assistant" && messageId !== undefined
-                ? messageId
-                : flushed.state.assistantMessageId,
+            answer: type === "assistant" ? `${newAssistantMessage ? "" : flushed.state.answer}${text}` : flushed.state.answer,
+            assistantMessageId: type === "assistant" && messageId !== undefined ? messageId : flushed.state.assistantMessageId,
             open: { type, text: `${flushed.state.open?.text ?? ""}${text}` },
         },
     };
@@ -42,9 +36,7 @@ function object(value) {
         : undefined;
 }
 function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1
-        ? value
-        : undefined;
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
 }
 function otherCall(name) {
     return { kind: "other", display: name };
@@ -84,9 +76,7 @@ function standardCall(update, name) {
         const path = nonblank(input?.path);
         const glob = nonblank(input?.glob);
         const scope = input?.scope;
-        const searchScope = scope === "content" || scope === "files" || scope === "web"
-            ? scope
-            : undefined;
+        const searchScope = scope === "content" || scope === "files" || scope === "web" ? scope : undefined;
         return {
             kind: "search",
             query,
@@ -115,33 +105,52 @@ export function mapAcpUpdate(update, previous, interpret) {
             const text = update.content.type === "text" ? update.content.text : undefined;
             if (text === undefined)
                 return flushAcpEvents(previous, [unknownEvent(`${update.sessionUpdate}/${update.content.type}`)]);
-            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null
-                ? update.messageId
-                : undefined);
+            return appendBlock(previous, update.sessionUpdate === "agent_message_chunk" ? "assistant" : "thought", text, update.sessionUpdate === "agent_message_chunk" && update.messageId !== null ? update.messageId : undefined);
         }
-        case "user_message_chunk": return flushAcpEvents(previous);
+        case "user_message_chunk":
+            return flushAcpEvents(previous);
         case "tool_call":
         case "tool_call_update": {
             const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
                 tools.delete(update.toolCallId);
-                return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
+                return flushAcpEvents({ ...previous, tools }, [
+                    {
+                        type: "tool",
+                        phase: "completed",
+                        id: update.toolCallId,
+                        ...observed,
+                        result: { status: update.status === "completed" ? "ok" : "error" },
+                    },
+                ]);
             }
             const started = tools.has(update.toolCallId);
             tools.set(update.toolCallId, observed);
             return started
                 ? flushAcpEvents({ ...previous, tools })
-                : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);
+                : flushAcpEvents({ ...previous, tools }, [
+                    { type: "tool", phase: "started", id: update.toolCallId, ...observed },
+                ]);
         }
-        case "plan": return flushAcpEvents(previous, [noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`)]);
-        case "available_commands_update": return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
-        case "current_mode_update": return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
-        case "config_option_update": return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
-        case "session_info_update": return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
-        case "usage_update": return flushAcpEvents(previous);
+        case "plan":
+            return flushAcpEvents(previous, [
+                noteEvent(`Plan updated: ${update.entries.map((entry) => entry.content).join("; ")}`),
+            ]);
+        case "available_commands_update":
+            return flushAcpEvents(previous, [noteEvent("ACP commands updated")]);
+        case "current_mode_update":
+            return flushAcpEvents(previous, [noteEvent("ACP mode updated")]);
+        case "config_option_update":
+            return flushAcpEvents(previous, [noteEvent("ACP configuration updated")]);
+        case "session_info_update":
+            return flushAcpEvents(previous, [noteEvent("ACP session metadata updated")]);
+        case "usage_update":
+            return flushAcpEvents(previous);
         case "plan_update":
-        case "plan_removed": return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
-        default: return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
+        case "plan_removed":
+            return flushAcpEvents(previous, [unknownEvent(update.sessionUpdate)]);
+        default:
+            return { events: [unknownEvent(String(update.sessionUpdate))], state: previous };
     }
 }

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

@@ -11,18 +11,28 @@ 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",
         options,
-        ...(options.readonly === undefined ? {} : {
-            readonly: {
-                enforcement: "none",
-                diagnostic: "ACP cannot remove task-surface mutation capabilities",
-            },
-        }),
+        ...(options.readonly === undefined
+            ? {}
+            : {
+                readonly: {
+                    enforcement: "none",
+                    diagnostic: "ACP cannot remove task-surface mutation capabilities",
+                },
+            }),
     };
 }
 function argv(execution, config, options) {