@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/agents/providers/claude-agent-sdk/registration.js

@@ -0,0 +1,214 @@
+import { z } from "zod";
+import { claudeSettingSourceSchema, executableSchema, providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
+import { FlowError } from "../../../flow-error.js";
+import { exactKeys, optionalString, optionalStringRecord, requiredEnum, snapshotError, } from "../../launch-snapshot/parse-helpers.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
+import { CLAUDE_AGENT_SDK_PROVIDER } from "./session.js";
+import { claudeSessionSchema } from "./session-schema.js";
+const startClaudeAgentSdk = async (prompt, cwd, options) => {
+    const { startClaudeAgentSdk: start } = await import("./adapter.js");
+    return start(prompt, cwd, options);
+};
+const CLAUDE_SETTING_SOURCES = new Set(["project", "user", "local"]);
+const ACCESS_VALUES = ["read", "write", "auto"];
+function admitResumeShape(schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${CLAUDE_AGENT_SDK_PROVIDER}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+export const claudeAgentSdkRegistration = {
+    name: CLAUDE_AGENT_SDK_PROVIDER,
+    start: startClaudeAgentSdk,
+    sessionSchema: claudeSessionSchema,
+    effortField: "effort",
+    instanceSchema: z
+        .object({
+        kind: z.literal(CLAUDE_AGENT_SDK_PROVIDER),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        settingSources: z.array(claudeSettingSourceSchema).optional(),
+        env: providerEnvSchema,
+    })
+        .strict(),
+    builtinInstance: {
+        name: CLAUDE_AGENT_SDK_PROVIDER,
+        source: "builtin",
+        instance: {
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            executable: "claude",
+            settingSources: ["project"],
+        },
+    },
+    builtinAkumaProfiles: [
+        { name: "akuma-claude", description: "Default Claude Agent SDK Akuma." },
+    ],
+    portablePolicy: {
+        access: new Set(ACCESS_VALUES),
+        network: new Set(),
+        webSearch: new Set(["disabled"]),
+    },
+    maxCaptureChars: (config) => config.claude.execMaxCaptureChars,
+    buildCallTerms: ({ snapshot, baseTerms, body }) => {
+        const provider = snapshot.provider;
+        return {
+            ...baseTerms,
+            provider: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(provider.model !== undefined ? { model: provider.model } : {}),
+            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
+            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
+            ...(provider.settingSources !== undefined ? { settingSources: provider.settingSources } : {}),
+            permissionMode: provider.permissionMode,
+            ...(provider.allowDangerouslySkipPermissions !== undefined
+                ? { allowDangerouslySkipPermissions: provider.allowDangerouslySkipPermissions }
+                : {}),
+            ...(provider.disallowedTools !== undefined ? { disallowedTools: provider.disallowedTools } : {}),
+            ...(provider.env !== undefined ? { env: provider.env } : {}),
+            systemPrompt: body
+                ? { type: "preset", preset: "claude_code", append: body }
+                : undefined,
+            onCheckpoint() { },
+        };
+    },
+    resolveLaunchProvider: ({ common, instance, model, effort, access, webSearch }) => {
+        if (instance.kind !== CLAUDE_AGENT_SDK_PROVIDER) {
+            throw new Error(`resolveLaunchProvider expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
+        }
+        const claudeInstance = instance;
+        const permissionMode = access === "read"
+            ? "plan"
+            : access === "write"
+                ? "acceptEdits"
+                : access === "auto"
+                    ? "bypassPermissions"
+                    : "default";
+        return Object.freeze({
+            ...common,
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(claudeInstance.executable !== undefined ? { executable: claudeInstance.executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(claudeInstance.settingSources !== undefined ? { settingSources: claudeInstance.settingSources } : {}),
+            permissionMode,
+            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(webSearch === "disabled" ? { disallowedTools: ["WebSearch"] } : {}),
+            ...(claudeInstance.env !== undefined ? { env: claudeInstance.env } : {}),
+        });
+    },
+    parseLaunchProvider: (provider, common) => {
+        exactKeys(provider, [
+            "name",
+            "source",
+            "kind",
+            "executable",
+            "model",
+            "effort",
+            "settingSources",
+            "permissionMode",
+            "allowDangerouslySkipPermissions",
+            "disallowedTools",
+            "env",
+        ], "provider");
+        const modes = new Set(["default", "plan", "acceptEdits", "bypassPermissions"]);
+        const permissionMode = requiredEnum(provider, "permissionMode", "provider", modes);
+        if (permissionMode === "bypassPermissions") {
+            if (provider.allowDangerouslySkipPermissions !== true) {
+                throw snapshotError("provider.allowDangerouslySkipPermissions", "must be true for bypassPermissions");
+            }
+        }
+        else if ("allowDangerouslySkipPermissions" in provider) {
+            throw snapshotError("provider.allowDangerouslySkipPermissions", "is only valid for bypassPermissions");
+        }
+        let settingSources;
+        if ("settingSources" in provider) {
+            if (!Array.isArray(provider.settingSources))
+                throw snapshotError("provider.settingSources", "must be an array");
+            settingSources = Object.freeze(provider.settingSources.map((source, index) => {
+                if (typeof source !== "string" || !CLAUDE_SETTING_SOURCES.has(source)) {
+                    throw snapshotError(`provider.settingSources[${index}]`, "has an invalid setting source");
+                }
+                return source;
+            }));
+        }
+        let disallowedTools;
+        if ("disallowedTools" in provider) {
+            if (!Array.isArray(provider.disallowedTools) ||
+                provider.disallowedTools.length !== 1 ||
+                provider.disallowedTools[0] !== "WebSearch") {
+                throw snapshotError("provider.disallowedTools", "must equal ['WebSearch']");
+            }
+            disallowedTools = Object.freeze(["WebSearch"]);
+        }
+        const executable = optionalString(provider, "executable", "provider");
+        const model = optionalString(provider, "model", "provider");
+        const effort = optionalString(provider, "effort", "provider");
+        const env = optionalStringRecord(provider, "env");
+        return Object.freeze({
+            ...common,
+            kind: CLAUDE_AGENT_SDK_PROVIDER,
+            ...(executable !== undefined ? { executable } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(settingSources !== undefined ? { settingSources } : {}),
+            permissionMode,
+            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(disallowedTools !== undefined ? { disallowedTools } : {}),
+            ...(env !== undefined ? { env } : {}),
+        });
+    },
+    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
+    providerEffortAndModel: (provider) => {
+        const resolved = provider;
+        return { model: resolved.model, effort: resolved.effort };
+    },
+    attachLoader: (terms, ports) => {
+        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER)
+            return terms;
+        const loader = ports.claudeAgentSdk;
+        return loader ? { ...terms, loader } : terms;
+    },
+    nativePolicyOwnership: () => null,
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
+            throw new Error(`startLive expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
+        }
+        const claudeTerms = terms;
+        const claudeOptions = {
+            model: claudeTerms.model,
+            executable: claudeTerms.executable,
+            effort: claudeTerms.effort,
+            env: claudeTerms.env,
+            signal,
+            permissionMode: claudeTerms.permissionMode,
+            settingSources: claudeTerms.settingSources,
+            allowDangerouslySkipPermissions: claudeTerms.allowDangerouslySkipPermissions,
+            disallowedTools: claudeTerms.disallowedTools,
+            systemPrompt: claudeTerms.systemPrompt,
+            onSyncCheckpoint,
+            onEvidence: claudeTerms.onEvidence,
+            onIngress,
+            initialTurn: claudeTerms.initialTurn,
+            loader: claudeTerms.loader,
+        };
+        const { startClaudeAgentSdk: start } = await import("./adapter.js");
+        if (reviveTerms) {
+            const session = admitResumeShape(claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+            return start(claudeTerms.prompt, claudeTerms.workdir, {
+                ...claudeOptions,
+                sessionId: session.sessionId,
+            });
+        }
+        return start(claudeTerms.prompt, claudeTerms.workdir, claudeOptions);
+    },
+};

package/build/agents/providers/claude-agent-sdk/session-schema.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const claudeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });

package/build/agents/providers/codex-app-server/adapter.js

@@ -1,52 +1,22 @@
-import { z } from "zod";
 import { appendDebugLog } from "../../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../../session.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
-import { buildSubagentEnv, createAbortError, emitProviderEvidence, coerceString } from "../../harness/runtime.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
+import { awaitProviderAbortSettlement, buildSubagentEnv, createAbortError, emitProviderEvidence, coerceString, } from "../../harness/runtime.js";
+import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 import { CodexAppServerProcess } from "./session.js";
 import { createCodexAppServerTurnMonitor, createCodexAppServerTurnState, recordTurnStartResponse, } from "./events.js";
+export { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 /** Identity-only opacity boundary for codex-app-server turn/start effort. */
 function toCodexAppServerEffort(effort) {
     return effort;
 }
-/** Session handle for codex-app-server: thread id plus optional CODEX_HOME for cross-process resume. */
-export const codexAppServerSessionSchema = z.object({
-    threadId: z.string().trim().min(1),
-    codexHome: z.string().trim().min(1).optional(),
-});
-const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+export { codexAppServerSessionSchema } from "./session-schema.js";
 const MINIMUM_CODEX_APP_SERVER_VERSION = { major: 0, minor: 143, patch: 0 };
 /** Non-interactive defaults for turn/start (faye #316 policy A). */
 export const CODEX_APP_SERVER_TURN_APPROVAL_POLICY = "never";
-export function buildCodexAppServerWorkspaceWriteSandboxPolicy(input) {
-    return {
-        type: "workspaceWrite",
-        writableRoots: [...input.writableRoots],
-        networkAccess: input.networkAccess,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-    };
-}
-/** True when config.* already owns approval policy — omit turn-level approvalPolicy default. */
-export function configOwnsApprovalPolicy(config) {
-    if (!config)
-        return false;
-    return Object.prototype.hasOwnProperty.call(config, "approval_policy");
-}
-/**
- * True when config.* already owns sandbox settings — omit turn-level sandboxPolicy default.
- * Matches `sandbox_mode` or any `sandbox_workspace_write` / `sandbox_workspace_write.*` key.
- */
-export function configOwnsSandboxPolicy(config) {
-    if (!config)
-        return false;
-    for (const key of Object.keys(config)) {
-        if (key === "sandbox_mode" || key === "sandbox_workspace_write" || key.startsWith("sandbox_workspace_write.")) {
-            return true;
-        }
-    }
-    return false;
-}
+export { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
+import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
 function parseSemver(version) {
     const match = version.trim().match(/(\d+)\.(\d+)\.(\d+)/);
     if (!match)
@@ -83,6 +53,14 @@ function extractVersionFromInitialize(result) {
     }
     return coerceString(record.version) ?? coerceString(record.cliVersion);
 }
+export async function settleCodexGracefulInterrupt(input) {
+    await input.requestInterrupt();
+    const terminal = await input.completion;
+    const terminalTurnId = coerceString(terminal.turn.id);
+    if (terminalTurnId !== input.turnId || terminal.status !== "interrupted") {
+        throw new Error(`${CODEX_APP_SERVER_PROVIDER} graceful abort expected interrupted turn '${input.turnId}', got '${terminalTurnId ?? "unknown"}' status '${terminal.status}'`);
+    }
+}
 /** Gate-facing production entry: the harness owns clocks, capture, classification, and outcome construction. */
 export async function startCodexAppServer(prompt, cwd, options = {}) {
     const executable = options.executable?.trim() || "codex";
@@ -91,6 +69,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
     const turnState = createCodexAppServerTurnState();
     let activeThreadId;
     let interruptRequested = false;
+    let activeTurnCompletion;
     let builderDiagnostic;
     let emitTurnStarted;
     const pendingTells = [];
@@ -204,19 +183,29 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 await server?.close("force");
                 return;
             }
-            if (server && activeThreadId && turnState.activeTurnId) {
-                try {
-                    // RPC acknowledgement is NOT terminal proof; wait for turn/completed interrupted.
-                    await server.request("turn/interrupt", {
-                        threadId: activeThreadId,
-                        turnId: turnState.activeTurnId,
-                    });
-                }
-                catch {
-                    // idle interrupt may error; still rely on process teardown
+            if (!server)
+                return;
+            if (activeThreadId && turnState.activeTurnId) {
+                const turnId = turnState.activeTurnId;
+                const completion = activeTurnCompletion;
+                if (!completion) {
+                    throw new Error(`${CODEX_APP_SERVER_PROVIDER} graceful abort lacked an active turn monitor`);
                 }
+                await awaitProviderAbortSettlement(CODEX_APP_SERVER_PROVIDER, (async () => {
+                    // RPC acknowledgement is submission evidence only. Keep the monitor
+                    // and server alive until the matching terminal notification arrives.
+                    await settleCodexGracefulInterrupt({
+                        turnId,
+                        requestInterrupt: () => server.request("turn/interrupt", {
+                            threadId: activeThreadId,
+                            turnId,
+                        }),
+                        completion,
+                    });
+                })());
+                return;
             }
-            await server?.close("graceful");
+            await awaitProviderAbortSettlement(CODEX_APP_SERVER_PROVIDER, server.close("force"), "startup abort could not force-close owned server");
         },
         async run(builder) {
             builderDiagnostic = (text) => builder.emit({ type: "diagnostic", text });
@@ -239,6 +228,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 isDrainingTells: () => drainingTells,
                 setFinishAfterTellDrain: (finish) => { finishAfterTellDrain = finish; },
             });
+            activeTurnCompletion = turnCompleted;
             try {
                 const initResult = await server.request("initialize", {
                     clientInfo: {
@@ -255,7 +245,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 if (isCodexAppServerVersionBelowMinimum(version)) {
                     const message = `${CODEX_APP_SERVER_PROVIDER} refused: initialize version '${version}' is below minimum supported version 0.143.0`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 const initRecord = (initResult && typeof initResult === "object" ? initResult : {});
                 const serverCodexHome = coerceString(initRecord.codexHome) ?? options.codexHome;
@@ -280,7 +270,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 if (!activeThreadId) {
                     const message = `${CODEX_APP_SERVER_PROVIDER} exec could not determine thread id`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 if (options.onEvidence)
                     emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_APP_SERVER_PROVIDER, threadId: activeThreadId }, builderDiagnostic);
@@ -303,6 +293,8 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 turnState.activeTurnId = undefined;
                 turnState.activeTurnSource = undefined;
                 turnState.activeTurnAcceptingSteer = false;
+                turnState.failureCause = undefined;
+                turnState.turnInFlight = true;
                 const turnStart = await server.request("turn/start", turnStartParams);
                 const turn = turnStart && typeof turnStart === "object"
                     ? (turnStart.turn ?? undefined)
@@ -311,18 +303,20 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 if (options.onEvidence)
                     emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_APP_SERVER_PROVIDER, fence: { kind: "turn", turnId }, source: "response" }, builderDiagnostic);
                 const completed = await turnCompleted;
+                turnState.turnInFlight = false;
                 if (completed.status === "interrupted" || interruptRequested) {
                     throw createAbortError(`${CODEX_APP_SERVER_PROVIDER} turn interrupted`);
                 }
                 if (completed.status === "failed") {
                     const message = `${CODEX_APP_SERVER_PROVIDER} turn failed`;
-                    builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message, {
+                        ...(turnState.failureCause ? { publicCause: turnState.failureCause } : {}),
+                    });
                 }
                 if (completed.status !== "completed") {
                     const message = `${CODEX_APP_SERVER_PROVIDER} turn ended with status '${completed.status}'`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
                 const session = {
@@ -338,6 +332,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 return { finalMessage, session };
             }
             finally {
+                activeTurnCompletion = undefined;
                 rejectPendingTells(new Error(`${CODEX_APP_SERVER_PROVIDER} execution ended before queued tell acceptance`));
                 await server?.close();
                 server = undefined;
@@ -345,3 +340,5 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
         },
     });
 }
+// Compiler-level binding to the named ProviderAdapter function contract.
+startCodexAppServer;

package/build/agents/providers/codex-app-server/events.js

@@ -1,7 +1,8 @@
 import { boundActivityExcerpt, diffstatFromUnifiedPatch } from "../../harness/activity-values.js";
 import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
 import { createAbortError, emitProviderEvidence, coerceString } from "../../harness/runtime.js";
-const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 const CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED = new Set([
     "item/agentMessage/delta",
     "item/commandExecution/outputDelta",
@@ -16,11 +17,13 @@ const CODEX_APP_SERVER_NOTIFICATION_MAPPED = new Set([
     "turn/completed",
     "error",
 ]);
-export function codexAppServerNotificationDisposition(method) {
+export function codexAppServerNotificationDisposition(method, params) {
     if (CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED.has(method))
         return "acknowledged-unpersisted";
     if (CODEX_APP_SERVER_NOTIFICATION_MAPPED.has(method))
         return "mapped";
+    if (method === "account/rateLimits/updated" && codexAppServerRateLimitCause(params))
+        return "mapped";
     return "unknown";
 }
 export function appServerRecord(value) {
@@ -37,6 +40,41 @@ const CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES = [
 function isCodexAppServerActivityItemType(value) {
     return CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES.includes(value);
 }
+/** Map a native or legacy fileChange kind fact into the public op. */
+function appServerFileChangeOp(kind) {
+    if (kind === "add" || kind === "update" || kind === "delete")
+        return kind;
+    const record = appServerRecord(kind);
+    if (!record)
+        return undefined;
+    if (record.type === "add" || record.type === "update" || record.type === "delete")
+        return record.type;
+    return undefined;
+}
+/** Trustworthy provider patch text only: per-change native `diff`, else legacy `details.patch`. */
+function appServerFileChangeDiffstat(item) {
+    let additions = 0;
+    let deletions = 0;
+    let saw = false;
+    if (Array.isArray(item.changes)) {
+        for (const entry of item.changes) {
+            const change = appServerRecord(entry);
+            if (!change || typeof change.diff !== "string" || !change.diff)
+                continue;
+            const partial = diffstatFromUnifiedPatch(change.diff);
+            if (!partial)
+                continue;
+            saw = true;
+            additions += partial.additions;
+            deletions += partial.deletions;
+        }
+    }
+    if (saw)
+        return additions || deletions ? { additions, deletions } : undefined;
+    const details = appServerRecord(item.details);
+    const patch = typeof details?.patch === "string" ? details.patch : undefined;
+    return patch ? diffstatFromUnifiedPatch(patch) : undefined;
+}
 export function appServerActivityCall(itemType, item) {
     switch (itemType) {
         case "commandExecution":
@@ -53,9 +91,9 @@ export function appServerActivityCall(itemType, item) {
                     const change = appServerRecord(entry);
                     if (!change || typeof change.path !== "string")
                         return [];
-                    if (change.kind !== "add" && change.kind !== "update" && change.kind !== "delete")
+                    const op = appServerFileChangeOp(change.kind);
+                    if (!op)
                         return [];
-                    const op = change.kind;
                     return [{ op, path: change.path }];
                 })
                 : [];
@@ -80,11 +118,7 @@ export function appServerActivityResult(item) {
             : typeof item.error === "string" && item.error
                 ? boundActivityExcerpt(item.error)
                 : undefined;
-    const details = item.details !== null && typeof item.details === "object" && !Array.isArray(item.details)
-        ? item.details
-        : undefined;
-    const patch = typeof details?.patch === "string" ? details.patch : undefined;
-    const diffstat = patch ? diffstatFromUnifiedPatch(patch) : undefined;
+    const diffstat = appServerFileChangeDiffstat(item);
     return {
         status: item.status === "failed" || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
         ...(message ? { message } : {}),
@@ -131,9 +165,23 @@ export function createCodexAppServerTurnState() {
         responseSeenTurnIds: new Set(),
         completedBeforeResponseTurnIds: new Set(),
         activeTurnAcceptingSteer: false,
+        turnInFlight: false,
         lastAgentMessage: "",
     };
 }
+/** Admit only positive native exhaustion evidence; no provider strings survive. */
+export function codexAppServerRateLimitCause(params) {
+    const rateLimits = appServerRecord(appServerRecord(params)?.rateLimits);
+    if (!rateLimits)
+        return undefined;
+    for (const value of Object.values(rateLimits)) {
+        const window = appServerRecord(value);
+        if (typeof window?.usedPercent === "number" && window.usedPercent >= 100) {
+            return { kind: "rate_limit_exhausted" };
+        }
+    }
+    return undefined;
+}
 export function recordActiveTurnId(state, candidate, source) {
     const turnId = coerceString(candidate);
     if (!turnId)
@@ -178,7 +226,7 @@ export function createCodexAppServerTurnMonitor(options) {
         const failServerRequest = (request) => {
             // Policy A forbids interactive server→client requests. Fail immediately with named diagnostic.
             const message = `${CODEX_APP_SERVER_PROVIDER} unexpected server request '${request.method}' (id=${String(request.id)}); non-interactive policy forbids server→client requests`;
-            failTurn(new Error(message));
+            failTurn(createProviderFailure(message));
         };
         const requestDeliveryOpportunity = () => {
             try {
@@ -200,7 +248,7 @@ export function createCodexAppServerTurnMonitor(options) {
         });
         unsubNotifications = server.onNotification((notification) => {
             try {
-                builder.ingress(CODEX_APP_SERVER_PROVIDER, notification.method, notification, codexAppServerNotificationDisposition(notification.method), () => {
+                builder.ingress(CODEX_APP_SERVER_PROVIDER, notification.method, notification, codexAppServerNotificationDisposition(notification.method, notification.params), () => {
                     if (notification.method === "item/agentMessage/delta") {
                         const delta = coerceString(notification.params?.delta);
                         if (delta) {
@@ -274,6 +322,14 @@ export function createCodexAppServerTurnMonitor(options) {
                         onSyncCheckpoint?.({ enqueue }, checkpoint);
                         void drainPendingTells();
                     }
+                    if (notification.method === "account/rateLimits/updated") {
+                        const cause = codexAppServerRateLimitCause(notification.params);
+                        if (cause) {
+                            builder.emit({ type: "warning", warning: { reason: "rate-limit", state: "exhausted" } });
+                            if (state.turnInFlight)
+                                state.failureCause ??= cause;
+                        }
+                    }
                     if (notification.method === "turn/completed") {
                         const turn = notification.params?.turn ?? {};
                         const status = coerceString(turn.status) ?? "unknown";

package/build/agents/providers/codex-app-server/identity.js

@@ -0,0 +1 @@
+export const CODEX_APP_SERVER_PROVIDER = "codex-app-server";

package/build/agents/providers/codex-app-server/policy.js

@@ -0,0 +1,29 @@
+export function buildCodexAppServerWorkspaceWriteSandboxPolicy(input) {
+    return {
+        type: "workspaceWrite",
+        writableRoots: [...input.writableRoots],
+        networkAccess: input.networkAccess,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+/** True when config.* already owns approval policy — omit turn-level approvalPolicy default. */
+export function configOwnsApprovalPolicy(config) {
+    if (!config)
+        return false;
+    return Object.prototype.hasOwnProperty.call(config, "approval_policy");
+}
+/**
+ * True when config.* already owns sandbox settings — omit turn-level sandboxPolicy default.
+ * Matches `sandbox_mode` or any `sandbox_workspace_write` / `sandbox_workspace_write.*` key.
+ */
+export function configOwnsSandboxPolicy(config) {
+    if (!config)
+        return false;
+    for (const key of Object.keys(config)) {
+        if (key === "sandbox_mode" || key === "sandbox_workspace_write" || key.startsWith("sandbox_workspace_write.")) {
+            return true;
+        }
+    }
+    return false;
+}