@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -1,4 +1,5 @@
 import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { nonblank, object, positiveLine, stringValue } from "../decode.js";
 export const EMPTY_ACP_EVENT_STATE = Object.freeze({
     answer: "",
     assistantMessageId: null,
@@ -27,20 +28,6 @@ function appendBlock(state, type, text, messageId) {
         },
     };
 }
-function nonblank(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
-function otherCall(name, input) {
-    return otherToolCall(name, input);
-}
 function locationFact(locations) {
     if (locations === null || locations === undefined)
         return {};
@@ -53,11 +40,30 @@ function locationFact(locations) {
     }
     return {};
 }
+/**
+ * The observed result text of one ACP tool update: its text content blocks in
+ * native order, otherwise a raw output that is itself a string. A raw output of
+ * any other shape is left absent rather than stringified.
+ */
+function verifiedToolOutput(update) {
+    if (Array.isArray(update.content)) {
+        const blocks = update.content.flatMap((entry) => {
+            const value = object(entry);
+            if (value?.type !== "content")
+                return [];
+            const content = object(value.content);
+            return content?.type === "text" && typeof content.text === "string" ? [content.text] : [];
+        });
+        if (blocks.length > 0)
+            return blocks.join("");
+    }
+    return stringValue(update.rawOutput);
+}
 function standardCall(update, name) {
     const location = locationFact(update.locations);
     if (update.kind === "read") {
         return location.path === undefined
-            ? otherCall(name, update.rawInput)
+            ? otherToolCall(name, update.rawInput)
             : {
                 kind: "read",
                 path: location.path,
@@ -67,12 +73,12 @@ function standardCall(update, name) {
     const input = object(update.rawInput);
     if (update.kind === "execute") {
         const command = nonblank(input?.command);
-        return command === undefined ? otherCall(name, update.rawInput) : { kind: "run", command };
+        return command === undefined ? otherToolCall(name, update.rawInput) : { kind: "run", command };
     }
     if (update.kind === "search") {
         const query = nonblank(input?.query);
         if (query === undefined)
-            return otherCall(name, update.rawInput);
+            return otherToolCall(name, update.rawInput);
         const path = nonblank(input?.path);
         const glob = nonblank(input?.glob);
         const scope = input?.scope;
@@ -85,7 +91,7 @@ function standardCall(update, name) {
             ...(glob === undefined ? {} : { glob }),
         };
     }
-    return otherCall(name, update.rawInput);
+    return otherToolCall(name, update.rawInput);
 }
 function strongest(previous, next) {
     if (previous === undefined || previous.kind === "other")
@@ -122,6 +128,7 @@ export function mapAcpUpdate(update, previous, interpret) {
             const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
+                const output = verifiedToolOutput(update);
                 tools.delete(update.toolCallId);
                 return flushAcpEvents({ ...previous, tools }, [
                     {
@@ -129,7 +136,10 @@ export function mapAcpUpdate(update, previous, interpret) {
                         phase: "completed",
                         id: update.toolCallId,
                         ...observed,
-                        result: { status: update.status === "completed" ? "ok" : "error" },
+                        result: {
+                            status: update.status === "completed" ? "ok" : "error",
+                            ...(output === undefined ? {} : { output }),
+                        },
                     },
                 ]);
             }

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

@@ -1,4 +1,4 @@
-import { createProviderAttempt } from "../../provider.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
 export { decodeAcpConfig } from "./config.js";
@@ -63,7 +63,6 @@ export function createAcpProvider(execution, dependencies = {}) {
     };
     return {
         admitOptions: (options) => optionAdmission(options, config),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle(drive),
     };
 }

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

@@ -1,4 +1,6 @@
-import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { modelEvent, noteEvent, otherToolCall, unknownEvent, } from "../../provider.js";
+import { finiteNumber, object, observedTextContent, positiveLine, searchToolCall, stringValue, trimmed, } from "../decode.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CLAUDE_MESSAGE_DISPOSITIONS = {
     assistant: "assistant",
     auth_status: "auth",
@@ -42,20 +44,6 @@ export const CLAUDE_SYSTEM_DISPOSITIONS = {
     thinking_tokens: "drop",
     worker_shutting_down: "note",
 };
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function nonblank(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-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);
@@ -64,21 +52,10 @@ function readRange(value) {
         ...(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);
-        const maximum = number(message.max_retries);
+        const attempt = finiteNumber(message.attempt);
+        const maximum = finiteNumber(message.max_retries);
         return attempt === undefined || maximum === undefined
             ? "Retrying request"
             : `Retrying request ${attempt}/${maximum}`;
@@ -90,24 +67,24 @@ const CLAUDE_SYSTEM_NOTES = {
         const failed = Array.isArray(message.failed) ? message.failed.length : 0;
         return failed === 0 ? `Persisted ${files} files` : `Persisted ${files} files; ${failed} failed`;
     },
-    informational: (message) => nonblank(message.content) ?? "Informational notice",
-    mirror_error: (message) => `Transcript mirror warning: ${nonblank(message.error) ?? nonblank(message.message) ?? "unknown error"}`,
+    informational: (message) => trimmed(message.content) ?? "Informational notice",
+    mirror_error: (message) => `Transcript mirror warning: ${trimmed(message.error) ?? trimmed(message.message) ?? "unknown error"}`,
     model_refusal_fallback: () => "Model refusal; using fallback",
     model_refusal_no_fallback: () => "Model refusal; no fallback available",
-    notification: (message) => nonblank(message.message) ?? nonblank(message.content) ?? "Notification",
-    permission_denied: (message) => `Permission refused${nonblank(message.message) === undefined ? "" : `: ${nonblank(message.message)}`}`,
-    plugin_install: (message) => `Plugin install ${nonblank(message.status) ?? "updated"}${nonblank(message.name) === undefined ? "" : `: ${nonblank(message.name)}`}`,
-    status: (message) => `Status: ${nonblank(message.status) ?? "idle"}${nonblank(message.error) === undefined ? "" : ` (${nonblank(message.error)})`}`,
-    task_notification: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} ${nonblank(message.status) ?? "updated"}`,
-    task_progress: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} progressed`,
-    task_started: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} started`,
-    task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
-    worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
+    notification: (message) => trimmed(message.message) ?? trimmed(message.content) ?? "Notification",
+    permission_denied: (message) => `Permission refused${trimmed(message.message) === undefined ? "" : `: ${trimmed(message.message)}`}`,
+    plugin_install: (message) => `Plugin install ${trimmed(message.status) ?? "updated"}${trimmed(message.name) === undefined ? "" : `: ${trimmed(message.name)}`}`,
+    status: (message) => `Status: ${trimmed(message.status) ?? "idle"}${trimmed(message.error) === undefined ? "" : ` (${trimmed(message.error)})`}`,
+    task_notification: (message) => `Task ${trimmed(message.task_id) ?? "unknown"} ${trimmed(message.status) ?? "updated"}`,
+    task_progress: (message) => trimmed(message.description) ?? `Task ${trimmed(message.task_id) ?? "unknown"} progressed`,
+    task_started: (message) => trimmed(message.description) ?? `Task ${trimmed(message.task_id) ?? "unknown"} started`,
+    task_updated: (message) => `Task ${trimmed(message.task_id) ?? "unknown"} updated`,
+    worker_shutting_down: (message) => `Worker stopping: ${trimmed(message.reason) ?? "unknown reason"}`,
 };
 function runCall(name, value, input) {
     if (name !== "Bash")
         return undefined;
-    const command = nonblank(value.command);
+    const command = trimmed(value.command);
     return command === undefined ? otherToolCall(name, input) : { kind: "run", command };
 }
 function readCall(name, path, value) {
@@ -115,19 +92,18 @@ function readCall(name, path, value) {
 }
 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);
+        const query = trimmed(value.pattern) ?? trimmed(value.query);
         return query === undefined
             ? undefined
-            : { kind: "search", query, scope: "files", ...(globPath === undefined ? {} : { path: globPath }) };
+            : searchToolCall(query, "content", { path: trimmed(value.path), glob: trimmed(value.glob) });
+    }
+    if (name === "Glob") {
+        const query = trimmed(value.pattern);
+        return query === undefined ? undefined : searchToolCall(query, "files", { path: trimmed(value.path) });
     }
     if (name === "WebSearch") {
-        const query = nonblank(value.query);
-        return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+        const query = trimmed(value.query);
+        return query === undefined ? undefined : searchToolCall(query, "web");
     }
     return undefined;
 }
@@ -143,44 +119,83 @@ function fileChangeCall(name, path) {
 }
 function startedPath(name, value) {
     if (name === "NotebookEdit")
-        return nonblank(value.notebook_path);
-    return nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+        return trimmed(value.notebook_path);
+    return trimmed(value.file_path) ?? (name === "Read" ? trimmed(value.path) : undefined);
 }
 function nonnegativeInt(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
 }
-function fileChange(op, path, gitDiff) {
-    const diff = object(gitDiff);
+function fileChange(op, path, result) {
+    const diff = object(result.gitDiff);
     const added = nonnegativeInt(diff?.additions);
     const removed = nonnegativeInt(diff?.deletions);
-    const diffstat = added === undefined || removed === undefined ? undefined : { added, removed };
+    const patch = stringValue(diff?.patch) ?? structuredPatchText(path, result.structuredPatch);
+    const diffstat = added === undefined || removed === undefined
+        ? patch === undefined
+            ? undefined
+            : diffstatFromUnifiedPatch(patch)
+        : { added, removed };
     return {
         kind: "fileChange",
-        changes: [{ op, path, ...(diffstat === undefined ? {} : { diffstat }) }],
+        changes: [
+            {
+                op,
+                path,
+                ...(diffstat === undefined ? {} : { diffstat }),
+                ...(patch === undefined ? {} : { patch }),
+            },
+        ],
     };
 }
+/**
+ * Render the native hunk record as unified diff text when the provider supplied
+ * no patch of its own. Every figure comes from that record; nothing is
+ * reconstructed from the working tree or from proposed old and new strings.
+ */
+function structuredPatchText(path, value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const hunks = [];
+    for (const entry of value) {
+        const hunk = object(entry);
+        const oldStart = finiteNumber(hunk?.oldStart);
+        const oldLines = finiteNumber(hunk?.oldLines);
+        const newStart = finiteNumber(hunk?.newStart);
+        const newLines = finiteNumber(hunk?.newLines);
+        const lines = hunk?.lines;
+        if (oldStart === undefined ||
+            oldLines === undefined ||
+            newStart === undefined ||
+            newLines === undefined ||
+            !Array.isArray(lines) ||
+            lines.some((line) => typeof line !== "string")) {
+            return undefined;
+        }
+        hunks.push(`@@ -${oldStart},${oldLines} +${newStart},${newLines} @@`, ...lines);
+    }
+    return [`--- a/${path}`, `+++ b/${path}`, ...hunks].join("\n");
+}
 function writeResult(result) {
     const value = object(result);
     if (value === undefined || (value.type !== "create" && value.type !== "update"))
         return undefined;
-    const path = nonblank(value.filePath);
+    const path = trimmed(value.filePath);
     if (path === undefined)
         return undefined;
-    const op = value.type === "create" ? "add" : "update";
-    return fileChange(op, path, value.gitDiff);
+    return fileChange(value.type === "create" ? "add" : "update", path, value);
 }
 function editResult(result) {
     const value = object(result);
     if (value === undefined || value.type === "create" || value.type === "update")
         return undefined;
-    const path = nonblank(value.filePath);
+    const path = trimmed(value.filePath);
     if (path === undefined)
         return undefined;
     const status = object(value.gitDiff)?.status;
-    return fileChange(status === "added" ? "add" : "update", path, value.gitDiff);
+    return fileChange(status === "added" ? "add" : "update", path, value);
 }
 function notebookResult(result) {
-    const path = nonblank(object(result)?.notebook_path);
+    const path = trimmed(object(result)?.notebook_path);
     return path === undefined ? undefined : { kind: "fileChange", changes: [{ op: "update", path }] };
 }
 function structuredFileChange(name, result) {
@@ -199,6 +214,11 @@ function toolCall(name, input) {
     return (readCall(name, path, value) ?? searchCall(name, value) ?? fileChangeCall(name, path) ?? otherToolCall(name, input));
 }
 function assistantEvents(message, events, state) {
+    // Every complete response names the model that produced it; the native model
+    // identity is reported as-is.
+    const model = trimmed(object(message.message)?.model);
+    if (model !== undefined)
+        events.emit(modelEvent(model));
     if (message.aborted === true)
         return;
     if (message.error !== undefined) {
@@ -232,7 +252,7 @@ function toolResultEvents(message, events, state) {
         const value = object(block);
         if (value?.type !== "tool_result")
             continue;
-        const id = nonblank(value.tool_use_id);
+        const id = trimmed(value.tool_use_id);
         if (id === undefined)
             continue;
         const observed = state.tools.get(id);
@@ -241,30 +261,51 @@ function toolResultEvents(message, events, state) {
         state.tools.delete(id);
         const failed = value.is_error === true;
         const structured = failed ? undefined : structuredFileChange(observed.name, message.tool_use_result);
+        const output = observedTextContent(value.content);
         events.emit({
             type: "tool",
             phase: "completed",
             id,
             name: observed.name,
             call: structured ?? observed.call,
-            result: { status: failed ? "error" : "ok" },
+            result: {
+                status: failed ? "error" : "ok",
+                ...(output === undefined ? {} : { output }),
+            },
         });
     }
 }
 function hookResponseNote(value) {
-    const outcome = nonblank(value.outcome);
+    const outcome = trimmed(value.outcome);
     if (outcome !== "error" && outcome !== "cancelled")
         return undefined;
-    const hook = nonblank(value.hook_name) ?? "unknown";
-    const exitCode = number(value.exit_code);
+    const hook = trimmed(value.hook_name) ?? "unknown";
+    const exitCode = finiteNumber(value.exit_code);
     return `Hook ${hook} ${outcome}${exitCode === undefined ? "" : ` (exit ${exitCode})`}`;
 }
+/**
+ * Native system notices that prove which model the session is actually using.
+ * `init` reports the startup selection. A refusal fallback reports the model
+ * that serves the retried request; only a session-scoped fallback swaps the
+ * session model, and `local` leaves it unchanged. The two no-longer-emitted
+ * directions stay in the native enum and are never treated as evidence.
+ */
+function systemModelEvidence(subtype, value) {
+    if (subtype === "init")
+        return trimmed(value.model);
+    if (subtype !== "model_refusal_fallback" || value.scope === "local")
+        return undefined;
+    return value.direction === "revert" || value.direction === "sticky" ? undefined : trimmed(value.fallback_model);
+}
 function emitSystemMessage(value, events) {
-    const subtype = nonblank(value?.subtype) ?? "unknown";
+    const subtype = trimmed(value?.subtype) ?? "unknown";
     if (!Object.hasOwn(CLAUDE_SYSTEM_DISPOSITIONS, subtype)) {
         events.emit(unknownEvent(subtype));
         return;
     }
+    const evidence = systemModelEvidence(subtype, value);
+    if (evidence !== undefined)
+        events.emit(modelEvent(evidence));
     const systemDisposition = CLAUDE_SYSTEM_DISPOSITIONS[subtype];
     if (systemDisposition === "drop")
         return;
@@ -281,7 +322,7 @@ function emitSystemMessage(value, events) {
 }
 export function emitClaudeMessage(message, events, state) {
     const value = object(message) ?? {};
-    const kind = nonblank(value.type) ?? "unknown";
+    const kind = trimmed(value.type) ?? "unknown";
     if (!Object.hasOwn(CLAUDE_MESSAGE_DISPOSITIONS, kind))
         return events.emit(unknownEvent(kind));
     const disposition = CLAUDE_MESSAGE_DISPOSITIONS[kind];
@@ -292,7 +333,7 @@ export function emitClaudeMessage(message, events, state) {
         toolResultEvents(message, events, state);
     }
     else if (disposition === "auth") {
-        const error = nonblank(value.error);
+        const error = trimmed(value.error);
         if (error !== undefined)
             events.emit(noteEvent(`Authentication warning: ${error}`));
     }

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

@@ -2,13 +2,12 @@ import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-
 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<{
     executable?: string;
     config?: Readonly<Record<string, unknown>>;
     env?: Readonly<Record<string, string>>;
 }>;
-export type ClaudeSdk = Readonly<{
+type ClaudeSdk = Readonly<{
     query(input: Readonly<{
         prompt: string | AsyncIterable<SDKUserMessage>;
         options?: Options;
@@ -42,3 +41,4 @@ export declare const claudeProvider: Readonly<{
         }>;
     }>): import("../../provider.js").ProviderAttempt<Session>;
 }>;
+export {};

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

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { emitClaudeMessage } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
-export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
 class ReceiptChannel {
     queued = [];
     waiters = [];
@@ -98,9 +98,6 @@ async function forkClaude(load, execution, input) {
         throw new Error("Claude fork reused the source session id");
     return { session: { sessionId: forked.sessionId } };
 }
-function launchText(input) {
-    return [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
-}
 function successfulResult(message, historyId) {
     return {
         kind: "answered",
@@ -292,7 +289,7 @@ async function driveClaude(load, execution, drive, custody) {
     const run = randomUUID();
     const accepted = [];
     const driveState = { submission: 0, openSubmissions: 0 };
-    const launchAcknowledged = input.push(claudeUserMessage(launchText(drive)));
+    const launchAcknowledged = input.push(claudeUserMessage(launchPrompt(drive.body, drive.launchTells)));
     const query = sdk.query({
         prompt: input.iterable,
         options: claudeQueryOptions(drive, execution, abortController),
@@ -364,8 +361,7 @@ export function createClaudeProvider(loadOrExecution = async () => (await import
     return {
         admitOptions: admitClaudeOptions,
         fork: (input) => createProviderAttempt(new AbortController().signal, async () => await forkClaude(load, selectedExecution, input)),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await driveClaude(load, selectedExecution, { ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await driveClaude(load, selectedExecution, { ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle((input, custody) => driveClaude(load, selectedExecution, input, custody)),
     };
 }
 export const claudeProvider = createClaudeProvider(async () => (await import("@anthropic-ai/claude-agent-sdk")));

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

@@ -1,4 +1,5 @@
-import { noteEvent, unknownEvent, } from "../../provider.js";
+import { modelEvent, noteEvent, unknownEvent, } from "../../provider.js";
+import { stringValue } from "../decode.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CODEX_NOTIFICATION_DISPOSITIONS = {
     "account/login/completed": "drop",
@@ -148,12 +149,14 @@ function itemChanges(item) {
         const op = fileChangeOp(change?.kind);
         if (path === undefined || op === undefined)
             return [];
-        const diffstat = typeof change?.diff === "string" ? diffstatFromUnifiedPatch(change.diff) : undefined;
+        const patch = stringValue(change?.diff);
+        const diffstat = patch === undefined ? undefined : diffstatFromUnifiedPatch(patch);
         return [
             {
                 op,
                 path,
                 ...(diffstat === undefined ? {} : { diffstat }),
+                ...(patch === undefined ? {} : { patch }),
             },
         ];
     });
@@ -195,10 +198,12 @@ function itemToolResult(item) {
     const status = codexText(item.status);
     const failed = error !== undefined || status === "failed" || status === "error";
     const detail = codexText(error?.message) ?? codexText(error?.additionalDetails);
+    const output = stringValue(item.aggregatedOutput);
     const exitCode = typeof item.exitCode === "number" && Number.isSafeInteger(item.exitCode) ? item.exitCode : undefined;
     return {
         status: failed || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
         ...(detail === undefined ? {} : { message: detail }),
+        ...(output === undefined ? {} : { output }),
         ...(exitCode === undefined ? {} : { exitCode }),
     };
 }
@@ -318,6 +323,13 @@ function hookCompletionNote(params) {
     const diagnostic = codexText(run?.statusMessage) ?? codexText(issue?.text);
     return `Hook ${eventName} ${label}${diagnostic === undefined ? "" : `: ${diagnostic}`}`;
 }
+/**
+ * A reroute names the model that now serves this thread, so it is runtime-model
+ * evidence as well as narration. Other notifications carry no model identity.
+ */
+function notificationModel(method, params) {
+    return method === "model/rerouted" ? codexText(params.toModel) : undefined;
+}
 function observeError(params, state, events) {
     const detail = turnError(params.error) ?? codexText(params.message) ?? "codex app-server error";
     state.error = detail;
@@ -348,6 +360,9 @@ export function codexNotificationResult(notification, state, events) {
         return undefined;
     }
     const disposition = CODEX_NOTIFICATION_DISPOSITIONS[method];
+    const rerouted = notificationModel(method, params);
+    if (rerouted !== undefined)
+        events.emit(modelEvent(rerouted));
     switch (disposition) {
         case "drop":
             return undefined;

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

@@ -1,6 +1,7 @@
 import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
-import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 function diagnostic(error) {
@@ -29,6 +30,12 @@ function turnId(result) {
         throw new Error("codex app-server did not return a turn id");
     return id;
 }
+/** Thread admission answers with the model the server actually loaded. */
+function emitAdmittedModel(result, events) {
+    const model = codexText(codexObject(result)?.model);
+    if (model !== undefined)
+        events.emit(modelEvent(model));
+}
 async function steerTurn(server, state, tell) {
     if (state.settled)
         return { kind: "turn-ended" };
@@ -61,13 +68,15 @@ async function admitTurn(server, input, state, events, config) {
                 : { developerInstructions: input.options.systemPrompt }),
     };
     if (input.session.kind === "fresh") {
-        state.threadId = threadId(await server.request("thread/start", threadParams));
+        const admitted = await server.request("thread/start", threadParams);
+        state.threadId = threadId(admitted);
+        emitAdmittedModel(admitted, events);
     }
     else {
-        state.threadId = threadId(await server.request("thread/resume", {
-            threadId: input.session.coordinate.sessionId,
-            ...threadParams,
-        }), input.session.coordinate.sessionId);
+        const resumed = input.session.coordinate.sessionId;
+        const admitted = await server.request("thread/resume", { threadId: resumed, ...threadParams });
+        state.threadId = threadId(admitted, resumed);
+        emitAdmittedModel(admitted, events);
     }
     events.emit({ type: "session", coordinate: { sessionId: state.threadId } });
     state.turnId = turnId(await server.request("turn/start", {
@@ -75,9 +84,7 @@ async function admitTurn(server, input, state, events, config) {
         input: [
             {
                 type: "text",
-                text: [input.body, ...input.launchTells.map((tell) => tell.text)]
-                    .filter((part) => part.length > 0)
-                    .join("\n\n"),
+                text: launchPrompt(input.body, input.launchTells),
             },
         ],
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
@@ -214,7 +221,6 @@ export function createCodexAppServerProvider(input = "codex") {
             };
         },
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => await forkCodex(execution, input, custody)),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle((input, custody) => startCodex(execution, input, custody)),
     };
 }

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

@@ -0,0 +1,33 @@
+import type { SearchScope, ToolCall } from "../provider.js";
+/**
+ * Native payload decoders shared by provider event adaptation. Every adapter
+ * reads the same untrusted native shapes; these are the only places that decide
+ * what a present value means, so each keeps one exact predicate and return.
+ */
+export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+export declare function object(value: unknown): Readonly<Record<string, unknown>> | undefined;
+/** A string with non-blank trim, returned as supplied. */
+export declare function nonblank(value: unknown): string | undefined;
+/** A string with non-blank trim, returned trimmed. */
+export declare function trimmed(value: unknown): string | undefined;
+/** A nonempty string, returned as supplied; internal whitespace stays content. */
+export declare function text(value: unknown): string | undefined;
+/** Any string, including the empty one; absence stays absence. */
+export declare function stringValue(value: unknown): string | undefined;
+/**
+ * The observed text of one native result value: a plain string, or its text
+ * blocks joined in native order. A value carrying no text block observed no
+ * text, while a present empty string is observed and empty.
+ */
+export declare function observedTextContent(content: unknown): string | undefined;
+/** A one-based line number. */
+export declare function positiveLine(value: unknown): number | undefined;
+export declare function nonnegativeCount(value: unknown): number | undefined;
+export declare function finiteNumber(value: unknown): number | undefined;
+/** One neutral search call carrying only the bounds the native input supplied. */
+export declare function searchToolCall(query: string, scope: SearchScope | undefined, bounds?: Readonly<{
+    path?: string | undefined;
+    glob?: string | undefined;
+}>): Extract<ToolCall, {
+    kind: "search";
+}>;