openclaw
diff --git a/‎docs/plugins/adding-capabilities.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/plugins/adding-capabilities.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/plugins/sdk-agent-harness.md‎
Lines changed: 4 additions & 2 deletions b/‎docs/plugins/sdk-agent-harness.md‎
Lines changed: 4 additions & 2 deletions
diff --git a/‎docs/providers/openai.md‎
Lines changed: 4 additions & 3 deletions b/‎docs/providers/openai.md‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎extensions/codex/src/app-server/dynamic-tool-build.test.ts‎
Lines changed: 42 additions & 0 deletions b/‎extensions/codex/src/app-server/dynamic-tool-build.test.ts‎
Lines changed: 42 additions & 0 deletions
diff --git a/‎extensions/codex/src/app-server/dynamic-tool-build.ts‎
Lines changed: 1 addition & 0 deletions b/‎extensions/codex/src/app-server/dynamic-tool-build.ts‎
Lines changed: 1 addition & 0 deletions
@@ -71,7 +71,7 @@ If the work is vendor-only and no shared contract exists yet, stop and define th
 
 Use **provider hooks** when the behavior belongs to the model provider contract rather than the generic agent loop. Examples include provider-specific request params after transport selection, auth-profile preference, prompt overlays, and follow-up fallback routing after model/profile failover.
 
-Use **agent harness hooks** when the behavior belongs to the runtime that is executing a turn. Harnesses can classify successful-but-unusable attempt results such as empty, reasoning-only, or planning-only responses so the outer model fallback policy can make the retry decision.
+Use **agent harness hooks** when the behavior belongs to the runtime that is executing a turn. Harnesses can classify explicit protocol outcomes such as empty output, reasoning without visible output, or a structured plan without a final answer so the outer model fallback policy can make the retry decision.
 
 Keep both seams narrow:
 
 
@@ -180,8 +180,10 @@ Native harnesses that own their own protocol projection can use
 `openclaw/plugin-sdk/agent-harness-runtime` when a completed turn produced no
 visible assistant text. The helper returns `empty`, `reasoning-only`, or
 `planning-only` so OpenClaw's fallback policy can decide whether to retry on a
-different model. It intentionally leaves prompt errors, in-flight turns, and
-intentional silent replies such as `NO_REPLY` unclassified.
+different model. `planning-only` requires the harness's explicit `planText`
+field; OpenClaw does not infer it from assistant prose. The helper intentionally
+leaves prompt errors, in-flight turns, and intentional silent replies such as
+`NO_REPLY` unclassified.
 
 ### Native Codex harness mode
 
 
@@ -1040,10 +1040,11 @@ the Server-side compaction accordion below.
     ```
 
     With `strict-agentic`, OpenClaw:
-    - No longer treats a plan-only turn as successful progress when a tool action is available
-    - Retries the turn with an act-now steer
     - Auto-enables `update_plan` for substantial work
-    - Surfaces an explicit blocked state if the model keeps planning without acting
+    - Retries structurally empty or reasoning-only turns with a visible-answer continuation
+    - Uses explicit harness plan events when the selected harness provides them
+
+    OpenClaw does not classify assistant prose to decide whether a turn is a plan, progress update, or final answer.
 
     <Note>
     Scoped to OpenAI and Codex GPT-5-family runs only. Other providers and older model families keep default behavior.
 
@@ -4,7 +4,9 @@ import os from "node:os";
 import path from "node:path";
 import {
   embeddedAgentLog,
+  isToolWrappedWithBeforeToolCallHook,
   type EmbeddedRunAttemptParams,
+  wrapToolWithBeforeToolCallHook,
 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
@@ -581,6 +583,46 @@ describe("Codex app-server dynamic tool build", () => {
     });
   });
 
+  it("forwards the tool outcome observer into Codex dynamic tools", async () => {
+    const sessionFile = path.join(tempDir, "session.jsonl");
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(sessionFile, workspaceDir);
+    const onToolOutcome = vi.fn();
+    params.disableTools = false;
+    params.onToolOutcome = onToolOutcome;
+    params.runtimePlan = createCodexRuntimePlanFixture();
+    const factoryOptions: unknown[] = [];
+    setOpenClawCodingToolsFactoryForTests((options) => {
+      factoryOptions.push(options);
+      return [];
+    });
+
+    await buildDynamicToolsForTest(params, workspaceDir, { sandbox: null as never });
+
+    expect(factoryOptions[0]).toMatchObject({ onToolOutcome });
+  });
+
+  it("preserves before-tool wrapping through Codex runtime normalization", async () => {
+    const sessionFile = path.join(tempDir, "session.jsonl");
+    const workspaceDir = path.join(tempDir, "workspace");
+    const params = createParams(sessionFile, workspaceDir);
+    params.disableTools = false;
+    const runtimePlan = createCodexRuntimePlanFixture();
+    runtimePlan.tools.normalize = (tools) => tools.map((tool) => ({ ...tool }));
+    params.runtimePlan = runtimePlan;
+    const wrappedTool = wrapToolWithBeforeToolCallHook(createRuntimeDynamicTool("web_fetch"), {
+      agentId: "main",
+      sessionId: params.sessionId,
+    });
+    setOpenClawCodingToolsFactoryForTests(() => [wrappedTool]);
+
+    const tools = await buildDynamicToolsForTest(params, workspaceDir, { sandbox: null as never });
+
+    expect(tools).toHaveLength(1);
+    expect(tools[0]).not.toBe(wrappedTool);
+    expect(isToolWrappedWithBeforeToolCallHook(tools[0])).toBe(true);
+  });
+
   it("passes runtime config into Codex exec dynamic tool construction", async () => {
     const sessionFile = path.join(tempDir, "session.jsonl");
     const workspaceDir = path.join(tempDir, "workspace");
 
@@ -290,6 +290,7 @@ export async function buildDynamicTools(input: DynamicToolBuildParams) {
     recordToolPrepStage: (name) => {
       toolBuildStages.mark(name);
     },
+    onToolOutcome: params.onToolOutcome,
   });
   toolBuildStages.mark("create-openclaw-coding-tools");
   const preNormalizationDiagnostics: RuntimeToolSchemaDiagnostic[] = [];