jeo-code 0.7.42 → 0.7.44

package/CHANGELOG.md

@@ -6,6 +6,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.7.44] - 2026-07-06
+_Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call._
+
+### Added
+- **Engine-level transient-network recovery ladder** (`src/agent/engine.ts`) — a mid-stream socket drop (`isTransientStreamDropError`, `src/util/retry.ts`: Bun/undici `"socket connection was closed"`/`ConnectionClosed`, Node's `"socket hang up"`/`"other side closed"`/`UND_ERR_SOCKET`) now resends the SAME step with capped exponential backoff (`GUARD_LIMITS.MAX_TRANSIENT_NETWORK_RETRIES` = 5, base 1s doubling to a 15s ceiling, `JEO_TRANSIENT_NETWORK_BACKOFF_BASE_MS` override) instead of ending the turn — visible via `onNotice` (`"connection dropped mid-response (…) — auto-retry #N in Ns"`), Esc/Ctrl-C cancellable mid-wait, and a real terminal error still surfaces once the bounded budget is exhausted (a persistent outage is not spun on forever). Deliberately narrower than `defaultRetryable`: a rate-limit/5xx/timeout error already ran the FULL model-manager `withRetry` budget before reaching the engine, so this ladder only matches the socket-death signature that layer structurally cannot retry.
+- `defaultRetryable` (`src/util/retry.ts`) now also classifies the same socket-drop message shapes as a transient network fault, so a drop BEFORE the first streamed chunk (still inside model-manager's own retry budget) is retried there too.
+
+### Verified
+- `bun run typecheck` clean; `bun test` 2429 pass / 0 fail.
+- New `test/transient-network-recovery.test.ts`: mid-stream socket drop resends and recovers; the bounded retry budget exhausts to a terminal error (not an infinite spin); Esc/Ctrl-C cancels the backoff wait; a deterministic safety refusal is still routed to the refusal ladder, never this one.
+- `test/retry.test.ts`: `defaultRetryable` now accepts the Bun `"socket connection was closed…"` message and the Node `"socket hang up"`/`"other side closed"`/`UND_ERR_SOCKET` equivalents.
+
+## [0.7.43] - 2026-07-06
+_TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves._
+
+### Added
+- **`src/tui/terminal-image.ts`** — protocol detection (`detectImageProtocol`, env/TTY-signal based: `KITTY_WINDOW_ID`/`GHOSTTY_RESOURCES_DIR`/`WEZTERM_PANE`/`ITERM_SESSION_ID`/`TERM_PROGRAM`, plus a `$TERM` fallback for tmux/screen-wrapped kitty sessions), dependency-free dimension parsers for PNG/JPEG/GIF/WEBP/BMP (own implementations against each format's public header spec — not ported from gjc's native Rust decoder), aspect-ratio-preserving cell fitting (`fitImageToCells`, never upscales), and encoders for both protocols (`encodeKittyImage` — chunked at the spec's 4096-byte boundary for large payloads; `encodeIterm2Image` — cell-based `width=`/`height=`, never `"auto"`, so jeo's fit math always agrees with what the terminal actually draws). `JEO_IMAGE_PROTOCOL=kitty|iterm2|none` forces a protocol; `JEO_NO_IMAGE_PREVIEW=1` disables inline rendering outright (same shape as `JEO_NO_MULTILINE`/`JEO_NO_MEMORY`).
+- **`src/tui/components/image-preview.ts`** — bridges `ImageAttachment[]` to the protocol layer: renders each attachment as an inline picture when the terminal/format combination supports it, else a dim `⧉ [mediaType] WxH` text caption (kitty's `f=100` decodes PNG only — a JPEG/GIF/WEBP/BMP attachment on a kitty-protocol terminal falls back to caption; iTerm2 decodes any host-native format, so those always render).
+- **`LaunchTui.flushUserCard(text, images?)`** (`src/tui/app.ts`) — the turn-starting user card now accepts the turn's image attachments and, in inline mode on a supporting terminal, flushes them into scrollback via a new `flushImageAttachments` that bypasses `appendLedger`'s width-wrap path entirely (a raw base64 image escape is not text — `wrapTextWithAnsi`/`visibleWidth` would measure its payload as thousands of display columns and mangle it mid-sequence). Wired from `runTurn` in `src/commands/launch.ts` for the real submitted prompt (a skill run's suppressed/compact card, which never carried the user's own attachments, is unaffected).
+
+### Fixed
+- **`truncateToWidth`** (`src/tui/components/width.ts`) now treats an inline-image escape line (detected via the new `isImageEscapeLine`) as opaque and returns it unchanged — a defensive fix for every current and future call site in the truncation pipeline (`terminal.ts#truncate`, the REPL's `logLines`, `Renderer.render`'s live-frame diff): naive column-counting would otherwise slice into a base64 payload mid-sequence, corrupting the image or leaving an unterminated escape that hangs the terminal waiting for its `ESC \`/BEL terminator.
+
+### Verified
+- `bun run typecheck` clean; `bun test` 2424 pass / 0 fail (34 new: `test/terminal-image.test.ts` — protocol detection incl. env-override/disable/tmux-fallback matrix, all 5 dimension parsers against real per-format headers plus malformed-input rejection, cell-fit aspect-ratio math, both encoders incl. kitty's >4096-byte chunking, the `isImageEscapeLine` guard, and the full `renderInlineImage` row-cursor construction proved line-by-line for both protocols; `test/image-preview.test.ts` — multi-attachment stacking and mixed protocol-support fallback; 3 new `LaunchTui.flushUserCard` cases covering a rendered image, a suppressed-terminal fallback with zero escape leakage, and the already-finished no-op).
+- Manual end-to-end smoke test against the real attached terminal (kitty): generated a genuine 4x4 PNG (real zlib-deflated IDAT, not just a magic-byte fixture), ran it through the actual `renderInlineImage` → wrote the resulting kitty APC sequence to `/dev/tty` — completed without hanging or corrupting the terminal. Repeated with an iTerm2 OSC 1337 sequence sent to the same (non-iTerm2) terminal to confirm an unsupported protocol degrades silently (BEL-terminated, ignored) rather than leaking garbage.
+
 ## [0.7.42] - 2026-07-06
 _Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too._
 

package/README.ja.md

@@ -259,11 +259,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
+- **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
 - **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 - **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
 - **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
-- **[0.7.39]** (2026-07-05) — Fixes an unrecovered Anthropic refusal on Claude Fable 5: the new `stop_details.category: "reasoning_extraction"` refusal shape wasn't recognized, so the turn died with a raw, unfriendly error instead of engaging jeo's existing context-reset refusal-recovery ladder.
-- **[0.7.38]** (2026-07-05) — Ponytail review of 0.7.37's Telegram daemon: closes a real trust-boundary gap (any Telegram user could steer/cancel subagents, not just the paired chat) and a `getUpdates`-failure hot-loop, plus bloat/style cleanup — no new surface area, no config changes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -259,11 +259,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
+- **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
 - **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 - **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
 - **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
-- **[0.7.39]** (2026-07-05) — Fixes an unrecovered Anthropic refusal on Claude Fable 5: the new `stop_details.category: "reasoning_extraction"` refusal shape wasn't recognized, so the turn died with a raw, unfriendly error instead of engaging jeo's existing context-reset refusal-recovery ladder.
-- **[0.7.38]** (2026-07-05) — Ponytail review of 0.7.37's Telegram daemon: closes a real trust-boundary gap (any Telegram user could steer/cancel subagents, not just the paired chat) and a `getUpdates`-failure hot-loop, plus bloat/style cleanup — no new surface area, no config changes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -261,11 +261,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
+- **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
 - **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 - **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
 - **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
-- **[0.7.39]** (2026-07-05) — Fixes an unrecovered Anthropic refusal on Claude Fable 5: the new `stop_details.category: "reasoning_extraction"` refusal shape wasn't recognized, so the turn died with a raw, unfriendly error instead of engaging jeo's existing context-reset refusal-recovery ladder.
-- **[0.7.38]** (2026-07-05) — Ponytail review of 0.7.37's Telegram daemon: closes a real trust-boundary gap (any Telegram user could steer/cancel subagents, not just the paired chat) and a `getUpdates`-failure hot-loop, plus bloat/style cleanup — no new surface area, no config changes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -259,11 +259,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
+- **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
 - **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 - **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
 - **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
-- **[0.7.39]** (2026-07-05) — Fixes an unrecovered Anthropic refusal on Claude Fable 5: the new `stop_details.category: "reasoning_extraction"` refusal shape wasn't recognized, so the turn died with a raw, unfriendly error instead of engaging jeo's existing context-reset refusal-recovery ladder.
-- **[0.7.38]** (2026-07-05) — Ponytail review of 0.7.37's Telegram daemon: closes a real trust-boundary gap (any Telegram user could steer/cancel subagents, not just the paired chat) and a `getUpdates`-failure hot-loop, plus bloat/style cleanup — no new surface area, no config changes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,8 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.42",
-
-
+  "version": "0.7.44",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -22,7 +22,7 @@ import { createLspTool } from "./lsp-tool";
 import { createLspRenameTool } from "./lsp-rename-tool";
 import { createDebugTool } from "./debug-tool";
 import { createBrowserTool } from "./browser-tool";
-import { isRateLimitError, waitAbortable } from "../util/retry";
+import { isRateLimitError, isTransientStreamDropError, waitAbortable } from "../util/retry";
 import { isContextOverflowError, isRefusalError, friendlyProviderError } from "../util/provider-error";
 import { runPreToolHooks, runPostTurnHooksForBatch } from "./hooks";
 import { truncateToolOutput, formatToolResultBody } from "./tool-output";
@@ -530,6 +530,14 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   // no-progress clock keeps ticking and terminates the turn at JEO_TURN_MAX_MS).
   const MAX_REFUSAL_RETRIES = GUARD_LIMITS.MAX_REFUSAL_RETRIES;
   let refusalRetries = 0;
+  // Transient-network ladder (mid-stream Bun/undici socket-closed, ECONNRESET, 5xx, …):
+  // `retryableStream` (model-manager.ts) only auto-retries losing the FIRST chunk — once
+  // any chunk has streamed to the caller it deliberately stops retrying (a full re-call
+  // would replay already-emitted content). A drop AFTER the first chunk therefore used to
+  // propagate straight out of invokeCallLlm and end the turn with a raw "Error: …", even
+  // though nothing was committed to `history` (the failed step never pushed) — a plain
+  // resend is exactly as safe as the refusal ladder's rung-1 free resend below.
+  let transientNetworkRetries = 0;
   let lastSig = "";
   let repeatCount = 0;
   // Cycle guard (the A↔B ping-pong the exact-repeat guard cannot see): the recent
@@ -799,6 +807,27 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
         await waitAbortable(delayMs, opts.signal);
         continue; // loop top surfaces "Cancelled." when the wait was aborted
       }
+      // Mid-stream transient-network drop (see `transientNetworkRetries` above): bounded
+      // resend with capped exponential backoff. Deliberately narrower than a general
+      // `defaultRetryable` check — a rate-limit/5xx/timeout error already ran the FULL
+      // model-manager `withRetry` budget (visible as its own "auto-retry #N" notices)
+      // before reaching here, so re-retrying it in this ladder too would silently double
+      // that budget. `isTransientStreamDropError` matches only the mid-stream socket-death
+      // class that `retryableStream` structurally cannot retry once a chunk has streamed.
+      if (isTransientStreamDropError(err)) {
+        transientNetworkRetries++;
+        if (transientNetworkRetries <= GUARD_LIMITS.MAX_TRANSIENT_NETWORK_RETRIES) {
+          const baseRaw = Number(jeoEnv("TRANSIENT_NETWORK_BACKOFF_BASE_MS") ?? NaN);
+          const baseMs = Number.isFinite(baseRaw) && baseRaw >= 0 ? baseRaw : GUARD_LIMITS.TRANSIENT_NETWORK_BACKOFF_BASE_MS;
+          const delayMs = Math.min(baseMs * 2 ** (transientNetworkRetries - 1), GUARD_LIMITS.TRANSIENT_NETWORK_BACKOFF_MAX_MS);
+          const escHint = ev.onModelStream ? " (Esc to cancel)" : "";
+          ev.onNotice?.(
+            `connection dropped mid-response (${friendlyProviderError(err)}) — auto-retry #${transientNetworkRetries} in ${Math.max(1, Math.round(delayMs / 1000))}s${escHint}`,
+          );
+          await waitAbortable(delayMs, opts.signal);
+          continue; // loop top surfaces "Cancelled." when the wait was aborted
+        }
+      }
       const message = friendlyProviderError(err);
       // The error IS the turn's doneReason and every caller displays that — emitting a
       // separate error event here printed the same message twice (live stream + reply).

package/src/agent/loop-guards.ts

@@ -54,6 +54,16 @@ export const GUARD_LIMITS = Object.freeze({
   MAX_PARSE_BOUNCES: 2,
   /** Recent-signature window scanned for an A↔B (≤2 distinct calls) cycle. */
   CYCLE_WINDOW: 6,
+  /** Mid-stream transient-network drops (Bun/undici socket-closed, ECONNRESET, stream
+   *  idle, 5xx, …) tolerated per turn before surfacing a terminal error. Distinct from
+   *  the refusal ladder: these are infra/transport faults, not content-classifier trips,
+   *  so a bounded retry (not unbounded backoff) is correct — a persistent failure past
+   *  this many attempts is a real outage worth surfacing, not spinning on forever. */
+  MAX_TRANSIENT_NETWORK_RETRIES: 5,
+  /** First transient-network retry wait (ms); doubles per attempt. */
+  TRANSIENT_NETWORK_BACKOFF_BASE_MS: 1_000,
+  /** Ceiling on the transient-network retry wait (ms). */
+  TRANSIENT_NETWORK_BACKOFF_MAX_MS: 15_000,
 });
 
 /**

package/src/commands/launch.ts

@@ -938,7 +938,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // in scrollback. opts.userCard overrides it: null suppresses the card entirely
       // (skill runs), a string shows a compact label instead of the raw input.
       const cardText = opts?.userCard === undefined ? userInput : opts.userCard;
-      if (tui && cardText && cardText.trim()) tui.flushUserCard(cardText);
+      // Images render alongside the card only for the real prompt (undefined
+      // userCard) — a skill run's compact/suppressed card never carried the
+      // user's own attachments in the first place (buildSkillTask calls above
+      // never pass `images`), so there is nothing to show either way.
+      if (tui && cardText && cardText.trim()) tui.flushUserCard(cardText, opts?.userCard === undefined ? images : undefined);
       tui?.setContextUsage(historyTokens(history), contextTokens);
 
       // Per-turn steering inbox (gjc parity): additional queries typed mid-turn land

package/src/tui/app.ts

@@ -38,6 +38,9 @@ import { formatDuration, formatUsage } from "./components/duration";
 import { renderHud, type JeoPhase } from "./components/hud";
 import { formatTodoWriteCard } from "./components/todo-card";
 import { renderInputBox, type HighlightRange } from "./components/input-box";
+import { renderImageAttachments } from "./components/image-preview";
+import { detectImageProtocol } from "./terminal-image";
+import type { ImageAttachment } from "../ai/types";
 import { jeoEnv } from "../util/env";
 import chalk from "chalk";
 
@@ -787,13 +790,35 @@ export class LaunchTui {
 
   /** Flush a `user` card into scrollback so a submitted query stays visible there
    *  (gjc parity), instead of only as the transient HUD turn-title / a status notice.
-   *  Shared by the prompt that STARTS a turn and the mid-turn steering flush. */
-  flushUserCard(text: string): void {
+   *  Shared by the prompt that STARTS a turn and the mid-turn steering flush.
+   *  `images` (clipboard/drag-drop/file-path attachments on THIS prompt) render as
+   *  an inline picture directly below the card on a terminal that speaks the kitty
+   *  or iTerm2 graphics protocol (gjc TUI-image parity); every other terminal, the
+   *  alt screen, and non-TTY output keep the existing text-only card unchanged. */
+  flushUserCard(text: string, images?: ImageAttachment[]): void {
     const t = (text ?? "").trim();
     if (!t || this.finished) return;
     const cols = Math.max(20, size().cols - 1);
     const lines = this.renderUserCard(t, cols);
     if (lines.length) this.appendLedger(lines.join("\n"), "card");
+    if (images?.length) this.flushImageAttachments(images, cols);
+  }
+
+  /** Render `images` (see {@link flushUserCard}) straight into scrollback via
+   *  `insertAbove`, bypassing `appendLedger`'s width-wrap path: an inline image
+   *  escape sequence is not text — `wrapTextWithAnsi`/`visibleWidth` would measure
+   *  its base64 payload as thousands of display columns and mangle it. Inline mode
+   *  only (alt screen has no scrollback to flush into; non-TTY has no terminal to
+   *  draw into) — every other mode already shows the "N image(s) attached" note
+   *  inline in the prompt text itself via `[image #N]` tags, unchanged. */
+  private flushImageAttachments(images: ImageAttachment[], cols: number): void {
+    if (!this.inline || this.finished) return;
+    const protocol = detectImageProtocol(process.env, this.tty);
+    const muted = this.theme.color ? chalk.dim : (s: string) => s;
+    const lines = renderImageAttachments(images, { cols, protocol, muted });
+    if (lines.length === 0) return;
+    this.recordActivity(`⧉ ${images.length} image(s) rendered`);
+    this.renderer.insertAbove(`${lines.join("\n")}\n`);
   }
 
   /** Mid-turn steering query → a `user` card in scrollback (accepted input that is

package/src/tui/components/image-preview.ts

@@ -0,0 +1,49 @@
+/**
+ * User-attached image → scrollback block. Bridges `ImageAttachment[]` (the
+ * clipboard/drag-drop/file-path attachments already supported by
+ * `util/file-attachment.ts` and `util/clipboard-image.ts`) to the inline-image
+ * escape sequences in `terminal-image.ts`, producing one stacked block ready for
+ * `Renderer.insertAbove` — gjc TUI-parity: jeo could already ATTACH an image to a
+ * turn, this is the missing DISPLAY half (the transcript previously showed only a
+ * `⧉ N image(s) attached` count, never the picture itself).
+ */
+import type { ImageAttachment } from "../../ai/types";
+import { detectImageProtocol, renderInlineImage, type ImageProtocol } from "../terminal-image";
+
+export interface ImagePreviewOptions {
+  /** Terminal columns available for the block (already margin-adjusted by the
+   *  caller, same convention as every other card renderer in `tui/app.ts`). */
+  cols: number;
+  /** Cap on how many terminal rows a SINGLE image may occupy — keeps one huge
+   *  screenshot from pushing the whole scrollback off-screen. */
+  maxRowsPerImage?: number;
+  /** Pre-detected protocol (tests / callers that already resolved it once per
+   *  process). Defaults to live detection against `process.env`/`process.stdout`. */
+  protocol?: ImageProtocol;
+  /** Dim/muted painter applied to text captions (fallback path) so they read as
+   *  secondary content, matching the rest of the TUI's caption styling. */
+  muted?: (s: string) => string;
+}
+
+/**
+ * Render every attachment as a stacked block of lines: an inline picture when the
+ * terminal protocol + format support it, else a dim text caption. Multiple
+ * attachments stack top-to-bottom, each keeping its own row reservation — see
+ * `terminal-image.ts#renderInlineImage` for why each image is self-contained
+ * (no dependency on being first/last in the stack).
+ */
+export function renderImageAttachments(images: ImageAttachment[], opts: ImagePreviewOptions): string[] {
+  if (images.length === 0) return [];
+  const protocol = opts.protocol ?? detectImageProtocol(process.env, !!process.stdout.isTTY);
+  const maxColumns = Math.max(10, Math.min(60, opts.cols - 4));
+  const maxRows = Math.max(4, opts.maxRowsPerImage ?? 20);
+  const muted = opts.muted ?? ((s: string) => s);
+
+  const lines: string[] = [];
+  for (const img of images) {
+    const result = renderInlineImage(img, protocol, { maxColumns, maxRows });
+    if (result.rendered) lines.push(...result.lines);
+    else lines.push(...result.lines.map(muted));
+  }
+  return lines;
+}

package/src/tui/components/width.ts

@@ -9,6 +9,7 @@
  * color escapes verbatim (never counting them) so colored/CJK lines truncate and
  * wrap without tearing an escape or miscounting a wide glyph.
  */
+import { isImageEscapeLine } from "../terminal-image";
 
 const TAB_STOP = 8;
 // Sticky SGR matcher: scan a heavily color-escaped line in O(n) without slicing.
@@ -96,6 +97,14 @@ export function visibleWidth(s: string): number {
 export function truncateToWidth(s: string, cols: number): string {
   const limit = Math.max(0, cols);
   if (limit === 0) return "";
+  // An inline terminal-image escape (Kitty APC / iTerm2 OSC 1337, see
+  // `../terminal-image.ts#isImageEscapeLine`) is not text: its "width" by a naive
+  // column count is the base64 payload length (thousands of columns), and slicing
+  // into the payload corrupts the image or leaves an unterminated escape that
+  // hangs the terminal waiting for its `ESC \\`/BEL terminator. The image was
+  // already fit to the caller's column budget when the sequence was BUILT, so the
+  // correct "truncation" here is always a no-op.
+  if (isImageEscapeLine(s)) return s;
   // Fast path: no escapes, no wide chars, no tabs → plain slice by length.
   if (!s.includes("\x1b") && !/[\t\u0300-\uffff]/.test(s) && !/[\u{10000}-\u{10ffff}]/u.test(s)) {
     return s.length <= limit ? s : s.slice(0, limit);

package/src/tui/terminal-image.ts

@@ -0,0 +1,363 @@
+/**
+ * Inline terminal image protocols (gjc TUI-parity): detect whether the attached
+ * terminal can render a real bitmap inline, and encode `ImageAttachment` bytes into
+ * the matching escape sequence — Kitty graphics protocol (also implemented by
+ * Ghostty and WezTerm) or iTerm2's OSC 1337 inline-image protocol. Sixel is
+ * intentionally NOT implemented: producing a sixel stream from arbitrary PNG/JPEG
+ * bytes needs a pixel quantizer, which would be jeo's first native/binary
+ * dependency — every terminal jeo targets (kitty/ghostty/wezterm/iTerm2) already
+ * speaks one of the two protocols below, so a text caption is the correct fallback
+ * everywhere else (Terminal.app, most Linux console/VTE terminals, CI/non-TTY).
+ *
+ * Callers never need to know which protocol was chosen: {@link renderInlineImage}
+ * returns either a ready-to-write escape block or `null` (caller shows the caption).
+ */
+// Inlined (not imported from `./terminal`) to keep this module free to be imported
+// FROM `./components/width` (see `isImageEscapeLine` below) without a cycle:
+// `./terminal` itself imports `truncateToWidth` from `./components/width`.
+function cursorUp(n: number): string {
+  return n > 0 ? `\x1b[${n}A` : "";
+}
+
+export enum ImageProtocol {
+  Kitty = "kitty",
+  Iterm2 = "iterm2",
+  None = "none",
+}
+
+export type EnvLike = Record<string, string | undefined>;
+
+export interface PixelDimensions {
+  widthPx: number;
+  heightPx: number;
+}
+
+export interface CellPixelSize {
+  widthPx: number;
+  heightPx: number;
+}
+
+/** `JEO_IMAGE_PROTOCOL=kitty|iterm2|none` forces the protocol regardless of
+ *  detection — the escape hatch for a misdetected terminal or a multiplexer that
+ *  doesn't forward `TERM_PROGRAM`. Unrecognized values are ignored (fall through
+ *  to detection) rather than silently disabling images. */
+function forcedProtocol(env: EnvLike): ImageProtocol | undefined {
+  const raw = env.JEO_IMAGE_PROTOCOL?.trim().toLowerCase();
+  if (!raw) return undefined;
+  if (raw === "kitty") return ImageProtocol.Kitty;
+  if (raw === "iterm2" || raw === "iterm") return ImageProtocol.Iterm2;
+  if (raw === "none" || raw === "off" || raw === "0" || raw === "false") return ImageProtocol.None;
+  return undefined;
+}
+
+/** `JEO_NO_IMAGE_PREVIEW=1` disables inline image rendering outright (same shape
+ *  as `JEO_NO_MULTILINE`/`JEO_NO_MEMORY`) — every attachment falls back to its text
+ *  caption. Distinct from `JEO_IMAGE_PROTOCOL=none` only in intent/discoverability;
+ *  both end at {@link ImageProtocol.None}. */
+export function imagePreviewDisabled(env: EnvLike = process.env): boolean {
+  const v = env.JEO_NO_IMAGE_PREVIEW;
+  return v === "1" || v === "true";
+}
+
+/**
+ * Detect the inline-image protocol the attached terminal speaks, from environment
+ * signals alone (no terminal query round-trip — keeps startup synchronous and
+ * side-effect-free, matching how `detectColorLevel` works). `env`/`isTty` are
+ * injectable for tests.
+ */
+export function detectImageProtocol(env: EnvLike = process.env, isTty = false): ImageProtocol {
+  if (imagePreviewDisabled(env)) return ImageProtocol.None;
+  const forced = forcedProtocol(env);
+  if (forced !== undefined) return forced;
+  if (!isTty) return ImageProtocol.None;
+
+  if (env.KITTY_WINDOW_ID) return ImageProtocol.Kitty;
+  if (env.GHOSTTY_RESOURCES_DIR) return ImageProtocol.Kitty; // Ghostty speaks the kitty graphics protocol
+  if (env.WEZTERM_PANE) return ImageProtocol.Kitty; // WezTerm speaks the kitty graphics protocol
+  if (env.ITERM_SESSION_ID) return ImageProtocol.Iterm2;
+
+  const termProgram = (env.TERM_PROGRAM ?? "").toLowerCase();
+  if (termProgram === "kitty") return ImageProtocol.Kitty;
+  if (termProgram === "ghostty" || termProgram === "wezterm") return ImageProtocol.Kitty;
+  if (termProgram === "iterm.app") return ImageProtocol.Iterm2;
+
+  // tmux/screen strip TERM_PROGRAM but usually preserve $TERM as "tmux-256color" /
+  // "screen.xterm-kitty" etc. — fall back to sniffing $TERM for a kitty signature
+  // (gjc parity: the same fallback it applies for tmux-wrapped kitty sessions).
+  const term = (env.TERM ?? "").toLowerCase();
+  if (term.includes("kitty")) return ImageProtocol.Kitty;
+  if ((term.startsWith("tmux") || term.startsWith("screen")) && env.KITTY_LISTEN_ON) return ImageProtocol.Kitty;
+
+  return ImageProtocol.None;
+}
+
+let cellPixelSizeOverride: CellPixelSize | undefined;
+
+/** Cell pixel size used to convert a target column/row box into scaled pixels for
+ *  the fit computation. jeo does not query the terminal for real font metrics (that
+ *  needs a synchronous escape round-trip on startup, which risks hanging on a
+ *  terminal that never answers) — 9x18 is the common monospace-at-default-size
+ *  figure (matches gjc's default) and only affects the ASPECT-RATIO fit, not
+ *  correctness: a wrong guess makes the preview a bit larger/smaller, never
+ *  corrupts output. Overridable for unusually large/small fonts. */
+export function getCellPixelSize(env: EnvLike = process.env): CellPixelSize {
+  if (cellPixelSizeOverride) return cellPixelSizeOverride;
+  const w = Number.parseInt(env.JEO_CELL_WIDTH_PX ?? "", 10);
+  const h = Number.parseInt(env.JEO_CELL_HEIGHT_PX ?? "", 10);
+  return {
+    widthPx: Number.isFinite(w) && w > 0 ? w : 9,
+    heightPx: Number.isFinite(h) && h > 0 ? h : 18,
+  };
+}
+
+/** Test-only: pin the cell size so fit-math assertions don't depend on env parsing. */
+export function setCellPixelSizeForTest(size: CellPixelSize | undefined): void {
+  cellPixelSizeOverride = size;
+}
+
+/** PNG: 8-byte signature + 4-byte length + "IHDR" (4 bytes) precede a big-endian
+ *  `{width, height}` u32 pair — the format's own spec, fixed offsets 16 and 20. */
+export function getPngDimensions(bytes: Uint8Array): PixelDimensions | null {
+  if (bytes.length < 24) return null;
+  if (bytes[0] !== 0x89 || bytes[1] !== 0x50 || bytes[2] !== 0x4e || bytes[3] !== 0x47) return null;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { widthPx: buf.readUInt32BE(16), heightPx: buf.readUInt32BE(20) };
+}
+
+/** JPEG: scan markers for the first SOFn (0xC0-0xC3, 0xC5-0xC7, 0xC9-0xCB, 0xCD-0xCF —
+ *  excludes 0xC4/0xC8/0xCC, which are DHT/JPG/DAC, not frame headers); height/width
+ *  are big-endian u16 at offsets 5/7 into that marker's segment. */
+export function getJpegDimensions(bytes: Uint8Array): PixelDimensions | null {
+  if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8) return null;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let offset = 2;
+  while (offset + 9 < buf.length) {
+    if (buf[offset] !== 0xff) { offset++; continue; }
+    const marker = buf[offset + 1]!;
+    const isSof = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+    if (isSof) return { heightPx: buf.readUInt16BE(offset + 5), widthPx: buf.readUInt16BE(offset + 7) };
+    if (marker === 0xd8 || (marker >= 0xd0 && marker <= 0xd9)) { offset += 2; continue; } // no-length markers
+    const segLen = buf.readUInt16BE(offset + 2);
+    if (segLen < 2) return null;
+    offset += 2 + segLen;
+  }
+  return null;
+}
+
+/** GIF87a/89a: little-endian u16 width/height at fixed offsets 6/8 in the Logical
+ *  Screen Descriptor, right after the 6-byte signature. */
+export function getGifDimensions(bytes: Uint8Array): PixelDimensions | null {
+  if (bytes.length < 10) return null;
+  const sig = Buffer.from(bytes.slice(0, 6)).toString("ascii");
+  if (sig !== "GIF87a" && sig !== "GIF89a") return null;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { widthPx: buf.readUInt16LE(6), heightPx: buf.readUInt16LE(8) };
+}
+
+/** WebP: RIFF container: dimensions live in the first sub-chunk, whose layout
+ *  differs by codec — VP8 (lossy, 10-bit width/height at a fixed offset), VP8L
+ *  (lossless, 14-bit packed into a little-endian u32), VP8X (extended, 24-bit
+ *  little-endian triples, stored as size-1). */
+export function getWebpDimensions(bytes: Uint8Array): PixelDimensions | null {
+  if (bytes.length < 30) return null;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WEBP") return null;
+  const chunk = buf.toString("ascii", 12, 16);
+  if (chunk === "VP8 ") {
+    return { widthPx: buf.readUInt16LE(26) & 0x3fff, heightPx: buf.readUInt16LE(28) & 0x3fff };
+  }
+  if (chunk === "VP8L") {
+    if (bytes.length < 25) return null;
+    const bits = buf.readUInt32LE(21);
+    return { widthPx: (bits & 0x3fff) + 1, heightPx: ((bits >> 14) & 0x3fff) + 1 };
+  }
+  if (chunk === "VP8X") {
+    return {
+      widthPx: (buf[24]! | (buf[25]! << 8) | (buf[26]! << 16)) + 1,
+      heightPx: (buf[27]! | (buf[28]! << 8) | (buf[29]! << 16)) + 1,
+    };
+  }
+  return null;
+}
+
+/** BMP: "BM" signature, then a DIB header whose size (u32 at offset 14) picks the
+ *  layout — the legacy 12-byte BITMAPCOREHEADER stores 16-bit dimensions at
+ *  offset 18/20; every later header (BITMAPINFOHEADER=40 and newer) stores 32-bit
+ *  signed dimensions at 18/22 (a negative height means top-down — take `abs`). */
+export function getBmpDimensions(bytes: Uint8Array): PixelDimensions | null {
+  if (bytes.length < 26 || bytes[0] !== 0x42 || bytes[1] !== 0x4d) return null;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dibSize = buf.readUInt32LE(14);
+  if (dibSize === 12) {
+    if (bytes.length < 22) return null;
+    return { widthPx: buf.readUInt16LE(18), heightPx: buf.readUInt16LE(20) };
+  }
+  if (bytes.length < 26) return null;
+  return { widthPx: buf.readInt32LE(18), heightPx: Math.abs(buf.readInt32LE(22)) };
+}
+
+/** Dispatch to the matching parser by IANA media type; `null` when unrecognized or
+ *  the bytes are too short/malformed to carry a header. */
+export function getImageDimensions(bytes: Uint8Array, mediaType: string): PixelDimensions | null {
+  switch (mediaType) {
+    case "image/png": return getPngDimensions(bytes);
+    case "image/jpeg": return getJpegDimensions(bytes);
+    case "image/gif": return getGifDimensions(bytes);
+    case "image/webp": return getWebpDimensions(bytes);
+    case "image/bmp": return getBmpDimensions(bytes);
+    default: return null;
+  }
+}
+
+export interface ImageFit {
+  columns: number;
+  rows: number;
+}
+
+/**
+ * Scale `dims` to fit within `maxColumns` x `maxRows` terminal cells, preserving
+ * aspect ratio (letterboxed, never cropped/stretched). Falls back to a 1:1
+ * guess (one column per ~1 cell-width of pixels) when `dims` is unknown so a
+ * dimension-less image (parser miss) still gets a sane box instead of a crash.
+ */
+export function fitImageToCells(dims: PixelDimensions | null, maxColumns: number, maxRows: number, cell: CellPixelSize): ImageFit {
+  const maxCols = Math.max(1, Math.floor(maxColumns));
+  const maxRowsClamped = Math.max(1, Math.floor(maxRows));
+  if (!dims || dims.widthPx <= 0 || dims.heightPx <= 0) {
+    return { columns: maxCols, rows: maxRowsClamped };
+  }
+  const maxWidthPx = maxCols * cell.widthPx;
+  const maxHeightPx = maxRowsClamped * cell.heightPx;
+  const scale = Math.min(maxWidthPx / dims.widthPx, maxHeightPx / dims.heightPx, 1);
+  const fittedWidthPx = dims.widthPx * scale;
+  const fittedHeightPx = dims.heightPx * scale;
+  return {
+    columns: Math.max(1, Math.min(maxCols, Math.round(fittedWidthPx / cell.widthPx))),
+    rows: Math.max(1, Math.min(maxRowsClamped, Math.ceil(fittedHeightPx / cell.heightPx))),
+  };
+}
+
+const KITTY_CHUNK_SIZE = 4096;
+
+/**
+ * Encode PNG bytes (base64) as a kitty graphics protocol APC sequence, chunked at
+ * 4096 base64 bytes per the spec (a payload above that MUST be split across
+ * multiple `m=1`-continued transmissions, terminated by one `m=0`). `a=T`
+ * (transmit-and-display in one step), `f=100` (PNG — the only compressed format
+ * the protocol decodes itself), `q=2` (suppress the terminal's OK/error response,
+ * which jeo never reads).
+ */
+export function encodeKittyImage(base64Png: string, fit: ImageFit): string {
+  const params = `a=T,f=100,q=2,c=${fit.columns},r=${fit.rows}`;
+  if (base64Png.length <= KITTY_CHUNK_SIZE) {
+    return `\x1b_G${params};${base64Png}\x1b\\`;
+  }
+  const parts: string[] = [];
+  for (let offset = 0; offset < base64Png.length; offset += KITTY_CHUNK_SIZE) {
+    const chunk = base64Png.slice(offset, offset + KITTY_CHUNK_SIZE);
+    const isFirst = offset === 0;
+    const isLast = offset + KITTY_CHUNK_SIZE >= base64Png.length;
+    const head = isFirst ? `${params},m=${isLast ? 0 : 1}` : `m=${isLast ? 0 : 1}`;
+    parts.push(`\x1b_G${head};${chunk}\x1b\\`);
+  }
+  return parts.join("");
+}
+
+/**
+ * Encode arbitrary image bytes (base64, any format iTerm2's host OS decodes —
+ * PNG/JPEG/GIF all included) as an OSC 1337 inline-image sequence. `inline=1`
+ * renders in place instead of downloading; `width`/`height` are given in CELLS
+ * (not "auto") so iTerm2's own scaling always agrees with jeo's precomputed
+ * {@link ImageFit} — the row-accounting in the caller depends on that agreement.
+ */
+export function encodeIterm2Image(base64Data: string, fit: ImageFit, name?: string): string {
+  const params = [`inline=1`, `width=${fit.columns}`, `height=${fit.rows}`, "preserveAspectRatio=1"];
+  if (name) params.push(`name=${Buffer.from(name).toString("base64")}`);
+  return `\x1b]1337;File=${params.join(";")}:${base64Data}\x07`;
+}
+
+/** True when `line` contains an inline-image escape sequence (Kitty APC or
+ *  iTerm2 OSC 1337) within its first 96 characters — a possible leading
+ *  `cursorUp(...)` prefix (see {@link renderInlineImage}) means the marker is not
+ *  always at offset 0. Callers that measure/truncate/wrap terminal lines by
+ *  DISPLAY WIDTH (`visibleWidth`, `truncateToWidth`, `wrapTextWithAnsi` in
+ *  `components/width.ts`) MUST treat a line matching this as opaque and pass it
+ *  through unchanged: the base64 payload is thousands of columns "wide" by a
+ *  naive count, and slicing mid-sequence corrupts or hangs the terminal (an
+ *  unterminated Kitty APC / OSC waits indefinitely for its `ESC \\` / BEL
+ *  terminator). Not currently wired into `width.ts` — every current image call
+ *  site (`insertAbove`) bypasses that pipeline entirely; exported so a future
+ *  call site can opt in without re-deriving the detection. */
+export function isImageEscapeLine(line: string): boolean {
+  const head = line.slice(0, 96);
+  return head.includes("\x1b_G") || head.includes("\x1b]1337;File=");
+}
+
+/** Human-readable stand-in for an attachment that can't be rendered inline
+ *  (unsupported terminal, unsupported format for the detected protocol, or an
+ *  undecodable dimension header). Mirrors the existing `⧉ N image(s) attached`
+ *  wording style used elsewhere in the TUI. */
+export function imageCaption(mediaType: string, dims: PixelDimensions | null, filename?: string): string {
+  const parts = [filename, `[${mediaType}]`, dims ? `${dims.widthPx}x${dims.heightPx}` : undefined].filter(Boolean);
+  return `⧉ ${parts.join(" ")}`;
+}
+
+export interface InlineImageResult {
+  /** Lines to feed into `Renderer.insertAbove` (or join with "\n" for a plain
+   *  `console.log`/pipe path). The array length equals the image's rendered
+   *  terminal-row footprint — every element is one physical row — so a caller
+   *  computing "rows written" from `lines.length` (as `insertAbove` does by
+   *  splitting on "\n") gets the correct height. */
+  lines: string[];
+  /** True when `lines` is a real inline image; false when it is a 1-line text
+   *  caption (unsupported terminal/format, or an unparsable header). */
+  rendered: boolean;
+}
+
+/**
+ * Build the escape sequence (or text caption) for one image attachment, sized to
+ * fit `maxColumns` x `maxRows` cells.
+ *
+ * Row bookkeeping (why this shape, not just "the sequence + rows-1 blank lines"):
+ * both protocols draw the image ANCHORED AT THE CURSOR'S ROW at the moment the
+ * escape is processed and expand DOWNWARD — they do not retroactively fill rows
+ * already scrolled past. So the cursor must already sit at the image's TOP row
+ * before the escape is written. `lines` therefore reserves `fit.rows - 1` blank
+ * rows FIRST (each later joined with "\n", which is what actually advances the
+ * cursor down — matches every other multi-row block `insertAbove` is fed), then a
+ * final row that rewinds the cursor back up to the reserved block's top
+ * (`cursorUp(fit.rows - 1)`) immediately before the escape sequence.
+ *
+ * After drawing, Kitty/kitty-compatible terminals leave the REAL cursor
+ * `fit.rows - 1` rows below the top (i.e. on the image's last row) — added to the
+ * caller's mandatory trailing "\n" (one per `InlineImageResult`, not emitted
+ * here), that lands the cursor exactly `fit.rows` rows below where it started,
+ * matching a plain `fit.rows`-line block of text. iTerm2 instead auto-advances
+ * PAST the image (`fit.rows` rows below the top), so a synthetic `cursorUp(1)`
+ * is appended after its escape to cancel that extra row and reach the same
+ * `fit.rows - 1` offset — keeping both protocols' net row math identical.
+ */
+export function renderInlineImage(
+  attachment: { mediaType: string; data: string },
+  protocol: ImageProtocol,
+  opts: { maxColumns: number; maxRows: number; filename?: string } = { maxColumns: 60, maxRows: 20 },
+): InlineImageResult {
+  const bytes = Buffer.from(attachment.data, "base64");
+  const dims = getImageDimensions(bytes, attachment.mediaType);
+  const caption = () => ({ lines: [imageCaption(attachment.mediaType, dims, opts.filename)], rendered: false });
+
+  if (protocol === ImageProtocol.None) return caption();
+  if (protocol === ImageProtocol.Kitty && attachment.mediaType !== "image/png") return caption(); // f=100 decodes PNG only
+  if (!dims) return caption(); // no protocol can size an image it can't measure
+
+  const cell = getCellPixelSize();
+  const fit = fitImageToCells(dims, opts.maxColumns, opts.maxRows, cell);
+  const seq =
+    protocol === ImageProtocol.Kitty
+      ? encodeKittyImage(attachment.data, fit)
+      : encodeIterm2Image(attachment.data, fit, opts.filename) + cursorUp(1); // cancel iTerm2's extra auto-advance row
+
+  const blankRows = Math.max(0, fit.rows - 1);
+  const lines = [...Array(blankRows).fill(""), cursorUp(blankRows) + seq];
+  return { lines, rendered: true };
+}

package/src/util/retry.ts

@@ -80,7 +80,18 @@ export function defaultRetryable(err: unknown): boolean {
     // OVERALL-deadline message ("stream exceeded the overall deadline") is a hard
     // wall-clock cap and is deliberately NOT matched here (it must fail fast).
     lowerMessage.includes("stream idle") ||
-    lowerMessage.includes("no chunk")
+    lowerMessage.includes("no chunk") ||
+    // A live TCP/TLS socket dying mid-request/mid-stream — Bun's fetch/undici
+    // ("The socket connection was closed unexpectedly …", the ConnectionClosed
+    // class) and Node's equivalent ("socket hang up", "other side closed",
+    // UND_ERR_SOCKET). Field case: OpenAI Codex OAuth SSE streams through
+    // chatgpt.com's backend die mid-stream after ~20-30min of active traffic
+    // (an infra-side connection-duration cap, not an idle timeout) — the
+    // request itself is fine, a fresh connection succeeds.
+    lowerMessage.includes("socket connection was closed") ||
+    lowerMessage.includes("socket hang up") ||
+    lowerMessage.includes("other side closed") ||
+    lowerMessage.includes("und_err_socket")
   ) {
     return true;
   }
@@ -284,3 +295,20 @@ export function isUsageLimitError(err: unknown): boolean {
 export function isRefusalError(err: unknown): boolean {
   return /stop_reason=refusal|finish_reason=content_filter|\(content_filter\)|(?:block|finish)Reason=(?:SAFETY|PROHIBITED_CONTENT|BLOCKLIST|RECITATION|SPII)|Refusal \(\w+\)/i.test(errorMessageOf(err));
 }
+/** True for a live TCP/TLS socket dying mid-request/mid-stream — Bun's fetch/undici
+ *  ("The socket connection was closed unexpectedly …", the ConnectionClosed class)
+ *  and Node's equivalent ("socket hang up", "other side closed", UND_ERR_SOCKET).
+ *  DELIBERATELY NARROWER than `defaultRetryable`: a rate-limit/5xx/timeout error has
+ *  already been through the model-manager's own `withRetry` budget (with visible
+ *  `onRetry` notices) by the time it reaches the engine, so re-retrying it there would
+ *  silently double the retry budget. A mid-stream socket drop is structurally
+ *  DIFFERENT — `retryableStream` (model-manager.ts) only auto-retries losing the FIRST
+ *  chunk; once any chunk has streamed it deliberately stops (a full re-call would
+ *  replay already-emitted content), so this class NEVER gets a model-manager retry at
+ *  all and needs its own engine-level recovery (see `transientNetworkRetries`). Field
+ *  case: OpenAI Codex OAuth SSE through chatgpt.com's backend dies mid-stream after
+ *  ~20-30min of active traffic (an infra connection-duration cap, not a broken network —
+ *  a fresh request succeeds). */
+export function isTransientStreamDropError(err: unknown): boolean {
+  return /socket connection was closed|socket hang up|other side closed|und_err_socket/i.test(errorMessageOf(err));
+}