@@ -182,7 +182,7 @@ const table = sqliteTable("session", {
 - Reusing a Session ID adopts the existing Session. Reusing a user or synthetic inbox item ID is idempotent when Session and type match: the first admission wins and the retried payload, metadata, and delivery mode are ignored, whether the item is still pending or already delivered (reconciled from the projected message without retained enqueue history). Cross-Session or cross-type reuse fails. Control items keep their operation-specific conflict behavior.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; interruption of a known but idle or locally unowned Session is a no-op, while the public API rejects an unknown Session.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
-- Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
+- Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Both token-window and request-payload rejections may trigger that rebuild before durable output; payload recovery starts compaction without inline media. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
 - Keep provider-specific native compaction mechanisms in `@opencode/ai` behind `LLMClient.compact`. `SessionCompaction` chooses a summary or native compaction from the model's `compaction` setting and owns route provenance, request shrinking, the retry policy, interruption, usage accounting, and checkpoint persistence.
 - Keep delivery vocabulary explicit. Prompts steer by default. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 
@@ -4,7 +4,7 @@ export { ImageClient } from "./image-client.js"
 export { Auth } from "./route/auth.js"
 export { Provider } from "./provider.js"
 export { ProviderPackage } from "./provider-package.js"
-export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js"
+export { isContextOverflow, isContextOverflowFailure, isPayloadTooLargeFailure, isRetryable } from "./provider-error.js"
 export type {
   RouteLanguageModelInput,
   RouteRoutedLanguageModelInput,
 
@@ -74,6 +74,11 @@ export const isContextOverflowFailure = (failure: unknown) =>
     ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow"
 
+export const isPayloadTooLargeFailure = (failure: unknown) =>
+  failure instanceof AIError
+    ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "payload-too-large"
+    : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "payload-too-large"
+
 /**
  * Whether a failed call may succeed when sent again: rate limits, provider-side failures, transport failures that did
  * not deliver an accepted write, and unrecognized failures. Callers decide which calls are safe to repeat.
 
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { isContextOverflow } from "../src/index.js"
+import { AIError, InvalidRequestError, LLMEvent, isContextOverflow, isPayloadTooLargeFailure } from "../src/index.js"
 import { classifyProviderFailure, providerErrorMessage } from "../src/provider-error.js"
 
 describe("provider error classification", () => {
@@ -45,6 +45,30 @@ describe("provider error classification", () => {
     )
   })
 
+  test("recognizes payload rejection errors and stream events without treating other failures as size errors", () => {
+    const reason = classifyProviderFailure({
+      message: "Gateway request body exceeds the configured limit.",
+      status: 413,
+      rawBody: '{"error":{"code":"proxy_error","status":413}}',
+    })
+    expect(isPayloadTooLargeFailure(new AIError({ reason }))).toBe(true)
+    expect(
+      isPayloadTooLargeFailure(
+        LLMEvent.providerError({
+          message: "Too large",
+          classification: "payload-too-large",
+        }),
+      ),
+    ).toBe(true)
+    expect(isPayloadTooLargeFailure(new AIError({ reason: new InvalidRequestError({ message: "Invalid" }) }))).toBe(
+      false,
+    )
+    expect(
+      isPayloadTooLargeFailure(LLMEvent.providerError({ message: "Too long", classification: "context-overflow" })),
+    ).toBe(false)
+    expect(isPayloadTooLargeFailure(undefined)).toBe(false)
+  })
+
   test("does not classify rate limits as context overflow", () => {
     const messages = [
       "Throttling error: Too many tokens, please wait before trying again.",
 
@@ -48,8 +48,8 @@ export type Editor = {
 }
 
 export type Trigger =
-  /** `overflow`: the provider just rejected this context as too long. */
-  | { readonly reason: "auto" | "overflow"; readonly context: SessionContext.Loaded }
+  /** `overflow`: token window rejection; `payload`: request body size rejection. */
+  | { readonly reason: "auto" | "overflow" | "payload"; readonly context: SessionContext.Loaded }
   /** `inputID` is the `/compact` inbox item, whose message shows the outcome. */
   | { readonly reason: "manual"; readonly context: SessionContext.Loaded; readonly inputID: SessionMessage.ID }
 
@@ -383,7 +383,8 @@ export const layer = Layer.effect(
       const policy = yield* SessionRunnerRetry.policy(context.session.id)
       let rejections = 0
       let rejected: number | undefined
-      let asText = false
+      // A primary request already rejected for its bytes must not resend the same inline media to summarize it.
+      let asText = trigger.reason === "payload"
 
       while (true) {
         const fits = !asText && estimateRequest(prepared.request) <= target
 
@@ -259,13 +259,14 @@ const layer = Layer.effect(
               retry: proposed,
             }),
           recoverContinuation,
-          recoverOverflow: Effect.suspend(() =>
-            recoverOverflow
-              ? compaction
-                  .compact({ reason: "overflow", context: loaded })
-                  .pipe(Effect.map((result) => result.status === "completed"))
-              : Effect.succeed(false),
-          ),
+          recoverOverflow: (reason) =>
+            Effect.suspend(() =>
+              recoverOverflow
+                ? compaction
+                    .compact({ reason, context: loaded })
+                    .pipe(Effect.map((result) => result.status === "completed"))
+                : Effect.succeed(false),
+            ),
         })
         const completed = yield* SessionStep.Outcome.$match(outcome, {
           Completed: (outcome) => Effect.succeed(outcome.needsContinuation),
 
@@ -6,6 +6,7 @@ import {
   LLMClient,
   LLMEvent,
   isContextOverflowFailure,
+  isPayloadTooLargeFailure,
   type ProviderErrorEvent,
   type ToolCall,
 } from "@opencode/ai"
@@ -55,13 +56,16 @@ interface Input {
   ) => Effect.Effect<{ readonly retry: false } | SessionRunnerRetry.Decision>
   readonly recoverContinuation: boolean
   /** The runner owns compaction policy; the attempt invokes it only before durable output. */
-  readonly recoverOverflow: Effect.Effect<boolean>
+  readonly recoverOverflow: (reason: "overflow" | "payload") => Effect.Effect<boolean>
 }
 
 const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
 const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
 const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
 
+const isRequestOverflowFailure = (failure: unknown) =>
+  isContextOverflowFailure(failure) || isPayloadTooLargeFailure(failure)
+
 /** Captures Location-scoped dependencies without introducing another service or execution loop. */
 export const make = Effect.gen(function* () {
   const bus = yield* Bus.Service
@@ -107,7 +111,7 @@ export const make = Effect.gen(function* () {
           if (overflowFailure || publisher.hasProviderError()) return
           if (
             LLMEvent.is.providerError(event) &&
-            isContextOverflowFailure(event) &&
+            isRequestOverflowFailure(event) &&
             !publisher.record().outputStarted
           ) {
             overflowFailure = event
@@ -147,12 +151,13 @@ export const make = Effect.gen(function* () {
         const overflow = overflowFailure ?? streamFailure
         if (
           !publisher.record().outputStarted &&
-          isContextOverflowFailure(overflow) &&
-          (yield* restore(input.recoverOverflow))
+          isRequestOverflowFailure(overflow) &&
+          (yield* restore(input.recoverOverflow(isPayloadTooLargeFailure(overflow) ? "payload" : "overflow")))
         ) {
-          yield* Effect.logWarning("provider rejected the request as too long; compacting", {
+          yield* Effect.logWarning("provider rejected the request size; compacted before retrying", {
             sessionID: input.sessionID,
             model: input.model.ref,
+            reason: isPayloadTooLargeFailure(overflow) ? "payload" : "overflow",
             message: overflow?.message,
           })
           return Outcome.Compacted()
@@ -179,7 +184,7 @@ export const make = Effect.gen(function* () {
         )
           return Outcome.RecoverFull()
         const retry =
-          llmFailure && llmError && !isContextOverflowFailure(llmFailure)
+          llmFailure && llmError && !isRequestOverflowFailure(llmFailure)
             ? yield* restore(
                 input.retry(
                   llmFailure,
 
@@ -3268,6 +3268,107 @@ describe("SessionRunnerLLM", () => {
     expect(yield* s.context).toMatchObject([{ type: "compaction" }, { type: "assistant", finish: "stop" }])
   })
 
+  for (const raw of [false, true]) {
+    scenario(`recovers once after a ${raw ? "raw" : "streamed"} payload-too-large rejection`, function* (s) {
+      yield* setupOverflowRecovery(s)
+      yield* s.llm.push(
+        raw
+          ? Stream.fail(payloadTooLarge())
+          : [LLMEvent.providerError({ message: "Too large", classification: "payload-too-large" })],
+        TestLLM.text("## Objective\n- Recover payload", "text-summary"),
+        TestLLM.text("Recovered", "text-final"),
+      )
+      yield* s.runPrompt("Continue")
+
+      expect(s.requests).toHaveLength(3)
+      expect(yield* s.context).toMatchObject([
+        { type: "compaction", summary: "## Objective\n- Recover payload" },
+        { type: "assistant", finish: "stop" },
+      ])
+      expect(yield* recordedEventTypes(sessionID)).not.toContain("session.step.failed.1")
+      yield* replaySessionProjection(sessionID)
+      expect(yield* s.context).toMatchObject([{ type: "compaction" }, { type: "assistant", finish: "stop" }])
+    })
+  }
+
+  scenario("omits inline media from the first payload recovery compaction and preserves stored history", function* (s) {
+    const image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="
+    yield* s.session.prompt({
+      sessionID,
+      text: "Inspect the screenshot",
+      files: [{ uri: `data:image/png;base64,${image}` }],
+      resume: false,
+    })
+    yield* s.llm.push(TestLLM.text("The screenshot shows a button", "inspection"))
+    yield* s.resume
+    s.requests.length = 0
+    yield* s.llm.push(
+      Stream.fail(payloadTooLarge()),
+      TestLLM.text("## Objective\n- Inspect the button", "summary"),
+      TestLLM.text("Recovered", "recovered"),
+    )
+    yield* s.runPrompt("Continue")
+
+    expect(s.requests).toHaveLength(3)
+    expect(s.requests[0]?.messages.some((m) => m.content.some((p) => p.type === "media"))).toBeTrue()
+    expect(s.requests[1]?.messages.every((m) => m.content.every((p) => p.type === "text"))).toBeTrue()
+    expect(JSON.stringify(s.requests[1])).not.toContain(image)
+    expect(JSON.stringify(s.requests[1])).toContain("The screenshot shows a button")
+    expect(JSON.stringify(yield* s.messages)).toContain(image)
+  })
+
+  scenario("does not recover payload rejection with automatic compaction disabled", function* (s) {
+    yield* setupOverflowRecovery(s)
+    const compaction = yield* SessionCompaction.Service
+    yield* compaction.transform((editor) => editor.configure({ auto: false }))
+    yield* s.llm.push(Stream.fail(payloadTooLarge()))
+    expect((yield* s.runPrompt("Continue").pipe(Effect.flip)).message).toBe("Too large")
+    expect(s.requests).toHaveLength(1)
+    expect(yield* s.context).not.toContainEqual(expect.objectContaining({ type: "compaction" }))
+  })
+
+  scenario("stops after a second payload rejection instead of compacting forever", function* (s) {
+    yield* setupOverflowRecovery(s)
+    yield* s.llm.push(
+      Stream.fail(payloadTooLarge()),
+      TestLLM.text("## Objective\n- Recover once", "summary"),
+      Stream.fail(payloadTooLarge()),
+    )
+    expect((yield* s.runPrompt("Continue").pipe(Effect.flip)).message).toBe("Too large")
+    expect(s.requests).toHaveLength(3)
+    expect(yield* s.context).toMatchObject([
+      { type: "compaction", status: "completed" },
+      { type: "assistant", finish: "error", error: { message: "Too large" } },
+    ])
+  })
+
+  scenario("does not recover payload rejection after durable output", function* (s) {
+    yield* setupOverflowRecovery(s)
+    yield* s.llm.push([
+      LLMEvent.textStart({ id: "partial" }),
+      LLMEvent.textDelta({ id: "partial", text: "Partial" }),
+      LLMEvent.textEnd({ id: "partial" }),
+      LLMEvent.providerError({ message: "Too large", classification: "payload-too-large" }),
+    ])
+    expect((yield* s.runPrompt("Continue").pipe(Effect.flip)).message).toBe("Too large")
+    expect(s.requests).toHaveLength(1)
+    expect(yield* s.context).not.toContainEqual(expect.objectContaining({ type: "compaction" }))
+  })
+
+  scenario("preserves the payload error when recovery compaction fails", function* (s) {
+    yield* setupOverflowRecovery(s)
+    yield* s.llm.push(Stream.fail(payloadTooLarge()), [LLMEvent.providerError({ message: "Summary unavailable" })])
+    expect((yield* s.runPrompt("Continue").pipe(Effect.flip)).message).toBe("Too large")
+    expect(s.requests).toHaveLength(2)
+    expect(yield* s.context).toContainEqual(
+      expect.objectContaining({
+        type: "compaction",
+        status: "failed",
+        error: { type: "provider.error", message: "Summary unavailable" },
+      }),
+    )
+  })
+
   scenario("refreshes preparation after overflow compaction without promoting new input", function* (s) {
     yield* setupOverflowRecovery(s)
 
 
@@ -118,7 +118,7 @@ for (const fixture of [
           retry: (_cause, _error, retry) =>
             Effect.succeed(retry ? { retry: true, attempt: 2, delay: 0 } : { retry: false }),
           recoverContinuation: true,
-          recoverOverflow: Effect.succeed(false),
+          recoverOverflow: () => Effect.succeed(false),
         })
         .pipe(Effect.exit)
       expect(Exit.isSuccess(result)).toBe(fixture.finish === "stop")