test: harden codex auth startup contracts

fix: refresh plugin sdk surface budget
docs: add alpha package changelog
2026-06-24 08:12:29 +08:00 · 2026-06-21 04:20:10 +00:00 · 2026-06-21 03:43:04 +00:00 · 2026-06-21 03:15:31 +00:00 · 2026-06-21 02:39:12 +00:00 · 2026-06-21 02:26:05 +00:00
370 changed files with 14282 additions and 25611 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,16 @@

 Docs: https://docs.openclaw.ai

+## 2026.6.10-alpha.3
+
+### Changes
+
+- Alpha nightly from current `main`, including unreleased agent, release, plugin, UI, mobile, and channel changes since 2026.6.9.
+
+### Fixes
+
+- Release validation includes refreshed config documentation metadata for the alpha package, stabilized Feishu media temp-home tests, and typed run-node signal injection for the alpha release path.
+
 ## 2026.6.9

 ### Highlights
--- a/docs/.generated/config-baseline.sha256
+++ b/docs/.generated/config-baseline.sha256
@@ -1,4 +1,4 @@
-ac06b6c20a93a8543ec1bd3748ef4f7bdae5006839dd93b3fff874d0da4244aa  config-baseline.json
-e7965566fdaedef445bcd562141f4f3ea1a499cf8ea5956418af7c98049bf242  config-baseline.core.json
+37742164ebf1765a735c4d56000a5ba18e817b6ac71782371c863a564cf6e7c5  config-baseline.json
+2923c1120c0369aeca6646cd67f7264590c6a1f4e5bc3157a04d7661324c6868  config-baseline.core.json
 2d735389858305509528e74329b6f8c65d311e1471c3b4e91dc17aaab8e63a80  config-baseline.channel.json
 0039da0cf2ba2845b37db52c4cf3a0f25e367cf3d2d507c5d6f8a5e5bdfdc4d4  config-baseline.plugin.json
--- a/docs/plugins/codex-harness.md
+++ b/docs/plugins/codex-harness.md
@@ -143,39 +143,12 @@ The native Codex app-server harness supports context engines that require
 pre-prompt assembly. Generic CLI backends, including `codex-cli`, do not provide
 that host capability.

-Codex thread bindings live in OpenClaw's SQLite plugin state and use the stable
-agent-scoped OpenClaw session key, or an opaque conversation-binding id, as
-their owner. Physical session ids fence delayed cleanup but may rotate without
-losing the Codex thread. Context-engine compaction adopts the successor id
-before continuing native Codex compaction. The bounded store rejects a new
-binding at its safety limit instead of evicting an existing thread's continuity
-record.
-Conversation binds create or resume their Codex thread on the first bound
-message after channel approval; an abandoned approval consumes no thread row.
-That first message carries the prepared thread directly into its turn.
-Subsequent messages use a metadata-only resume to subscribe the shared client,
-then unsubscribe after the turn completes.
-The runtime does not poll transcript-adjacent binding files. Upgrades from
-releases that used `*.jsonl.codex-app-server.json` sidecars migrate them during
-normal startup preflight. `openclaw doctor --fix` can run the same migration
-manually.
-Successfully matched sidecars are archived before the new runtime resumes their
-threads. Migration imports durable thread ownership only; it does not infer
-Codex context usage from OpenClaw counters or crawl Codex rollout files. For
-agent-session harness bindings, the next resume attempts to restore a cached
-native snapshot when Codex has one, and ongoing turns persist the current-context
-usage reported by app-server notifications, not the cumulative thread lifetime
-total. Conversation bindings
-keep metadata-only resumes and leave continuity and compaction with the native
-Codex thread. Conflicting or ambiguous sidecars stay in place with a warning for
-operator review.
-
 For Codex-backed agents, `/compact` starts native Codex app-server compaction on
-the bound thread. OpenClaw bounds the request-acceptance RPC but does not wait
-for compaction completion, restart the shared app-server, or fall back to a
-context-engine or public OpenAI summarizer. If the native Codex thread binding
-is missing or stale, the command fails closed so the operator sees the real
-runtime boundary instead of silently switching compaction backends.
+the bound thread. OpenClaw does not wait for completion, impose an OpenClaw
+timeout, restart the shared app-server, or fall back to a context-engine or
+public OpenAI summarizer. If the native Codex thread binding is missing or
+stale, the command fails closed so the operator sees the real runtime boundary
+instead of silently switching compaction backends.

 ```json5
 {
--- a/extensions/acpx/npm-shrinkwrap.json
+++ b/extensions/acpx/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/acpx",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/acpx",
-      "version": "2026.6.8",
+      "version": "2026.6.10-alpha.3",
      "dependencies": {
        "@agentclientprotocol/claude-agent-acp": "0.39.0",
        "@zed-industries/codex-acp": "0.15.0",
--- a/extensions/acpx/package.json
+++ b/extensions/acpx/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/acpx",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw ACP runtime backend with plugin-owned session and transport management.",
  "repository": {
    "type": "git",
@@ -26,10 +26,10 @@
      "minHostVersion": ">=2026.4.25"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "staticAssets": [
        {
          "source": "./src/runtime-internals/mcp-proxy.mjs",
--- a/extensions/admin-http-rpc/package.json
+++ b/extensions/admin-http-rpc/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/admin-http-rpc",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw admin HTTP RPC endpoint",
  "type": "module",
--- a/extensions/alibaba/package.json
+++ b/extensions/alibaba/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/alibaba-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw Alibaba Model Studio video provider plugin",
  "type": "module",
--- a/extensions/amazon-bedrock-mantle/npm-shrinkwrap.json
+++ b/extensions/amazon-bedrock-mantle/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/amazon-bedrock-mantle-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/amazon-bedrock-mantle-provider",
-      "version": "2026.6.8",
+      "version": "2026.6.10-alpha.3",
      "dependencies": {
        "@anthropic-ai/sdk": "0.100.1",
        "@aws/bedrock-token-generator": "1.1.0"
--- a/extensions/amazon-bedrock-mantle/package.json
+++ b/extensions/amazon-bedrock-mantle/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/amazon-bedrock-mantle-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Amazon Bedrock Mantle provider plugin for OpenAI-compatible model routing.",
  "repository": {
    "type": "git",
@@ -24,10 +24,10 @@
      "minHostVersion": ">=2026.5.12-beta.1"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/amazon-bedrock/npm-shrinkwrap.json
+++ b/extensions/amazon-bedrock/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/amazon-bedrock-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/amazon-bedrock-provider",
-      "version": "2026.6.8",
+      "version": "2026.6.10-alpha.3",
      "dependencies": {
        "@aws-sdk/client-bedrock": "3.1056.0",
        "@aws-sdk/client-bedrock-runtime": "3.1056.0",
--- a/extensions/amazon-bedrock/package.json
+++ b/extensions/amazon-bedrock/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/amazon-bedrock-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Amazon Bedrock provider plugin with model discovery, embeddings, and guardrail support.",
  "repository": {
    "type": "git",
@@ -28,10 +28,10 @@
      "minHostVersion": ">=2026.5.12-beta.1"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/anthropic-vertex/npm-shrinkwrap.json
+++ b/extensions/anthropic-vertex/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/anthropic-vertex-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/anthropic-vertex-provider",
-      "version": "2026.6.8",
+      "version": "2026.6.10-alpha.3",
      "dependencies": {
        "@anthropic-ai/vertex-sdk": "0.16.1"
      }
--- a/extensions/anthropic-vertex/package.json
+++ b/extensions/anthropic-vertex/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/anthropic-vertex-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Anthropic Vertex provider plugin for Claude models on Google Vertex AI.",
  "repository": {
    "type": "git",
@@ -23,10 +23,10 @@
      "minHostVersion": ">=2026.5.12-beta.1"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/anthropic/package.json
+++ b/extensions/anthropic/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/anthropic-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw Anthropic provider plugin",
  "type": "module",
--- a/extensions/arcee/npm-shrinkwrap.json
+++ b/extensions/arcee/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/arcee-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/arcee-provider",
-      "version": "2026.6.8"
+      "version": "2026.6.10-alpha.3"
    }
  }
 }
--- a/extensions/arcee/package.json
+++ b/extensions/arcee/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/arcee-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Arcee provider plugin.",
  "repository": {
    "type": "git",
@@ -21,10 +21,10 @@
      "minHostVersion": ">=2026.6.8"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/azure-speech/package.json
+++ b/extensions/azure-speech/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/azure-speech",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw Azure Speech plugin",
  "type": "module",
--- a/extensions/bonjour/package.json
+++ b/extensions/bonjour/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/bonjour",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Bonjour/mDNS gateway discovery",
  "type": "module",
  "dependencies": {
--- a/extensions/brave/npm-shrinkwrap.json
+++ b/extensions/brave/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/brave-plugin",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/brave-plugin",
-      "version": "2026.6.8"
+      "version": "2026.6.10-alpha.3"
    }
  }
 }
--- a/extensions/brave/package.json
+++ b/extensions/brave/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/brave-plugin",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Brave Search provider plugin for web search.",
  "repository": {
    "type": "git",
@@ -21,10 +21,10 @@
      "allowInvalidConfigRecovery": true
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8"
+      "openclawVersion": "2026.6.10-alpha.3"
    },
    "release": {
      "publishToClawHub": true,
--- a/extensions/browser/package.json
+++ b/extensions/browser/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/browser-plugin",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw browser tool plugin",
  "type": "module",
--- a/extensions/byteplus/package.json
+++ b/extensions/byteplus/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/byteplus-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw BytePlus provider plugin",
  "type": "module",
--- a/extensions/canvas/package.json
+++ b/extensions/canvas/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/canvas-plugin",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw Canvas plugin",
  "type": "module",
--- a/extensions/cerebras/npm-shrinkwrap.json
+++ b/extensions/cerebras/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/cerebras-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/cerebras-provider",
-      "version": "2026.6.8"
+      "version": "2026.6.10-alpha.3"
    }
  }
 }
--- a/extensions/cerebras/package.json
+++ b/extensions/cerebras/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/cerebras-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Cerebras provider plugin.",
  "repository": {
    "type": "git",
@@ -21,10 +21,10 @@
      "minHostVersion": ">=2026.6.8"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/chutes/npm-shrinkwrap.json
+++ b/extensions/chutes/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/chutes-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/chutes-provider",
-      "version": "2026.6.8"
+      "version": "2026.6.10-alpha.3"
    }
  }
 }
--- a/extensions/chutes/package.json
+++ b/extensions/chutes/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/chutes-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Chutes.ai provider plugin.",
  "repository": {
    "type": "git",
@@ -21,10 +21,10 @@
      "minHostVersion": ">=2026.6.8"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/clickclack/package.json
+++ b/extensions/clickclack/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/clickclack",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw ClickClack channel plugin",
  "type": "module",
@@ -18,7 +18,7 @@
    "openclaw": "2026.5.28"
  },
  "peerDependencies": {
-    "openclaw": ">=2026.6.8"
+    "openclaw": ">=2026.6.10-alpha.3"
  },
  "peerDependenciesMeta": {
    "openclaw": {
--- a/extensions/cloudflare-ai-gateway/npm-shrinkwrap.json
+++ b/extensions/cloudflare-ai-gateway/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/cloudflare-ai-gateway-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/cloudflare-ai-gateway-provider",
-      "version": "2026.6.8"
+      "version": "2026.6.10-alpha.3"
    }
  }
 }
--- a/extensions/cloudflare-ai-gateway/package.json
+++ b/extensions/cloudflare-ai-gateway/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/cloudflare-ai-gateway-provider",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Cloudflare AI Gateway provider plugin.",
  "repository": {
    "type": "git",
@@ -21,10 +21,10 @@
      "minHostVersion": ">=2026.6.8"
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8",
+      "openclawVersion": "2026.6.10-alpha.3",
      "bundledDist": false
    },
    "release": {
--- a/extensions/codex-supervisor/package.json
+++ b/extensions/codex-supervisor/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/codex-supervisor",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "private": true,
  "description": "OpenClaw Codex app-server fleet supervision plugin.",
  "type": "module",
--- a/extensions/codex/doctor-contract-api.test.ts
+++ b/extensions/codex/doctor-contract-api.test.ts
--- a/extensions/codex/doctor-contract-api.ts
+++ b/extensions/codex/doctor-contract-api.ts
@@ -1,4 +1,7 @@
-/** Doctor contract hooks for Codex config, state migration, and route ownership. */
+/**
+ * Doctor contract hooks for Codex plugin config migrations and session-route
+ * ownership warnings.
+ */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import type { DoctorSessionRouteStateOwner } from "openclaw/plugin-sdk/runtime-doctor";

@@ -48,7 +51,9 @@ export const legacyConfigRules: LegacyConfigRule[] = [
  },
 ];

-/** Removes retired Codex plugin config keys while preserving unrelated config. */
+/**
+ * Removes retired Codex plugin config keys while preserving unrelated config.
+ */
 export function normalizeCompatibilityConfig({ cfg }: { cfg: OpenClawConfig }): {
  config: OpenClawConfig;
  changes: string[];
@@ -66,9 +71,10 @@ export function normalizeCompatibilityConfig({ cfg }: { cfg: OpenClawConfig }):
  const nextConfig = structuredClone(cfg) as OpenClawConfig & {
    plugins?: Record<string, unknown>;
  };
-  const nextPluginConfig = asRecord(
-    asRecord(asRecord(asRecord(nextConfig.plugins)?.entries)?.codex)?.config,
-  );
+  const nextPlugins = asRecord(nextConfig.plugins);
+  const nextEntries = asRecord(nextPlugins?.entries);
+  const nextEntry = asRecord(nextEntries?.codex);
+  const nextPluginConfig = asRecord(nextEntry?.config);
  if (!nextPluginConfig) {
    return { config: cfg, changes: [] };
  }
@@ -115,5 +121,3 @@ export const sessionRouteStateOwners: DoctorSessionRouteStateOwner[] = [
    authProfilePrefixes: ["codex:", "codex-cli:", "openai-codex:"],
  },
 ];
-
-export { stateMigrations } from "./src/migration/session-binding-sidecars.js";
--- a/extensions/codex/harness.test.ts
+++ b/extensions/codex/harness.test.ts
@@ -1,18 +1,9 @@
 // Codex tests cover harness plugin behavior.
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import { describe, expect, it } from "vitest";
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import {
-  createCodexTestBindingStore,
-  testCodexAppServerBindingStore,
-} from "./src/app-server/session-binding.test-helpers.js";

 describe("Codex agent harness supports()", () => {
-  const harness = createCodexAppServerAgentHarness({
-    bindingStore: testCodexAppServerBindingStore,
-  });
+  const harness = createCodexAppServerAgentHarness();

  it("supports the canonical codex virtual provider", () => {
    expect(harness.supports({ provider: "codex", requestedRuntime: "codex" })).toEqual({
@@ -49,149 +40,8 @@ describe("Codex agent harness supports()", () => {
  });

  it("honors explicit provider id overrides", () => {
-    const narrowHarness = createCodexAppServerAgentHarness({
-      bindingStore: testCodexAppServerBindingStore,
-      providerIds: ["codex"],
-    });
+    const narrowHarness = createCodexAppServerAgentHarness({ providerIds: ["codex"] });
    const result = narrowHarness.supports({ provider: "openai", requestedRuntime: "codex" });
    expect(result.supported).toBe(false);
  });
 });
-
-describe("Codex agent harness reset", () => {
-  it("uses the host agent for global session keys", async () => {
-    const bindingStore = createCodexTestBindingStore();
-    const harness = createCodexAppServerAgentHarness({ bindingStore });
-    const identity = {
-      kind: "session" as const,
-      agentId: "work",
-      sessionId: "session-1",
-      sessionKey: "global",
-    };
-    await bindingStore.mutate(identity, {
-      kind: "set",
-      binding: { threadId: "thread-work", cwd: "/repo" },
-    });
-
-    await harness.reset?.({
-      agentId: "work",
-      sessionId: "session-1",
-      sessionKey: "global",
-      reason: "reset",
-    });
-
-    await expect(bindingStore.read(identity)).resolves.toBeUndefined();
-    await expect(
-      bindingStore.mutate(identity, {
-        kind: "set",
-        binding: { threadId: "thread-stale", cwd: "/stale" },
-      }),
-    ).resolves.toBe(false);
-    const nextIdentity = { ...identity, sessionId: "session-2" };
-    await expect(
-      bindingStore.mutate(nextIdentity, {
-        kind: "set",
-        binding: { threadId: "thread-next", cwd: "/next" },
-      }),
-    ).resolves.toBe(false);
-    await expect(
-      bindingStore.mutate(nextIdentity, {
-        kind: "reclaim-generation",
-        expectedPreviousSessionId: identity.sessionId,
-      }),
-    ).resolves.toBe(true);
-    await expect(
-      bindingStore.mutate(nextIdentity, {
-        kind: "set",
-        binding: { threadId: "thread-next", cwd: "/next" },
-      }),
-    ).resolves.toBe(true);
-    await expect(bindingStore.read(nextIdentity)).resolves.toMatchObject({
-      threadId: "thread-next",
-    });
-  });
-
-  it("accepts an absent binding but rejects a mismatched reset generation", async () => {
-    const bindingStore = createCodexTestBindingStore();
-    const harness = createCodexAppServerAgentHarness({ bindingStore });
-    const current = {
-      kind: "session" as const,
-      agentId: "main",
-      sessionId: "session-1",
-      sessionKey: "agent:main:main",
-    };
-
-    await expect(
-      harness.reset?.({
-        agentId: "main",
-        sessionId: "missing-session",
-        sessionKey: "agent:main:missing",
-        reason: "reset",
-      }),
-    ).resolves.toBeUndefined();
-
-    await bindingStore.mutate(current, {
-      kind: "set",
-      binding: { threadId: "thread-1", cwd: "/repo" },
-    });
-    await expect(
-      harness.reset?.({
-        agentId: "main",
-        sessionId: "session-2",
-        sessionKey: current.sessionKey,
-        reason: "reset",
-      }),
-    ).rejects.toThrow("binding generation changed");
-    await expect(bindingStore.read(current)).resolves.toMatchObject({ threadId: "thread-1" });
-  });
-
-  it("reclaims a stale generation left while the Codex plugin was unavailable", async () => {
-    const stateDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-reset-"));
-    const storePath = path.join(stateDir, "sessions.json");
-    const sessionKey = "agent:main:main";
-    await fs.writeFile(
-      storePath,
-      JSON.stringify({
-        [sessionKey]: {
-          sessionId: "session-2",
-          updatedAt: Date.now(),
-        },
-      }),
-      "utf8",
-    );
-    const bindingStore = createCodexTestBindingStore();
-    const harness = createCodexAppServerAgentHarness({
-      bindingStore,
-      resolveConfig: () => ({ session: { store: storePath } }),
-    });
-    const stale = {
-      kind: "session" as const,
-      agentId: "main",
-      sessionId: "session-1",
-      sessionKey,
-    };
-    await bindingStore.mutate(stale, {
-      kind: "set",
-      binding: { threadId: "thread-stale", cwd: "/repo" },
-    });
-
-    await expect(
-      harness.reset?.({
-        agentId: "main",
-        sessionId: "session-2",
-        sessionKey,
-        reason: "reset",
-      }),
-    ).resolves.toBeUndefined();
-
-    const current = { ...stale, sessionId: "session-2" };
-    await expect(bindingStore.read(current)).resolves.toBeUndefined();
-    await expect(
-      bindingStore.mutate(current, {
-        kind: "set",
-        binding: { threadId: "thread-delayed", cwd: "/repo" },
-      }),
-    ).resolves.toBe(false);
-    await fs.rm(stateDir, { recursive: true, force: true });
-  });
-});
--- a/extensions/codex/harness.ts
+++ b/extensions/codex/harness.ts
@@ -7,13 +7,11 @@ import type {
  AgentHarnessCompactResult,
  ContextEngineHostCapability,
 } from "openclaw/plugin-sdk/agent-harness-runtime";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import type {
  CodexAppServerListModelsOptions,
  CodexAppServerModel,
  CodexAppServerModelListResult,
 } from "./src/app-server/models.js";
-import type { CodexAppServerBindingStore } from "./src/app-server/session-binding.js";

 const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = new Set(["codex", "openai"]);
 const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
@@ -39,14 +37,12 @@ type CodexAppServerAgentHarness = AgentHarness & {
 * Creates the Codex app-server harness used for attempts, side questions,
 * compaction, reset, and disposal.
 */
-export function createCodexAppServerAgentHarness(options: {
+export function createCodexAppServerAgentHarness(options?: {
  id?: string;
  label?: string;
  providerIds?: Iterable<string>;
  pluginConfig?: unknown;
  resolvePluginConfig?: () => unknown;
-  resolveConfig?: () => OpenClawConfig | undefined;
-  bindingStore: CodexAppServerBindingStore;
 }): AgentHarness {
  const providerIds = new Set(
    [...(options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS)].map((id) =>
@@ -75,7 +71,6 @@ export function createCodexAppServerAgentHarness(options: {
      // cold provider catalog reads do not pull in the whole Codex runtime.
      const { runCodexAppServerAttempt } = await import("./src/app-server/run-attempt.js");
      return runCodexAppServerAttempt(params, {
-        bindingStore: options.bindingStore,
        pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
        nativeHookRelay: { enabled: true },
      });
@@ -83,7 +78,6 @@ export function createCodexAppServerAgentHarness(options: {
    runSideQuestion: async (params) => {
      const { runCodexAppServerSideQuestion } = await import("./src/app-server/side-question.js");
      return runCodexAppServerSideQuestion(params, {
-        bindingStore: options.bindingStore,
        pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
        nativeHookRelay: { enabled: true },
      });
@@ -91,43 +85,20 @@ export function createCodexAppServerAgentHarness(options: {
    compact: async (params) => {
      const { maybeCompactCodexAppServerSession } = await import("./src/app-server/compact.js");
      return maybeCompactCodexAppServerSession(params, {
-        bindingStore: options.bindingStore,
        pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
      });
    },
    compactAfterContextEngine: async (params) => {
      const { maybeCompactCodexAppServerSession } = await import("./src/app-server/compact.js");
      return maybeCompactCodexAppServerSession(params, {
-        bindingStore: options.bindingStore,
        pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
        allowNonManualNativeRequest: true,
      });
    },
    reset: async (params) => {
-      if (params.sessionId) {
-        const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } =
-          await import("./src/app-server/session-binding.js");
-        const identity = sessionBindingIdentity({
-          agentId: params.agentId,
-          sessionId: params.sessionId,
-          sessionKey: params.sessionKey,
-        });
-        let retired = await options.bindingStore.retireSessionGeneration(identity);
-        if (retired === "conflict") {
-          const reclaimed = await reclaimCurrentCodexSessionGeneration({
-            bindingStore: options.bindingStore,
-            identity,
-            config: options.resolveConfig?.(),
-          });
-          if (reclaimed) {
-            retired = await options.bindingStore.retireSessionGeneration(identity);
-          }
-        }
-        if (retired === "conflict") {
-          throw new Error(
-            `Codex binding generation changed before session ${params.sessionId} could reset`,
-          );
-        }
+      if (params.sessionFile) {
+        const { clearCodexAppServerBinding } = await import("./src/app-server/session-binding.js");
+        await clearCodexAppServerBinding(params.sessionFile);
      }
    },
    dispose: async () => {
--- a/extensions/codex/index.test.ts
+++ b/extensions/codex/index.test.ts
@@ -4,30 +4,10 @@ import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
 import { describe, expect, it, vi } from "vitest";
 import { createCodexAppServerAgentHarness } from "./harness.js";
 import plugin from "./index.js";
-import {
-  createCodexAppServerBindingStore,
-  sessionBindingIdentity,
-} from "./src/app-server/session-binding.js";
-import {
-  createCodexTestBindingStateStore,
-  testCodexAppServerBindingStore,
-} from "./src/app-server/session-binding.test-helpers.js";

 const runCodexAppServerAttemptMock = vi.hoisted(() => vi.fn());
 const runCodexAppServerSideQuestionMock = vi.hoisted(() => vi.fn());

-function createCodexTestRuntime(
-  current?: () => unknown,
-  stateStore = createCodexTestBindingStateStore(),
-) {
-  return {
-    ...(current ? { config: { current } } : {}),
-    state: {
-      openSyncKeyedStore: () => stateStore,
-    },
-  } as never;
-}
-
 vi.mock("./src/app-server/run-attempt.js", () => ({
  runCodexAppServerAttempt: runCodexAppServerAttemptMock,
 }));
@@ -60,6 +40,7 @@ describe("codex plugin", () => {
    const registerProvider = vi.fn();
    const registerWebSearchProvider = vi.fn();
    const on = vi.fn();
+    const onConversationBindingResolved = vi.fn();

    plugin.register(
      createTestPluginApi({
@@ -68,7 +49,7 @@ describe("codex plugin", () => {
        source: "test",
        config: {},
        pluginConfig: {},
-        runtime: createCodexTestRuntime(),
+        runtime: {} as never,
        registerAgentHarness,
        registerCommand,
        registerMediaUnderstandingProvider,
@@ -76,6 +57,7 @@ describe("codex plugin", () => {
        registerProvider,
        registerWebSearchProvider,
        on,
+        onConversationBindingResolved,
      }),
    );

@@ -85,6 +67,9 @@ describe("codex plugin", () => {
      | Record<string, unknown>
      | undefined;
    const inboundClaimRegistration = mockCall(on) as [unknown, unknown] | undefined;
+    const bindingResolvedRegistration = mockCall(onConversationBindingResolved) as
+      | [unknown]
+      | undefined;

    expect(providerRegistration.id).toBe("codex");
    expect(providerRegistration.label).toBe("Codex");
@@ -118,12 +103,33 @@ describe("codex plugin", () => {
    expect(migrationRegistration?.label).toBe("Codex");
    expect(inboundClaimRegistration?.[0]).toBe("inbound_claim");
    expect(typeof inboundClaimRegistration?.[1]).toBe("function");
+    expect(typeof bindingResolvedRegistration?.[0]).toBe("function");
+  });
+
+  it("registers with capture APIs that do not expose conversation binding hooks yet", () => {
+    const registerProvider = vi.fn();
+    const api = createTestPluginApi({
+      id: "codex",
+      name: "Codex",
+      source: "test",
+      config: {},
+      pluginConfig: {},
+      runtime: {} as never,
+      registerAgentHarness: vi.fn(),
+      registerCommand: vi.fn(),
+      registerMediaUnderstandingProvider: vi.fn(),
+      registerProvider,
+      on: vi.fn(),
+    });
+    delete (api as { onConversationBindingResolved?: unknown }).onConversationBindingResolved;
+
+    plugin.register(api);
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+    expect((mockCallArg(registerProvider) as { id?: string } | undefined)?.id).toBe("codex");
  });

  it("claims the Codex routing providers by default", () => {
-    const harness = createCodexAppServerAgentHarness({
-      bindingStore: testCodexAppServerBindingStore,
-    });
+    const harness = createCodexAppServerAgentHarness();

    expect(harness.deliveryDefaults?.sourceVisibleReplies).toBe("message_tool");
    expect(
@@ -144,196 +150,8 @@ describe("codex plugin", () => {
    expect(unsupported.supported).toBe(false);
  });

-  it("clears only ended session binding rows in the owning agent scope", async () => {
-    const stateStore = createCodexTestBindingStateStore();
-    const bindingStore = createCodexAppServerBindingStore(stateStore);
-    const on = vi.fn();
-    plugin.register(
-      createTestPluginApi({
-        id: "codex",
-        name: "Codex",
-        source: "test",
-        config: {},
-        pluginConfig: {},
-        runtime: createCodexTestRuntime(undefined, stateStore),
-        registerAgentHarness: vi.fn(),
-        registerCommand: vi.fn(),
-        registerMediaUnderstandingProvider: vi.fn(),
-        registerMigrationProvider: vi.fn(),
-        registerProvider: vi.fn(),
-        on,
-      }),
-    );
-    const sessionEnd = on.mock.calls.find(([name]) => name === "session_end")?.[1] as
-      | ((
-          event: { sessionId: string; sessionKey?: string; reason?: string },
-          ctx: { agentId?: string; sessionId: string; sessionKey?: string },
-        ) => Promise<void>)
-      | undefined;
-    if (!sessionEnd) {
-      throw new Error("missing Codex session_end hook");
-    }
-    const identity = sessionBindingIdentity({
-      agentId: "worker",
-      sessionId: "session-1",
-      sessionKey: "agent:worker:session-1",
-    });
-    const setBinding = () =>
-      bindingStore.mutate(identity, {
-        kind: "set",
-        binding: { threadId: "thread-1", cwd: "/repo" },
-      });
-
-    for (const reason of ["shutdown", "restart", "compaction", "unknown"] as const) {
-      await setBinding();
-      await sessionEnd(
-        { sessionId: "session-1", sessionKey: "agent:worker:session-1", reason },
-        { agentId: "worker", sessionId: "session-1" },
-      );
-      await expect(bindingStore.read(identity)).resolves.toMatchObject({
-        threadId: "thread-1",
-      });
-    }
-    for (const reason of ["new", "reset", "idle", "daily", "deleted"] as const) {
-      await setBinding();
-      await sessionEnd(
-        { sessionId: "session-1", sessionKey: "agent:worker:session-1", reason },
-        { agentId: "worker", sessionId: "session-1" },
-      );
-      await expect(bindingStore.read(identity)).resolves.toBeUndefined();
-    }
-  });
-
-  it("adopts compaction successors before delayed lifecycle cleanup", async () => {
-    const stateStore = createCodexTestBindingStateStore();
-    const bindingStore = createCodexAppServerBindingStore(stateStore);
-    const on = vi.fn();
-    plugin.register(
-      createTestPluginApi({
-        id: "codex",
-        name: "Codex",
-        source: "test",
-        config: {},
-        pluginConfig: {},
-        runtime: createCodexTestRuntime(undefined, stateStore),
-        registerAgentHarness: vi.fn(),
-        registerCommand: vi.fn(),
-        registerMediaUnderstandingProvider: vi.fn(),
-        registerMigrationProvider: vi.fn(),
-        registerProvider: vi.fn(),
-        on,
-      }),
-    );
-    const afterCompaction = on.mock.calls.find(([name]) => name === "after_compaction")?.[1] as
-      | ((
-          event: {
-            messageCount: number;
-            compactedCount: number;
-            previousSessionId?: string;
-          },
-          ctx: { agentId?: string; sessionId?: string; sessionKey?: string },
-        ) => Promise<void>)
-      | undefined;
-    const sessionEnd = on.mock.calls.find(([name]) => name === "session_end")?.[1] as
-      | ((
-          event: { sessionId: string; sessionKey?: string; reason?: string },
-          ctx: { agentId?: string; sessionId: string; sessionKey?: string },
-        ) => Promise<void>)
-      | undefined;
-    if (!afterCompaction || !sessionEnd) {
-      throw new Error("missing Codex compaction lifecycle hooks");
-    }
-    const sessionKey = "agent:worker:telegram:chat-1";
-    const previous = sessionBindingIdentity({
-      agentId: "worker",
-      sessionId: "session-1",
-      sessionKey,
-    });
-    const successor = sessionBindingIdentity({
-      agentId: "worker",
-      sessionId: "session-2",
-      sessionKey,
-    });
-    const newest = sessionBindingIdentity({
-      agentId: "worker",
-      sessionId: "session-3",
-      sessionKey,
-    });
-    await bindingStore.mutate(previous, {
-      kind: "set",
-      binding: { threadId: "thread-1", cwd: "/repo" },
-    });
-
-    await afterCompaction(
-      { messageCount: 1, compactedCount: 1, previousSessionId: "session-1" },
-      { agentId: "worker", sessionId: "session-2", sessionKey },
-    );
-    await expect(bindingStore.read(previous)).resolves.toBeUndefined();
-    await expect(bindingStore.read(successor)).resolves.toMatchObject({ threadId: "thread-1" });
-
-    await afterCompaction(
-      { messageCount: 1, compactedCount: 1, previousSessionId: "session-2" },
-      { agentId: "worker", sessionId: "session-3", sessionKey },
-    );
-    await afterCompaction(
-      { messageCount: 1, compactedCount: 1, previousSessionId: "session-1" },
-      { agentId: "worker", sessionId: "session-2", sessionKey },
-    );
-    await expect(bindingStore.read(successor)).resolves.toBeUndefined();
-    await expect(bindingStore.read(newest)).resolves.toMatchObject({ threadId: "thread-1" });
-
-    await sessionEnd(
-      { sessionId: "session-1", sessionKey, reason: "reset" },
-      { agentId: "worker", sessionId: "session-1", sessionKey },
-    );
-    await sessionEnd(
-      { sessionId: "session-2", sessionKey, reason: "compaction" },
-      { agentId: "worker", sessionId: "session-2", sessionKey },
-    );
-    await expect(bindingStore.read(newest)).resolves.toMatchObject({ threadId: "thread-1" });
-    expect(stateStore.entries()).toHaveLength(1);
-  });
-
-  it("ignores compaction for a session without a Codex binding", async () => {
-    const warn = vi.fn();
-    const on = vi.fn();
-    plugin.register(
-      createTestPluginApi({
-        id: "codex",
-        name: "Codex",
-        source: "test",
-        config: {},
-        pluginConfig: {},
-        logger: { debug: vi.fn(), info: vi.fn(), warn, error: vi.fn() },
-        runtime: createCodexTestRuntime(),
-        registerAgentHarness: vi.fn(),
-        registerCommand: vi.fn(),
-        registerMediaUnderstandingProvider: vi.fn(),
-        registerMigrationProvider: vi.fn(),
-        registerProvider: vi.fn(),
-        on,
-      }),
-    );
-    const afterCompaction = on.mock.calls.find(([name]) => name === "after_compaction")?.[1] as
-      | ((event: object, ctx: { sessionId?: string; sessionKey?: string }) => Promise<void>)
-      | undefined;
-    if (!afterCompaction) {
-      throw new Error("missing Codex after_compaction hook");
-    }
-
-    await afterCompaction(
-      { previousSessionId: "session-1" },
-      { sessionId: "session-2", sessionKey: "agent:main:main" },
-    );
-
-    expect(warn).not.toHaveBeenCalled();
-  });
-
  it("enables the native hook relay for public Codex app-server attempts", async () => {
-    const harness = createCodexAppServerAgentHarness({
-      bindingStore: testCodexAppServerBindingStore,
-      pluginConfig: { appServer: {} },
-    });
+    const harness = createCodexAppServerAgentHarness({ pluginConfig: { appServer: {} } });
    const result = { success: true };
    runCodexAppServerAttemptMock.mockResolvedValueOnce(result);

@@ -342,7 +160,6 @@ describe("codex plugin", () => {
    expect(runCodexAppServerAttemptMock).toHaveBeenCalledWith(
      { prompt: "hello" },
      {
-        bindingStore: testCodexAppServerBindingStore,
        pluginConfig: { appServer: {} },
        nativeHookRelay: { enabled: true },
      },
@@ -377,7 +194,11 @@ describe("codex plugin", () => {
        source: "test",
        config: {},
        pluginConfig: { codexPlugins: { enabled: false } },
-        runtime: createCodexTestRuntime(() => liveConfig),
+        runtime: {
+          config: {
+            current: () => liveConfig,
+          },
+        } as never,
        registerAgentHarness,
        registerCommand: vi.fn(),
        registerMediaUnderstandingProvider: vi.fn(),
@@ -397,49 +218,14 @@ describe("codex plugin", () => {
    expect(runCodexAppServerAttemptMock).toHaveBeenCalledWith(
      { prompt: "calendar" },
      {
-        bindingStore: expect.any(Object),
        pluginConfig: liveConfig.plugins.entries.codex.config,
        nativeHookRelay: { enabled: true },
      },
    );
  });

-  it("does not resurrect startup Codex config after the live entry is removed", async () => {
-    const registerAgentHarness = vi.fn();
-    plugin.register(
-      createTestPluginApi({
-        id: "codex",
-        name: "Codex",
-        source: "test",
-        config: {},
-        pluginConfig: { appServer: { mode: "yolo" } },
-        runtime: createCodexTestRuntime(() => ({ plugins: { entries: {} } })),
-        registerAgentHarness,
-        registerCommand: vi.fn(),
-        registerMediaUnderstandingProvider: vi.fn(),
-        registerMigrationProvider: vi.fn(),
-        registerProvider: vi.fn(),
-        on: vi.fn(),
-      }),
-    );
-    const harness = mockCallArg(registerAgentHarness) as ReturnType<
-      typeof createCodexAppServerAgentHarness
-    >;
-    runCodexAppServerAttemptMock.mockResolvedValueOnce({ success: true });
-
-    await harness.runAttempt({ prompt: "default policy" } as never);
-
-    expect(runCodexAppServerAttemptMock).toHaveBeenCalledWith(
-      { prompt: "default policy" },
-      expect.objectContaining({ pluginConfig: undefined }),
-    );
-  });
-
  it("enables the native hook relay for public Codex side questions", async () => {
-    const harness = createCodexAppServerAgentHarness({
-      bindingStore: testCodexAppServerBindingStore,
-      pluginConfig: { appServer: {} },
-    });
+    const harness = createCodexAppServerAgentHarness({ pluginConfig: { appServer: {} } });
    const runSideQuestion = harness["runSideQuestion"];
    const result = { text: "ok" };
    runCodexAppServerSideQuestionMock.mockResolvedValueOnce(result);
@@ -452,7 +238,6 @@ describe("codex plugin", () => {
    expect(runCodexAppServerSideQuestionMock).toHaveBeenCalledWith(
      { question: "btw" },
      {
-        bindingStore: testCodexAppServerBindingStore,
        pluginConfig: { appServer: {} },
        nativeHookRelay: { enabled: true },
      },
--- a/extensions/codex/index.ts
+++ b/extensions/codex/index.ts
@@ -4,72 +4,48 @@
 */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
-import {
-  resolveLivePluginConfigObject,
-  resolvePluginConfigObject,
-} from "openclaw/plugin-sdk/plugin-config-runtime";
+import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { createCodexAppServerAgentHarness } from "./harness.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import { buildCodexProvider } from "./provider.js";
-import {
-  CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
-  CODEX_APP_SERVER_BINDING_NAMESPACE,
-  createLazyCodexAppServerBindingStore,
-  type StoredCodexAppServerBinding,
-} from "./src/app-server/session-binding-store.js";
 import type { CodexPluginsConfigBlock } from "./src/command-plugins-management.js";
 import { createCodexCommand } from "./src/commands.js";
+import {
+  handleCodexConversationBindingResolved,
+  handleCodexConversationInboundClaim,
+} from "./src/conversation-binding.js";
 import { buildCodexMigrationProvider } from "./src/migration/provider.js";
 import {
  createCodexCliSessionNodeHostCommands,
  createCodexCliSessionNodeInvokePolicies,
-} from "./src/node-cli-session-registration.js";
+  listCodexCliSessionsOnNode,
+  resumeCodexCliSessionOnNode,
+  resolveCodexCliSessionForBindingOnNode,
+} from "./src/node-cli-sessions.js";
 import { createCodexWebSearchProvider } from "./src/web-search-provider.js";

-const ENDED_SESSION_REASONS: ReadonlySet<string> = new Set([
-  "new",
-  "reset",
-  "idle",
-  "daily",
-  "deleted",
-]);
-
 export default definePluginEntry({
  id: "codex",
  name: "Codex",
  description: "Codex app-server harness and Codex-managed GPT model catalog.",
  register(api) {
-    const runtimeConfigLoader = api.runtime.config?.current
-      ? () => api.runtime.config?.current() as OpenClawConfig
-      : undefined;
-    const resolveCurrentConfig = () => runtimeConfigLoader?.();
-    const loadNodeCliSessions = () => import("./src/node-cli-sessions.js");
+    const resolveCurrentConfig = () =>
+      api.runtime.config?.current ? (api.runtime.config.current() as OpenClawConfig) : undefined;
    const resolveCurrentPluginConfig = () =>
      // Codex plugin config can change at runtime; resolve from live config for
      // harness attempts and binding claims instead of keeping startup values.
      resolveLivePluginConfigObject(
-        runtimeConfigLoader,
+        resolveCurrentConfig,
        "codex",
        api.pluginConfig as Record<string, unknown>,
-      );
-    const bindingStore = createLazyCodexAppServerBindingStore(
-      api.runtime.state.openSyncKeyedStore<StoredCodexAppServerBinding>({
-        namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
-        maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
-        overflowPolicy: "reject-new",
-      }),
-    );
+      ) ?? api.pluginConfig;
    api.registerAgentHarness(
-      createCodexAppServerAgentHarness({
-        bindingStore,
-        resolveConfig: resolveCurrentConfig,
-        resolvePluginConfig: resolveCurrentPluginConfig,
-      }),
+      createCodexAppServerAgentHarness({ resolvePluginConfig: resolveCurrentPluginConfig }),
    );
    api.registerProvider(buildCodexProvider({ pluginConfig: api.pluginConfig }));
    api.registerMediaUnderstandingProvider(
-      buildCodexMediaUnderstandingProvider({ resolvePluginConfig: resolveCurrentPluginConfig }),
+      buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }),
    );
    api.registerWebSearchProvider(
      createCodexWebSearchProvider({ resolvePluginConfig: resolveCurrentPluginConfig }),
@@ -83,43 +59,43 @@ export default definePluginEntry({
    }
    api.registerCommand(
      createCodexCommand({
-        resolvePluginConfig: resolveCurrentPluginConfig,
+        pluginConfig: api.pluginConfig,
        deps: {
-          bindingStore,
-          listCodexCliSessionsOnNode: async (params) =>
-            await (
-              await loadNodeCliSessions()
-            ).listCodexCliSessionsOnNode({
-              runtime: api.runtime,
-              ...params,
-            }),
-          resolveCodexCliSessionForBindingOnNode: async (params) =>
-            await (
-              await loadNodeCliSessions()
-            ).resolveCodexCliSessionForBindingOnNode({
-              runtime: api.runtime,
-              ...params,
-            }),
+          listCodexCliSessionsOnNode: (params) =>
+            listCodexCliSessionsOnNode({ runtime: api.runtime, ...params }),
+          resolveCodexCliSessionForBindingOnNode: (params) =>
+            resolveCodexCliSessionForBindingOnNode({ runtime: api.runtime, ...params }),
          codexPluginsManagementIo: {
            readConfig: () => {
              const current = (api.runtime.config?.current?.() ?? {}) as OpenClawConfig;
-              const codexPlugins = resolvePluginConfigObject(current, "codex")?.codexPlugins;
-              if (
-                !codexPlugins ||
-                typeof codexPlugins !== "object" ||
-                Array.isArray(codexPlugins)
-              ) {
+              const plugins = (current as Record<string, unknown>).plugins;
+              if (!plugins || typeof plugins !== "object") {
                return Promise.resolve({});
              }
-              const block = codexPlugins as Record<string, unknown>;
-              const declared = block.plugins;
+              const entries = (plugins as Record<string, unknown>).entries;
+              if (!entries || typeof entries !== "object") {
+                return Promise.resolve({});
+              }
+              const codexEntry = (entries as Record<string, unknown>).codex;
+              if (!codexEntry || typeof codexEntry !== "object") {
+                return Promise.resolve({});
+              }
+              const config = (codexEntry as Record<string, unknown>).config;
+              if (!config || typeof config !== "object") {
+                return Promise.resolve({});
+              }
+              const codexPlugins = (config as Record<string, unknown>).codexPlugins;
+              if (!codexPlugins || typeof codexPlugins !== "object") {
+                return Promise.resolve({});
+              }
+              const declared = (codexPlugins as Record<string, unknown>).plugins;
              if (!declared || typeof declared !== "object") {
                return Promise.resolve({
-                  enabled: block.enabled === true,
+                  enabled: (codexPlugins as Record<string, unknown>).enabled === true,
                });
              }
              return Promise.resolve({
-                enabled: block.enabled === true,
+                enabled: (codexPlugins as Record<string, unknown>).enabled === true,
                plugins: declared as Record<string, never>,
              });
            },
@@ -129,12 +105,17 @@ export default definePluginEntry({
                  // Create the nested plugin config path on demand so codex
                  // plugin commands can enable/update Codex-managed plugins.
                  const root = draft as Record<string, unknown>;
-                  const pluginsBlock = (root.plugins ??= {}) as Record<string, unknown>;
-                  const entries = (pluginsBlock.entries ??= {}) as Record<string, unknown>;
-                  const codexEntry = (entries.codex ??= {}) as Record<string, unknown>;
-                  const config = (codexEntry.config ??= {}) as Record<string, unknown>;
-                  const codexPlugins = (config.codexPlugins ??= {}) as Record<string, unknown>;
-                  codexPlugins.plugins ??= {};
+                  root.plugins = (root.plugins ?? {}) as Record<string, unknown>;
+                  const pluginsBlock = root.plugins as Record<string, unknown>;
+                  pluginsBlock.entries = (pluginsBlock.entries ?? {}) as Record<string, unknown>;
+                  const entries = pluginsBlock.entries as Record<string, unknown>;
+                  entries.codex = (entries.codex ?? {}) as Record<string, unknown>;
+                  const codexEntry = entries.codex as Record<string, unknown>;
+                  codexEntry.config = (codexEntry.config ?? {}) as Record<string, unknown>;
+                  const config = codexEntry.config as Record<string, unknown>;
+                  config.codexPlugins = (config.codexPlugins ?? {}) as Record<string, unknown>;
+                  const codexPlugins = config.codexPlugins as Record<string, unknown>;
+                  codexPlugins.plugins = (codexPlugins.plugins ?? {}) as Record<string, unknown>;
                  update(codexPlugins as CodexPluginsConfigBlock);
                },
              });
@@ -143,58 +124,14 @@ export default definePluginEntry({
        },
      }),
    );
-    api.on("inbound_claim", async (event, ctx) => {
-      const { handleCodexConversationInboundClaim } = await import("./src/conversation-binding.js");
-      return await handleCodexConversationInboundClaim(event, ctx, {
-        bindingStore,
+    api.on("inbound_claim", (event, ctx) =>
+      handleCodexConversationInboundClaim(event, ctx, {
        pluginConfig: resolveCurrentPluginConfig(),
        config: resolveCurrentConfig(),
-        resumeCodexCliSessionOnNode: async (params) =>
-          await (
-            await loadNodeCliSessions()
-          ).resumeCodexCliSessionOnNode({
-            runtime: api.runtime,
-            ...params,
-          }),
-      });
-    });
-    api.on("after_compaction", async (event, ctx) => {
-      const previousSessionId = event.previousSessionId?.trim();
-      const sessionId = ctx.sessionId?.trim();
-      if (!previousSessionId || !sessionId || previousSessionId === sessionId) {
-        return;
-      }
-      const config = resolveCurrentConfig();
-      const sessionKey = ctx.sessionKey?.trim();
-      const { sessionBindingIdentity } = await import("./src/app-server/session-binding.js");
-      const identity = sessionBindingIdentity({
-        sessionId,
-        ...(sessionKey ? { sessionKey } : {}),
-        ...(ctx.agentId ? { agentId: ctx.agentId } : {}),
-        ...(config ? { config } : {}),
-      });
-      const adopted = await bindingStore.adoptSessionGeneration(identity, previousSessionId);
-      if (adopted === "conflict") {
-        api.logger.warn?.(
-          `codex: could not adopt compacted session generation ${sessionId} (${adopted}); secondary native compaction will skip`,
-        );
-      }
-    });
-    api.on("session_end", async (event, ctx) => {
-      if (!event.reason || !ENDED_SESSION_REASONS.has(event.reason)) {
-        return;
-      }
-      const sessionKey = event.sessionKey ?? ctx.sessionKey;
-      const config = resolveCurrentConfig();
-      const { sessionBindingIdentity } = await import("./src/app-server/session-binding.js");
-      await bindingStore.retireSessionGeneration(
-        sessionBindingIdentity({
-          sessionId: event.sessionId,
-          ...(sessionKey ? { sessionKey } : {}),
-          ...(ctx.agentId ? { agentId: ctx.agentId } : {}),
-          ...(config ? { config } : {}),
-        }),
-      );
-    });
+        resumeCodexCliSessionOnNode: (params) =>
+          resumeCodexCliSessionOnNode({ runtime: api.runtime, ...params }),
+      }),
+    );
+    api.onConversationBindingResolved?.(handleCodexConversationBindingResolved);
  },
 });
--- a/extensions/codex/media-understanding-provider.test.ts
+++ b/extensions/codex/media-understanding-provider.test.ts
@@ -2,25 +2,8 @@
 import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
-import { CodexAppServerRpcError, type CodexAppServerClient } from "./src/app-server/client.js";
+import type { CodexAppServerClient } from "./src/app-server/client.js";
 import type { CodexServerNotification, JsonValue } from "./src/app-server/protocol.js";
-import { adaptCodexTestClientFactory } from "./src/app-server/test-support.js";
-
-const EXPECTED_MEDIA_THREAD_CONFIG = {
-  project_doc_max_bytes: 0,
-  web_search: "disabled",
-  "tools.experimental_request_user_input.enabled": false,
-  "features.hooks": false,
-  "features.multi_agent": false,
-  "features.apps": false,
-  "features.plugins": false,
-  "features.image_generation": false,
-  "features.skill_mcp_dependency_install": false,
-  "features.memories": false,
-  "features.goals": false,
-  "features.code_mode": false,
-  "features.code_mode_only": false,
-};

 const sharedClientMocks = vi.hoisted(() => ({
  createIsolatedCodexAppServerClient: vi.fn(),
@@ -102,15 +85,13 @@ function createFakeClient(options?: {
  inputModalities?: string[];
  completeWithItems?: boolean;
  notifyError?: string;
+  approvalRequestMethod?: string;
  responseText?: string;
-  turnStartError?: Error;
-  preBindNotificationCount?: number;
-  interruptError?: Error;
-  unsubscribeError?: Error;
 }) {
  const notifications = new Set<(notification: CodexServerNotification) => void>();
-  const closeHandlers = new Set<() => void>();
+  const requestHandlers = new Set<(request: { method: string }) => JsonValue | undefined>();
  const requests: Array<{ method: string; params?: JsonValue }> = [];
+  const approvalResponses: JsonValue[] = [];
  const request = vi.fn(async (method: string, params?: JsonValue) => {
    requests.push({ method, params });
    if (method === "model/list") {
@@ -123,60 +104,51 @@ function createFakeClient(options?: {
      return threadStartResult();
    }
    if (method === "turn/start") {
-      if (options?.turnStartError) {
-        throw options.turnStartError;
-      }
-      if (options?.preBindNotificationCount) {
-        for (let index = 0; index < options.preBindNotificationCount; index += 1) {
-          for (const notify of notifications) {
-            notify({
-              method: "item/started",
-              params: { threadId: "thread-1", turnId: "turn-1" },
-            });
+      if (options?.approvalRequestMethod) {
+        for (const handler of requestHandlers) {
+          const response = handler({ method: options.approvalRequestMethod });
+          if (response !== undefined) {
+            approvalResponses.push(response);
          }
        }
-        return turnStartResult();
      }
-      const emitTurnNotifications = () => {
-        if (options?.notifyError) {
-          for (const notify of notifications) {
-            notify({
-              method: "error",
-              params: {
-                threadId: "thread-1",
-                turnId: "turn-1",
-                error: {
-                  message: options.notifyError,
-                  codexErrorInfo: null,
-                  additionalDetails: null,
-                },
-                willRetry: false,
+      if (options?.notifyError) {
+        for (const notify of notifications) {
+          notify({
+            method: "error",
+            params: {
+              threadId: "thread-1",
+              turnId: "turn-1",
+              error: {
+                message: options.notifyError,
+                codexErrorInfo: null,
+                additionalDetails: null,
              },
-            });
-          }
-        } else if (!options?.completeWithItems) {
-          for (const notify of notifications) {
-            notify({
-              method: "item/agentMessage/delta",
-              params: {
-                threadId: "thread-1",
-                turnId: "turn-1",
-                itemId: "msg-1",
-                delta: options?.responseText ?? "A red square.",
-              },
-            });
-            notify({
-              method: "turn/completed",
-              params: {
-                threadId: "thread-1",
-                turnId: "turn-1",
-                turn: turnStartResult("completed").turn,
-              },
-            });
-          }
+              willRetry: false,
+            },
+          });
        }
-      };
-      emitTurnNotifications();
+      } else if (!options?.completeWithItems) {
+        for (const notify of notifications) {
+          notify({
+            method: "item/agentMessage/delta",
+            params: {
+              threadId: "thread-1",
+              turnId: "turn-1",
+              itemId: "msg-1",
+              delta: options?.responseText ?? "A red square.",
+            },
+          });
+          notify({
+            method: "turn/completed",
+            params: {
+              threadId: "thread-1",
+              turnId: "turn-1",
+              turn: turnStartResult("completed").turn,
+            },
+          });
+        }
+      }
      return turnStartResult(
        options?.completeWithItems ? "completed" : "inProgress",
        options?.completeWithItems
@@ -192,12 +164,6 @@ function createFakeClient(options?: {
          : [],
      );
    }
-    if (method === "turn/interrupt" && options?.interruptError) {
-      throw options.interruptError;
-    }
-    if (method === "thread/unsubscribe" && options?.unsubscribeError) {
-      throw options.unsubscribeError;
-    }
    return {};
  });

@@ -207,17 +173,14 @@ function createFakeClient(options?: {
      notifications.add(handler);
      return () => notifications.delete(handler);
    },
-    addRequestHandler() {
-      return () => undefined;
-    },
-    addCloseHandler(handler: () => void) {
-      closeHandlers.add(handler);
-      return () => closeHandlers.delete(handler);
+    addRequestHandler(handler: (request: { method: string }) => JsonValue | undefined) {
+      requestHandlers.add(handler);
+      return () => requestHandlers.delete(handler);
    },
    close: vi.fn(),
  } as unknown as CodexAppServerClient;

-  return { client, requests };
+  return { client, requests, approvalResponses };
 }

 describe("codex media understanding provider", () => {
@@ -229,9 +192,11 @@ describe("codex media understanding provider", () => {

  it("runs image understanding through a bounded Codex app-server turn", async () => {
    const { client, requests } = createFakeClient();
-    const clientFactory = vi.fn(async () => client);
+    const clientFactory = vi.fn(
+      async (_startOptions, _authProfileId, _agentDir, _config) => client,
+    );
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(clientFactory),
+      clientFactory,
    });
    const cfg = {
      auth: {
@@ -254,33 +219,42 @@ describe("codex media understanding provider", () => {
    });

    expect(result).toEqual({ text: "A red square.", model: "gpt-5.4" });
+    expect(requests.map((entry) => entry.method)).toEqual([
+      "model/list",
+      "thread/start",
+      "turn/start",
+    ]);
    expect(clientFactory).toHaveBeenCalledWith(
      expect.any(Object),
      undefined,
      "/tmp/openclaw-agent",
      cfg,
-      expect.objectContaining({ timeoutMs: 30_000 }),
+      { timeoutMs: 30_000 },
    );
-    expect(requests.map((entry) => entry.method)).toEqual([
-      "model/list",
-      "thread/start",
-      "turn/start",
-      "thread/unsubscribe",
-    ]);
-    expect(requests[0]?.params).toEqual({ limit: 100, cursor: null, includeHidden: true });
    expect(requests[1]?.params).toEqual({
      model: "gpt-5.4",
      modelProvider: "openai",
-      cwd: "/tmp/openclaw-agent/codex-media-home",
-      approvalPolicy: "never",
+      cwd: "/tmp/openclaw-agent",
+      approvalPolicy: "on-request",
      sandbox: "read-only",
      serviceName: "OpenClaw",
-      personality: "none",
      developerInstructions:
        "You are OpenClaw's bounded image-understanding worker. Describe only the provided image content. Do not call tools, edit files, or ask follow-up questions.",
-      config: EXPECTED_MEDIA_THREAD_CONFIG,
+      config: {
+        "features.apps": false,
+        "features.code_mode": false,
+        "features.code_mode_only": false,
+        "features.image_generation": false,
+        "features.multi_agent": false,
+        "features.plugins": false,
+        "features.standalone_web_search": false,
+        web_search: "disabled",
+      },
      environments: [],
+      dynamicTools: [],
+      experimentalRawEvents: true,
      ephemeral: true,
+      persistExtendedHistory: false,
    });
    expect(requests[2]?.params).toEqual({
      threadId: "thread-1",
@@ -288,6 +262,9 @@ describe("codex media understanding provider", () => {
        { type: "text", text: "Describe briefly.", text_elements: [] },
        { type: "image", url: "data:image/png;base64,aW1hZ2UtYnl0ZXM=" },
      ],
+      cwd: "/tmp/openclaw-agent",
+      approvalPolicy: "on-request",
+      model: "gpt-5.4",
      effort: "low",
    });
  });
@@ -295,12 +272,8 @@ describe("codex media understanding provider", () => {
  it("treats a blank agent directory as absent when starting the app-server", async () => {
    const { client, requests } = createFakeClient();
    const clientFactory = vi.fn(async () => client);
-    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(clientFactory),
-    });
-    const cfg = {
-      agents: { list: [{ id: "main", agentDir: "/tmp/openclaw-default-agent" }] },
-    };
+    const provider = buildCodexMediaUnderstandingProvider({ clientFactory });
+    const cfg = {};

    await provider.describeImage?.({
      buffer: Buffer.from("image-bytes"),
@@ -313,16 +286,11 @@ describe("codex media understanding provider", () => {
      agentDir: " ",
    });

-    expect(clientFactory).toHaveBeenCalledWith(
-      expect.any(Object),
-      undefined,
-      "/tmp/openclaw-default-agent",
-      cfg,
-      expect.any(Object),
-    );
-    expect(requests[1]?.params).toEqual(
-      expect.objectContaining({ cwd: "/tmp/openclaw-default-agent/codex-media-home" }),
-    );
+    expect(clientFactory).toHaveBeenCalledWith(expect.any(Object), undefined, undefined, cfg, {
+      timeoutMs: 30_000,
+    });
+    expect(requests[1]?.params).toEqual(expect.objectContaining({ cwd: process.cwd() }));
+    expect(requests[2]?.params).toEqual(expect.objectContaining({ cwd: process.cwd() }));
  });

  it("preserves configured WebSocket transport for media turns", async () => {
@@ -402,7 +370,7 @@ describe("codex media understanding provider", () => {
    try {
      const { client } = createFakeClient();
      const provider = buildCodexMediaUnderstandingProvider({
-        clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+        clientFactory: async () => client,
      });

      const result = await provider.describeImage?.({
@@ -425,97 +393,33 @@ describe("codex media understanding provider", () => {
    }
  });

-  it("starts the media deadline before client acquisition", async () => {
-    vi.useFakeTimers();
+  it("declines approval requests during image understanding", async () => {
+    const { client, approvalResponses } = createFakeClient({
+      approvalRequestMethod: "item/permissions/requestApproval",
+    });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(
-        async () => await new Promise<CodexAppServerClient>(() => {}),
-      ),
+      clientFactory: async () => client,
    });
-    const description = provider.describeImage?.({
-      buffer: Buffer.from("image-bytes"),
-      fileName: "image.png",
-      mime: "image/png",
-      provider: "codex",
-      model: "gpt-5.4",
-      timeoutMs: 100,
-      cfg: {},
-      agentDir: "/tmp/openclaw-agent",
-    });
-    const rejected = expect(description).rejects.toThrow(
-      "Codex app-server image understanding timed out",
-    );
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    await rejected;
-  });
-
-  it("retires a media client lease that resolves after its deadline", async () => {
-    let resolveLease!: (lease: {
-      client: CodexAppServerClient;
-      release: () => void;
-      abandon: () => Promise<void>;
-    }) => void;
-    const pendingLease = new Promise<{
-      client: CodexAppServerClient;
-      release: () => void;
-      abandon: () => Promise<void>;
-    }>((resolve) => {
-      resolveLease = resolve;
-    });
-    const clientLeaseFactory = vi.fn(async () => await pendingLease);
-    const provider = buildCodexMediaUnderstandingProvider({ clientLeaseFactory });
-    const description = provider.describeImage?.({
-      buffer: Buffer.from("image-bytes"),
-      fileName: "image.png",
-      mime: "image/png",
-      provider: "codex",
-      model: "gpt-5.4",
-      timeoutMs: 5,
-      cfg: {},
-      agentDir: "/tmp/openclaw-agent",
-    });
-
-    await expect(description).rejects.toThrow("Codex app-server image understanding timed out");
-    const { client } = createFakeClient();
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    resolveLease({ client, release, abandon });
-    await vi.waitFor(() => expect(abandon).toHaveBeenCalledOnce());
-
-    expect(release).not.toHaveBeenCalled();
-  });
-
-  it("releases the bounded route between isolated media calls", async () => {
-    const { client, requests } = createFakeClient();
-    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
-    });
-    const request = {
+
+    await provider.describeImage?.({
      buffer: Buffer.from("image-bytes"),
      fileName: "image.png",
      mime: "image/png",
      provider: "codex",
      model: "gpt-5.4",
+      prompt: "Describe briefly.",
      timeoutMs: 30_000,
      cfg: {},
      agentDir: "/tmp/openclaw-agent",
-    };
+    });

-    const first = await provider.describeImage?.(request);
-    const second = await provider.describeImage?.(request);
-
-    expect(first?.text).toBe("A red square.");
-    expect(second?.text).toBe("A red square.");
-    expect(requests.filter((entry) => entry.method === "model/list")).toHaveLength(2);
-    expect(requests.filter((entry) => entry.method === "thread/start")).toHaveLength(2);
+    expect(approvalResponses).toEqual([{ permissions: {}, scope: "turn" }]);
  });

  it("extracts text from terminal turn items", async () => {
    const { client } = createFakeClient({ completeWithItems: true });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    const result = await provider.describeImages?.({
@@ -534,7 +438,7 @@ describe("codex media understanding provider", () => {
  it("rejects text-only Codex app-server models before starting a turn", async () => {
    const { client, requests } = createFakeClient({ inputModalities: ["text"] });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    await expect(
@@ -555,7 +459,7 @@ describe("codex media understanding provider", () => {
  it("surfaces Codex app-server turn errors", async () => {
    const { client } = createFakeClient({ notifyError: "vision unavailable" });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    await expect(
@@ -572,107 +476,12 @@ describe("codex media understanding provider", () => {
    ).rejects.toThrow("vision unavailable");
  });

-  it.each([
-    {
-      name: "structured rejection",
-      error: new CodexAppServerRpcError({ message: "turn rejected" }, "turn/start"),
-      abandonCount: 0,
-    },
-    {
-      name: "ambiguous timeout",
-      error: new Error("turn/start timed out"),
-      abandonCount: 1,
-    },
-  ])("handles $name with exact media lease ownership", async ({ error, abandonCount }) => {
-    const { client } = createFakeClient({ turnStartError: error });
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: async () => ({ client, release, abandon }),
-    });
-
-    await expect(
-      provider.describeImage?.({
-        buffer: Buffer.from("image-bytes"),
-        fileName: "image.png",
-        mime: "image/png",
-        provider: "codex",
-        model: "gpt-5.4",
-        timeoutMs: 30_000,
-        cfg: {},
-        agentDir: "/tmp/openclaw-agent",
-      }),
-    ).rejects.toBe(error);
-
-    expect(abandon).toHaveBeenCalledTimes(abandonCount);
-    expect(release).toHaveBeenCalledTimes(1);
-  });
-
-  it("retires the media client when thread cleanup is unconfirmed", async () => {
-    const { client } = createFakeClient({ unsubscribeError: new Error("unsubscribe failed") });
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: async () => ({ client, release, abandon }),
-    });
-
-    await expect(
-      provider.describeImage?.({
-        buffer: Buffer.from("image-bytes"),
-        fileName: "image.png",
-        mime: "image/png",
-        provider: "codex",
-        model: "gpt-5.4",
-        timeoutMs: 30_000,
-        cfg: {},
-        agentDir: "/tmp/openclaw-agent",
-      }),
-    ).resolves.toEqual({ text: "A red square.", model: "gpt-5.4" });
-
-    expect(abandon).toHaveBeenCalledOnce();
-    expect(release).not.toHaveBeenCalled();
-  });
-
-  it("retires the media client when an accepted turn cannot be interrupted", async () => {
-    const { client, requests } = createFakeClient({
-      preBindNotificationCount: 257,
-      interruptError: new Error("interrupt timeout"),
-    });
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: async () => ({ client, release, abandon }),
-    });
-
-    await expect(
-      provider.describeImage?.({
-        buffer: Buffer.from("image-bytes"),
-        fileName: "image.png",
-        mime: "image/png",
-        provider: "codex",
-        model: "gpt-5.4",
-        timeoutMs: 30_000,
-        cfg: {},
-        agentDir: "/tmp/openclaw-agent",
-      }),
-    ).rejects.toThrow("pre-bind notification buffer exceeded 256 entries");
-
-    expect(requests.map((entry) => entry.method)).toEqual([
-      "model/list",
-      "thread/start",
-      "turn/start",
-      "turn/interrupt",
-    ]);
-    expect(abandon).toHaveBeenCalledOnce();
-    expect(release).not.toHaveBeenCalled();
-  });
-
  it("runs structured extraction through the same bounded Codex app-server path", async () => {
    const { client, requests } = createFakeClient({
      responseText: '{"summary":"red square","tags":["shape"]}',
    });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    const result = await provider.extractStructured?.({
@@ -713,21 +522,31 @@ describe("codex media understanding provider", () => {
      "model/list",
      "thread/start",
      "turn/start",
-      "thread/unsubscribe",
    ]);
    expect(requests[1]?.params).toEqual({
      model: "gpt-5.4",
      modelProvider: "openai",
-      cwd: "/tmp/openclaw-agent/codex-media-home",
-      approvalPolicy: "never",
+      cwd: "/tmp/openclaw-agent",
+      approvalPolicy: "on-request",
      sandbox: "read-only",
      serviceName: "OpenClaw",
-      personality: "none",
      developerInstructions:
        "You are OpenClaw's bounded structured-extraction worker. Return only the requested extraction. Do not call tools, edit files, ask follow-up questions, or include secrets.",
-      config: EXPECTED_MEDIA_THREAD_CONFIG,
+      config: {
+        "features.apps": false,
+        "features.code_mode": false,
+        "features.code_mode_only": false,
+        "features.image_generation": false,
+        "features.multi_agent": false,
+        "features.plugins": false,
+        "features.standalone_web_search": false,
+        web_search: "disabled",
+      },
      environments: [],
+      dynamicTools: [],
+      experimentalRawEvents: true,
      ephemeral: true,
+      persistExtendedHistory: false,
    });
    const turnParams = requests[2]?.params as
      | {
@@ -740,9 +559,9 @@ describe("codex media understanding provider", () => {
        }
      | undefined;
    expect(turnParams?.threadId).toBe("thread-1");
-    expect(turnParams?.approvalPolicy).toBeUndefined();
-    expect(turnParams?.model).toBeUndefined();
-    expect(turnParams?.cwd).toBeUndefined();
+    expect(turnParams?.approvalPolicy).toBe("on-request");
+    expect(turnParams?.model).toBe("gpt-5.4");
+    expect(turnParams?.cwd).toBe("/tmp/openclaw-agent");
    expect(turnParams?.effort).toBe("low");
    expect(turnParams?.input).toHaveLength(3);
    expect(turnParams?.input?.[0]?.type).toBe("text");
@@ -765,7 +584,7 @@ describe("codex media understanding provider", () => {
      responseText: '{"summary":"only text"}',
    });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    await expect(
@@ -785,7 +604,7 @@ describe("codex media understanding provider", () => {
  it("returns a controlled error when structured JSON parsing fails", async () => {
    const { client } = createFakeClient({ responseText: "not json" });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    await expect(
@@ -814,7 +633,7 @@ describe("codex media understanding provider", () => {
      responseText: '{"summary":123,"tags":["shape"]}',
    });
    const provider = buildCodexMediaUnderstandingProvider({
-      clientLeaseFactory: adaptCodexTestClientFactory(async () => client),
+      clientFactory: async () => client,
    });

    await expect(
--- a/extensions/codex/media-understanding-provider.ts
+++ b/extensions/codex/media-understanding-provider.ts
@@ -1,35 +1,216 @@
-/** Lazy registration facade for Codex-backed media understanding. */
-import type { MediaUnderstandingProvider } from "openclaw/plugin-sdk/media-understanding";
+/**
+ * Codex-backed media understanding provider for bounded image description and
+ * structured extraction turns.
+ */
+import {
+  type JsonSchemaObject,
+  validateJsonSchemaValue,
+} from "openclaw/plugin-sdk/json-schema-runtime";
+import type {
+  ImagesDescriptionRequest,
+  ImagesDescriptionResult,
+  MediaUnderstandingProvider,
+  StructuredExtractionRequest,
+  StructuredExtractionResult,
+} from "openclaw/plugin-sdk/media-understanding";
 import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
-import type { CodexAppServerClientLeaseFactory } from "./src/app-server/shared-client.js";
+import {
+  runBoundedCodexAppServerTurn,
+  type CodexBoundedTurnOptions,
+} from "./src/app-server/bounded-turn.js";
+import type { CodexUserInput } from "./src/app-server/protocol.js";

 const DEFAULT_CODEX_IMAGE_MODEL =
  FALLBACK_CODEX_MODELS.find((model) => model.inputModalities.includes("image"))?.id ??
  FALLBACK_CODEX_MODELS[0]?.id;
+const DEFAULT_CODEX_IMAGE_PROMPT = "Describe the image.";

-/** Dependencies and plugin config for Codex media-understanding calls. */
-export type CodexMediaUnderstandingProviderOptions = {
-  pluginConfig?: unknown;
-  resolvePluginConfig?: () => unknown;
-  clientLeaseFactory?: CodexAppServerClientLeaseFactory;
-};
+export type CodexMediaUnderstandingProviderOptions = CodexBoundedTurnOptions;

-/** Builds a provider whose app-server implementation loads on first use. */
+/**
+ * Builds the media-understanding provider that delegates image tasks to an
+ * isolated Codex app-server session.
+ */
 export function buildCodexMediaUnderstandingProvider(
  options: CodexMediaUnderstandingProviderOptions = {},
 ): MediaUnderstandingProvider {
-  let runtime: Promise<typeof import("./src/media-understanding-provider.runtime.js")> | undefined;
-  const load = () => (runtime ??= import("./src/media-understanding-provider.runtime.js"));
  return {
    id: CODEX_PROVIDER_ID,
    capabilities: ["image"],
    ...(DEFAULT_CODEX_IMAGE_MODEL ? { defaultModels: { image: DEFAULT_CODEX_IMAGE_MODEL } } : {}),
-    describeImage: async ({ buffer, fileName, mime, ...request }) =>
-      await (
-        await load()
-      ).describeCodexImages({ ...request, images: [{ buffer, fileName, mime }] }, options),
-    describeImages: async (request) => await (await load()).describeCodexImages(request, options),
-    extractStructured: async (request) =>
-      await (await load()).extractCodexStructured(request, options),
+    describeImage: async (req) =>
+      describeCodexImages(
+        {
+          images: [
+            {
+              buffer: req.buffer,
+              fileName: req.fileName,
+              mime: req.mime,
+            },
+          ],
+          provider: req.provider,
+          model: req.model,
+          prompt: req.prompt,
+          maxTokens: req.maxTokens,
+          timeoutMs: req.timeoutMs,
+          profile: req.profile,
+          preferredProfile: req.preferredProfile,
+          authStore: req.authStore,
+          agentDir: req.agentDir,
+          cfg: req.cfg,
+        },
+        options,
+      ),
+    describeImages: async (req) => describeCodexImages(req, options),
+    extractStructured: async (req) => extractCodexStructured(req, options),
  };
 }
+
+async function describeCodexImages(
+  req: ImagesDescriptionRequest,
+  options: CodexMediaUnderstandingProviderOptions,
+): Promise<ImagesDescriptionResult> {
+  const model = req.model.trim();
+  if (!model) {
+    throw new Error("Codex image understanding requires model id.");
+  }
+
+  const { text } = await runBoundedCodexAppServerTurn({
+    config: req.cfg,
+    model: { mode: "required", id: model },
+    profile: req.profile,
+    timeoutMs: req.timeoutMs,
+    agentDir: req.agentDir,
+    authProfileStore: req.authStore,
+    options,
+    taskLabel: "image understanding",
+    developerInstructions:
+      "You are OpenClaw's bounded image-understanding worker. Describe only the provided image content. Do not call tools, edit files, or ask follow-up questions.",
+    input: [
+      { type: "text", text: buildCodexImagePrompt(req), text_elements: [] },
+      ...req.images.map((image) => ({
+        type: "image" as const,
+        url: `data:${image.mime ?? "image/png"};base64,${image.buffer.toString("base64")}`,
+      })),
+    ],
+    requiredModalities: ["text", "image"],
+    isolation: "configured-transport",
+  });
+  return { text, model };
+}
+
+async function extractCodexStructured(
+  req: StructuredExtractionRequest,
+  options: CodexMediaUnderstandingProviderOptions,
+): Promise<StructuredExtractionResult> {
+  const model = req.model.trim();
+  if (!model) {
+    throw new Error("Codex structured extraction requires model id.");
+  }
+  const instructions = req.instructions.trim();
+  if (!instructions) {
+    throw new Error("Codex structured extraction requires instructions.");
+  }
+  if (req.input.length === 0) {
+    throw new Error("Codex structured extraction requires at least one input.");
+  }
+  if (!req.input.some((entry) => entry.type === "image")) {
+    throw new Error("Codex structured extraction requires at least one image input.");
+  }
+
+  const { text } = await runBoundedCodexAppServerTurn({
+    config: req.cfg,
+    model: { mode: "required", id: model },
+    profile: req.profile,
+    timeoutMs: req.timeoutMs,
+    agentDir: req.agentDir,
+    authProfileStore: req.authStore,
+    options,
+    taskLabel: "structured extraction",
+    developerInstructions:
+      "You are OpenClaw's bounded structured-extraction worker. Return only the requested extraction. Do not call tools, edit files, ask follow-up questions, or include secrets.",
+    input: buildCodexStructuredInput(req),
+    requiredModalities: requiredStructuredModalities(),
+    isolation: "configured-transport",
+  });
+  return normalizeStructuredExtractionResult({ text, model, provider: req.provider, req });
+}
+
+function buildCodexImagePrompt(req: ImagesDescriptionRequest): string {
+  const prompt = req.prompt?.trim() || DEFAULT_CODEX_IMAGE_PROMPT;
+  if (req.images.length <= 1) {
+    return prompt;
+  }
+  return `${prompt}\n\nAnalyze all ${req.images.length} images together.`;
+}
+
+function requiredStructuredModalities(): string[] {
+  return ["text", "image"];
+}
+
+function buildCodexStructuredInput(req: StructuredExtractionRequest): CodexUserInput[] {
+  return [
+    { type: "text", text: buildStructuredExtractionPrompt(req), text_elements: [] },
+    ...req.input.map((entry) => {
+      if (entry.type === "text") {
+        return { type: "text" as const, text: entry.text, text_elements: [] };
+      }
+      return {
+        type: "image" as const,
+        url: `data:${entry.mime ?? "image/png"};base64,${entry.buffer.toString("base64")}`,
+      };
+    }),
+  ];
+}
+
+function buildStructuredExtractionPrompt(req: StructuredExtractionRequest): string {
+  return [
+    req.instructions.trim(),
+    req.schemaName ? `Schema name: ${req.schemaName}` : undefined,
+    req.jsonSchema ? `JSON schema:\n${JSON.stringify(req.jsonSchema)}` : undefined,
+    req.jsonMode === false
+      ? "Return the extraction as concise text."
+      : "Return valid JSON only. Do not wrap the JSON in Markdown fences.",
+  ]
+    .filter((part): part is string => Boolean(part))
+    .join("\n\n");
+}
+
+function isJsonSchemaObject(value: unknown): value is JsonSchemaObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeStructuredExtractionResult(params: {
+  text: string;
+  model: string;
+  provider: string;
+  req: StructuredExtractionRequest;
+}): StructuredExtractionResult {
+  const result: StructuredExtractionResult = {
+    text: params.text,
+    model: params.model,
+    provider: params.provider,
+    contentType: params.req.jsonMode === false ? "text" : "json",
+  };
+  if (params.req.jsonMode !== false) {
+    try {
+      result.parsed = JSON.parse(params.text);
+    } catch {
+      throw new Error("Codex structured extraction returned invalid JSON.");
+    }
+    if (isJsonSchemaObject(params.req.jsonSchema)) {
+      const validation = validateJsonSchemaValue({
+        schema: params.req.jsonSchema,
+        cacheKey: "codex.media-understanding.extractStructured",
+        value: result.parsed,
+        cache: false,
+      });
+      if (!validation.ok) {
+        const message = validation.errors.map((error) => error.text).join("; ") || "invalid";
+        throw new Error(`Codex structured extraction JSON did not match schema: ${message}`);
+      }
+      result.parsed = validation.value;
+    }
+  }
+  return result;
+}
--- a/extensions/codex/npm-shrinkwrap.json
+++ b/extensions/codex/npm-shrinkwrap.json
@@ -1,12 +1,12 @@
 {
  "name": "@openclaw/codex",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@openclaw/codex",
-      "version": "2026.6.8",
+      "version": "2026.6.10-alpha.3",
      "dependencies": {
        "@openai/codex": "0.139.0",
        "typebox": "1.1.39",
--- a/extensions/codex/package.json
+++ b/extensions/codex/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@openclaw/codex",
-  "version": "2026.6.8",
+  "version": "2026.6.10-alpha.3",
  "description": "OpenClaw Codex app-server harness and model provider plugin with a Codex-managed GPT catalog.",
  "repository": {
    "type": "git",
@@ -34,10 +34,10 @@
      ]
    },
    "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.10-alpha.3"
    },
    "build": {
-      "openclawVersion": "2026.6.8"
+      "openclawVersion": "2026.6.10-alpha.3"
    },
    "release": {
      "publishToClawHub": true,
--- a/extensions/codex/provider.test.ts
+++ b/extensions/codex/provider.test.ts
@@ -4,10 +4,10 @@ import { CODEX_GPT5_BEHAVIOR_CONTRACT } from "./prompt-overlay.js";
 import { codexProviderDiscovery } from "./provider-discovery.js";
 import { buildCodexProvider, buildCodexProviderCatalog } from "./provider.js";
 import { CodexAppServerClient } from "./src/app-server/client.js";
-import type { listAllCodexAppServerModels } from "./src/app-server/models.js";
+import type { listCodexAppServerModels } from "./src/app-server/models.js";
 import {
  createIsolatedCodexAppServerClient,
-  leaseSharedCodexAppServerClient,
+  getSharedCodexAppServerClient,
  resetSharedCodexAppServerClientForTests,
 } from "./src/app-server/shared-client.js";

@@ -26,8 +26,7 @@ function createFakeCodexClient(): CodexAppServerClient {
  return {
    initialize: vi.fn(async () => undefined),
    request: vi.fn(async () => ({ data: [] })),
-    addNotificationHandler: vi.fn(() => () => undefined),
-    addRequestHandler: vi.fn(() => () => undefined),
+    setActiveSharedLeaseCountProviderForUnscopedNotifications: vi.fn(),
    addCloseHandler: vi.fn(() => () => undefined),
    close: vi.fn(),
  } as unknown as CodexAppServerClient;
@@ -40,7 +39,7 @@ const TEST_CODEX_APP_SERVER_CONFIG = {
 };

 async function listTestCodexAppServerModels(
-  options: Parameters<typeof listAllCodexAppServerModels>[0] = {},
+  options: Parameters<typeof listCodexAppServerModels>[0] = {},
 ) {
  expect(options.sharedClient).toBe(false);
  const client = await createIsolatedCodexAppServerClient({
@@ -184,33 +183,45 @@ describe("codex provider", () => {
    expect(resultProvider?.models.map((model) => model.id)).toEqual(["gpt-5.4"]);
  });

-  it("delegates all-page discovery to one model lister call", async () => {
-    const listModels = vi.fn(async () => ({
-      models: [
-        {
-          id: "gpt-5.4",
-          model: "gpt-5.4",
-          hidden: false,
-          inputModalities: ["text", "image"],
-          supportedReasoningEfforts: ["medium"],
-        },
-        {
-          id: "gpt-5.5",
-          model: "gpt-5.5",
-          hidden: false,
-          inputModalities: ["text"],
-          supportedReasoningEfforts: [],
-        },
-      ],
-    }));
+  it("pages through live discovery before building the provider catalog", async () => {
+    const listModels = vi
+      .fn()
+      .mockResolvedValueOnce({
+        models: [
+          {
+            id: "gpt-5.4",
+            model: "gpt-5.4",
+            hidden: false,
+            inputModalities: ["text", "image"],
+            supportedReasoningEfforts: ["medium"],
+          },
+        ],
+        nextCursor: "page-2",
+      })
+      .mockResolvedValueOnce({
+        models: [
+          {
+            id: "gpt-5.5",
+            model: "gpt-5.5",
+            hidden: false,
+            inputModalities: ["text"],
+            supportedReasoningEfforts: [],
+          },
+        ],
+      });

    const result = await buildCodexProviderCatalog({
      env: {},
      listModels,
    });

-    expect(listModels).toHaveBeenCalledTimes(1);
    expectRecordFields(mockCallArg(listModels, 0), {
+      cursor: undefined,
+      limit: 100,
+      sharedClient: false,
+    });
+    expectRecordFields(mockCallArg(listModels, 1), {
+      cursor: "page-2",
      limit: 100,
      sharedClient: false,
    });
@@ -266,7 +277,7 @@ describe("codex provider", () => {
      .mockReturnValueOnce(activeClient)
      .mockReturnValueOnce(discoveryClient);

-    await leaseSharedCodexAppServerClient({
+    await getSharedCodexAppServerClient({
      startOptions: {
        transport: "stdio",
        command: "/tmp/openclaw-test-codex",
--- a/extensions/codex/provider.ts
+++ b/extensions/codex/provider.ts
@@ -18,11 +18,16 @@ import {
  CODEX_PROVIDER_ID,
  FALLBACK_CODEX_MODELS,
 } from "./provider-catalog.js";
-import type { CodexAppServerStartOptions } from "./src/app-server/config.js";
+import {
+  type CodexAppServerStartOptions,
+  readCodexPluginConfig,
+  resolveCodexAppServerRuntimeOptions,
+} from "./src/app-server/config.js";
 import type {
  CodexAppServerModel,
  CodexAppServerModelListResult,
 } from "./src/app-server/models.js";
+import { buildCodexAppServerUsageSnapshot } from "./src/app-server/rate-limits.js";

 const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
 const LIVE_DISCOVERY_ENV = "OPENCLAW_CODEX_DISCOVERY_LIVE";
@@ -34,6 +39,7 @@ const codexCatalogLog = createSubsystemLogger("codex/catalog");
 type CodexModelLister = (options: {
  timeoutMs: number;
  limit?: number;
+  cursor?: string;
  startOptions?: CodexAppServerStartOptions;
  sharedClient?: boolean;
 }) => Promise<CodexAppServerModelListResult>;
@@ -117,11 +123,6 @@ export function buildCodexProvider(options: BuildCodexProviderOptions = {}): Pro
      }
      const runtimePluginConfig = resolvePluginConfigObject(ctx.config, CODEX_PROVIDER_ID);
      const pluginConfig = runtimePluginConfig ?? (ctx.config ? undefined : options.pluginConfig);
-      const [{ resolveCodexAppServerRuntimeOptions }, { buildCodexAppServerUsageSnapshot }] =
-        await Promise.all([
-          import("./src/app-server/config.js"),
-          import("./src/app-server/rate-limits.js"),
-        ]);
      const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
      const rateLimits = await (options.readRateLimits ?? requestCodexAppServerRateLimitsLazy)({
        timeoutMs: ctx.timeoutMs,
@@ -155,15 +156,13 @@ export function buildCodexProvider(options: BuildCodexProviderOptions = {}): Pro
 export async function buildCodexProviderCatalog(
  options: BuildCatalogOptions = {},
 ): Promise<{ provider: ModelProviderConfig }> {
-  const { readCodexPluginConfig, resolveCodexAppServerRuntimeOptions } =
-    await import("./src/app-server/config.js");
  const config = readCodexPluginConfig(options.pluginConfig);
  const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
  const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
  let discovered: CodexAppServerModel[] = [];
  if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) {
    discovered = await listModelsBestEffort({
-      listModels: options.listModels ?? listAllCodexAppServerModelsLazy,
+      listModels: options.listModels ?? listCodexAppServerModelsLazy,
      timeoutMs,
      startOptions: appServer.start,
      onDiscoveryFailure: options.onDiscoveryFailure,
@@ -201,14 +200,22 @@ async function listModelsBestEffort(params: {
  onDiscoveryFailure?: (error: unknown) => void;
 }): Promise<CodexAppServerModel[]> {
  try {
-    // The all-pages helper keeps one app-server client alive across pagination.
-    const result = await params.listModels({
-      timeoutMs: params.timeoutMs,
-      limit: MODEL_DISCOVERY_PAGE_LIMIT,
-      startOptions: params.startOptions,
-      sharedClient: false,
-    });
-    return result.models.filter((model) => !model.hidden);
+    const models: CodexAppServerModel[] = [];
+    let cursor: string | undefined;
+    do {
+      // App-server model listing is paginated; collect every visible model so
+      // aliases and picker rows match the current Codex account.
+      const result = await params.listModels({
+        timeoutMs: params.timeoutMs,
+        limit: MODEL_DISCOVERY_PAGE_LIMIT,
+        cursor,
+        startOptions: params.startOptions,
+        sharedClient: false,
+      });
+      models.push(...result.models.filter((model) => !model.hidden));
+      cursor = result.nextCursor;
+    } while (cursor);
+    return models;
  } catch (error) {
    params.onDiscoveryFailure?.(error);
    codexCatalogLog.debug("codex model discovery failed; using fallback catalog", {
@@ -218,14 +225,15 @@ async function listModelsBestEffort(params: {
  }
 }

-async function listAllCodexAppServerModelsLazy(options: {
+async function listCodexAppServerModelsLazy(options: {
  timeoutMs: number;
  limit?: number;
+  cursor?: string;
  startOptions?: CodexAppServerStartOptions;
  sharedClient?: boolean;
 }): Promise<CodexAppServerModelListResult> {
-  const { listAllCodexAppServerModels } = await import("./src/app-server/models.js");
-  return listAllCodexAppServerModels(options);
+  const { listCodexAppServerModels } = await import("./src/app-server/models.js");
+  return listCodexAppServerModels(options);
 }

 async function requestCodexAppServerRateLimitsLazy(options: {
--- a/extensions/codex/src/app-server/app-server-policy.test.ts
+++ b/extensions/codex/src/app-server/app-server-policy.test.ts
@@ -1,6 +1,9 @@
 // Codex tests cover app server policy plugin behavior.
 import { describe, expect, it } from "vitest";
-import { resolveCodexAppServerForOpenClawToolPolicy } from "./app-server-policy.js";
+import {
+  resolveCodexAppServerForModelProvider,
+  resolveCodexAppServerForOpenClawToolPolicy,
+} from "./app-server-policy.js";
 import { readCodexPluginConfig, resolveCodexAppServerRuntimeOptions } from "./config.js";

 describe("Codex app-server policy", () => {
@@ -66,4 +69,143 @@ describe("Codex app-server policy", () => {
    expect(explicitEnv.approvalPolicy).toBe("never");
    expect(explicitRequirements.approvalPolicy).toBe("never");
  });
+
+  it("keeps model-backed reviewers for explicit OpenAI model providers", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      execMode: "auto",
+      modelProvider: "openai",
+    });
+
+    expect(
+      resolveCodexAppServerForModelProvider({
+        appServer,
+        provider: "codex",
+        model: "openai/gpt-5.5",
+      }).approvalsReviewer,
+    ).toBe("auto_review");
+    expect(
+      resolveCodexAppServerForModelProvider({
+        appServer,
+        provider: "codex",
+        model: "gpt-5.5",
+      }).approvalsReviewer,
+    ).toBe("user");
+    expect(
+      resolveCodexAppServerForModelProvider({ appServer, provider: "openai" }).approvalsReviewer,
+    ).toBe("auto_review");
+  });
+
+  it("uses human approval for OpenAI-compatible custom endpoints", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      execMode: "auto",
+      modelProvider: "openai",
+      model: "gpt-5.5",
+      config: {
+        models: {
+          providers: {
+            openai: {
+              baseUrl: "http://localhost:8080/v1",
+              models: [],
+            },
+          },
+        },
+      },
+    });
+
+    expect(appServer.approvalsReviewer).toBe("user");
+    expect(
+      resolveCodexAppServerForModelProvider({
+        appServer,
+        provider: "openai",
+        model: "gpt-5.5",
+        config: {
+          models: {
+            providers: {
+              openai: {
+                baseUrl: "http://localhost:8080/v1",
+                models: [],
+              },
+            },
+          },
+        },
+      }).approvalsReviewer,
+    ).toBe("user");
+  });
+
+  it("uses human approval instead of Codex Guardian for custom model providers", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      execMode: "auto",
+      modelProvider: "openai",
+    });
+
+    const resolved = resolveCodexAppServerForModelProvider({
+      appServer,
+      provider: "lmstudio",
+    });
+    const vendorPrefixedModel = resolveCodexAppServerForModelProvider({
+      appServer,
+      provider: "openrouter",
+      model: "openai/gpt-5.5",
+    });
+
+    expect(appServer.approvalsReviewer).toBe("auto_review");
+    expect(resolved.approvalPolicy).toBe("on-request");
+    expect(resolved.sandbox).toBe("workspace-write");
+    expect(resolved.approvalsReviewer).toBe("user");
+    expect(vendorPrefixedModel.approvalsReviewer).toBe("user");
+  });
+
+  it("infers custom providers from provider-qualified model refs", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      execMode: "auto",
+    });
+
+    expect(
+      resolveCodexAppServerForModelProvider({
+        appServer,
+        model: "lmstudio/local-model",
+      }).approvalsReviewer,
+    ).toBe("user");
+  });
+
+  it("uses provider-qualified model refs to override broad native provider wrappers", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      execMode: "auto",
+    });
+
+    expect(
+      resolveCodexAppServerForModelProvider({
+        appServer,
+        provider: "codex",
+        model: "lmstudio/local-model",
+      }).approvalsReviewer,
+    ).toBe("user");
+  });
+
+  it("downgrades legacy guardian_subagent for custom model providers", () => {
+    const appServer = resolveCodexAppServerRuntimeOptions({
+      env: {},
+      requirementsToml: null,
+      pluginConfig: {
+        appServer: {
+          mode: "guardian",
+          approvalsReviewer: "guardian_subagent",
+        },
+      },
+    });
+
+    expect(
+      resolveCodexAppServerForModelProvider({ appServer, provider: "local" }).approvalsReviewer,
+    ).toBe("user");
+  });
 });
--- a/extensions/codex/src/app-server/app-server-policy.ts
+++ b/extensions/codex/src/app-server/app-server-policy.ts
@@ -2,10 +2,11 @@
 * Policy promotion for Codex app-server runs that can safely use OpenClaw tool
 * approvals.
 */
-import type {
-  CodexAppServerRuntimeOptions,
-  CodexPluginConfig,
-  OpenClawExecPolicyForCodexAppServer,
+import {
+  canUseCodexModelBackedApprovalsReviewerForModel,
+  type CodexAppServerRuntimeOptions,
+  type CodexPluginConfig,
+  type OpenClawExecPolicyForCodexAppServer,
 } from "./config.js";

 /**
@@ -44,6 +45,35 @@ export function resolveCodexAppServerForOpenClawToolPolicy(params: {
  };
 }

+export function resolveCodexAppServerForModelProvider(params: {
+  appServer: CodexAppServerRuntimeOptions;
+  provider?: string;
+  model?: string;
+  config?: Parameters<typeof canUseCodexModelBackedApprovalsReviewerForModel>[0]["config"];
+  env?: NodeJS.ProcessEnv;
+  agentDir?: string;
+  codexConfigToml?: string | null;
+}): CodexAppServerRuntimeOptions {
+  const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);
+  if (
+    !isCodexModelBackedApprovalsReviewer(params.appServer.approvalsReviewer) ||
+    canUseCodexModelBackedApprovalsReviewerForModel({
+      modelProvider: explicitProvider,
+      model: params.model,
+      config: params.config,
+      env: params.env,
+      agentDir: params.agentDir,
+      codexConfigToml: params.codexConfigToml,
+    })
+  ) {
+    return params.appServer;
+  }
+  return {
+    ...params.appServer,
+    approvalsReviewer: "user",
+  };
+}
+
 function isCodexAppServerPolicyMode(value: unknown): boolean {
  return value === "guardian" || value === "yolo";
 }
@@ -53,3 +83,12 @@ function isCodexAppServerApprovalPolicy(value: unknown): boolean {
    value === "never" || value === "on-request" || value === "on-failure" || value === "untrusted"
  );
 }
+
+function isCodexModelBackedApprovalsReviewer(value: string): boolean {
+  return value === "auto_review" || value === "guardian_subagent";
+}
+
+function normalizeModelBackedReviewerProvider(provider: string | undefined): string | undefined {
+  const normalized = provider?.trim().toLowerCase();
+  return normalized || undefined;
+}
--- a/extensions/codex/src/app-server/approval-bridge.ts
+++ b/extensions/codex/src/app-server/approval-bridge.ts
@@ -285,7 +285,8 @@ function matchesCurrentTurn(
  if (!requestParams) {
    return false;
  }
-  const requestThreadId = readString(requestParams, "threadId");
+  const requestThreadId =
+    readString(requestParams, "threadId") ?? readString(requestParams, "conversationId");
  const requestTurnId = readString(requestParams, "turnId");
  return requestThreadId === threadId && requestTurnId === turnId;
 }
--- a/extensions/codex/src/app-server/attempt-client-cleanup.test.ts
+++ b/extensions/codex/src/app-server/attempt-client-cleanup.test.ts
@@ -2,41 +2,10 @@
 import { describe, expect, it, vi } from "vitest";
 import {
  interruptCodexTurnBestEffort,
-  runCodexTurnStartWithLease,
-  settleCodexAppServerClientLease,
  unsubscribeCodexThreadBestEffort,
-  validateCodexThreadCreationResponse,
 } from "./attempt-client-cleanup.js";
-import { CodexAppServerRpcError } from "./client.js";

 describe("Codex app-server attempt client cleanup", () => {
-  it("keeps the client lease after a structured turn-start rejection", async () => {
-    const abandon = vi.fn(async () => undefined);
-    const error = new CodexAppServerRpcError({ message: "turn rejected" }, "turn/start");
-
-    await expect(
-      runCodexTurnStartWithLease({ abandon } as never, async () => {
-        throw error;
-      }),
-    ).rejects.toBe(error);
-
-    expect(abandon).not.toHaveBeenCalled();
-  });
-
-  it("abandons only the exact client lease after an ambiguous turn-start timeout", async () => {
-    const abandon = vi.fn(async () => undefined);
-    const otherAbandon = vi.fn(async () => undefined);
-
-    await expect(
-      runCodexTurnStartWithLease({ abandon } as never, async () => {
-        throw new Error("turn/start timed out");
-      }),
-    ).rejects.toThrow("turn/start timed out");
-
-    expect(abandon).toHaveBeenCalledTimes(1);
-    expect(otherAbandon).not.toHaveBeenCalled();
-  });
-
  it("interrupts turns with optional request timeout", () => {
    const request = vi.fn(async () => ({}));

@@ -53,58 +22,7 @@ describe("Codex app-server attempt client cleanup", () => {
    );
  });

-  it("unsubscribes a retained thread when its create response is malformed", async () => {
-    const request = vi.fn(async () => ({}));
-    const abandon = vi.fn(async () => undefined);
-    const invalidResponse = { thread: { id: "thread-1" } };
-
-    await expect(
-      validateCodexThreadCreationResponse(
-        { client: { request } as never, abandon },
-        invalidResponse,
-        () => {
-          throw new Error("invalid thread/start response");
-        },
-      ),
-    ).rejects.toThrow("invalid thread/start response");
-
-    expect(request).toHaveBeenCalledWith(
-      "thread/unsubscribe",
-      { threadId: "thread-1" },
-      { timeoutMs: 5_000 },
-    );
-    expect(abandon).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ["omits the retained thread id", {}, vi.fn(async () => ({}))],
-    [
-      "cannot confirm unsubscribe",
-      { thread: { id: "thread-1" } },
-      vi.fn(async () => {
-        throw new Error("connection lost");
-      }),
-    ],
-  ])(
-    "retires the client when a malformed create response %s",
-    async (_label, response, request) => {
-      const abandon = vi.fn(async () => undefined);
-
-      await expect(
-        validateCodexThreadCreationResponse(
-          { client: { request } as never, abandon },
-          response,
-          () => {
-            throw new Error("invalid thread/start response");
-          },
-        ),
-      ).rejects.toThrow("subscription could not be released");
-
-      expect(abandon).toHaveBeenCalledOnce();
-    },
-  );
-
-  it("reports unsubscribe cleanup failures", async () => {
+  it("swallows unsubscribe cleanup failures", async () => {
    const request = vi.fn(async () => {
      throw new Error("already gone");
    });
@@ -114,7 +32,7 @@ describe("Codex app-server attempt client cleanup", () => {
        threadId: "thread-1",
        timeoutMs: 123,
      }),
-    ).resolves.toBe(false);
+    ).resolves.toBeUndefined();

    expect(request).toHaveBeenCalledWith(
      "thread/unsubscribe",
@@ -122,31 +40,4 @@ describe("Codex app-server attempt client cleanup", () => {
      { timeoutMs: 123 },
    );
  });
-
-  it("returns leases only after thread cleanup is confirmed", async () => {
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    await settleCodexAppServerClientLease(
-      { client: { request: vi.fn(async () => ({})) }, release, abandon } as never,
-      { threadId: "thread-ok", timeoutMs: 123 },
-    );
-    expect(release).toHaveBeenCalledOnce();
-    expect(abandon).not.toHaveBeenCalled();
-
-    release.mockClear();
-    await settleCodexAppServerClientLease(
-      {
-        client: {
-          request: vi.fn(async () => {
-            throw new Error("unsubscribe failed");
-          }),
-        },
-        release,
-        abandon,
-      } as never,
-      { threadId: "thread-stale", timeoutMs: 123 },
-    );
-    expect(release).not.toHaveBeenCalled();
-    expect(abandon).toHaveBeenCalledOnce();
-  });
 });
--- a/extensions/codex/src/app-server/attempt-client-cleanup.ts
+++ b/extensions/codex/src/app-server/attempt-client-cleanup.ts
@@ -2,124 +2,60 @@
 * Best-effort cleanup helpers for Codex app-server startup attempts and turns.
 */
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { CodexAppServerRpcError, type CodexAppServerClient } from "./client.js";
-import { isJsonObject, readCodexThreadCreationResponseId } from "./protocol.js";
-import type { CodexAppServerClientLease } from "./shared-client.js";
+import type { CodexAppServerClient } from "./client.js";
+import {
+  clearSharedCodexAppServerClientIfCurrent,
+  clearSharedCodexAppServerClientIfCurrentAndUnclaimed,
+  retireSharedCodexAppServerClientIfCurrent,
+} from "./shared-client.js";

 /** Timeout for best-effort app-server turn interruption during cleanup. */
 export const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5_000;
 /** Timeout for best-effort thread unsubscribe during cleanup. */
 export const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5_000;

-/** The connection's thread-subscription ownership can no longer be proven. */
-export class CodexAppServerUnsafeSubscriptionError extends Error {
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = "CodexAppServerUnsafeSubscriptionError";
+async function closeClientAndWaitIfAvailable(client: CodexAppServerClient): Promise<void> {
+  const closeable = client as {
+    close?: CodexAppServerClient["close"];
+    closeAndWait?: CodexAppServerClient["closeAndWait"];
+  };
+  if (typeof closeable.closeAndWait === "function") {
+    await closeable.closeAndWait();
+    return;
  }
+  closeable.close?.();
 }

-export function isCodexAppServerUnsafeSubscriptionError(
-  error: unknown,
-): error is CodexAppServerUnsafeSubscriptionError {
-  return error instanceof CodexAppServerUnsafeSubscriptionError;
-}
-
-/** A resume response may only describe the thread this connection retained. */
-export function assertCodexThreadResumeSubscription(
-  requestedThreadId: string,
-  returnedThreadId: string,
-): void {
-  if (returnedThreadId !== requestedThreadId) {
-    throw new CodexAppServerUnsafeSubscriptionError(
-      `Codex thread/resume returned ${returnedThreadId} for ${requestedThreadId}`,
-    );
+export async function closeCodexStartupClientBestEffort(
+  client: CodexAppServerClient | undefined,
+): Promise<void> {
+  if (!client) {
+    return;
  }
-}
-
-/** Retires the exact client lease when turn acceptance is ambiguous. */
-export async function runCodexTurnStartWithLease<T>(
-  lease: CodexAppServerClientLease,
-  startTurn: () => Promise<T>,
-): Promise<T> {
-  try {
-    return await startTurn();
-  } catch (error) {
-    // Structured RPC rejection happens before Codex accepts the turn. Transport,
-    // timeout, and abort failures may hide an accepted turn with an unknown id.
-    if (!(error instanceof CodexAppServerRpcError)) {
-      await lease.abandon();
+  const unclaimedSharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client);
+  if (unclaimedSharedClient.closed) {
+    await closeClientAndWaitIfAvailable(client);
+    return;
+  }
+  if (unclaimedSharedClient.found) {
+    const retired = retireSharedCodexAppServerClientIfCurrent(client);
+    if (retired?.closed) {
+      await closeClientAndWaitIfAvailable(client);
    }
-    throw error;
+    return;
  }
-}
-
-/** Retries once when native work wins the race immediately before turn/start. */
-export async function runCodexTurnStartWithNativeTurnRetry<T>(params: {
-  startTurn: () => Promise<T>;
-  waitForActiveTurnCompletion: () => Promise<boolean>;
-  afterActiveTurnCompletion?: () => Promise<void>;
-  onRetry?: () => void;
-}): Promise<T> {
-  try {
-    return await params.startTurn();
-  } catch (error) {
-    if (!isCodexActiveTurnNotSteerableError(error)) {
-      throw error;
+  const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
+  if (retiredSharedClient) {
+    if (retiredSharedClient.closed) {
+      await closeClientAndWaitIfAvailable(client);
    }
-    params.onRetry?.();
-    if (!(await params.waitForActiveTurnCompletion())) {
-      throw error;
-    }
-    await params.afterActiveTurnCompletion?.();
-    return await params.startTurn();
+    return;
  }
-}
-
-/** True for Codex's structured rejection when native work already owns the thread. */
-export function isCodexActiveTurnNotSteerableError(error: unknown): boolean {
-  if (!(error instanceof CodexAppServerRpcError) || !isJsonObject(error.data)) {
-    return false;
-  }
-  const info = error.data.codexErrorInfo;
-  return isJsonObject(info) && isJsonObject(info.activeTurnNotSteerable);
-}
-
-/** Validates a create response and retires the client unless cleanup is confirmed. */
-export async function validateCodexThreadCreationResponse<T>(
-  owner: {
-    client: CodexAppServerClient;
-    abandon: () => Promise<void>;
-  },
-  response: unknown,
-  validate: (value: unknown) => T,
-): Promise<T> {
-  try {
-    return validate(response);
-  } catch (error) {
-    const threadId = readCodexThreadCreationResponseId(response);
-    const released = threadId
-      ? await unsubscribeCodexThreadBestEffort(owner.client, {
-          threadId,
-          timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-        })
-      : false;
-    if (released) {
-      throw error;
-    }
-    try {
-      await owner.abandon();
-    } catch (abandonError) {
-      throw new CodexAppServerUnsafeSubscriptionError(
-        "Codex thread creation response was invalid and its client could not be retired",
-        { cause: abandonError },
-      );
-    }
-    throw new CodexAppServerUnsafeSubscriptionError(
-      "Codex thread creation response was invalid and its subscription could not be released",
-      { cause: error },
-    );
+  if (clearSharedCodexAppServerClientIfCurrent(client)) {
+    await closeClientAndWaitIfAvailable(client);
+    return;
  }
+  await closeClientAndWaitIfAvailable(client);
 }

 /** Sends a turn interrupt without blocking abort cleanup on app-server errors. */
@@ -148,56 +84,28 @@ export function interruptCodexTurnBestEffort(
  }
 }

-/** Unsubscribes from a thread and reports whether wire cleanup was confirmed. */
+/** Unsubscribes from a thread while swallowing cleanup-only failures. */
 export async function unsubscribeCodexThreadBestEffort(
  client: CodexAppServerClient,
  params: {
    threadId: string;
    timeoutMs: number;
  },
-): Promise<boolean> {
+): Promise<void> {
  try {
    await client.request(
      "thread/unsubscribe",
      { threadId: params.threadId },
      { timeoutMs: params.timeoutMs },
    );
-    return true;
  } catch (error) {
    embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
      threadId: params.threadId,
      error,
    });
-    return false;
  }
 }

-/** Returns one exact client lease to the pool only after subscription cleanup succeeds. */
-export async function settleCodexAppServerClientLease(
-  lease: CodexAppServerClientLease,
-  params: {
-    threadId?: string;
-    timeoutMs: number;
-    abandon?: boolean;
-  },
-): Promise<void> {
-  if (params.abandon) {
-    await lease.abandon();
-    return;
-  }
-  if (
-    params.threadId &&
-    !(await unsubscribeCodexThreadBestEffort(lease.client, {
-      threadId: params.threadId,
-      timeoutMs: params.timeoutMs,
-    }))
-  ) {
-    await lease.abandon();
-    return;
-  }
-  lease.release();
-}
-
 /**
 * Retires the shared client after a timed-out turn so later runs do not reuse a
 * potentially wedged app-server connection.
@@ -208,9 +116,10 @@ export async function retireCodexAppServerClientAfterTimedOutTurn(
    threadId: string;
    turnId: string;
    reason: string;
-    abandonClientLease: () => Promise<void>;
  },
 ): Promise<void> {
+  const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
+  const detachedSharedClient = Boolean(retiredSharedClient);
  interruptCodexTurnBestEffort(client, {
    threadId: params.threadId,
    turnId: params.turnId,
@@ -220,10 +129,28 @@ export async function retireCodexAppServerClientAfterTimedOutTurn(
    threadId: params.threadId,
    timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
  });
-  await params.abandonClientLease();
+  let closedClient = retiredSharedClient?.closed ?? false;
+  if (!detachedSharedClient) {
+    const close = (client as { close?: () => void }).close;
+    if (typeof close === "function") {
+      try {
+        close.call(client);
+        closedClient = true;
+      } catch (error) {
+        embeddedAgentLog.debug("codex app-server client close failed during timeout cleanup", {
+          threadId: params.threadId,
+          turnId: params.turnId,
+          error,
+        });
+      }
+    }
+  }
  embeddedAgentLog.warn("codex app-server client retired after timed-out turn", {
    threadId: params.threadId,
    turnId: params.turnId,
    reason: params.reason,
+    detachedSharedClient,
+    closedClient,
+    activeSharedClientLeases: retiredSharedClient?.activeLeases ?? 0,
  });
 }
--- a/extensions/codex/src/app-server/attempt-notification-state.ts
+++ b/extensions/codex/src/app-server/attempt-notification-state.ts
@@ -9,6 +9,7 @@ import {
  isFileChangePatchUpdatedNotification,
  isAssistantCommentaryCompletionNotification,
  isNativeToolProgressNotification,
+  isNativeResponseStreamDeltaNotification,
  isPendingOpenClawDynamicToolCompletionNotification,
  isRawAssistantProgressNotification,
  isRawReasoningCompletionNotification,
@@ -16,6 +17,7 @@ import {
  isReasoningProgressNotification,
  isReasoningItemCompletionNotification,
  isRetryableErrorNotification,
+  isTurnNotification,
  readCodexNotificationItem,
  readNotificationItemId,
  shouldDisarmAssistantCompletionIdleWatch,
@@ -23,7 +25,6 @@ import {
 } from "./attempt-notifications.js";
 import { CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS } from "./attempt-timeouts.js";
 import type { CodexAttemptTurnWatchController } from "./attempt-turn-watches.js";
-import { isCodexNotificationForTurn } from "./notification-correlation.js";
 import type { CodexServerNotification } from "./protocol.js";

 type CodexExecutionPhase =
@@ -69,7 +70,7 @@ export function isTerminalCodexTurnNotificationForTurn(params: {
  turnId: string;
  currentPromptTexts: string[];
 }): boolean {
-  if (!isCodexNotificationForTurn(params.notification.params, params.threadId, params.turnId)) {
+  if (!isTurnNotification(params.notification.params, params.threadId, params.turnId)) {
    return false;
  }
  return (
@@ -104,15 +105,16 @@ export function applyCodexTurnNotificationState(params: {
  turnCrossedToolHandoff: boolean;
 } {
  const { notification, turnWatches } = params;
-  const isCurrentTurnNotification = isCodexNotificationForTurn(
+  const isCurrentTurnNotification = isTurnNotification(
    notification.params,
    params.threadId,
    params.turnId,
  );
  const isTurnCompletion = notification.method === "turn/completed" && isCurrentTurnNotification;
+  const isNativeResponseStreamDelta = isNativeResponseStreamDeltaNotification(notification);
  let turnCrossedToolHandoff = params.turnCrossedToolHandoff;

-  if (isCurrentTurnNotification) {
+  if (isCurrentTurnNotification && !isNativeResponseStreamDelta) {
    turnWatches.touchActivity(`notification:${notification.method}`, {
      details: describeNotificationActivity(notification),
      attemptProgress: true,
@@ -248,6 +250,7 @@ export function applyCodexTurnNotificationState(params: {
    !turnWatches.isCompletionIdleWatchPinnedByTerminalError() &&
    notification.method !== "turn/completed" &&
    isCurrentTurnNotification &&
+    !isNativeResponseStreamDelta &&
    !trackedDynamicToolCompletion &&
    !rawToolOutputCompletion &&
    !postToolProgressNeedsTerminalGuard &&
--- a/extensions/codex/src/app-server/attempt-notifications.ts
+++ b/extensions/codex/src/app-server/attempt-notifications.ts
@@ -1,6 +1,11 @@
 /**
 * Predicates and readers for Codex app-server notification envelopes.
 */
+import { asBoolean } from "openclaw/plugin-sdk/string-coerce-runtime";
+import {
+  describeCodexNotificationCorrelation,
+  isCodexNotificationForTurn,
+} from "./notification-correlation.js";
 import {
  isJsonObject,
  type CodexServerNotification,
@@ -211,6 +216,13 @@ export function isNativeToolProgressNotification(notification: CodexServerNotifi
  }
 }

+/** Returns true for raw native response stream delta events. */
+export function isNativeResponseStreamDeltaNotification(
+  notification: CodexServerNotification,
+): boolean {
+  return notification.method.startsWith("response.") && notification.method.endsWith(".delta");
+}
+
 /** Returns true for file-change patch update notifications. */
 export function isFileChangePatchUpdatedNotification(
  notification: CodexServerNotification,
@@ -265,9 +277,74 @@ function readRawAssistantTextPreview(item: JsonObject): string | undefined {
  return text.length > 240 ? `${text.slice(0, 237)}...` : text;
 }

+/** Returns true when notification params correlate to a specific thread/turn. */
+export function isTurnNotification(
+  value: JsonValue | undefined,
+  threadId: string,
+  turnId: string,
+): boolean {
+  return isCodexNotificationForTurn(value, threadId, turnId);
+}
+
+/** Returns true when a correlated notification belongs to another active run. */
+export function isCodexNotificationOutsideActiveRun(
+  correlation: ReturnType<typeof describeCodexNotificationCorrelation>,
+): boolean {
+  const hasThreadScope = Boolean(correlation.threadId || correlation.nestedTurnThreadId);
+  if (!hasThreadScope) {
+    return false;
+  }
+  if (!correlation.matchesActiveThread) {
+    return true;
+  }
+  const hasTurnScope = Boolean(correlation.turnId || correlation.nestedTurnId);
+  return hasTurnScope && correlation.matchesActiveTurn === false;
+}
+
+/** Checks request params that must contain the current thread and turn ids. */
+export function isCurrentThreadTurnRequestParams(
+  value: JsonValue | undefined,
+  threadId: string,
+  turnId: string,
+): boolean {
+  if (!isJsonObject(value)) {
+    return false;
+  }
+  return readString(value, "threadId") === threadId && readString(value, "turnId") === turnId;
+}
+
+/** Checks approval request params, accepting `conversationId` as thread id. */
+export function isCurrentApprovalTurnRequestParams(
+  value: JsonValue | undefined,
+  threadId: string,
+  turnId: string,
+): boolean {
+  if (!isJsonObject(value)) {
+    return false;
+  }
+  const requestThreadId = readString(value, "threadId") ?? readString(value, "conversationId");
+  return requestThreadId === threadId && readString(value, "turnId") === turnId;
+}
+
+/** Checks request params where `turnId` may be omitted or null for the thread. */
+export function isCurrentThreadOptionalTurnRequestParams(
+  value: JsonValue | undefined,
+  threadId: string,
+  turnId: string,
+): boolean {
+  if (!isJsonObject(value) || readString(value, "threadId") !== threadId) {
+    return false;
+  }
+  const requestTurnId = value.turnId;
+  return requestTurnId === null || requestTurnId === undefined || requestTurnId === turnId;
+}
+
 /** Returns true for app-server error notifications that will retry. */
 export function isRetryableErrorNotification(value: JsonValue | undefined): boolean {
-  return isJsonObject(value) && value.willRetry === true;
+  if (!isJsonObject(value)) {
+    return false;
+  }
+  return readBoolean(value, "willRetry") === true || readBoolean(value, "will_retry") === true;
 }

 /** Returns true for terminal app-server thread status strings. */
@@ -342,6 +419,10 @@ function readString(record: JsonObject, key: string): string | undefined {
  return typeof value === "string" ? value : undefined;
 }

+function readBoolean(record: JsonObject, key: string): boolean | undefined {
+  return asBoolean(record[key]);
+}
+
 /** Reads a typed Codex item from notification params when id/type are present. */
 export function readCodexNotificationItem(
  params: JsonValue | undefined,
--- a/extensions/codex/src/app-server/attempt-startup.test.ts
+++ b/extensions/codex/src/app-server/attempt-startup.test.ts
@@ -9,16 +9,13 @@ import type {
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { startCodexAttemptThread } from "./attempt-startup.js";
+import { defaultLeasedCodexAppServerClientFactory } from "./client-factory.js";
 import { CodexAppServerClient } from "./client.js";
 import { type CodexPluginConfig, resolveCodexAppServerRuntimeOptions } from "./config.js";
-import { threadStartResult } from "./run-attempt-test-harness.js";
 import {
-  resetCodexTestBindingStore,
-  testCodexAppServerBindingStore,
-} from "./session-binding.test-helpers.js";
-import {
-  leaseSharedCodexAppServerClient,
-  resetSharedCodexAppServerClientForTests,
+  clearSharedCodexAppServerClient,
+  getLeasedSharedCodexAppServerClient,
+  releaseLeasedSharedCodexAppServerClient,
 } from "./shared-client.js";
 import { createClientHarness, createCodexTestModel } from "./test-support.js";

@@ -88,10 +85,12 @@ function startThreadWithHarness(
  signal = new AbortController().signal,
  overrides?: {
    pluginConfig?: CodexPluginConfig;
+    attemptClientFactory?: (
+      harness: ClientHarness,
+    ) => Parameters<typeof startCodexAttemptThread>[0]["attemptClientFactory"];
    harness?: ClientHarness;
    paths?: AttemptPaths;
    skipStartSpy?: boolean;
-    onThreadReserved?: Parameters<typeof startCodexAttemptThread>[0]["onThreadReserved"];
  },
 ) {
  const harness = overrides?.harness ?? createClientHarness();
@@ -102,7 +101,8 @@ function startThreadWithHarness(
  const effectivePluginConfig = overrides?.pluginConfig ?? pluginConfig;

  const run = startCodexAttemptThread({
-    bindingStore: testCodexAppServerBindingStore,
+    attemptClientFactory:
+      overrides?.attemptClientFactory?.(harness) ?? defaultLeasedCodexAppServerClientFactory,
    appServer: resolveCodexAppServerRuntimeOptions({ pluginConfig: effectivePluginConfig }),
    pluginConfig: effectivePluginConfig,
    computerUseConfig: effectivePluginConfig.computerUse ?? { enabled: false },
@@ -125,11 +125,10 @@ function startThreadWithHarness(
    sandboxExecServerEnabled: false,
    sandbox: null,
    contextEngineProjection: undefined,
-    startupTokenGuard: {},
    startupTimeoutMs,
    signal,
    onStartupTimeout: vi.fn(),
-    onThreadReserved: overrides?.onThreadReserved,
+    spawnedBy: undefined,
  });

  return { harness, run };
@@ -171,13 +170,12 @@ describe("startCodexAttemptThread", () => {
    vi.useRealTimers();
    vi.stubEnv("CODEX_API_KEY", "");
    vi.stubEnv("OPENAI_API_KEY", "");
-    resetCodexTestBindingStore();
-    resetSharedCodexAppServerClientForTests();
+    clearSharedCodexAppServerClient();
  });

  afterEach(async () => {
    vi.useRealTimers();
-    resetSharedCodexAppServerClientForTests();
+    clearSharedCodexAppServerClient();
    vi.restoreAllMocks();
    vi.unstubAllEnvs();
    for (const root of tempRoots) {
@@ -186,7 +184,7 @@ describe("startCodexAttemptThread", () => {
    tempRoots.clear();
  });

-  it("keeps the shared app-server reusable after a structured startup rejection", async () => {
+  it("clears the shared app-server when top-level thread startup fails with an app error", async () => {
    const { harness, run } = startThreadWithHarness(5_000);
    await answerInitialize(harness);
    const threadStart = await waitForThreadStart(harness);
@@ -196,57 +194,25 @@ describe("startCodexAttemptThread", () => {
    });

    await expect(run).rejects.toThrow("Invalid bearer token");
-    expect(harness.process.stdin.destroyed).toBe(false);
-  });
-
-  it("retires the client when malformed startup cleanup cannot be confirmed", async () => {
-    const { harness, run } = startThreadWithHarness(5_000);
-    await answerInitialize(harness);
-    const threadStart = await waitForThreadStart(harness);
-    harness.send({ id: threadStart.id, result: { thread: { id: "thread-malformed" } } });
-    const unsubscribe = await waitForRequest(harness, "thread/unsubscribe");
-    harness.send({
-      id: unsubscribe.id,
-      error: { code: -32000, message: "unsubscribe failed" },
-    });
-
-    await expect(run).rejects.toThrow("subscription could not be released");
    expect(harness.process.stdin.destroyed).toBe(true);
  });

-  it("retires the client when route cleanup cannot release the subscription", async () => {
-    const { harness, run } = startThreadWithHarness(5_000, undefined, {
-      onThreadReserved: () => {
-        throw new Error("route integration failed");
-      },
-    });
-    await answerInitialize(harness);
-    const threadStart = await waitForThreadStart(harness);
-    harness.send({ id: threadStart.id, result: threadStartResult("thread-route-failed") });
-    const unsubscribe = await waitForRequest(harness, "thread/unsubscribe");
-    harness.send({
-      id: unsubscribe.id,
-      error: { code: -32000, message: "unsubscribe failed" },
-    });
-
-    await expect(run).rejects.toThrow("Codex startup subscription cleanup failed");
-    expect(harness.process.stdin.destroyed).toBe(true);
-  });
-
-  it("does not retire a peer-owned client after a structured startup rejection", async () => {
+  it("retires a failed startup client after another active lease releases", async () => {
    const retained = createClientHarness();
-    const startSpy = vi.spyOn(CodexAppServerClient, "start").mockReturnValue(retained.client);
+    const replacement = createClientHarness();
+    const startSpy = vi
+      .spyOn(CodexAppServerClient, "start")
+      .mockReturnValueOnce(retained.client)
+      .mockReturnValueOnce(replacement.client);
    const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
    const paths = createAttemptPaths();

-    const retainedLeasePromise = leaseSharedCodexAppServerClient({
+    const retainedLease = getLeasedSharedCodexAppServerClient({
      startOptions: appServer.start,
      agentDir: paths.agentDir,
-      preparedAuth: {},
    });
    await answerInitialize(retained);
-    const retainedLease = await retainedLeasePromise;
-    expect(retainedLease.client).toBe(retained.client);
+    await expect(retainedLease).resolves.toBe(retained.client);

    const { run } = startThreadWithHarness(5_000, new AbortController().signal, {
      harness: retained,
@@ -262,16 +228,17 @@ describe("startCodexAttemptThread", () => {
    await expect(run).rejects.toThrow("Invalid bearer token");
    expect(retained.process.stdin.destroyed).toBe(false);

-    retainedLease.release();
-    const nextLeasePromise = leaseSharedCodexAppServerClient({
+    expect(releaseLeasedSharedCodexAppServerClient(retained.client)).toBe(true);
+    await vi.waitFor(() => expect(retained.process.stdin.destroyed).toBe(true));
+
+    const replacementLease = getLeasedSharedCodexAppServerClient({
      startOptions: appServer.start,
      agentDir: paths.agentDir,
-      preparedAuth: {},
    });
-    const nextLease = await nextLeasePromise;
-    expect(nextLease.client).toBe(retained.client);
-    expect(startSpy).toHaveBeenCalledTimes(1);
-    nextLease.release();
+    await answerInitialize(replacement);
+    await expect(replacementLease).resolves.toBe(replacement.client);
+    expect(startSpy).toHaveBeenCalledTimes(2);
+    expect(releaseLeasedSharedCodexAppServerClient(replacement.client)).toBe(true);
  });

  it("clears the shared app-server when startup abandons an in-flight thread request", async () => {
@@ -293,20 +260,18 @@ describe("startCodexAttemptThread", () => {
    expect(harness.stdinDestroyed).toBe(true);
  });

-  it("retires abandoned thread startup even when another lease shares the client", async () => {
+  it("aborts abandoned thread startup when another lease keeps the shared app-server alive", async () => {
    const retained = createClientHarness();
    vi.spyOn(CodexAppServerClient, "start").mockReturnValue(retained.client);
    const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
    const paths = createAttemptPaths();

-    const retainedLeasePromise = leaseSharedCodexAppServerClient({
+    const retainedLease = getLeasedSharedCodexAppServerClient({
      startOptions: appServer.start,
      agentDir: paths.agentDir,
-      preparedAuth: {},
    });
    await answerInitialize(retained);
-    const retainedLease = await retainedLeasePromise;
-    expect(retainedLease.client).toBe(retained.client);
+    await expect(retainedLease).resolves.toBe(retained.client);

    const { run } = startThreadWithHarness(100, new AbortController().signal, {
      harness: retained,
@@ -317,9 +282,11 @@ describe("startCodexAttemptThread", () => {
    const threadStart = await waitForThreadStart(retained);

    await rejected;
-    expect(threadStart.id).toBeDefined();
-    expect(retained.process.stdin.destroyed).toBe(true);
-    retainedLease.release();
+    expect(retained.process.stdin.destroyed).toBe(false);
+
+    retained.send({ id: threadStart.id, result: { threadId: "late-thread" } });
+    expect(releaseLeasedSharedCodexAppServerClient(retained.client)).toBe(true);
+    await vi.waitFor(() => expect(retained.process.stdin.destroyed).toBe(true));
  });

  it("closes the shared app-server when startup times out during initialize", async () => {
@@ -344,37 +311,45 @@ describe("startCodexAttemptThread", () => {
    ).toBe(false);
  });

-  it("releases a late startup lease without retiring a peer-owned initializing client", async () => {
-    const harness = createClientHarness();
-    const startSpy = vi.spyOn(CodexAppServerClient, "start").mockReturnValue(harness.client);
-    const paths = createAttemptPaths();
-    const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-    const peerPromise = leaseSharedCodexAppServerClient({
-      startOptions: appServer.start,
-      agentDir: paths.agentDir,
-      preparedAuth: {},
+  it("closes a startup client that arrives after startup timeout", async () => {
+    let observedFactoryOptions:
+      | {
+          onStartedClient?: (client: CodexAppServerClient) => void;
+          abandonSignal?: AbortSignal;
+        }
+      | undefined;
+    let resolveFactoryDone: () => void = () => undefined;
+    const factoryDone = new Promise<void>((resolve) => {
+      resolveFactoryDone = resolve;
    });
-    const { run } = startThreadWithHarness(100, new AbortController().signal, {
-      harness,
-      paths,
-      skipStartSpy: true,
+    const { harness, run } = startThreadWithHarness(100, new AbortController().signal, {
+      attemptClientFactory:
+        (factoryHarness) => async (_startOptions, _authProfileId, _agentDir, _config, options) => {
+          try {
+            observedFactoryOptions = options;
+            await new Promise<void>((resolve) => {
+              setTimeout(resolve, 250);
+            });
+            options?.onStartedClient?.(factoryHarness.client);
+            return factoryHarness.client;
+          } finally {
+            resolveFactoryDone();
+          }
+        },
    });
+    const rejected = expect(run).rejects.toThrow("codex app-server startup timed out");

-    await expect(run).rejects.toThrow("codex app-server startup timed out");
-    expect(harness.stdinDestroyed).toBe(false);
-    await answerInitialize(harness);
-    const peer = await peerPromise;
-    expect(peer.client).toBe(harness.client);
-    await new Promise<void>((resolve) => {
-      setImmediate(resolve);
+    await rejected;
+    await factoryDone;
+    await vi.waitFor(() => expect(harness.stdinDestroyed).toBe(true), {
+      interval: 1,
+      timeout: 2_000,
    });
-
-    expect(startSpy).toHaveBeenCalledTimes(1);
    expect(
      readHarnessMessages(harness.writes).some((write) => write.method === "thread/start"),
    ).toBe(false);
-    await peer.abandon();
-    expect(harness.stdinDestroyed).toBe(true);
+    expect(observedFactoryOptions?.onStartedClient).toBeTypeOf("function");
+    expect(observedFactoryOptions?.abandonSignal?.aborted).toBe(true);
  });

  it("clears the shared app-server when cancellation abandons an in-flight thread request", async () => {
--- a/extensions/codex/src/app-server/attempt-startup.ts
+++ b/extensions/codex/src/app-server/attempt-startup.ts
@@ -11,15 +11,10 @@ import {
  type resolveSandboxContext,
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { defaultCodexAppInventoryCache } from "./app-inventory-cache.js";
-import {
-  CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-  CodexAppServerUnsafeSubscriptionError,
-  isCodexAppServerUnsafeSubscriptionError,
-  unsubscribeCodexThreadBestEffort,
-} from "./attempt-client-cleanup.js";
+import { closeCodexStartupClientBestEffort } from "./attempt-client-cleanup.js";
 import { buildCodexPluginThreadConfigEligibilityLogData } from "./attempt-diagnostics.js";
 import { withCodexStartupTimeout } from "./attempt-timeouts.js";
-import { ensureCodexAppServerClientRuntime } from "./client-runtime.js";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import { isCodexAppServerConnectionClosedError, type CodexAppServerClient } from "./client.js";
 import { ensureCodexComputerUse } from "./computer-use.js";
 import {
@@ -57,23 +52,16 @@ import {
  releaseCodexSandboxExecServerEnvironment,
  type CodexSandboxExecEnvironment,
 } from "./sandbox-exec-server.js";
-import type { CodexAppServerBindingStore } from "./session-binding.js";
 import {
-  leaseSharedCodexAppServerClient,
-  type CodexAppServerClientLease,
-  type CodexAppServerClientLeaseFactory,
+  clearSharedCodexAppServerClientIfCurrent,
+  releaseLeasedSharedCodexAppServerClient,
 } from "./shared-client.js";
-import type { CodexAppServerStartupTokenGuard } from "./startup-binding.js";
 import {
  startOrResumeThread,
  type CodexAppServerThreadLifecycleBinding,
  type CodexContextEngineThreadBootstrapProjection,
 } from "./thread-lifecycle.js";
-import {
-  getCodexAppServerTurnRouter,
-  type CodexAppServerTurnRouter,
-  type CodexThreadRouteReservation,
-} from "./turn-router.js";
+import type { CodexNativeWebSearchSupport } from "./web-search.js";

 const CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS = 3;

@@ -81,15 +69,14 @@ type CodexSandboxContext = Awaited<ReturnType<typeof resolveSandboxContext>>;

 /** Resources and bindings returned after a Codex attempt thread starts. */
 export type StartCodexAttemptThreadResult = {
-  turnRouter: CodexAppServerTurnRouter;
-  turnRoute: CodexThreadRouteReservation;
+  client: CodexAppServerClient;
  thread: CodexAppServerThreadLifecycleBinding;
+  pluginAppServer: CodexAppServerRuntimeOptions;
  sandboxEnvironment: CodexSandboxExecEnvironment | undefined;
  environmentSelection: CodexTurnEnvironmentParams[] | undefined;
  executionCwd: string;
  sandboxPolicy: CodexSandboxPolicy | undefined;
-  clientLease: CodexAppServerClientLease;
-  mcpElicitationDelegationRequired: boolean;
+  releaseSharedClientLease: () => void;
  restartContextEngineCodexThread: () => Promise<CodexAppServerThreadLifecycleBinding>;
 };

@@ -98,8 +85,7 @@ export type StartCodexAttemptThreadResult = {
 * run loop must later release.
 */
 export async function startCodexAttemptThread(params: {
-  bindingStore: CodexAppServerBindingStore;
-  clientLeaseFactory?: CodexAppServerClientLeaseFactory;
+  attemptClientFactory: CodexAppServerClientFactory;
  appServer: CodexAppServerRuntimeOptions;
  pluginConfig: CodexPluginConfig;
  computerUseConfig: CodexComputerUseConfig;
@@ -125,26 +111,18 @@ export async function startCodexAttemptThread(params: {
  sandboxExecServerEnabled: boolean;
  sandbox: CodexSandboxContext;
  contextEngineProjection: CodexContextEngineThreadBootstrapProjection | undefined;
-  expectedResumeThreadId?: string;
-  startupTokenGuard: CodexAppServerStartupTokenGuard;
  startupTimeoutMs: number;
  signal: AbortSignal;
  onStartupTimeout: () => void | Promise<void>;
-  onThreadReserved?: (client: CodexAppServerClient, threadId: string) => () => void;
+  spawnedBy: EmbeddedRunAttemptParams["spawnedBy"];
 }): Promise<StartCodexAttemptThreadResult> {
-  let mcpElicitationDelegationRequired = false;
-  let sharedClientLease: CodexAppServerClientLease | undefined;
+  let pluginAppServer = params.appServer;
+  let releaseSharedClientLease: (() => void) | undefined;
+  let startupClientForAbandonedRequestCleanup: CodexAppServerClient | undefined;
  let releaseStartupResourcesOnTimeout: (() => Promise<void>) | undefined;
  let startupAbandoned = false;
  const startupAbandonController = new AbortController();
  const abandonStartupAcquire = () => startupAbandonController.abort();
-  const abandonStartupClient = async () => {
-    const lease = sharedClientLease;
-    sharedClientLease = undefined;
-    if (lease) {
-      await lease.abandon();
-    }
-  };
  params.signal.addEventListener("abort", abandonStartupAcquire, { once: true });
  try {
    const startupResult = await withCodexStartupTimeout({
@@ -155,7 +133,10 @@ export async function startCodexAttemptThread(params: {
        startupAbandonController.abort();
        await params.onStartupTimeout();
        await releaseStartupResourcesOnTimeout?.();
-        await abandonStartupClient();
+        releaseSharedClientLease?.();
+        releaseSharedClientLease = undefined;
+        await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
+        startupClientForAbandonedRequestCleanup = undefined;
      },
      operation: async () => {
        const threadConfig = mergeCodexThreadConfigs(
@@ -172,9 +153,8 @@ export async function startCodexAttemptThread(params: {
        const resolvedPluginPolicy = pluginThreadConfigRequired
          ? resolveCodexPluginsPolicy(pluginThreadConfigPluginConfig)
          : undefined;
-        const computerUseMcpElicitationDelegationRequired =
-          params.computerUseConfig.enabled === true;
-        mcpElicitationDelegationRequired =
+        const computerUseMcpElicitationDelegationRequired = params.computerUseConfig.enabled;
+        const mcpElicitationDelegationRequired =
          resolvedPluginPolicy?.enabled === true || computerUseMcpElicitationDelegationRequired;
        const enabledPluginConfigKeys = resolvedPluginPolicy
          ? resolvedPluginPolicy.pluginPolicies
@@ -182,48 +162,55 @@ export async function startCodexAttemptThread(params: {
              .map((plugin) => plugin.configKey)
              .toSorted()
          : undefined;
-        const pluginAppServer = mcpElicitationDelegationRequired
+        pluginAppServer = mcpElicitationDelegationRequired
          ? {
              ...params.appServer,
              approvalPolicy: withMcpElicitationsApprovalPolicy(params.appServer.approvalPolicy),
            }
          : params.appServer;

-        let attemptedClientAbandoned = false;
+        let attemptedClient: CodexAppServerClient | undefined;
        const startupAttempt = async () => {
-          let startupClientLease: CodexAppServerClientLease | undefined;
-          let clientWorkStarted = false;
-          attemptedClientAbandoned = false;
+          let startupClientLease: (() => void) | undefined;
+          let startupClient: CodexAppServerClient | undefined;
+          let startupAttemptError: unknown;
+          let startupAttemptSucceeded = false;
          try {
-            startupClientLease = await (
-              params.clientLeaseFactory ?? leaseSharedCodexAppServerClient
-            )({
-              startOptions: params.appServer.start,
-              authProfileId: params.startupAuthProfileId,
-              agentDir: params.agentDir,
-              config: params.config,
-              preparedAuth: {
-                profileId: params.startupAuthProfileId,
-                cacheKey: params.startupAuthAccountCacheKey ?? params.startupEnvApiKeyCacheKey,
+            startupClient = await params.attemptClientFactory(
+              params.appServer.start,
+              params.startupAuthProfileId,
+              params.agentDir,
+              params.config,
+              {
+                onStartedClient: (client) => {
+                  // Timeout cleanup may fire before the client factory resolves;
+                  // close any late-arriving client instead of leaking a lease.
+                  startupClientForAbandonedRequestCleanup = client;
+                  if (startupAbandoned || startupAbandonController.signal.aborted) {
+                    void closeCodexStartupClientBestEffort(client);
+                  }
+                },
+                abandonSignal: startupAbandonController.signal,
              },
-              abandonSignal: startupAbandonController.signal,
-            });
-            const activeStartupLease = startupClientLease;
-            const activeStartupClient = activeStartupLease.client;
-            sharedClientLease = startupClientLease;
+            );
+            const activeStartupClient = startupClient;
+            let startupClientLeaseReleased = false;
+            startupClientLease = () => {
+              if (startupClientLeaseReleased) {
+                return;
+              }
+              startupClientLeaseReleased = true;
+              releaseLeasedSharedCodexAppServerClient(activeStartupClient);
+            };
+            releaseSharedClientLease = startupClientLease;
+            attemptedClient = activeStartupClient;
+            startupClientForAbandonedRequestCleanup = activeStartupClient;
            if (startupAbandoned) {
              throw new Error("codex app-server startup timed out");
            }
            if (startupAbandonController.signal.aborted) {
              throw new Error("codex app-server startup aborted");
            }
-            clientWorkStarted = true;
-            ensureCodexAppServerClientRuntime(activeStartupClient, {
-              agentDir: params.agentDir,
-              authProfileId: params.startupAuthProfileId,
-              config: params.config,
-            });
-            const turnRouter = getCodexAppServerTurnRouter(activeStartupClient);
            await ensureCodexComputerUse({
              client: activeStartupClient,
              pluginConfig: params.pluginConfig,
@@ -290,6 +277,7 @@ export async function startCodexAttemptThread(params: {
                : undefined;
              startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
              if (startupAbandonController.signal.aborted) {
+                await releaseStartupSandboxEnvironment();
                throw new Error("codex app-server startup aborted");
              }
              if (
@@ -320,57 +308,9 @@ export async function startCodexAttemptThread(params: {
            const startupSandboxPolicy = startupSandboxEnvironment
              ? resolveCodexExternalSandboxPolicyForOpenClawSandbox(params.sandbox)
              : undefined;
-            let startupReservation:
-              | { route: CodexThreadRouteReservation; release: () => void }
-              | undefined;
-            const reserveStartupThread = (threadId: string) => {
-              if (startupReservation) {
-                if (startupReservation.route.threadId !== threadId) {
-                  throw new Error(
-                    `codex app-server reserved ${startupReservation.route.threadId} but started ${threadId}`,
-                  );
-                }
-                return { release: startupReservation.release };
-              }
-              const route = turnRouter.reserveThread({
-                threadId,
-                releaseOn: params.signal,
-              });
-              let releaseIntegration: (() => void) | undefined;
-              try {
-                releaseIntegration = params.onThreadReserved?.(activeStartupClient, threadId);
-              } catch (error) {
-                route.release();
-                throw error;
-              }
-              let released = false;
-              const release = () => {
-                if (released) {
-                  return;
-                }
-                released = true;
-                if (startupReservation?.route === route) {
-                  startupReservation = undefined;
-                }
-                route.release();
-                releaseIntegration?.();
-              };
-              startupReservation = { route, release };
-              return { release };
-            };
-            const releaseStartupResources = async () => {
-              startupReservation?.release();
-              await releaseStartupSandboxEnvironment();
-            };
-            releaseStartupResourcesOnTimeout = releaseStartupResources;
-            const buildThreadLifecycleParams = (
-              signal: AbortSignal,
-              options: { freshStartOnly?: boolean } = {},
-            ) =>
+            const buildThreadLifecycleParams = (signal: AbortSignal) =>
              ({
                client: activeStartupClient,
-                abandonClient: activeStartupLease.abandon,
-                bindingStore: params.bindingStore,
                params: params.buildAttemptParams(),
                agentId: params.sessionAgentId,
                cwd: startupExecutionCwd,
@@ -392,13 +332,7 @@ export async function startCodexAttemptThread(params: {
                environmentSelection: startupEnvironmentSelection,
                appServerRuntimeFingerprint,
                contextEngineProjection: params.contextEngineProjection,
-                freshStartOnly: options.freshStartOnly,
-                expectedResumeThreadId: options.freshStartOnly
-                  ? undefined
-                  : params.expectedResumeThreadId,
                signal,
-                reserveResumeThread: options.freshStartOnly ? undefined : reserveStartupThread,
-                startupTokenGuard: params.startupTokenGuard,
                pluginThreadConfig: pluginThreadConfigRequired
                  ? {
                      enabled: true,
@@ -422,65 +356,57 @@ export async function startCodexAttemptThread(params: {
              const startupThread = await startOrResumeThread(
                buildThreadLifecycleParams(startupAbandonController.signal),
              );
-              try {
-                reserveStartupThread(startupThread.threadId);
-              } catch (error) {
-                const unsubscribed = await unsubscribeCodexThreadBestEffort(activeStartupClient, {
-                  threadId: startupThread.threadId,
-                  timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-                });
-                if (!unsubscribed) {
-                  throw new CodexAppServerUnsafeSubscriptionError(
-                    "Codex startup subscription cleanup failed",
-                    { cause: error },
-                  );
-                }
-                throw error;
-              }
              if (startupAbandonController.signal.aborted) {
+                await releaseStartupSandboxEnvironment();
                throw new Error("codex app-server startup aborted");
              }
-              if (!startupReservation) {
-                throw new Error("codex app-server startup did not reserve its thread route");
-              }
              startupSandboxEnvironmentAcquired = false;
+              startupAttemptSucceeded = true;
              return {
-                turnRouter,
-                turnRoute: startupReservation.route,
+                client: activeStartupClient,
                thread: startupThread,
                sandboxEnvironment: startupSandboxEnvironment,
                environmentSelection: startupEnvironmentSelection,
                executionCwd: startupExecutionCwd,
                sandboxPolicy: startupSandboxPolicy,
                restartContextEngineCodexThread: () =>
-                  startOrResumeThread(
-                    buildThreadLifecycleParams(params.signal, { freshStartOnly: true }),
-                  ),
+                  startOrResumeThread(buildThreadLifecycleParams(params.signal)),
              };
            } catch (error) {
-              await releaseStartupResources();
+              await releaseStartupSandboxEnvironment();
              throw error;
            } finally {
-              if (releaseStartupResourcesOnTimeout === releaseStartupResources) {
+              if (releaseStartupResourcesOnTimeout === releaseStartupSandboxEnvironment) {
                releaseStartupResourcesOnTimeout = undefined;
              }
            }
          } catch (error) {
-            if (sharedClientLease === startupClientLease) {
-              sharedClientLease = undefined;
-            }
-            const shouldAbandonStartupClient =
-              clientWorkStarted &&
-              (startupAbandoned ||
-                params.signal.aborted ||
-                isIndeterminateCodexStartupFailure(error));
-            if (shouldAbandonStartupClient) {
-              attemptedClientAbandoned = true;
-              await startupClientLease?.abandon();
-            } else {
-              startupClientLease?.release();
-            }
+            startupAttemptError = error;
            throw error;
+          } finally {
+            if (!startupAttemptSucceeded) {
+              if (releaseSharedClientLease === startupClientLease) {
+                releaseSharedClientLease = undefined;
+              }
+              startupClientLease?.();
+              if (startupAbandoned || params.signal.aborted) {
+                if (startupClientForAbandonedRequestCleanup === startupClient) {
+                  startupClientForAbandonedRequestCleanup = undefined;
+                }
+                await closeCodexStartupClientBestEffort(startupClient);
+              } else if (
+                shouldClearSharedClientAfterStartupRace(startupAttemptError) ||
+                shouldClearSharedClientAfterStartupFailure({
+                  error: startupAttemptError,
+                  spawnedBy: params.spawnedBy,
+                })
+              ) {
+                if (startupClientForAbandonedRequestCleanup === startupClient) {
+                  startupClientForAbandonedRequestCleanup = undefined;
+                }
+                await closeCodexStartupClientBestEffort(startupClient);
+              }
+            }
          }
        };

@@ -495,13 +421,18 @@ export async function startCodexAttemptThread(params: {
            if (params.signal.aborted || !isCodexAppServerConnectionClosedError(error)) {
              throw error;
            }
+            const failedClient = attemptedClient;
+            const clearedSharedClient = clearSharedCodexAppServerClientIfCurrent(failedClient);
+            if (startupClientForAbandonedRequestCleanup === failedClient) {
+              startupClientForAbandonedRequestCleanup = undefined;
+            }
            if (attempt >= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS) {
              embeddedAgentLog.warn(
                "codex app-server connection closed during startup; retries exhausted",
                {
                  attempt,
                  maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
-                  abandonedSharedClient: attemptedClientAbandoned,
+                  clearedSharedClient,
                  error: formatErrorMessage(error),
                },
              );
@@ -513,7 +444,7 @@ export async function startCodexAttemptThread(params: {
                attempt,
                nextAttempt: attempt + 1,
                maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
-                abandonedSharedClient: attemptedClientAbandoned,
+                clearedSharedClient,
                error: formatErrorMessage(error),
              },
            );
@@ -522,21 +453,32 @@ export async function startCodexAttemptThread(params: {
        throw new Error("codex app-server startup retry loop exited unexpectedly");
      },
    });
-    const completedSharedClientLease = sharedClientLease;
-    if (!completedSharedClientLease) {
+    startupClientForAbandonedRequestCleanup = undefined;
+    if (!releaseSharedClientLease) {
      throw new Error("codex app-server startup succeeded without a shared client lease");
    }
-    sharedClientLease = undefined;
    return {
      ...startupResult,
-      mcpElicitationDelegationRequired,
-      clientLease: completedSharedClientLease,
+      pluginAppServer,
+      releaseSharedClientLease,
    };
  } catch (error) {
-    const shouldAbandonStartupClient =
-      params.signal.aborted || isIndeterminateCodexStartupFailure(error);
-    if (shouldAbandonStartupClient) {
-      await abandonStartupClient();
+    if (params.signal.aborted || shouldClearSharedClientAfterStartupAbandon(error)) {
+      releaseSharedClientLease?.();
+      releaseSharedClientLease = undefined;
+      await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
+      startupClientForAbandonedRequestCleanup = undefined;
+    } else if (
+      shouldClearSharedClientAfterStartupRace(error) ||
+      shouldClearSharedClientAfterStartupFailure({
+        error,
+        spawnedBy: params.spawnedBy,
+      })
+    ) {
+      releaseSharedClientLease?.();
+      releaseSharedClientLease = undefined;
+      await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
+      startupClientForAbandonedRequestCleanup = undefined;
    }
    throw error;
  } finally {
@@ -544,13 +486,30 @@ export async function startCodexAttemptThread(params: {
  }
 }

-function isIndeterminateCodexStartupFailure(error: unknown): boolean {
+function shouldClearSharedClientAfterStartupAbandon(error: unknown): boolean {
  return (
-    isCodexAppServerUnsafeSubscriptionError(error) ||
-    isCodexAppServerConnectionClosedError(error) ||
-    (error instanceof Error &&
-      (error.message.endsWith(" timed out") ||
-        error.message.endsWith(" aborted") ||
-        error.message.includes("write EPIPE")))
+    error instanceof Error &&
+    (error.message === "codex app-server startup timed out" ||
+      error.message === "codex app-server startup aborted")
  );
 }
+
+function shouldClearSharedClientAfterStartupRace(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (shouldClearSharedClientAfterStartupAbandon(error) || error.message.endsWith(" timed out"))
+  );
+}
+
+function shouldClearSharedClientAfterStartupFailure(params: {
+  error: unknown;
+  spawnedBy: EmbeddedRunAttemptParams["spawnedBy"];
+}): boolean {
+  if (!(params.error instanceof Error)) {
+    return !params.spawnedBy;
+  }
+  if (params.error.message.includes("write EPIPE")) {
+    return true;
+  }
+  return !params.spawnedBy;
+}
--- a/extensions/codex/src/app-server/attempt-timeouts.test.ts
+++ b/extensions/codex/src/app-server/attempt-timeouts.test.ts
@@ -159,39 +159,6 @@ describe("Codex app-server attempt timeouts", () => {
    expect(events).toEqual(["cleanup-start", "cleanup-done"]);
  });

-  it("keeps the timeout result when startup resolves during timeout cleanup", async () => {
-    vi.useFakeTimers();
-    const events: string[] = [];
-    let resolveOperation!: (value: string) => void;
-    let finishCleanup!: () => void;
-    const run = withCodexStartupTimeout({
-      timeoutMs: 10,
-      signal: new AbortController().signal,
-      onTimeout: async () => {
-        events.push("cleanup-start");
-        await new Promise<void>((resolve) => {
-          finishCleanup = resolve;
-        });
-        events.push("cleanup-done");
-      },
-      operation: () =>
-        new Promise<string>((resolve) => {
-          resolveOperation = resolve;
-        }),
-    });
-    const rejected = expect(run).rejects.toThrow("codex app-server startup timed out");
-
-    await vi.advanceTimersByTimeAsync(10);
-    expect(events).toEqual(["cleanup-start"]);
-    resolveOperation("late-ready");
-    await Promise.resolve();
-    expect(events).toEqual(["cleanup-start"]);
-    finishCleanup();
-
-    await rejected;
-    expect(events).toEqual(["cleanup-start", "cleanup-done"]);
-  });
-
  it("rejects startup timeout when aborted before completion", async () => {
    vi.useFakeTimers();
    const controller = new AbortController();
--- a/extensions/codex/src/app-server/attempt-timeouts.ts
+++ b/extensions/codex/src/app-server/attempt-timeouts.ts
@@ -52,13 +52,13 @@ export async function withCodexStartupTimeout<T>(params: {
        };
        timeout = setTimeout(() => {
          timeoutError = new Error("codex app-server startup timed out");
-          rejectOnce(timeoutError);
-          timeoutCleanup = Promise.resolve()
-            .then(() => params.onTimeout?.())
-            .then(
-              () => undefined,
-              () => undefined,
-            );
+          timeoutCleanup = Promise.resolve(params.onTimeout?.()).then(
+            () => undefined,
+            () => undefined,
+          );
+          void timeoutCleanup.finally(() => {
+            rejectOnce(timeoutError!);
+          });
        }, params.timeoutMs);
        const abortListener = () => rejectOnce(new Error("codex app-server startup aborted"));
        params.signal.addEventListener("abort", abortListener, { once: true });
--- a/extensions/codex/src/app-server/attempt-turn-watches.test.ts
+++ b/extensions/codex/src/app-server/attempt-turn-watches.test.ts
@@ -29,7 +29,7 @@ describe("Codex app-server attempt turn watches", () => {
    const progress: string[] = [];
    const diagnostics: string[] = [];
    const controller = createCodexAttemptTurnWatchController({
-      getThreadId: () => "thread-1",
+      threadId: "thread-1",
      signal: abortController.signal,
      getTurnId: () => "turn-1",
      isCompleted: () => completed,
--- a/extensions/codex/src/app-server/attempt-turn-watches.ts
+++ b/extensions/codex/src/app-server/attempt-turn-watches.ts
@@ -29,7 +29,7 @@ export type CodexAttemptTurnWatchController = ReturnType<
 * notifications and tool handoffs progress.
 */
 export function createCodexAttemptTurnWatchController(params: {
-  getThreadId: () => string;
+  threadId: string;
  signal: AbortSignal;
  getTurnId: () => string | undefined;
  isCompleted: () => boolean;
@@ -79,7 +79,6 @@ export function createCodexAttemptTurnWatchController(params: {
  const turnTerminalIdleTimeoutMs = resolveTimerTimeoutMs(params.turnTerminalIdleTimeoutMs, 1);
  const interruptTimeoutMs = resolveTimerTimeoutMs(params.interruptTimeoutMs, 1);
  const resolveWatchTimeoutMs = (timeoutMs: number) => resolveTimerTimeoutMs(timeoutMs, 1);
-  const currentThreadId = () => params.getThreadId();

  const clearCompletionIdleTimer = () => {
    if (completionIdleTimer) {
@@ -228,7 +227,7 @@ export function createCodexAttemptTurnWatchController(params: {
    clearTerminalIdleTimer();
    const turnId = params.getTurnId();
    params.onRecordEvent("turn.assistant_completion_idle_release", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId,
      idleMs,
      timeoutMs: turnAssistantCompletionIdleTimeoutMs,
@@ -237,7 +236,7 @@ export function createCodexAttemptTurnWatchController(params: {
    embeddedAgentLog.warn(
      "codex app-server turn released after completed assistant item without terminal event",
      {
-        threadId: currentThreadId(),
+        threadId: params.threadId,
        turnId,
        idleMs,
        timeoutMs: turnAssistantCompletionIdleTimeoutMs,
@@ -246,7 +245,7 @@ export function createCodexAttemptTurnWatchController(params: {
    );
    if (turnId) {
      params.onInterruptTurn({
-        threadId: currentThreadId(),
+        threadId: params.threadId,
        turnId,
        timeoutMs: interruptTimeoutMs,
      });
@@ -279,7 +278,7 @@ export function createCodexAttemptTurnWatchController(params: {
    params.onTimeout(timeout);
    params.onMarkTimedOut();
    params.onRecordEvent("turn.progress_idle_timeout", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs: timeout.timeoutMs,
@@ -287,7 +286,7 @@ export function createCodexAttemptTurnWatchController(params: {
      ...timeout.details,
    });
    embeddedAgentLog.warn("codex app-server turn idle timed out waiting for progress", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs: timeout.timeoutMs,
@@ -332,7 +331,7 @@ export function createCodexAttemptTurnWatchController(params: {
    params.onTimeout(timeout);
    params.onMarkTimedOut();
    params.onRecordEvent("turn.completion_idle_timeout", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs,
@@ -340,7 +339,7 @@ export function createCodexAttemptTurnWatchController(params: {
      ...timeout.details,
    });
    embeddedAgentLog.warn("codex app-server turn idle timed out waiting for completion", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs,
@@ -375,7 +374,7 @@ export function createCodexAttemptTurnWatchController(params: {
    params.onTimeout(timeout);
    params.onMarkTimedOut();
    params.onRecordEvent("turn.terminal_idle_timeout", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs: timeout.timeoutMs,
@@ -383,7 +382,7 @@ export function createCodexAttemptTurnWatchController(params: {
      ...timeout.details,
    });
    embeddedAgentLog.warn("codex app-server turn idle timed out waiting for terminal event", {
-      threadId: currentThreadId(),
+      threadId: params.threadId,
      turnId: params.getTurnId(),
      idleMs,
      timeoutMs: timeout.timeoutMs,
@@ -458,11 +457,9 @@ export function createCodexAttemptTurnWatchController(params: {
        details?: Record<string, unknown>;
        attemptProgress?: boolean;
        attemptTimeoutMs?: number;
-        receivedAtMs?: number;
      },
    ) => {
-      const now = Date.now();
-      completionLastActivityAt = Math.min(now, options?.receivedAtMs ?? now);
+      completionLastActivityAt = Date.now();
      completionLastActivityReason = `notification:${method}`;
      if (options?.details !== undefined) {
        completionLastActivityDetails = options.details;
--- a/extensions/codex/src/app-server/auth-bridge.test.ts
+++ b/extensions/codex/src/app-server/auth-bridge.test.ts
@@ -1583,6 +1583,7 @@ describe("bridgeCodexAppServerStartOptions", () => {
    });
    vi.stubEnv("CODEX_API_KEY", "codex-env-api-key");
    vi.stubEnv("OPENAI_API_KEY", "openai-env-api-key");
+    vi.stubEnv("CODEX_HOME", path.join(agentDir, "codex-home"));
    try {
      await applyCodexAppServerAuthProfile({
        client: { request } as never,
@@ -1777,6 +1778,7 @@ describe("bridgeCodexAppServerStartOptions", () => {
    });
    vi.stubEnv("CODEX_API_KEY", "codex-env-api-key");
    vi.stubEnv("OPENAI_API_KEY", "openai-env-api-key");
+    vi.stubEnv("CODEX_HOME", path.join(agentDir, "codex-home"));
    try {
      await applyCodexAppServerAuthProfile({
        client: { request } as never,
--- a/extensions/codex/src/app-server/auth-profile-runtime-contract.test.ts
+++ b/extensions/codex/src/app-server/auth-profile-runtime-contract.test.ts
@@ -8,56 +8,40 @@ import {
 } from "openclaw/plugin-sdk/agent-harness";
 import { AUTH_PROFILE_RUNTIME_CONTRACT } from "openclaw/plugin-sdk/agent-runtime-test-contracts";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import { runCodexAppServerAttempt as runCodexAppServerAttemptImpl } from "./run-attempt.js";
 import {
  readCodexAppServerBinding,
-  registerCodexTestSessionIdentity,
-  resetCodexTestBindingStore,
-  testCodexAppServerBindingStore,
-  writeCodexAppServerBinding,
-} from "./session-binding.test-helpers.js";
-import type { CodexAppServerClientLeaseFactory } from "./shared-client.js";
-import {
-  adaptCodexTestClientFactory,
-  createCodexTestModel,
-  type CodexTestAppServerClientFactory,
-} from "./test-support.js";
+  writeCodexAppServerBinding as writeRawCodexAppServerBinding,
+} from "./session-binding.js";
+import { createCodexTestModel } from "./test-support.js";

-let codexAppServerClientLeaseFactoryForTest: CodexAppServerClientLeaseFactory | undefined;
+let codexAppServerClientFactoryForTest: CodexAppServerClientFactory | undefined;

-type RunCodexAppServerAttemptImplOptions = NonNullable<
+type RunCodexAppServerAttemptOptions = NonNullable<
  Parameters<typeof runCodexAppServerAttemptImpl>[1]
 >;
-type RunCodexAppServerAttemptOptions = Omit<RunCodexAppServerAttemptImplOptions, "bindingStore"> & {
-  bindingStore?: RunCodexAppServerAttemptImplOptions["bindingStore"];
-};

-function setCodexAppServerClientFactoryForTest(factory: CodexTestAppServerClientFactory): void {
-  codexAppServerClientLeaseFactoryForTest = adaptCodexTestClientFactory(factory);
+function setCodexAppServerClientFactoryForTest(factory: CodexAppServerClientFactory): void {
+  codexAppServerClientFactoryForTest = factory;
 }

 function resetCodexAppServerClientFactoryForTest(): void {
-  codexAppServerClientLeaseFactoryForTest = undefined;
+  codexAppServerClientFactoryForTest = undefined;
 }

 function runCodexAppServerAttempt(
  params: EmbeddedRunAttemptParams,
  options: RunCodexAppServerAttemptOptions = {},
 ) {
-  const clientLeaseFactory = options.clientLeaseFactory ?? codexAppServerClientLeaseFactoryForTest;
-  return runCodexAppServerAttemptImpl(params, {
-    ...options,
-    bindingStore: options.bindingStore ?? testCodexAppServerBindingStore,
-    ...(clientLeaseFactory ? { clientLeaseFactory } : {}),
-  });
+  const clientFactory = options.clientFactory ?? codexAppServerClientFactoryForTest;
+  return runCodexAppServerAttemptImpl(
+    params,
+    clientFactory ? { ...options, clientFactory } : options,
+  );
 }

 function createParams(sessionFile: string, workspaceDir: string): EmbeddedRunAttemptParams {
-  registerCodexTestSessionIdentity(
-    sessionFile,
-    AUTH_PROFILE_RUNTIME_CONTRACT.sessionId,
-    AUTH_PROFILE_RUNTIME_CONTRACT.sessionKey,
-  );
  return {
    prompt: AUTH_PROFILE_RUNTIME_CONTRACT.workspacePrompt,
    sessionId: AUTH_PROFILE_RUNTIME_CONTRACT.sessionId,
@@ -81,6 +65,7 @@ const DISABLED_CODEX_WEB_SEARCH_THREAD_CONFIG_FINGERPRINT = JSON.stringify({
  "features.standalone_web_search": false,
  web_search: "disabled",
 });
+const STARTUP_CONTRACT_WAIT = { interval: 10, timeout: 5_000 };

 function writeCodexAppServerBinding(
  ...args: Parameters<typeof writeRawCodexAppServerBinding>
@@ -164,8 +149,7 @@ function createCodexAuthProfileHarness(params: { startMethod: "thread/start" | "
  const seenAuthProfileIds: Array<string | undefined> = [];
  const seenAgentDirs: Array<string | undefined> = [];
  const requests: Array<{ method: string; params: unknown }> = [];
-  const notificationHandlers = new Set<(notification: unknown) => Promise<void> | void>();
-  const requestHandlers = new Set<(request: unknown) => unknown>();
+  let notify: (notification: unknown) => Promise<void> = async () => undefined;
  setCodexAppServerClientFactoryForTest(async (_startOptions, authProfileId, agentDir) => {
    seenAuthProfileIds.push(authProfileId);
    seenAgentDirs.push(agentDir);
@@ -181,28 +165,19 @@ function createCodexAuthProfileHarness(params: { startMethod: "thread/start" | "
        }
        throw new Error(`unexpected method: ${method}`);
      }),
-      addNotificationHandler: (handler: (notification: unknown) => Promise<void> | void) => {
-        notificationHandlers.add(handler);
-        return () => notificationHandlers.delete(handler);
+      addNotificationHandler: (handler: (notification: unknown) => Promise<void>) => {
+        notify = handler;
+        return () => undefined;
      },
-      addRequestHandler: (handler: (request: unknown) => unknown) => {
-        requestHandlers.add(handler);
-        return () => requestHandlers.delete(handler);
-      },
-      addCloseHandler: () => () => undefined,
+      addRequestHandler: () => () => undefined,
    } as never;
  });
-  const notify = async (notification: unknown) => {
-    await Promise.all(
-      [...notificationHandlers].map((handler) => Promise.resolve(handler(notification))),
-    );
-  };
  return {
    seenAuthProfileIds,
    seenAgentDirs,
    async waitForMethod(method: string) {
      await vi.waitFor(() => expect(requests.map((entry) => entry.method)).toContain(method), {
-        interval: 1,
+        ...STARTUP_CONTRACT_WAIT,
      });
    },
    async completeTurn() {
@@ -222,7 +197,6 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
  let tmpDir: string;

  beforeEach(async () => {
-    resetCodexTestBindingStore();
    vi.useRealTimers();
    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-auth-contract-"));
  });
@@ -247,7 +221,7 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
        expect(harness.seenAuthProfileIds).toEqual([
          AUTH_PROFILE_RUNTIME_CONTRACT.openAiCodexProfileId,
        ]),
-      { interval: 1 },
+      STARTUP_CONTRACT_WAIT,
    );
    expect(harness.seenAgentDirs).toEqual([tmpDir]);
    await harness.waitForMethod("turn/start");
@@ -258,7 +232,6 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
  it("reuses a bound OpenAI Codex auth profile when resume params omit authProfileId", async () => {
    const harness = createCodexAuthProfileHarness({ startMethod: "thread/resume" });
    const sessionFile = path.join(tmpDir, "session.jsonl");
-    const params = createParams(sessionFile, tmpDir);
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-auth-contract",
      cwd: tmpDir,
@@ -266,6 +239,7 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
      dynamicToolsFingerprint: "[]",
    });
    // authProfileId is intentionally omitted to exercise the resume-bound profile path.
+    const params = createParams(sessionFile, tmpDir);

    const run = runCodexAppServerAttempt(params);
    await vi.waitFor(
@@ -273,7 +247,7 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
        expect(harness.seenAuthProfileIds).toEqual([
          AUTH_PROFILE_RUNTIME_CONTRACT.openAiCodexProfileId,
        ]),
-      { interval: 1 },
+      STARTUP_CONTRACT_WAIT,
    );
    await harness.waitForMethod("turn/start");
    await harness.completeTurn();
@@ -283,13 +257,13 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
  it("prefers an explicit runtime auth profile over a stale persisted binding", async () => {
    const harness = createCodexAuthProfileHarness({ startMethod: "thread/resume" });
    const sessionFile = path.join(tmpDir, "session.jsonl");
-    const params = createParams(sessionFile, tmpDir);
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-auth-contract",
      cwd: tmpDir,
      authProfileId: "openai:stale",
      dynamicToolsFingerprint: "[]",
    });
+    const params = createParams(sessionFile, tmpDir);
    params.authProfileId = AUTH_PROFILE_RUNTIME_CONTRACT.openAiCodexProfileId;

    const run = runCodexAppServerAttempt(params);
@@ -298,7 +272,7 @@ describe("Auth profile runtime contract - Codex app-server adapter", () => {
        expect(harness.seenAuthProfileIds).toEqual([
          AUTH_PROFILE_RUNTIME_CONTRACT.openAiCodexProfileId,
        ]),
-      { interval: 1 },
+      STARTUP_CONTRACT_WAIT,
    );
    await harness.waitForMethod("turn/start");
    await harness.completeTurn();
--- a/extensions/codex/src/app-server/bounded-turn.ts
+++ b/extensions/codex/src/app-server/bounded-turn.ts
@@ -5,6 +5,7 @@ import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 import { readCodexNotificationItem } from "./attempt-notifications.js";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import type { CodexAppServerClient } from "./client.js";
 import { resolveCodexAppServerRuntimeOptions } from "./config.js";
 import { readModelListResult } from "./models.js";
@@ -26,10 +27,6 @@ import {
  type JsonObject,
  type JsonValue,
 } from "./protocol.js";
-import type {
-  CodexAppServerClientLease,
-  CodexAppServerClientLeaseFactory,
-} from "./shared-client.js";
 import { buildCodexRuntimeThreadConfig } from "./thread-lifecycle.js";

 const CODEX_PRIVATE_STDIO_ARGS = ["app-server", "--listen", "stdio://"];
@@ -49,7 +46,7 @@ const CODEX_PRIVATE_BOUNDED_THREAD_CONFIG: JsonObject = {

 export type CodexBoundedTurnOptions = {
  pluginConfig?: unknown;
-  clientFactory?: CodexAppServerClientLeaseFactory;
+  clientFactory?: CodexAppServerClientFactory;
 };

 export type CodexBoundedTurnResult = {
@@ -121,17 +118,11 @@ async function runBoundedCodexAppServerTurnInWorkspace(
  const startOptions = workspace.codexHome
    ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome)
    : appServer.start;
-  let lease: CodexAppServerClientLease | undefined;
+  const ownsClient = !params.options.clientFactory;
  const client = params.options.clientFactory
-    ? ((lease = await params.options.clientFactory({
-        startOptions,
+    ? await params.options.clientFactory(startOptions, params.profile, agentDir, params.config, {
        timeoutMs,
-        authProfileId: params.profile,
-        agentDir,
-        authProfileStore: params.authProfileStore,
-        config: params.config,
-      })),
-      lease.client)
+      })
    : await import("./shared-client.js").then(({ createIsolatedCodexAppServerClient }) =>
        createIsolatedCodexAppServerClient({
          startOptions,
@@ -217,9 +208,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(
  } finally {
    clearTimeout(timeout);
    params.signal?.removeEventListener("abort", abortFromCaller);
-    if (lease) {
-      lease.release();
-    } else {
+    if (ownsClient) {
      client.close();
    }
  }
--- a/extensions/codex/src/app-server/client-factory.ts
+++ b/extensions/codex/src/app-server/client-factory.ts
@@ -0,0 +1,50 @@
+/**
+ * Lazy factories for shared and leased Codex app-server clients.
+ */
+import type { resolveCodexAppServerAuthProfileIdForAgent } from "./auth-bridge.js";
+import type { CodexAppServerClient } from "./client.js";
+import type { CodexAppServerStartOptions } from "./config.js";
+
+type AuthProfileOrderConfig = Parameters<
+  typeof resolveCodexAppServerAuthProfileIdForAgent
+>[0]["config"];
+
+/** Factory signature used by Codex attempt startup to acquire a client. */
+export type CodexAppServerClientFactory = (
+  startOptions?: CodexAppServerStartOptions,
+  authProfileId?: string,
+  agentDir?: string,
+  config?: AuthProfileOrderConfig,
+  options?: {
+    onStartedClient?: (client: CodexAppServerClient) => void;
+    abandonSignal?: AbortSignal;
+    timeoutMs?: number;
+  },
+) => Promise<CodexAppServerClient>;
+
+let sharedClientModulePromise: Promise<typeof import("./shared-client.js")> | null = null;
+
+const loadSharedClientModule = async () => {
+  sharedClientModulePromise ??= import("./shared-client.js");
+  return await sharedClientModulePromise;
+};
+
+/** Returns a leased shared client so startup can release ownership explicitly. */
+export const defaultLeasedCodexAppServerClientFactory: CodexAppServerClientFactory = (
+  startOptions,
+  authProfileId,
+  agentDir,
+  config,
+  options,
+) =>
+  loadSharedClientModule().then(({ getLeasedSharedCodexAppServerClient }) =>
+    getLeasedSharedCodexAppServerClient({
+      startOptions,
+      authProfileId,
+      agentDir,
+      config,
+      onStartedClient: options?.onStartedClient,
+      abandonSignal: options?.abandonSignal,
+      timeoutMs: options?.timeoutMs,
+    }),
+  );
--- a/extensions/codex/src/app-server/client-runtime.test.ts
+++ b/extensions/codex/src/app-server/client-runtime.test.ts
@@ -1,78 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { CodexAppServerClient } from "./client.js";
-import { createClientHarness } from "./test-support.js";
-
-const mocks = vi.hoisted(() => ({
-  refreshAuth: vi.fn(async () => ({ accessToken: "refreshed", chatgptAccountId: "account" })),
-  mergeRateLimitUpdate: vi.fn(),
-}));
-
-vi.mock("./auth-bridge.js", () => ({
-  refreshCodexAppServerAuthTokens: mocks.refreshAuth,
-}));
-
-vi.mock("./rate-limit-cache.js", () => ({
-  mergeCodexRateLimitsUpdate: mocks.mergeRateLimitUpdate,
-}));
-
-const { ensureCodexAppServerClientRuntime } = await import("./client-runtime.js");
-
-describe("Codex app-server client runtime", () => {
-  const clients: CodexAppServerClient[] = [];
-
-  afterEach(() => {
-    for (const client of clients) {
-      client.close();
-    }
-    clients.length = 0;
-    mocks.refreshAuth.mockClear();
-    mocks.mergeRateLimitUpdate.mockClear();
-  });
-
-  it("installs shared handlers once per physical client", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-    const context = {
-      agentDir: "/tmp/agent",
-      authProfileId: "openai:default",
-      config: {},
-    };
-    const updatedContext = {
-      ...context,
-      authProfileStore: { version: 1 as const, profiles: {} },
-      config: { models: { mode: "merge" as const } },
-    };
-    const addNotificationHandler = vi.spyOn(harness.client, "addNotificationHandler");
-    const addRequestHandler = vi.spyOn(harness.client, "addRequestHandler");
-    const addCloseHandler = vi.spyOn(harness.client, "addCloseHandler");
-
-    ensureCodexAppServerClientRuntime(harness.client, context);
-    ensureCodexAppServerClientRuntime(harness.client, updatedContext);
-
-    expect(addNotificationHandler).toHaveBeenCalledTimes(1);
-    expect(addRequestHandler).toHaveBeenCalledTimes(1);
-    expect(addCloseHandler).not.toHaveBeenCalled();
-    harness.send({
-      method: "account/rateLimits/updated",
-      params: { rateLimits: { primary: { usedPercent: 12 } } },
-    });
-    harness.send({
-      id: "refresh-1",
-      method: "account/chatgptAuthTokens/refresh",
-      params: { reason: "expired" },
-    });
-
-    await vi.waitFor(() => expect(mocks.mergeRateLimitUpdate).toHaveBeenCalledTimes(1));
-    await vi.waitFor(() => expect(mocks.refreshAuth).toHaveBeenCalledTimes(1));
-    expect(mocks.refreshAuth).toHaveBeenCalledWith(updatedContext);
-    expect(mocks.mergeRateLimitUpdate).toHaveBeenCalledWith(harness.client, {
-      rateLimits: { primary: { usedPercent: 12 } },
-    });
-    await vi.waitFor(() =>
-      expect(harness.writes.map((line) => JSON.parse(line) as unknown)).toContainEqual({
-        id: "refresh-1",
-        result: { accessToken: "refreshed", chatgptAccountId: "account" },
-      }),
-    );
-  });
-});
--- a/extensions/codex/src/app-server/client-runtime.ts
+++ b/extensions/codex/src/app-server/client-runtime.ts
@@ -1,50 +0,0 @@
-/** Client-scoped Codex auth and account observers. */
-import { refreshCodexAppServerAuthTokens } from "./auth-bridge.js";
-import type { CodexAppServerClient } from "./client.js";
-import type { JsonValue } from "./protocol.js";
-import { mergeCodexRateLimitsUpdate } from "./rate-limit-cache.js";
-import type { CodexAppServerAuthProfileLookup } from "./session-binding.js";
-
-type ClientRuntimeContext = Omit<CodexAppServerAuthProfileLookup, "agentDir"> & {
-  agentDir: string;
-};
-
-type ClientRuntime = {
-  context: ClientRuntimeContext;
-};
-
-const configuredClients = new WeakMap<CodexAppServerClient, ClientRuntime>();
-
-/** Installs one auth-refresh handler and one rate-limit observer per physical client. */
-export function ensureCodexAppServerClientRuntime(
-  client: CodexAppServerClient,
-  context: ClientRuntimeContext,
-): void {
-  const existing = configuredClients.get(client);
-  if (existing) {
-    // Shared-client keys already isolate agent/auth identity. Keep config fresh
-    // without installing another physical-client handler set.
-    existing.context = context;
-    return;
-  }
-  const runtime: ClientRuntime = { context };
-  configuredClients.set(client, runtime);
-  client.addRequestHandler(async (request) => {
-    if (request.method !== "account/chatgptAuthTokens/refresh") {
-      return undefined;
-    }
-    return (await refreshCodexAppServerAuthTokens({
-      agentDir: runtime.context.agentDir,
-      authProfileId: runtime.context.authProfileId,
-      ...(runtime.context.authProfileStore
-        ? { authProfileStore: runtime.context.authProfileStore }
-        : {}),
-      config: runtime.context.config,
-    })) as unknown as JsonValue;
-  });
-  client.addNotificationHandler((notification) => {
-    if (notification.method === "account/rateLimits/updated") {
-      mergeCodexRateLimitsUpdate(client, notification.params);
-    }
-  });
-}
--- a/extensions/codex/src/app-server/client.test.ts
+++ b/extensions/codex/src/app-server/client.test.ts
@@ -50,78 +50,6 @@ describe("CodexAppServerClient", () => {
    expect(outbound.method).toBe("model/list");
  });

-  it("keeps a shared thread subscribed until every local owner releases it", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-
-    const firstResume = harness.client.request("thread/resume", { threadId: "thread-1" });
-    const secondResume = harness.client.request("thread/resume", { threadId: "thread-1" });
-    const [firstRequest, secondRequest] = harness.writes.map((line) => JSON.parse(line)) as Array<{
-      id: number;
-    }>;
-    const resumeResult = {
-      thread: { id: "thread-1", cwd: "/tmp", status: { type: "idle" } },
-      model: "gpt-5.5",
-    };
-    harness.send({ id: firstRequest?.id, result: resumeResult });
-    harness.send({ id: secondRequest?.id, result: resumeResult });
-    await Promise.all([firstResume, secondResume]);
-
-    await expect(
-      harness.client.request("thread/unsubscribe", { threadId: "thread-1" }),
-    ).resolves.toEqual({ status: "unsubscribed" });
-    expect(harness.writes).toHaveLength(2);
-
-    const finalRelease = harness.client.request("thread/unsubscribe", {
-      threadId: "thread-1",
-    });
-    const releaseRequest = JSON.parse(harness.writes[2] ?? "{}") as { id?: number };
-    harness.send({ id: releaseRequest.id, result: { status: "unsubscribed" } });
-    await expect(finalRelease).resolves.toEqual({ status: "unsubscribed" });
-    expect(harness.writes).toHaveLength(3);
-  });
-
-  it("pairs written resume failures without retaining pre-aborted requests", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-
-    const firstResume = harness.client.request("thread/resume", { threadId: "thread-1" });
-    const firstRequest = JSON.parse(harness.writes[0] ?? "{}") as { id?: number };
-    harness.send({
-      id: firstRequest.id,
-      result: {
-        thread: { id: "thread-1", cwd: "/tmp", status: { type: "idle" } },
-        model: "gpt-5.5",
-      },
-    });
-    await firstResume;
-
-    const failedResume = harness.client.request("thread/resume", { threadId: "thread-1" });
-    const failedRequest = JSON.parse(harness.writes[1] ?? "{}") as { id?: number };
-    harness.send({ id: failedRequest.id, error: { code: -32000, message: "resume failed" } });
-    await expect(failedResume).rejects.toThrow("resume failed");
-
-    await expect(
-      harness.client.request("thread/unsubscribe", { threadId: "thread-1" }),
-    ).resolves.toEqual({ status: "unsubscribed" });
-    expect(harness.writes).toHaveLength(2);
-
-    const controller = new AbortController();
-    controller.abort();
-    await expect(
-      harness.client.request(
-        "thread/resume",
-        { threadId: "thread-1" },
-        { signal: controller.signal },
-      ),
-    ).rejects.toThrow("thread/resume aborted");
-    const unsubscribe = harness.client.request("thread/unsubscribe", { threadId: "thread-1" });
-    expect(harness.writes).toHaveLength(3);
-    const unsubscribeRequest = JSON.parse(harness.writes[2] ?? "{}") as { id?: number };
-    harness.send({ id: unsubscribeRequest.id, result: { status: "unsubscribed" } });
-    await expect(unsubscribe).resolves.toEqual({ status: "unsubscribed" });
-  });
-
  it("removes unpaired surrogate code units from outbound JSON-RPC strings", async () => {
    const harness = createClientHarness();
    clients.push(harness.client);
@@ -142,9 +70,9 @@ describe("CodexAppServerClient", () => {
    expect(outbound.params?.nested).toEqual(["lowend", "emoji 🙈 ok"]);
    harness.send({
      id: JSON.parse(harness.writes[0] ?? "{}").id,
-      result: { thread: { id: "thread-1" } },
+      result: { threadId: "thread-1" },
    });
-    await expect(request).resolves.toEqual({ thread: { id: "thread-1" } });
+    await expect(request).resolves.toEqual({ threadId: "thread-1" });
  });

  it("logs a redacted preview for malformed app-server messages", async () => {
@@ -212,30 +140,6 @@ describe("CodexAppServerClient", () => {
    expect(warn).not.toHaveBeenCalled();
  });

-  it("contains synchronous notification handler failures and continues fanout", async () => {
-    const warn = vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
-    const harness = createClientHarness();
-    clients.push(harness.client);
-    const laterHandler = vi.fn();
-    harness.client.addNotificationHandler(() => {
-      throw new Error("handler exploded");
-    });
-    harness.client.addNotificationHandler(laterHandler);
-
-    expect(() =>
-      harness.send({
-        method: "item/commandExecution/outputDelta",
-        params: { delta: "still routed" },
-      }),
-    ).not.toThrow();
-
-    await vi.waitFor(() => expect(laterHandler).toHaveBeenCalledTimes(1));
-    expect(warn).toHaveBeenCalledWith(
-      "codex app-server notification handler failed",
-      expect.objectContaining({ error: expect.any(Error) }),
-    );
-  });
-
  it("preserves JSON-RPC error codes", async () => {
    const harness = createClientHarness();
    clients.push(harness.client);
@@ -316,95 +220,6 @@ describe("CodexAppServerClient", () => {
    expect(harness.writes).toHaveLength(1);
  });

-  it.each([
-    {
-      method: "thread/start" as const,
-      params: {},
-      abandonment: "timeout" as const,
-      expectedError: "thread/start timed out",
-    },
-    {
-      method: "thread/fork" as const,
-      params: { threadId: "parent-thread" },
-      abandonment: "abort" as const,
-      expectedError: "thread/fork aborted",
-    },
-  ])("unsubscribes a late successful $method after local $abandonment", async (testCase) => {
-    vi.useFakeTimers();
-    const harness = createClientHarness();
-    clients.push(harness.client);
-    const controller = new AbortController();
-    const options =
-      testCase.abandonment === "timeout" ? { timeoutMs: 1 } : { signal: controller.signal };
-    const request = harness.client.request(testCase.method, testCase.params, options);
-    const outbound = JSON.parse(harness.writes[0] ?? "{}") as { id?: number };
-    const rejected = expect(request).rejects.toThrow(testCase.expectedError);
-
-    if (testCase.abandonment === "timeout") {
-      await vi.advanceTimersByTimeAsync(100);
-    } else {
-      controller.abort();
-    }
-    await rejected;
-
-    harness.send({ id: outbound.id, result: { thread: { id: "late-thread" } } });
-    expect(JSON.parse(harness.writes[1] ?? "{}")).toEqual({
-      id: expect.any(Number),
-      method: "thread/unsubscribe",
-      params: { threadId: "late-thread" },
-    });
-  });
-
-  it("closes when a late thread creation subscription cannot be released", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-    const controller = new AbortController();
-    const request = harness.client.request("thread/start", {}, { signal: controller.signal });
-    const outbound = JSON.parse(harness.writes[0] ?? "{}") as { id?: number };
-    const rejected = expect(request).rejects.toThrow("thread/start aborted");
-
-    controller.abort();
-    await rejected;
-    harness.send({ id: outbound.id, result: { thread: { id: "late-thread" } } });
-    const unsubscribe = JSON.parse(harness.writes[1] ?? "{}") as { id?: number };
-    harness.send({
-      id: unsubscribe.id,
-      error: { code: -32_000, message: "unsubscribe failed" },
-    });
-
-    await vi.waitFor(() => expect(harness.stdinDestroyed).toBe(true));
-  });
-
-  it("does not unsubscribe a late rejected thread creation", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-    const controller = new AbortController();
-    const request = harness.client.request("thread/start", {}, { signal: controller.signal });
-    const outbound = JSON.parse(harness.writes[0] ?? "{}") as { id?: number };
-    const rejected = expect(request).rejects.toThrow("thread/start aborted");
-
-    controller.abort();
-    await rejected;
-    harness.send({ id: outbound.id, error: { code: -32000, message: "start failed" } });
-
-    expect(harness.writes).toHaveLength(1);
-  });
-
-  it("closes after the bounded late-creation cleanup ledger fills", async () => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-
-    for (let index = 0; index < 129; index += 1) {
-      const controller = new AbortController();
-      const request = harness.client.request("thread/start", {}, { signal: controller.signal });
-      const rejected = expect(request).rejects.toThrow("thread/start aborted");
-      controller.abort();
-      await rejected;
-    }
-
-    expect(harness.stdinDestroyed).toBe(true);
-  });
-
  it("initializes with the required client version", async () => {
    const { harness, initializing, outbound } = startInitialize();
    harness.send({
@@ -701,26 +516,6 @@ describe("CodexAppServerClient", () => {
    });
  });

-  it.each(["execCommandApproval", "applyPatchApproval"])(
-    "fails closed for unhandled legacy %s requests",
-    async (method) => {
-      const harness = createClientHarness();
-      clients.push(harness.client);
-
-      harness.send({
-        id: "legacy-approval-1",
-        method,
-        params: { conversationId: "thread-1" },
-      });
-      await vi.waitFor(() => expect(harness.writes.length).toBe(1));
-
-      expect(JSON.parse(harness.writes[0] ?? "{}")).toEqual({
-        id: "legacy-approval-1",
-        result: { decision: "denied" },
-      });
-    },
-  );
-
  it("fails closed for unhandled native app-server approvals", async () => {
    const harness = createClientHarness();
    clients.push(harness.client);
@@ -738,41 +533,6 @@ describe("CodexAppServerClient", () => {
    });
  });

-  it.each([
-    [
-      "item/tool/call",
-      {
-        contentItems: [
-          {
-            type: "inputText",
-            text: "OpenClaw did not register a handler for this app-server tool call.",
-          },
-        ],
-        success: false,
-      },
-    ],
-    ["item/permissions/requestApproval", { permissions: {}, scope: "turn" }],
-    ["mcpServer/elicitation/request", { action: "decline" }],
-    [
-      "item/future/requestApproval",
-      {
-        decision: "decline",
-        reason: "OpenClaw codex app-server bridge does not grant unknown native approvals.",
-      },
-    ],
-  ])("fails closed for an unhandled %s request", async (method, expected) => {
-    const harness = createClientHarness();
-    clients.push(harness.client);
-
-    harness.send({ id: "unhandled-1", method, params: { threadId: "thread-1" } });
-    await vi.waitFor(() => expect(harness.writes.length).toBe(1));
-
-    expect(JSON.parse(harness.writes[0] ?? "{}")).toEqual({
-      id: "unhandled-1",
-      result: expected,
-    });
-  });
-
  it("only treats known Codex app-server approval methods as approvals", () => {
    expect(isCodexAppServerApprovalRequest("item/commandExecution/requestApproval")).toBe(true);
    expect(isCodexAppServerApprovalRequest("item/fileChange/requestApproval")).toBe(true);
--- a/extensions/codex/src/app-server/client.ts
+++ b/extensions/codex/src/app-server/client.ts
@@ -12,7 +12,6 @@ import {
  type CodexInitializeParams,
  type CodexInitializeResponse,
  isRpcResponse,
-  readCodexThreadCreationResponseId,
  type CodexServerNotification,
  type JsonValue,
  type RpcMessage,
@@ -35,8 +34,6 @@ const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 1_000_000;
 const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1_000;
 const CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS = 600_000;
 const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2_000;
-const CODEX_APP_SERVER_ABANDONED_THREAD_CREATION_MAX = 128;
-const CODEX_APP_SERVER_LATE_THREAD_CLEANUP_TIMEOUT_MS = 5_000;
 const UNPAIRED_SURROGATE_RE =
  /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;

@@ -123,10 +120,7 @@ export class CodexAppServerClient {
  private readonly requestHandlers = new Set<CodexServerRequestHandler>();
  private readonly notificationHandlers = new Set<CodexServerNotificationHandler>();
  private readonly closeHandlers = new Set<(client: CodexAppServerClient) => void>();
-  private readonly threadSubscriptionOwners = new Map<string, number>();
-  // Codex may finish a locally abandoned create request. Remember its RPC id
-  // until response/close so the unknown thread subscription can be released.
-  private readonly abandonedThreadCreationRequestIds = new Set<number | string>();
+  private activeSharedLeaseCountProvider: (() => number | undefined) | undefined;
  private nextId = 1;
  private initialized = false;
  private closed = false;
@@ -247,27 +241,11 @@ export class CodexAppServerClient {
    if (options.signal?.aborted) {
      return Promise.reject(new Error(`${method} aborted`));
    }
-    const requestedThreadId = readRequestThreadId(params);
-    if (
-      method === "thread/unsubscribe" &&
-      requestedThreadId &&
-      this.releaseThreadSubscriptionOwner(requestedThreadId)
-    ) {
-      // Codex subscriptions are connection-wide sets. A logical owner can
-      // release without silencing another turn on the same physical client.
-      return Promise.resolve({ status: "unsubscribed" } as unknown as T);
-    }
-    if (method === "thread/resume" && requestedThreadId) {
-      // Every resume attempt owns one release, even if the response times out
-      // or aborts: Codex may have subscribed before OpenClaw saw the outcome.
-      this.retainThreadSubscriptionOwner(requestedThreadId);
-    }
    const id = this.nextId++;
    const message: RpcRequest = { id, method, params: params as JsonValue | undefined };
    return new Promise<T>((resolve, reject) => {
      let timeout: ReturnType<typeof setTimeout> | undefined;
      let cleanupAbort: (() => void) | undefined;
-      let requestWritten = false;
      const cleanup = () => {
        if (timeout) {
          clearTimeout(timeout);
@@ -276,37 +254,23 @@ export class CodexAppServerClient {
        cleanupAbort?.();
        cleanupAbort = undefined;
      };
-      const rejectPending = (error: Error, rememberLateThreadCreation = false) => {
+      const rejectPending = (error: Error) => {
        if (!this.pending.has(id)) {
          return;
        }
        this.pending.delete(id);
-        if (rememberLateThreadCreation && isThreadCreationRequest(method)) {
-          if (
-            this.abandonedThreadCreationRequestIds.size >=
-            CODEX_APP_SERVER_ABANDONED_THREAD_CREATION_MAX
-          ) {
-            // Lost create responses can hide server subscriptions. Once the
-            // bounded cleanup ledger fills, closing is the only safe release.
-            this.closeWithError(
-              new Error("codex app-server abandoned thread creation limit exceeded"),
-            );
-          } else {
-            this.abandonedThreadCreationRequestIds.add(id);
-          }
-        }
        cleanup();
        reject(error);
      };
      if (options.timeoutMs && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
        timeout = setTimeout(
-          () => rejectPending(new Error(`${method} timed out`), true),
+          () => rejectPending(new Error(`${method} timed out`)),
          Math.max(100, options.timeoutMs),
        );
        timeout.unref?.();
      }
      if (options.signal) {
-        const abortListener = () => rejectPending(new Error(`${method} aborted`), requestWritten);
+        const abortListener = () => rejectPending(new Error(`${method} aborted`));
        options.signal.addEventListener("abort", abortListener, { once: true });
        cleanupAbort = () => options.signal?.removeEventListener("abort", abortListener);
      }
@@ -314,12 +278,6 @@ export class CodexAppServerClient {
        method,
        resolve: (value) => {
          cleanup();
-          if (method === "thread/start" || method === "thread/fork") {
-            const threadId = readCodexThreadCreationResponseId(value);
-            if (threadId) {
-              this.retainThreadSubscriptionOwner(threadId);
-            }
-          }
          resolve(value as T);
        },
        reject: (error) => {
@@ -333,7 +291,6 @@ export class CodexAppServerClient {
        return;
      }
      try {
-        requestWritten = true;
        this.writeMessage(message, (error) => rejectPending(error));
      } catch (error) {
        rejectPending(error instanceof Error ? error : new Error(String(error)));
@@ -358,6 +315,18 @@ export class CodexAppServerClient {
    return () => this.notificationHandlers.delete(handler);
  }

+  /** Installs a lease-count provider used to route unscoped notifications. */
+  setActiveSharedLeaseCountProviderForUnscopedNotifications(
+    provider: (() => number | undefined) | undefined,
+  ): void {
+    this.activeSharedLeaseCountProvider = provider;
+  }
+
+  /** Reads the active shared-client lease count when available. */
+  getActiveSharedLeaseCountForUnscopedNotifications(): number | undefined {
+    return this.activeSharedLeaseCountProvider?.();
+  }
+
  /** Registers a close handler and returns its disposer. */
  addCloseHandler(handler: (client: CodexAppServerClient) => void): () => void {
    this.closeHandlers.add(handler);
@@ -476,15 +445,6 @@ export class CodexAppServerClient {
  }

  private handleResponse(response: RpcResponse): void {
-    if (this.abandonedThreadCreationRequestIds.delete(response.id)) {
-      if (!response.error) {
-        const threadId = readCodexThreadCreationResponseId(response.result);
-        if (threadId) {
-          this.unsubscribeLateThreadCreation(threadId);
-        }
-      }
-      return;
-    }
    const pending = this.pending.get(response.id);
    if (!pending) {
      return;
@@ -562,14 +522,7 @@ export class CodexAppServerClient {

  private handleNotification(notification: CodexServerNotification): void {
    for (const handler of this.notificationHandlers) {
-      let result: Promise<void> | void;
-      try {
-        result = handler(notification);
-      } catch (error) {
-        embeddedAgentLog.warn("codex app-server notification handler failed", { error });
-        continue;
-      }
-      Promise.resolve(result).catch((error: unknown) => {
+      Promise.resolve(handler(notification)).catch((error: unknown) => {
        embeddedAgentLog.warn("codex app-server notification handler failed", { error });
      });
    }
@@ -587,54 +540,11 @@ export class CodexAppServerClient {
    }
    this.closed = true;
    this.closeError = error;
-    this.threadSubscriptionOwners.clear();
-    this.abandonedThreadCreationRequestIds.clear();
    this.lines.close();
    this.rejectPendingRequests(error);
    return true;
  }

-  private unsubscribeLateThreadCreation(threadId: string): void {
-    // This late response never registered a local owner. Track the wire
-    // release anyway; an unconfirmed cleanup makes this client unsafe to pool.
-    void this.request(
-      "thread/unsubscribe",
-      { threadId },
-      { timeoutMs: CODEX_APP_SERVER_LATE_THREAD_CLEANUP_TIMEOUT_MS },
-    ).catch((error: unknown) => {
-      embeddedAgentLog.debug("codex app-server late thread unsubscribe failed", {
-        threadId,
-        error,
-      });
-      this.closeWithError(
-        new Error(`Codex late thread subscription could not be released: ${threadId}`, {
-          cause: error,
-        }),
-      );
-    });
-  }
-
-  private retainThreadSubscriptionOwner(threadId: string): void {
-    this.threadSubscriptionOwners.set(
-      threadId,
-      (this.threadSubscriptionOwners.get(threadId) ?? 0) + 1,
-    );
-  }
-
-  /** Returns true when another local owner still needs the wire subscription. */
-  private releaseThreadSubscriptionOwner(threadId: string): boolean {
-    const owners = this.threadSubscriptionOwners.get(threadId);
-    if (owners === undefined) {
-      return false;
-    }
-    if (owners > 1) {
-      this.threadSubscriptionOwners.set(threadId, owners - 1);
-      return true;
-    }
-    this.threadSubscriptionOwners.delete(threadId);
-    return false;
-  }
-
  private rejectPendingRequests(error: Error): void {
    for (const pending of this.pending.values()) {
      pending.cleanup();
@@ -647,17 +557,6 @@ export class CodexAppServerClient {
  }
 }

-function readRequestThreadId(value: unknown): string | undefined {
-  if (!isJsonObject(value) || typeof value.threadId !== "string") {
-    return undefined;
-  }
-  return value.threadId.trim() || undefined;
-}
-
-function isThreadCreationRequest(method: string): boolean {
-  return method === "thread/start" || method === "thread/fork";
-}
-
 function defaultServerRequestResponse(
  request: Required<Pick<RpcRequest, "id" | "method">> & { params?: JsonValue },
 ): JsonValue {
@@ -672,9 +571,6 @@ function defaultServerRequestResponse(
      success: false,
    };
  }
-  if (request.method === "execCommandApproval" || request.method === "applyPatchApproval") {
-    return { decision: "denied" };
-  }
  if (
    request.method === "item/commandExecution/requestApproval" ||
    request.method === "item/fileChange/requestApproval"
@@ -690,12 +586,6 @@ function defaultServerRequestResponse(
      reason: "OpenClaw codex app-server bridge does not grant native approvals yet.",
    };
  }
-  if (request.method.includes("requestApproval")) {
-    return {
-      decision: "decline",
-      reason: "OpenClaw codex app-server bridge does not grant unknown native approvals.",
-    };
-  }
  if (request.method === "item/tool/requestUserInput") {
    return {
      answers: {},
--- a/extensions/codex/src/app-server/compact.test.ts
+++ b/extensions/codex/src/app-server/compact.test.ts
--- a/extensions/codex/src/app-server/compact.ts
+++ b/extensions/codex/src/app-server/compact.ts
@@ -7,396 +7,145 @@ import {
  type EmbeddedAgentCompactResult,
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import {
-  CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-  isCodexAppServerUnsafeSubscriptionError,
-  settleCodexAppServerClientLease,
-} from "./attempt-client-cleanup.js";
-import { readCodexNotificationItem } from "./attempt-notifications.js";
-import { resolveCodexTurnTerminalIdleTimeoutMs } from "./attempt-timeouts.js";
-import { CodexAppServerRpcError } from "./client.js";
+  defaultLeasedCodexAppServerClientFactory,
+  type CodexAppServerClientFactory,
+} from "./client-factory.js";
 import { resolveCodexAppServerRuntimeOptions } from "./config.js";
-import { isJsonObject, type JsonObject, type JsonValue } from "./protocol.js";
+import type { JsonObject } from "./protocol.js";
 import { resolveCodexNativeExecutionBlock } from "./sandbox-guard.js";
 import {
  CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
-  sessionBindingIdentity,
-  type CodexAppServerBindingIdentity,
-  type CodexAppServerBindingStore,
+  readCodexAppServerBinding,
+  withCodexAppServerBindingLock,
+  writeCodexAppServerBinding,
  type CodexAppServerThreadBinding,
 } from "./session-binding.js";
-import {
-  leaseSharedCodexAppServerClient,
-  type CodexAppServerClientLease,
-  type CodexAppServerClientLeaseFactory,
-  type CodexAppServerClientOptions,
-} from "./shared-client.js";
-import { resumeCodexAppServerThread } from "./thread-resume.js";
-import { withTimeout } from "./timeout.js";
-import {
-  getCodexAppServerTurnRouter,
-  isCodexTerminalTurnNotification,
-  type CodexNativeTurnCompletionWatch,
-  type CodexThreadRouteReservation,
-} from "./turn-router.js";
+import { releaseLeasedSharedCodexAppServerClient } from "./shared-client.js";

+const warnedIgnoredCompactionOverrides = new Set<string>();
 type CodexAppServerCompactOptions = {
-  bindingStore: CodexAppServerBindingStore;
  pluginConfig?: unknown;
-  clientLeaseFactory?: CodexAppServerClientLeaseFactory;
+  clientFactory?: CodexAppServerClientFactory;
  allowNonManualNativeRequest?: boolean;
 };

-class CodexNativeTurnBindingChangedError extends Error {}
-
-type CodexNativeTurnRequest = {
-  bindingStore: CodexAppServerBindingStore;
-  bindingIdentity: CodexAppServerBindingIdentity;
-  expectedBinding: CodexAppServerThreadBinding;
-  pluginConfig?: unknown;
-  authProfileId?: string;
-  agentDir?: string;
-  config?: CodexAppServerClientOptions["config"];
-  abortSignal?: AbortSignal;
-  clientLeaseFactory?: CodexAppServerClientLeaseFactory;
-};
-
-export type CodexNativeTurnKind = "compact" | "review";
-
-/** Starts one native Codex turn and retains its app-server owner through completion. */
-export async function requestCodexNativeTurnForBinding(
-  params: CodexNativeTurnRequest,
-  kind: CodexNativeTurnKind,
-): Promise<void> {
-  const isCompaction = kind === "compact";
-  const label = isCompaction ? "compaction" : "review";
-  const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.pluginConfig });
-  const requestTimeoutMs = Math.min(
-    appServer.requestTimeoutMs,
-    CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
-  );
-  await params.bindingStore.withLease(params.bindingIdentity, async () => {
-    const currentBinding = await params.bindingStore.read(params.bindingIdentity);
-    if (!currentBinding || !isSameNativeTurnBinding(currentBinding, params.expectedBinding)) {
-      throw new CodexNativeTurnBindingChangedError(
-        `Codex thread binding changed before native ${label}`,
-      );
-    }
-    const clientLease = await (params.clientLeaseFactory ?? leaseSharedCodexAppServerClient)({
-      startOptions: appServer.start,
-      authProfileId: params.authProfileId ?? currentBinding.authProfileId,
-      agentDir: params.agentDir,
-      config: params.config,
-      abandonSignal: params.abortSignal,
-      timeoutMs: appServer.requestTimeoutMs,
-    });
-    const client = clientLease.client;
-    let subscribedThreadId: string | undefined;
-    let abandonClient = false;
-    let lifecycleTransferred = false;
-    let awaitingNativeTurnStart = false;
-    const terminalTurnsBeforeWatch = new Set<string>();
-    let route: CodexThreadRouteReservation | undefined;
-    let completionWatch: CodexNativeTurnCompletionWatch | undefined;
-    let observedContextCompaction = false;
-    let bindingInvalidated = false;
-    let resolveNativeTurnStarted!: () => void;
-    const nativeTurnStarted = new Promise<void>((resolve) => {
-      resolveNativeTurnStarted = resolve;
-    });
-    try {
-      const router = getCodexAppServerTurnRouter(client);
-      route = router.reserveThread({
-        threadId: currentBinding.threadId,
-        onNotificationReceived: (notification, scope) => {
-          const contextCompactionStarted =
-            isCompaction &&
-            Boolean(scope.turnId) &&
-            notification.method === "item/started" &&
-            readCodexNotificationItem(notification.params)?.type === "contextCompaction";
-          if (contextCompactionStarted) {
-            observedContextCompaction = true;
-          }
-          if (!awaitingNativeTurnStart || !scope.turnId) {
-            return;
-          }
-          if (isCodexTerminalTurnNotification(notification)) {
-            terminalTurnsBeforeWatch.add(scope.turnId);
-          }
-          if (contextCompactionStarted) {
-            completionWatch ??= router.watchNativeTurnCompletion({
-              threadId: currentBinding.threadId,
-              turnId: scope.turnId,
-              timeoutMs: resolveCodexTurnTerminalIdleTimeoutMs(undefined),
-            });
-            resolveNativeTurnStarted();
-          }
-        },
-        onNotification: () => undefined,
-      });
-      throwIfCodexNativeTurnAborted(params.abortSignal, kind);
-      let resumed;
-      try {
-        subscribedThreadId = currentBinding.threadId;
-        resumed = await resumeCodexAppServerThread({
-          client,
-          abandonClient: clientLease.abandon,
-          request: {
-            threadId: currentBinding.threadId,
-            excludeTurns: true,
-            persistExtendedHistory: true,
-          },
-          timeoutMs: requestTimeoutMs,
-          signal: params.abortSignal,
-        });
-      } catch (error) {
-        abandonClient = isCodexAppServerUnsafeSubscriptionError(error);
-        throw error;
-      }
-      const invalidateNativeContextBinding = async () => {
-        if (bindingInvalidated) {
-          return;
-        }
-        const invalidated = await params.bindingStore.mutate(params.bindingIdentity, {
-          kind: "invalidate-native-context",
-          threadId: currentBinding.threadId,
-          ...(isCompaction ? { invalidateContextEngineProjection: true as const } : {}),
-        });
-        if (!invalidated) {
-          throw new CodexNativeTurnBindingChangedError(
-            `Codex thread binding changed before native ${label}`,
-          );
-        }
-        bindingInvalidated = true;
-      };
-      if (isCompaction && observedContextCompaction) {
-        await invalidateNativeContextBinding();
-      }
-      if (resumed.thread.status?.type === "active") {
-        throw new Error(
-          `Codex thread already has an active turn; retry ${label} after it finishes`,
-        );
-      }
-      throwIfCodexNativeTurnAborted(params.abortSignal, kind);
-      await invalidateNativeContextBinding();
-      awaitingNativeTurnStart = true;
-      let requestResult: JsonValue | undefined;
-      try {
-        requestResult = await client.request(
-          isCompaction ? "thread/compact/start" : "review/start",
-          isCompaction
-            ? { threadId: currentBinding.threadId }
-            : { threadId: currentBinding.threadId, target: { type: "uncommittedChanges" } },
-          { timeoutMs: requestTimeoutMs },
-        );
-      } catch (error) {
-        const requestRejected = error instanceof CodexAppServerRpcError;
-        if (requestRejected) {
-          // A structured rejection proves this request did not start a native
-          // turn. Preserve only compaction already observed on the same thread.
-          completionWatch?.cancel();
-          completionWatch = undefined;
-          if (!isCompaction || !observedContextCompaction) {
-            const restored = await params.bindingStore.mutate(params.bindingIdentity, {
-              kind: "set",
-              binding: currentBinding,
-            });
-            if (!restored) {
-              throw new Error(`Codex thread binding changed after native ${label} was rejected`, {
-                cause: error,
-              });
-            }
-          }
-          throw error;
-        }
-        if (completionWatch) {
-          embeddedAgentLog.debug(`codex app-server ${kind} request failed after startup`, {
-            threadId: currentBinding.threadId,
-            error,
-          });
-        } else {
-          abandonClient = true;
-          throw error;
-        }
-      }
-      if (!isCompaction) {
-        try {
-          const review = assertCodexReviewStartResponse(requestResult);
-          if (review.reviewThreadId !== currentBinding.threadId) {
-            throw new Error(
-              `Codex review/start returned ${review.reviewThreadId} for inline review on ${currentBinding.threadId}`,
-            );
-          }
-          completionWatch = terminalTurnsBeforeWatch.has(review.turnId)
-            ? { completion: Promise.resolve(true), cancel: () => undefined }
-            : router.watchNativeTurnCompletion({
-                threadId: currentBinding.threadId,
-                turnId: review.turnId,
-                timeoutMs: resolveCodexTurnTerminalIdleTimeoutMs(undefined),
-              });
-        } catch (error) {
-          abandonClient = true;
-          throw error;
-        }
-      } else if (!completionWatch) {
-        try {
-          await waitForCodexNativeTurnStart({
-            started: nativeTurnStarted,
-            routeSignal: route.signal,
-            timeoutMs: requestTimeoutMs,
-            threadId: currentBinding.threadId,
-            kind,
-          });
-        } catch (error) {
-          // Codex accepted Op::Compact, so missing startup confirmation is
-          // ambiguous. Keep facts invalidated and retire this connection.
-          abandonClient = true;
-          throw error;
-        }
-      }
-      awaitingNativeTurnStart = false;
-      route.release();
-      route = undefined;
-      const transferredWatch = completionWatch;
-      if (!transferredWatch) {
-        abandonClient = true;
-        throw new Error(
-          `codex app-server ${kind} turn started without a turn id for thread ${currentBinding.threadId}`,
-        );
-      }
-      completionWatch = undefined;
-      lifecycleTransferred = true;
-      monitorCodexNativeTurn({
-        completionWatch: transferredWatch,
-        clientLease,
-        subscribedThreadId,
-        threadId: currentBinding.threadId,
-        kind,
-      });
-    } finally {
-      if (!lifecycleTransferred) {
-        completionWatch?.cancel();
-        route?.release();
-        await settleCodexAppServerClientLease(clientLease, {
-          threadId: subscribedThreadId,
-          timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-          abandon: abandonClient,
-        });
-      }
-    }
-  });
-}
-
-function assertCodexReviewStartResponse(value: JsonValue | undefined): {
-  turnId: string;
-  reviewThreadId: string;
-} {
-  if (
-    !isJsonObject(value) ||
-    !isJsonObject(value.turn) ||
-    typeof value.turn.id !== "string" ||
-    !value.turn.id.trim() ||
-    typeof value.reviewThreadId !== "string" ||
-    !value.reviewThreadId.trim()
-  ) {
-    throw new Error("invalid Codex review/start response");
-  }
-  return { turnId: value.turn.id, reviewThreadId: value.reviewThreadId };
-}
-
-function monitorCodexNativeTurn(params: {
-  completionWatch: CodexNativeTurnCompletionWatch;
-  clientLease: CodexAppServerClientLease;
-  subscribedThreadId?: string;
-  threadId: string;
-  kind: CodexNativeTurnKind;
-}): void {
-  void (async () => {
-    const completed = await params.completionWatch.completion;
-    await settleCodexAppServerClientLease(params.clientLease, {
-      threadId: params.subscribedThreadId,
-      timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-      abandon: !completed,
-    });
-    if (!completed) {
-      embeddedAgentLog.warn(`codex app-server ${params.kind} turn lost terminal confirmation`, {
-        threadId: params.threadId,
-      });
-    }
-  })().catch(async (error: unknown) => {
-    await params.clientLease.abandon().catch(() => undefined);
-    embeddedAgentLog.warn(`codex app-server ${params.kind} turn cleanup failed`, {
-      threadId: params.threadId,
-      error,
-    });
-  });
-}
-
-function throwIfCodexNativeTurnAborted(
-  signal: AbortSignal | undefined,
-  kind: CodexNativeTurnKind,
-): void {
-  if (!signal?.aborted) {
-    return;
-  }
-  if (signal.reason instanceof Error) {
-    throw signal.reason;
-  }
-  throw new Error(`codex app-server ${kind} aborted before native turn startup`, {
-    cause: signal.reason,
-  });
-}
-
-async function waitForCodexNativeTurnStart(params: {
-  started: Promise<void>;
-  routeSignal: AbortSignal;
-  timeoutMs: number;
-  threadId: string;
-  kind: CodexNativeTurnKind;
-}): Promise<void> {
-  const signal = params.routeSignal;
-  let removeAbort: (() => void) | undefined;
-  const aborted = new Promise<never>((_resolve, reject) => {
-    const onAbort = () => reject(asNativeTurnAbortError(signal));
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbort = () => signal.removeEventListener("abort", onAbort);
-    if (signal.aborted) {
-      onAbort();
-    }
-  });
-  try {
-    await withTimeout(
-      Promise.race([params.started, aborted]),
-      params.timeoutMs,
-      `codex app-server ${params.kind} turn did not start for thread ${params.threadId}`,
-    );
-  } finally {
-    removeAbort?.();
-  }
-}
-
-function asNativeTurnAbortError(signal: AbortSignal): Error {
-  return signal.reason instanceof Error
-    ? signal.reason
-    : new Error("codex app-server native turn startup aborted", { cause: signal.reason });
-}
-
 /**
 * Starts native Codex compaction for a manually requested bound session, or
 * reports why Codex-owned automatic compaction should handle the trigger.
 */
 export async function maybeCompactCodexAppServerSession(
  params: CompactEmbeddedAgentSessionParams,
-  options: CodexAppServerCompactOptions,
+  options: CodexAppServerCompactOptions = {},
 ): Promise<EmbeddedAgentCompactResult | undefined> {
+  warnIfIgnoringOpenClawCompactionOverrides(params);
  // Codex owns automatic context-pressure compaction for Codex runtime sessions.
  // This entry point starts native Codex compaction for the bound thread and
  // returns immediately; Codex applies the compaction inside its app-server.
  return compactCodexNativeThread(params, options);
 }

+function warnIfIgnoringOpenClawCompactionOverrides(
+  params: CompactEmbeddedAgentSessionParams,
+): void {
+  const ignoredConfig = readIgnoredCompactionOverridePaths(params);
+  if (ignoredConfig.length === 0) {
+    return;
+  }
+  const warningKey = ignoredConfig.join("\0");
+  if (warnedIgnoredCompactionOverrides.has(warningKey)) {
+    return;
+  }
+  warnedIgnoredCompactionOverrides.add(warningKey);
+  embeddedAgentLog.warn(
+    "ignoring OpenClaw compaction overrides for Codex app-server compaction; Codex uses native server-side compaction",
+    {
+      sessionId: params.sessionId,
+      sessionKey: params.sessionKey,
+      ignoredConfig,
+    },
+  );
+}
+
+function readIgnoredCompactionOverridePaths(params: CompactEmbeddedAgentSessionParams): string[] {
+  const ignored = new Set<string>();
+  for (const entry of readCompactionOverrideEntries(params)) {
+    const localProvider =
+      typeof entry.record.provider === "string" ? entry.record.provider.trim() : "";
+    const inheritedProvider =
+      !localProvider && typeof entry.inheritedRecord?.provider === "string"
+        ? entry.inheritedRecord.provider.trim()
+        : "";
+    const providerPath = localProvider
+      ? `${entry.path}.compaction.provider`
+      : inheritedProvider && entry.inheritedPath
+        ? `${entry.inheritedPath}.compaction.provider`
+        : undefined;
+    if (typeof entry.record.model === "string" && entry.record.model.trim()) {
+      ignored.add(`${entry.path}.compaction.model`);
+    }
+    if (providerPath) {
+      ignored.add(providerPath);
+    }
+  }
+  return [...ignored];
+}
+
+function readCompactionOverrideEntries(params: CompactEmbeddedAgentSessionParams): Array<{
+  path: string;
+  record: Record<string, unknown>;
+  inheritedRecord?: Record<string, unknown>;
+  inheritedPath?: string;
+}> {
+  const entries: Array<{
+    path: string;
+    record: Record<string, unknown>;
+    inheritedRecord?: Record<string, unknown>;
+    inheritedPath?: string;
+  }> = [];
+  const defaultCompaction = readRecord(readRecord(params.config?.agents)?.defaults)?.compaction;
+  const defaultRecord = readRecord(defaultCompaction);
+  if (defaultRecord) {
+    entries.push({ path: "agents.defaults", record: defaultRecord });
+  }
+  const agentId = readAgentIdFromSessionKey(params.sessionKey ?? params.sandboxSessionKey);
+  if (!agentId) {
+    return entries;
+  }
+  const agents = Array.isArray(params.config?.agents?.list) ? params.config.agents.list : [];
+  const activeAgent = agents.find((agent) => {
+    const id = typeof agent?.id === "string" ? agent.id.trim().toLowerCase() : "";
+    return id === agentId;
+  });
+  const agentCompaction = readRecord(activeAgent)?.compaction;
+  const agentRecord = readRecord(agentCompaction);
+  if (agentRecord) {
+    entries.push({
+      path: `agents.list.${agentId}`,
+      record: agentRecord,
+      inheritedRecord: defaultRecord,
+      inheritedPath: "agents.defaults",
+    });
+  }
+  return entries;
+}
+
+function readAgentIdFromSessionKey(sessionKey: string | undefined): string | undefined {
+  const parts = sessionKey?.trim().toLowerCase().split(":").filter(Boolean) ?? [];
+  if (parts.length < 3 || parts[0] !== "agent") {
+    return undefined;
+  }
+  return parts[1]?.trim() || undefined;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
 async function compactCodexNativeThread(
  params: CompactEmbeddedAgentSessionParams,
-  options: CodexAppServerCompactOptions,
+  options: CodexAppServerCompactOptions = {},
 ): Promise<EmbeddedAgentCompactResult | undefined> {
  if (params.trigger !== "manual" && !options.allowNonManualNativeRequest) {
    embeddedAgentLog.info("skipping codex app-server compaction for non-manual trigger", {
@@ -423,7 +172,6 @@ async function compactCodexNativeThread(
  }
  const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
    config: params.config,
-    agentId: params.agentId,
    sessionKey: params.sandboxSessionKey ?? params.sessionKey,
    sessionId: params.sessionId,
    surface: "native compaction",
@@ -431,20 +179,17 @@ async function compactCodexNativeThread(
  if (nativeExecutionBlock) {
    return { ok: false, compacted: false, reason: nativeExecutionBlock };
  }
-  const bindingIdentity: CodexAppServerBindingIdentity = sessionBindingIdentity({
-    sessionId: params.sessionId,
-    sessionKey: params.sessionKey,
-    agentId: params.agentId,
+  const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+  const initialBinding = await readCodexAppServerBinding(params.sessionFile, {
    config: params.config,
  });
-  const initialBinding = await options.bindingStore.read(bindingIdentity);
  if (!initialBinding?.threadId) {
    return failedCodexThreadBindingCompactionResult(params, {
      reason: "no codex app-server thread binding",
      recovery: "missing_thread_binding",
    });
  }
-  const binding = initialBinding;
+  let binding = initialBinding;
  const requestedAuthProfileId = params.authProfileId?.trim() || undefined;
  if (
    requestedAuthProfileId &&
@@ -455,42 +200,85 @@ async function compactCodexNativeThread(
    // with another profile risks operating on a different Codex account.
    return { ok: false, compacted: false, reason: "auth profile mismatch for session binding" };
  }
-  if (options.allowNonManualNativeRequest && params.abortSignal?.aborted) {
-    const currentBinding = await options.bindingStore.read(bindingIdentity);
-    return skippedCodexNativeCompactionResult(params, {
-      reason: "codex app-server compaction aborted before native compaction",
-      code: "aborted_before_native_compaction",
-      expectedThreadId: binding.threadId,
-      currentThreadId: currentBinding?.threadId,
-    });
-  }
+  const shouldReleaseDefaultLease = !options.clientFactory;
+  const clientFactory = options.clientFactory ?? defaultLeasedCodexAppServerClientFactory;
+  const client = await clientFactory(
+    appServer.start,
+    requestedAuthProfileId ?? binding.authProfileId,
+    params.agentDir,
+    params.config,
+  );
  try {
-    await requestCodexNativeTurnForBinding(
-      {
-        bindingIdentity,
-        bindingStore: options.bindingStore,
-        expectedBinding: binding,
-        pluginConfig: options.pluginConfig,
-        authProfileId: requestedAuthProfileId,
-        agentDir: params.agentDir,
-        config: params.config,
-        abortSignal: params.abortSignal,
-        clientLeaseFactory: options.clientLeaseFactory,
-      },
-      "compact",
-    );
+    if (options.allowNonManualNativeRequest) {
+      const guardedResult = await withCodexAppServerBindingLock(params.sessionFile, async () => {
+        const currentBinding = await readCodexAppServerBinding(params.sessionFile, {
+          config: params.config,
+        });
+        if (params.abortSignal?.aborted) {
+          return {
+            started: false as const,
+            result: skippedCodexNativeCompactionResult(params, {
+              reason: "codex app-server compaction aborted before native compaction",
+              code: "aborted_before_native_compaction",
+              expectedThreadId: binding.threadId,
+              currentThreadId: currentBinding?.threadId,
+            }),
+          };
+        }
+        if (!currentBinding || !isSameNativeCompactionBinding(currentBinding, binding)) {
+          embeddedAgentLog.warn(
+            "skipping codex app-server compaction because the thread binding changed",
+            {
+              sessionId: params.sessionId,
+              sessionKey: params.sessionKey,
+              expectedThreadId: binding.threadId,
+              currentThreadId: currentBinding?.threadId,
+            },
+          );
+          return {
+            started: false as const,
+            result: skippedCodexNativeCompactionResult(params, {
+              reason: "codex app-server binding changed before native compaction",
+              code: "binding_changed_before_native_compaction",
+              expectedThreadId: binding.threadId,
+              currentThreadId: currentBinding?.threadId,
+            }),
+          };
+        }
+        binding = currentBinding;
+        await clearContextEngineProjectionBeforeNativeCompaction({
+          sessionId: params.sessionId,
+          sessionFile: params.sessionFile,
+          binding,
+          config: params.config,
+        });
+        await client.request(
+          "thread/compact/start",
+          {
+            threadId: binding.threadId,
+          },
+          {
+            timeoutMs: Math.min(
+              appServer.requestTimeoutMs,
+              CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
+            ),
+          },
+        );
+        return { started: true as const };
+      });
+      if (!guardedResult.started) {
+        return guardedResult.result;
+      }
+    } else {
+      await client.request("thread/compact/start", {
+        threadId: binding.threadId,
+      });
+    }
    embeddedAgentLog.info("started codex app-server compaction", {
      sessionId: params.sessionId,
      threadId: binding.threadId,
    });
  } catch (error) {
-    if (
-      options.allowNonManualNativeRequest &&
-      error instanceof CodexNativeTurnBindingChangedError
-    ) {
-      const latestBinding = await options.bindingStore.read(bindingIdentity);
-      return skippedBindingChangeResult(params, binding.threadId, latestBinding?.threadId);
-    }
    if (isCodexThreadNotFoundError(error)) {
      return failedCodexThreadBindingCompactionResult(params, {
        threadId: binding.threadId,
@@ -509,6 +297,10 @@ async function compactCodexNativeThread(
      compacted: false,
      reason: formatCompactionError(error),
    };
+  } finally {
+    if (shouldReleaseDefaultLease) {
+      releaseLeasedSharedCodexAppServerClient(client);
+    }
  }
  const resultDetails: JsonObject = {
    backend: "codex-app-server",
@@ -534,25 +326,6 @@ async function compactCodexNativeThread(
  };
 }

-function skippedBindingChangeResult(
-  params: CompactEmbeddedAgentSessionParams,
-  expectedThreadId: string,
-  currentThreadId: string | undefined,
-): EmbeddedAgentCompactResult {
-  embeddedAgentLog.warn("skipping codex app-server compaction because the thread binding changed", {
-    sessionId: params.sessionId,
-    sessionKey: params.sessionKey,
-    expectedThreadId,
-    currentThreadId,
-  });
-  return skippedCodexNativeCompactionResult(params, {
-    reason: "codex app-server binding changed before native compaction",
-    code: "binding_changed_before_native_compaction",
-    expectedThreadId,
-    currentThreadId,
-  });
-}
-
 function skippedCodexNativeCompactionResult(
  params: CompactEmbeddedAgentSessionParams,
  skipped: {
@@ -609,7 +382,39 @@ function failedCodexThreadBindingCompactionResult(
  };
 }

-function isSameNativeTurnBinding(
+async function clearContextEngineProjectionBeforeNativeCompaction(params: {
+  sessionId: string;
+  sessionFile: string;
+  binding: CodexAppServerThreadBinding;
+  config: CompactEmbeddedAgentSessionParams["config"];
+}): Promise<void> {
+  const contextEngineBinding = params.binding.contextEngine;
+  if (!contextEngineBinding?.projection) {
+    return;
+  }
+  // Native Codex compaction mutates the thread history outside the projection
+  // guard. Clear only the projection marker so the next turn reprojects context.
+  await writeCodexAppServerBinding(
+    params.sessionFile,
+    {
+      ...params.binding,
+      contextEngine: {
+        ...contextEngineBinding,
+        projection: undefined,
+      },
+      createdAt: params.binding.createdAt,
+    },
+    { config: params.config },
+  );
+  embeddedAgentLog.info("cleared codex context-engine projection before native compaction", {
+    sessionId: params.sessionId,
+    threadId: params.binding.threadId,
+    previousEpoch: contextEngineBinding.projection.epoch,
+    previousFingerprint: contextEngineBinding.projection.fingerprint,
+  });
+}
+
+function isSameNativeCompactionBinding(
  current: CodexAppServerThreadBinding,
  expected: CodexAppServerThreadBinding,
 ): boolean {
--- a/extensions/codex/src/app-server/config.test.ts
+++ b/extensions/codex/src/app-server/config.test.ts
@@ -1,7 +1,5 @@
 // Codex tests cover config plugin behavior.
 import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";
 import { describe, expect, it, vi } from "vitest";
 import {
@@ -202,7 +200,7 @@ describe("Codex app-server config", () => {
              },
              unix_sockets: {
                "/tmp/mock-proxy.sock": "allow",
-                "/tmp/blocked.sock": "deny",
+                "/tmp/blocked.sock": "none",
              },
              proxy_url: "http://127.0.0.1:3128",
              socks_url: "socks5h://127.0.0.1:8081",
@@ -560,6 +558,7 @@ describe("Codex app-server config", () => {
    const switchedLocalModel = resolveCodexModelBackedReviewerPolicyContext({
      model: "lmstudio/local-model",
      bindingModel: "gpt-5.5",
+      nativeAuthProfile: true,
    });
    expect(switchedLocalModel).toEqual({
      modelProvider: "lmstudio",
@@ -746,39 +745,6 @@ describe("Codex app-server config", () => {
    });
  });

-  it("reloads Codex config.toml policy when Codex can reload it", async () => {
-    const agentDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-config-"));
-    const codexHome = path.join(agentDir, "codex-home");
-    const configPath = path.join(codexHome, "config.toml");
-    await fs.mkdir(codexHome);
-    try {
-      await fs.writeFile(configPath, 'openai_base_url = "http://localhost:8080/v1"\n');
-      const context = { modelProvider: "openai", model: "gpt-5.5", agentDir };
-      expect(canUseCodexModelBackedApprovalsReviewerForModel(context)).toBe(false);
-
-      await fs.writeFile(configPath, 'openai_base_url = "https://api.openai.com/v1"\n');
-      expect(canUseCodexModelBackedApprovalsReviewerForModel(context)).toBe(true);
-    } finally {
-      await fs.rm(agentDir, { recursive: true, force: true });
-    }
-  });
-
-  it("observes a Codex config.toml created after the first policy check", async () => {
-    const agentDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-config-"));
-    const codexHome = path.join(agentDir, "codex-home");
-    const configPath = path.join(codexHome, "config.toml");
-    await fs.mkdir(codexHome);
-    try {
-      const context = { modelProvider: "openai", model: "gpt-5.5", agentDir };
-      expect(canUseCodexModelBackedApprovalsReviewerForModel(context)).toBe(true);
-
-      await fs.writeFile(configPath, 'openai_base_url = "http://localhost:8080/v1"\n');
-      expect(canUseCodexModelBackedApprovalsReviewerForModel(context)).toBe(false);
-    } finally {
-      await fs.rm(agentDir, { recursive: true, force: true });
-    }
-  });
-
  it("forces prompting when explicit no-prompt config cannot use model-backed review", () => {
    const runtime = resolveRuntimeForTest({
      pluginConfig: {
@@ -976,8 +942,8 @@ allowed_sandbox_modes = ["read-only", "workspace-write"]
      env: {},
      modelProvider: "openai",
      requirementsPath: "/custom/codex/requirements.toml",
-      readRequirementsFile: (requirementsPath) => {
-        readPaths.push(requirementsPath);
+      readRequirementsFile: (path) => {
+        readPaths.push(path);
        return 'allowed_sandbox_modes = ["read-only", "workspace-write"]\n';
      },
    });
@@ -997,8 +963,8 @@ allowed_sandbox_modes = ["read-only", "workspace-write"]
      env: { ProgramData: "D:\\ManagedData" },
      modelProvider: "openai",
      platform: "win32",
-      readRequirementsFile: (requirementsPath) => {
-        readPaths.push(requirementsPath);
+      readRequirementsFile: (path) => {
+        readPaths.push(path);
        return 'allowed_sandbox_modes = ["read-only", "workspace-write"]\n';
      },
    });
--- a/extensions/codex/src/app-server/config.ts
+++ b/extensions/codex/src/app-server/config.ts
@@ -192,11 +192,6 @@ export type CodexAppServerRuntimeOptions = {
  networkProxy?: ResolvedCodexAppServerNetworkProxyConfig;
 };

-export type CodexAppServerRuntimeResolution = {
-  appServer: CodexAppServerRuntimeOptions;
-  modelBackedReviewerAvailable: boolean;
-};
-
 export type CodexModelBackedReviewerContext = {
  modelProvider?: string;
  model?: string;
@@ -337,9 +332,7 @@ const codexAppServerNetworkProxySchema = z
    baseProfile: z.enum(["read-only", "workspace"]).optional(),
    mode: z.enum(["limited", "full"]).optional(),
    domains: z.record(z.string(), codexAppServerNetworkProxyDomainPermissionSchema).optional(),
-    unixSockets: z
-      .record(z.string(), codexAppServerNetworkProxyUnixSocketPermissionSchema)
-      .optional(),
+    unixSockets: z.record(z.string(), codexAppServerNetworkProxyUnixSocketPermissionSchema).optional(),
    proxyUrl: z.string().trim().min(1).optional(),
    socksUrl: z.string().trim().min(1).optional(),
    enableSocks5: z.boolean().optional(),
@@ -508,34 +501,25 @@ function resolveCodexPluginDestructivePolicy(policy: CodexPluginDestructivePolic
  };
 }

-type CodexAppServerRuntimeParams = {
-  pluginConfig?: unknown;
-  execMode?: OpenClawExecMode;
-  execPolicy?: OpenClawExecPolicyForCodexAppServer;
-  modelProvider?: string;
-  model?: string;
-  config?: ProviderAuthAliasConfig;
-  env?: NodeJS.ProcessEnv;
-  agentDir?: string;
-  codexConfigToml?: string | null;
-  requirementsToml?: string | null;
-  requirementsPath?: string;
-  readRequirementsFile?: (path: string) => string | undefined;
-  platform?: NodeJS.Platform;
-  hostName?: string;
-  openClawSandboxActive?: boolean;
-};
-
 export function resolveCodexAppServerRuntimeOptions(
-  params: CodexAppServerRuntimeParams = {},
+  params: {
+    pluginConfig?: unknown;
+    execMode?: OpenClawExecMode;
+    execPolicy?: OpenClawExecPolicyForCodexAppServer;
+    modelProvider?: string;
+    model?: string;
+    config?: ProviderAuthAliasConfig;
+    env?: NodeJS.ProcessEnv;
+    agentDir?: string;
+    codexConfigToml?: string | null;
+    requirementsToml?: string | null;
+    requirementsPath?: string;
+    readRequirementsFile?: (path: string) => string | undefined;
+    platform?: NodeJS.Platform;
+    hostName?: string;
+    openClawSandboxActive?: boolean;
+  } = {},
 ): CodexAppServerRuntimeOptions {
-  return resolveCodexAppServerRuntime(params).appServer;
-}
-
-/** Resolves runtime options and the model-policy fact computed with them. */
-export function resolveCodexAppServerRuntime(
-  params: CodexAppServerRuntimeParams = {},
-): CodexAppServerRuntimeResolution {
  const env = params.env ?? process.env;
  const config = readCodexPluginConfig(params.pluginConfig).appServer ?? {};
  const transport = resolveTransport(config.transport);
@@ -675,46 +659,43 @@ export function resolveCodexAppServerRuntime(
        : "implicit";

  return {
-    modelBackedReviewerAvailable: canUseModelBackedReviewer,
-    appServer: {
-      start: {
-        transport,
-        command,
-        commandSource,
-        args: args.length > 0 ? args : ["app-server", "--listen", "stdio://"],
-        ...(url ? { url } : {}),
-        ...(authToken ? { authToken } : {}),
-        headers,
-        ...(transport === "stdio" && clearEnv.length > 0 ? { clearEnv } : {}),
-      },
-      connectionClass,
-      remoteAppsSubstrate,
-      ...(remoteWorkspaceRoot ? { remoteWorkspaceRoot } : {}),
-      codeModeOnly: config.codeModeOnly === true,
-      requestTimeoutMs: normalizePositiveNumber(config.requestTimeoutMs, 60_000),
-      turnCompletionIdleTimeoutMs: normalizePositiveNumber(
-        config.turnCompletionIdleTimeoutMs,
-        60_000,
-      ),
-      ...(config.postToolRawAssistantCompletionIdleTimeoutMs !== undefined
-        ? {
-            postToolRawAssistantCompletionIdleTimeoutMs: normalizePositiveNumber(
-              config.postToolRawAssistantCompletionIdleTimeoutMs,
-              60_000,
-            ),
-          }
-        : {}),
-      approvalPolicy: forcedPolicy?.approvalPolicy ?? approvalPolicy,
-      approvalPolicySource,
-      sandbox: resolvedSandbox,
-      approvalsReviewer:
-        forcedPolicy?.approvalsReviewer ??
-        explicitApprovalsReviewer ??
-        defaultPolicy?.approvalsReviewer ??
-        (policyMode === "guardian" ? "auto_review" : "user"),
-      ...resolveCodexAppServerNetworkProxy(config.networkProxy, resolvedSandbox),
-      ...(serviceTier ? { serviceTier } : {}),
+    start: {
+      transport,
+      command,
+      commandSource,
+      args: args.length > 0 ? args : ["app-server", "--listen", "stdio://"],
+      ...(url ? { url } : {}),
+      ...(authToken ? { authToken } : {}),
+      headers,
+      ...(transport === "stdio" && clearEnv.length > 0 ? { clearEnv } : {}),
    },
+    connectionClass,
+    remoteAppsSubstrate,
+    ...(remoteWorkspaceRoot ? { remoteWorkspaceRoot } : {}),
+    codeModeOnly: config.codeModeOnly === true,
+    requestTimeoutMs: normalizePositiveNumber(config.requestTimeoutMs, 60_000),
+    turnCompletionIdleTimeoutMs: normalizePositiveNumber(
+      config.turnCompletionIdleTimeoutMs,
+      60_000,
+    ),
+    ...(config.postToolRawAssistantCompletionIdleTimeoutMs !== undefined
+      ? {
+          postToolRawAssistantCompletionIdleTimeoutMs: normalizePositiveNumber(
+            config.postToolRawAssistantCompletionIdleTimeoutMs,
+            60_000,
+          ),
+        }
+      : {}),
+    approvalPolicy: forcedPolicy?.approvalPolicy ?? approvalPolicy,
+    approvalPolicySource,
+    sandbox: resolvedSandbox,
+    approvalsReviewer:
+      forcedPolicy?.approvalsReviewer ??
+      explicitApprovalsReviewer ??
+      defaultPolicy?.approvalsReviewer ??
+      (policyMode === "guardian" ? "auto_review" : "user"),
+    ...(serviceTier ? { serviceTier } : {}),
+    ...resolveCodexAppServerNetworkProxy(config.networkProxy, resolvedSandbox),
  };
 }

@@ -786,6 +767,7 @@ export function resolveCodexModelBackedReviewerPolicyContext(params: {
  model?: string;
  bindingModelProvider?: string;
  bindingModel?: string;
+  nativeAuthProfile?: boolean;
 }): CodexModelBackedReviewerContext {
  const provider = params.provider?.trim();
  if (provider && provider.toLowerCase() !== "codex") {
@@ -817,7 +799,7 @@ export function resolveCodexModelBackedReviewerPolicyContext(params: {
    };
  }
  return {
-    modelProvider: undefined,
+    modelProvider: params.nativeAuthProfile === true ? "openai" : undefined,
    model: params.model ?? params.bindingModel,
  };
 }
@@ -884,7 +866,6 @@ export function codexAppServerStartOptionsKey(
  options: CodexAppServerStartOptions,
  params: {
    authProfileId?: string;
-    authAccountCacheKey?: string;
    agentDir?: string;
    fallbackApiKeyCacheKey?: string;
  } = {},
@@ -904,7 +885,6 @@ export function codexAppServerStartOptionsKey(
      .map(([key, value]) => [key, hashSecretForKey(value, `env:${key}`)]),
    clearEnv: [...(options.clearEnv ?? [])].toSorted(),
    authProfileId: params.authProfileId ?? null,
-    authAccountCacheKey: params.authAccountCacheKey ?? null,
    agentDir: params.agentDir ?? null,
    fallbackApiKeyCacheKey: params.fallbackApiKeyCacheKey ?? null,
  });
@@ -944,7 +924,7 @@ function resolveCodexAppServerNetworkProxy(
    enabled: true,
    mode: config.mode,
    domains: normalizeNetworkProxyPermissionMap(config.domains),
-    unix_sockets: normalizeNetworkProxyUnixSocketPermissionMap(config.unixSockets),
+    unix_sockets: normalizeNetworkProxyPermissionMap(config.unixSockets),
    proxy_url: readNonEmptyString(config.proxyUrl),
    socks_url: readNonEmptyString(config.socksUrl),
    enable_socks5: config.enableSocks5,
@@ -999,20 +979,6 @@ export function fingerprintCodexAppServerNetworkProxyConfigPatch(configPatch: Js
  return createHash("sha256").update(stableStringifyJson(configPatch)).digest("hex");
 }

-function normalizeNetworkProxyUnixSocketPermissionMap(
-  value: Record<string, CodexAppServerNetworkProxyUnixSocketPermission> | undefined,
-): Record<string, "allow" | "deny"> | undefined {
-  const normalized = normalizeNetworkProxyPermissionMap(value);
-  return normalized
-    ? Object.fromEntries(
-        Object.entries(normalized).map(([socketPath, permission]) => [
-          socketPath,
-          permission === "none" ? "deny" : permission,
-        ]),
-      )
-    : undefined;
-}
-
 function normalizeNetworkProxyPermissionMap<TPermission extends string>(
  value: Record<string, TPermission> | undefined,
 ): Record<string, TPermission> | undefined {
--- a/extensions/codex/src/app-server/dynamic-tool-build.test.ts
+++ b/extensions/codex/src/app-server/dynamic-tool-build.test.ts
@@ -11,10 +11,11 @@ import {
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
  addSandboxShellDynamicToolsIfAvailable,
+  buildDynamicTools,
  filterCodexDynamicToolsForAllowlist,
  hasWildcardCodexToolsAllow,
  includeForcedCodexDynamicToolAllow,
-  prepareDynamicToolCatalog,
+  mapCodexAppServerRemoteWorkspacePath,
  resetOpenClawCodingToolsFactoryForTests,
  resolveCodexAppServerExecutionCwd,
  resolveOpenClawCodingToolsSessionKeys,
@@ -22,7 +23,6 @@ import {
  setOpenClawCodingToolsFactoryForTests,
  shouldEnableCodexAppServerNativeToolSurface,
  shouldForceMessageTool,
-  type OpenClawCodingToolsFactory,
 } from "./dynamic-tool-build.js";
 import {
  filterCodexDynamicTools,
@@ -106,13 +106,13 @@ function createRuntimeDynamicTool(name: string): RuntimeDynamicToolForTest {
 async function buildDynamicToolsForTest(
  params: EmbeddedRunAttemptParams,
  workspaceDir: string,
-  options: Partial<Parameters<typeof prepareDynamicToolCatalog>[0]> = {},
+  options: Partial<Parameters<typeof buildDynamicTools>[0]> = {},
 ) {
  const sandboxSessionKey = params.sessionKey;
  if (!sandboxSessionKey) {
    throw new Error("createParams must provide a sessionKey for Codex dynamic tool tests.");
  }
-  const catalog = await prepareDynamicToolCatalog({
+  return buildDynamicTools({
    params,
    resolvedWorkspace: workspaceDir,
    effectiveWorkspace: workspaceDir,
@@ -125,7 +125,6 @@ async function buildDynamicToolsForTest(
    onYieldDetected: () => undefined,
    ...options,
  });
-  return catalog.tools;
 }

 describe("Codex app-server dynamic tool build", () => {
@@ -228,51 +227,197 @@ describe("Codex app-server dynamic tool build", () => {
    ]);
  });

-  it("prepares runtime and durable tool views from one OpenClaw catalog", async () => {
-    const messageTool = createRuntimeDynamicTool("message");
-    const webSearchTool = createRuntimeDynamicTool("web_search");
-    const heartbeatTool = createRuntimeDynamicTool("heartbeat_respond");
-    const factory = vi.fn<OpenClawCodingToolsFactory>((options) => [
-      messageTool,
-      webSearchTool,
-      ...(options?.enableHeartbeatTool ? [heartbeatTool] : []),
-    ]);
-    setOpenClawCodingToolsFactoryForTests(factory);
-    const sessionFile = path.join(tempDir, "session.jsonl");
+  it("removes managed web_search when domain-restricted Codex hosted search is active", async () => {
    const workspaceDir = path.join(tempDir, "workspace");
-    const params = createParams(sessionFile, workspaceDir);
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
    params.disableTools = false;
-    const runtimePlan = createCodexRuntimePlanFixture();
-    params.runtimePlan = {
-      ...runtimePlan,
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.config = {
      tools: {
-        normalize: (tools: Array<{ name: string }>) =>
-          tools.filter((tool) => tool.name === "message"),
-        logDiagnostics: () => undefined,
+        web: {
+          search: { openaiCodex: { allowedDomains: ["example.com"] } },
+        },
      },
-    } as unknown as NonNullable<EmbeddedRunAttemptParams["runtimePlan"]>;
+    } as never;
+    setOpenClawCodingToolsFactoryForTests(() => [
+      createRuntimeDynamicTool("web_search"),
+      createRuntimeDynamicTool("message"),
+    ]);
+    let webSearchAllowed = false;

-    const catalog = await prepareDynamicToolCatalog({
-      params,
-      resolvedWorkspace: workspaceDir,
-      effectiveWorkspace: workspaceDir,
-      sandboxSessionKey: params.sessionKey ?? "agent:main:session-1",
-      sandbox: { enabled: false, backendId: "docker" } as never,
-      nativeToolSurfaceEnabled: true,
-      runAbortController: new AbortController(),
-      sessionAgentId: "main",
-      pluginConfig: {},
-      onYieldDetected: () => undefined,
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      onWebSearchPolicyResolved: (allowed) => {
+        webSearchAllowed = allowed;
+      },
    });

-    expect(factory).toHaveBeenCalledTimes(1);
-    expect(factory.mock.calls[0]?.[0]?.enableHeartbeatTool).toBe(true);
-    expect(catalog.tools.map((tool) => tool.name)).toEqual(["message"]);
-    expect(catalog.registeredTools.map((tool) => tool.name)).toEqual([
-      "message",
-      "web_search",
-      "heartbeat_respond",
+    expect(tools.map((tool) => tool.name)).toEqual(["message"]);
+    expect(webSearchAllowed).toBe(true);
+  });
+
+  it("reports hosted search denied when effective tool policy removes web_search", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    setOpenClawCodingToolsFactoryForTests(() => [createRuntimeDynamicTool("message")]);
+    let webSearchAllowed = true;
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      onWebSearchPolicyResolved: (allowed) => {
+        webSearchAllowed = allowed;
+      },
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual(["message"]);
+    expect(webSearchAllowed).toBe(false);
+  });
+
+  it("separates persistent search policy from a runtime toolsAllow restriction", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.toolsAllow = ["message"];
+    setOpenClawCodingToolsFactoryForTests(() => [
+      createRuntimeDynamicTool("web_search"),
+      createRuntimeDynamicTool("message"),
    ]);
+    let persistentWebSearchAllowed = false;
+    let webSearchAllowed = true;
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      onPersistentWebSearchPolicyResolved: (allowed) => {
+        persistentWebSearchAllowed = allowed;
+      },
+      onWebSearchPolicyResolved: (allowed) => {
+        webSearchAllowed = allowed;
+      },
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual(["message"]);
+    expect(persistentWebSearchAllowed).toBe(true);
+    expect(webSearchAllowed).toBe(false);
+  });
+
+  it("keeps persistent search denied when runtime toolsAllow also excludes it", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.toolsAllow = ["message"];
+    setOpenClawCodingToolsFactoryForTests(() => [createRuntimeDynamicTool("message")]);
+    let persistentWebSearchAllowed = true;
+    let webSearchAllowed = true;
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      onPersistentWebSearchPolicyResolved: (allowed) => {
+        persistentWebSearchAllowed = allowed;
+      },
+      onWebSearchPolicyResolved: (allowed) => {
+        webSearchAllowed = allowed;
+      },
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual(["message"]);
+    expect(persistentWebSearchAllowed).toBe(false);
+    expect(webSearchAllowed).toBe(false);
+  });
+
+  it("treats sender-scoped web_search denial as transient", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.senderId = "restricted-sender";
+    params.config = {
+      tools: {
+        toolsBySender: {
+          "id:restricted-sender": { deny: ["web_search"] },
+        },
+      },
+    } as never;
+    setOpenClawCodingToolsFactoryForTests(() => [createRuntimeDynamicTool("message")]);
+    let persistentWebSearchAllowed = false;
+    let webSearchAllowed = true;
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      onPersistentWebSearchPolicyResolved: (allowed) => {
+        persistentWebSearchAllowed = allowed;
+      },
+      onWebSearchPolicyResolved: (allowed) => {
+        webSearchAllowed = allowed;
+      },
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual(["message"]);
+    expect(persistentWebSearchAllowed).toBe(true);
+    expect(webSearchAllowed).toBe(false);
+  });
+
+  it("keeps persistent search denied when global and sender policy both deny it", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.senderId = "restricted-sender";
+    params.config = {
+      tools: {
+        deny: ["web_search"],
+        toolsBySender: {
+          "id:restricted-sender": { deny: ["web_search"] },
+        },
+      },
+    } as never;
+    setOpenClawCodingToolsFactoryForTests(() => [createRuntimeDynamicTool("message")]);
+    let persistentWebSearchAllowed = true;
+
+    await buildDynamicToolsForTest(params, workspaceDir, {
+      onPersistentWebSearchPolicyResolved: (allowed) => {
+        persistentWebSearchAllowed = allowed;
+      },
+    });
+
+    expect(persistentWebSearchAllowed).toBe(false);
+  });
+
+  it("keeps managed web_search when a managed provider is explicitly selected", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    params.config = {
+      tools: {
+        web: {
+          search: { provider: "brave" },
+        },
+      },
+    } as never;
+    setOpenClawCodingToolsFactoryForTests(() => [
+      createRuntimeDynamicTool("web_search"),
+      createRuntimeDynamicTool("message"),
+    ]);
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir);
+
+    expect(tools.map((tool) => tool.name)).toEqual(["web_search", "message"]);
+  });
+
+  it("keeps managed web_search when the active Codex provider lacks hosted search", async () => {
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(path.join(tempDir, "session.jsonl"), workspaceDir);
+    params.disableTools = false;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    setOpenClawCodingToolsFactoryForTests(() => [
+      createRuntimeDynamicTool("web_search"),
+      createRuntimeDynamicTool("message"),
+    ]);
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, {
+      nativeProviderWebSearchSupport: "unsupported",
+    });
+
+    expect(tools.map((tool) => tool.name)).toEqual(["web_search", "message"]);
  });

  it("applies additional Codex dynamic tool excludes without exposing Codex-native tools", () => {
--- a/extensions/codex/src/app-server/dynamic-tool-build.ts
+++ b/extensions/codex/src/app-server/dynamic-tool-build.ts
@@ -46,9 +46,6 @@ type OpenClawExecOptions = NonNullable<OpenClawCodingToolsOptions["exec"]>;
 export type OpenClawCodingToolsFactory =
  (typeof import("openclaw/plugin-sdk/agent-harness"))["createOpenClawCodingTools"];
 type OpenClawDynamicTool = ReturnType<OpenClawCodingToolsFactory>[number];
-type OpenClawDynamicToolProjection = ReturnType<
-  typeof filterProviderNormalizableTools<OpenClawDynamicTool>
->;
 type OpenClawSandboxContext = Awaited<ReturnType<typeof resolveSandboxContext>>;
 type CodexDynamicToolBuildEvent = Parameters<
  NonNullable<EmbeddedRunAttemptParams["onAgentEvent"]>
@@ -63,7 +60,9 @@ const CODEX_NATIVE_SANDBOX_TOOL_REQUIREMENTS = [
  "apply_patch",
 ] as const;
 const CODEX_MEMORY_FLUSH_DYNAMIC_TOOL_ALLOW = new Set(["read", "write"]);
-const CODEX_HEARTBEAT_DYNAMIC_TOOL_NAME = "heartbeat_respond";
+const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
+const CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME = "node_process";
+const CODEX_NODE_EXEC_HIDDEN_PARAMETER_NAMES = new Set(["host", "security", "ask", "node"]);

 /** Runtime inputs needed to derive the exact Codex dynamic tool surface for a turn. */
 export type DynamicToolBuildParams = {
@@ -79,6 +78,9 @@ export type DynamicToolBuildParams = {
  sessionAgentId: string;
  pluginConfig: CodexPluginConfig;
  profilerEnabled?: boolean;
+  forceHeartbeatTool?: boolean;
+  ignoreDisableMessageTool?: boolean;
+  ignoreRuntimePlan?: boolean;
  onYieldDetected: () => void;
  onCodexAppServerEvent?: (event: CodexDynamicToolBuildEvent) => void;
  onPersistentWebSearchPolicyResolved?: (allowed: boolean) => void;
@@ -141,11 +143,6 @@ type CodexDynamicToolBuildStageSummary = {
  stages: CodexDynamicToolBuildStageTiming[];
 };

-type CodexDynamicToolBuildStageTracker = {
-  mark: (name: string) => void;
-  snapshot: () => CodexDynamicToolBuildStageSummary;
-};
-
 const CODEX_DYNAMIC_TOOL_BUILD_WARN_TOTAL_MS = 1_000;
 const CODEX_DYNAMIC_TOOL_BUILD_WARN_STAGE_MS = 500;

@@ -207,42 +204,26 @@ export function formatCodexDynamicToolBuildStageSummary(
    : "none";
 }

-/** Builds the turn-visible and durable registration views from one OpenClaw tool catalog. */
-export async function prepareDynamicToolCatalog(input: DynamicToolBuildParams): Promise<{
-  tools: OpenClawDynamicTool[];
-  registeredTools: OpenClawDynamicTool[];
-}> {
+/** Builds, filters, and normalizes Codex-compatible runtime tools for a single turn. */
+export async function buildDynamicTools(input: DynamicToolBuildParams) {
  const { params } = input;
-  if (params.disableTools || !supportsModelTools(params.model)) {
-    return { tools: [], registeredTools: [] };
+  const messagePolicyParams = input.ignoreDisableMessageTool
+    ? { ...params, disableMessageTool: false }
+    : params;
+  if (params.disableTools) {
+    input.onWebSearchPolicyResolved?.(false);
+    return [];
  }
+  if (!supportsModelTools(params.model)) {
+    input.onPersistentWebSearchPolicyResolved?.(false);
+    input.onWebSearchPolicyResolved?.(false);
+    return [];
+  }
+  // Dynamic tool construction is on the reply hot path, so per-stage
+  // Date.now/span bookkeeping runs only when the Codex profiler flag is set.
  const toolBuildStages = createCodexDynamicToolBuildStageTracker({
    enabled: input.profilerEnabled,
  });
-  // The durable schema must include heartbeat_respond across normal and heartbeat
-  // turns. Build that superset once, then hide it only from normal turn exposure.
-  const allTools = await buildOpenClawDynamicToolSource(input, toolBuildStages);
-  const readableTools = filterProviderNormalizableTools(allTools);
-  toolBuildStages.mark("provider-normalization");
-  const tools = projectDynamicTools(input, readableTools, toolBuildStages, {
-    excludeHeartbeatTool: params.trigger !== "heartbeat",
-    phase: "runtime-tools",
-    stagePrefix: "runtime",
-  });
-  const registeredTools = projectDynamicTools(input, readableTools, toolBuildStages, {
-    ignoreRuntimePlan: true,
-    phase: "registered-tools",
-    reportDiagnostics: false,
-    stagePrefix: "registered",
-  });
-  return { tools, registeredTools };
-}
-
-async function buildOpenClawDynamicToolSource(
-  input: DynamicToolBuildParams,
-  toolBuildStages: CodexDynamicToolBuildStageTracker,
-): Promise<OpenClawDynamicTool[]> {
-  const { params } = input;
  const modelHasVision = params.model.input?.includes("image") ?? false;
  const agentDir = params.agentDir ?? resolveAgentDir(params.config ?? {}, input.sessionAgentId);
  const agentHarness = await import("openclaw/plugin-sdk/agent-harness");
@@ -321,10 +302,10 @@ async function buildOpenClawDynamicToolSource(
    requireExplicitMessageTarget:
      params.requireExplicitMessageTarget ?? isSubagentSessionKey(params.sessionKey),
    sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
-    disableMessageTool: params.disableMessageTool,
-    forceMessageTool: shouldForceMessageTool(params),
-    enableHeartbeatTool: true,
-    forceHeartbeatTool: true,
+    disableMessageTool: input.ignoreDisableMessageTool ? false : params.disableMessageTool,
+    forceMessageTool: shouldForceMessageTool(messagePolicyParams),
+    enableHeartbeatTool: params.trigger === "heartbeat" || input.forceHeartbeatTool === true,
+    forceHeartbeatTool: params.trigger === "heartbeat" || input.forceHeartbeatTool === true,
    onYield: (message) => {
      input.onYieldDetected();
      input.onCodexAppServerEvent?.({
@@ -339,30 +320,16 @@ async function buildOpenClawDynamicToolSource(
    allocateToolOutcomeOrdinal: params.allocateToolOutcomeOrdinal,
  });
  toolBuildStages.mark("create-openclaw-coding-tools");
-  return allTools;
-}
-
-function projectDynamicTools(
-  input: DynamicToolBuildParams,
-  source: OpenClawDynamicToolProjection,
-  toolBuildStages: CodexDynamicToolBuildStageTracker,
-  options: {
-    excludeHeartbeatTool?: boolean;
-    ignoreRuntimePlan?: boolean;
-    phase?: "runtime-tools" | "registered-tools";
-    reportDiagnostics?: boolean;
-    stagePrefix?: string;
-  } = {},
-): OpenClawDynamicTool[] {
-  const { params } = input;
-  const markStage = (name: string) =>
-    toolBuildStages.mark(options.stagePrefix ? `${options.stagePrefix}-${name}` : name);
-  const preNormalizationDiagnostics: RuntimeToolSchemaDiagnostic[] = [...source.diagnostics];
-  const readableAllTools = [...source.tools].filter(
-    (tool) =>
-      !options.excludeHeartbeatTool ||
-      normalizeCodexDynamicToolName(tool.name) !== CODEX_HEARTBEAT_DYNAMIC_TOOL_NAME,
-  );
+  const preNormalizationDiagnostics: RuntimeToolSchemaDiagnostic[] = [];
+  const readableAllToolProjection = filterProviderNormalizableTools(allTools);
+  preNormalizationDiagnostics.push(...readableAllToolProjection.diagnostics);
+  const webSearchPlan = resolveCodexWebSearchPlan({
+    config: params.config,
+    disableTools: params.disableTools,
+    nativeToolSurfaceEnabled: input.nativeToolSurfaceEnabled,
+    nativeProviderWebSearchSupport: input.nativeProviderWebSearchSupport,
+  });
+  const readableAllTools = [...readableAllToolProjection.tools];
  const codexFilteredTools = addNodeShellDynamicToolsIfNeeded(
    addSandboxShellDynamicToolsIfAvailable(
      isCodexMemoryFlushRun(params)
@@ -375,18 +342,51 @@ function projectDynamicTools(
    input,
    nativeExecutionPolicy,
  );
-  markStage("codex-filtering");
-  const modelHasVision = params.model.input?.includes("image") ?? false;
+  toolBuildStages.mark("codex-filtering");
  const visionFilteredTools = filterToolsForVisionInputs(codexFilteredTools, {
    modelHasVision,
    hasInboundImages: (params.images?.length ?? 0) > 0,
  });
-  markStage("vision-filtering");
-  const toolsAllow = includeForcedCodexDynamicToolAllow(params.toolsAllow, params);
+  toolBuildStages.mark("vision-filtering");
+  const webSearchPresent = visionFilteredTools.some((tool) => tool.name === "web_search");
+  const webSearchPolicy = agentHarness.resolveWebSearchToolPolicy({
+    config: params.config,
+    modelProvider: params.model.provider,
+    modelId: params.modelId,
+    agentId: input.sessionAgentId,
+    sessionKey: input.sandboxSessionKey,
+    sandboxToolPolicy: input.sandbox?.tools,
+    messageProvider: resolveCodexMessageToolProvider(params),
+    agentAccountId: params.agentAccountId,
+    groupId: params.groupId,
+    groupChannel: params.groupChannel,
+    groupSpace: params.groupSpace,
+    spawnedBy: params.spawnedBy,
+    senderId: params.senderId,
+    senderName: params.senderName,
+    senderUsername: params.senderUsername,
+    senderE164: params.senderE164,
+  });
+  const senderScopedWebSearchRestriction =
+    !webSearchPolicy.allowed && webSearchPolicy.persistentAllowed;
+  const transientWebSearchRestriction =
+    senderScopedWebSearchRestriction || isCodexMemoryFlushRun(params);
+  const persistentCodexWebSearchSurface =
+    params.config?.tools?.web?.search?.enabled !== false &&
+    !(input.pluginConfig.codexDynamicToolsExclude ?? []).some(
+      (name) => normalizeCodexDynamicToolName(name) === "web_search",
+    );
+  input.onPersistentWebSearchPolicyResolved?.(
+    webSearchPresent ||
+      (persistentCodexWebSearchSurface &&
+        transientWebSearchRestriction &&
+        webSearchPolicy.persistentAllowed),
+  );
+  const toolsAllow = includeForcedCodexDynamicToolAllow(params.toolsAllow, messagePolicyParams);
  const filteredTools = filterCodexDynamicToolsForAllowlist(visionFilteredTools, toolsAllow);
-  markStage("allowlist-filter");
+  toolBuildStages.mark("allowlist-filter");
  const normalizedTools = normalizeAgentRuntimeTools({
-    runtimePlan: options.ignoreRuntimePlan ? undefined : params.runtimePlan,
+    runtimePlan: input.ignoreRuntimePlan ? undefined : params.runtimePlan,
    tools: filteredTools,
    provider: params.provider,
    config: params.config,
@@ -395,14 +395,17 @@ function projectDynamicTools(
    modelId: params.modelId,
    modelApi: params.model.api,
    model: params.model,
-    // Registration is a projection of the already-prepared catalog. Never
-    // activate another provider runtime while constructing its durable schema.
-    allowProviderRuntimePluginLoad: options.ignoreRuntimePlan ? false : undefined,
    onPreNormalizationSchemaDiagnostics: (diagnostics) =>
      preNormalizationDiagnostics.push(...diagnostics),
  });
-  markStage("runtime-normalization");
-  if (options.reportDiagnostics !== false && preNormalizationDiagnostics.length > 0) {
+  toolBuildStages.mark("runtime-normalization");
+  // Resolve policy before hiding the managed tool. Hosted search follows the
+  // same effective policy, while only one search implementation is exposed.
+  input.onWebSearchPolicyResolved?.(normalizedTools.some((tool) => tool.name === "web_search"));
+  const exposedTools = webSearchPlan.suppressManagedWebSearch
+    ? normalizedTools.filter((tool) => tool.name !== "web_search")
+    : normalizedTools;
+  if (preNormalizationDiagnostics.length > 0) {
    embeddedAgentLog.warn(
      `codex app-server quarantined ${preNormalizationDiagnostics.length} unsupported runtime tool schema${preNormalizationDiagnostics.length === 1 ? "" : "s"} before dynamic tool registration`,
      {
@@ -419,7 +422,7 @@ function projectDynamicTools(
  }
  const summary = toolBuildStages.snapshot();
  if (shouldWarnCodexDynamicToolBuildStageSummary(summary)) {
-    const phase = options.phase ?? "runtime-tools";
+    const phase = input.forceHeartbeatTool ? "registered-tools" : "runtime-tools";
    embeddedAgentLog.warn(
      `codex app-server dynamic tool build timings runId=${params.runId} sessionId=${params.sessionId} phase=${phase} totalMs=${summary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(summary)}`,
      {
@@ -432,8 +435,9 @@ function projectDynamicTools(
        codexFilteredToolCount: codexFilteredTools.length,
        visionFilteredToolCount: visionFilteredTools.length,
        filteredToolCount: filteredTools.length,
-        normalizedToolCount: normalizedTools.length,
-        ignoreRuntimePlan: options.ignoreRuntimePlan === true,
+        normalizedToolCount: exposedTools.length,
+        forceHeartbeatTool: input.forceHeartbeatTool === true,
+        ignoreRuntimePlan: input.ignoreRuntimePlan === true,
        nativeToolSurfaceEnabled: input.nativeToolSurfaceEnabled === true,
      },
    );
--- a/extensions/codex/src/app-server/dynamic-tools.ts
+++ b/extensions/codex/src/app-server/dynamic-tools.ts
@@ -72,12 +72,6 @@ type CodexDynamicToolHookContext = {

 type CodexToolResultHookContext = Omit<CodexDynamicToolHookContext, "config">;

-type AgentToolResultObserver = (event: {
-  toolName: string;
-  result: unknown;
-  isError: boolean;
-}) => void;
-
 type ProjectedCodexDynamicTool = {
  tool: AnyAgentTool;
  name: string;
@@ -114,7 +108,8 @@ export type CodexDynamicToolBridge = {
    params: CodexDynamicToolCallParams,
    options?: {
      signal?: AbortSignal;
-      onAgentToolResult?: AgentToolResultObserver;
+      onAgentToolResult?: EmbeddedRunAttemptParams["onAgentToolResult"];
+      toolCallOrdinal?: number;
    },
  ) => Promise<CodexDynamicToolCallResponse>;
  telemetry: {
@@ -447,7 +442,7 @@ export function createCodexDynamicToolBridge(params: {
 }

 function notifyAgentToolResult(
-  observer: AgentToolResultObserver | undefined,
+  observer: EmbeddedRunAttemptParams["onAgentToolResult"] | undefined,
  toolName: string,
  result: unknown,
  isError: boolean,
--- a/extensions/codex/src/app-server/event-projector.test.ts
+++ b/extensions/codex/src/app-server/event-projector.test.ts
@@ -24,6 +24,7 @@ import {
  type CodexAppServerEventProjectorOptions,
  type CodexAppServerToolTelemetry,
 } from "./event-projector.js";
+import { rememberCodexRateLimits, resetCodexRateLimitCacheForTests } from "./rate-limit-cache.js";
 import { createCodexTestModel } from "./test-support.js";

 const THREAD_ID = "thread-1";
@@ -107,6 +108,7 @@ afterEach(async () => {
  resetAgentEventsForTest();
  resetDiagnosticEventsForTest();
  resetGlobalHookRunner();
+  resetCodexRateLimitCacheForTests();
  vi.restoreAllMocks();
  vi.unstubAllEnvs();
  for (const tempDir of tempDirs) {
@@ -861,11 +863,10 @@ describe("CodexAppServerEventProjector", () => {
  });

  it("uses Codex rate-limit resets for usage-limit app-server errors", async () => {
+    const projector = await createProjector();
    const resetsAt = Math.ceil(Date.now() / 1000) + 120;
-    const projector = await createProjector(undefined, {
-      readRecentRateLimits: () => rateLimitsUpdated(resetsAt).params,
-    });

+    await projector.handleNotification(rateLimitsUpdated(resetsAt));
    await projector.handleNotification(
      forCurrentTurn("error", {
        error: {
@@ -886,11 +887,10 @@ describe("CodexAppServerEventProjector", () => {
  });

  it("uses Codex rate-limit resets for failed turns", async () => {
+    const projector = await createProjector();
    const resetsAt = Math.ceil(Date.now() / 1000) + 120;
-    const projector = await createProjector(undefined, {
-      readRecentRateLimits: () => rateLimitsUpdated(resetsAt).params,
-    });

+    await projector.handleNotification(rateLimitsUpdated(resetsAt));
    await projector.handleNotification(
      forCurrentTurn("turn/completed", {
        turn: {
@@ -914,8 +914,9 @@ describe("CodexAppServerEventProjector", () => {
  });

  it("uses a recent Codex rate-limit snapshot when failed turns omit reset details", async () => {
+    const projector = await createProjector();
    const resetsAt = Math.ceil(Date.now() / 1000) + 120;
-    const rateLimits = {
+    rememberCodexRateLimits({
      rateLimits: {
        limitId: "codex",
        limitName: "Codex",
@@ -926,9 +927,6 @@ describe("CodexAppServerEventProjector", () => {
        rateLimitReachedType: "rate_limit_reached",
      },
      rateLimitsByLimitId: null,
-    };
-    const projector = await createProjector(undefined, {
-      readRecentRateLimits: () => rateLimits,
    });

    await projector.handleNotification(
@@ -980,19 +978,19 @@ describe("CodexAppServerEventProjector", () => {
    expect(result.promptErrorSource).toBe("prompt");
  });

-  it("normalizes current app-server token usage", async () => {
+  it("normalizes snake_case current token usage fields", async () => {
    const projector = await createProjector();

    await projector.handleNotification(agentMessageDelta("done"));
    await projector.handleNotification(
      forCurrentTurn("thread/tokenUsage/updated", {
        tokenUsage: {
-          total: { totalTokens: 1_000_000 },
-          last: {
-            totalTokens: 17,
-            inputTokens: 8,
-            cachedInputTokens: 3,
-            outputTokens: 9,
+          total: { total_tokens: 1_000_000 },
+          last_token_usage: {
+            total_tokens: 17,
+            input_tokens: 8,
+            cached_input_tokens: 3,
+            output_tokens: 9,
          },
        },
      }),
--- a/extensions/codex/src/app-server/event-projector.ts
+++ b/extensions/codex/src/app-server/event-projector.ts
@@ -26,7 +26,10 @@ import type { AssistantMessage, Usage } from "openclaw/plugin-sdk/llm";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution.js";
-import { isCodexNotificationForTurn } from "./notification-correlation.js";
+import {
+  readCodexNotificationThreadId,
+  readCodexNotificationTurnId,
+} from "./notification-correlation.js";
 import { readCodexTurn } from "./protocol-validators.js";
 import {
  isJsonObject,
@@ -37,6 +40,7 @@ import {
  type JsonObject,
  type JsonValue,
 } from "./protocol.js";
+import { readRecentCodexRateLimits, rememberCodexRateLimits } from "./rate-limit-cache.js";
 import { formatCodexUsageLimitErrorMessage } from "./rate-limits.js";
 import { readCodexMirroredSessionHistoryMessages } from "./session-history.js";
 import {
@@ -61,7 +65,6 @@ export type CodexAppServerToolTelemetry = {

 export type CodexAppServerEventProjectorOptions = {
  nativePostToolUseRelayEnabled?: boolean;
-  readRecentRateLimits?: () => JsonValue | undefined;
  trajectoryRecorder?: CodexTrajectoryRecorder | null;
 };

@@ -89,6 +92,22 @@ const ZERO_USAGE: Usage = {
  },
 };

+const CURRENT_TOKEN_USAGE_KEYS = [
+  "last",
+  "current",
+  "lastCall",
+  "lastCallUsage",
+  "lastTokenUsage",
+  "last_token_usage",
+] as const;
+
+const CODEX_PROMPT_TOTAL_INPUT_KEYS = [
+  "inputTokens",
+  "input_tokens",
+  "promptTokens",
+  "prompt_tokens",
+] as const;
+
 const MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM = 20;
 const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 12_000;
 const MISSING_TOOL_RESULT_ERROR =
@@ -184,6 +203,8 @@ export class CodexAppServerEventProjector {
  private tokenUsage: ReturnType<typeof normalizeUsage>;
  private guardianReviewCount = 0;
  private completedCompactionCount = 0;
+  private latestRateLimits: JsonValue | undefined;
+
  constructor(
    private readonly params: EmbeddedRunAttemptParams,
    private readonly threadId: string,
@@ -220,6 +241,11 @@ export class CodexAppServerEventProjector {
    if (!params) {
      return;
    }
+    if (notification.method === "account/rateLimits/updated") {
+      this.latestRateLimits = params;
+      rememberCodexRateLimits(params);
+      return;
+    }
    if (isHookNotificationMethod(notification.method)) {
      if (!this.isHookNotificationForCurrentThread(params)) {
        return;
@@ -272,7 +298,7 @@ export class CodexAppServerEventProjector {
        await this.handleRawResponseItemCompleted(params);
        break;
      case "error":
-        if (params.willRetry === true) {
+        if (readBooleanAlias(params, ["willRetry", "will_retry"]) === true) {
          break;
        }
        this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
@@ -683,7 +709,9 @@ export class CodexAppServerEventProjector {

  private handleTokenUsage(params: JsonObject): void {
    const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : undefined;
-    const current = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : undefined;
+    const current =
+      (tokenUsage ? readFirstJsonObject(tokenUsage, CURRENT_TOKEN_USAGE_KEYS) : undefined) ??
+      readFirstJsonObject(params, CURRENT_TOKEN_USAGE_KEYS);
    if (!current) {
      return;
    }
@@ -754,7 +782,7 @@ export class CodexAppServerEventProjector {
        formatCodexUsageLimitErrorMessage({
          message: turn.error?.message,
          codexErrorInfo: turn.error?.codexErrorInfo as JsonValue | null | undefined,
-          rateLimits: this.options.readRecentRateLimits?.(),
+          rateLimits: this.latestRateLimits ?? readRecentCodexRateLimits(),
        }) ??
        turn.error?.message ??
        "codex app-server turn failed";
@@ -1661,7 +1689,7 @@ export class CodexAppServerEventProjector {
      formatCodexUsageLimitErrorMessage({
        message: error ? readString(error, "message") : undefined,
        codexErrorInfo: error?.codexErrorInfo,
-        rateLimits: this.options.readRecentRateLimits?.(),
+        rateLimits: this.latestRateLimits ?? readRecentCodexRateLimits(),
      }) ?? readCodexErrorNotificationMessage(params)
    );
  }
@@ -1856,7 +1884,9 @@ export class CodexAppServerEventProjector {
  }

  private isNotificationForTurn(params: JsonObject): boolean {
-    return isCodexNotificationForTurn(params, this.threadId, this.turnId);
+    const threadId = readCodexNotificationThreadId(params);
+    const turnId = readNotificationTurnId(params);
+    return threadId === this.threadId && turnId === this.turnId;
  }

  private isHookNotificationForCurrentThread(params: JsonObject): boolean {
@@ -1870,6 +1900,10 @@ function isHookNotificationMethod(method: string): method is "hook/started" | "h
  return method === "hook/started" || method === "hook/completed";
 }

+function readNotificationTurnId(record: JsonObject): string | undefined {
+  return readCodexNotificationTurnId(record);
+}
+
 function readString(record: JsonObject, key: string): string | undefined {
  const value = record[key];
  return typeof value === "string" ? value : undefined;
@@ -1959,6 +1993,21 @@ function readNonNegativeInteger(record: JsonObject, key: string): number | undef
  return value !== undefined && Number.isInteger(value) && value >= 0 ? value : undefined;
 }

+function readBoolean(record: JsonObject, key: string): boolean | undefined {
+  const value = record[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function readBooleanAlias(record: JsonObject, keys: readonly string[]): boolean | undefined {
+  for (const key of keys) {
+    const value = readBoolean(record, key);
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
 function readCodexErrorNotificationMessage(record: JsonObject): string | undefined {
  const error = record.error;
  if (isJsonObject(error)) {
@@ -1986,19 +2035,52 @@ function readHookOutputEntries(
  });
 }

+function readFirstJsonObject(record: JsonObject, keys: readonly string[]): JsonObject | undefined {
+  for (const key of keys) {
+    const value = record[key];
+    if (isJsonObject(value)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function readNumberAlias(record: JsonObject, keys: readonly string[]): number | undefined {
+  for (const key of keys) {
+    const value = readNumber(record, key);
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
 function normalizeCodexTokenUsage(record: JsonObject): ReturnType<typeof normalizeUsage> {
-  const promptTotalInput = readNumber(record, "inputTokens");
-  const cacheRead = readNumber(record, "cachedInputTokens");
+  const promptTotalInput = readNumberAlias(record, CODEX_PROMPT_TOTAL_INPUT_KEYS);
+  const cacheRead = readNumberAlias(record, [
+    "cachedInputTokens",
+    "cached_input_tokens",
+    "cacheRead",
+    "cache_read",
+    "cache_read_input_tokens",
+    "cached_tokens",
+  ]);
  const input =
    promptTotalInput !== undefined && cacheRead !== undefined
      ? Math.max(0, promptTotalInput - cacheRead)
-      : promptTotalInput;
+      : (promptTotalInput ?? readNumber(record, "input"));

  return normalizeUsage({
    input,
-    output: readNumber(record, "outputTokens"),
+    output: readNumberAlias(record, ["outputTokens", "output_tokens", "output"]),
    cacheRead,
-    total: readNumber(record, "totalTokens"),
+    cacheWrite: readNumberAlias(record, [
+      "cacheWrite",
+      "cache_write",
+      "cacheCreationInputTokens",
+      "cache_creation_input_tokens",
+    ]),
+    total: readNumberAlias(record, ["totalTokens", "total_tokens", "total"]),
  });
 }

--- a/extensions/codex/src/app-server/models.ts
+++ b/extensions/codex/src/app-server/models.ts
@@ -8,10 +8,6 @@ import type { CodexAppServerClient } from "./client.js";
 import type { CodexAppServerStartOptions } from "./config.js";
 import { readCodexModelListResponse } from "./protocol-validators.js";
 import type { CodexModel, CodexReasoningEffortOption } from "./protocol.js";
-import {
-  createIsolatedCodexAppServerClient,
-  leaseSharedCodexAppServerClient,
-} from "./shared-client.js";

 /** Normalized model metadata returned by the Codex app-server model listing helper. */
 export type CodexAppServerModel = {
@@ -40,11 +36,10 @@ export type CodexAppServerListModelsOptions = {
  includeHidden?: boolean;
  timeoutMs?: number;
  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string | null;
+  authProfileId?: string;
  agentDir?: string;
  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
  sharedClient?: boolean;
-  signal?: AbortSignal;
 };

 /** Lists one Codex app-server model page using the configured auth/client options. */
@@ -59,37 +54,27 @@ export async function listCodexAppServerModels(
 /** Walks Codex app-server model pages until exhaustion or the max-page guard. */
 export async function listAllCodexAppServerModels(
  options: CodexAppServerListModelsOptions & { maxPages?: number } = {},
-): Promise<CodexAppServerModelListResult> {
-  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) =>
-    listAllCodexAppServerModelsWithClient(client, { ...options, timeoutMs }),
-  );
-}
-
-/** Walks all model pages on an already-owned physical app-server client. */
-export async function listAllCodexAppServerModelsWithClient(
-  client: CodexAppServerClient,
-  options: CodexAppServerListModelsOptions & { maxPages?: number } = {},
 ): Promise<CodexAppServerModelListResult> {
  const maxPages = normalizeMaxPages(options.maxPages);
-  const timeoutMs = options.timeoutMs ?? 2500;
-  const models: CodexAppServerModel[] = [];
-  let cursor = options.cursor;
-  let nextCursor: string | undefined;
-  for (let page = 0; page < maxPages; page += 1) {
-    options.signal?.throwIfAborted();
-    const result = await requestModelListPage(client, {
-      ...options,
-      timeoutMs,
-      cursor,
-    });
-    models.push(...result.models);
-    nextCursor = result.nextCursor;
-    if (!nextCursor) {
-      return { models };
+  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
+    const models: CodexAppServerModel[] = [];
+    let cursor = options.cursor;
+    let nextCursor: string | undefined;
+    for (let page = 0; page < maxPages; page += 1) {
+      const result = await requestModelListPage(client, {
+        ...options,
+        timeoutMs,
+        cursor,
+      });
+      models.push(...result.models);
+      nextCursor = result.nextCursor;
+      if (!nextCursor) {
+        return { models };
+      }
+      cursor = nextCursor;
    }
-    cursor = nextCursor;
-  }
-  return { models, nextCursor, truncated: true };
+    return { models, nextCursor, truncated: true };
+  });
 }

 async function withCodexAppServerModelClient<T>(
@@ -98,32 +83,33 @@ async function withCodexAppServerModelClient<T>(
 ): Promise<T> {
  const timeoutMs = options.timeoutMs ?? 2500;
  const useSharedClient = options.sharedClient !== false;
-  const clientLease = useSharedClient
-    ? await leaseSharedCodexAppServerClient({
+  const {
+    createIsolatedCodexAppServerClient,
+    getLeasedSharedCodexAppServerClient,
+    releaseLeasedSharedCodexAppServerClient,
+  } = await import("./shared-client.js");
+  const client = useSharedClient
+    ? await getLeasedSharedCodexAppServerClient({
        startOptions: options.startOptions,
        timeoutMs,
        authProfileId: options.authProfileId,
        agentDir: options.agentDir,
        config: options.config,
-        abandonSignal: options.signal,
      })
-    : undefined;
-  const client =
-    clientLease?.client ??
-    (await createIsolatedCodexAppServerClient({
-      startOptions: options.startOptions,
-      timeoutMs,
-      authProfileId: options.authProfileId,
-      agentDir: options.agentDir,
-      config: options.config,
-    }));
+    : await createIsolatedCodexAppServerClient({
+        startOptions: options.startOptions,
+        timeoutMs,
+        authProfileId: options.authProfileId,
+        agentDir: options.agentDir,
+        config: options.config,
+      });
  try {
    return await run({ client, timeoutMs });
  } finally {
    if (useSharedClient) {
-      clientLease?.release();
+      releaseLeasedSharedCodexAppServerClient(client);
    } else {
-      await client.closeAndWait({ exitTimeoutMs: 2_000, forceKillDelayMs: 250 });
+      client.close();
    }
  }
 }
@@ -139,7 +125,7 @@ async function requestModelListPage(
      cursor: options.cursor ?? null,
      includeHidden: options.includeHidden ?? null,
    },
-    { timeoutMs: options.timeoutMs, signal: options.signal },
+    { timeoutMs: options.timeoutMs },
  );
  return readModelListResult(response);
 }
--- a/extensions/codex/src/app-server/native-execution-policy.ts
+++ b/extensions/codex/src/app-server/native-execution-policy.ts
@@ -4,12 +4,7 @@
 */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
-import {
-  loadSessionStore,
-  resolveSessionStoreEntry,
-  resolveStorePath,
-  type SessionEntry,
-} from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry, type SessionEntry } from "openclaw/plugin-sdk/session-store-runtime";

 type ExecHost = "sandbox" | "gateway" | "node";
 type ExecTarget = "auto" | ExecHost;
@@ -50,17 +45,19 @@ export function resolveCodexNativeExecutionPolicy(params: {
  const config = params.config ?? {};
  const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim() || undefined;
  const agentId = resolvePolicyAgentId({ config, sessionKey, agentId: params.agentId });
+  const canReadSessionEntry =
+    params.readRuntimeSessionEntry &&
+    shouldReadRuntimeSessionEntry({ config, sessionKey, agentId: params.agentId });
  const sessionEntry =
    params.sessionEntry ??
-    (params.readRuntimeSessionEntry && sessionKey
-      ? readRuntimeSessionEntryBestEffort(config, sessionKey, agentId)
+    (canReadSessionEntry && sessionKey
+      ? readRuntimeSessionEntryBestEffort({ sessionKey, agentId })
      : undefined);
  const sandboxAvailable =
    params.sandboxAvailable ??
    (sessionKey
      ? resolveSandboxRuntimeStatus({
          cfg: config,
-          agentId,
          sessionKey,
        }).sandboxed
      : false);
@@ -233,17 +230,16 @@ function resolveEffectiveExecHost(params: {
  return params.requestedExecHost;
 }

-function readRuntimeSessionEntryBestEffort(
-  config: OpenClawConfig,
-  sessionKey: string,
-  agentId: string,
-): SessionEntry | undefined {
+function readRuntimeSessionEntryBestEffort(params: {
+  sessionKey: string;
+  agentId: string;
+}): SessionEntry | undefined {
  try {
-    const storePath = resolveStorePath(config.session?.store, { agentId });
-    return resolveSessionStoreEntry({
-      store: loadSessionStore(storePath, { skipCache: true }),
-      sessionKey,
-    }).existing;
+    return getSessionEntry({
+      sessionKey: params.sessionKey,
+      agentId: params.agentId,
+      hydrateSkillPromptRefs: false,
+    });
  } catch {
    return undefined;
  }
--- a/extensions/codex/src/app-server/native-hook-relay.ts
+++ b/extensions/codex/src/app-server/native-hook-relay.ts
@@ -13,6 +13,7 @@ import {
  addTimerTimeoutGraceMs,
  finiteSecondsToTimerSafeMilliseconds,
 } from "openclaw/plugin-sdk/number-runtime";
+import type { CodexAppServerRuntimeOptions } from "./config.js";
 import type { JsonObject, JsonValue } from "./protocol.js";

 /** Codex hook events that can be registered through OpenClaw's native relay. */
@@ -23,6 +24,8 @@ export const CODEX_NATIVE_HOOK_RELAY_EVENTS: readonly NativeHookRelayEvent[] = [
  "before_agent_finalize",
 ] as const;

+const CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS =
+  CODEX_NATIVE_HOOK_RELAY_EVENTS.filter((event) => event !== "permission_request");
 const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 60_000;
 /** Extra relay lifetime after the expected turn budget, preventing late hook drops. */
 export const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 60_000;
@@ -146,8 +149,9 @@ export function createCodexNativeHookRelay(params: {
    allowedEvents: params.events,
    ttlMs: resolveCodexNativeHookRelayTtlMs({
      explicitTtlMs: params.options?.ttlMs,
-      operationBudgetMs:
-        params.attemptTimeoutMs + params.startupTimeoutMs + params.turnStartTimeoutMs,
+      attemptTimeoutMs: params.attemptTimeoutMs,
+      startupTimeoutMs: params.startupTimeoutMs,
+      turnStartTimeoutMs: params.turnStartTimeoutMs,
    }),
    signal: params.signal,
    command: {
@@ -159,27 +163,38 @@ export function createCodexNativeHookRelay(params: {
  });
 }

-/** Selects the native hook events Codex should install for this thread. */
+/** Selects the native hook events Codex should install for the current approval mode. */
 export function resolveCodexNativeHookRelayEvents(params: {
  configuredEvents?: readonly NativeHookRelayEvent[];
+  appServer: Pick<CodexAppServerRuntimeOptions, "approvalPolicy">;
 }): readonly NativeHookRelayEvent[] {
  if (params.configuredEvents?.length) {
    return params.configuredEvents;
  }
-  // Thread config is fixed before Codex reports the authoritative provider.
-  // Install the stable superset; the relay defers permission prompts from guarded turns.
-  return CODEX_NATIVE_HOOK_RELAY_EVENTS;
+  // Codex emits PermissionRequest before the app-server approval reviewer has
+  // resolved the command. In native approval modes, let Codex's app-server
+  // approval bridge own the real escalation instead of surfacing a stale
+  // pre-guardian OpenClaw plugin approval prompt.
+  return params.appServer.approvalPolicy === "never"
+    ? CODEX_NATIVE_HOOK_RELAY_EVENTS
+    : CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS;
 }

 /** Derives the native hook relay TTL from the turn budget unless explicitly configured. */
 export function resolveCodexNativeHookRelayTtlMs(params: {
  explicitTtlMs: number | undefined;
-  operationBudgetMs: number;
+  attemptTimeoutMs: number;
+  startupTimeoutMs: number;
+  turnStartTimeoutMs: number;
 }): number {
  if (params.explicitTtlMs !== undefined) {
    return params.explicitTtlMs;
  }
-  const relayBudgetMs = params.operationBudgetMs + CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
+  const relayBudgetMs =
+    params.attemptTimeoutMs +
+    params.startupTimeoutMs +
+    params.turnStartTimeoutMs +
+    CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
  return Math.max(CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS, Math.floor(relayBudgetMs));
 }

--- a/extensions/codex/src/app-server/native-subagent-monitor.test.ts
+++ b/extensions/codex/src/app-server/native-subagent-monitor.test.ts
--- a/extensions/codex/src/app-server/native-subagent-monitor.ts
+++ b/extensions/codex/src/app-server/native-subagent-monitor.ts
--- a/extensions/codex/src/app-server/native-subagent-notification.test.ts
+++ b/extensions/codex/src/app-server/native-subagent-notification.test.ts
@@ -4,7 +4,6 @@ import {
  extractCodexNativeSubagentCompletions,
  extractCodexNativeSubagentCompletionsFromText,
 } from "./native-subagent-notification.js";
-import type { CodexServerNotification } from "./protocol.js";

 function trustedInterAgentNotification(params: {
  agentPath: string;
@@ -36,29 +35,6 @@ function trustedInterAgentNotification(params: {
  };
 }

-function trustedAgentMessageNotification(params: {
-  agentPath: string;
-  text?: string;
-  encryptedContent?: string;
-}): CodexServerNotification {
-  return {
-    method: "rawResponseItem/completed",
-    params: {
-      threadId: "parent-thread",
-      item: {
-        type: "agent_message",
-        author: params.agentPath,
-        recipient: "/root",
-        content: [
-          params.encryptedContent
-            ? { type: "encrypted_content", encrypted_content: params.encryptedContent }
-            : { type: "input_text", text: params.text ?? "" },
-        ],
-      },
-    },
-  };
-}
-
 describe("Codex native subagent notifications", () => {
  it("parses completed child results from Codex notification XML", () => {
    expect(
@@ -160,26 +136,6 @@ describe("Codex native subagent notifications", () => {
    ]);
  });

-  it("extracts completions from the current Codex agent-message item", () => {
-    expect(
-      extractCodexNativeSubagentCompletions(
-        trustedAgentMessageNotification({
-          agentPath: "child-thread",
-          text:
-            '<subagent_notification>{"agent_path":"child-thread","status":{"completed":"done"}}' +
-            "</subagent_notification>",
-        }),
-      ),
-    ).toEqual([
-      {
-        agentPath: "child-thread",
-        status: "succeeded",
-        statusLabel: "completed",
-        result: "done",
-      },
-    ]);
-  });
-
  it("ignores visible user text that looks like a native completion", () => {
    expect(
      extractCodexNativeSubagentCompletions({
@@ -214,27 +170,6 @@ describe("Codex native subagent notifications", () => {
        }),
      ),
    ).toEqual([]);
-    expect(
-      extractCodexNativeSubagentCompletions(
-        trustedAgentMessageNotification({
-          agentPath: "other-child",
-          text:
-            '<subagent_notification>{"agent_path":"child-thread","status":{"success":"spoof"}}' +
-            "</subagent_notification>",
-        }),
-      ),
-    ).toEqual([]);
-  });
-
-  it("ignores encrypted agent messages that cannot be authenticated", () => {
-    expect(
-      extractCodexNativeSubagentCompletions(
-        trustedAgentMessageNotification({
-          agentPath: "child-thread",
-          encryptedContent: "opaque",
-        }),
-      ),
-    ).toEqual([]);
  });

  it("ignores malformed payloads and non-user messages", () => {
--- a/extensions/codex/src/app-server/native-subagent-notification.ts
+++ b/extensions/codex/src/app-server/native-subagent-notification.ts
@@ -39,12 +39,13 @@ export function extractCodexNativeSubagentCompletions(
  if (!item) {
    return [];
  }
-  const communication = readTrustedInterAgentCommunication(item);
-  if (!communication) {
+  const text = readTrustedInterAgentCommunicationContent(item);
+  if (!text) {
    return [];
  }
-  return extractCodexNativeSubagentCompletionsFromText(communication.content).filter(
-    (completion) => completion.agentPath === communication.author,
+  const author = readTrustedInterAgentCommunicationAuthor(item);
+  return extractCodexNativeSubagentCompletionsFromText(text).filter(
+    (completion) => completion.agentPath === author,
  );
 }

@@ -189,21 +190,17 @@ function completedWithoutFinalAssistantMessage(): {
  };
 }

-type TrustedInterAgentCommunication = {
-  author: string;
-  recipient: string;
-  content: string;
-};
+function readTrustedInterAgentCommunicationContent(item: JsonObject): string | undefined {
+  const communication = readTrustedInterAgentCommunication(item);
+  return typeof communication?.content === "string" ? communication.content : undefined;
+}

-function readTrustedInterAgentCommunication(
-  item: JsonObject,
-): TrustedInterAgentCommunication | undefined {
-  if (readString(item, "type") === "agent_message") {
-    const author = readString(item, "author")?.trim();
-    const recipient = readString(item, "recipient")?.trim();
-    const content = extractSingleTextPart(item, "input_text");
-    return author && recipient && content ? { author, recipient, content } : undefined;
-  }
+function readTrustedInterAgentCommunicationAuthor(item: JsonObject): string | undefined {
+  const communication = readTrustedInterAgentCommunication(item);
+  return typeof communication?.author === "string" ? communication.author : undefined;
+}
+
+function readTrustedInterAgentCommunication(item: JsonObject): JsonObject | undefined {
  if (
    readString(item, "type") !== "message" ||
    readString(item, "role") !== "assistant" ||
@@ -211,7 +208,7 @@ function readTrustedInterAgentCommunication(
  ) {
    return undefined;
  }
-  const text = extractSingleTextPart(item, "output_text", "text");
+  const text = extractSingleTextPart(item);
  if (!text) {
    return undefined;
  }
@@ -224,20 +221,18 @@ function readTrustedInterAgentCommunication(
  if (!isJsonObject(parsed)) {
    return undefined;
  }
-  const author = typeof parsed.author === "string" ? parsed.author.trim() : "";
-  const recipient = typeof parsed.recipient === "string" ? parsed.recipient.trim() : "";
  if (
-    !author ||
-    !recipient ||
+    typeof parsed.author !== "string" ||
+    typeof parsed.recipient !== "string" ||
    typeof parsed.content !== "string" ||
    parsed.trigger_turn !== false
  ) {
    return undefined;
  }
-  return { author, recipient, content: parsed.content };
+  return parsed;
 }

-function extractSingleTextPart(item: JsonObject, ...acceptedTypes: string[]): string | undefined {
+function extractSingleTextPart(item: JsonObject): string | undefined {
  const content = item.content;
  if (!Array.isArray(content) || content.length !== 1) {
    return undefined;
@@ -247,7 +242,7 @@ function extractSingleTextPart(item: JsonObject, ...acceptedTypes: string[]): st
    return undefined;
  }
  const type = readString(entry, "type");
-  if (!type || !acceptedTypes.includes(type)) {
+  if (type !== "output_text" && type !== "text") {
    return undefined;
  }
  return readString(entry, "text")?.trim();
--- a/extensions/codex/src/app-server/native-subagent-task-mirror.ts
+++ b/extensions/codex/src/app-server/native-subagent-task-mirror.ts
@@ -56,8 +56,8 @@ export class CodexNativeSubagentTaskMirror {
  }

  markAuthoritativeCompletionExpected(childThreadId: string): void {
-    // The monitor recovers the authoritative result through app-server history.
-    // Keep collab completion as progress so it cannot finalize stale text first.
+    // Local transcripts and V2 agent paths can supply the real result later.
+    // Remote V1 lacks both and must keep collab-completed as its fallback.
    this.expectedAuthoritativeRunIds.add(codexNativeSubagentRunId(childThreadId));
  }

--- a/extensions/codex/src/app-server/notification-correlation.ts
+++ b/extensions/codex/src/app-server/notification-correlation.ts
@@ -2,7 +2,28 @@
 * Correlates Codex app-server notifications with the active thread/turn so
 * projectors can ignore global or stale events without losing diagnostics.
 */
-import { isJsonObject, type JsonObject, type JsonValue } from "./protocol.js";
+import {
+  isJsonObject,
+  type CodexServerNotification,
+  type JsonObject,
+  type JsonValue,
+} from "./protocol.js";
+
+/** Debug-friendly correlation summary for a Codex app-server notification. */
+export type CodexNotificationCorrelation = {
+  method: string;
+  paramsKeys?: string[];
+  activeThreadId: string;
+  activeTurnId?: string;
+  threadId?: string;
+  turnId?: string;
+  nestedTurnThreadId?: string;
+  nestedTurnId?: string;
+  turnStatus?: string;
+  turnItemCount?: number;
+  matchesActiveThread: boolean;
+  matchesActiveTurn?: boolean;
+};

 /** Returns true when a notification payload belongs to the exact active thread and turn. */
 export function isCodexNotificationForTurn(
@@ -19,10 +40,9 @@ export function isCodexNotificationForTurn(
  );
 }

-/** Reads a thread id from canonical top-level or nested thread payloads. */
+/** Reads a thread id from either top-level notification params or nested turn payloads. */
 export function readCodexNotificationThreadId(record: JsonObject): string | undefined {
-  const thread = isJsonObject(record.thread) ? record.thread : undefined;
-  return readString(record, "threadId") ?? (thread ? readString(thread, "id") : undefined);
+  return readNestedTurnThreadId(record) ?? readString(record, "threadId");
 }

 /** Reads a turn id from either top-level notification params or nested turn payloads. */
@@ -30,11 +50,50 @@ export function readCodexNotificationTurnId(record: JsonObject): string | undefi
  return readNestedTurnId(record) ?? readString(record, "turnId");
 }

+/** Builds structured correlation details for logs when notification routing is ambiguous. */
+export function describeCodexNotificationCorrelation(
+  notification: CodexServerNotification,
+  active: { threadId: string; turnId?: string },
+): CodexNotificationCorrelation {
+  const params = isJsonObject(notification.params) ? notification.params : undefined;
+  const turn = params && isJsonObject(params.turn) ? params.turn : undefined;
+  const threadId = params ? readString(params, "threadId") : undefined;
+  const turnId = params ? readString(params, "turnId") : undefined;
+  const nestedTurnThreadId = turn ? readString(turn, "threadId") : undefined;
+  const nestedTurnId = turn ? readString(turn, "id") : undefined;
+  const resolvedThreadId = params ? readCodexNotificationThreadId(params) : undefined;
+  const resolvedTurnId = params ? readCodexNotificationTurnId(params) : undefined;
+  const matchesActiveThread = resolvedThreadId === active.threadId;
+  const matchesActiveTurn = active.turnId
+    ? matchesActiveThread && resolvedTurnId === active.turnId
+    : undefined;
+  const items = turn?.items;
+  return {
+    method: notification.method,
+    ...(params ? { paramsKeys: Object.keys(params).toSorted() } : {}),
+    activeThreadId: active.threadId,
+    ...(active.turnId ? { activeTurnId: active.turnId } : {}),
+    ...(threadId ? { threadId } : {}),
+    ...(turnId ? { turnId } : {}),
+    ...(nestedTurnThreadId ? { nestedTurnThreadId } : {}),
+    ...(nestedTurnId ? { nestedTurnId } : {}),
+    ...(turn ? { turnStatus: readString(turn, "status") } : {}),
+    ...(Array.isArray(items) ? { turnItemCount: items.length } : {}),
+    matchesActiveThread,
+    ...(matchesActiveTurn === undefined ? {} : { matchesActiveTurn }),
+  };
+}
+
 function readNestedTurnId(record: JsonObject): string | undefined {
  const turn = record.turn;
  return isJsonObject(turn) ? readString(turn, "id") : undefined;
 }

+function readNestedTurnThreadId(record: JsonObject): string | undefined {
+  const turn = record.turn;
+  return isJsonObject(turn) ? readString(turn, "threadId") : undefined;
+}
+
 function readString(record: JsonObject, key: string): string | undefined {
  const value = record[key];
  return typeof value === "string" && value.trim() ? value.trim() : undefined;
--- a/extensions/codex/src/app-server/prompt-sections.ts
+++ b/extensions/codex/src/app-server/prompt-sections.ts
@@ -1,4 +0,0 @@
-/** Joins non-empty Codex prompt sections with stable paragraph spacing. */
-export function joinCodexPromptSections(...sections: Array<string | undefined>): string {
-  return sections.filter((section): section is string => Boolean(section?.trim())).join("\n\n");
-}
--- a/extensions/codex/src/app-server/protocol-validators.test.ts
+++ b/extensions/codex/src/app-server/protocol-validators.test.ts
@@ -60,6 +60,14 @@ describe("assertCodexThreadStartResponse", () => {
    expect(result.thread.sessionId).toBe("session-1");
  });

+  it("normalizes missing id from sessionId", () => {
+    const response = makeMinimalResponse({ id: undefined, sessionId: "session-1" });
+    delete (response.thread as Record<string, unknown>).id;
+    const result = assertCodexThreadStartResponse(response);
+    expect(result.thread.id).toBe("session-1");
+    expect(result.thread.sessionId).toBe("session-1");
+  });
+
  it("throws on invalid response", () => {
    expect(() => assertCodexThreadStartResponse({})).toThrow("Invalid Codex app-server");
  });
--- a/extensions/codex/src/app-server/protocol-validators.ts
+++ b/extensions/codex/src/app-server/protocol-validators.ts
@@ -8,6 +8,7 @@ import errorNotificationSchema from "./protocol-generated/json/v2/ErrorNotificat
 import modelListResponseSchema from "./protocol-generated/json/v2/ModelListResponse.json" with { type: "json" };
 import threadResumeResponseSchema from "./protocol-generated/json/v2/ThreadResumeResponse.json" with { type: "json" };
 import threadStartResponseSchema from "./protocol-generated/json/v2/ThreadStartResponse.json" with { type: "json" };
+import turnCompletedNotificationSchema from "./protocol-generated/json/v2/TurnCompletedNotification.json" with { type: "json" };
 import turnStartResponseSchema from "./protocol-generated/json/v2/TurnStartResponse.json" with { type: "json" };
 import type {
  CodexDynamicToolCallParams,
@@ -17,6 +18,7 @@ import type {
  CodexThreadResumeResponse,
  CodexThreadStartResponse,
  CodexTurn,
+  CodexTurnCompletedNotification,
  CodexTurnStartResponse,
 } from "./protocol.js";

@@ -219,6 +221,9 @@ const validateThreadResumeResponse = compileCodexSchema<CodexThreadResumeRespons
 );
 const validateThreadStartResponse =
  compileCodexSchema<CodexThreadStartResponse>(threadStartResponseSchema);
+const validateTurnCompletedNotification = compileCodexSchema<CodexTurnCompletedNotification>(
+  turnCompletedNotificationSchema,
+);
 const validateTurnStartResponse =
  compileCodexSchema<CodexTurnStartResponse>(turnStartResponseSchema);

@@ -293,6 +298,19 @@ export function readCodexTurn(value: unknown): CodexTurn | undefined {
  return response?.turn;
 }

+/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
+export function readCodexTurnCompletedNotification(
+  value: unknown,
+): CodexTurnCompletedNotification | undefined {
+  return readCodexShape(
+    validateTurnCompletedNotification,
+    normalizeWithDefaults(
+      turnCompletedNotificationSchema,
+      normalizeTurnCompletedNotification(value),
+    ),
+  );
+}
+
 function assertCodexShape<T>(validate: CodexValidator<T>, value: unknown, label: string): T {
  if (validate.check(value)) {
    return value;
@@ -357,6 +375,9 @@ function normalizeThreadResponse(value: unknown): unknown {
    if (typeof t.id === "string" && typeof t.sessionId !== "string") {
      return { ...value, thread: { ...thread, sessionId: t.id } };
    }
+    if (typeof t.sessionId === "string" && typeof t.id !== "string") {
+      return { ...value, thread: { ...thread, id: t.sessionId } };
+    }
  }
  return value;
 }
@@ -371,6 +392,16 @@ function normalizeTurnStartResponse(value: unknown): unknown {
  };
 }

+function normalizeTurnCompletedNotification(value: unknown): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) {
+    return value;
+  }
+  return {
+    ...value,
+    turn: normalizeTurn((value as { turn?: unknown }).turn),
+  };
+}
+
 function formatValidationErrors(validate: CodexValidator<unknown>, value: unknown): string {
  const errors = validate.errors(value);
  if (!errors || errors.length === 0) {
--- a/extensions/codex/src/app-server/protocol.ts
+++ b/extensions/codex/src/app-server/protocol.ts
@@ -139,7 +139,6 @@ export type CodexThreadResumeParams = JsonObject & {
  serviceTier?: CodexServiceTier | null;
  config?: JsonObject;
  developerInstructions?: string;
-  excludeTurns?: boolean;
  /** Retired by Codex 0.137, but still sent for supported custom app-server 0.125-0.136. */
  persistExtendedHistory?: boolean;
 };
@@ -147,10 +146,7 @@ export type CodexThreadResumeParams = JsonObject & {
 export type CodexThreadStartResponse = {
  thread: CodexThread;
  model: string;
-  modelProvider: string;
-  approvalPolicy: string | JsonObject;
-  approvalsReviewer: string;
-  sandbox: CodexSandboxPolicy;
+  modelProvider?: string | null;
 };

 export type CodexThreadForkParams = CodexThreadStartParams & {
@@ -166,22 +162,7 @@ export type CodexThreadForkResponse = CodexThreadStartResponse;
 export type CodexThreadResumeResponse = {
  thread: CodexThread;
  model: string;
-  modelProvider: string;
-  approvalPolicy: string | JsonObject;
-  approvalsReviewer: string;
-  sandbox: CodexSandboxPolicy;
-};
-
-export type CodexThreadReadParams = JsonObject & {
-  threadId: string;
-  includeTurns?: boolean;
-};
-
-export type CodexThreadReadResponse = {
-  thread: CodexThread & {
-    parentThreadId?: string | null;
-    turns?: JsonObject[];
-  };
+  modelProvider?: string | null;
 };

 export type CodexThreadInjectItemsParams = JsonObject & {
@@ -226,10 +207,11 @@ export type CodexTurnStartResponse = {

 export type CodexTurn = {
  id: string;
+  threadId: string;
  status?: string;
  error?: CodexErrorNotification["error"];
-  startedAt?: number | null;
-  completedAt?: number | null;
+  startedAt?: string | null;
+  completedAt?: string | null;
  durationMs?: number | null;
  items: CodexThreadItem[];
 };
@@ -247,7 +229,6 @@ export type CodexThread = {
  threadSource?: string | null;
  agentNickname?: string | null;
  agentRole?: string | null;
-  turns: CodexTurn[];
 };

 export type CodexThreadStatus =
@@ -583,7 +564,6 @@ type CodexAppServerRequestParamsOverride = {
  "environment/add": { environmentId: string; execServerUrl: string };
  "thread/fork": CodexThreadForkParams;
  "thread/inject_items": CodexThreadInjectItemsParams;
-  "thread/read": CodexThreadReadParams;
  "thread/start": CodexThreadStartParams;
  "thread/unsubscribe": CodexThreadUnsubscribeParams;
  "turn/interrupt": CodexTurnInterruptParams;
@@ -612,7 +592,6 @@ type CodexAppServerRequestResultMap = {
  "thread/fork": CodexThreadForkResponse;
  "thread/inject_items": JsonValue;
  "thread/list": JsonValue;
-  "thread/read": CodexThreadReadResponse;
  "thread/resume": CodexThreadResumeResponse;
  "thread/start": CodexThreadStartResponse;
  "thread/unsubscribe": JsonValue;
@@ -625,14 +604,6 @@ export function isJsonObject(value: unknown): value is JsonObject {
  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }

-/** Reads the thread identity whose subscription the client retained on create. */
-export function readCodexThreadCreationResponseId(value: unknown): string | undefined {
-  if (!isJsonObject(value) || !isJsonObject(value.thread) || typeof value.thread.id !== "string") {
-    return undefined;
-  }
-  return value.thread.id.trim() || undefined;
-}
-
 export function isRpcResponse(message: RpcMessage): message is RpcResponse {
  return "id" in message && !("method" in message);
 }
--- a/extensions/codex/src/app-server/provider-capabilities.test.ts
+++ b/extensions/codex/src/app-server/provider-capabilities.test.ts
@@ -1,8 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import type { CodexAppServerClient } from "./client.js";
 import type { CodexAppServerRuntimeOptions } from "./config.js";
 import { resolveCodexProviderWebSearchSupport } from "./provider-capabilities.js";
-import type { CodexAppServerClientLeaseFactory } from "./shared-client.js";

 const appServer = {
  start: {},
@@ -13,16 +13,12 @@ function createClientFactory(webSearch: boolean | boolean[]) {
  const values = Array.isArray(webSearch) ? [...webSearch] : [webSearch];
  const request = vi.fn(async () => ({ webSearch: values.shift() ?? false }));
  const client = { request } as unknown as CodexAppServerClient;
-  const release = vi.fn();
-  const clientFactory = vi.fn(async () => ({
-    client,
-    release,
-  })) as CodexAppServerClientLeaseFactory;
-  return { clientFactory, release, request };
+  const clientFactory = vi.fn(async () => client) as unknown as CodexAppServerClientFactory;
+  return { clientFactory, request };
 }

 function resolveSupport(
-  clientFactory: CodexAppServerClientLeaseFactory,
+  clientFactory: CodexAppServerClientFactory,
  modelProviderOverride?: string,
 ) {
  return resolveCodexProviderWebSearchSupport({
@@ -54,7 +50,7 @@ describe("resolveCodexProviderWebSearchSupport", () => {
  it("reports unknown support when app-server startup fails", async () => {
    const clientFactory = vi.fn(async () => {
      throw new Error("old app-server");
-    }) as CodexAppServerClientLeaseFactory;
+    }) as unknown as CodexAppServerClientFactory;

    await expect(resolveSupport(clientFactory)).resolves.toBe("unknown");
  });
@@ -64,15 +60,10 @@ describe("resolveCodexProviderWebSearchSupport", () => {
      throw new Error("transient rpc failure");
    });
    const client = { request } as unknown as CodexAppServerClient;
-    const release = vi.fn();
-    const clientFactory = vi.fn(async () => ({
-      client,
-      release,
-    })) as CodexAppServerClientLeaseFactory;
+    const clientFactory = vi.fn(async () => client) as unknown as CodexAppServerClientFactory;

    await expect(resolveSupport(clientFactory)).resolves.toBe("unknown");
    expect(request).toHaveBeenCalledOnce();
-    expect(release).toHaveBeenCalledOnce();
  });

  it("keeps managed search when the configured provider reports no hosted support", async () => {
--- a/extensions/codex/src/app-server/provider-capabilities.ts
+++ b/extensions/codex/src/app-server/provider-capabilities.ts
@@ -1,10 +1,8 @@
 import type { EmbeddedRunAttemptParams } from "openclaw/plugin-sdk/agent-harness-runtime";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import type { CodexAppServerClient } from "./client.js";
 import type { CodexAppServerRuntimeOptions } from "./config.js";
-import type {
-  CodexAppServerClientLease,
-  CodexAppServerClientLeaseFactory,
-} from "./shared-client.js";
+import { releaseLeasedSharedCodexAppServerClient } from "./shared-client.js";
 import type { CodexNativeWebSearchSupport } from "./web-search.js";

 async function readConfiguredProviderWebSearchSupport(params: {
@@ -47,7 +45,7 @@ export async function resolveCodexProviderWebSearchSupportForClient(params: {
 }

 export async function resolveCodexProviderWebSearchSupport(params: {
-  clientFactory: CodexAppServerClientLeaseFactory;
+  clientFactory: CodexAppServerClientFactory;
  appServer: CodexAppServerRuntimeOptions;
  authProfileId: string | undefined;
  agentDir: string;
@@ -55,17 +53,17 @@ export async function resolveCodexProviderWebSearchSupport(params: {
  modelProviderOverride: string | undefined;
  signal: AbortSignal;
 }): Promise<CodexNativeWebSearchSupport> {
-  let lease: CodexAppServerClientLease | undefined;
+  let client: CodexAppServerClient | undefined;
  try {
-    lease = await params.clientFactory({
-      startOptions: params.appServer.start,
-      authProfileId: params.authProfileId,
-      agentDir: params.agentDir,
-      config: params.config,
-      timeoutMs: params.appServer.requestTimeoutMs,
-    });
+    client = await params.clientFactory(
+      params.appServer.start,
+      params.authProfileId,
+      params.agentDir,
+      params.config,
+      { timeoutMs: params.appServer.requestTimeoutMs },
+    );
    return await resolveCodexProviderWebSearchSupportForClient({
-      client: lease.client,
+      client,
      timeoutMs: params.appServer.requestTimeoutMs,
      modelProviderOverride: params.modelProviderOverride,
      signal: params.signal,
@@ -73,6 +71,8 @@ export async function resolveCodexProviderWebSearchSupport(params: {
  } catch {
    return "unknown";
  } finally {
-    lease?.release();
+    if (client) {
+      releaseLeasedSharedCodexAppServerClient(client);
+    }
  }
 }
--- a/extensions/codex/src/app-server/rate-limit-cache.test.ts
+++ b/extensions/codex/src/app-server/rate-limit-cache.test.ts
@@ -1,124 +0,0 @@
-// Codex tests cover physical-client rate-limit snapshot ownership and rolling merges.
-import { describe, expect, it } from "vitest";
-import type { CodexAppServerClient } from "./client.js";
-import {
-  mergeCodexRateLimitsUpdate,
-  readCodexRateLimitsRevision,
-  readRecentCodexRateLimits,
-  rememberCodexRateLimitsRead,
-} from "./rate-limit-cache.js";
-
-function clientIdentity(): CodexAppServerClient {
-  return {} as unknown as CodexAppServerClient;
-}
-
-describe("Codex rate-limit cache", () => {
-  it("isolates snapshots by physical client", () => {
-    const first = clientIdentity();
-    const second = clientIdentity();
-    expect(readCodexRateLimitsRevision(first)).toBe(0);
-    rememberCodexRateLimitsRead(first, { rateLimits: { limitId: "first" } }, 100);
-    rememberCodexRateLimitsRead(second, { rateLimits: { limitId: "second" } }, 200);
-    expect(readCodexRateLimitsRevision(first, "first")).toBe(1);
-    expect(readCodexRateLimitsRevision(second, "second")).toBe(1);
-
-    expect(readRecentCodexRateLimits(first, { nowMs: 250 })).toEqual({
-      rateLimits: { limitId: "first" },
-    });
-    expect(readRecentCodexRateLimits(second, { nowMs: 250 })).toEqual({
-      rateLimits: { limitId: "second" },
-    });
-    expect(readRecentCodexRateLimits(first, { nowMs: 301, maxAgeMs: 200 })).toBeUndefined();
-    expect(readRecentCodexRateLimits(second, { nowMs: 301, maxAgeMs: 200 })).toEqual({
-      rateLimits: { limitId: "second" },
-    });
-  });
-
-  it("merges sparse rolling updates without clearing account metadata", () => {
-    const client = clientIdentity();
-    const codexSnapshot = {
-      limitId: "codex",
-      limitName: "Codex",
-      primary: { usedPercent: 10, windowDurationMins: 300, resetsAt: 1000 },
-      secondary: { usedPercent: 20, windowDurationMins: 10_080, resetsAt: 2000 },
-      credits: { hasCredits: true, unlimited: false, balance: "5" },
-      individualLimit: {
-        limit: "25000",
-        used: "8000",
-        remainingPercent: 68,
-        resetsAt: 3000,
-      },
-      planType: "pro",
-      rateLimitReachedType: "rate_limit_reached",
-    };
-    const otherSnapshot = {
-      limitId: "codex_other",
-      limitName: "Other",
-      primary: { usedPercent: 30, windowDurationMins: 60, resetsAt: 4000 },
-      secondary: null,
-      credits: null,
-      individualLimit: null,
-      planType: "pro",
-      rateLimitReachedType: null,
-    };
-    rememberCodexRateLimitsRead(client, {
-      rateLimits: codexSnapshot,
-      rateLimitsByLimitId: { codex: codexSnapshot, codex_other: otherSnapshot },
-    });
-
-    mergeCodexRateLimitsUpdate(client, {
-      rateLimits: {
-        limitId: null,
-        limitName: null,
-        primary: { usedPercent: 90, windowDurationMins: 300, resetsAt: 5000 },
-        secondary: null,
-        credits: null,
-        individualLimit: null,
-        planType: null,
-        rateLimitReachedType: null,
-      },
-    });
-    mergeCodexRateLimitsUpdate(client, {
-      rateLimits: {
-        limitId: "codex_other",
-        limitName: null,
-        primary: { usedPercent: 75, windowDurationMins: 60, resetsAt: 6000 },
-        secondary: null,
-        credits: null,
-        individualLimit: null,
-        planType: null,
-        rateLimitReachedType: null,
-      },
-    });
-    expect(readCodexRateLimitsRevision(client)).toBe(2);
-    expect(readCodexRateLimitsRevision(client, "codex_other")).toBe(2);
-
-    const mergedCodexSnapshot = {
-      limitId: "codex",
-      limitName: null,
-      primary: { usedPercent: 90, windowDurationMins: 300, resetsAt: 5000 },
-      secondary: null,
-      credits: codexSnapshot.credits,
-      individualLimit: codexSnapshot.individualLimit,
-      planType: "pro",
-      rateLimitReachedType: null,
-    };
-    const mergedOtherSnapshot = {
-      limitId: "codex_other",
-      limitName: null,
-      primary: { usedPercent: 75, windowDurationMins: 60, resetsAt: 6000 },
-      secondary: null,
-      credits: codexSnapshot.credits,
-      individualLimit: codexSnapshot.individualLimit,
-      planType: "pro",
-      rateLimitReachedType: null,
-    };
-    expect(readRecentCodexRateLimits(client)).toEqual({
-      rateLimits: mergedCodexSnapshot,
-      rateLimitsByLimitId: {
-        codex: mergedCodexSnapshot,
-        codex_other: mergedOtherSnapshot,
-      },
-    });
-  });
-});
--- a/extensions/codex/src/app-server/rate-limit-cache.ts
+++ b/extensions/codex/src/app-server/rate-limit-cache.ts
@@ -1,166 +1,55 @@
-/** Client-owned Codex app-server rate-limit snapshots. */
-import type { CodexAppServerClient } from "./client.js";
-import { isJsonObject, type JsonObject, type JsonValue } from "./protocol.js";
+/**
+ * Keeps the latest Codex app-server rate-limit payload in process-global state
+ * so failure handling can enrich later usage-limit errors.
+ */
+import type { JsonValue } from "./protocol.js";

 const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 10 * 60_000;
-const SPARSE_ACCOUNT_METADATA_KEYS = ["credits", "individualLimit", "planType"] as const;
+const CODEX_RATE_LIMIT_CACHE_STATE = Symbol.for("openclaw.codexRateLimitCacheState");

 type CodexRateLimitCacheState = {
-  value: JsonValue;
-  updatedAtMs: number;
-  revisionsByLimitId: Record<string, number>;
+  value?: JsonValue;
+  updatedAtMs?: number;
 };

-const rateLimitsByClient = new WeakMap<CodexAppServerClient, CodexRateLimitCacheState>();
-
-/** Replaces one physical client's cache with an authoritative rate-limit read response. */
-export function rememberCodexRateLimitsRead(
-  client: CodexAppServerClient,
-  value: JsonValue | undefined,
-  nowMs = Date.now(),
-): void {
-  if (value !== undefined) {
-    const currentState = rateLimitsByClient.get(client);
-    const revisionsByLimitId = { ...currentState?.revisionsByLimitId };
-    for (const limitId of readRateLimitIds(value)) {
-      revisionsByLimitId[limitId] = (revisionsByLimitId[limitId] ?? 0) + 1;
-    }
-    rateLimitsByClient.set(client, {
-      value,
-      updatedAtMs: nowMs,
-      revisionsByLimitId,
-    });
-  }
+function getCodexRateLimitCacheState(): CodexRateLimitCacheState {
+  const globalState = globalThis as typeof globalThis & {
+    [CODEX_RATE_LIMIT_CACHE_STATE]?: CodexRateLimitCacheState;
+  };
+  globalState[CODEX_RATE_LIMIT_CACHE_STATE] ??= {};
+  return globalState[CODEX_RATE_LIMIT_CACHE_STATE];
 }

-/** Merges a sparse rolling notification into one physical client's latest read response. */
-export function mergeCodexRateLimitsUpdate(
-  client: CodexAppServerClient,
-  value: JsonValue | undefined,
-  nowMs = Date.now(),
-): void {
-  const update =
-    isJsonObject(value) && isJsonObject(value.rateLimits) ? value.rateLimits : undefined;
-  if (!update) {
+/** Stores a non-empty Codex rate-limit payload with its observation time. */
+export function rememberCodexRateLimits(value: JsonValue | undefined, nowMs = Date.now()): void {
+  if (value === undefined) {
    return;
  }
-  const currentState = rateLimitsByClient.get(client);
-  const current = currentState?.value;
-  const limitId = readLimitId(update);
-  rateLimitsByClient.set(client, {
-    value: mergeRateLimitUpdate(current, update),
-    updatedAtMs: nowMs,
-    revisionsByLimitId: {
-      ...currentState?.revisionsByLimitId,
-      [limitId]: (currentState?.revisionsByLimitId[limitId] ?? 0) + 1,
-    },
-  });
+  const state = getCodexRateLimitCacheState();
+  state.value = value;
+  state.updatedAtMs = nowMs;
 }

-/** Per-limit marker used to trust only primary Codex updates from one turn startup. */
-export function readCodexRateLimitsRevision(
-  client: CodexAppServerClient,
-  limitId = "codex",
-): number {
-  return rateLimitsByClient.get(client)?.revisionsByLimitId[limitId] ?? 0;
-}
-
-/** Reads one physical client's cached rate-limit payload within the max-age window. */
-export function readRecentCodexRateLimits(
-  client: CodexAppServerClient,
-  options?: {
-    nowMs?: number;
-    maxAgeMs?: number;
-  },
-): JsonValue | undefined {
-  const state = rateLimitsByClient.get(client);
-  if (!state) {
+/** Reads the cached Codex rate-limit payload when it is still within the max-age window. */
+export function readRecentCodexRateLimits(options?: {
+  nowMs?: number;
+  maxAgeMs?: number;
+}): JsonValue | undefined {
+  const state = getCodexRateLimitCacheState();
+  if (state.value === undefined || state.updatedAtMs === undefined) {
    return undefined;
  }
  const nowMs = options?.nowMs ?? Date.now();
  const maxAgeMs = options?.maxAgeMs ?? DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS;
-  return maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs ? undefined : state.value;
+  if (maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs) {
+    return undefined;
+  }
+  return state.value;
 }

-function mergeRateLimitUpdate(current: JsonValue | undefined, update: JsonObject): JsonObject {
-  const currentEnvelope = isJsonObject(current) ? current : undefined;
-  const currentPrimary =
-    currentEnvelope && isJsonObject(currentEnvelope.rateLimits)
-      ? currentEnvelope.rateLimits
-      : undefined;
-  const currentByLimitId =
-    currentEnvelope && isJsonObject(currentEnvelope.rateLimitsByLimitId)
-      ? currentEnvelope.rateLimitsByLimitId
-      : undefined;
-  const limitId = readLimitId(update);
-  const currentPrimaryLimitId = currentPrimary ? readLimitId(currentPrimary) : undefined;
-  const currentForLimit =
-    (currentByLimitId && isJsonObject(currentByLimitId[limitId])
-      ? currentByLimitId[limitId]
-      : undefined) ?? (currentPrimaryLimitId === limitId ? currentPrimary : undefined);
-  const merged = mergeSparseSnapshot(
-    isJsonObject(currentForLimit) ? currentForLimit : undefined,
-    currentPrimary,
-    update,
-    limitId,
-  );
-  const nextPrimary =
-    !currentPrimary || currentPrimaryLimitId === limitId ? merged : currentPrimary;
-  let nextByLimitId: JsonObject | undefined;
-  if (currentByLimitId) {
-    nextByLimitId = { ...currentByLimitId, [limitId]: merged };
-  } else if (currentPrimary && currentPrimaryLimitId && currentPrimaryLimitId !== limitId) {
-    nextByLimitId = {
-      [currentPrimaryLimitId]: currentPrimary,
-      [limitId]: merged,
-    };
-  }
-  return {
-    ...currentEnvelope,
-    rateLimits: nextPrimary,
-    ...(nextByLimitId ? { rateLimitsByLimitId: nextByLimitId } : {}),
-  };
-}
-
-function readRateLimitIds(value: JsonValue): string[] {
-  if (!isJsonObject(value)) {
-    return [];
-  }
-  const ids = new Set<string>();
-  if (isJsonObject(value.rateLimits)) {
-    ids.add(readLimitId(value.rateLimits));
-  }
-  if (isJsonObject(value.rateLimitsByLimitId)) {
-    for (const [key, snapshot] of Object.entries(value.rateLimitsByLimitId)) {
-      const snapshotLimitId =
-        isJsonObject(snapshot) && typeof snapshot.limitId === "string"
-          ? snapshot.limitId.trim()
-          : "";
-      ids.add(snapshotLimitId || key);
-    }
-  }
-  return [...ids];
-}
-
-function mergeSparseSnapshot(
-  current: JsonObject | undefined,
-  accountFallback: JsonObject | undefined,
-  update: JsonObject,
-  limitId: string,
-): JsonObject {
-  const merged: JsonObject = { ...update, limitId };
-  // Rolling updates serialize unavailable account metadata as null. Preserve
-  // only those sparse fields; window and reached-state nulls remain authoritative.
-  for (const key of SPARSE_ACCOUNT_METADATA_KEYS) {
-    const previous = current?.[key] ?? accountFallback?.[key];
-    if (merged[key] == null && previous != null) {
-      merged[key] = previous;
-    }
-  }
-  return merged;
-}
-
-function readLimitId(snapshot: JsonObject): string {
-  const value = snapshot.limitId;
-  return typeof value === "string" && value.trim() ? value.trim() : "codex";
+/** Clears the process-global rate-limit cache for deterministic tests. */
+export function resetCodexRateLimitCacheForTests(): void {
+  const state = getCodexRateLimitCacheState();
+  state.value = undefined;
+  state.updatedAtMs = undefined;
 }
--- a/extensions/codex/src/app-server/request.test.ts
+++ b/extensions/codex/src/app-server/request.test.ts
@@ -1,80 +1,23 @@
 // Codex tests cover request plugin behavior.
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { CodexAppServerClient } from "./client.js";
-import { readRecentCodexRateLimits } from "./rate-limit-cache.js";

 const sharedClientMocks = vi.hoisted(() => ({
-  abandon: vi.fn(async () => undefined),
  createIsolatedCodexAppServerClient: vi.fn(),
  getSharedCodexAppServerClient: vi.fn(),
-  release: vi.fn(),
 }));

 vi.mock("./shared-client.js", () => ({
  ...sharedClientMocks,
-  leaseSharedCodexAppServerClient: async (...args: unknown[]) => {
-    let settled = false;
-    return {
-      client: await sharedClientMocks.getSharedCodexAppServerClient(...args),
-      release: () => {
-        if (!settled) {
-          settled = true;
-          sharedClientMocks.release();
-        }
-      },
-      abandon: async () => {
-        if (!settled) {
-          settled = true;
-          await sharedClientMocks.abandon();
-        }
-      },
-    };
-  },
+  getLeasedSharedCodexAppServerClient: sharedClientMocks.getSharedCodexAppServerClient,
+  releaseLeasedSharedCodexAppServerClient: vi.fn(),
 }));

 const { requestCodexAppServerJson } = await import("./request.js");

-function resumeResponse(threadId: string) {
-  return {
-    thread: {
-      id: threadId,
-      sessionId: "session-1",
-      forkedFromId: null,
-      preview: "",
-      ephemeral: false,
-      modelProvider: "openai",
-      createdAt: 1,
-      updatedAt: 1,
-      status: { type: "idle" },
-      path: null,
-      cwd: "/repo",
-      cliVersion: "0.139.0",
-      source: "unknown",
-      agentNickname: null,
-      agentRole: null,
-      gitInfo: null,
-      name: null,
-      turns: [],
-    },
-    model: "gpt-5.5-codex",
-    modelProvider: "openai",
-    serviceTier: null,
-    cwd: "/repo",
-    instructionSources: [],
-    approvalPolicy: "never",
-    approvalsReviewer: "user",
-    sandbox: { type: "dangerFullAccess" },
-    permissionProfile: null,
-    reasoningEffort: null,
-  };
-}
-
 describe("requestCodexAppServerJson sandbox guard", () => {
  beforeEach(() => {
    sharedClientMocks.createIsolatedCodexAppServerClient.mockReset();
    sharedClientMocks.getSharedCodexAppServerClient.mockReset();
-    sharedClientMocks.release.mockClear();
-    sharedClientMocks.abandon.mockClear();
  });

  it("fails closed before raw app-server bypass methods in sandboxed sessions", async () => {
@@ -92,29 +35,6 @@ describe("requestCodexAppServerJson sandbox guard", () => {
    expect(sharedClientMocks.getSharedCodexAppServerClient).not.toHaveBeenCalled();
  });

-  it("uses the explicit agent sandbox for globally scoped session keys", async () => {
-    await expect(
-      requestCodexAppServerJson({
-        method: "command/exec",
-        requestParams: { command: ["sh", "-lc", "id"] },
-        config: {
-          agents: {
-            list: [
-              { id: "main", default: true, sandbox: { mode: "off" } },
-              { id: "work", sandbox: { mode: "all" } },
-            ],
-          },
-        },
-        agentId: "work",
-        sessionKey: "global-session",
-      }),
-    ).rejects.toThrow(
-      "Codex-native app-server method `command/exec` is unavailable because OpenClaw sandboxing is active for this session.",
-    );
-
-    expect(sharedClientMocks.getSharedCodexAppServerClient).not.toHaveBeenCalled();
-  });
-
  it("fails closed before raw app-server bypass methods when exec host=node is active", async () => {
    for (const method of ["command/exec", "process/spawn"]) {
      await expect(
@@ -145,31 +65,7 @@ describe("requestCodexAppServerJson sandbox guard", () => {
      }),
    ).resolves.toEqual({ ok: true });

-    expect(request).toHaveBeenCalledWith(
-      "thread/list",
-      { limit: 10 },
-      expect.objectContaining({
-        timeoutMs: expect.any(Number),
-        signal: expect.any(AbortSignal),
-      }),
-    );
-  });
-
-  it("records full rate-limit reads on the physical control client", async () => {
-    const snapshot = { rateLimits: { limitId: "codex", primary: { usedPercent: 12 } } };
-    const client = {
-      request: vi.fn(async () => snapshot),
-    } as unknown as CodexAppServerClient;
-    sharedClientMocks.getSharedCodexAppServerClient.mockResolvedValue(client);
-
-    await expect(
-      requestCodexAppServerJson({
-        method: "account/rateLimits/read",
-        requestParams: undefined,
-      }),
-    ).resolves.toEqual(snapshot);
-
-    expect(readRecentCodexRateLimits(client)).toEqual(snapshot);
+    expect(request).toHaveBeenCalledWith("thread/list", { limit: 10 }, { timeoutMs: 60_000 });
  });

  it("fails closed for config-level exec host=node even without a session key", async () => {
@@ -213,125 +109,11 @@ describe("requestCodexAppServerJson sandbox guard", () => {
      }),
    ).resolves.toEqual({ ok: true });

-    expect(request).toHaveBeenCalledWith(
-      "thread/list",
-      { limit: 10 },
-      expect.objectContaining({
-        timeoutMs: expect.any(Number),
-        signal: expect.any(AbortSignal),
-      }),
-    );
-  });
-
-  it("unsubscribes owned resumes but abandons a mismatched response", async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValueOnce(resumeResponse("thread-1"))
-      .mockResolvedValueOnce({})
-      .mockRejectedValueOnce(new Error("resume response lost"))
-      .mockResolvedValueOnce(resumeResponse("wrong-thread"));
-    sharedClientMocks.getSharedCodexAppServerClient.mockResolvedValue({
-      request,
-      addNotificationHandler: vi.fn(() => () => undefined),
-    });
-
-    await expect(
-      requestCodexAppServerJson({
-        method: "thread/resume",
-        requestParams: { threadId: "thread-1" },
-      }),
-    ).resolves.toMatchObject({ thread: { id: "thread-1" } });
-    await expect(
-      requestCodexAppServerJson({
-        method: "thread/resume",
-        requestParams: { threadId: "thread-2" },
-      }),
-    ).rejects.toThrow("resume response lost");
-    await expect(
-      requestCodexAppServerJson({
-        method: "thread/resume",
-        requestParams: { threadId: "thread-3" },
-      }),
-    ).rejects.toThrow("Codex thread/resume returned wrong-thread for thread-3");
-
-    expect(request.mock.calls.map(([method, params]) => [method, params])).toEqual([
-      ["thread/resume", { threadId: "thread-1" }],
-      ["thread/unsubscribe", { threadId: "thread-1" }],
-      ["thread/resume", { threadId: "thread-2" }],
-      ["thread/resume", { threadId: "thread-3" }],
-    ]);
-    expect(sharedClientMocks.abandon).toHaveBeenCalledTimes(2);
-  });
-
-  it("does not release a thread owner when the request deadline expires before resume", async () => {
-    const request = vi.fn();
-    sharedClientMocks.getSharedCodexAppServerClient.mockResolvedValue({ request });
-    const now = vi.spyOn(Date, "now").mockReturnValueOnce(0).mockReturnValue(10);
-
-    await expect(
-      requestCodexAppServerJson({
-        method: "thread/resume",
-        requestParams: { threadId: "thread-1" },
-        timeoutMs: 1,
-      }),
-    ).rejects.toThrow("codex app-server thread/resume timed out");
-
-    expect(request).not.toHaveBeenCalled();
-    expect(sharedClientMocks.release).toHaveBeenCalledOnce();
-    expect(sharedClientMocks.abandon).not.toHaveBeenCalled();
-    now.mockRestore();
-  });
-
-  it("retires an isolated client that resolves after the end-to-end deadline", async () => {
-    let resolveClient!: (client: CodexAppServerClient) => void;
-    sharedClientMocks.createIsolatedCodexAppServerClient.mockImplementationOnce(
-      async () =>
-        await new Promise<CodexAppServerClient>((resolve) => {
-          resolveClient = resolve;
-        }),
-    );
-    const request = vi.fn();
-    const closeAndWait = vi.fn(async () => undefined);
-    const response = requestCodexAppServerJson({
-      method: "model/list",
-      requestParams: { limit: 10 },
-      isolated: true,
-      timeoutMs: 5,
-    });
-
-    await expect(response).rejects.toThrow("codex app-server model/list timed out");
-    resolveClient({ request, closeAndWait } as unknown as CodexAppServerClient);
-    await vi.waitFor(() => expect(closeAndWait).toHaveBeenCalledOnce());
-
-    expect(request).not.toHaveBeenCalled();
-  });
-
-  it("does not let isolated teardown extend the caller deadline", async () => {
-    const request = vi.fn(async () => ({ data: [] }));
-    const closeAndWait = vi.fn(async () => await new Promise<void>(() => {}));
-    sharedClientMocks.createIsolatedCodexAppServerClient.mockResolvedValue({
-      request,
-      closeAndWait,
-    });
-
-    await expect(
-      requestCodexAppServerJson({
-        method: "model/list",
-        requestParams: { limit: 10 },
-        isolated: true,
-        timeoutMs: 5,
-      }),
-    ).rejects.toThrow("codex app-server model/list timed out");
-
-    expect(request).toHaveBeenCalledOnce();
-    expect(closeAndWait).toHaveBeenCalledOnce();
+    expect(request).toHaveBeenCalledWith("thread/list", { limit: 10 }, { timeoutMs: 60_000 });
  });

  it("allows sandbox-pinned thread starts in sandboxed sessions", async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValueOnce({ thread: { id: "thread-1" }, model: "gpt-5.5" })
-      .mockResolvedValueOnce({});
+    const request = vi.fn(async () => ({ thread: { id: "thread-1" }, model: "gpt-5.5" }));
    sharedClientMocks.getSharedCodexAppServerClient.mockResolvedValue({ request });
    const params = {
      cwd: "/workspace",
@@ -347,44 +129,7 @@ describe("requestCodexAppServerJson sandbox guard", () => {
      }),
    ).resolves.toEqual({ thread: { id: "thread-1" }, model: "gpt-5.5" });

-    expect(request.mock.calls).toEqual([
-      [
-        "thread/start",
-        params,
-        expect.objectContaining({
-          timeoutMs: expect.any(Number),
-          signal: expect.any(AbortSignal),
-        }),
-      ],
-      ["thread/unsubscribe", { threadId: "thread-1" }, { timeoutMs: 5_000 }],
-    ]);
-  });
-
-  it("unsubscribes one-shot shared thread forks", async () => {
-    const request = vi
-      .fn()
-      .mockResolvedValueOnce({ thread: { id: "child-thread" } })
-      .mockResolvedValueOnce({});
-    sharedClientMocks.getSharedCodexAppServerClient.mockResolvedValue({ request });
-
-    await expect(
-      requestCodexAppServerJson({
-        method: "thread/fork",
-        requestParams: { threadId: "parent-thread" },
-      }),
-    ).resolves.toEqual({ thread: { id: "child-thread" } });
-
-    expect(request.mock.calls).toEqual([
-      [
-        "thread/fork",
-        { threadId: "parent-thread" },
-        expect.objectContaining({
-          timeoutMs: expect.any(Number),
-          signal: expect.any(AbortSignal),
-        }),
-      ],
-      ["thread/unsubscribe", { threadId: "child-thread" }, { timeoutMs: 5_000 }],
-    ]);
+    expect(request).toHaveBeenCalledWith("thread/start", params, { timeoutMs: 60_000 });
  });

  it("blocks thread starts with sandbox environments when exec host=node is active", async () => {
--- a/extensions/codex/src/app-server/request.ts
+++ b/extensions/codex/src/app-server/request.ts
@@ -1,30 +1,21 @@
-import {
-  CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-  CodexAppServerUnsafeSubscriptionError,
-  settleCodexAppServerClientLease,
-} from "./attempt-client-cleanup.js";
 /**
 * Sends typed JSON-RPC requests to the Codex app-server with sandbox guard
 * checks, shared-client leasing, and isolated-client shutdown handling.
 */
 import type { resolveCodexAppServerAuthProfileIdForAgent } from "./auth-bridge.js";
 import type { CodexAppServerStartOptions } from "./config.js";
-import {
-  isJsonObject,
-  readCodexThreadCreationResponseId,
-  type CodexAppServerRequestMethod,
-  type CodexAppServerRequestParams,
-  type CodexAppServerRequestResult,
-  type CodexThreadResumeParams,
-  type JsonValue,
+import type {
+  CodexAppServerRequestMethod,
+  CodexAppServerRequestParams,
+  CodexAppServerRequestResult,
+  JsonValue,
 } from "./protocol.js";
-import { rememberCodexRateLimitsRead } from "./rate-limit-cache.js";
 import { resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard.js";
 import {
  createIsolatedCodexAppServerClient,
-  leaseSharedCodexAppServerClient,
+  getLeasedSharedCodexAppServerClient,
+  releaseLeasedSharedCodexAppServerClient,
 } from "./shared-client.js";
-import { resumeCodexAppServerThread } from "./thread-resume.js";
 import { withTimeout } from "./timeout.js";

 /** Sends a typed Codex app-server request and returns the method-specific response shape. */
@@ -34,7 +25,6 @@ export async function requestCodexAppServerJson<M extends CodexAppServerRequestM
  timeoutMs?: number;
  startOptions?: CodexAppServerStartOptions;
  authProfileId?: string | null;
-  agentId?: string;
  agentDir?: string;
  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
  sessionKey?: string;
@@ -47,7 +37,6 @@ export async function requestCodexAppServerJson<T = JsonValue | undefined>(param
  timeoutMs?: number;
  startOptions?: CodexAppServerStartOptions;
  authProfileId?: string | null;
-  agentId?: string;
  agentDir?: string;
  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
  sessionKey?: string;
@@ -60,7 +49,6 @@ export async function requestCodexAppServerJson<T = JsonValue | undefined>(param
  timeoutMs?: number;
  startOptions?: CodexAppServerStartOptions;
  authProfileId?: string | null;
-  agentId?: string;
  agentDir?: string;
  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
  sessionKey?: string;
@@ -71,7 +59,6 @@ export async function requestCodexAppServerJson<T = JsonValue | undefined>(param
    method: params.method,
    requestParams: params.requestParams,
    config: params.config,
-    agentId: params.agentId,
    sessionKey: params.sessionKey,
    sessionId: params.sessionId,
  });
@@ -79,112 +66,33 @@ export async function requestCodexAppServerJson<T = JsonValue | undefined>(param
    throw new Error(sandboxBlock);
  }
  const timeoutMs = params.timeoutMs ?? 60_000;
-  const timeoutMessage = `codex app-server ${params.method} timed out`;
-  const abortController = new AbortController();
-  const operation = (async () => {
-    const startedAt = Date.now();
-    const clientOptions = {
-      startOptions: params.startOptions,
-      timeoutMs,
-      authProfileId: params.authProfileId,
-      agentDir: params.agentDir,
-      config: params.config,
-      abandonSignal: abortController.signal,
-    };
-    const clientLease = params.isolated
-      ? undefined
-      : await leaseSharedCodexAppServerClient(clientOptions);
-    const client = clientLease?.client ?? (await createIsolatedCodexAppServerClient(clientOptions));
-    const requestedThreadId =
-      params.method === "thread/resume" && isJsonObject(params.requestParams)
-        ? typeof params.requestParams.threadId === "string"
-          ? params.requestParams.threadId
-          : undefined
-        : undefined;
-    let subscribedThreadId: string | undefined;
-    let abandonClient = false;
-    try {
-      abortController.signal.throwIfAborted();
-      const requestTimeoutMs = remainingRequestTimeoutMs(startedAt, timeoutMs, params.method);
-      let response: T;
-      if (params.method === "thread/resume" && requestedThreadId) {
-        subscribedThreadId = requestedThreadId;
-        response = (await resumeCodexAppServerThread({
-          client,
-          abandonClient: clientLease
-            ? clientLease.abandon
-            : async () =>
-                await client.closeAndWait({ exitTimeoutMs: 2_000, forceKillDelayMs: 250 }),
-          request: params.requestParams as CodexThreadResumeParams,
-          timeoutMs: requestTimeoutMs,
-          signal: abortController.signal,
-        })) as T;
-      } else {
-        response = await client.request<T>(params.method, params.requestParams, {
-          timeoutMs: requestTimeoutMs,
-          signal: abortController.signal,
-        });
-      }
-      if (params.method === "account/rateLimits/read") {
-        rememberCodexRateLimitsRead(client, response as JsonValue | undefined);
-      }
-      if (isThreadSubscriptionMethod(params.method)) {
-        const returnedThreadId = readCodexThreadCreationResponseId(response);
-        if (!returnedThreadId) {
-          abandonClient = true;
-          throw new CodexAppServerUnsafeSubscriptionError(
-            `Codex ${params.method} response omitted its thread id`,
-          );
-        }
-        if (params.method === "thread/resume") {
-          if (!requestedThreadId) {
-            abandonClient = true;
-            throw new CodexAppServerUnsafeSubscriptionError(
-              "Codex thread/resume succeeded without a requested thread id",
-            );
-          }
+  return await withTimeout(
+    (async () => {
+      const client = await (
+        params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient
+      )({
+        startOptions: params.startOptions,
+        timeoutMs,
+        authProfileId: params.authProfileId,
+        agentDir: params.agentDir,
+        config: params.config,
+      });
+      try {
+        return await client.request<T>(params.method, params.requestParams, { timeoutMs });
+      } finally {
+        if (params.isolated) {
+          // Wait for the child to actually exit (with a SIGKILL fallback) so
+          // the parent process doesn't hang on an orphaned codex app-server.
+          // The stdio bin shim does not always propagate stdin EOF to the
+          // underlying codex binary, so the unref'd close() path can leave
+          // the child running and keep the parent's event loop alive.
+          await client.closeAndWait({ exitTimeoutMs: 2_000, forceKillDelayMs: 250 });
        } else {
-          subscribedThreadId = returnedThreadId;
+          releaseLeasedSharedCodexAppServerClient(client);
        }
      }
-      return response;
-    } catch (error) {
-      abandonClient ||= error instanceof CodexAppServerUnsafeSubscriptionError;
-      throw error;
-    } finally {
-      if (params.isolated) {
-        // Cleanup may outlive the caller's end-to-end deadline, but the outer
-        // timeout aborts all work and returns without orphaning the child.
-        await client.closeAndWait({ exitTimeoutMs: 2_000, forceKillDelayMs: 250 });
-      } else if (clientLease) {
-        await settleCodexAppServerClientLease(clientLease, {
-          threadId: subscribedThreadId,
-          timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-          abandon: abandonClient,
-        });
-      }
-    }
-  })();
-  try {
-    return await withTimeout(operation, timeoutMs, timeoutMessage);
-  } catch (error) {
-    abortController.abort(error);
-    void operation.catch(() => undefined);
-    throw error;
-  }
-}
-
-function remainingRequestTimeoutMs(startedAt: number, timeoutMs: number, method: string): number {
-  if (timeoutMs <= 0) {
-    return timeoutMs;
-  }
-  const remaining = timeoutMs - (Date.now() - startedAt);
-  if (remaining <= 0) {
-    throw new Error(`codex app-server ${method} timed out`);
-  }
-  return Math.max(1, remaining);
-}
-
-function isThreadSubscriptionMethod(method: string): boolean {
-  return method === "thread/start" || method === "thread/fork" || method === "thread/resume";
+    })(),
+    timeoutMs,
+    `codex app-server ${params.method} timed out`,
+  );
 }
--- a/extensions/codex/src/app-server/run-attempt-test-harness.ts
+++ b/extensions/codex/src/app-server/run-attempt-test-harness.ts
@@ -15,29 +15,19 @@ import { clearPluginCommands } from "openclaw/plugin-sdk/plugin-runtime";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
 import { afterEach, beforeEach, expect, vi } from "vitest";
 import { defaultCodexAppInventoryCache } from "./app-inventory-cache.js";
-import type { CodexAppServerClient } from "./client.js";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import { createCodexDynamicToolBridge } from "./dynamic-tools.js";
-import type { CodexServerNotification, CodexThread } from "./protocol.js";
+import type { CodexServerNotification } from "./protocol.js";
+import { resetCodexRateLimitCacheForTests } from "./rate-limit-cache.js";
 import {
  runCodexAppServerAttempt as runCodexAppServerAttemptImpl,
  testing,
 } from "./run-attempt.js";
 import { closeCodexSandboxExecServersForTests } from "./sandbox-exec-server.js";
-import {
-  registerCodexTestSessionIdentity,
-  resetCodexTestBindingStore,
-  testCodexAppServerBindingStore,
-} from "./session-binding.test-helpers.js";
-import type { CodexAppServerClientLeaseFactory } from "./shared-client.js";
-import {
-  adaptCodexTestClientFactory,
-  createCodexTestModel,
-  type CodexTestAppServerClientFactory,
-} from "./test-support.js";
+import { createCodexTestModel } from "./test-support.js";

 export let tempDir: string;
-let codexAppServerClientLeaseFactoryForTest: CodexAppServerClientLeaseFactory | undefined;
-const multiplexedTestClients = new WeakSet<CodexAppServerClient>();
+let codexAppServerClientFactoryForTest: CodexAppServerClientFactory | undefined;
 export const fastWait = { interval: 1, timeout: 5_000 } as const;
 const appServerHarnessWait = { interval: 1, timeout: 120_000 } as const;
 const activeAppServerAttemptsForTest = new Set<{
@@ -47,12 +37,9 @@ const activeAppServerAttemptsForTest = new Set<{
  sessionKey?: string;
 }>();

-type RunCodexAppServerAttemptImplOptions = NonNullable<
+type RunCodexAppServerAttemptOptions = NonNullable<
  Parameters<typeof runCodexAppServerAttemptImpl>[1]
 >;
-type RunCodexAppServerAttemptOptions = Omit<RunCodexAppServerAttemptImplOptions, "bindingStore"> & {
-  bindingStore?: RunCodexAppServerAttemptImplOptions["bindingStore"];
-};

 export function queueActiveRunMessageForTest(
  ...args: Parameters<typeof queueAgentHarnessMessage>
@@ -60,66 +47,19 @@ export function queueActiveRunMessageForTest(
  return queueAgentHarnessMessage(...args);
 }

-export function setCodexAppServerClientFactoryForTest(
-  factory: CodexTestAppServerClientFactory,
-): void {
-  codexAppServerClientLeaseFactoryForTest = adaptCodexTestClientFactory(async (...args) => {
-    const client = await factory(...args);
-    const testClient = client as unknown as {
-      addCloseHandler?: (handler: () => void) => () => void;
-    };
-    // Narrow test doubles still need the client lifecycle hook installed by
-    // the keyed router, even when the test never simulates transport closure.
-    testClient.addCloseHandler ??= () => () => undefined;
-    multiplexTestClientHandlers(client);
-    return client;
-  });
-}
-
-function multiplexTestClientHandlers(client: CodexAppServerClient): void {
-  if (multiplexedTestClients.has(client)) {
-    return;
-  }
-  multiplexedTestClients.add(client);
-  const notificationHandlers = new Set<
-    Parameters<CodexAppServerClient["addNotificationHandler"]>[0]
-  >();
-  const requestHandlers = new Set<Parameters<CodexAppServerClient["addRequestHandler"]>[0]>();
-  const addNotificationHandler = client.addNotificationHandler.bind(client);
-  const addRequestHandler = client.addRequestHandler.bind(client);
-  addNotificationHandler(async (notification) => {
-    await Promise.all(
-      [...notificationHandlers].map((handler) => Promise.resolve(handler(notification))),
-    );
-  });
-  addRequestHandler(async (request) => {
-    for (const handler of requestHandlers) {
-      const result = await handler(request);
-      if (result !== undefined) {
-        return result;
-      }
-    }
-    return undefined;
-  });
-  client.addNotificationHandler = (handler) => {
-    notificationHandlers.add(handler);
-    return () => notificationHandlers.delete(handler);
-  };
-  client.addRequestHandler = (handler) => {
-    requestHandlers.add(handler);
-    return () => requestHandlers.delete(handler);
-  };
+export function setCodexAppServerClientFactoryForTest(factory: CodexAppServerClientFactory): void {
+  codexAppServerClientFactoryForTest = factory;
 }

 function resetCodexAppServerClientFactoryForTest(): void {
-  codexAppServerClientLeaseFactoryForTest = undefined;
+  codexAppServerClientFactoryForTest = undefined;
 }

 export function runCodexAppServerAttempt(
  params: EmbeddedRunAttemptParams,
  options: RunCodexAppServerAttemptOptions = {},
 ) {
-  const clientLeaseFactory = options.clientLeaseFactory ?? codexAppServerClientLeaseFactoryForTest;
+  const clientFactory = options.clientFactory ?? codexAppServerClientFactoryForTest;
  const abortController = params.abortSignal ? undefined : new AbortController();
  const trackedParams = abortController
    ? ({ ...params, abortSignal: abortController.signal } as EmbeddedRunAttemptParams)
@@ -130,11 +70,10 @@ export function runCodexAppServerAttempt(
    sessionId: params.sessionId,
    sessionKey: params.sessionKey,
  };
-  const promise = runCodexAppServerAttemptImpl(trackedParams, {
-    ...options,
-    bindingStore: options.bindingStore ?? testCodexAppServerBindingStore,
-    ...(clientLeaseFactory ? { clientLeaseFactory } : {}),
-  }).finally(() => {
+  const promise = runCodexAppServerAttemptImpl(
+    trackedParams,
+    clientFactory ? { ...options, clientFactory } : options,
+  ).finally(() => {
    activeAppServerAttemptsForTest.delete(entry);
  });
  entry.promise = promise;
@@ -182,7 +121,6 @@ async function drainActiveAppServerAttemptsForTest(): Promise<void> {
 }

 export function createParams(sessionFile: string, workspaceDir: string): EmbeddedRunAttemptParams {
-  registerCodexTestSessionIdentity(sessionFile, "session-1", "agent:main:session-1");
  return {
    prompt: "hello",
    sessionId: "session-1",
@@ -300,7 +238,7 @@ export function threadStartResult(threadId = "thread-1") {
      agentRole: null,
      gitInfo: null,
      name: null,
-      turns: [] as CodexThread["turns"],
+      turns: [],
    },
    model: "gpt-5.4-codex",
    modelProvider: "openai",
@@ -363,73 +301,61 @@ export function createAppServerHarness(
  } = {},
 ) {
  const requests: Array<{ method: string; params: unknown }> = [];
-  const notificationHandlers = new Set<
-    (notification: CodexServerNotification) => Promise<void> | void
-  >();
-  const serverRequestHandlers = new Set<AppServerRequestHandler>();
+  let notifyHandler: ((notification: CodexServerNotification) => Promise<void>) | undefined;
+  let handleServerRequest: AppServerRequestHandler | undefined;
  const closeHandlers = new Set<() => void>();
  const request = vi.fn(async (method: string, params?: unknown, requestOptions?: unknown) => {
    requests.push({ method, params });
    return requestImpl(method, params, requestOptions as { signal?: AbortSignal } | undefined);
  });

-  const client = {
-    getServerVersion: () => "0.132.0",
-    request,
-    addNotificationHandler: (
-      handler: (notification: CodexServerNotification) => Promise<void> | void,
-    ) => {
-      notificationHandlers.add(handler);
-      return () => notificationHandlers.delete(handler);
-    },
-    addRequestHandler: (handler: AppServerRequestHandler) => {
-      serverRequestHandlers.add(handler);
-      return () => serverRequestHandlers.delete(handler);
-    },
-    addCloseHandler: (handler: () => void) => {
-      closeHandlers.add(handler);
-      return () => closeHandlers.delete(handler);
-    },
-  } as unknown as CodexAppServerClient;
  setCodexAppServerClientFactoryForTest(async (_startOptions, authProfileId, agentDir) => {
    options.onStart?.(authProfileId, agentDir);
-    return client;
+    return {
+      ...mockClientRuntimeMethods(),
+      request,
+      addNotificationHandler: (
+        handler: (notification: CodexServerNotification) => Promise<void>,
+      ) => {
+        notifyHandler = handler;
+        return () => {
+          if (notifyHandler === handler) {
+            notifyHandler = undefined;
+          }
+        };
+      },
+      addRequestHandler: (handler: AppServerRequestHandler) => {
+        handleServerRequest = handler;
+        return () => undefined;
+      },
+      addCloseHandler: (handler: () => void) => {
+        closeHandlers.add(handler);
+        return () => closeHandlers.delete(handler);
+      },
+    } as never;
  });

  const waitForServerRequestHandler = async () => {
-    await vi.waitFor(() => expect(serverRequestHandlers.size).toBeGreaterThan(0), {
+    await vi.waitFor(() => expect(handleServerRequest).toBeTypeOf("function"), {
      interval: 1,
      timeout: appServerHarnessWait.timeout,
    });
-    return async (requestLocal: Parameters<AppServerRequestHandler>[0]) => {
-      for (const handler of serverRequestHandlers) {
-        const result = await handler(requestLocal);
-        if (result !== undefined) {
-          return result;
-        }
-      }
-      return undefined;
-    };
+    return handleServerRequest!;
  };

  const waitForNotificationHandler = async () => {
-    await vi.waitFor(() => expect(notificationHandlers.size).toBeGreaterThan(0), {
+    await vi.waitFor(() => expect(notifyHandler).toBeTypeOf("function"), {
      interval: 1,
      timeout: appServerHarnessWait.timeout,
    });
-    return async (notification: CodexServerNotification) => {
-      await Promise.all(
-        [...notificationHandlers].map((handler) => Promise.resolve(handler(notification))),
-      );
-    };
+    return notifyHandler!;
  };
  const sendNotification = async (notification: CodexServerNotification) => {
-    const handler = await waitForNotificationHandler();
+    const handler = notifyHandler ?? (await waitForNotificationHandler());
    await handler(notification);
  };

  return {
-    client,
    request,
    requests,
    waitForMethod: async (method: string, timeoutMs: number = appServerHarnessWait.timeout) => {
@@ -502,10 +428,9 @@ export function createStartedThreadHarness(
 }

 export function createResumeHarness() {
-  return createAppServerHarness(async (method, params) => {
+  return createAppServerHarness(async (method) => {
    if (method === "thread/resume") {
-      const threadId = (params as { threadId?: unknown }).threadId;
-      return threadStartResult(typeof threadId === "string" ? threadId : "thread-existing");
+      return threadStartResult("thread-existing");
    }
    if (method === "turn/start") {
      return turnStartResult();
@@ -589,7 +514,6 @@ export function setupRunAttemptTestHooks(): void {
    clearMemoryPluginState();
    resetAgentEventsForTest();
    resetDiagnosticEventsForTest();
-    resetCodexTestBindingStore();
    vi.stubEnv("OPENCLAW_TRAJECTORY", "0");
    vi.stubEnv("CODEX_API_KEY", "");
    vi.stubEnv("OPENAI_API_KEY", "");
@@ -603,6 +527,7 @@ export function setupRunAttemptTestHooks(): void {
    testing.resetOpenClawCodingToolsFactoryForTests();
    testing.resetEnsuredCodexWorkspaceDirsForTests();
    testing.clearPendingCodexNativeHookRelayUnregistersForTests();
+    resetCodexRateLimitCacheForTests();
    nativeHookRelayTesting.clearNativeHookRelaysForTests();
    clearMemoryPluginState();
    clearPluginCommands();
--- a/extensions/codex/src/app-server/run-attempt-thread-cleanup.test.ts
+++ b/extensions/codex/src/app-server/run-attempt-thread-cleanup.test.ts
@@ -7,35 +7,10 @@ import {
  type EmbeddedRunAttemptParams,
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { CodexAppServerRpcError } from "./client.js";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
 import type { CodexServerNotification } from "./protocol.js";
 import { runCodexAppServerAttempt } from "./run-attempt.js";
-import { createCodexTestBindingStore } from "./session-binding.test-helpers.js";
-import {
-  adaptCodexTestClientFactory,
-  createCodexTestModel,
-  type CodexTestAppServerClientFactory,
-} from "./test-support.js";
-
-const configRuntimeMock = vi.hoisted(() => ({ rejectedProvider: undefined as string | undefined }));
-
-vi.mock("./config.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./config.js")>();
-  return {
-    ...actual,
-    resolveCodexAppServerRuntime: (
-      params: Parameters<typeof actual.resolveCodexAppServerRuntime>[0],
-    ) => {
-      if (
-        configRuntimeMock.rejectedProvider &&
-        params?.modelProvider === configRuntimeMock.rejectedProvider
-      ) {
-        throw new Error(`rejected active provider: ${params.modelProvider}`);
-      }
-      return actual.resolveCodexAppServerRuntime(params);
-    },
-  };
-});
+import { createCodexTestModel } from "./test-support.js";

 let tempDir: string;

@@ -130,7 +105,6 @@ describe("Codex app-server main thread cleanup", () => {
    vi.stubEnv("OPENCLAW_TRAJECTORY", "0");
    vi.stubEnv("CODEX_API_KEY", "");
    vi.stubEnv("OPENAI_API_KEY", "");
-    configRuntimeMock.rejectedProvider = undefined;
    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-run-cleanup-"));
  });

@@ -146,9 +120,7 @@ describe("Codex app-server main thread cleanup", () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
    const requests: Array<{ method: string; params: unknown }> = [];
-    const notificationHandlers = new Set<
-      (notification: CodexServerNotification) => Promise<void> | void
-    >();
+    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
    const request = vi.fn(async (method: string, params?: unknown) => {
      requests.push({ method, params });
      if (method === "thread/start") {
@@ -160,37 +132,33 @@ describe("Codex app-server main thread cleanup", () => {
      return {};
    });

-    const clientFactory: CodexTestAppServerClientFactory = async () => {
+    const clientFactory: CodexAppServerClientFactory = async () => {
      return {
        ...mockClientRuntimeMethods(),
        request,
-        addNotificationHandler: (handler: (notification: CodexServerNotification) => void) => {
-          notificationHandlers.add(handler);
-          return () => notificationHandlers.delete(handler);
+        addNotificationHandler: (handler: typeof notify) => {
+          notify = handler;
+          return () => undefined;
        },
        addRequestHandler: () => () => undefined,
-        addCloseHandler: () => () => undefined,
      } as never;
    };

    const run = runCodexAppServerAttempt(createParams(sessionFile, workspaceDir), {
-      bindingStore: createCodexTestBindingStore(),
-      clientLeaseFactory: adaptCodexTestClientFactory(clientFactory),
+      clientFactory,
    });
    await vi.waitFor(() => expect(requests.map((entry) => entry.method)).toContain("turn/start"), {
      interval: 1,
      timeout: 5_000,
    });
-    for (const handler of notificationHandlers) {
-      await handler({
-        method: "turn/completed",
-        params: {
-          threadId: "thread-1",
-          turnId: "turn-1",
-          turn: { id: "turn-1", status: "completed" },
-        },
-      });
-    }
+    await notify({
+      method: "turn/completed",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        turn: { id: "turn-1", status: "completed" },
+      },
+    });

    const result = await run;
    expect(result.aborted).toBe(false);
@@ -221,28 +189,20 @@ describe("Codex app-server main thread cleanup", () => {
      return {};
    });

-    const clientFactory: CodexTestAppServerClientFactory = async () => {
+    const clientFactory: CodexAppServerClientFactory = async () => {
      return {
        ...mockClientRuntimeMethods(),
        request,
        addNotificationHandler: () => () => undefined,
        addRequestHandler: () => () => undefined,
-        addCloseHandler: () => () => undefined,
      } as never;
    };
-    const abandon = vi.fn(async () => undefined);

    await expect(
      runCodexAppServerAttempt(createParams(sessionFile, workspaceDir), {
-        bindingStore: createCodexTestBindingStore(),
-        clientLeaseFactory: async () => ({
-          client: await clientFactory(),
-          release: () => undefined,
-          abandon,
-        }),
+        clientFactory,
      }),
    ).rejects.toThrow("turn start exploded");
-    expect(abandon).toHaveBeenCalledOnce();
    expect(requests.map((entry) => entry.method)).toEqual([
      "thread/start",
      "turn/start",
@@ -254,162 +214,4 @@ describe("Codex app-server main thread cleanup", () => {
      { timeoutMs: 5_000 },
    );
  });
-
-  it("releases startup ownership when authoritative provider policy rejects", async () => {
-    const sessionFile = path.join(tempDir, "session-policy-rejection.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace-policy-rejection");
-    const request = vi.fn(async (method: string) => {
-      if (method === "thread/start") {
-        const response = threadStartResult();
-        return {
-          ...response,
-          thread: { ...response.thread, modelProvider: "lmstudio" },
-          model: "local-model",
-          modelProvider: "lmstudio",
-        };
-      }
-      if (method === "thread/unsubscribe") {
-        return {};
-      }
-      throw new Error(`unexpected method: ${method}`);
-    });
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    configRuntimeMock.rejectedProvider = "lmstudio";
-
-    await expect(
-      runCodexAppServerAttempt(createParams(sessionFile, workspaceDir), {
-        bindingStore: createCodexTestBindingStore(),
-        clientLeaseFactory: async () => ({
-          client: {
-            request,
-            addNotificationHandler: () => () => undefined,
-            addRequestHandler: () => () => undefined,
-            addCloseHandler: () => () => undefined,
-          } as never,
-          release,
-          abandon,
-        }),
-      }),
-    ).rejects.toThrow("rejected active provider: lmstudio");
-
-    expect(request).toHaveBeenCalledWith(
-      "thread/unsubscribe",
-      { threadId: "thread-1" },
-      { timeoutMs: 5_000 },
-    );
-    expect(release).toHaveBeenCalledOnce();
-    expect(abandon).not.toHaveBeenCalled();
-  });
-
-  it("keeps the main client reusable after a structured turn rejection", async () => {
-    const sessionFile = path.join(tempDir, "session-rpc-rejection.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace-rpc-rejection");
-    const request = vi.fn(async (method: string) => {
-      if (method === "thread/start") {
-        return threadStartResult();
-      }
-      if (method === "turn/start") {
-        throw new CodexAppServerRpcError({ code: -32000, message: "turn rejected" }, method);
-      }
-      return {};
-    });
-    const abandon = vi.fn(async () => undefined);
-
-    await expect(
-      runCodexAppServerAttempt(createParams(sessionFile, workspaceDir), {
-        bindingStore: createCodexTestBindingStore(),
-        clientLeaseFactory: async () => ({
-          client: {
-            request,
-            addNotificationHandler: () => () => undefined,
-            addRequestHandler: () => () => undefined,
-            addCloseHandler: () => () => undefined,
-          } as never,
-          release: () => undefined,
-          abandon,
-        }),
-      }),
-    ).rejects.toThrow("turn rejected");
-
-    expect(abandon).not.toHaveBeenCalled();
-    expect(request).toHaveBeenCalledWith(
-      "thread/unsubscribe",
-      { threadId: "thread-1" },
-      { timeoutMs: 5_000 },
-    );
-  });
-
-  it("reuses one client router after each attempt releases its thread route", async () => {
-    const sessionFile = path.join(tempDir, "session-reused.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace-reused");
-    const bindingStore = createCodexTestBindingStore();
-    const notificationHandlers = new Set<
-      (notification: CodexServerNotification) => Promise<void> | void
-    >();
-    const requestHandlers = new Set<(request: unknown) => unknown>();
-    let turnIndex = 0;
-    const request = vi.fn(async (method: string) => {
-      if (method === "thread/start" || method === "thread/resume") {
-        return threadStartResult();
-      }
-      if (method === "turn/start") {
-        turnIndex += 1;
-        return turnStartResult(`turn-${turnIndex}`);
-      }
-      return {};
-    });
-    const addNotificationHandler = vi.fn(
-      (handler: (notification: CodexServerNotification) => Promise<void> | void) => {
-        notificationHandlers.add(handler);
-        return () => notificationHandlers.delete(handler);
-      },
-    );
-    const addRequestHandler = vi.fn((handler: (request: unknown) => unknown) => {
-      requestHandlers.add(handler);
-      return () => requestHandlers.delete(handler);
-    });
-    const client = {
-      request,
-      addNotificationHandler,
-      addRequestHandler,
-      addCloseHandler: () => () => undefined,
-    };
-    const clientFactory: CodexTestAppServerClientFactory = async () => client as never;
-
-    const runAttempt = async (turnId: string, expectedTurnStartCount: number) => {
-      const run = runCodexAppServerAttempt(createParams(sessionFile, workspaceDir), {
-        bindingStore,
-        clientLeaseFactory: adaptCodexTestClientFactory(clientFactory),
-      });
-      await vi.waitFor(
-        () =>
-          expect(request.mock.calls.filter(([method]) => method === "turn/start")).toHaveLength(
-            expectedTurnStartCount,
-          ),
-        { interval: 1, timeout: 5_000 },
-      );
-      for (const handler of notificationHandlers) {
-        void handler({
-          method: "turn/completed",
-          params: {
-            threadId: "thread-1",
-            turnId,
-            turn: { id: turnId, threadId: "thread-1", status: "completed" },
-          },
-        });
-      }
-      return await run;
-    };
-
-    await expect(runAttempt("turn-1", 1)).resolves.toMatchObject({ aborted: false });
-    const notificationHandlerCount = addNotificationHandler.mock.calls.length;
-    const requestHandlerCount = addRequestHandler.mock.calls.length;
-    await expect(runAttempt("turn-2", 2)).resolves.toMatchObject({ aborted: false });
-
-    expect(addNotificationHandler).toHaveBeenCalledTimes(notificationHandlerCount);
-    expect(addRequestHandler).toHaveBeenCalledTimes(requestHandlerCount);
-    expect(notificationHandlers.size).toBe(notificationHandlerCount);
-    expect(requestHandlers.size).toBe(requestHandlerCount);
-  });
 });
--- a/extensions/codex/src/app-server/run-attempt.context-engine.test.ts
+++ b/extensions/codex/src/app-server/run-attempt.context-engine.test.ts
@@ -17,63 +17,43 @@ import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-de
 import { createMockPluginRegistry } from "openclaw/plugin-sdk/plugin-test-runtime";
 import { registerSandboxBackend } from "openclaw/plugin-sdk/sandbox";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { CodexAppServerClient } from "./client.js";
+import type { CodexAppServerClientFactory } from "./client-factory.js";
+import { CODEX_TURN_START_TEXT_INPUT_MAX_CHARS } from "./context-engine-projection.js";
 import type { CodexServerNotification } from "./protocol.js";
 import { runCodexAppServerAttempt as runCodexAppServerAttemptImpl } from "./run-attempt.js";
 import {
-  clearCodexAppServerBinding,
  readCodexAppServerBinding,
-  registerCodexTestSessionIdentity,
-  resetCodexTestBindingStore,
-  testCodexAppServerBindingStore,
-  writeCodexAppServerBinding as writeStoredCodexAppServerBinding,
-} from "./session-binding.test-helpers.js";
-import type { CodexAppServerClientLeaseFactory } from "./shared-client.js";
-import {
-  adaptCodexTestClientFactory,
-  createCodexTestModel,
-  type CodexTestAppServerClientFactory,
-} from "./test-support.js";
+  writeCodexAppServerBinding as writeRawCodexAppServerBinding,
+} from "./session-binding.js";
+import { createCodexTestModel } from "./test-support.js";

 let tempDir: string;
-let codexAppServerClientLeaseFactoryForTest: CodexAppServerClientLeaseFactory | undefined;
+let codexAppServerClientFactoryForTest: CodexAppServerClientFactory | undefined;

-type RunCodexAppServerAttemptImplOptions = NonNullable<
+type RunCodexAppServerAttemptOptions = NonNullable<
  Parameters<typeof runCodexAppServerAttemptImpl>[1]
 >;
-type RunCodexAppServerAttemptOptions = Omit<RunCodexAppServerAttemptImplOptions, "bindingStore"> & {
-  bindingStore?: RunCodexAppServerAttemptImplOptions["bindingStore"];
-};

-function setCodexAppServerClientFactoryForTest(factory: CodexTestAppServerClientFactory): void {
-  codexAppServerClientLeaseFactoryForTest = adaptCodexTestClientFactory(factory);
+function setCodexAppServerClientFactoryForTest(factory: CodexAppServerClientFactory): void {
+  codexAppServerClientFactoryForTest = factory;
 }

 function resetCodexAppServerClientFactoryForTest(): void {
-  codexAppServerClientLeaseFactoryForTest = undefined;
-}
-
-async function writeCodexAppServerBinding(
-  ...args: Parameters<typeof writeStoredCodexAppServerBinding>
-): Promise<void> {
-  registerCodexTestSessionIdentity(args[0], "session-1", "agent:main:session-1");
-  await writeStoredCodexAppServerBinding(...args);
+  codexAppServerClientFactoryForTest = undefined;
 }

 function runCodexAppServerAttempt(
  params: EmbeddedRunAttemptParams,
  options: RunCodexAppServerAttemptOptions = {},
 ) {
-  const clientLeaseFactory = options.clientLeaseFactory ?? codexAppServerClientLeaseFactoryForTest;
-  return runCodexAppServerAttemptImpl(params, {
-    ...options,
-    bindingStore: options.bindingStore ?? testCodexAppServerBindingStore,
-    ...(clientLeaseFactory ? { clientLeaseFactory } : {}),
-  });
+  const clientFactory = options.clientFactory ?? codexAppServerClientFactoryForTest;
+  return runCodexAppServerAttemptImpl(
+    params,
+    clientFactory ? { ...options, clientFactory } : options,
+  );
 }

 function createParams(sessionFile: string, workspaceDir: string): EmbeddedRunAttemptParams {
-  registerCodexTestSessionIdentity(sessionFile, "session-1", "agent:main:session-1");
  return {
    prompt: "hello",
    sessionId: "session-1",
@@ -223,10 +203,7 @@ function createStartedThreadHarness(
  requestImpl: (method: string, params: unknown) => Promise<unknown> = async () => undefined,
 ) {
  const requests: Array<{ method: string; params: unknown }> = [];
-  const notificationHandlers = new Set<
-    (notification: CodexServerNotification) => Promise<void> | void
-  >();
-  const requestHandlers = new Set<(request: unknown) => unknown>();
+  let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
  const request = vi.fn(async (method: string, params?: unknown) => {
    requests.push({ method, params });
    const override = await requestImpl(method, params);
@@ -242,37 +219,21 @@ function createStartedThreadHarness(
    return {};
  });

-  const client = {
-    request,
-    addNotificationHandler: (
-      handler: (notification: CodexServerNotification) => Promise<void> | void,
-    ) => {
-      notificationHandlers.add(handler);
-      return () => notificationHandlers.delete(handler);
-    },
-    addRequestHandler: (handler: (request: unknown) => unknown) => {
-      requestHandlers.add(handler);
-      return () => requestHandlers.delete(handler);
-    },
-    addCloseHandler: () => () => undefined,
-  } as unknown as CodexAppServerClient;
-  setCodexAppServerClientFactoryForTest(async () => client);
-
-  const notify = async (notification: CodexServerNotification) => {
-    await Promise.all(
-      [...notificationHandlers].map((handler) => Promise.resolve(handler(notification))),
-    );
-  };
+  setCodexAppServerClientFactoryForTest(
+    async () =>
+      ({
+        ...mockClientRuntimeMethods(),
+        request,
+        addNotificationHandler: (handler: typeof notify) => {
+          notify = handler;
+          return () => undefined;
+        },
+        addRequestHandler: () => () => undefined,
+      }) as never,
+  );

  return {
-    client,
    requests,
-    async handleServerRequest(serverRequest: unknown) {
-      const responses = await Promise.all(
-        [...requestHandlers].map((handler) => Promise.resolve(handler(serverRequest))),
-      );
-      return responses[0];
-    },
    async waitForMethod(method: string) {
      await vi.waitFor(() => expect(requests.map((entry) => entry.method)).toContain(method), {
        interval: 1,
@@ -388,7 +349,6 @@ function getRequestInputTextAt(

 describe("runCodexAppServerAttempt context-engine lifecycle", () => {
  beforeEach(async () => {
-    resetCodexTestBindingStore();
    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-codex-context-engine-"));
  });

@@ -785,14 +745,13 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    await secondRun;
  });

-  it("resumes a matching thread-bootstrap binding without a native usage snapshot", async () => {
+  it("resumes a matching thread-bootstrap binding even when the bootstrap turn exceeded the opt-in native byte guard", async () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
+    const agentDir = path.join(tempDir, "agent");
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-bootstrapped",
      cwd: workspaceDir,
-      model: "gpt-5.4-codex",
-      modelProvider: "openai",
      dynamicToolsFingerprint: "[]",
      contextEngine: {
        schemaVersion: 1,
@@ -806,6 +765,21 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        },
      },
    });
+    await fs.writeFile(
+      path.join(path.dirname(sessionFile), "sessions.json"),
+      JSON.stringify({
+        "agent:main:session-1": {
+          sessionFile,
+          totalTokens: 12_000,
+        },
+      }),
+    );
+    const rolloutDir = path.join(agentDir, "codex-home", "sessions");
+    await fs.mkdir(rolloutDir, { recursive: true });
+    await fs.writeFile(
+      path.join(rolloutDir, "rollout-thread-bootstrapped.jsonl"),
+      "x".repeat(2_000),
+    );
    const contextEngine = createContextEngine({
      assemble: vi.fn(async ({ prompt }) => ({
        messages: [
@@ -817,11 +791,28 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        contextProjection: { mode: "thread_bootstrap" as const, epoch: "epoch-1" },
      })),
    });
-    const harness = createStartedThreadHarness(async (method) =>
-      method === "thread/resume" ? threadStartResult("thread-bootstrapped") : undefined,
-    );
+    const harness = createStartedThreadHarness(async (method) => {
+      if (method === "thread/resume") {
+        return threadStartResult("thread-bootstrapped");
+      }
+      if (method === "thread/start") {
+        return threadStartResult("thread-fresh");
+      }
+      return undefined;
+    });
    const params = createParams(sessionFile, workspaceDir);
+    params.agentDir = agentDir;
    params.contextEngine = contextEngine;
+    params.config = {
+      agents: {
+        defaults: {
+          compaction: {
+            truncateAfterCompaction: true,
+            maxActiveTranscriptBytes: 1_000,
+          },
+        },
+      },
+    } as EmbeddedRunAttemptParams["config"];

    const run = runCodexAppServerAttempt(params);
    await harness.waitForMethod("turn/start");
@@ -839,263 +830,14 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    await run;
  });

-  it("projects assembled context when the binding changes during startup", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    await writeCodexAppServerBinding(sessionFile, {
-      threadId: "thread-old",
-      cwd: workspaceDir,
-      dynamicToolsFingerprint: "[]",
-      contextEngine: {
-        schemaVersion: 1,
-        engineId: "lossless-claw",
-        policyFingerprint:
-          '{"schemaVersion":1,"engineId":"lossless-claw","ownsCompaction":true,"projectionMaxChars":24000}',
-        projection: {
-          schemaVersion: 1,
-          mode: "thread_bootstrap",
-          epoch: "epoch-1",
-        },
-      },
-    });
-    const contextEngine = createContextEngine({
-      assemble: vi.fn(async ({ prompt }) => {
-        // Simulate a concurrent /codex resume or reset after the initial read.
-        await clearCodexAppServerBinding(sessionFile);
-        return {
-          messages: [
-            assistantMessage("assembled startup context", 10),
-            userMessage(prompt ?? "", 11),
-          ],
-          estimatedTokens: 42,
-          systemPromptAddition: "context-engine system",
-          contextProjection: { mode: "thread_bootstrap" as const, epoch: "epoch-1" },
-        };
-      }),
-    });
-    const harness = createStartedThreadHarness(async (method) =>
-      method === "thread/start" ? threadStartResult("thread-fresh") : undefined,
-    );
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-
-    expect(harness.requests.map((request) => request.method)).toEqual([
-      "thread/start",
-      "turn/start",
-    ]);
-    expectRequestInputTextContains(harness, "assembled startup context");
-    await harness.completeTurn("completed", "thread-fresh");
-    await run;
-    await expect(readCodexAppServerBinding(sessionFile)).resolves.toMatchObject({
-      threadId: "thread-fresh",
-      contextEngine: {
-        projection: { mode: "thread_bootstrap", epoch: "epoch-1" },
-      },
-    });
-  });
-
-  it("awaits accepted-turn interruption and retires the client when it cannot be confirmed", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    const contextEngine = createContextEngine({
-      assemble: vi.fn(async ({ prompt }) => ({
-        messages: [assistantMessage("projected context", 10), userMessage(prompt ?? "", 11)],
-        estimatedTokens: 42,
-        contextProjection: { mode: "thread_bootstrap" as const, epoch: "epoch-1" },
-      })),
-    });
-    let rejectTurnInterrupt!: (reason?: unknown) => void;
-    const turnInterrupt = new Promise<unknown>((_resolve, reject) => {
-      rejectTurnInterrupt = reject;
-    });
-    const harness = createStartedThreadHarness(async (method) => {
-      if (method === "thread/start") {
-        return threadStartResult("thread-fresh");
-      }
-      if (method === "turn/start") {
-        return turnStartResult("turn-fresh");
-      }
-      if (method === "turn/interrupt") {
-        return await turnInterrupt;
-      }
-      return undefined;
-    });
-    let releaseProjectionCommit!: () => void;
-    let markProjectionCommitStarted!: () => void;
-    const projectionCommitStarted = new Promise<void>((resolve) => {
-      markProjectionCommitStarted = resolve;
-    });
-    const projectionCommitReleased = new Promise<void>((resolve) => {
-      releaseProjectionCommit = resolve;
-    });
-    const bindingStore: RunCodexAppServerAttemptImplOptions["bindingStore"] = {
-      ...testCodexAppServerBindingStore,
-      async mutate(identity, mutation) {
-        if (
-          mutation.kind === "patch" &&
-          mutation.patch.contextEngine?.projection?.epoch === "epoch-1"
-        ) {
-          markProjectionCommitStarted();
-          await projectionCommitReleased;
-          return false;
-        }
-        return await testCodexAppServerBindingStore.mutate(identity, mutation);
-      },
-    };
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-    const onAgentEvent = vi.fn();
-    params.onAgentEvent = onAgentEvent;
-    const releaseClient = vi.fn();
-    const abandonClient = vi.fn(async () => undefined);
-
-    const run = runCodexAppServerAttempt(params, {
-      bindingStore,
-      clientLeaseFactory: async () => ({
-        client: harness.client,
-        release: releaseClient,
-        abandon: abandonClient,
-      }),
-    });
-    await projectionCommitStarted;
-    const bufferedToolRequest = harness.handleServerRequest({
-      id: "tool-after-accepted-turn",
-      method: "item/tool/call",
-      params: {
-        threadId: "thread-fresh",
-        turnId: "turn-fresh",
-        callId: "call-1",
-        namespace: null,
-        tool: "python",
-        arguments: { code: "print('must not run')" },
-      },
-    });
-    releaseProjectionCommit();
-    await harness.waitForMethod("turn/interrupt");
-    const runSettled = vi.fn();
-    void run.then(runSettled, runSettled);
-    await new Promise((resolve) => {
-      setImmediate(resolve);
-    });
-    expect(runSettled).not.toHaveBeenCalled();
-    expect(abandonClient).not.toHaveBeenCalled();
-
-    rejectTurnInterrupt(new Error("interrupt response lost"));
-    await expect(run).rejects.toThrow("binding changed before context projection commit");
-    await expect(bufferedToolRequest).resolves.toBeUndefined();
-    expect(abandonClient).toHaveBeenCalledOnce();
-    expect(releaseClient).not.toHaveBeenCalled();
-    expect(onAgentEvent).not.toHaveBeenCalledWith(expect.objectContaining({ stream: "tool" }));
-    expect(
-      harness.requests.some(
-        (request) =>
-          request.method === "turn/interrupt" &&
-          (request.params as { threadId?: string; turnId?: string }).threadId === "thread-fresh" &&
-          (request.params as { threadId?: string; turnId?: string }).turnId === "turn-fresh",
-      ),
-    ).toBe(true);
-  });
-
-  it("invalidates the projection and preserves fresh usage after native compaction", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    await writeCodexAppServerBinding(sessionFile, {
-      threadId: "thread-bootstrapped",
-      cwd: workspaceDir,
-      model: "gpt-5.4-codex",
-      modelProvider: "openai",
-      dynamicToolsFingerprint: "[]",
-      nativeContextUsage: { currentTokens: 220_000 },
-      modelContextWindow: 258_400,
-      contextEngine: {
-        schemaVersion: 1,
-        engineId: "lossless-claw",
-        policyFingerprint:
-          '{"schemaVersion":1,"engineId":"lossless-claw","ownsCompaction":true,"projectionMaxChars":24000}',
-        projection: {
-          schemaVersion: 1,
-          mode: "thread_bootstrap",
-          epoch: "epoch-1",
-          fingerprint: "fingerprint-1",
-        },
-      },
-    });
-    const contextEngine = createContextEngine({
-      assemble: vi.fn(async ({ prompt }) => ({
-        messages: [userMessage(prompt ?? "", 11)],
-        estimatedTokens: 42,
-        systemPromptAddition: "context-engine system",
-        contextProjection: {
-          mode: "thread_bootstrap" as const,
-          epoch: "epoch-1",
-          fingerprint: "fingerprint-1",
-        },
-      })),
-    });
-    const harness = createStartedThreadHarness(async (method) =>
-      method === "thread/resume" ? threadStartResult("thread-bootstrapped") : undefined,
-    );
-    const params = createParams(sessionFile, workspaceDir);
-    params.contextEngine = contextEngine;
-
-    const run = runCodexAppServerAttempt(params);
-    await harness.waitForMethod("turn/start");
-    await harness.notify({
-      method: "item/started",
-      params: {
-        threadId: "thread-bootstrapped",
-        turnId: "turn-1",
-        item: { id: "compact-1", type: "contextCompaction" },
-      },
-    });
-    const startedBinding = await readCodexAppServerBinding(sessionFile);
-    expect(startedBinding).not.toHaveProperty("nativeContextUsage");
-    expect(startedBinding?.contextEngine).not.toHaveProperty("projection");
-    await harness.notify({
-      method: "thread/tokenUsage/updated",
-      params: {
-        threadId: "thread-bootstrapped",
-        turnId: "turn-1",
-        tokenUsage: {
-          total: { totalTokens: 900_000 },
-          last: { totalTokens: 12_000 },
-          modelContextWindow: null,
-        },
-      },
-    });
-    await harness.notify({
-      method: "item/completed",
-      params: {
-        threadId: "thread-bootstrapped",
-        turnId: "turn-1",
-        item: { id: "compact-1", type: "contextCompaction" },
-      },
-    });
-    const compactedBinding = await readCodexAppServerBinding(sessionFile);
-    expect(compactedBinding).not.toHaveProperty("nativeContextUsage");
-    await harness.completeTurn("completed", "thread-bootstrapped");
-    await run;
-
-    const binding = await readCodexAppServerBinding(sessionFile);
-    expect(binding?.contextEngine?.projection).toBeUndefined();
-    expect(binding?.nativeContextUsage).toEqual({
-      currentTokens: 12_000,
-    });
-    expect(binding?.modelContextWindow).toBe(258_400);
-  });
-
  it("starts a fresh thread instead of resuming a token-pressured thread-bootstrap binding", async () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
+    const agentDir = path.join(tempDir, "agent");
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-bootstrapped",
      cwd: workspaceDir,
      dynamicToolsFingerprint: "[]",
-      nativeContextUsage: { currentTokens: 241_198 },
-      modelContextWindow: 258_400,
      contextEngine: {
        schemaVersion: 1,
        engineId: "lossless-claw",
@@ -1108,6 +850,31 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        },
      },
    });
+    await fs.writeFile(
+      path.join(path.dirname(sessionFile), "sessions.json"),
+      JSON.stringify({
+        "agent:main:session-1": {
+          sessionFile,
+          totalTokens: 12_000,
+        },
+      }),
+    );
+    const rolloutDir = path.join(agentDir, "codex-home", "sessions");
+    await fs.mkdir(rolloutDir, { recursive: true });
+    await fs.writeFile(
+      path.join(rolloutDir, "rollout-thread-bootstrapped.jsonl"),
+      `${JSON.stringify({
+        payload: {
+          type: "token_count",
+          info: {
+            last_token_usage: {
+              total_tokens: 241_198,
+            },
+            model_context_window: 258_400,
+          },
+        },
+      })}\n`,
+    );
    const contextEngine = createContextEngine({
      assemble: vi.fn(async ({ prompt }) => ({
        messages: [assistantMessage("reprojected context", 10), userMessage(prompt ?? "", 11)],
@@ -1126,14 +893,13 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
      return undefined;
    });
    const params = createParams(sessionFile, workspaceDir);
+    params.agentDir = agentDir;
    params.contextEngine = contextEngine;

    const run = runCodexAppServerAttempt(params);
    await harness.waitForMethod("turn/start");

    expect(harness.requests.map((request) => request.method)).toEqual([
-      "thread/resume",
-      "thread/unsubscribe",
      "thread/start",
      "turn/start",
    ]);
@@ -1148,6 +914,7 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
  it("does not inject mirrored history when a stale thread-bootstrap binding has no active context engine", async () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
+    const agentDir = path.join(tempDir, "agent");
    const sessionManager = SessionManager.open(sessionFile);
    sessionManager.appendMessage(
      userMessage("previous stale-bootstrap request", Date.now()) as never,
@@ -1159,7 +926,6 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
      threadId: "thread-stale-bootstrap",
      cwd: workspaceDir,
      dynamicToolsFingerprint: "[]",
-      nativeContextUsage: { currentTokens: 300_000 },
      contextEngine: {
        schemaVersion: 1,
        engineId: "lossless-claw",
@@ -1172,6 +938,30 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        },
      },
    });
+    await fs.writeFile(
+      path.join(path.dirname(sessionFile), "sessions.json"),
+      JSON.stringify({
+        "agent:main:session-1": {
+          sessionFile,
+          totalTokens: 12_000,
+        },
+      }),
+    );
+    const rolloutDir = path.join(agentDir, "codex-home", "sessions");
+    await fs.mkdir(rolloutDir, { recursive: true });
+    await fs.writeFile(
+      path.join(rolloutDir, "rollout-thread-stale-bootstrap.jsonl"),
+      `${JSON.stringify({
+        payload: {
+          type: "token_count",
+          info: {
+            last_token_usage: {
+              total_tokens: 300_000,
+            },
+          },
+        },
+      })}\n`,
+    );
    const harness = createStartedThreadHarness(async (method) => {
      if (method === "thread/resume") {
        return threadStartResult("thread-stale-bootstrap");
@@ -1182,6 +972,17 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
      return undefined;
    });
    const params = createParams(sessionFile, workspaceDir);
+    params.agentDir = agentDir;
+    params.config = {
+      agents: {
+        defaults: {
+          compaction: {
+            truncateAfterCompaction: true,
+            maxActiveTranscriptBytes: "1mb",
+          },
+        },
+      },
+    } as EmbeddedRunAttemptParams["config"];

    const run = runCodexAppServerAttempt(params);
    await harness.waitForMethod("turn/start");
@@ -1329,7 +1130,7 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        sessionId: "session-1",
        threadId: "thread-new",
        engineId: "lossless-claw",
-        projectionPending: true,
+        epoch: "epoch-new",
        action: "rotated",
      }),
    );
@@ -1341,8 +1142,6 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-old",
      cwd: workspaceDir,
-      model: "gpt-5.4-codex",
-      modelProvider: "openai",
      dynamicToolsFingerprint: "[]",
      contextEngine: {
        schemaVersion: 1,
@@ -1509,12 +1308,6 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        },
      });
      await run;
-      await expect(readCodexAppServerBinding(sessionFile)).resolves.toMatchObject({
-        threadId: "thread-old",
-        contextEngine: {
-          projection: { mode: "thread_bootstrap", epoch: "epoch-1" },
-        },
-      });
    } finally {
      restoreSandboxBackend();
    }
@@ -1596,11 +1389,7 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-old",
      cwd: workspaceDir,
-      model: "gpt-5.4-codex",
-      modelProvider: "openai",
      dynamicToolsFingerprint: "[]",
-      nativeContextUsage: { currentTokens: 120_000 },
-      modelContextWindow: 258_400,
      contextEngine: {
        schemaVersion: 1,
        engineId: "lossless-claw",
@@ -1647,13 +1436,7 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        throw new Error("Codex ran out of room in the model's context window");
      }
      if (method === "thread/start") {
-        const response = threadStartResult("thread-fresh");
-        return {
-          ...response,
-          thread: { ...response.thread, modelProvider: "lmstudio" },
-          model: "local-model",
-          modelProvider: "lmstudio",
-        };
+        return threadStartResult("thread-fresh");
      }
      if (method === "turn/start" && request.threadId === "thread-fresh") {
        return turnStartResult("turn-fresh");
@@ -1664,30 +1447,15 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    params.contextEngine = contextEngine;
    params.contextTokenBudget = 400_000;

-    const run = runCodexAppServerAttempt(params, {
-      pluginConfig: { appServer: { mode: "guardian" } },
-    });
+    const run = runCodexAppServerAttempt(params);
    await vi.waitFor(() =>
      expect(harness.requests.map((request) => request.method)).toEqual([
        "thread/resume",
        "turn/start",
-        "thread/unsubscribe",
        "thread/start",
        "turn/start",
      ]),
    );
-    await harness.notify({
-      method: "thread/tokenUsage/updated",
-      params: {
-        threadId: "thread-fresh",
-        turnId: "turn-fresh",
-        tokenUsage: {
-          total: { totalTokens: 900_000 },
-          last: { totalTokens: 12_000 },
-          modelContextWindow: null,
-        },
-      },
-    });
    await harness.notify({
      method: "turn/completed",
      params: {
@@ -1703,36 +1471,15 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
    const result = await run;

    expect(result.assistantTexts).toContain("fresh answer");
-    const turnStarts = harness.requests.filter((request) => request.method === "turn/start");
-    expect(turnStarts[0]?.params).toMatchObject({ approvalsReviewer: "auto_review" });
-    expect(turnStarts[1]?.params).toMatchObject({
-      model: "local-model",
-      approvalsReviewer: "user",
-      approvalPolicy: "on-request",
-    });
    expect(compact).not.toHaveBeenCalled();
    expect(assemble).toHaveBeenCalledTimes(1);
    const retryInputText = getRequestInputTextAt(harness, -1);
-    expect(retryInputText).toContain("context epoch-before");
-    expect(retryInputText).toContain("hello");
+    expect(retryInputText).toBe("hello");
    expect(retryInputText).not.toContain("successor compacted context");
    const savedBinding = await readCodexAppServerBinding(sessionFile);
    expect(savedBinding?.threadId).toBe("thread-fresh");
    expect(savedBinding?.contextEngine?.engineId).toBe("lossless-claw");
-    expect(savedBinding?.contextEngine?.projection).toEqual({
-      schemaVersion: 1,
-      mode: "thread_bootstrap",
-      epoch: "epoch-before",
-    });
-    expect(savedBinding?.nativeContextUsage).toEqual({
-      currentTokens: 12_000,
-    });
-    expect(savedBinding?.modelContextWindow).toBeUndefined();
-    expect(
-      harness.requests
-        .filter((request) => request.method === "thread/unsubscribe")
-        .map((request) => request.params),
-    ).toEqual([{ threadId: "thread-old" }, { threadId: "thread-fresh" }]);
+    expect(savedBinding?.contextEngine?.projection).toBeUndefined();
  });

  it("preserves a newer context-engine binding when a stale resumed thread overflows", async () => {
@@ -2023,7 +1770,6 @@ describe("runCodexAppServerAttempt context-engine lifecycle", () => {
        expect(harness.requests.map((request) => request.method)).toEqual([
          "thread/resume",
          "turn/start",
-          "thread/unsubscribe",
          "thread/start",
          "turn/start",
        ]),
--- a/extensions/codex/src/app-server/run-attempt.hooks.test.ts
+++ b/extensions/codex/src/app-server/run-attempt.hooks.test.ts
@@ -178,8 +178,6 @@ describe("runCodexAppServerAttempt hooks and model diagnostics", () => {
        phase?: string;
        startedAt?: number;
        text?: string;
-        threadId?: string;
-        turnId?: string;
      };
      stream: string;
    }>;
@@ -187,11 +185,6 @@ describe("runCodexAppServerAttempt hooks and model diagnostics", () => {
      (event) => event.stream === "lifecycle" && event.data.phase === "start",
    );
    expect(typeof lifecycleStart?.data.startedAt).toBe("number");
-    const turnAccepted = agentEvents.find(
-      (event) =>
-        event.stream === "codex_app_server.lifecycle" && event.data.phase === "turn_accepted",
-    );
-    expect(turnAccepted?.data).toMatchObject({ threadId: "thread-1", turnId: "turn-1" });
    const assistantEvent = agentEvents.find((event) => event.stream === "assistant");
    expect(assistantEvent?.data).toEqual({ text: "hello back" });
    const lifecycleEnd = agentEvents.find(
@@ -203,16 +196,10 @@ describe("runCodexAppServerAttempt hooks and model diagnostics", () => {
      (event) => event.stream === "lifecycle" && event.data.phase === "start",
    );
    const assistantIndex = agentEvents.findIndex((event) => event.stream === "assistant");
-    const acceptedIndex = agentEvents.findIndex(
-      (event) =>
-        event.stream === "codex_app_server.lifecycle" && event.data.phase === "turn_accepted",
-    );
    const endIndex = agentEvents.findIndex(
      (event) => event.stream === "lifecycle" && event.data.phase === "end",
    );
    expect(startIndex).toBeGreaterThanOrEqual(0);
-    expect(acceptedIndex).toBeGreaterThanOrEqual(0);
-    expect(startIndex).toBeGreaterThan(acceptedIndex);
    expect(assistantIndex).toBeGreaterThan(startIndex);
    expect(endIndex).toBeGreaterThan(assistantIndex);
    const globalAssistantEvent = globalAgentEvents.find((event) => event.stream === "assistant");
--- a/extensions/codex/src/app-server/run-attempt.native-hook-relay.test.ts
+++ b/extensions/codex/src/app-server/run-attempt.native-hook-relay.test.ts
@@ -7,7 +7,6 @@ import {
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { describe, expect, it, vi } from "vitest";
 import * as approvalBridge from "./approval-bridge.js";
-import { CodexAppServerRpcError } from "./client.js";
 import {
  createParams,
  createResumeHarness,
@@ -17,21 +16,12 @@ import {
  runCodexAppServerAttempt,
  setupRunAttemptTestHooks,
  tempDir,
-  threadStartResult,
 } from "./run-attempt-test-harness.js";
 import { testing } from "./run-attempt.js";
 import {
  readCodexAppServerBinding,
-  registerCodexTestSessionIdentity,
-  writeCodexAppServerBinding as writeStoredCodexAppServerBinding,
-} from "./session-binding.test-helpers.js";
-
-async function writeCodexAppServerBinding(
-  ...args: Parameters<typeof writeStoredCodexAppServerBinding>
-): Promise<void> {
-  registerCodexTestSessionIdentity(args[0], "session-1", "agent:main:session-1");
-  await writeStoredCodexAppServerBinding(...args);
-}
+  writeCodexAppServerBinding as writeRawCodexAppServerBinding,
+} from "./session-binding.js";

 setupRunAttemptTestHooks();

@@ -284,7 +274,7 @@ describe("runCodexAppServerAttempt native hook relay", () => {
    expect(nativeHookRelayTesting.getNativeHookRelayRegistrationForTests(relayId)).toBeUndefined();
  });

-  it("installs policy-stable native hook relay events before thread policy is known", async () => {
+  it("lets Codex app-server approval modes own native permission requests by default", async () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
    const harness = createStartedThreadHarness();
@@ -305,16 +295,11 @@ describe("runCodexAppServerAttempt native hook relay", () => {
    expect(Array.isArray(startConfig?.["hooks.PreToolUse"])).toBe(true);
    expect(startConfig?.["hooks.PostToolUse"]).toEqual([]);
    expect(startConfig?.["hooks.Stop"]).toEqual([]);
-    const permissionRequestHooks = startConfig?.["hooks.PermissionRequest"] as
-      | Array<{ hooks?: Array<{ command?: string }> }>
-      | undefined;
-    expect(permissionRequestHooks?.[0]?.hooks?.[0]?.command).toContain(
-      "--event permission_request",
-    );
+    expect(startConfig).not.toHaveProperty("hooks.PermissionRequest");
    const relayId = extractRelayIdFromThreadRequest(startRequest?.params);
    expect(
      nativeHookRelayTesting.getNativeHookRelayRegistrationForTests(relayId)?.allowedEvents,
-    ).toEqual(["pre_tool_use", "post_tool_use", "permission_request", "before_agent_finalize"]);
+    ).toEqual(["pre_tool_use", "post_tool_use", "before_agent_finalize"]);

    await harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
    await run;
@@ -322,68 +307,6 @@ describe("runCodexAppServerAttempt native hook relay", () => {
    expect(nativeHookRelayTesting.getNativeHookRelayRegistrationForTests(relayId)).toBeUndefined();
  });

-  it("defers permission hooks after Codex returns a provider with guarded policy", async () => {
-    const sessionFile = path.join(tempDir, "session.jsonl");
-    const workspaceDir = path.join(tempDir, "workspace");
-    const harness = createStartedThreadHarness(async (method) => {
-      if (method !== "thread/start") {
-        return undefined;
-      }
-      const response = threadStartResult();
-      return {
-        ...response,
-        thread: { ...response.thread, modelProvider: "lmstudio" },
-        model: "local-model",
-        modelProvider: "lmstudio",
-      };
-    });
-    const approvalRequester = vi.fn(async () => "allow" as const);
-    nativeHookRelayTesting.setNativeHookRelayPermissionApprovalRequesterForTests(approvalRequester);
-    const params = createParams(sessionFile, workspaceDir);
-    params.modelId = "openai/gpt-5.4-codex";
-
-    const run = runCodexAppServerAttempt(params, {
-      pluginConfig: {
-        appServer: {
-          mode: "yolo",
-          approvalsReviewer: "auto_review",
-        },
-      },
-      nativeHookRelay: { enabled: true },
-    });
-    await harness.waitForMethod("turn/start");
-
-    const startRequest = harness.requests.find((request) => request.method === "thread/start");
-    const startParams = startRequest?.params as
-      | { approvalPolicy?: unknown; config?: Record<string, unknown> }
-      | undefined;
-    expect(startParams?.approvalPolicy).toBe("never");
-    expect(Array.isArray(startParams?.config?.["hooks.PermissionRequest"])).toBe(true);
-    const turnStartRequest = harness.requests.find((request) => request.method === "turn/start");
-    expect(
-      (turnStartRequest?.params as { approvalPolicy?: unknown } | undefined)?.approvalPolicy,
-    ).toBe("on-request");
-    const relayId = extractRelayIdFromThreadRequest(startRequest?.params);
-    await expect(
-      invokeNativeHookRelay({
-        provider: "codex",
-        relayId,
-        event: "permission_request",
-        rawPayload: {
-          hook_event_name: "PermissionRequest",
-          permission_mode: "default",
-          tool_name: "Bash",
-          tool_input: { command: "git push" },
-        },
-      }),
-    ).resolves.toEqual({ stdout: "", stderr: "", exitCode: 0 });
-    expect(approvalRequester).not.toHaveBeenCalled();
-
-    await harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
-    await run;
-    testing.flushPendingCodexNativeHookRelayUnregistersForTests();
-  });
-
  it("preserves explicit native permission request relay events in app-server approval modes", async () => {
    const sessionFile = path.join(tempDir, "session.jsonl");
    const workspaceDir = path.join(tempDir, "workspace");
@@ -531,7 +454,7 @@ describe("runCodexAppServerAttempt native hook relay", () => {
      "run-2",
    );

-    await secondHarness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
+    await secondHarness.completeTurn({ threadId: "thread-existing", turnId: "turn-1" });
    await secondRun;
    expect(nativeHookRelayTesting.getNativeHookRelayRegistrationForTests(firstRelayId)?.runId).toBe(
      "run-2",
@@ -583,7 +506,7 @@ describe("runCodexAppServerAttempt native hook relay", () => {
    expect(extractRelayIdFromThreadRequest(resumeRequest?.params)).toBe(firstRelayId);
    expect(extractGenerationFromThreadRequest(resumeRequest?.params)).toBe(firstGeneration);

-    await secondHarness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
+    await secondHarness.completeTurn({ threadId: "thread-existing", turnId: "turn-1" });
    await secondRun;
    testing.flushPendingCodexNativeHookRelayUnregistersForTests();
  });
@@ -713,7 +636,7 @@ describe("runCodexAppServerAttempt native hook relay", () => {
    });
    const harness = createStartedThreadHarness(async (method) => {
      if (method === "thread/resume") {
-        throw new CodexAppServerRpcError({ code: -32000, message: "resume failed" }, method);
+        throw new Error("resume failed");
      }
      return undefined;
    });
--- a/extensions/codex/src/app-server/run-attempt.test.ts
+++ b/extensions/codex/src/app-server/run-attempt.test.ts
--- a/extensions/codex/src/app-server/run-attempt.ts
+++ b/extensions/codex/src/app-server/run-attempt.ts
--- a/extensions/codex/src/app-server/run-attempt.turn-watches.test.ts
+++ b/extensions/codex/src/app-server/run-attempt.turn-watches.test.ts
@@ -37,10 +37,10 @@ import {
 } from "./run-attempt-test-harness.js";
 import { testing } from "./run-attempt.js";
 import {
-  createCodexTestBindingStore,
  readCodexAppServerBinding,
-  writeCodexAppServerBinding,
-} from "./session-binding.test-helpers.js";
+  resolveCodexAppServerBindingPath,
+  writeCodexAppServerBinding as writeRawCodexAppServerBinding,
+} from "./session-binding.js";

 setupRunAttemptTestHooks();

@@ -71,7 +71,7 @@ describe("createCodexAttemptTurnWatchController", () => {
    const onTimeout = vi.fn();
    const onAbort = vi.fn();
    const controller = createCodexAttemptTurnWatchController({
-      getThreadId: () => "thread-1",
+      threadId: "thread-1",
      signal: new AbortController().signal,
      getTurnId: () => "turn-1",
      isCompleted: () => false,
@@ -100,7 +100,7 @@ describe("createCodexAttemptTurnWatchController", () => {
      await new Promise((resolve) => {
        setTimeout(resolve, 20);
      });
-      controller.noteNotificationReceived("item/fileChange/patchUpdated", {
+      controller.noteNotificationReceived("response.output_text.delta", {
        attemptProgress: true,
        attemptTimeoutMs: 40,
      });
@@ -113,7 +113,7 @@ describe("createCodexAttemptTurnWatchController", () => {
        expect.objectContaining({
          kind: "progress",
          timeoutMs: 40,
-          lastActivityReason: "notification:item/fileChange/patchUpdated",
+          lastActivityReason: "notification:response.output_text.delta",
        }),
      );
    } finally {
@@ -159,6 +159,8 @@ describe("runCodexAppServerAttempt turn watches", () => {
      path.join(tempDir, "workspace"),
    );
    params.timeoutMs = 200;
+    const bindingPath = resolveCodexAppServerBindingPath(params.sessionFile);
+
    const run = runCodexAppServerAttempt(params, {
      pluginConfig: { appServer: { turnCompletionIdleTimeoutMs: 5 } },
      postToolRawAssistantCompletionIdleTimeoutMs: 5,
@@ -204,7 +206,7 @@ describe("runCodexAppServerAttempt turn watches", () => {
        ),
      { interval: 1 },
    );
-    await expect(readCodexAppServerBinding(params.sessionFile)).resolves.toBeUndefined();
+    await expect(fs.stat(bindingPath)).rejects.toMatchObject({ code: "ENOENT" });
    expect(queueActiveRunMessageForTest("session-1", "after timeout")).toBe(false);
  });

@@ -422,7 +424,8 @@ describe("runCodexAppServerAttempt turn watches", () => {
    expect(result.promptTimeoutOutcome).toBeUndefined();
  });

-  it("unsubscribes the app-server client when the active turn goes idle past the attempt timeout", async () => {
+  it("unsubscribes and closes the app-server client when the active turn goes idle past the attempt timeout", async () => {
+    const close = vi.fn();
    const request = vi.fn(async (method: string) => {
      if (method === "thread/start") {
        return threadStartResult("thread-1");
@@ -440,6 +443,7 @@ describe("runCodexAppServerAttempt turn watches", () => {
        ({
          ...mockClientRuntimeMethods(),
          request,
+          close,
          addNotificationHandler: () => () => undefined,
          addRequestHandler: () => () => undefined,
        }) as never,
@@ -472,6 +476,7 @@ describe("runCodexAppServerAttempt turn watches", () => {
      },
      { timeoutMs: 5_000 },
    );
+    expect(close).toHaveBeenCalledTimes(1);
    expect(queueActiveRunMessageForTest("session-1", "after timeout")).toBe(false);
  });

@@ -1881,6 +1886,119 @@ describe("runCodexAppServerAttempt turn watches", () => {
    expect(completionWarnData?.timeoutMs).toBe(100);
  });

+  it("counts native response deltas as post-tool raw assistant activity", async () => {
+    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
+    let handleRequest:
+      | ((request: { id: string; method: string; params?: unknown }) => Promise<unknown>)
+      | undefined;
+    const request = vi.fn(async (method: string) => {
+      if (method === "thread/start") {
+        return threadStartResult("thread-1");
+      }
+      if (method === "turn/start") {
+        return turnStartResult("turn-1", "inProgress");
+      }
+      return {};
+    });
+    setCodexAppServerClientFactoryForTest(
+      async () =>
+        ({
+          ...mockClientRuntimeMethods(),
+          request,
+          addNotificationHandler: (handler: typeof notify) => {
+            notify = handler;
+            return () => undefined;
+          },
+          addRequestHandler: (
+            handler: (request: {
+              id: string;
+              method: string;
+              params?: unknown;
+            }) => Promise<unknown>,
+          ) => {
+            handleRequest = handler;
+            return () => undefined;
+          },
+        }) as never,
+    );
+    const params = createParams(
+      path.join(tempDir, "session.jsonl"),
+      path.join(tempDir, "workspace"),
+    );
+    params.timeoutMs = 60_000;
+
+    let settled = false;
+    const run = runCodexAppServerAttempt(params, {
+      turnCompletionIdleTimeoutMs: 500,
+      turnAssistantCompletionIdleTimeoutMs: 5,
+      postToolRawAssistantCompletionIdleTimeoutMs: 50,
+      turnTerminalIdleTimeoutMs: 500,
+    }).finally(() => {
+      settled = true;
+    });
+    await vi.waitFor(() => expect(handleRequest).toBeTypeOf("function"), fastWait);
+
+    const toolResult = (await handleRequest?.({
+      id: "request-tool-1",
+      method: "item/tool/call",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        callId: "call-1",
+        namespace: null,
+        tool: "message",
+        arguments: { action: "send", text: "already sent" },
+      },
+    })) as { success?: boolean };
+    expect(toolResult.success).toBe(false);
+    await notify({
+      method: "rawResponseItem/completed",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        item: {
+          type: "message",
+          id: "raw-status-1",
+          role: "assistant",
+          content: [{ type: "output_text", text: "I'm writing a large patch now." }],
+        },
+      },
+    });
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 30);
+    });
+    // This covers the future-compatible path for raw response deltas if Codex
+    // app-server exposes them directly; current Codex primarily emits
+    // rawResponseItem/completed for the raw-event surface.
+    await notify({
+      method: "response.custom_tool_call_input.delta",
+      params: {
+        item_id: "ctc-large-edit-1",
+        output_index: 0,
+        delta: '{"cmd":"apply_patch","patch":"large chunk"}',
+      },
+    });
+    await new Promise((resolve) => {
+      setTimeout(resolve, 30);
+    });
+    expect(settled).toBe(false);
+
+    await notify({
+      method: "turn/completed",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        turn: { id: "turn-1", status: "completed" },
+      },
+    });
+
+    const result = await run;
+    expect(result.aborted).toBe(false);
+    expect(result.timedOut).toBe(false);
+    expect(result.promptError).toBeNull();
+  });
+
  it("keeps the post-tool guard armed for patch update snapshots", async () => {
    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
    let handleRequest:
@@ -1992,6 +2110,214 @@ describe("runCodexAppServerAttempt turn watches", () => {
    expect(completionWarnData?.lastNotificationMethod).toBe("item/fileChange/patchUpdated");
  });

+  it("keeps the post-tool guard armed for scoped native response deltas", async () => {
+    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
+    let handleRequest:
+      | ((request: { id: string; method: string; params?: unknown }) => Promise<unknown>)
+      | undefined;
+    const request = vi.fn(async (method: string) => {
+      if (method === "thread/start") {
+        return threadStartResult("thread-1");
+      }
+      if (method === "turn/start") {
+        return turnStartResult("turn-1", "inProgress");
+      }
+      return {};
+    });
+    setCodexAppServerClientFactoryForTest(
+      async () =>
+        ({
+          ...mockClientRuntimeMethods(),
+          request,
+          addNotificationHandler: (handler: typeof notify) => {
+            notify = handler;
+            return () => undefined;
+          },
+          addRequestHandler: (
+            handler: (request: {
+              id: string;
+              method: string;
+              params?: unknown;
+            }) => Promise<unknown>,
+          ) => {
+            handleRequest = handler;
+            return () => undefined;
+          },
+        }) as never,
+    );
+    const params = createParams(
+      path.join(tempDir, "session-scoped-delta-timeout.jsonl"),
+      path.join(tempDir, "workspace-scoped-delta-timeout"),
+    );
+    params.timeoutMs = 2_000;
+
+    const run = runCodexAppServerAttempt(params, {
+      turnCompletionIdleTimeoutMs: 500,
+      turnAssistantCompletionIdleTimeoutMs: 5,
+      postToolRawAssistantCompletionIdleTimeoutMs: 50,
+      turnTerminalIdleTimeoutMs: 500,
+    });
+    await vi.waitFor(() => expect(handleRequest).toBeTypeOf("function"), fastWait);
+
+    await handleRequest?.({
+      id: "request-tool-1",
+      method: "item/tool/call",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        callId: "call-1",
+        namespace: null,
+        tool: "message",
+        arguments: { action: "send", text: "already sent" },
+      },
+    });
+    await notify({
+      method: "rawResponseItem/completed",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        item: {
+          type: "message",
+          id: "raw-status-1",
+          role: "assistant",
+          content: [{ type: "output_text", text: "I'm writing a large patch now." }],
+        },
+      },
+    });
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 30);
+    });
+    await notify({
+      method: "response.custom_tool_call_input.delta",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        item_id: "ctc-large-edit-1",
+        output_index: 0,
+        delta: '{"cmd":"apply_patch","patch":"large chunk"}',
+      },
+    });
+
+    const result = await run;
+    expect(result.timedOut).toBe(true);
+    expect(result.promptError).toBe(
+      "codex app-server turn idle timed out waiting for turn/completed",
+    );
+  });
+
+  it("ignores unscoped native response deltas while another turn leases the client", async () => {
+    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
+    let handleRequest:
+      | ((request: { id: string; method: string; params?: unknown }) => Promise<unknown>)
+      | undefined;
+    const warn = vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
+    const request = vi.fn(async (method: string) => {
+      if (method === "thread/start") {
+        return threadStartResult("thread-1");
+      }
+      if (method === "turn/start") {
+        return turnStartResult("turn-1", "inProgress");
+      }
+      return {};
+    });
+    setCodexAppServerClientFactoryForTest(
+      async () =>
+        ({
+          ...mockClientRuntimeMethods(),
+          request,
+          getActiveSharedLeaseCountForUnscopedNotifications: () => 2,
+          addNotificationHandler: (handler: typeof notify) => {
+            notify = handler;
+            return () => undefined;
+          },
+          addRequestHandler: (
+            handler: (request: {
+              id: string;
+              method: string;
+              params?: unknown;
+            }) => Promise<unknown>,
+          ) => {
+            handleRequest = handler;
+            return () => undefined;
+          },
+        }) as never,
+    );
+    const params = createParams(
+      path.join(tempDir, "session.jsonl"),
+      path.join(tempDir, "workspace"),
+    );
+    params.timeoutMs = 60_000;
+
+    let settled = false;
+    const run = runCodexAppServerAttempt(params, {
+      turnCompletionIdleTimeoutMs: 500,
+      turnAssistantCompletionIdleTimeoutMs: 5,
+      postToolRawAssistantCompletionIdleTimeoutMs: 80,
+      turnTerminalIdleTimeoutMs: 500,
+    }).finally(() => {
+      settled = true;
+    });
+    await vi.waitFor(() => expect(handleRequest).toBeTypeOf("function"), fastWait);
+
+    await handleRequest?.({
+      id: "request-tool-1",
+      method: "item/tool/call",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        callId: "call-1",
+        namespace: null,
+        tool: "message",
+        arguments: { action: "send", text: "already sent" },
+      },
+    });
+    await notify({
+      method: "rawResponseItem/completed",
+      params: {
+        threadId: "thread-1",
+        turnId: "turn-1",
+        item: {
+          type: "message",
+          id: "raw-status-1",
+          role: "assistant",
+          content: [{ type: "output_text", text: "I'm writing a large patch now." }],
+        },
+      },
+    });
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 40);
+    });
+    await notify({
+      method: "response.custom_tool_call_input.delta",
+      params: {
+        item_id: "foreign-large-edit-1",
+        output_index: 0,
+        delta: '{"cmd":"apply_patch","patch":"other turn"}',
+      },
+    });
+    await vi.waitFor(() => expect(settled).toBe(true), fastWait);
+
+    const result = await run;
+    expect(result.aborted).toBe(true);
+    expect(result.timedOut).toBe(true);
+    expect(result.promptError).toBe(
+      "codex app-server turn idle timed out waiting for turn/completed",
+    );
+    const completionWarnCall = warn.mock.calls.find(
+      ([message]) => message === "codex app-server turn idle timed out waiting for completion",
+    );
+    const completionWarnData = completionWarnCall?.[1] as
+      | {
+          lastActivityReason?: string;
+          lastNotificationMethod?: string;
+        }
+      | undefined;
+    expect(completionWarnData?.lastActivityReason).toBe("notification:rawResponseItem/completed");
+    expect(completionWarnData?.lastNotificationMethod).toBe("rawResponseItem/completed");
+  });
+
  it("times out post-native-tool raw assistant progress after the post-tool timeout", async () => {
    let notify: (notification: CodexServerNotification) => Promise<void> = async () => undefined;
    const request = vi.fn(async (method: string) => {
@@ -2692,47 +3018,6 @@ describe("runCodexAppServerAttempt turn watches", () => {
    );
  });

-  it("retires a timed-out client even when binding cleanup fails", async () => {
-    vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
-    const baseBindingStore = createCodexTestBindingStore();
-    const bindingStore = {
-      ...baseBindingStore,
-      mutate: vi.fn(async (...args: Parameters<typeof baseBindingStore.mutate>) => {
-        if (args[1].kind === "clear") {
-          throw new Error("binding store unavailable");
-        }
-        return await baseBindingStore.mutate(...args);
-      }),
-    };
-    const harness = createStartedThreadHarness();
-    const release = vi.fn();
-    const abandon = vi.fn(async () => undefined);
-    const params = createParams(
-      path.join(tempDir, "session-retirement.jsonl"),
-      path.join(tempDir, "workspace-retirement"),
-    );
-    params.timeoutMs = 200;
-
-    const result = await runCodexAppServerAttempt(params, {
-      bindingStore,
-      turnCompletionIdleTimeoutMs: 15,
-      clientLeaseFactory: async () => ({ client: harness.client, release, abandon }),
-    });
-
-    expect(result.timedOut).toBe(true);
-    expect(bindingStore.mutate).toHaveBeenCalledWith(
-      expect.any(Object),
-      expect.objectContaining({ kind: "clear", threadId: "thread-1" }),
-    );
-    expect(harness.request).toHaveBeenCalledWith(
-      "thread/unsubscribe",
-      { threadId: "thread-1" },
-      { timeoutMs: 5_000 },
-    );
-    expect(abandon).toHaveBeenCalledOnce();
-    expect(release).not.toHaveBeenCalled();
-  });
-
  it("clears the thread binding after a completion-idle timeout so the next turn starts fresh", async () => {
    // Regression for openclaw#89974. The "user interrupted the previous turn on
    // purpose" wording is Codex's generic <turn_aborted> rollout marker, written
@@ -2744,7 +3029,6 @@ describe("runCodexAppServerAttempt turn watches", () => {
    vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);
    const sessionFile = path.join(tempDir, "session-89974.jsonl");
    const workspaceDir = path.join(tempDir, "workspace-89974");
-    const firstParams = createParams(sessionFile, workspaceDir);
    await writeCodexAppServerBinding(sessionFile, {
      threadId: "thread-existing",
      cwd: workspaceDir,
@@ -2755,6 +3039,7 @@ describe("runCodexAppServerAttempt turn watches", () => {

    // Turn 1: resume an existing thread, then never deliver turn/completed.
    const firstHarness = createResumeHarness();
+    const firstParams = createParams(sessionFile, workspaceDir);
    firstParams.timeoutMs = 200;
    const firstRun = runCodexAppServerAttempt(firstParams, { turnCompletionIdleTimeoutMs: 15 });
    await firstHarness.waitForMethod("turn/start");
@@ -2796,9 +3081,9 @@ describe("runCodexAppServerAttempt turn watches", () => {
    const processing = harness.notify(notification);
    await Promise.resolve();

-    expect(readRecentCodexRateLimits(harness.client)).toBeUndefined();
+    expect(readRecentCodexRateLimits()).toBeUndefined();
    await processing;
-    expect(readRecentCodexRateLimits(harness.client)).toEqual(notification.params);
+    expect(readRecentCodexRateLimits()).toEqual(notification.params);

    await harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
    await expect(run).resolves.toMatchObject({ aborted: false, timedOut: false });
@@ -3847,8 +4132,9 @@ describe("runCodexAppServerAttempt turn watches", () => {
    );

    await harness.waitForMethod("turn/start");
-    await harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
+    const completed = harness.completeTurn({ threadId: "thread-1", turnId: "turn-1" });
    harness.close();
+    await completed;

    const result = await run;
    expect(result.promptError ?? undefined).toBeUndefined();
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tideclaw	ab7bd17b8f	test: harden codex auth startup contracts	2026-06-21 04:20:10 +00:00
Tideclaw	a4271ace37	fix: refresh plugin sdk surface budget	2026-06-21 03:43:04 +00:00
Tideclaw	9fad831d5f	docs: add alpha package changelog	2026-06-21 03:15:31 +00:00
Tideclaw	29c56f7e4a	chore: prepare alpha 2026.6.10-alpha.3	2026-06-21 02:39:12 +00:00
Tideclaw	015b38cd9a	fix: refresh alpha config baseline	2026-06-21 02:26:05 +00:00
Tideclaw	6244b56f9e	fix: type run-node signal injection	2026-06-21 02:14:49 +00:00
Tideclaw	c0f2ab145b	fix: use sdk temp helper in feishu media tests	2026-06-21 02:14:49 +00:00