turbollm 1.10.4 → 1.10.6

package/dist/cli.js

@@ -5753,6 +5753,12 @@ var SUPPORTED = {
   hermes: { bin: "hermes", label: "Hermes Agent", install: "npm install -g hermes-agent", prepareConfig: prepareHermes },
   pi: { bin: "pi", label: "pi", install: "npm install -g @earendil-works/pi-coding-agent", prepareConfig: preparePi }
 };
+var CLAUDE_AUTO_COMPACT_WINDOW_MIN = 1e5;
+var CLAUDE_AUTO_COMPACT_WINDOW_MAX = 1e6;
+function clampAutoCompactWindow(ctx) {
+  return Math.min(CLAUDE_AUTO_COMPACT_WINDOW_MAX, Math.max(CLAUDE_AUTO_COMPACT_WINDOW_MIN, Math.round(ctx)));
+}
+var CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = "80";
 var realSpawn = (cmd, args, opts) => {
   if (!opts?.shell) return spawn4(cmd, args, opts);
   const resolved = resolveExecutable(cmd);
@@ -6180,6 +6186,15 @@ Open ${base2} \u2192 Models \u2192 Load a model, then run this again.
     // Opt into gateway model discovery: Claude Code queries our /v1/models at startup and
     // populates the /model picker with the local library (gateway synthesises the entries).
     CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+    // Founder-reported: the ctx-fill display "jumps between full and empty" and the CLI "never
+    // auto-compacts at 80%, always reaches 100% and fails". The second half is Claude Code
+    // assuming a generic ~200K context window for our unrecognized model id and only compacting
+    // near THAT — see clampAutoCompactWindow's own doc comment for the full root cause and its
+    // documented [100_000, 1_000_000] floor/ceiling. Only set when the daemon actually reports a
+    // real ctx (status.model.ctx) — an absent/zero value means "don't know", and guessing a
+    // window here would be worse than leaving the CLI's own generic default in place.
+    ...status.model?.ctx ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(clampAutoCompactWindow(status.model.ctx)) } : {},
+    CLAUDE_AUTOCOMPACT_PCT_OVERRIDE,
     // Cap background-agent fan-out at what the engine can actually run concurrently.
     //
     // Claude Code spawns subagents in parallel, and each is a full, independent request to the
@@ -7140,13 +7155,16 @@ var AUTO_MODE_ALLOWED_TOOLS = {
   claude: ["WebSearch", "WebFetch"]
 };
 var MAX_SEEDED_MESSAGE_CHARS = 4e3;
-var UNSEEDABLE = /["\u0000-\u001f]/;
+var UNSEEDABLE = /["\u0000-\u0008\u000b\u000c\u000e-\u001f]/;
+function normalizeSeededMessage(message) {
+  return message.replace(/[\r\n\t]+/g, " ").trim();
+}
 function canSeedFirstMessage(message, agent) {
   if (agent !== "claude") return false;
-  const trimmed = message.trim();
-  if (trimmed.length === 0 || trimmed.length > MAX_SEEDED_MESSAGE_CHARS) return false;
-  if (UNSEEDABLE.test(trimmed)) return false;
-  if (trimmed.endsWith("\\")) return false;
+  const normalized = normalizeSeededMessage(message);
+  if (normalized.length === 0 || normalized.length > MAX_SEEDED_MESSAGE_CHARS) return false;
+  if (UNSEEDABLE.test(normalized)) return false;
+  if (normalized.endsWith("\\")) return false;
   return true;
 }
 function buildTerminalLaunchCommand(agent, port2, token, sessionId, launchedOnce, permissionMode, mode, firstMessage) {
@@ -7155,7 +7173,7 @@ function buildTerminalLaunchCommand(agent, port2, token, sessionId, launchedOnce
   const modeArg = permissionMode ? ` --permission-mode ${permissionMode}` : "";
   const allowed = mode === "auto" ? AUTO_MODE_ALLOWED_TOOLS[agent] : void 0;
   const allowedArg = allowed?.length ? ` --allowedTools ${allowed.join(",")}` : "";
-  const promptArg = firstMessage && canSeedFirstMessage(firstMessage, agent) ? ` ${quotePtyShellArg(firstMessage.trim())}` : "";
+  const promptArg = firstMessage && canSeedFirstMessage(firstMessage, agent) ? ` ${quotePtyShellArg(normalizeSeededMessage(firstMessage))}` : "";
   return `turbollm launch ${agent}${promptArg} --port ${port2} --token ${token}${sessionArg}${modeArg}${allowedArg}`;
 }
 function err(c, s, code, msg2) {
@@ -13488,6 +13506,10 @@ var ConversationStore = class {
       if (!this.hasColumn("api_usage", "harness")) this.db.exec(`ALTER TABLE api_usage ADD COLUMN harness TEXT;`);
       this.db.exec(`PRAGMA user_version = 43;`);
     }
+    if (v < 44) {
+      this.db.exec(`CREATE INDEX IF NOT EXISTS idx_api_usage_code_session_tokens ON api_usage(code_session_id, prompt_tokens);`);
+      this.db.exec(`PRAGMA user_version = 44;`);
+    }
   }
   listConversations(q, kind = "all") {
     if (q) {
@@ -13874,10 +13896,37 @@ var ConversationStore = class {
       $harness: rec.harness ?? null
     });
   }
-  /** Most recent completed gateway request attributed to a terminal-agent Code session
-   *  (ADR-284) — powers TerminalToolbar.tsx's composer-parity stats row the same way
-   *  `lastRealStats` already does for a 'turbollm' chat session's last turn. null when the
-   *  session has made no gateway requests yet (fresh session, or a non-terminal-agent one). */
+  /** The session's own gateway-request stats (ADR-284, revised twice — founder-reported "ctx
+   *  fill jumps between full and empty in the same session", then a review pass on that same fix
+   *  catching that it had gone on to freeze the LAST-TURN stats too). Two different questions,
+   *  two different rows:
+   *
+   *  `ctxUsed` is the MAX prompt_tokens row, not literally the most-recently-INSERTED one. Every
+   *  request a real `claude` CLI process makes — the main conversation's own turn AND every
+   *  parallel Task-tool sub-agent it spawns — shares the SAME code_session_id: `resolveCodeSession`
+   *  (gateway.ts) derives it purely from the bearer token, and the CLI mints exactly one token
+   *  (ANTHROPIC_AUTH_TOKEN, set once at launch) for its whole process, sub-agents included. A
+   *  sub-agent's own prompt is a small, isolated sub-task — nothing like the full resent
+   *  conversation — so whichever of the two finishes last used to decide what the ring showed:
+   *  the real, large, ever-growing main-turn prompt one poll, a tiny sub-agent prompt the next,
+   *  with no change to the actual conversation in between. The MAX is the honest answer to "how
+   *  full has this session's context gotten" — a real Claude Code CLI resends the whole
+   *  conversation every turn, so its size only grows within one continuous conversation, and a
+   *  sub-agent (always smaller) can never legitimately raise that high-water mark. Trade-off,
+   *  accepted: after a real `/clear` inside the CLI (invisible to the daemon — a terminal-agent
+   *  session's turns are never persisted here, see ADR-297), this keeps reporting the pre-clear
+   *  high-water mark until the new conversation grows past it. A temporarily-stale-high ring
+   *  reading after a rare, deliberate user action beats an unpredictable full/empty flicker on
+   *  every ordinary agentic turn with sub-agents.
+   *
+   *  `promptTokens`/`genTokens`/`promptTps`/`genTps` are the temporally-LAST row instead — these
+   *  power TerminalToolbar.tsx's composer-parity stats row, which reads as "your last turn", not
+   *  "session high-water mark". Sharing the MAX row here (the original version of this fix) meant
+   *  a sub-agent call landing after the real turn hid its own genTokens/tps behind the earlier,
+   *  larger turn's numbers, and after a `/clear` these froze at the pre-clear turn's numbers
+   *  forever, same failure shape as the ctxUsed bug this method was written to fix in the first
+   *  place. null when the session has made no gateway requests yet (fresh session, or a
+   *  non-terminal-agent one). */
   getLastApiUsageForSession(codeSessionId) {
     const row = this.db.prepare(`
       SELECT prompt_tokens, gen_tokens, duration_ms, prompt_tps, gen_tps FROM api_usage
@@ -13885,8 +13934,12 @@ var ConversationStore = class {
       ORDER BY created_at DESC LIMIT 1
     `).get({ $codeSessionId: codeSessionId });
     if (!row) return null;
+    const ctxUsed = this.db.prepare(`
+      SELECT MAX(prompt_tokens) as maxPromptTokens FROM api_usage WHERE code_session_id = $codeSessionId
+    `).get({ $codeSessionId: codeSessionId }).maxPromptTokens;
     const seconds = row.duration_ms != null && row.duration_ms > 0 ? row.duration_ms / 1e3 : null;
     return {
+      ctxUsed,
       promptTokens: row.prompt_tokens,
       genTokens: row.gen_tokens,
       promptTps: row.prompt_tps ?? (seconds ? row.prompt_tokens / seconds : null),
@@ -15549,6 +15602,17 @@ import { execFile as execFile10 } from "child_process";
 import { readFileSync as readFileSync12 } from "fs";
 import { randomUUID as randomUUID6 } from "crypto";
 
+// src/bench/spill.ts
+var SPILL_TOLERANCE_MB = 512;
+function spillMb(baselineSharedMb, loadedSharedMb) {
+  if (baselineSharedMb === null || loadedSharedMb === null) return null;
+  return Math.max(0, loadedSharedMb - baselineSharedMb);
+}
+function isSpilling(spill) {
+  if (spill === null) return false;
+  return spill > SPILL_TOLERANCE_MB;
+}
+
 // src/api/path-utils.ts
 function inferRepoFromPath(filePath, modelDirs) {
   const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -16476,7 +16540,6 @@ var PREFILL_GRACE_MS = 8e3;
 var TOTAL_BUDGET_MS = 45 * 6e4;
 var OOM_RE = /out of memory|cudaMalloc|failed to allocate|unable to allocate|device not ready|CUDA error/i;
 var QUALITY_KV = ["f16", "q8_0", "turbo4"];
-var OUTPUT_TIE = 0.05;
 var KV_BYTES = {
   f32: 4,
   f16: 2,
@@ -16749,16 +16812,28 @@ var BenchRunner = class {
         const probe2 = await this.probeVram(entry, sys, { ...base2, ngl: mid }, caps);
         this.pushProbe(results, base2, "ngl", mid, probe2);
         await this.settleGpu(sys);
-        if (probe2.outcome === "ok" && !overHeadroom(probe2.vramAbsMb, budgetMb, headroomMb)) {
+        const verdict = probeVerdict(probe2, budgetMb, headroomMb);
+        if (verdict.decision === "fits") {
           bestNgl = mid;
           lo = mid + 1;
         } else {
+          if (verdict.reason === "spill") {
+            this.emit(`ngl=${mid} spilling ${Math.round(verdict.shortfallMb ?? 0)} MB to system RAM \u2014 using fewer GPU layers`);
+          }
           hi = mid - 1;
         }
       }
     }
     if (bestNgl === null) return null;
     let found = await this.benchAt(entry, sys, { ...base2, ngl: bestNgl }, caps, results, `ngl=${bestNgl}`);
+    if (found && isSpilling(found.cand.spillMb) && bestNgl > 0) {
+      this.emit(`ngl=${bestNgl} spilled ${Math.round(found.cand.spillMb)} MB once actually generating (the load-only probe could not see this) \u2014 retrying at ngl=${bestNgl - 1}`);
+      const safer = await this.benchAt(entry, sys, { ...base2, ngl: bestNgl - 1 }, caps, results, `ngl=${bestNgl - 1} (spill backoff)`);
+      if (safer) {
+        found = safer;
+        bestNgl = bestNgl - 1;
+      }
+    }
     if (found && overHeadroom(found.cand.vramAbsMb, budgetMb, headroomMb) && bestNgl > 0) {
       this.emit(`ngl=${bestNgl} exceeded headroom after generation (${found.cand.vramAbsMb} MB) \u2014 retrying at ngl=${bestNgl - 1}`);
       const safer = await this.benchAt(entry, sys, { ...base2, ngl: bestNgl - 1 }, caps, results, `ngl=${bestNgl - 1} (headroom backoff)`);
@@ -16792,32 +16867,61 @@ var BenchRunner = class {
       const probe2 = await this.probeVram(entry, sys, { ...base2, nCpuMoe: mid }, caps);
       this.pushProbe(results, base2, "nCpuMoe", mid, probe2);
       await this.settleGpu(sys);
-      if (probe2.outcome === "oom" || overHeadroom(probe2.vramAbsMb, budgetMb, headroomMb)) {
-        lo = mid + 1;
-      } else if (probe2.outcome === "ok") {
+      const verdict = probeVerdict(probe2, budgetMb, headroomMb);
+      if (verdict.decision === "fits") {
         bestN = mid;
         hi = mid - 1;
       } else {
+        if (verdict.reason === "spill") {
+          this.emit(`nCpuMoe=${mid} spilling ${Math.round(verdict.shortfallMb ?? 0)} MB to system RAM \u2014 offloading more`);
+        }
         lo = mid + 1;
       }
     }
     if (bestN === null) return null;
-    let found = await this.benchAt(entry, sys, { ...base2, nCpuMoe: bestN }, caps, results, `nCpuMoe=${bestN}`);
-    if (found && overHeadroom(found.cand.vramAbsMb, budgetMb, headroomMb) && bestN < maxN) {
-      this.emit(`nCpuMoe=${bestN} exceeded headroom after generation (${found.cand.vramAbsMb} MB) \u2014 retrying at nCpuMoe=${bestN + 1}`);
-      const safer = await this.benchAt(entry, sys, { ...base2, nCpuMoe: bestN + 1 }, caps, results, `nCpuMoe=${bestN + 1} (headroom backoff)`);
-      if (safer) found = safer;
+    let found = null;
+    let foundN = bestN;
+    for (let n = bestN; n <= maxN; n++) {
+      const label = n === bestN ? `nCpuMoe=${n}` : `nCpuMoe=${n} (crash backoff)`;
+      found = await this.benchAt(entry, sys, { ...base2, nCpuMoe: n }, caps, results, label);
+      if (found) {
+        foundN = n;
+        break;
+      }
+      const stopped = this.cancelled || Date.now() > this.deadline;
+      if (stopped) {
+        this.emit(`nCpuMoe=${n} failed to bench (${results[results.length - 1]?.outcome ?? "crash"}) \u2014 run ${this.cancelled ? "cancelled" : "out of time budget"}, stopping`);
+        break;
+      }
+      if (n < maxN) this.emit(`nCpuMoe=${n} failed to bench (${results[results.length - 1]?.outcome ?? "crash"}) \u2014 retrying at nCpuMoe=${n + 1}`);
+    }
+    if (found && isSpilling(found.cand.spillMb) && foundN < maxN) {
+      this.emit(`nCpuMoe=${foundN} spilled ${Math.round(found.cand.spillMb)} MB once actually generating (the load-only probe could not see this) \u2014 retrying at nCpuMoe=${foundN + 1}`);
+      const safer = await this.benchAt(entry, sys, { ...base2, nCpuMoe: foundN + 1 }, caps, results, `nCpuMoe=${foundN + 1} (spill backoff)`);
+      if (safer) {
+        found = safer;
+        foundN = foundN + 1;
+      }
+    }
+    if (found && overHeadroom(found.cand.vramAbsMb, budgetMb, headroomMb) && foundN < maxN) {
+      this.emit(`nCpuMoe=${foundN} exceeded headroom after generation (${found.cand.vramAbsMb} MB) \u2014 retrying at nCpuMoe=${foundN + 1}`);
+      const safer = await this.benchAt(entry, sys, { ...base2, nCpuMoe: foundN + 1 }, caps, results, `nCpuMoe=${foundN + 1} (headroom backoff)`);
+      if (safer) {
+        found = safer;
+        foundN = foundN + 1;
+      }
     }
     if (headroomMb === VRAM_HEADROOM_SPILL_MB && found && found.cand.tps !== null) {
       let current = found;
       while (current.cand.params.nCpuMoe > 0 && !this.cancelled && Date.now() <= this.deadline) {
         const spillN = current.cand.params.nCpuMoe - 1;
-        const prev = { tps: current.cand.tps, prefillTps: current.cand.prefillTps };
-        const prevLabel = `${prev.tps.toFixed(1)} tok/s (prefill ${prev.prefillTps !== null ? prev.prefillTps.toFixed(1) : "n/a"} tok/s)`;
+        const prev = { ttftMs: current.cand.ttftMs, tps: current.cand.tps };
+        const prevTtf = ttfMs(prev);
+        const prevLabel = prevTtf !== null ? `${(prevTtf / 1e3).toFixed(1)}s to ${TTF_OUTPUT_TOKENS} tokens` : "an unmeasurable result";
         this.emit(`nCpuMoe=${current.cand.params.nCpuMoe} measured ${prevLabel} \u2014 trying VRAM-spill nCpuMoe=${spillN}`);
         const spillFound = await this.benchAt(entry, sys, { ...base2, nCpuMoe: spillN }, caps, results, `nCpuMoe=${spillN} (VRAM-spill hill-climb)`);
         if (!spillImproves(prev, spillFound?.cand ?? null)) {
-          this.emit(`nCpuMoe=${spillN} spill did not improve on ${prevLabel} (generation or prefill speed decreased) \u2014 stopping climb, keeping nCpuMoe=${current.cand.params.nCpuMoe}`);
+          this.emit(`nCpuMoe=${spillN} did not beat ${prevLabel} \u2014 stopping climb, keeping nCpuMoe=${current.cand.params.nCpuMoe}`);
           break;
         }
         current = spillFound;
@@ -16834,7 +16938,7 @@ var BenchRunner = class {
    *  measuring t/s at every search step would be wasted — we bench ONCE, at the chosen config. */
   async probeVram(entry, sys, profile, caps) {
     const active = this.registry.active();
-    if (!active) return { outcome: "crash", vramAbsMb: null };
+    if (!active) return { outcome: "crash", vramAbsMb: null, spillMb: null };
     const testDeadline = Math.min(Date.now() + READY_TIMEOUT_MS + 5e3, this.deadline);
     const opts = {
       engine: active,
@@ -16842,19 +16946,22 @@ var BenchRunner = class {
       modelPath: entry.path,
       extraArgs: profileToArgs(profile, entry, caps, sys.cores, sys, active.binPath)
     };
+    const sharedBefore = await readGpuSharedMb(sys);
     try {
       await this.manager.start(opts);
     } catch {
-      return { outcome: "crash", vramAbsMb: null };
+      return { outcome: "crash", vramAbsMb: null, spillMb: null };
     }
     const outcome = await this.awaitReady(testDeadline);
     let vramAbsMb = null;
+    let spill = null;
     if (outcome === "ok") {
       await sleep3(800);
       vramAbsMb = await readGpuVramMb(sys);
+      spill = spillMb(sharedBefore, await readGpuSharedMb(sys));
     }
     await this.stopEngine();
-    return { outcome, vramAbsMb };
+    return { outcome, vramAbsMb, spillMb: spill };
   }
   /** Record a VRAM-probe trial in the candidate list (tps/prefill are null — nothing was generated;
    *  only the load outcome and absolute VRAM are known). */
@@ -16874,7 +16981,8 @@ var BenchRunner = class {
       prefillTps: null,
       ttftMs: null,
       vramMb: null,
-      vramAbsMb: probe2.vramAbsMb
+      vramAbsMb: probe2.vramAbsMb,
+      spillMb: probe2.spillMb
     };
     results.push(probeCand);
     this.emit(`${probeCand.label} \u2192 ${probe2.outcome}${probe2.vramAbsMb != null ? ` (${probe2.vramAbsMb} MB)` : ""}`, probeCand);
@@ -16905,7 +17013,7 @@ var BenchRunner = class {
       kvTypeK: profile.kvTypeK,
       flashAttn: profile.flashAttn
     };
-    const fail = (outcome2) => ({ label, params, outcome: outcome2, tps: null, prefillTps: null, ttftMs: null, vramMb: null, vramAbsMb: null });
+    const fail = (outcome2) => ({ label, params, outcome: outcome2, tps: null, prefillTps: null, ttftMs: null, vramMb: null, vramAbsMb: null, spillMb: null });
     const phase = (p) => {
       this.state = { ...this.state, step: `${stepPrefix} \u2014 ${p}` };
     };
@@ -16920,6 +17028,7 @@ var BenchRunner = class {
       extraArgs: profileToArgs(profile, entry, caps, sys.cores, sys, active.binPath)
     };
     const vramBefore = await readGpuVramMb(sys);
+    const sharedBefore = await readGpuSharedMb(sys);
     phase("loading model\u2026");
     try {
       await this.manager.start(opts);
@@ -16947,10 +17056,11 @@ var BenchRunner = class {
     phase("measuring t/s\u2026");
     const measured = await this.runChatWatched(target, benchMessages, 128, remaining(), logPath);
     const vramAfter = await readGpuVramMb(sys);
+    const sharedAfter = await readGpuSharedMb(sys);
     await this.stopEngine();
     if ("fault" in measured) return fail(measured.fault);
     const vramMb = vramBefore !== null && vramAfter !== null ? Math.max(0, vramAfter - vramBefore) : vramAfter;
-    return { label, params, outcome: "ok", tps: measured.tps, prefillTps: measured.prefillTps, ttftMs: measured.ttftMs, vramMb, vramAbsMb: vramAfter };
+    return { label, params, outcome: "ok", tps: measured.tps, prefillTps: measured.prefillTps, ttftMs: measured.ttftMs, vramMb, vramAbsMb: vramAfter, spillMb: spillMb(sharedBefore, sharedAfter) };
   }
   /** Poll the manager state until the engine is running, the readiness window
    *  elapses (timeout), the process exits (crash), or an OOM line appears in the
@@ -17459,20 +17569,35 @@ function pickKvQuants(baseKv, kvTypes) {
   for (const t of [baseKv, ...QUALITY_KV]) if (supported(t) && !out.includes(t)) out.push(t);
   return out;
 }
+function probeVerdict(probe2, budgetMb, headroomMb) {
+  if (probe2.outcome === "oom") return { decision: "offload-more", reason: "oom" };
+  if (isSpilling(probe2.spillMb)) {
+    return { decision: "offload-more", reason: "spill", shortfallMb: probe2.spillMb };
+  }
+  if (overHeadroom(probe2.vramAbsMb, budgetMb, headroomMb)) {
+    return { decision: "offload-more", reason: "headroom" };
+  }
+  if (probe2.outcome === "ok") return { decision: "fits" };
+  return { decision: "offload-more", reason: "failed" };
+}
+var TTF_OUTPUT_TOKENS = 1e3;
+function ttfMs(c, outputTokens = TTF_OUTPUT_TOKENS) {
+  if (c.ttftMs === null || c.tps === null || c.tps <= 0) return null;
+  return c.ttftMs + outputTokens / c.tps * 1e3;
+}
 function betterBySpeed(a, b) {
-  const at = a.tps ?? 0;
-  const bt = b.tps ?? 0;
-  if (bt <= 0) return at > 0;
-  const rel = (at - bt) / bt;
-  if (rel > OUTPUT_TIE) return true;
-  if (rel < -OUTPUT_TIE) return false;
-  return (a.prefillTps ?? 0) > (b.prefillTps ?? 0);
+  const at = ttfMs(a);
+  const bt = ttfMs(b);
+  if (at === null) return false;
+  if (bt === null) return true;
+  return at < bt;
 }
 function spillImproves(previous, candidate) {
-  if (!candidate || candidate.outcome !== "ok" || candidate.tps === null) return false;
-  if (candidate.tps < previous.tps) return false;
-  if (previous.prefillTps !== null && (candidate.prefillTps === null || candidate.prefillTps < previous.prefillTps)) return false;
-  return true;
+  if (!candidate || candidate.outcome !== "ok") return false;
+  const next = ttfMs(candidate);
+  const prev = ttfMs(previous);
+  if (next === null || prev === null) return false;
+  return next < prev;
 }
 function kvBytes(t) {
   return KV_BYTES[t] ?? 2;
@@ -17538,6 +17663,66 @@ async function readGpuVramMb(sys) {
   if (sys.gpus.some((g) => g.vendor === "amd")) return readRocmVramMb();
   return null;
 }
+var WDDM_SHARED_PS = "$s=(Get-Counter '\\GPU Adapter Memory(*)\\Shared Usage' -ErrorAction SilentlyContinue).CounterSamples;if(-not $s){exit 1};[math]::Round((($s|Measure-Object CookedValue -Sum).Sum)/1MB,1)";
+var wddmSharedUnsupported = false;
+function readWddmSharedMb() {
+  if (process.platform !== "win32" || wddmSharedUnsupported) return Promise.resolve(null);
+  return new Promise((resolve5) => {
+    try {
+      execFile10(
+        "powershell",
+        ["-NoProfile", "-NonInteractive", "-Command", WDDM_SHARED_PS],
+        { timeout: 1e4, windowsHide: true },
+        (err8, stdout) => {
+          if (err8) {
+            if (!err8.killed) wddmSharedUnsupported = true;
+            return resolve5(null);
+          }
+          const mb = parseFloat((stdout || "").trim());
+          if (!Number.isFinite(mb) || mb < 0) {
+            wddmSharedUnsupported = true;
+            return resolve5(null);
+          }
+          resolve5(Math.round(mb));
+        }
+      );
+    } catch {
+      wddmSharedUnsupported = true;
+      resolve5(null);
+    }
+  });
+}
+function parseRocmGttUsed(memJson) {
+  try {
+    const mem = JSON.parse(memJson);
+    let total = 0;
+    for (const fields of Object.values(mem)) {
+      const usedKey = Object.keys(fields).find((k) => /GTT Total Used Memory/i.test(k));
+      total += usedKey ? parseInt(String(fields[usedKey]).trim(), 10) || 0 : 0;
+    }
+    return Number.isFinite(total) ? Math.round(total / 1e6) : null;
+  } catch {
+    return null;
+  }
+}
+function readRocmGttMb() {
+  return new Promise((resolve5) => {
+    try {
+      execFile10("rocm-smi", ["--showmeminfo", "gtt", "--json"], { timeout: 8e3, windowsHide: true }, (err8, stdout) => {
+        if (err8 || !stdout) return resolve5(null);
+        resolve5(parseRocmGttUsed(stdout));
+      });
+    } catch {
+      resolve5(null);
+    }
+  });
+}
+async function readGpuSharedMb(sys) {
+  const win = await readWddmSharedMb();
+  if (win !== null) return win;
+  if (sys.gpus.some((g) => g.vendor === "amd")) return readRocmGttMb();
+  return null;
+}
 function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -24252,7 +24437,59 @@ function mapFromOpenAI(oai, modelName) {
     usage: { input_tokens: usage?.prompt_tokens ?? 0, output_tokens: usage?.completion_tokens ?? 0 }
   };
 }
-async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive, onToolCalls) {
+var DEFAULT_PING_INTERVAL_MS = 1e4;
+function waitOrPing(pending2, ms) {
+  return new Promise((resolve5) => {
+    const timer = setTimeout(() => resolve5("ping"), ms);
+    pending2.then(
+      () => {
+        clearTimeout(timer);
+        resolve5("data");
+      },
+      () => {
+        clearTimeout(timer);
+        resolve5("data");
+      }
+    );
+  });
+}
+async function pingWhilePending(pending2, emitPing, pingIntervalMs = DEFAULT_PING_INTERVAL_MS, onOrphan) {
+  pending2.catch(() => {
+  });
+  let nextPingAt = Date.now() + pingIntervalMs;
+  while (true) {
+    const remaining = Math.max(0, nextPingAt - Date.now());
+    const outcome = remaining === 0 ? "ping" : await waitOrPing(pending2, remaining);
+    if (outcome === "ping") {
+      try {
+        await emitPing();
+      } catch (e) {
+        if (onOrphan) pending2.then(onOrphan).catch(() => {
+        });
+        throw e;
+      }
+      nextPingAt = Date.now() + pingIntervalMs;
+      continue;
+    }
+    return pending2;
+  }
+}
+function messageStartEvent(msgId, modelName) {
+  return sse("message_start", {
+    message: {
+      id: msgId,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model: modelName,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 1 }
+    }
+  });
+}
+async function* streamToAnthropic(oaiStream, modelName, msgId, opts = {}) {
+  const { onUsage, onLive, onToolCalls, pingIntervalMs = DEFAULT_PING_INTERVAL_MS, skipMessageStart = false } = opts;
   let blockIdx = 0;
   let inThinking = false;
   let inText = false;
@@ -24265,25 +24502,30 @@ async function* streamToAnthropic(oaiStream, modelName, msgId, onUsage, onLive,
   let promptTps = 0;
   let genTps = 0;
   let liveOut = 0;
-  yield sse("message_start", {
-    message: {
-      id: msgId,
-      type: "message",
-      role: "assistant",
-      content: [],
-      model: modelName,
-      stop_reason: null,
-      stop_sequence: null,
-      usage: { input_tokens: 0, output_tokens: 1 }
-    }
-  });
+  if (!skipMessageStart) yield messageStartEvent(msgId, modelName);
   const reader = oaiStream.getReader();
   const dec = new TextDecoder();
   let buf = "";
   let failed = false;
+  let nextPingAt = Date.now() + pingIntervalMs;
   try {
     outer: while (true) {
-      const { done, value } = await reader.read();
+      const readPromise = reader.read();
+      readPromise.catch(() => {
+      });
+      let result;
+      while (true) {
+        const remaining = Math.max(0, nextPingAt - Date.now());
+        const outcome = remaining === 0 ? "ping" : await waitOrPing(readPromise, remaining);
+        if (outcome === "ping") {
+          yield sse("ping", {});
+          nextPingAt = Date.now() + pingIntervalMs;
+          continue;
+        }
+        result = await readPromise;
+        break;
+      }
+      const { done, value } = result;
       if (done) break;
       buf += dec.decode(value, { stream: true });
       const lines = buf.split("\n");
@@ -24828,7 +25070,23 @@ function anthropicErrorType(status) {
 function asClientStatus(status) {
   return status >= 400 && status <= 599 ? status : 500;
 }
-function registerGateway(app2, d) {
+function classifyGateError(e) {
+  const aborted = e.message === "gate_acquire_aborted";
+  return aborted ? { status: 400, type: "invalid_request_error", message: "Client disconnected while queued for the engine." } : { status: 503, type: "overloaded_error", message: "Timed out waiting for a free engine slot." };
+}
+function classifyFetchError(e, ac) {
+  const err8 = e;
+  const isAbort = err8.name === "AbortError" || ac.signal.aborted;
+  const cause = err8.cause instanceof Error ? `: ${err8.cause.message}` : "";
+  return {
+    status: 500,
+    type: "api_error",
+    message: isAbort ? "Client disconnected before the engine responded." : `${err8.message || "Engine unreachable."}${cause}`
+  };
+}
+function registerGateway(app2, d, opts = {}) {
+  const pingIntervalMs = opts.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS;
+  const gateAcquireTimeoutMs = opts.gateAcquireTimeoutMs ?? 6e5;
   app2.post("/v1/messages", async (c) => {
     let req;
     try {
@@ -24888,23 +25146,131 @@ function registerGateway(app2, d) {
     if (guidance?.forceTextOnly) oaiBody.tool_choice = "none";
     const oaiAlias = engineModelAlias(d.registry.active()?.kind ?? "");
     if (oaiAlias) oaiBody.model = oaiAlias;
+    const ac = clientAbort(c);
+    if (req.stream) {
+      const msgId = `msg_${randomUUID13().replace(/-/g, "")}`;
+      return streamSSE4(c, async (stream) => {
+        let gateRelease2 = null;
+        let generationStarted = false;
+        stream.onAbort(() => ac.abort());
+        const ping = () => stream.writeSSE({ event: "ping", data: JSON.stringify({ type: "ping" }) });
+        try {
+          try {
+            await stream.writeSSE(messageStartEvent(msgId, modelName));
+            if (d.gate) {
+              try {
+                gateRelease2 = await pingWhilePending(
+                  d.gate.acquire("bg", { signal: c.req.raw.signal, timeoutMs: gateAcquireTimeoutMs }),
+                  ping,
+                  pingIntervalMs,
+                  (release) => release()
+                );
+              } catch (e) {
+                const { type, message } = classifyGateError(e);
+                await stream.writeSSE({ event: "error", data: JSON.stringify({ type: "error", error: { type, message } }) });
+                return;
+              }
+            }
+            d.manager.generationStart();
+            generationStarted = true;
+            const requestStart2 = Date.now();
+            let res2;
+            try {
+              res2 = await pingWhilePending(
+                fetch(`${target}/v1/chat/completions`, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify(oaiBody),
+                  signal: ac.signal
+                }),
+                ping,
+                pingIntervalMs
+                // No onOrphan: an orphaned Response has nothing to release — its body is simply
+                // never read and gets garbage-collected, unlike gate.acquire()'s grant above.
+              );
+            } catch (e) {
+              const { type, message } = classifyFetchError(e, ac);
+              await stream.writeSSE({ event: "error", data: JSON.stringify({ type: "error", error: { type, message } }) });
+              return;
+            }
+            if (!res2.ok || !res2.body) {
+              const { message, type } = await describeEngineError(res2);
+              await stream.writeSSE({
+                event: "error",
+                data: JSON.stringify({ type: "error", error: { type: type ?? anthropicErrorType(res2.status), message } })
+              });
+              return;
+            }
+            const gen = streamToAnthropic(res2.body, modelName, msgId, {
+              onUsage: (u) => {
+                try {
+                  d.manager.recordCompletion({
+                    inputTokens: u.inputTokens,
+                    outputTokens: u.outputTokens,
+                    promptTps: u.promptTps,
+                    genTps: u.genTps
+                  });
+                  d.db.recordApiUsage({
+                    source: "anthropic",
+                    modelKey: req.model ?? null,
+                    promptTokens: u.inputTokens,
+                    genTokens: u.outputTokens,
+                    codeSessionId: anthropicCodeSessionId,
+                    durationMs: Date.now() - requestStart2,
+                    promptTps: u.promptTps,
+                    genTps: u.genTps,
+                    harness: anthropicHarness
+                  });
+                } catch {
+                }
+              },
+              // Live per-request progress for the engine card (prefill % + token count),
+              // so Claude Code traffic shows the same live row as in-app chat.
+              onLive: (live) => {
+                try {
+                  d.manager.setLiveGen(live);
+                } catch {
+                }
+              },
+              // Coding-activity attribution for terminal-agent sessions — see
+              // observeCodeSessionTurn. Nothing to attribute for any other client.
+              onToolCalls: (calls) => {
+                if (!anthropicCodeSessionId) return;
+                try {
+                  observeCodeSessionTurn(d, anthropicCodeSessionId, calls);
+                } catch {
+                }
+              },
+              skipMessageStart: true
+              // already sent above, before the queue wait
+            });
+            for await (const evt of gen) {
+              await stream.writeSSE({ event: evt.event, data: evt.data });
+            }
+          } finally {
+            ac.abort();
+            if (generationStarted) d.manager.generationEnd();
+            gateRelease2?.();
+          }
+        } catch (e) {
+          await stream.writeSSE({
+            event: "error",
+            data: JSON.stringify({ type: "error", error: { type: "api_error", message: e?.message || "Internal gateway error." } })
+          }).catch(() => {
+          });
+        }
+      });
+    }
     let gateRelease = null;
     if (d.gate) {
       try {
-        gateRelease = await d.gate.acquire("bg", { signal: c.req.raw.signal, timeoutMs: 6e5 });
+        gateRelease = await d.gate.acquire("bg", { signal: c.req.raw.signal, timeoutMs: gateAcquireTimeoutMs });
       } catch (e) {
-        const aborted = e.message === "gate_acquire_aborted";
-        return c.json(
-          {
-            type: "error",
-            error: aborted ? { type: "invalid_request_error", message: "Client disconnected while queued for the engine." } : { type: "overloaded_error", message: "Timed out waiting for a free engine slot." }
-          },
-          aborted ? 400 : 503
-        );
+        const { status: status2, type, message } = classifyGateError(e);
+        return c.json({ type: "error", error: { type, message } }, status2);
       }
     }
     d.manager.generationStart();
-    const ac = clientAbort(c);
     const requestStart = Date.now();
     let res;
     try {
@@ -24917,19 +25283,8 @@ function registerGateway(app2, d) {
     } catch (e) {
       d.manager.generationEnd();
       gateRelease?.();
-      const err8 = e;
-      const isAbort = err8.name === "AbortError" || ac.signal.aborted;
-      const cause = err8.cause instanceof Error ? `: ${err8.cause.message}` : "";
-      return c.json(
-        {
-          type: "error",
-          error: {
-            type: "api_error",
-            message: isAbort ? "Client disconnected before the engine responded." : `${err8.message || "Engine unreachable."}${cause}`
-          }
-        },
-        500
-      );
+      const { status: status2, type, message } = classifyFetchError(e, ac);
+      return c.json({ type: "error", error: { type, message } }, status2);
     }
     if (!res.ok || !res.body) {
       d.manager.generationEnd();
@@ -24940,65 +25295,6 @@ function registerGateway(app2, d) {
         asClientStatus(res.status)
       );
     }
-    if (req.stream) {
-      const msgId = `msg_${randomUUID13().replace(/-/g, "")}`;
-      const gen = streamToAnthropic(
-        res.body,
-        modelName,
-        msgId,
-        (u) => {
-          try {
-            d.manager.recordCompletion({
-              inputTokens: u.inputTokens,
-              outputTokens: u.outputTokens,
-              promptTps: u.promptTps,
-              genTps: u.genTps
-            });
-            d.db.recordApiUsage({
-              source: "anthropic",
-              modelKey: req.model ?? null,
-              promptTokens: u.inputTokens,
-              genTokens: u.outputTokens,
-              codeSessionId: anthropicCodeSessionId,
-              durationMs: Date.now() - requestStart,
-              promptTps: u.promptTps,
-              genTps: u.genTps,
-              harness: anthropicHarness
-            });
-          } catch {
-          }
-        },
-        // Live per-request progress for the engine card (prefill % + token count),
-        // so Claude Code traffic shows the same live row as in-app chat.
-        (live) => {
-          try {
-            d.manager.setLiveGen(live);
-          } catch {
-          }
-        },
-        // Coding-activity attribution for terminal-agent sessions — see
-        // observeCodeSessionTurn. Nothing to attribute for any other client.
-        (calls) => {
-          if (!anthropicCodeSessionId) return;
-          try {
-            observeCodeSessionTurn(d, anthropicCodeSessionId, calls);
-          } catch {
-          }
-        }
-      );
-      return streamSSE4(c, async (stream) => {
-        stream.onAbort(() => ac.abort());
-        try {
-          for await (const evt of gen) {
-            await stream.writeSSE({ event: evt.event, data: evt.data });
-          }
-        } finally {
-          ac.abort();
-          d.manager.generationEnd();
-          gateRelease?.();
-        }
-      });
-    }
     try {
       const oaiRes = await res.json();
       recordOpenAiUsage(d, oaiRes, "anthropic", req.model ?? null, anthropicCodeSessionId, Date.now() - requestStart, anthropicHarness);