@@ -363,9 +363,33 @@ function partIsAnthropicThinking(part: unknown): boolean {
     return type === "thinking" || type === "reasoning" || type === "redacted_thinking";
 }
 
+function partEndsAnthropicAssistantRun(part: unknown): boolean {
+    if (!part || typeof part !== "object") return false;
+    const value = part as Record<string, unknown>;
+    if (
+        value.type !== "tool" ||
+        value.providerExecuted === true ||
+        !value.state ||
+        typeof value.state !== "object"
+    ) {
+        return false;
+    }
+    const status = (value.state as Record<string, unknown>).status;
+    return status === "completed" || status === "error";
+}
+
+function partIsOpenCodeStepMetadata(part: unknown): boolean {
+    if (!part || typeof part !== "object") return false;
+    const type = (part as Record<string, unknown>).type;
+    return type === "step-start" || type === "step-finish";
+}
+
 /**
- * The Anthropic adapter merges adjacent assistant messages before sending them.
- * A merged run may contain only one leading thinking block; moving or retaining a
+ * The Anthropic adapter merges adjacent assistant content before sending it. A
+ * completed non-provider-executed tool result materializes as user content and
+ * starts a new assistant run, while OpenCode's step markers do not materialize
+ * on the provider wire.
+ * Each resulting assistant run may contain only one leading thinking block; a
  * later signed block would invalidate its provider signature, so recovery declines
  * the entire replay instead of attempting a rewrite.
  */
@@ -383,7 +407,10 @@ export function validateAnthropicReasoningRuns(messages: MessageLike[]): boolean
                 if (partIsAnthropicThinking(part)) {
                     thinkingBlocks += 1;
                     if (thinkingBlocks > 1 || sawOtherContent) return false;
-                } else {
+                } else if (partEndsAnthropicAssistantRun(part)) {
+                    thinkingBlocks = 0;
+                    sawOtherContent = false;
+                } else if (!partIsOpenCodeStepMetadata(part)) {
                     sawOtherContent = true;
                 }
             }
 
@@ -6,6 +6,7 @@ import {
     captureLkgSlot,
     projectLkgEntry,
     replayLkg,
+    validateAnthropicReasoningRuns,
     validateLkgEntry,
     validateLkgSeam,
 } from "./lkg-replay";
@@ -298,6 +299,69 @@ describe("LKG transform replay", () => {
         expect(getSlot("anthropic-invalid")).toBeUndefined();
     });
 
+    test("serves a new Anthropic thinking run after a completed tool result", () => {
+        resetLkgSlotsForTest();
+        const prefix = assistant("a-prefix", 1, [
+            { type: "step-start" },
+            { type: "thinking", thinking: "first signed trace", signature: "sig-a" },
+            { type: "text", text: "calling a tool" },
+            {
+                type: "tool",
+                callID: "call-1",
+                tool: "read",
+                providerExecuted: false,
+                state: { status: "completed", input: {}, output: "result" },
+            },
+            { type: "step-finish" },
+        ]);
+        captureSlot("anthropic-tool-boundary", {
+            jsonPrefix: JSON.stringify([prefix]),
+            inputIdSeq: ["u-anchor"],
+            inputContentDigests: [
+                lkgContentDigest(
+                    user("u-anchor", 2, { providerID: "anthropic", modelID: "claude-test" }),
+                )!,
+            ],
+            lastInputMessageId: "u-anchor",
+            modelKey: "anthropic/claude-test",
+            providerKey: "anthropic",
+            capturedAt: 1,
+        });
+        const current = [
+            user("u-anchor", 2, { providerID: "anthropic", modelID: "claude-test" }),
+            assistant("a-tail", 3, [
+                { type: "thinking", thinking: "second signed trace", signature: "sig-b" },
+                { type: "text", text: "second response" },
+            ]),
+        ];
+
+        const replay = replayLkg({
+            sessionId: "anthropic-tool-boundary",
+            messages: current,
+            modelKey: "anthropic/claude-test",
+            providerKey: "anthropic",
+        });
+        expect(replay).toEqual({ ok: true, messages: [prefix, current[1]] });
+    });
+
+    test("declines a new thinking run after a provider-executed tool", () => {
+        const first = assistant("a-prefix", 1, [
+            { type: "thinking", thinking: "first signed trace", signature: "sig-a" },
+            {
+                type: "tool",
+                callID: "call-1",
+                tool: "provider-tool",
+                providerExecuted: true,
+                state: { status: "completed", input: {}, output: "result" },
+            },
+        ]);
+        const second = assistant("a-tail", 2, [
+            { type: "thinking", thinking: "second signed trace", signature: "sig-b" },
+        ]);
+
+        expect(validateAnthropicReasoningRuns([first, second])).toBe(false);
+    });
+
     test("serves an Anthropic replay with one leading thinking block in an assistant run", () => {
         resetLkgSlotsForTest();
         captureSlot("anthropic-valid", {
 
@@ -1864,6 +1864,89 @@ describe("Rust mode authority adapter", () => {
         expect(output.messages).toEqual([]);
     });
 
+    it("refuses a large raw fallback when the token estimator is unavailable", async () => {
+        const sessionId = `rust-raw-estimator-unavailable-${Date.now()}`;
+        sessions.push(sessionId);
+        const db = makeDb();
+        installRawProvider(sessionId);
+        recordDetectedContextLimit(db, sessionId, 1_000, "test-provider/test-model");
+        const moduleClient: RustModeModuleClient = {
+            call: async ({ method }) => {
+                if (method === "transform") throw new Error("client closed");
+                return { ok: true };
+            },
+        };
+        const deps = makeDeps(db, moduleClient);
+        let estimatorCalls = 0;
+        const transform = createRustModeTransform(deps, {
+            moduleClient,
+            rawFallbackEstimatorForTests: () => {
+                estimatorCalls += 1;
+                throw new Error("tokenizer unavailable");
+            },
+        });
+        const input = [
+            {
+                info: {
+                    id: "m1",
+                    role: "user",
+                    sessionID: sessionId,
+                    model: { providerID: "test-provider", modelID: "test-model" },
+                },
+                parts: [{ type: "text", text: "x".repeat(5_000) }],
+            },
+        ] as MessageLike[];
+        const output = { messages: [] as unknown[] };
+
+        await expect(
+            transform.run(sessionId, input, output, makeMeta(db, sessionId)),
+        ).rejects.toBeInstanceOf(RawFallbackContextLimitError);
+        expect(estimatorCalls).toBe(1);
+        expect(output.messages).toEqual([]);
+    });
+
+    it("refuses a byte-large raw fallback when the token estimate is materially low", async () => {
+        const sessionId = `rust-raw-estimator-low-${Date.now()}`;
+        sessions.push(sessionId);
+        const db = makeDb();
+        installRawProvider(sessionId);
+        recordDetectedContextLimit(db, sessionId, 1_000, "test-provider/test-model");
+        const moduleClient: RustModeModuleClient = {
+            call: async ({ method }) => {
+                if (method === "transform") throw new Error("client closed");
+                return { ok: true };
+            },
+        };
+        const deps = makeDeps(db, moduleClient);
+        const transform = createRustModeTransform(deps, {
+            moduleClient,
+            rawFallbackEstimatorForTests: () => ({
+                tokens: 900,
+                trusted: true,
+                messageTokens: { conversation: 900, toolCall: 0 },
+                systemTokens: 0,
+                toolDefinitionTokens: 0,
+            }),
+        });
+        const input = [
+            {
+                info: {
+                    id: "m1",
+                    role: "user",
+                    sessionID: sessionId,
+                    model: { providerID: "test-provider", modelID: "test-model" },
+                },
+                parts: [{ type: "text", text: "x".repeat(5_000) }],
+            },
+        ] as MessageLike[];
+        const output = { messages: [] as unknown[] };
+
+        await expect(
+            transform.run(sessionId, input, output, makeMeta(db, sessionId)),
+        ).rejects.toBeInstanceOf(RawFallbackContextLimitError);
+        expect(output.messages).toEqual([]);
+    });
+
     it("preserves raw fail-open when the estimate fits the known context limit", async () => {
         const sessionId = `rust-raw-fits-${Date.now()}`;
         sessions.push(sessionId);
 
@@ -102,6 +102,17 @@ export const RUST_PARK_RETRY_INTERVAL = 5;
 export const RUST_EMERGENCY_WALL_PCT = 95;
 export const RUST_PARK_PROBE_PRESSURE_BYPASS_PCT = 90;
 const RUST_SEND_TIMEOUT_MS = 15_000;
+const RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
+
+function rawFallbackSerializedBytes(messages: readonly MessageLike[]): number | null {
+    try {
+        const serialized = JSON.stringify(messages);
+        return typeof serialized === "string" ? Buffer.byteLength(serialized) : null;
+    } catch {
+        // Serialization is itself required before these messages can reach a provider.
+        return null;
+    }
+}
 
 export interface RustModeModuleClient extends ModuleStateSyncClient {
     authorityStatus?(args: {
@@ -212,6 +223,8 @@ export interface RustModeTransformOptions {
     allowAuthorityProtocolBypassForTests?: boolean;
     /** Override only for deterministic capture scheduling in tests. */
     scheduleLkgCapture?: (capture: () => void) => void;
+    /** Override only to exercise raw-fallback estimator failures in tests. */
+    rawFallbackEstimatorForTests?: typeof estimateFinalWireInputTokens;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -1110,6 +1123,8 @@ export function createRustModeTransform(
     const wireCaches = new Map<string, RustWireCache>();
     const scheduleLkgCapture =
         options.scheduleLkgCapture ?? ((capture: () => void) => setImmediate(capture));
+    const rawFallbackEstimator =
+        options.rawFallbackEstimatorForTests ?? estimateFinalWireInputTokens;
     const timeoutMs = Math.max(1, options.moduleTimeoutMs ?? RUST_SEND_TIMEOUT_MS);
 
     const logStage = (
@@ -1421,26 +1436,34 @@ export function createRustModeTransform(
                     ? overflowState.detectedContextLimit
                     : undefined);
             if (contextLimit !== undefined) {
+                let estimate: ReturnType<typeof estimateFinalWireInputTokens> | undefined;
                 try {
-                    const estimate = estimateFinalWireInputTokens({
+                    estimate = rawFallbackEstimator({
                         messages,
                         systemPromptTokens: sessionMeta.systemPromptTokens,
                         providerID: model?.providerID,
                         modelID: model?.modelID,
                         agentName: deps.getNotificationParams?.(sessionId)?.agent,
                     });
-                    if (estimate.tokens > contextLimit) {
-                        sessionLog(
-                            sessionId,
-                            `raw_fallback_over_context_limit estimated=${estimate.tokens} limit=${contextLimit}`,
-                        );
-                        throw new RawFallbackContextLimitError(estimate.tokens, contextLimit, {
-                            cause,
-                        });
-                    }
-                } catch (error) {
-                    if (error instanceof RawFallbackContextLimitError) throw error;
-                    // An unavailable estimate leaves the ordinary raw fail-open contract intact.
+                } catch {
+                    // The byte proxy below remains available when tokenization does not.
+                }
+                const rawBytes = rawFallbackSerializedBytes(messages);
+                // The local tokenizer is telemetry-grade and can materially undercount a new
+                // provider tokenizer. Four serialized bytes per context token is an independent,
+                // conservative risk budget for a raw full-history fallback.
+                const proxyTokens =
+                    rawBytes === null
+                        ? contextLimit + 1
+                        : Math.ceil(rawBytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+                const refusalTokens = Math.max(estimate?.tokens ?? 0, proxyTokens);
+                if (refusalTokens > contextLimit) {
+                    sessionLog(
+                        sessionId,
+                        `raw_fallback_over_context_limit estimated=${estimate?.tokens ?? "unavailable"} ` +
+                            `proxy_bytes=${rawBytes ?? "unavailable"} proxy_tokens=${proxyTokens} limit=${contextLimit}`,
+                    );
+                    throw new RawFallbackContextLimitError(refusalTokens, contextLimit, { cause });
                 }
             }
             replaceMessagesInPlace(output, messages);