jeo-code 0.7.30 → 0.7.32

package/src/agent/subagent-tool.ts

@@ -1,11 +1,13 @@
 /**
  * `subagent` control tool (#9) — the parent's handle on DETACHED subagents launched
  * via `task {detached:true}`. Mirrors gjc's `subagent`/`job` control surface, scoped
- * to an in-process registry: list, inspect, await (optionally bounded), and cancel.
+ * to an in-process registry: list, inspect, await (optionally bounded), cancel, and
+ * steer (live peer messaging into a single running subagent).
  *
- * Out of scope here (separate subsystems, not stubbed): live peer messaging (IRC)
- * and pause/resume — a step-budget loop has no safe mid-step checkpoint to resume
- * from, so those are intentionally absent rather than faked.
+ * Out of scope here (a separate subsystem, not stubbed): pause/resume — a step-budget
+ * loop has no safe mid-step checkpoint to resume from, so that remains intentionally
+ * absent rather than faked. Live peer messaging to/among ALL running subagents (not
+ * just one target id) is the `irc` tool, built on the same registry.steer().
  */
 import type { ToolHandler } from "./engine";
 import type { ToolResult } from "./tools";
@@ -13,9 +15,10 @@ import type { SubagentRegistry, SubagentRecord } from "./subagent-registry";
 
 /** One-line protocol description appended to the launch system prompt. */
 export const SUBAGENT_TOOL_PROTOCOL_LINE =
-  `subagent {action:"list"|"inspect"|"await"|"cancel", ids?, timeoutMs?} — control DETACHED ` +
+  `subagent {action:"list"|"inspect"|"await"|"cancel"|"steer", ids?, id?, message?, timeoutMs?} — control DETACHED ` +
   `subagents started with task{detached:true}. 'await' blocks (optionally up to timeoutMs ms) and ` +
-  `returns their reports; 'inspect' shows status + result; 'cancel' aborts them. Omit ids to target all running.`;
+  `returns their reports; 'inspect' shows status + result; 'cancel' aborts them; 'steer' sends {id, message} ` +
+  `to inject a live instruction into that ONE running subagent, picked up before its next step. Omit ids to target all running (list/inspect/await/cancel).`;
 
 function elapsed(rec: SubagentRecord): string {
   const end = rec.finishedAt ?? Date.now();
@@ -84,6 +87,23 @@ export function createSubagentTool(registry: SubagentRegistry): ToolHandler {
       return { success: true, output: `Cancelled ${recs.length} subagent(s):\n${recs.map(rowLine).join("\n")}` };
     }
 
-    return { success: false, output: "", error: `Unknown subagent action '${action}'. Use list | inspect | await | cancel.` };
+    if (action === "steer") {
+      const targetIds = Array.isArray(args.id) ? [] : args.id !== undefined ? [String(args.id)] : [];
+      const message = typeof args.message === "string" ? args.message : typeof args.text === "string" ? args.text : "";
+      if (targetIds.length !== 1) {
+        return { success: false, output: "", error: `subagent 'steer' requires exactly one target 'id' (a single string, not 'ids'). Got: ${JSON.stringify(args.id)}.` };
+      }
+      const id = targetIds[0]!;
+      if (!message.trim()) {
+        return { success: false, output: "", error: "subagent 'steer' requires a non-empty 'message' (or 'text')." };
+      }
+      const ok = registry.steer(id, message);
+      if (!ok) {
+        return { success: false, output: "", error: `Cannot steer '${id}': no running subagent with that id.` };
+      }
+      return { success: true, output: `Steered ${id}: ${message.trim()}` };
+    }
+
+    return { success: false, output: "", error: `Unknown subagent action '${action}'. Use list | inspect | await | cancel | steer.` };
   };
 }

package/src/agent/subagents.ts

@@ -252,7 +252,7 @@ export function bashCommandAllowed(command: string, prefixes: string[]): boolean
  */
 export function subagentToolset(role: SubagentRole): Record<string, ToolHandler> {
   if (role.readOnly) {
-    const MUTATING = new Set(["write", "edit", "bash", "mkdir", "delete"]);
+    const MUTATING = new Set(["write", "edit", "bash", "mkdir", "delete", "ast_edit", "computer", "lsp_rename", "debug"]);
     const ro: Record<string, ToolHandler> = {};
     for (const [name, handler] of Object.entries(DEFAULT_TOOLS)) {
       if (MUTATING.has(name)) continue;

package/src/agent/task-tool.ts

@@ -78,6 +78,27 @@ const MAX_FANOUT = 4;
  *  parent turn. Split larger efforts into sequential task calls. */
 const MAX_SERIAL_EXECUTOR = 6;
 
+/** Minimum distinct, non-filler words a spawn-gate justification must contain.
+ *  A bare length check (`.length >= 20`) previously accepted any 20-char string
+ *  ("xxxxxxxxxxxxxxxxxxxx", "asdf asdf asdf asdf"), which defeated the intent of
+ *  the gate (force the model to actually justify the parallelism, not just pay a
+ *  cheap toll). This does not attempt real NLP — it only rejects the trivially
+ *  degenerate cases a model would use to rubber-stamp past the gate. */
+const JUSTIFICATION_MIN_DISTINCT_WORDS = 4;
+
+/** True when `text` reads as an actual justification rather than filler padding
+ *  used only to clear the ≥20-char length bar. */
+function isMeaningfulJustification(text: string): boolean {
+  const trimmed = text.trim();
+  if (trimmed.length < 20) return false;
+  // Reject strings that are one character (or one repeated short token) padded out —
+  // e.g. "xxxxxxxxxxxxxxxxxxxx" or "aaaa aaaa aaaa aaaa".
+  if (/^(.)\1*$/.test(trimmed.replace(/\s+/g, ""))) return false;
+  const words = trimmed.toLowerCase().match(/[a-z0-9']+/g) ?? [];
+  const distinct = new Set(words);
+  return distinct.size >= JUSTIFICATION_MIN_DISTINCT_WORDS;
+}
+
 /** Broadcast steering hub for a fan-out batch. Each concurrent worker registers
  *  ONCE and then sees every parent steer message exactly once (append-only log +
  *  per-worker cursor), so a mid-batch redirect reaches all running subagents
@@ -320,13 +341,13 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
       // stays bounded at MAX_FANOUT (read-only) or 1 (mutating) regardless.
       if (items.length > MAX_FANOUT) {
         const justification = typeof args.justification === "string" ? args.justification.trim() : "";
-        if (justification.length < 20) {
+        if (!isMeaningfulJustification(justification)) {
           return {
             success: false,
             output: "",
             error:
               `Fan-out of ${items.length} tasks exceeds the default gate of ${MAX_FANOUT}. ` +
-              `Either reduce the batch, or resend with a "justification" string (≥20 chars) explaining why these tasks are independent and must run in one batch.`,
+              `Either reduce the batch, or resend with a "justification" string (≥20 chars, ≥${JUSTIFICATION_MIN_DISTINCT_WORDS} distinct words, not filler) explaining why these tasks are independent and must run in one batch.`,
           };
         }
       }
@@ -371,10 +392,11 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     }
     // Detached form (#9): register a background run and return immediately so the
     // parent can keep working, then list/inspect/await/cancel via the `subagent`
-    // tool. Steering is not forwarded to a detached run (no single active drainer).
+    // tool. Live peer messaging (steer/irc) DOES reach a detached run — it drains
+    // its own registry inbox (registry.steerDrainFor(id)) between its own steps.
     if (args.detached === true && opts.registry) {
-      const rec = opts.registry.launch(role.id, taskText, signal =>
-        runOne(role, taskText, ctx(args.context), cwd, { signal }),
+      const rec = opts.registry.launch(role.id, taskText, (signal, id) =>
+        runOne(role, taskText, ctx(args.context), cwd, { signal, steer: opts.registry!.steerDrainFor(id) }),
       );
       return {
         success: true,

package/src/agent/tools.ts

@@ -226,7 +226,7 @@ function excerptForRecovery(content: string, centerLine?: number): string {
  *  Refreshes the snapshot to CURRENT so the immediate retry (model just saw fresh content) passes. */
 async function staleReadError(absPath: string, filePath: string, verb: string): Promise<ToolResult | null> {
   const snap = lastReadSnapshots.get(absPath);
-  if (!snap) return null; // never read → no guard (back-compat; read-first is advisory)
+  if (!snap) return null; // never read → no guard here (see the narrow blind-replace guard in editTool)
   const st = await fs.stat(absPath).catch(() => null);
   if (!st || !st.isFile()) return null; // deleted/replaced-by-dir: let the op surface its own error
   if (st.mtimeMs === snap.mtimeMs && st.size === snap.size) return null;
@@ -509,6 +509,24 @@ export async function editTool(
             error: `Invalid edit range ${startLine}..${endLine}: out of bounds or reversed (file has ${lines.length} lines)`,
           };
         }
+        // Narrow blind-replace guard: a ≔A..B REPLACE with NO anchors on EITHER
+        // bound carries zero content verification (SEARCH/REPLACE self-verifies via
+        // the search text matching; an anchored ≔ self-verifies via the hash). If the
+        // agent never read this file THIS SESSION, it has nothing to base a blind
+        // line-range replace on — reject instead of silently overwriting unseen lines.
+        // (Insert/append directives above are unaffected: they don't destroy content.
+        // Checked AFTER the bounds check so an out-of-range request still reports as
+        // out-of-range rather than being masked by this guard.)
+        if (!aStart && !aEnd && !lastReadSnapshots.has(absPath)) {
+          return {
+            success: false,
+            output: "",
+            error:
+              `Edit rejected: ${filePath} — a line-range replace with no anchors and no prior read this session ` +
+              `has nothing to verify against. Read the file first, then retry (or include the hashline anchors ` +
+              `from read output, or use a <<<<<<< SEARCH block instead).`,
+          };
+        }
         const mismatch = anchorMismatch(s, aStart) ?? anchorMismatch(e, aEnd);
         if (mismatch) return mismatch;
         lines.splice(s - 1, e - s + 1, payload);
@@ -599,26 +617,95 @@ 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;
 }
 
+// ── Destructive-bash hard block (applies to EVERY bash call, main agent and
+// subagent alike — including the bundled `executor` role, whose bash is
+// otherwise unconstrained since `bashAllowedPrefixes` is an opt-in allowlist
+// no bundled role sets). This is a narrow denylist for unambiguously
+// catastrophic, effectively-irreversible commands, not a general policy
+// filter — everyday destructive-but-scoped commands (rm -rf node_modules,
+// git reset --hard, force-push) stay unconstrained by design. ──
+function stripLeadingSudo(tokens: string[]): string[] {
+  return tokens[0] === "sudo" ? tokens.slice(1) : tokens;
+}
+
+/** True for `rm -rf /`, `rm -fr ~`, `sudo rm -Rf /`, etc. — a recursive,
+ *  forced delete whose target normalizes to the filesystem root or the home
+ *  directory. Scoped deletes (`rm -rf ./dist`, `rm -rf /tmp/x`) are untouched. */
+function isRootOrHomeWipe(command: string): boolean {
+  for (const raw of command.split(/(?:&&|\|\||[;|])/)) {
+    const tokens = stripLeadingSudo(raw.trim().split(/\s+/).filter(Boolean));
+    if (tokens.length === 0) continue;
+    const cmd = tokens[0].replace(/^.*\//, "");
+    if (cmd !== "rm") continue;
+    const flagTokens = tokens.slice(1).filter(t => t.startsWith("-"));
+    const flags = flagTokens.join("");
+    if (!/r/i.test(flags) || !/f/i.test(flags)) continue;
+    const targets = tokens.slice(1).filter(t => !t.startsWith("-"));
+    for (const t of targets) {
+      const norm = t.replace(/\/+$/, "");
+      if (norm === "" || norm === "/" || norm === "~" || norm === "$HOME" || norm === "${HOME}") return true;
+    }
+  }
+  return false;
+}
+
+/** Returns a short human-readable reason when `command` matches a catastrophic,
+ *  effectively-irreversible pattern; null when it does not. */
+function bashDestructiveReason(command: string): string | null {
+  if (isRootOrHomeWipe(command)) return "a recursive force-delete of the filesystem root or home directory (rm -rf / or ~)";
+  if (/:\(\)\s*\{\s*:\s*\|\s*:&?\s*;?\s*\}\s*;\s*:/.test(command)) return "a fork-bomb pattern";
+  if (/\bdd\b[^\n]*\bof=\/dev\/(disk|[rs]?[hsv]d[a-z]?|nvme\w*|xvd\w*)/i.test(command)) return "a raw disk-device overwrite (dd ... of=/dev/...)";
+  if (/\bmkfs(?:\.\w+)?\s+.*\/dev\//i.test(command)) return "a filesystem format on a raw device (mkfs)";
+  return null;
+}
 export async function bashTool(
   command: string,
   cwd: string = process.cwd(),
@@ -632,6 +719,14 @@ export async function bashTool(
     const fx = applyBashFixups(command);
     command = fx.command;
   }
+  const destructive = bashDestructiveReason(command);
+  if (destructive) {
+    return {
+      success: false,
+      output: "",
+      error: `bash rejected: this command looks like ${destructive}. If this is genuinely intended, ask the user to run it manually — it is not permitted from the agent.`,
+    };
+  }
   try {
     // The mutation lock is keyed on the PROJECT cwd, not the run subdir.
     await assertBashAllowed(cwd);

package/src/agent/ts-language-service.ts

@@ -0,0 +1,173 @@
+/**
+ * In-process TypeScript "language service" host (gjc `lsp` parity for TS/JS/TSX/JSX
+ * ONLY — no external `typescript-language-server` process, no other languages).
+ * Built directly on the `typescript` compiler API's `ts.LanguageService`, which is
+ * the exact engine `tsserver`/most TS editor integrations run on top of — so
+ * definition/references/hover/rename here match what a real TS language server
+ * would report, just without the LSP wire protocol or multi-language support.
+ *
+ * One `ts.LanguageService` is cached per project root (`cwd`) and reused across
+ * calls within a turn. `getScriptVersion` stats the file on every call (no manual
+ * invalidation needed) so edits made by `write`/`edit`/`ast_edit` earlier in the
+ * same turn are picked up on the next `lsp` call. A file outside the project's
+ * `tsconfig.json` "include" set is added to the tracked root set on first use.
+ */
+import * as ts from "typescript";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveTargetFiles } from "./ast-file-scan";
+
+interface CachedService {
+  service: ts.LanguageService;
+  extraFiles: Set<string>;
+}
+
+const serviceCache = new Map<string, CachedService>();
+
+function fileVersion(absPath: string): string {
+  try {
+    const st = fs.statSync(absPath);
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return "missing";
+  }
+}
+
+const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions = {
+  target: ts.ScriptTarget.Latest,
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
+  jsx: ts.JsxEmit.ReactJSX,
+  allowJs: true,
+  checkJs: false,
+  esModuleInterop: true,
+  resolveJsonModule: true,
+  strict: false,
+};
+
+function loadProjectFiles(cwd: string): { options: ts.CompilerOptions; fileNames: string[] } {
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (!configFile.error) {
+      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+      if (parsed.fileNames.length > 0) return { options: parsed.options, fileNames: parsed.fileNames };
+    }
+  }
+  return { options: DEFAULT_COMPILER_OPTIONS, fileNames: [] };
+}
+
+/** Get (or lazily create) the cached `ts.LanguageService` for a project root. */
+async function getCached(cwd: string): Promise<CachedService> {
+  const existing = serviceCache.get(cwd);
+  if (existing) return existing;
+
+  const fromConfig = loadProjectFiles(cwd);
+  // No tsconfig.json (or it named zero files) — scan the whole project tree for
+  // supported TS/JS files instead of starting with an EMPTY root set. Without this,
+  // "references"/"rename" starting from a declaration would only ever see the ONE
+  // file explicitly queried: TS's own module resolution pulls in files a root file
+  // IMPORTS, never the reverse (files that import a root file), so a project with
+  // no tsconfig would silently miss every cross-file usage.
+  const fileNames = fromConfig.fileNames.length > 0 ? fromConfig.fileNames : await resolveTargetFiles(["**/*"], cwd);
+  const options = fromConfig.options;
+  const rootFiles = new Set(fileNames);
+  const extraFiles = new Set<string>();
+
+  const host: ts.LanguageServiceHost = {
+    getScriptFileNames: () => [...rootFiles, ...extraFiles],
+    getScriptVersion: fileVersion,
+    getScriptSnapshot: (fileName) => {
+      try {
+        return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName, "utf-8"));
+      } catch {
+        return undefined;
+      }
+    },
+    getCurrentDirectory: () => cwd,
+    getCompilationSettings: () => options,
+    getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+  };
+
+  const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+  const cached: CachedService = { service, extraFiles };
+  serviceCache.set(cwd, cached);
+  return cached;
+}
+
+/** Get the language service for `cwd`, ensuring `absPath` is tracked (added to the
+ *  root set if the project's tsconfig didn't already include it). */
+export async function languageServiceFor(cwd: string, absPath: string): Promise<ts.LanguageService> {
+  const cached = await getCached(cwd);
+  if (!cached.extraFiles.has(absPath)) cached.extraFiles.add(absPath);
+  return cached.service;
+}
+
+/** Drop a cached language service (tests / long-running sessions that need a
+ *  clean project graph after large structural changes). */
+export function resetLanguageServiceCache(cwd?: string): void {
+  if (cwd) serviceCache.delete(cwd);
+  else serviceCache.clear();
+}
+
+export interface SymbolSelector { text: string; occurrence: number }
+
+/** Parse a loose `"name"` or `"name#N"` selector (1-indexed occurrence, default 1). */
+export function parseSymbolSelector(input: string | undefined): SymbolSelector | undefined {
+  if (!input) return undefined;
+  const m = /^(.*)#(\d+)$/.exec(input);
+  if (m) return { text: m[1]!, occurrence: Math.max(1, parseInt(m[2]!, 10)) };
+  return { text: input, occurrence: 1 };
+}
+
+export type PositionResult = { position: number } | { error: string };
+
+/** Resolve a 1-indexed `line` (+ optional symbol substring selector) to an absolute
+ *  character offset in `fileText`, using the TS compiler's own line map (so CRLF
+ *  files are handled correctly, unlike naive `split("\n")` offset arithmetic). */
+export function resolvePosition(fileText: string, line1: number, symbol?: SymbolSelector): PositionResult {
+  const sf = ts.createSourceFile("__pos__.tsx", fileText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+  const lineCount = sf.getLineStarts().length;
+  if (line1 < 1 || line1 > lineCount) {
+    return { error: `line ${line1} is out of range (file has ${lineCount} lines)` };
+  }
+  const lineStart = sf.getPositionOfLineAndCharacter(line1 - 1, 0);
+  const lineEnd = line1 < lineCount ? sf.getPositionOfLineAndCharacter(line1, 0) : fileText.length;
+  const lineText = fileText.slice(lineStart, lineEnd).replace(/\r?\n$/, "");
+
+  if (!symbol) return { position: lineStart };
+
+  let idx = -1;
+  let from = 0;
+  for (let i = 0; i < symbol.occurrence; i++) {
+    idx = lineText.indexOf(symbol.text, from);
+    if (idx === -1) break;
+    from = idx + 1;
+  }
+  if (idx === -1) {
+    return { error: `symbol '${symbol.text}' (occurrence ${symbol.occurrence}) not found on line ${line1}: ${lineText.trim().slice(0, 120)}` };
+  }
+  return { position: lineStart + idx + Math.max(0, Math.floor(symbol.text.length / 2)) };
+}
+
+/** One line of a file, 1-indexed, trimmed for display. */
+export function lineTextAt(fileText: string, line1: number): string {
+  const lines = fileText.split(/\r?\n/);
+  return (lines[line1 - 1] ?? "").trim();
+}
+
+/** Convert a 0-indexed TS `position` in `fileText` to a 1-indexed line number. */
+export function lineOfPosition(fileText: string, position: number): number {
+  const sf = ts.createSourceFile("__pos__.tsx", fileText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+  return sf.getLineAndCharacterOfPosition(position).line + 1;
+}
+
+/** A short, uniform `path:line: text` result line. */
+export function formatLocation(relPath: string, line1: number, text: string): string {
+  return `${relPath}:${line1}: ${text.length > 160 ? text.slice(0, 159) + "…" : text}`;
+}

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/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;
 }