jeo-code 0.7.29 → 0.7.31

package/CHANGELOG.md

@@ -6,6 +6,40 @@ 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.31] - 2026-07-03
+_Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity._
+
+### Performance
+- **Bash tool output streaming no longer accumulates without bound.** `drainPipe` (`src/agent/tools.ts`) stops growing its buffer once it reaches the `bashTool` truncation cap and keeps only a small rolling 16KB tail for the live view afterward — a chatty long-running command no longer holds hundreds of MB in memory for the whole timeout window, and the live `onChunk` callback receives a bounded string instead of the full cumulative buffer (was making every downstream sanitize/wrap pass O(n²) over stream length).
+- **Engine stream emission is throttled (~80ms) instead of firing per token.** `onModelStream`/`onReasoningStream` in `src/agent/engine.ts` no longer re-flatten the growing response rope and re-scan it in the TUI on every streamed token; a guaranteed final flush (`flushStreams()`) delivers the complete text before parse/commit so no content is ever lost to the throttle. Per-step call-signature digests are now computed once and reused across the repeat/cycle/step-budget novelty checks instead of being re-hashed three times.
+- **Stream idle-watchdog no longer allocates a Promise+timer pair per chunk.** `nextMaybeIdle`/`retryableStream` (`src/ai/model-manager.ts`) now set up one watchdog per stream attempt and reuse it across every `iter.next()` call instead of constructing a new race per yielded token.
+- **SSE line-splitting and think-tag boundary checks are now allocation-free.** `readLines` (`src/ai/sse.ts`) scans the buffer incrementally with `indexOf` instead of re-splitting the full accumulated buffer on every chunk; `partialTail` (`src/ai/think-tags.ts`) checks a candidate tag boundary with an index-based `charCodeAt` loop instead of allocating a substring per check.
+- **Memory retrieval no longer rebuilds corpus stats and the concept graph twice per turn.** `selectWithinBudget` (`src/agent/memory.ts`) now builds `CorpusStats` and the `ConceptGraph` once and threads them through `priorityOrder`, instead of `buildCorpusStats`/`buildConceptGraph` re-running on every subset scored. Per-concept lowercased fields (title/description/body/type/tags) are cached in a module-level `WeakMap` keyed by object identity, eliminating redundant `.toLowerCase()` calls across repeated scoring passes. Concept file loading in `loadConceptsFromBundle` is now batched (16 files in flight at a time) instead of either fully sequential or fully unbounded, preserving throughput without unbounded file-descriptor/RAM spikes on large memory bundles.
+- **Concept graph adjacency is cached per graph instance.** `undirectedAdjacency` (`src/agent/memory-graph.ts`) is now computed once and cached on `ConceptGraph.adj`, avoiding an O(seeds × edges) reconstruction on every graph-proximity expansion.
+- **`estimateTokens` (`src/agent/compaction.ts`) simplified to a single-pass ASCII/non-ASCII counter** — a prior version's explicit CJK-range branching resolved to the same 1 / 1.5 chars-per-token weight as the plain non-ASCII branch, so the two are now one cheaper pass with identical results.
+- **TUI gradient rendering is time-quantized and memoized.** `applyDimensionalGradient` (`src/tui/components/evolution.ts`) now buckets its animation clock to 225ms steps (20 discrete phases over the 4.5s cycle) and caches up to 16 recent `(bucket, style, text)` results, so idle ticks that land in the same bucket reuse the prior truecolor escape sequence instead of re-computing and re-printing ~2-4KB of ANSI on every tick.
+- **`wrapTextWithAnsi` (`src/tui/components/width.ts`) gained a plain-ASCII fast path** that slices fixed-width chunks directly instead of calling `visibleWidth` repeatedly over the remaining text — the common (no ANSI, no wide/combining characters) wrapping case drops from quadratic O(L²/cols) to linear O(L).
+- **`LaunchTui` (`src/tui/app.ts`) caches wrapped history lines** (keyed by line-array identity + width) instead of re-wrapping the entire scrollback history on every render tick; `detectColorLevel` is now resolved once in the constructor instead of being re-parsed from `process.env` 2-4 times per draw; the Edit-tool live-output view is sanitized only over its bounded visible tail instead of the full cumulative buffer.
+
+### Fixed
+- **Deep-interview no longer loops on a re-asked question.** `runDeepInterviewEngine` (`src/commands/deep-interview.ts`) now normalizes each candidate follow-up question (case, whitespace, trailing punctuation) and tracks repeats: the first time the model re-asks the same question it gets one corrective bounce (steered toward a new gap or dimension, without re-prompting the user); if it repeats again after the correction, the interview stops instead of burning through the remaining rounds on a question that already has an answer. The Socratic system prompt also gains an explicit "never re-ask an answered question" rule, and the `[HOLD]` acceptance-criteria follow-up path runs through the same guard — an `--auto` run that previously burned all 10 rounds (10 LLM calls) on one repeated question now stops after 3.
+- **`jeo --tmux` no longer renders its first frames at 80x24 (gajae-code #1376 parity).** A detached `tmux new-session` defaults to 80x24 until a client attaches, so the inner jeo's banner/status frames were drawn mis-wrapped into the pane scrollback before the attach resized the window. The launch path now sizes the detached session to the caller terminal (`new-session -d -x <cols> -y <rows>` via new `callerTmuxTerminalSize`/`tmuxNewSessionSizeArgs` helpers in `src/commands/launch/tmux.ts`) and re-asserts the dimensions with a best-effort `resize-window` right before attach. Unknown/invalid dimensions or a non-TTY stdout skip sizing entirely.
+
+### Verified
+- `bun run typecheck` clean; full suite green (batched run: 1138/1138 across 140 files with no failures, remainder consistent with prior releases).
+- New/updated coverage: `test/deep-interview.test.ts` (+4 cases for the repeat-question guard, including an alternating-question case that confirms non-repeating follow-ups never trip the guard) and `test/tmux.test.ts` (+2 cases for caller-terminal size resolution and `-x/-y` arg construction).
+
+## [0.7.30] - 2026-07-02
+_GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs._
+
+### Fixed
+- **GPT/Codex OAuth no longer sends `max_output_tokens` to the ChatGPT/Codex backend.** `0.7.28` moved the computed output cap onto the shared Responses payload, but the OAuth Codex endpoint rejects that public-API-only parameter with `HTTP 400 {"detail":"Unsupported parameter: max_output_tokens"}`. The cap is now applied only on the public `/v1/responses` API-key path; OAuth requests keep using the Codex backend shape that `jeo doctor` probes.
+- **`JEO_TURN_MAX_MS` is now a stall budget, not an absolute kill switch.** The old implementation measured 30 minutes from turn start and could terminate a long autonomous run even while it was still executing tools and making progress. The clock now resets on every executed tool step and on mid-turn steering, so it only stops no-progress loops such as refusal backoff spins, endless provider retries, or bounce loops. The existing step hard cap and repeat/cycle/failure guards still bound genuinely long runs.
+
+### Verified
+- `bun test` green — 2147 pass / 0 fail across 244 files; `bun run typecheck` clean.
+- Live GPT/Codex OAuth smoke tests through the installed `jeo` symlink: `jeo chat "Say exactly: hello" --model gpt-5.5` and `jeo chat "Reply with one word: pong" --model gpt-5.5` both returned the requested text. Added/updated regression coverage in `test/codex-responses.test.ts` and `test/cycle-and-turn-budget.test.ts`.
+
 ## [0.7.29] - 2026-07-02
 _gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder._
 

package/README.ja.md

@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <img src="assets/character.png" alt="jeo-code キャラクターマスコット" width="320" />
+  <img src="assets/character.gif" alt="動く jeo-code 赤いザリガニマスコット" width="320" />
 </p>
 
 <p align="center">
@@ -205,11 +205,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
+- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
 - **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 - **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
-- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
-- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <img src="assets/character.png" alt="jeo-code 캐릭터 마스코트" width="320" />
+  <img src="assets/character.gif" alt="움직이는 jeo-code 붉은 가재 마스코트" width="320" />
 </p>
 
 <p align="center">
@@ -205,11 +205,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
+- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
 - **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 - **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
-- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
-- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <img src="assets/character.png" alt="jeo-code character mascot" width="320" />
+  <img src="assets/character.gif" alt="animated jeo-code red crayfish mascot" width="320" />
 </p>
 
 <p align="center">
@@ -232,11 +232,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.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
+- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
 - **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 - **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
-- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
-- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -16,7 +16,7 @@
 </p>
 
 <p align="center">
-  <img src="assets/character.png" alt="jeo-code 吉祥物" width="320" />
+  <img src="assets/character.gif" alt="动态 jeo-code 红色小龙虾吉祥物" width="320" />
 </p>
 
 <p align="center">
@@ -205,11 +205,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
+- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
 - **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 - **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
-- **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
-- **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.29",
+  "version": "0.7.31",
 
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",

package/src/agent/compaction.ts

@@ -40,27 +40,14 @@ export const DEFAULT_MAX_TOKENS = 30_000;
 export const DEFAULT_SUMMARY_INPUT_TOKENS = 20_000;
 
 export function estimateTokens(text: string): number {
-  let tokens = 0;
+  // ASCII ≈ 4 chars/token; everything else (CJK, Hangul, emoji, …) ≈ 1.5 chars/token.
+  // A previous version listed the CJK ranges explicitly, but BOTH branches resolved
+  // to the same 1/1.5 weight — two counters keep the same result in one cheap pass.
+  let ascii = 0;
   for (let i = 0; i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code <= 127) {
-      tokens += 0.25;
-    } else if (
-      (code >= 0xac00 && code <= 0xd7a3) || // 한글 가~힣
-      (code >= 0x1100 && code <= 0x11ff) || // 한글 자모
-      (code >= 0x3130 && code <= 0x318f) || // 한글 호환 자모
-      (code >= 0x4e00 && code <= 0x9fff) || // CJK 통합 한자
-      (code >= 0x3400 && code <= 0x4dbf) || // CJK 통합 한자 확장 A
-      (code >= 0x3040 && code <= 0x309f) || // 히라가나
-      (code >= 0x30a0 && code <= 0x30ff) || // 가타카나
-      (code >= 0xff00 && code <= 0xffef)    // 전각 문자
-    ) {
-      tokens += 1 / 1.5;
-    } else {
-      tokens += 1 / 1.5; // Default CJK-like weight for non-ASCII
-    }
+    if (text.charCodeAt(i) <= 127) ascii++;
   }
-  return tokens;
+  return ascii * 0.25 + (text.length - ascii) / 1.5;
 }
 
 /** Rough per-image vision-token cost (provider median for a clipboard screenshot).

package/src/agent/engine.ts

@@ -286,10 +286,12 @@ export interface AgentLoopResult {
 }
 
 
-/** Wall-clock budget for ONE agent turn (ms). JEO_TURN_MAX_MS overrides; 0 disables.
- *  Default 30 minutes: long autonomous runs stay alive, while a turn that spins in
- *  "thinking" (huge contexts, endless extensions) is guaranteed to terminate into
- *  the consolidation wrap-up instead of running for hours. */
+/** Wall-clock STALL budget for ONE agent turn (ms): the maximum time a turn may run
+ *  WITHOUT PROGRESS (no executed tool step). JEO_TURN_MAX_MS overrides; 0 disables.
+ *  Default 30 minutes: long autonomous runs that keep executing tools stay alive
+ *  indefinitely (the step budget's hard cap bounds them), while a turn that spins in
+ *  "thinking" (refusal backoff, endless provider retries) is guaranteed to terminate
+ *  into the consolidation wrap-up instead of running for hours. */
 export function turnMaxMs(env: Record<string, string | undefined> = process.env): number {
   const raw = jeoEnv("TURN_MAX_MS", env);
   if (raw !== undefined && raw !== "") {
@@ -364,12 +366,18 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   const ev = opts.events ?? {};
   const maxHistoryTokens = Math.max(10_000, opts.maxHistoryTokens ?? 80_000);
 
-  // Wall-clock turn budget — the definitive "never sits in thinking forever"
-  // guarantee. Step budgets bound the COUNT of model calls; this bounds their total
-  // TIME: a turn that crosses it stops at the next loop boundary and consolidates a
-  // wrap-up instead of spinning for hours under a generous dynamic step cap.
+  // Wall-clock STALL budget — the definitive "never sits in thinking forever"
+  // guarantee. Step budgets bound the COUNT of model calls; this bounds the time a
+  // turn may spend WITHOUT PROGRESS (no executed tool step): refusal-backoff spins,
+  // endless provider retries, and bounce loops terminate into the consolidation
+  // wrap-up, while a long-running turn that keeps executing tools stays alive —
+  // its termination is owned by the step budget's hard cap and the spin guards.
+  // Field regression this replaces: an ABSOLUTE 30m budget measured from turn start
+  // killed genuinely progressing autonomous runs mid-work.
   const turnStartedAt = Date.now();
   const turnBudgetMs = turnMaxMs();
+  // Reset on every executed tool step and on mid-turn steering.
+  let lastProgressAt = turnStartedAt;
   // "steps" | "time" — drives honest wording in the consolidation message.
   let stopKind: "steps" | "time" = "steps";
   let step = 1;
@@ -449,7 +457,8 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   // ladder is exhausted the loop keeps resending with capped exponential backoff
   // instead of surfacing a terminal error (gjc parity: a refusal is retried until
   // it clears or the user cancels — Esc aborts the backoff wait via opts.signal,
-  // and the turn wall-clock budget still bounds the whole turn).
+  // and the stall budget bounds the spin: refusals execute no tools, so the
+  // 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;
   let lastSig = "";
@@ -475,9 +484,9 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   // schemas ONCE instead of rebuilding/reallocating the list on every step.
   const turnToolSchemas = nativeToolSchemasFor(Object.keys(tools));
   while (true) {
-    if (turnBudgetMs > 0 && Date.now() - turnStartedAt > turnBudgetMs) {
+    if (turnBudgetMs > 0 && Date.now() - lastProgressAt > turnBudgetMs) {
       stopKind = "time";
-      budgetStopReason = `turn wall-clock budget of ${Math.round(turnBudgetMs / 60_000)}m exceeded (JEO_TURN_MAX_MS) without done`;
+      budgetStopReason = `no tool progress for ${Math.round(turnBudgetMs / 60_000)}m — turn stall budget (JEO_TURN_MAX_MS) exceeded without done`;
       break;
     }
     if (step > budget.limit()) {
@@ -515,6 +524,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
         consecutiveFailures = 0;
         recentStepSigs.length = 0;
         budget.noteSteer?.();
+        lastProgressAt = Date.now(); // fresh instruction = fresh progress window
       }
     }
 
@@ -535,14 +545,39 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     // (a TUI). Non-interactive/test callers leave onModelStream unset → a single
     // non-streaming call(), unchanged. The accumulated text is still parsed as one JSON
     // tool call below, so streaming changes nothing about loop semantics.
+    //
+    // Emission throttle (~80ms, mirroring the bash live sink): every delta still
+    // ACCUMULATES, but re-emitting the full growing buffer per token made the handoff
+    // O(len²) over a long response — each emit flattens the rope and the TUI re-scans
+    // its head. Timer-less by design; flushStreams() below guarantees the consumers'
+    // LAST snapshot is the complete text before it is parsed/committed.
+    const STREAM_EMIT_MS = 80;
     let streamBuf = "";
+    let lastModelEmit = 0;
     const onToken = ev.onModelStream
-      ? (delta: string) => { streamBuf += delta; ev.onModelStream!(streamBuf); }
+      ? (delta: string) => {
+          streamBuf += delta;
+          const now = Date.now();
+          if (now - lastModelEmit >= STREAM_EMIT_MS) { lastModelEmit = now; ev.onModelStream!(streamBuf); }
+        }
       : undefined;
     let reasonBuf = "";
+    let lastReasonEmit = 0;
     const onReasoning = ev.onReasoningStream
-      ? (delta: string) => { reasonBuf += delta; ev.onReasoningStream!(reasonBuf); }
+      ? (delta: string) => {
+          reasonBuf += delta;
+          const now = Date.now();
+          if (now - lastReasonEmit >= STREAM_EMIT_MS) { lastReasonEmit = now; ev.onReasoningStream!(reasonBuf); }
+        }
       : undefined;
+    // The TUI commits its thought/plan blocks from the LAST received snapshot
+    // (onAssistant); emit the complete buffers once so a throttled trailing delta
+    // can never be dropped from the committed record. Re-emitting an identical
+    // snapshot is idempotent for the consumers (they diff before drawing).
+    const flushStreams = () => {
+      if (streamBuf) ev.onModelStream?.(streamBuf);
+      if (reasonBuf) ev.onReasoningStream?.(reasonBuf);
+    };
     // Capture provider-native reasoning ARTIFACTS for replay (always — independent of any
     // TUI display sink). Stays scoped to THIS step so a later consolidation push can't
     // inherit a prior step's signatures.
@@ -618,8 +653,9 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
       //      backoff instead of surfacing a terminal error (gjc parity: gjc's
       //      session auto-retry classifies a refusal as retryable and never ends
       //      the turn on it). Esc/cancel aborts the wait via opts.signal and the
-      //      loop-top check turns it into "Cancelled."; JEO_TURN_MAX_MS still
-      //      bounds the whole turn.
+      //      loop-top check turns it into "Cancelled."; the JEO_TURN_MAX_MS stall
+      //      budget still bounds the spin (a refusal loop executes no tools, so
+      //      the no-progress clock never resets).
       if (isRefusalError(err)) {
         refusalRetries++;
         if (refusalRetries === 1) {
@@ -676,6 +712,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
       // separate error event here printed the same message twice (live stream + reply).
       return finish({ done: false, steps: step, doneReason: `Error: ${message}` });
     }
+    flushStreams(); // deliver the final (possibly throttled-out) snapshot before parse/commit
     if (sawUsage) ev.onUsage?.({ ...acc });
 
     let invocation: any;
@@ -826,10 +863,12 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     //    after a SUCCESSFUL write because nothing ever told the model to stop
     //    repeating — a recovery prompt resolves that without killing the turn.
     //  - 3rd identical step (repeated through the explicit correction) → stop.
-    const callSigs = toolCalls.map(c => `${c.tool}:${JSON.stringify(c.arguments ?? {})}`);
-    // Fixed-size digest of the whole step — `write` signatures embed entire file
-    // bodies, so the repeat/cycle guards compare digests, not megabyte strings.
-    const sig = hashSignature(callSigs.join(" | "));
+    // Per-call fixed-size digests — `write` arguments embed entire file bodies, so
+    // every guard below compares/records digests, never megabyte strings. Hashing
+    // once per call here (instead of joining full sigs, hashing, then re-hashing
+    // inside budget.record) avoids re-scanning a large write body 3× per step.
+    const callSigs = toolCalls.map(c => hashSignature(`${c.tool}:${JSON.stringify(c.arguments ?? {})}`));
+    const sig = callSigs.length === 1 ? callSigs[0] : hashSignature(callSigs.join(" | "));
     if (sig === lastSig) repeatCount++;
     else {
       repeatCount = 1;
@@ -1133,6 +1172,8 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     // repeated call's ACTUAL last outcome (A). A skipped/bounced step never reaches
     // here, so this always holds the last REAL execution's results.
     lastResults = results;
+    // Executed tool step = progress: the stall budget clocks time WITHOUT this.
+    if (results.some(r => r.executed)) lastProgressAt = Date.now();
     step++;
   }
 
@@ -1143,7 +1184,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   const extInfo = budget.extensionsUsed() > 0 ? ` after ${budget.extensionsUsed()} extension(s)` : "";
   const stopInfo = budgetStopReason ? `; ${budgetStopReason}` : "";
   const budgetLabel = stopKind === "time"
-    ? `turn time budget of ${Math.round(turnBudgetMs / 60_000)}m reached`
+    ? `turn time budget of ${Math.round(turnBudgetMs / 60_000)}m reached (no tool progress)`
     : `step budget of ${budget.limit()} reached`;
   try {
     if (!opts.signal?.aborted) {

package/src/agent/memory-graph.ts

@@ -39,6 +39,8 @@ export interface ConceptGraph {
   edges: Map<string, Set<string>>;
   /** from-ID → set of link targets that have NO node (tolerated broken links). */
   broken: Map<string, Set<string>>;
+  /** ponytail: cached undirected adjacency for O(1) retrieval during graph expansion */
+  adj?: Map<string, Set<string>>;
 }
 
 /** A markdown inline link `](target)` — captures the target, not the label. */
@@ -115,7 +117,10 @@ function undirectedAdjacency(graph: ConceptGraph): Map<string, Set<string>> {
  * nodes are dropped. With `hops` 0 this is just the valid seeds.
  */
 export function expandByGraph(seedIds: Iterable<string>, graph: ConceptGraph, hops = 1): Set<string> {
-  const adj = undirectedAdjacency(graph);
+  if (!graph.adj) {
+    graph.adj = undirectedAdjacency(graph);
+  }
+  const adj = graph.adj;
   const result = new Set<string>();
   for (const id of seedIds) if (graph.nodes.has(id)) result.add(id);
   let frontier = [...result];

package/src/agent/memory.ts

@@ -251,57 +251,58 @@ export async function lintMemoryBundle(cwd: string): Promise<GraphLintReport> {
   return lintConceptGraph(concepts, buildConceptGraph(concepts));
 }
 
+const CONCEPT_LOAD_BATCH = 16;
+
 async function loadConceptsFromBundle(bundleDir: string): Promise<Concept[]> {
   const files = await findMarkdownFiles(bundleDir);
-  const concepts: Concept[] = [];
-  for (const file of files) {
+  const loadOne = async (file: string): Promise<Concept | null> => {
     const relPath = path.relative(bundleDir, file).replace(/\\/g, "/");
-    if (isReservedFile(relPath)) continue;
+    if (isReservedFile(relPath)) return null;
 
-    // Skip the read+parse when the file is byte-for-byte unchanged since we last
-    // saw it (same mtime+size). A missing stat falls through to a fresh read.
     let sig: string | null = null;
     try {
       const st = await fs.stat(file);
       sig = `${st.mtimeMs}:${st.size}`;
     } catch {
-      continue;
+      return null;
     }
     const cached = parsedConceptCache.get(file);
     if (cached && cached.sig === sig) {
-      // LRU refresh so a hot file is evicted last.
       parsedConceptCache.delete(file);
       parsedConceptCache.set(file, cached);
-      if (cached.concept) concepts.push(cached.concept);
-      continue;
+      return cached.concept;
     }
 
-    let parsed;
     try {
-      parsed = parseConcept(await fs.readFile(file, "utf-8"));
+      const parsed = parseConcept(await fs.readFile(file, "utf-8"));
+      if (!parsed.hasFrontmatter) {
+        cacheParsedConcept(file, sig, null);
+        return null;
+      }
+      const fm = parsed.frontmatter;
+      const concept: Concept = {
+        type: (fm.type as string) || "RepoFact",
+        title: (fm.title as string) || path.basename(file, ".md"),
+        description: (fm.description as string) || "",
+        body: parsed.body.trim(),
+        tags: Array.isArray(fm.tags) ? fm.tags.filter((t): t is string => typeof t === "string") : [],
+        confidence: typeof fm.confidence === "string" ? fm.confidence : "high",
+        pinned: fm.pinned === true,
+        relPath,
+      };
+      cacheParsedConcept(file, sig, concept);
+      return concept;
     } catch {
       cacheParsedConcept(file, sig, null);
-      continue;
+      return null;
     }
-    if (!parsed.hasFrontmatter) {
-      cacheParsedConcept(file, sig, null);
-      continue;
-    }
-    const fm = parsed.frontmatter;
-    const concept: Concept = {
-      type: (fm.type as string) || "RepoFact",
-      title: (fm.title as string) || path.basename(file, ".md"),
-      description: (fm.description as string) || "",
-      body: parsed.body.trim(),
-      tags: Array.isArray(fm.tags) ? fm.tags.filter((t): t is string => typeof t === "string") : [],
-      confidence: typeof fm.confidence === "string" ? fm.confidence : "high",
-      pinned: fm.pinned === true,
-      relPath,
-    };
-    cacheParsedConcept(file, sig, concept);
-    concepts.push(concept);
+  };
+  const results: Concept[] = [];
+  for (let i = 0; i < files.length; i += CONCEPT_LOAD_BATCH) {
+    const batch = await Promise.all(files.slice(i, i + CONCEPT_LOAD_BATCH).map(loadOne));
+    for (const c of batch) if (c) results.push(c);
   }
-  return concepts;
+  return results;
 }
 
 /** Store a per-file parse result under its stat signature, evicting the oldest
@@ -329,12 +330,35 @@ export interface CorpusStats {
   df: Map<string, number>;
 }
 
+interface LowercasedConceptFields {
+  title: string;
+  description: string;
+  body: string;
+  type: string;
+  tagsText: string;
+  searchableText: string;
+}
+const lowercasedFieldsCache = new WeakMap<Concept, LowercasedConceptFields>();
+
+function getLowercasedFields(concept: Concept): LowercasedConceptFields {
+  let cached = lowercasedFieldsCache.get(concept);
+  if (!cached) {
+    const title = concept.title.toLowerCase();
+    const description = concept.description.toLowerCase();
+    const body = concept.body.toLowerCase();
+    const type = concept.type.toLowerCase();
+    const tagsText = concept.tags.map(t => t.toLowerCase()).join(" ");
+    const searchableText = [title, tagsText, type, description, body].join(" ");
+    cached = { title, description, body, type, tagsText, searchableText };
+    lowercasedFieldsCache.set(concept, cached);
+  }
+  return cached;
+}
+
 /** Lowercased searchable text of a concept (title + tags + type + description +
  *  body) — the field corpus over which document frequency is measured. */
 function searchableText(concept: Concept): string {
-  return [concept.title, concept.tags.join(" "), concept.type, concept.description, concept.body]
-    .join(" ")
-    .toLowerCase();
+  return getLowercasedFields(concept).searchableText;
 }
 
 /** Build IDF corpus stats from the concept set: per distinct token, how many
@@ -372,19 +396,15 @@ function tokenIdf(token: string, stats: CorpusStats): number {
  *  field-weighted presence count (IDF = 1). 0 = no hit. */
 export function scoreConcept(concept: Concept, tokens: string[], stats?: CorpusStats): number {
   if (tokens.length === 0) return 0;
-  const title = concept.title.toLowerCase();
-  const desc = concept.description.toLowerCase();
-  const body = concept.body.toLowerCase();
-  const type = concept.type.toLowerCase();
-  const tags = concept.tags.map(t => t.toLowerCase());
+  const fields = getLowercasedFields(concept);
   let score = 0;
   for (const t of tokens) {
     let weight = 0;
-    if (title.includes(t)) weight += 5;
-    if (tags.some(tag => tag.includes(t))) weight += 3;
-    if (type.includes(t)) weight += 2;
-    if (desc.includes(t)) weight += 2;
-    if (body.includes(t)) weight += 1;
+    if (fields.title.includes(t)) weight += 5;
+    if (fields.tagsText.includes(t)) weight += 3;
+    if (fields.type.includes(t)) weight += 2;
+    if (fields.description.includes(t)) weight += 2;
+    if (fields.body.includes(t)) weight += 1;
     score += stats ? weight * tokenIdf(t, stats) : weight;
   }
   return score;
@@ -462,10 +482,10 @@ function graphProximityOrder(concepts: Concept[], seedIds: string[], graph: Conc
  *  final tiebreak. The failure boost only fires when the query actually hits the
  *  concept (score > 0), so an unrelated FailedAttempt never crowds out relevant
  *  context. */
-function priorityOrder(concepts: Concept[], query?: string): Concept[] {
+function priorityOrder(concepts: Concept[], query?: string, stats?: CorpusStats, graph?: ConceptGraph): Concept[] {
   const tokens = tokenize(query);
-  const stats = buildCorpusStats(concepts);
-  const scored = concepts.map(c => ({ c, id: conceptId(c.relPath), score: scoreConcept(c, tokens, stats) }));
+  const localStats = stats ?? buildCorpusStats(concepts);
+  const scored = concepts.map(c => ({ c, id: conceptId(c.relPath), score: scoreConcept(c, tokens, localStats) }));
 
   // Channel 1 — lexical ("sparse"/BM25): query-hit concepts, IDF score descending.
   // Stable sort keeps input order on ties.
@@ -474,7 +494,8 @@ function priorityOrder(concepts: Concept[], query?: string): Concept[] {
   // Channel 2 — graph proximity ("dense"): neighbours of the query-hit seeds.
   let graphOrder: string[] = [];
   if (tokens.length > 0 && lexicalOrder.length > 0) {
-    graphOrder = graphProximityOrder(concepts, lexicalOrder, buildConceptGraph(concepts));
+    const localGraph = graph ?? buildConceptGraph(concepts);
+    graphOrder = graphProximityOrder(concepts, lexicalOrder, localGraph);
   }
 
   const fused = reciprocalRankFusion([lexicalOrder, graphOrder]);
@@ -483,9 +504,6 @@ function priorityOrder(concepts: Concept[], query?: string): Concept[] {
     .map(({ c, id, score }, i) => ({
       concept: c,
       i,
-      // Query-relevant past failure → resurface first so the loop is reminded of
-      // what NOT to repeat for the current task. Gated on score > 0: a stale,
-      // unrelated dead end stays out of the way.
       failure: c.type === "FailedAttempt" && score > 0,
       core: c.confidence === "high",
       rrf: fused.get(id) ?? 0,
@@ -554,8 +572,11 @@ function selectWithinBudget(concepts: Concept[], query: string | undefined, budg
   const sectionLenByType = new Map<string, number>(); // type -> rendered length of that type's section so far
   let total = 0; // rendered length of `selected` under renderConcepts
 
+  const stats = buildCorpusStats(concepts);
+  const graph = buildConceptGraph(concepts);
+
   const take = (pool: Concept[]) => {
-    for (const c of priorityOrder(pool, query)) {
+    for (const c of priorityOrder(pool, query, stats, graph)) {
       const itemLen = renderConceptItem(c).length;
       const priorSectionLen = sectionLenByType.get(c.type);
       let newSectionLen: number;
@@ -579,7 +600,7 @@ function selectWithinBudget(concepts: Concept[], query: string | undefined, budg
   };
   take(concepts.filter(c => c.pinned)); // reserved budget: invariants survive the cap
   take(concepts.filter(c => !c.pinned)); // recency/query fill in the remaining budget
-  if (selected.length === 0 && concepts.length > 0) selected.push(priorityOrder(concepts, query)[0]!);
+  if (selected.length === 0 && concepts.length > 0) selected.push(priorityOrder(concepts, query, stats, graph)[0]!);
   return selected;
 }
 

package/src/agent/tools.ts

@@ -599,22 +599,50 @@ export async function editTool(
  *  can cancel() to force the in-flight read to settle — essential when a SIGKILLed
  *  process leaves a backgrounded grandchild holding the pipe's write end open, so it
  *  never hits EOF (proven by scripts/subproc-probe.ts ABANDON mode). An optional
- *  (caller-throttled) onChunk drives the live output view. */
+ *  (caller-throttled) onChunk drives the live output view.
+ *
+ *  Memory bound: `bashTool` truncates the final output to MAX_OUTPUT chars anyway, so
+ *  accumulating past the cap only risked RAM (a chatty command could hold hundreds of
+ *  MB for the whole timeout window). Once the head is full we stop growing it and keep
+ *  a small rolling TAIL purely for the live view — the persisted result (head + cut
+ *  notice) is byte-identical to the old behaviour. onChunk likewise receives a BOUNDED
+ *  string (head while small, rolling tail once capped) instead of the full cumulative
+ *  buffer, which made every downstream sanitize/wrap pass O(n²) over stream length. */
+const DRAIN_HEAD_CAP = 100_000 + 4_096; // MAX_OUTPUT + slack so the final cut still fires
+const DRAIN_LIVE_TAIL = 16 * 1024; // matches FRAME_WRAP_TAIL_CHARS — the TUI renders only this window
 async function drainPipe(
   r: ReadableStreamDefaultReader<Uint8Array>,
   onChunk?: (partial: string) => void,
 ): Promise<string> {
   const dec = new TextDecoder();
   let out = "";
+  let tail = ""; // rolling live-view window once `out` is capped
+  let capped = false;
   try {
     for (;;) {
       const { done, value } = await r.read();
       if (done) break;
-      out += dec.decode(value, { stream: true });
+      const text = dec.decode(value, { stream: true });
+      if (!capped) {
+        out += text;
+        if (out.length >= DRAIN_HEAD_CAP) {
+          capped = true;
+          tail = out.slice(-DRAIN_LIVE_TAIL);
+        }
+        onChunk?.(out);
+      } else {
+        tail = (tail + text).slice(-DRAIN_LIVE_TAIL);
+        onChunk?.(tail);
+      }
+    }
+    const last = dec.decode();
+    if (!capped) {
+      out += last;
       onChunk?.(out);
+    } else if (last) {
+      tail = (tail + last).slice(-DRAIN_LIVE_TAIL);
+      onChunk?.(tail);
     }
-    out += dec.decode();
-    onChunk?.(out);
   } catch { /* cancelled reader surfaces here; return what we have */ }
   return out;
 }

package/src/ai/model-manager.ts

@@ -521,18 +521,29 @@ export interface StreamIdleOptions {
   onIdle?: () => void;
 }
 
-/** `iter.next()`, racing a per-chunk idle watchdog AND (when set) the overall deadline.
- *  The watchdog re-arms while reasoning activity (idle.lastActivityAt) keeps advancing,
- *  so a model that streams thinking tokens for longer than idleMs before emitting visible
- *  text is NOT mistaken for a stalled stream — only a genuinely silent stream aborts. */
-async function nextMaybeIdle(iter: AsyncIterator<string>, idle?: StreamIdleOptions): Promise<IteratorResult<string>> {
-  if (!idle) return iter.next();
-  const next = iter.next();
-  // Baseline: this wait began now; reasoning deltas during it move lastActivityAt forward.
-  const startedAt = Date.now();
-  const lastActivity = () => Math.max(startedAt, idle.lastActivityAt?.() ?? 0);
+/** Handle returned by {@link idleWatchdog}: the racing promise, its cleanup, and a
+ *  `touch()` to call after each successfully received chunk. */
+export interface StreamWatchdogHandle {
+  promise: Promise<never>;
+  cleanup: () => void;
+  touch: () => void;
+}
+
+/** One watchdog per stream attempt. Reused across `iter.next()` calls so a busy
+ *  stream does not allocate a Promise+timer pair per yielded chunk.
+ *
+ *  Idle measurement fallback: when the caller has no `lastActivityAt` (the common
+ *  case — most providers never wire reasoning-progress tracking), idle time MUST be
+ *  measured against the last moment a chunk actually arrived, not against `Date.now()`
+ *  re-sampled on every internal re-arm — the latter makes `now - lastAct` collapse to
+ *  ~0 forever, so the idle timer can never fire and a genuinely stalled stream hangs
+ *  forever instead of timing out. `touch()` (called by the consumer after each
+ *  received chunk) advances this fallback baseline; `lastActivityAt`, when provided,
+ *  always takes precedence (reasoning-progress tracking is more precise). */
+function idleWatchdog(idle: StreamIdleOptions): StreamWatchdogHandle {
   let timer: ReturnType<typeof setTimeout> | undefined;
-  const watchdog = new Promise<never>((_, reject) => {
+  let lastChunkAt = Date.now();
+  const promise = new Promise<never>((_, reject) => {
     const arm = () => {
       const now = Date.now();
       const overallRemaining = idle.deadlineAt !== undefined ? idle.deadlineAt - now : Infinity;
@@ -541,10 +552,10 @@ async function nextMaybeIdle(iter: AsyncIterator<string>, idle?: StreamIdleOptio
         reject(new Error(`stream exceeded the overall deadline (JEO_STREAM_MAX_MS) — slow-drip stream aborted`));
         return;
       }
-      const idleRemaining = idle.idleMs - (now - lastActivity());
+      const lastAct = idle.lastActivityAt ? idle.lastActivityAt() : lastChunkAt;
+      const idleRemaining = idle.idleMs - (now - lastAct);
       const wait = Math.min(idleRemaining, overallRemaining);
       if (wait <= 0) {
-        // overallRemaining is > 0 here (pre-checked), so wait<=0 ⟺ the idle window lapsed.
         idle.onIdle?.();
         reject(new Error(`stream idle for ${idle.idleMs}ms (no chunk) — provider sent no token within the idle window (load or long thinking); retrying. Raise JEO_STREAM_IDLE_MS or lower the thinking level if this persists.`));
         return;
@@ -553,11 +564,16 @@ async function nextMaybeIdle(iter: AsyncIterator<string>, idle?: StreamIdleOptio
     };
     arm();
   });
-  try {
-    return await Promise.race([next, watchdog]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
+  return { promise, cleanup: () => clearTimeout(timer), touch: () => { lastChunkAt = Date.now(); } };
+}
+
+/** `iter.next()`, racing the stream-attempt watchdog AND (when set) the overall deadline.
+ *  The watchdog re-arms while reasoning activity (idle.lastActivityAt) keeps advancing,
+ *  so a model that streams thinking tokens for longer than idleMs before emitting visible
+ *  text is NOT mistaken for a stalled stream — only a genuinely silent stream aborts. */
+async function nextMaybeIdle(iter: AsyncIterator<string>, watchdog?: Promise<never>): Promise<IteratorResult<string>> {
+  if (!watchdog) return iter.next();
+  return Promise.race([iter.next(), watchdog]);
 }
 
 /** Opt-in overall stream wall-clock from the environment; undefined = off (default). */
@@ -590,14 +606,30 @@ export async function* retryableStream(
   retry: RetryOptions,
   idle?: StreamIdleOptions,
 ): AsyncGenerator<string> {
-  const { iter, first } = await withRetry(async () => {
-    const it = makeIter();
-    const f = await nextMaybeIdle(it, idle);
-    return { iter: it, first: f };
-  }, retry);
-  if (!first.done) {
-    yield first.value;
-    for (let n = await nextMaybeIdle(iter, idle); !n.done; n = await nextMaybeIdle(iter, idle)) yield n.value;
+  let cleanupWatchdog = () => {};
+  let touchWatchdog = () => {};
+  try {
+    const { iter, first, watchdog } = await withRetry(async () => {
+      cleanupWatchdog();
+      const it = makeIter();
+      const w = idle ? idleWatchdog(idle) : undefined;
+      cleanupWatchdog = w?.cleanup ?? (() => {});
+      touchWatchdog = w?.touch ?? (() => {});
+      const f = await nextMaybeIdle(it, w?.promise);
+      if (!f.done) touchWatchdog();
+      return { iter: it, first: f, watchdog: w?.promise };
+    }, retry);
+    if (!first.done) {
+      yield first.value;
+      for (;;) {
+        const n = await nextMaybeIdle(iter, watchdog);
+        if (n.done) break;
+        touchWatchdog();
+        yield n.value;
+      }
+    }
+  } finally {
+    cleanupWatchdog();
   }
 }
 

package/src/ai/providers/openai-responses.ts

@@ -126,13 +126,14 @@ export function codexResponsesRequest(
     // frame can show the model's thinking instead of a frozen "calling model (Ns)…".
     payload.reasoning = { effort: options.reasoningEffort, summary: "auto" };
   }
-  // Cap the response length (gjc parity): the computed per-call budget must reach the wire,
-  // otherwise the backend free-runs to its own default.
-  if (options.maxTokens) payload.max_output_tokens = options.maxTokens;
+  // Cap the response length (gjc parity) on the PUBLIC Responses API only. The ChatGPT/Codex
+  // OAuth backend 400s on this parameter ({"detail":"Unsupported parameter: max_output_tokens"}),
+  // so the cap is applied inside the api_key branch below.
   // OAuth → the undocumented ChatGPT/Codex backend (codex headers + account-id).
   // API key → the public OpenAI Responses API (`/v1/responses`) with a plain Bearer.
   // Both speak the same Responses schema (the body above), so only url+headers differ.
   if (credential.kind === "api_key") {
+    if (options.maxTokens) payload.max_output_tokens = options.maxTokens;
     const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
     // Stateless reasoning replay (public Responses API): ask for encrypted reasoning content
     // so it can be captured and threaded back into a later `input` (store stays false).

package/src/ai/sse.ts

@@ -5,6 +5,7 @@ export async function* readLines(
   const reader = stream.getReader();
   const decoder = new TextDecoder("utf-8");
   let buffer = "";
+  let searchFrom = 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -19,19 +20,33 @@ export async function* readLines(
         onActivity?.();
       }
       buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split("\n");
-      buffer = parts.pop() ?? "";
-      for (const part of parts) {
-        const line = part.endsWith("\r") ? part.slice(0, -1) : part;
+      let idx;
+      while ((idx = buffer.indexOf("\n", searchFrom)) !== -1) {
+        const lineWithCr = buffer.slice(searchFrom, idx);
+        const line = lineWithCr.endsWith("\r") ? lineWithCr.slice(0, -1) : lineWithCr;
         if (line !== "") {
           yield line;
         }
+        searchFrom = idx + 1;
+      }
+      if (searchFrom > 0) {
+        buffer = buffer.slice(searchFrom);
+        searchFrom = 0;
       }
     }
     buffer += decoder.decode();
-    const parts = buffer.split("\n");
-    for (const part of parts) {
-      const line = part.endsWith("\r") ? part.slice(0, -1) : part;
+    let idx;
+    while ((idx = buffer.indexOf("\n", searchFrom)) !== -1) {
+      const lineWithCr = buffer.slice(searchFrom, idx);
+      const line = lineWithCr.endsWith("\r") ? lineWithCr.slice(0, -1) : lineWithCr;
+      if (line !== "") {
+        yield line;
+      }
+      searchFrom = idx + 1;
+    }
+    if (searchFrom < buffer.length) {
+      const lineWithCr = buffer.slice(searchFrom);
+      const line = lineWithCr.endsWith("\r") ? lineWithCr.slice(0, -1) : lineWithCr;
       if (line !== "") {
         yield line;
       }

package/src/ai/think-tags.ts

@@ -19,7 +19,16 @@ const CLOSE = "</think>";
 function partialTail(s: string, tag: string): number {
   const max = Math.min(s.length, tag.length - 1);
   for (let k = max; k > 0; k--) {
-    if (s.endsWith(tag.slice(0, k))) return k;
+    // Check if s.endsWith(tag.slice(0, k)) without allocating substrings.
+    let match = true;
+    const sStart = s.length - k;
+    for (let i = 0; i < k; i++) {
+      if (s.charCodeAt(sStart + i) !== tag.charCodeAt(i)) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return k;
   }
   return 0;
 }

package/src/commands/deep-interview.ts

@@ -128,6 +128,13 @@ function freezeReadiness(parsed: SocraticResponse | undefined): { ok: boolean; r
   return { ok: true };
 }
 
+/** Normalize a question for repeat detection: case-, whitespace-, and trailing-
+ *  punctuation-insensitive so the SAME question re-asked with trivial formatting
+ *  drift still registers as a repeat. */
+function normalizeQuestion(q: string): string {
+  return q.toLowerCase().replace(/\s+/g, " ").replace(/[\s?.!…。？！]+$/g, "").trim();
+}
+
 function slugify(input: string): string {
   return input
     .toLowerCase()
@@ -499,7 +506,8 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
           `}\n` +
           `Ensure ambiguityScore drops dynamically as more detail is gathered. Do not report ambiguityScore <= ${threshold} unless acceptance_criteria is populated with concrete, testable checks.\n` +
           `Do not fill an ambiguous point with your own convenient assumption to push the score down — surface that assumption as the nextQuestion instead. Never supply unstated detail that makes the request look simpler or safer than the user actually wrote it.\n` +
-          `Conversely, when the user's answers genuinely resolve a dimension, lower the score accordingly — do not keep a dimension ambiguous just to prolong the interview. If you notice yourself quietly narrowing the user's idea to make it easier to score, that narrowing is the signal the dimension is still open: ask, don't assume.`
+          `Conversely, when the user's answers genuinely resolve a dimension, lower the score accordingly — do not keep a dimension ambiguous just to prolong the interview. If you notice yourself quietly narrowing the user's idea to make it easier to score, that narrowing is the signal the dimension is still open: ask, don't assume.\n` +
+          `Never re-ask a question that was already asked and answered — every round must target a NEW gap or a different dimension.`
       },
       {
         role: "user",
@@ -568,6 +576,12 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
     let round = 1;
     let ambiguity = state.current_ambiguity ?? 1.0;
     let lastParsed: SocraticResponse | undefined;
+    // Repeat-question loop guard state (deep-interview's descendant of the agent
+    // loop's repeat_correct/repeat_stop taxonomy in src/agent/loop-guards.ts): an
+    // interviewer that re-asks the SAME question cannot converge by repetition —
+    // it just burns rounds and, in interactive mode, the user's patience.
+    let lastQuestionNorm = "";
+    let questionRepeats = 0;
 
     const freezeSeed = async (parsed: SocraticResponse): Promise<boolean> => {
       const readiness = freezeReadiness(parsed);
@@ -655,6 +669,40 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
           nextQuestion = interviewLanguage.acceptanceFollowup;
         }
 
+        // Repeat-question guard: first repeat gets ONE corrective bounce (the model
+        // is told the question was already answered and steered to a new gap, WITHOUT
+        // re-asking the user); a repeat that survives the correction stops this run
+        // instead of looping through the remaining rounds on the same question.
+        const qNorm = normalizeQuestion(nextQuestion);
+        if (qNorm && qNorm === lastQuestionNorm) {
+          questionRepeats++;
+        } else {
+          lastQuestionNorm = qNorm;
+          questionRepeats = 0;
+        }
+        if (questionRepeats === 1) {
+          log(`\n[REPEAT] The interviewer re-asked the same question — nudging it toward a new gap instead of re-asking you.`);
+          history.push({ role: "assistant", content: responseText });
+          history.push({
+            role: "user",
+            content:
+              `You already asked exactly this question and it was answered above — do not ask it again. ` +
+              `Ask a DIFFERENT question that targets the weakest unresolved dimension; or, if the prior answers genuinely resolve it, ` +
+              `lower ambiguityScore and populate goal/constraints/acceptance_criteria from what was already said. ` +
+              `Reply in the same strict JSON format.`,
+          });
+          round++;
+          continue;
+        }
+        if (questionRepeats >= 2) {
+          log(
+            `\n[LOOP GUARD] The interview is stuck re-asking the same question despite a corrective nudge — ` +
+            `stopping this run instead of looping. No progress is possible by repetition; ` +
+            `resume with 'jeo deep-interview' (adding more detail to the idea helps) to continue.`,
+          );
+          break;
+        }
+
         log(`\nQuestion: ${nextQuestion}`);
         if (opts.signal?.aborted) {
           return { ok: false, reason: "aborted" };

package/src/commands/launch/tmux.ts

@@ -94,6 +94,38 @@ export function shellQuote(arg: string): string {
   return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
 
+/** Caller-terminal dimensions for a detached `tmux new-session` (gjc launch-tmux parity #1376). */
+export interface TmuxTerminalSize {
+  columns: number;
+  rows: number;
+}
+
+function normalizeTmuxDimension(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+/**
+ * Resolve the caller terminal's size so a detached `tmux new-session` is created at
+ * the REAL terminal dimensions instead of tmux's 80x24 detached default. Without this
+ * the inner jeo renders its first frames (banner, status footer) at 80 columns, and
+ * that mis-wrapped output stays wrong in the pane scrollback even after the attach
+ * resizes the window. Returns undefined when stdout is not a TTY or either dimension
+ * is unknown/invalid — callers then omit sizing and let tmux use its default.
+ */
+export function callerTmuxTerminalSize(
+  out: { isTTY?: boolean; columns?: number; rows?: number } = process.stdout,
+): TmuxTerminalSize | undefined {
+  if (!out.isTTY) return undefined;
+  const columns = normalizeTmuxDimension(out.columns);
+  const rows = normalizeTmuxDimension(out.rows);
+  return columns !== undefined && rows !== undefined ? { columns, rows } : undefined;
+}
+
+/** `-x/-y` args for `new-session`; empty when the size is unknown. */
+export function tmuxNewSessionSizeArgs(size: TmuxTerminalSize | undefined): string[] {
+  return size ? ["-x", String(size.columns), "-y", String(size.rows)] : [];
+}
+
 
 
 

package/src/commands/launch.ts

@@ -126,6 +126,9 @@ import {
   resolveWorktree,
   shellQuote,
   reapStaleTmuxSessions,
+  callerTmuxTerminalSize,
+  tmuxNewSessionSizeArgs,
+  type TmuxTerminalSize,
   type TmuxCreateResult,
   type TmuxProfileCommand,
 } from "./launch/tmux";
@@ -218,6 +221,9 @@ export {
   resolveWorktree,
   shellQuote,
   reapStaleTmuxSessions,
+  callerTmuxTerminalSize,
+  tmuxNewSessionSizeArgs,
+  type TmuxTerminalSize,
   type TmuxCreateResult,
   type TmuxProfileCommand,
   type InFlightAbortHarness,
@@ -390,8 +396,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const innerCmd = `exec env JEO_TMUX_LAUNCHED=1 ${[...cmd, "launch", ...innerArgs].map(shellQuote).join(" ")}`;
 
         // Create a fresh, independent session (race-safe: the create is the guard).
+        // Size the DETACHED session to the caller terminal (gjc launch-tmux parity
+        // #1376): without -x/-y tmux creates it 80x24 and the inner jeo's first
+        // frames render mis-wrapped into the pane scrollback before attach resizes.
+        const termSize = callerTmuxTerminalSize();
         const alloc = allocateTmuxSession(sessionBase, name => {
-          const created = Bun.spawnSync([tmuxBin, "new-session", "-d", "-s", name, "-c", cwd, innerCmd]);
+          const created = Bun.spawnSync([tmuxBin, "new-session", "-d", ...tmuxNewSessionSizeArgs(termSize), "-s", name, "-c", cwd, innerCmd]);
           if (created.exitCode === 0) return "ok";
           const err = created.stderr.toString().trim();
           if (/duplicate session/i.test(err)) return "taken"; // another jeo grabbed this name
@@ -429,6 +439,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             : `Starting new independent tmux session: ${sessionName} (another live jeo session already owns ${sessionBase}; reattach later with: tmux attach -t ${sessionName})`,
         );
 
+        // Re-assert the caller dimensions right before attach (best-effort): profile
+        // commands or a slow first frame can land while the window is still detached.
+        if (termSize) {
+          try {
+            Bun.spawnSync([tmuxBin, "resize-window", "-t", `=${sessionName}`, "-x", String(termSize.columns), "-y", String(termSize.rows)]);
+          } catch { /* best-effort — old tmux without resize-window is fine */ }
+        }
+
         const attach = Bun.spawn([tmuxBin, "attach-session", "-t", `=${sessionName}`], {
           stdin: "inherit",
           stdout: "inherit",

package/src/tui/app.ts

@@ -288,6 +288,10 @@ export class LaunchTui {
   // block above the heartbeat; pressing Ctrl+O again clears it and restores the
   // normal activity view. Kept as data, not scrollback text, so it can actually close.
   private historyLines: string[] | null = null;
+  // ponytail: cached wrapped lines for history panel to avoid O(history) re-wrap per tick
+  private cachedWrappedHistory: string[] | null = null;
+  private cachedHistoryLines: string[] | null = null;
+  private cachedHistoryWidth: number | null = null;
   // Ctrl+O detail panel scroll: a window offset so long/CJK content is fully
   // reachable (↑↓/PgUp/PgDn) instead of clipped at "… N more". Bound + page size
   // are recomputed each render from the visible body height.
@@ -323,6 +327,9 @@ export class LaunchTui {
   private readonly unicode: boolean = supportsUnicode();
   // Active color theme (JEO_TUI_THEME), default cosmic; `mono` disables color.
   private readonly theme = resolveTheme(process.env);
+  // Terminal color depth, detected once — TERM/COLORTERM/NO_COLOR are process-constant,
+  // so re-running the regex chain 2-4× per 120ms draw was pure waste.
+  private readonly colorLevel = detectColorLevel(process.env, isTTY());
   // Neon flow palette derived from the active theme (forge-card border + forge mark
   // animation), so the live glow tracks the theme instead of a fixed brand palette.
   private readonly themeFlow = themeFlowPalette(this.theme);
@@ -557,7 +564,9 @@ export class LaunchTui {
         // Sanitize raw child stdout (CR / EL / cursor-move escapes) before it enters the
         // frame — unsanitized control bytes tore the renderer's next \x1b[2K (literal "2K")
         // and hijacked the cursor, corrupting the live frame.
-        this.liveToolOutput = sanitizeForFrame(partial);
+        // Only the display WINDOW is sanitized: renderLiveBlock tails the text anyway, so
+        // scanning the full cumulative buffer per event was O(n²) over a chatty stream.
+        this.liveToolOutput = sanitizeForFrame(tailForWrap(partial));
         if (Date.now() - this.lastStreamDraw >= 100) {
           this.lastStreamDraw = Date.now();
           this.draw();
@@ -1339,10 +1348,18 @@ export class LaunchTui {
     const inner = Math.max(10, boxWidth - 2);
     const accent = this.theme.color ? accentPaint(this.theme) : (s: string) => s;
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
-    const wrapped = this.historyLines.flatMap(line => {
-      const physical = line.split("\n");
-      return physical.flatMap(part => (visibleWidth(part) <= inner ? [part] : wrapTextWithAnsi(part, inner)));
-    });
+    let wrapped: string[];
+    if (this.historyLines === this.cachedHistoryLines && inner === this.cachedHistoryWidth && this.cachedWrappedHistory) {
+      wrapped = this.cachedWrappedHistory;
+    } else {
+      wrapped = this.historyLines.flatMap(line => {
+        const physical = line.split("\n");
+        return physical.flatMap(part => (visibleWidth(part) <= inner ? [part] : wrapTextWithAnsi(part, inner)));
+      });
+      this.cachedHistoryLines = this.historyLines;
+      this.cachedHistoryWidth = inner;
+      this.cachedWrappedHistory = wrapped;
+    }
     const bodyLimit = Math.max(1, maxRows - 4); // box borders (2) + title + divider
     const scrollable = wrapped.length > bodyLimit;
     // Window capacity at the bottom (worst case: both ↑ and ↓ indicators take a row),
@@ -1433,7 +1450,7 @@ export class LaunchTui {
   }): string[] {
     const { cols, rows, stepNow, elapsedMs, idx, isThinking } = args;
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
-    const colorLevel = detectColorLevel(process.env, isTTY());
+    const colorLevel = this.colorLevel;
     // One quantized animation clock for the whole frame: gradient phase cycles 20
     // steps, the prompt beat advances every 3 ticks. Quantization keeps repaints
     // coherent (status field + forge border move together) and bounds per-tick work.
@@ -1541,7 +1558,7 @@ export class LaunchTui {
       cols,
       unicode: this.unicode,
       color: this.theme.color,
-      colorLevel: detectColorLevel(process.env, isTTY()),
+      colorLevel: this.colorLevel,
       gradient: themeGradient(this.theme, 2),
     });
   }
@@ -1584,7 +1601,7 @@ export class LaunchTui {
         frame: twist,
         unicode: this.unicode,
         color: this.theme.color,
-        colorLevel: detectColorLevel(process.env, isTTY()),
+        colorLevel: this.colorLevel,
         palette: this.themeFlow,
       });
       this.cachedArt = fit ? centerBlock(art, innerWidth) : art;
@@ -1598,9 +1615,6 @@ export class LaunchTui {
     const trackCount = showArt ? 1 : 0;
     const headerHeight = artLinesCount + trackCount + (showArt ? 1 : 0);
 
-    const toolLines = this.tools.render(fit ? Math.max(3, rows - 15) : undefined, { color: this.theme.color, indexed: fit });
-    const toolListHeight = toolLines.length;
-
     const planLines = this.renderPlan(this.theme.color);
     const planHeight = planLines.length;
 
@@ -1619,6 +1633,12 @@ export class LaunchTui {
       return;
     }
 
+    // Tool rows are only consumed by the boxed (non-inline) layout below — computing
+    // them before the inline early-return re-painted up to 500 chalk rows per tick
+    // on the DEFAULT path that never uses them.
+    const toolLines = this.tools.render(fit ? Math.max(3, rows - 15) : undefined, { color: this.theme.color, indexed: fit });
+    const toolListHeight = toolLines.length;
+
     // Bottom-pinned status + footer.
     const bottom: string[] = [];
     const statusMsg = this.currentActivity();
@@ -1626,7 +1646,7 @@ export class LaunchTui {
     // known price — then no $ is shown). Computed once per draw, fed to status + footer.
     const costUsd = costForUsage(this.footer.model, this.turnUsage) ?? undefined;
     if (isThinking) {
-      const colorLevel = detectColorLevel(process.env, isTTY());
+      const colorLevel = this.colorLevel;
       const phase = (this.tickCount * 0.05) % 1;
       const grad = themeGradient(this.theme, idx);
       const palette = [grad.from, grad.to];

package/src/tui/components/evolution.ts

@@ -308,7 +308,17 @@ export function transitionMessage(index: number): string {
  * Applies a dimensional, animated gradient (foreground or background) to a string of text.
  * Driven by a phaseMs timestamp, it creates a slow, tasteful shimmer wave
  * and adds depth cues (bright core, dimmer edges).
+ *
+ * The clock is QUANTIZED to 225ms buckets (20 discrete phases over the 4.5s period,
+ * matching the forge art's quantized-clock rule): callers pass raw Date.now(), but two
+ * calls in the same bucket produce byte-identical output, so the differential renderer
+ * skips the row instead of rewriting ~2-4KB of truecolor escapes on every idle tick.
+ * A small memo returns the exact prior string for a repeated (bucket, style, text) —
+ * the common case between consecutive 120ms ticks.
  */
+const GRADIENT_BUCKET_MS = 225;
+const gradientMemo = new Map<string, string>();
+const GRADIENT_MEMO_CAP = 16;
 export function applyDimensionalGradient(
   text: string,
   timeMs: number,
@@ -320,6 +330,10 @@ export function applyDimensionalGradient(
 ): string {
   const plain = stripAnsi(text);
   if (level === ColorLevel.None || plain.length === 0) return plain;
+  const bucket = timeMs - (timeMs % GRADIENT_BUCKET_MS);
+  const memoKey = `${bucket}|${fromHex}|${toHex}|${level}|${isBg ? 1 : 0}|${fgHex}|${plain}`;
+  const hit = gradientMemo.get(memoKey);
+  if (hit !== undefined) return hit;
 
   const from = hexToRgb(fromHex);
   const to = hexToRgb(toHex);
@@ -331,8 +345,8 @@ export function applyDimensionalGradient(
     out += fgEscape(fg, level);
   }
 
-  // Slow period: 4.5 seconds for a complete wave cycle
-  const p = (timeMs / 4500) % 1;
+  // Slow period: 4.5 seconds for a complete wave cycle (quantized bucket → 20 phases)
+  const p = (bucket / 4500) % 1;
 
   for (let i = 0; i < L; i++) {
     const ch = plain[i]!;
@@ -380,5 +394,11 @@ export function applyDimensionalGradient(
     }
   }
 
-  return out + resetEscape(level);
+  const result = out + resetEscape(level);
+  if (gradientMemo.size >= GRADIENT_MEMO_CAP) {
+    const oldest = gradientMemo.keys().next().value;
+    if (oldest !== undefined) gradientMemo.delete(oldest);
+  }
+  gradientMemo.set(memoKey, result);
+  return result;
 }

package/src/tui/components/width.ts

@@ -217,9 +217,13 @@ export function wrapTextWithAnsi(text: string, cols: number): string[] {
       out.push(rawLine);
       continue;
     }
+    if (!rawLine.includes("\x1b") && !/[\t\u0300-\uffff]/.test(rawLine) && !/[\u{10000}-\u{10ffff}]/u.test(rawLine)) {
+      for (let i = 0; i < rawLine.length; i += width) out.push(rawLine.slice(i, i + width));
+      continue;
+    }
     let rest = rawLine;
     let active = ""; // SGR open at the wrap boundary, carried to the next line
-    while (visibleWidth(rest) > width) {
+    while (true) {
       const head = truncateToWidth(rest, width);
       // Advance past exactly the consumed substring. truncateToWidth may append a
       // SYNTHETIC trailing reset (frame safety) that is NOT in `rest` — including it
@@ -230,6 +234,12 @@ export function wrapTextWithAnsi(text: string, cols: number): string[] {
         : head.endsWith(RESET) && rest.startsWith(head.slice(0, -RESET.length))
           ? head.slice(0, -RESET.length)
           : head;
+      if (consumed.length === rest.length) {
+        let line = active + rest;
+        if (active && !line.endsWith(RESET)) line += RESET;
+        out.push(line);
+        break;
+      }
       let line = active + head;
       const next = sgrStateAfter(active, consumed);
       // Close any color still open at the line end so it cannot tint the padding/border.
@@ -238,11 +248,6 @@ export function wrapTextWithAnsi(text: string, cols: number): string[] {
       active = next;
       rest = rest.slice(consumed.length);
     }
-    if (rest.length > 0) {
-      let line = active + rest;
-      if (active && !line.endsWith(RESET)) line += RESET;
-      out.push(line);
-    }
   }
   return out;
 }