@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -53,6 +53,28 @@ function nonblank(value) {
 function number(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+function readRange(value) {
+    const offset = positiveLine(value.offset);
+    const limit = positiveLine(value.limit);
+    return {
+        ...(offset === undefined ? {} : { offset }),
+        ...(limit === undefined ? {} : { limit }),
+    };
+}
+function contentSearch(value, query) {
+    const path = nonblank(value.path);
+    const glob = nonblank(value.glob);
+    return {
+        kind: "search",
+        query,
+        scope: "content",
+        ...(path === undefined ? {} : { path }),
+        ...(glob === undefined ? {} : { glob }),
+    };
+}
 const CLAUDE_SYSTEM_NOTES = {
     api_retry: (message) => {
         const attempt = number(message.attempt);
@@ -82,22 +104,53 @@ const CLAUDE_SYSTEM_NOTES = {
     task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
     worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
 };
-function toolCall(name, input) {
-    const value = object(input) ?? {};
+function runCall(name, value) {
+    if (name !== "Bash")
+        return undefined;
     const command = nonblank(value.command);
-    if (command !== undefined)
-        return { kind: "run", command };
-    const path = nonblank(value.file_path) ?? nonblank(value.path);
-    if (/^(?:read|view)/iu.test(name) && path !== undefined)
-        return { kind: "read", path };
-    const query = nonblank(value.query) ?? nonblank(value.pattern);
-    if (/search|grep|glob/iu.test(name) && query !== undefined)
-        return { kind: "search", query };
-    if (/write/iu.test(name) && path !== undefined)
+    return command === undefined ? { kind: "other", display: name } : { kind: "run", command };
+}
+function readCall(name, path, value) {
+    return name === "Read" && path !== undefined ? { kind: "read", path, ...readRange(value) } : undefined;
+}
+function searchCall(name, value) {
+    if (name === "Grep") {
+        const query = nonblank(value.pattern) ?? nonblank(value.query);
+        return query === undefined ? undefined : contentSearch(value, query);
+    }
+    if (name === "Glob") {
+        const query = nonblank(value.pattern);
+        const globPath = nonblank(value.path);
+        return query === undefined
+            ? undefined
+            : { kind: "search", query, scope: "files", ...(globPath === undefined ? {} : { path: globPath }) };
+    }
+    if (name === "WebSearch") {
+        const query = nonblank(value.query);
+        return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+    }
+    return undefined;
+}
+function fileChangeCall(name, path) {
+    if (path === undefined)
+        return undefined;
+    if (name === "Write")
         return { kind: "fileChange", changes: [{ op: "add", path }] };
-    if (/edit|notebook/iu.test(name) && path !== undefined)
+    if (name === "Edit" || name === "NotebookEdit") {
         return { kind: "fileChange", changes: [{ op: "update", path }] };
-    return { kind: "other", display: name };
+    }
+    return undefined;
+}
+function toolCall(name, input) {
+    const value = object(input) ?? {};
+    const run = runCall(name, value);
+    if (run !== undefined)
+        return run;
+    const path = nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+    return readCall(name, path, value)
+        ?? searchCall(name, value)
+        ?? fileChangeCall(name, path)
+        ?? { kind: "other", display: name };
 }
 function assistantEvents(message, events, state) {
     if (message.aborted === true)

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

@@ -1,5 +1,6 @@
 import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
-import { type ProviderAdapter, type ProviderOptions, type Session } from "../../provider.js";
+import { type ProviderAdapter, type Session } from "../../provider.js";
+import type { ProviderOptions } from "../../provider-recipe.js";
 import type { ResumeCoordinate } from "../../provider.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
 type ClaudeExecution = Readonly<{

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { abortable } from "../../abort.js";
 import { AgentEventChannel, } from "../../provider.js";
 import { emitClaudeMessage, } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
@@ -38,16 +39,16 @@ class ReceiptChannel {
 }
 function admitClaudeOptions(options) {
     if (options.network !== undefined) {
-        return { kind: "refused", diagnostic: "Claude provider does not support the Archetype network option" };
+        return { kind: "refused", diagnostic: "Claude provider does not support the network option" };
     }
-    return { kind: "admitted", options: Object.freeze({ ...options }) };
+    return {
+        kind: "admitted",
+        options: Object.freeze({ ...options }),
+        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+    };
 }
-function permissionMode(access) {
-    if (access === "read")
-        return "plan";
-    if (access === "write")
-        return "acceptEdits";
-    return "bypassPermissions";
+function permissionMode(readonly) {
+    return readonly === true ? "plan" : "bypassPermissions";
 }
 function claudeSessionId(coordinate) {
     if (!("sessionId" in coordinate) || coordinate.sessionId === undefined) {
@@ -56,14 +57,14 @@ function claudeSessionId(coordinate) {
     return coordinate.sessionId;
 }
 function claudeQueryOptions(input, execution, abortController) {
-    const access = permissionMode(input.options.access);
+    const mode = permissionMode(input.options.readonly);
     return {
         cwd: input.cwd,
         abortController,
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
         ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
-        permissionMode: access,
-        ...(access === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+        permissionMode: mode,
+        ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         settingSources: ["user", "project", "local"],
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
@@ -92,9 +93,11 @@ function launchText(input) {
         .filter((part) => part.length > 0).join("\n\n");
 }
 function successfulResult(message, historyId) {
-    return historyId === undefined
-        ? { kind: "failed", diagnostic: "Claude query succeeded without an assistant history id" }
-        : { kind: "answered", answer: message.subtype === "success" ? message.result : "", historyId };
+    return {
+        kind: "answered",
+        answer: message.subtype === "success" ? message.result : "",
+        ...(historyId === undefined ? {} : { historyId }),
+    };
 }
 function finishClaudeInput(input, terminal) {
     if (terminal?.kind === "answered")
@@ -192,7 +195,10 @@ function observeClaudeQuery(context) {
 async function driveClaude(load, execution, drive) {
     if (drive.session.kind === "resume")
         claudeSessionId(drive.session.coordinate);
-    const sdk = await load();
+    const signal = drive.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const sdk = await abortable(load(), signal);
+    signal.throwIfAborted();
     const events = new AgentEventChannel();
     const receipts = new ReceiptChannel();
     const input = createClaudeInput();
@@ -206,11 +212,23 @@ async function driveClaude(load, execution, drive) {
         prompt: input.iterable,
         options: claudeQueryOptions(drive, execution, abortController),
     });
+    const shutDown = (error) => {
+        abortController.abort(error);
+        input.fail(error);
+        query.close();
+    };
+    const abortSetup = () => shutDown(signal.reason);
+    signal.addEventListener("abort", abortSetup, { once: true });
     const observed = observeClaudeQuery({
         query, input, events, receipts, accepted,
         state: { get openSubmissions() { return openSubmissions; } },
     });
-    await Promise.all([launchAcknowledged, observed.admission]);
+    try {
+        await Promise.all([launchAcknowledged, observed.admission]);
+    }
+    finally {
+        signal.removeEventListener("abort", abortSetup);
+    }
     return {
         admission: { fence: `claude:${run}:0` },
         events,
@@ -245,11 +263,7 @@ async function driveClaude(load, execution, drive) {
             });
         },
         async abort() {
-            const error = new Error("Claude query aborted");
-            abortController.abort(error);
-            input.fail(error);
-            query.close();
-            await observed.completion;
+            shutDown(new Error("Claude query aborted"));
         },
     };
 }

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

@@ -186,7 +186,10 @@ function itemToolCall(item, kind) {
         return path === undefined ? { kind: "other", display: "image view" } : { kind: "read", path };
     }
     if (kind === "webSearch") {
-        return { kind: "search", query: codexText(item.query) ?? "web search" };
+        const query = codexText(item.query);
+        return query === undefined
+            ? { kind: "other", display: "web search" }
+            : { kind: "search", query, scope: "web" };
     }
     if (kind === "fileChange") {
         const changes = itemChanges(item);

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

@@ -1,12 +1,12 @@
-import { type Session, type ProviderAdapter, type ProviderOptions } from "../../provider.js";
-import type { ProviderExecution } from "../../heart/index.js";
+import { type Session, type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 export declare function createCodexAppServerProvider(input?: string | ProviderExecution): ProviderAdapter;
 export declare const codexAppServerProvider: Readonly<{
     confinement(input: Readonly<{
         cwd: string;
         options: ProviderOptions;
-    }>): import("../../heart/facts.js").Confinement;
+    }>): import("../../index.js").Confinement;
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: import("../../coordinate.js").ResumeCoordinate;

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

@@ -2,14 +2,6 @@ import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
 import { AgentEventChannel, AKUMA_REQUESTS_ENV, } from "../../provider.js";
 import { codexNotificationResult, codexObject, codexText, } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
-const INTERRUPT_TIMEOUT_MS = 1_000;
-function interrupt(server, threadId, turnId) {
-    const request = server.request("turn/interrupt", { threadId, turnId });
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error("codex app-server interrupt timed out")), INTERRUPT_TIMEOUT_MS);
-        void request.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
-    });
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -56,6 +48,9 @@ async function steerTurn(server, state, tell) {
     return { kind: "accepted", fence: `${accepted}:${tell.id}` };
 }
 function sandbox(cwd, options, requests) {
+    if (options.readonly === true) {
+        return { type: "readOnly", networkAccess: options.network === "enabled" };
+    }
     return {
         type: "workspaceWrite",
         writableRoots: [cwd, ...(requests === undefined ? [] : [requests.dir])],
@@ -115,26 +110,13 @@ async function forkCodex(execution, input) {
         await server.close();
     }
 }
-async function abortTurn(server, state, completion, settle) {
-    if (state.settled) {
-        await completion;
-        return;
-    }
-    if (state.threadId !== undefined && state.turnId !== undefined) {
-        try {
-            await interrupt(server, state.threadId, state.turnId);
-            await completion;
-        }
-        catch (error) {
-            settle({ kind: "failed", diagnostic: diagnostic(error) });
-        }
-    }
-    else {
-        settle({ kind: "failed", diagnostic: "codex app-server aborted before turn admission" });
-    }
-    await completion;
+async function abortTurn(server, state, settle) {
+    if (!state.settled)
+        settle({ kind: "failed", diagnostic: "codex app-server interrupted" });
+    await server.close(true);
 }
 async function startCodex(execution, input) {
+    const signal = input.signal ?? new AbortController().signal;
     if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
         throw new Error("Codex app-server resume requires sessionId");
     const events = new AgentEventChannel();
@@ -177,19 +159,29 @@ async function startCodex(execution, input) {
         kind: "failed",
         diagnostic: `codex app-server made forbidden interactive request ${request.method}`,
     }));
+    const abortSetup = () => { void server.close(true); };
+    signal.addEventListener("abort", abortSetup, { once: true });
     try {
+        signal.throwIfAborted();
         await admitTurn(server, input, state, events, execution.config);
     }
     catch (error) {
+        if (signal.aborted) {
+            await server.close(true);
+            throw signal.reason;
+        }
         finish({ kind: "failed", diagnostic: diagnostic(error) });
     }
+    finally {
+        signal.removeEventListener("abort", abortSetup);
+    }
     if (state.turnId === undefined)
         throw new Error("codex app-server did not admit a turn");
     return {
         admission: { fence: state.turnId },
         events,
         completion,
-        abort: () => abortTurn(server, state, completion, finish),
+        abort: () => abortTurn(server, state, finish),
         tell: (tell) => steerTurn(server, state, tell),
     };
 }
@@ -200,10 +192,11 @@ export function createCodexAppServerProvider(input = "codex") {
     return {
         confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
-            if (options.access !== undefined && options.access !== "write") {
-                return { kind: "refused", diagnostic: "Codex app-server supports only access: write" };
-            }
-            return { kind: "admitted", options: Object.freeze({ ...options }) };
+            return {
+                kind: "admitted",
+                options: Object.freeze({ ...options }),
+                ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
+            };
         },
         fork: (input) => forkCodex(execution, input),
         start: (input) => startCodex(execution, input),

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

@@ -0,0 +1,4 @@
+import type { ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
+import { type AcpDependencies } from "../acp/core.js";
+export declare function createGrokBuildProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -0,0 +1,70 @@
+import { startAcpSession } from "../acp/core.js";
+const INTERJECT_METHOD = "x.ai/interject";
+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) {
+        return { kind: "refused", diagnostic: "Grok Build does not support the systemPrompt option" };
+    }
+    return {
+        kind: "admitted",
+        options,
+        ...(options.readonly === undefined ? {} : {
+            readonly: {
+                enforcement: "none",
+                diagnostic: "Grok Build cannot remove task-surface mutation capabilities",
+            },
+        }),
+    };
+}
+function argv(execution, options) {
+    if (execution.executable === undefined)
+        throw new Error("Grok Build provider execution requires executable");
+    const values = [execution.executable, "agent", "--always-approve"];
+    if (options.model !== undefined)
+        values.push("--model", options.model);
+    if (options.effort !== undefined)
+        values.push("--reasoning-effort", options.effort);
+    values.push("stdio");
+    return values;
+}
+function withInterject(live) {
+    return {
+        ...live.session,
+        tell: async (tell) => {
+            if (!live.open())
+                return { kind: "turn-ended" };
+            const response = await live.agent.request(INTERJECT_METHOD, {
+                sessionId: live.sessionId,
+                text: tell.text,
+                interjectionId: tell.id,
+            });
+            if (!live.open())
+                return { kind: "turn-ended" };
+            if (response === null || typeof response !== "object" || response.status !== "queued") {
+                throw new Error("Grok Build interject did not return queued");
+            }
+            return { kind: "accepted", fence: tell.id };
+        },
+    };
+}
+export function createGrokBuildProvider(execution, dependencies = {}) {
+    if (execution.executable === undefined)
+        throw new TypeError("Grok Build provider execution requires executable");
+    if (execution.config !== undefined)
+        throw new TypeError("Grok Build provider does not support execution config");
+    const drive = async (input) => {
+        const launch = {
+            argv: argv(execution, input.options),
+            ...(execution.env === undefined ? {} : { env: execution.env }),
+        };
+        return withInterject(await startAcpSession(launch, input, dependencies));
+    };
+    return {
+        confinement: () => ({ kind: "unconfined" }),
+        admitOptions: optionAdmission,
+        start: async (input) => await drive(input),
+        resume: async (input) => await drive(input),
+    };
+}

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

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

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

@@ -1,75 +1,26 @@
+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 record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : null;
-}
-function snapshot(value) {
-    if (Array.isArray(value))
-        return Object.freeze(value.map(snapshot));
-    const object = record(value);
-    if (object === null)
-        return value;
-    return Object.freeze(Object.fromEntries(Object.entries(object).map(([key, item]) => [key, snapshot(item)])));
-}
-function optionalText(value, field) {
-    const selected = value[field];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || selected.trim().length === 0) {
-        throw new TypeError(`provider execution ${field} must be a nonblank string`);
-    }
-    return selected;
-}
-function providerKind(value) {
-    return value === "claude-agent-sdk" || value === "codex-app-server" || value === "opencode-sdk" || value === "pi";
-}
-function providerConfig(value, kind) {
-    const config = value.config === undefined ? undefined : record(value.config);
-    if (config === null)
-        throw new TypeError("provider execution config must be an object");
+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;
 }
-export function decodeProviderExecution(input) {
-    const value = record(input);
-    if (value === null)
-        throw new TypeError("provider execution must be an object");
-    const allowed = ["config", "env", "executable", "kind", "name"];
-    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider execution has unknown field ${unknown}`);
-    if (typeof value.name !== "string" || value.name.trim().length === 0) {
-        throw new TypeError("provider execution name must be a nonblank string");
-    }
-    if (!providerKind(value.kind)) {
-        throw new TypeError("provider execution has unknown kind");
-    }
-    const executable = optionalText(value, "executable");
-    const config = providerConfig(value, value.kind);
-    const env = value.env === undefined ? undefined : record(value.env);
-    if (env === null)
-        throw new TypeError("provider execution env must be an object");
-    if (env !== undefined && Object.values(env).some((item) => typeof item !== "string")) {
-        throw new TypeError("provider execution env must contain only string values");
-    }
-    return Object.freeze({
-        name: value.name,
-        kind: value.kind,
-        ...(executable === undefined ? {} : { executable }),
-        ...(config === undefined ? {} : { config: snapshot(config) }),
-        ...(env === undefined ? {} : { env: Object.freeze({ ...env }) }),
-    });
-}
-export function providerNamed(execution) {
+function adapterFor(execution) {
+    if (execution.kind === "acp")
+        return createAcpProvider(execution);
     if (execution.kind === "claude-agent-sdk") {
         return execution.executable === undefined && execution.env === undefined
             ? PROVIDERS.claude
@@ -77,9 +28,23 @@ export function providerNamed(execution) {
     }
     if (execution.kind === "codex-app-server")
         return createCodexAppServerProvider(execution);
+    if (execution.kind === "grok-build")
+        return createGrokBuildProvider(execution);
     if (execution.kind === "opencode-sdk")
         return createOpencodeProvider(execution);
     if (execution.kind === "pi")
         return 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) });
+}

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

@@ -1,48 +1,54 @@
-import type { AgentEvent, ToolCall } from "../../provider.js";
+import { type AgentEvent, type ToolCall } from "../../provider.js";
 type Emitter = {
     emit(event: AgentEvent): void;
 };
-type ToolState = Readonly<{
+type ObservedTool = Readonly<{
     name: string;
     call: ToolCall;
 }>;
 type State = {
-    tools: Map<string, ToolState>;
-    answer: string[];
-    seen: Set<string>;
+    sessionId?: string;
+    assistantParts: Set<string>;
+    reasoningParts: Set<string>;
+    tools: Map<string, ObservedTool>;
+    completedTools: Set<string>;
     failure?: string;
 };
 export declare const OPENCODE_EVENT_DISPOSITIONS: {
-    readonly "session.next.agent.switched": "dropped";
-    readonly "session.next.model.switched": "dropped";
-    readonly "session.next.moved": "dropped";
-    readonly "session.next.prompted": "dropped";
-    readonly "session.next.prompt.admitted": "dropped";
-    readonly "session.next.context.updated": "dropped";
-    readonly "session.next.synthetic": "dropped";
-    readonly "session.next.shell.started": "dropped";
-    readonly "session.next.shell.ended": "dropped";
-    readonly "session.next.step.started": "dropped";
-    readonly "session.next.step.ended": "dropped";
-    readonly "session.next.step.failed": "mapped";
-    readonly "session.next.text.started": "dropped";
-    readonly "session.next.text.ended": "mapped";
-    readonly "session.next.tool.input.started": "dropped";
-    readonly "session.next.tool.input.ended": "dropped";
-    readonly "session.next.tool.called": "mapped";
-    readonly "session.next.tool.progress": "dropped";
-    readonly "session.next.tool.success": "mapped";
-    readonly "session.next.tool.failed": "mapped";
-    readonly "session.next.reasoning.started": "dropped";
-    readonly "session.next.reasoning.ended": "mapped";
-    readonly "session.next.retried": "mapped";
-    readonly "session.next.compaction.started": "dropped";
-    readonly "session.next.compaction.ended": "dropped";
-    readonly "session.next.revert.staged": "dropped";
-    readonly "session.next.revert.cleared": "dropped";
-    readonly "session.next.revert.committed": "dropped";
+    readonly "server.instance.disposed": "dropped";
+    readonly "installation.updated": "dropped";
+    readonly "installation.update-available": "dropped";
+    readonly "lsp.client.diagnostics": "dropped";
+    readonly "lsp.updated": "dropped";
+    readonly "message.updated": "mapped";
+    readonly "message.removed": "dropped";
+    readonly "message.part.updated": "mapped";
+    readonly "message.part.removed": "dropped";
+    readonly "permission.updated": "dropped";
+    readonly "permission.replied": "dropped";
+    readonly "session.status": "dropped";
+    readonly "session.idle": "dropped";
+    readonly "session.compacted": "dropped";
+    readonly "file.edited": "dropped";
+    readonly "todo.updated": "mapped";
+    readonly "command.executed": "dropped";
+    readonly "session.created": "dropped";
+    readonly "session.updated": "dropped";
+    readonly "session.deleted": "dropped";
+    readonly "session.diff": "dropped";
+    readonly "session.error": "mapped";
+    readonly "file.watcher.updated": "dropped";
+    readonly "vcs.branch.updated": "dropped";
+    readonly "tui.prompt.append": "dropped";
+    readonly "tui.command.execute": "dropped";
+    readonly "tui.toast.show": "dropped";
+    readonly "pty.created": "dropped";
+    readonly "pty.updated": "dropped";
+    readonly "pty.exited": "dropped";
+    readonly "pty.deleted": "dropped";
+    readonly "server.connected": "dropped";
 };
 export declare function mapEvent(value: unknown, events: Emitter, state: State): void;
 export type EventState = State;
-export declare function createEventState(): State;
+export declare function createEventState(sessionId?: string): State;
 export {};