fix(opencode): publish overflow error when recovery is abandoned, not attempted

A provider 413 with auto-compaction on published Session.Event.Error and
then recovered: compact, retry, succeed. Every consumer of that channel
treats it as the run's outcome — CLI run exits 1, TUI shows an error
toast, the desktop app fires an OS notification, and orchestrators
tailing --format json mark the run failed — so a run that produced a
complete, correct result was reported as a failure.

The publish at processor.halt's auto-compact branch was the outlier on
three counts: it was the only publisher that does not set message.error
(the durable record disagreed with the event), the only one not followed
by idle or a throw, and nothing consumed it (compaction is triggered by
the "compact" return value). Recoverable provider errors elsewhere are
silent: retried 429s never publish, and the proactive overflow check
sets needsCompaction without an event.

Move the announcement to where failure is actually decided: compaction's
result === "compact" branch ("too large to compact even after
stripping"), which already writes the durable error but published
nothing — its error event previously arrived only as a side effect of
the halt re-entering during summary generation. Net contract:
session.error with a sessionID fires iff the outcome is affected.

Tests pin both directions: 413 -> compact -> retry exits 0 with no error
event; 413 -> compaction also overflows exits 1 with exactly one error
event carrying the clearer compaction message. Both fail without the
source change (verified by stashing it).

The recovered-413 fixture is from #123 by Magnus, which fixed the same
symptom consumer-side in run.ts; this supersedes it at the producer so
run.ts stays identical to upstream and stream consumers need no
clear-on-later-success logic.

Author: Alezander9

packages/opencode/src/session/compaction.ts

@@ -402,13 +402,20 @@ const layer = Layer.effect(
       })
 
       if (result === "compact") {
+        // Recovery abandoned: this is where overflow becomes an outcome, so
+        // the error event fires here rather than on the recoverable 413 in
+        // processor.halt.
         processor.message.error = new SessionV1.ContextOverflowError({
           message: replay
             ? "Conversation history too large to compact - exceeds model context limit"
             : "Session too large to compact - context exceeds model limit even after stripping media",
         }).toObject()
         processor.message.finish = "error"
         yield* session.updateMessage(processor.message)
+        yield* events.publish(Session.Event.Error, {
+          sessionID: input.sessionID,
+          error: processor.message.error,
+        })
         return "stop"
       }
 

packages/opencode/src/session/processor.ts

@@ -638,8 +638,13 @@ const layer = Layer.effect(
             yield* status.set(ctx.sessionID, { type: "idle" })
             return
           }
+          // Recovery attempt, not an outcome: auto-compaction will retry, so
+          // nothing is published here. The durable message carries no error
+          // either; announcing one on the error channel made every consumer
+          // (CLI exit code, TUI toast, orchestrators) fail runs that recover.
+          // If compaction cannot shrink the session, compaction.ts publishes
+          // the terminal error.
           ctx.needsCompaction = true
-          yield* events.publish(Session.Event.Error, { sessionID: ctx.sessionID, error })
           return
         }
         ctx.assistantMessage.error = error

packages/opencode/test/cli/run/run-process.test.ts

@@ -241,6 +241,63 @@ describe("opencode run (non-interactive subprocess)", () => {
     60_000,
   )
 
+  cliIt.concurrent(
+    "recovers from a provider size error via compaction without emitting an error event",
+    ({ llm, opencode }) =>
+      Effect.gen(function* () {
+        yield* llm.error(413, {
+          error: { type: "request_too_large", message: "Request exceeds the maximum size" },
+        })
+        yield* llm.text("compacted history")
+        yield* llm.text("recovered output")
+
+        const result = yield* opencode.run("recover after overflow", {
+          format: "json",
+          env: { OPENCODE_DISABLE_AUTOCOMPACT: "0" },
+        })
+
+        opencode.expectExit(result, 0)
+        const events = opencode.parseJsonEvents(result.stdout)
+        expect(events.some((event) => event.type === "error")).toBe(false)
+        expect(
+          events.some(
+            (event) =>
+              event.type === "text" &&
+              typeof event.part === "object" &&
+              event.part !== null &&
+              "text" in event.part &&
+              event.part.text === "recovered output",
+          ),
+        ).toBe(true)
+      }),
+    60_000,
+  )
+
+  cliIt.concurrent(
+    "exits nonzero with an error event when compaction cannot shrink the session",
+    ({ llm, opencode }) =>
+      Effect.gen(function* () {
+        yield* llm.error(413, {
+          error: { type: "request_too_large", message: "Request exceeds the maximum size" },
+        })
+        yield* llm.error(413, {
+          error: { type: "request_too_large", message: "Request exceeds the maximum size" },
+        })
+
+        const result = yield* opencode.run("overflow beyond recovery", {
+          format: "json",
+          env: { OPENCODE_DISABLE_AUTOCOMPACT: "0" },
+        })
+
+        opencode.expectExit(result, 1)
+        const events = opencode.parseJsonEvents(result.stdout)
+        const errors = events.filter((event) => event.type === "error")
+        expect(errors.length).toBe(1)
+        expect(JSON.stringify(errors[0])).toContain("too large to compact")
+      }),
+    60_000,
+  )
+
   cliIt.concurrent(
     "rejects requested permissions by default and allows them with the dangerous flag",
     ({ home, llm, opencode }) =>