mixdog 0.9.19 → 0.9.21

package/src/runtime/shared/atomic-file.mjs

@@ -20,6 +20,14 @@ const LOCK_WAIT_CODES = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
 const DEFAULT_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
 const DEFAULT_LOCK_TIMEOUT_MS = 8000;
 
+// Per-process owner identity. A bare pid is not a durable holder identity:
+// after a holder crashes the OS can recycle its pid onto an unrelated live
+// process (or onto THIS process), making a corpse lock look "held by a live
+// pid" — including "held by me" — which starves every waiter. Stamping a
+// random per-instance token alongside the pid lets reclaim/release tell our
+// current lock apart from a same-pid prior/other instance's leftover.
+const _OWNER_TOKEN = randomBytes(12).toString('hex');
+
 function sleepSync(ms) {
   try {
     const buf = new SharedArrayBuffer(4);
@@ -73,55 +81,11 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
         contErr.cause = err;
         throw contErr;
       }
+      // Stale-lock reclaim (shared with the async variant). Covers a dead
+      // owner pid, a same-pid-but-foreign-token corpse from a reused pid, and
+      // a pidless/empty corpse lock; a live foreign holder is never stolen.
       try {
-        const st = statSync(lockPath);
-        // Dead-owner fast path: if the lock's recorded owner pid is gone,
-        // force-release immediately instead of waiting out staleMs. A crashed
-        // owner would otherwise hold the path until the 30s stale window,
-        // starving waiters past the 8s acquire timeout (the restart stall).
-        const ownerPidEarly = _readLockOwnerPid(lockPath);
-        const ownerDead = ownerPidEarly !== null && _pidIsDead(ownerPidEarly);
-        if (ownerDead || Date.now() - st.mtimeMs > staleMs) {
-          // Only steal a stale lock when we can prove the owner is
-          // gone. Reading the pid from the lock file and probing it
-          // with kill(pid, 0) protects a slow-but-live holder from
-          // having its lock yanked out from under it; the next
-          // process that acquires the lock would otherwise race
-          // against the original holder and clobber its write.
-          //
-          // Two-waiter stale-reclaim race: a pure rename "claim" is
-          // not enough. A waiter that proved pid D dead can stall;
-          // another waiter can then remove D and acquire a live lock,
-          // and the stalled waiter would rename that live lock away.
-          // Instead, serialize stale removal behind a tiny pid-stamped
-          // reclaim guard, then re-read the lock while the stale file
-          // is still present at lockPath. If the owner token no longer
-          // matches the pid we proved dead, treat the holder as live
-          // and back off. We never move or unlink a mismatched live-
-          // token file. Guard cleanup is only a best-effort unblocker:
-          // path unlink is not a portable unlink-if-token-still-matches
-          // primitive, so live-lock safety rests on the lockPath token
-          // reverify immediately before the lockPath unlink below.
-          const deadPid = ownerPidEarly;
-          if (ownerDead) {
-            const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
-            if (reclaim !== null) {
-              let reclaimed = false;
-              try {
-                const currentSt = statSync(lockPath);
-                if (ownerDead || Date.now() - currentSt.mtimeMs > staleMs) {
-                  const currentPid = _readLockOwnerPid(lockPath);
-                  if (currentPid === deadPid && _pidIsDead(currentPid)) {
-                    try { unlinkSync(lockPath); reclaimed = true; } catch {}
-                  }
-                }
-              } finally {
-                _releaseReclaimGuard(reclaim);
-              }
-              if (reclaimed) continue;
-            }
-          }
-        }
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
       } catch {}
       if (Date.now() >= deadline) break;
       const base = DEFAULT_BACKOFFS_MS[Math.min(attempt, DEFAULT_BACKOFFS_MS.length - 1)];
@@ -130,10 +94,12 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
       attempt += 1;
       continue;
     }
-    // Stamp our pid into the lock so stale-lock recovery and the
-    // finally-unlink below can verify ownership instead of blindly
-    // deleting whatever lock file happens to be at this path.
-    try { writeFileSync(fd, `${process.pid} ${Date.now()}\n`, 'utf8'); } catch {}
+    // Stamp pid + per-instance token so stale-lock recovery and the
+    // finally-unlink below can verify OUR identity instead of blindly
+    // deleting whatever lock file happens to be at this path. Format
+    // `<pid> <ts> <token>` is a superset of the old `<pid> <ts>`; a
+    // tokenless (old-format) lock is still read as pid-authoritative.
+    try { writeFileSync(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}\n`, 'utf8'); } catch {}
     // For secret-bearing critical sections, the lock file sits beside
     // the secret in the same (shared-home) directory; clamp it owner-only
     // too. Fail-closed: an unenforceable ACL aborts before fn() runs.
@@ -148,7 +114,7 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
       // owner's lock and break mutual exclusion for whoever is
       // queued behind it.
       try {
-        if (_lockOwnedByPid(lockPath, process.pid)) unlinkSync(lockPath);
+        if (_lockOwnedBySelf(lockPath)) unlinkSync(lockPath);
       } catch {}
     }
   }
@@ -189,8 +155,109 @@ function _pidIsDead(pid) {
   }
 }
 
-function _lockOwnedByPid(lockPath, pid) {
-  return _readLockOwnerPid(lockPath) === pid;
+// Full owner identity: pid plus per-instance token. token is null for an
+// old-format (`<pid> <ts>`) lock, in which case callers fall back to
+// pid-authoritative handling so a still-running old-format holder is
+// respected. A read/parse error yields {pid:null, token:null} ("unknown").
+function _readLockOwner(lockPath) {
+  try {
+    const raw = readFileSync(lockPath, 'utf8');
+    const parts = String(raw).trim().split(/\s+/);
+    const pid = Number.parseInt(parts[0], 10);
+    return {
+      pid: Number.isFinite(pid) && pid > 0 ? pid : null,
+      token: parts.length >= 3 ? parts[2] : null,
+    };
+  } catch {
+    return { pid: null, token: null };
+  }
+}
+
+// Is this recorded owner a genuinely live holder?
+//  - pid null (empty/unparseable): not live (unknown owner).
+//  - pid === our pid: treated as LIVE. A foreign/absent token on our own
+//    pid is ambiguous — it may be a recycled-pid corpse, but it may also
+//    be a live sibling worker_thread (which shares process.pid yet owns a
+//    separate _OWNER_TOKEN module instance). We cannot distinguish them
+//    from the token alone, so we never call a same-pid owner instantly
+//    dead; the reclaim path gates a same-pid foreign-token steal behind
+//    stale mtime (see _ownerIsSelfForeign / _tryReclaimStaleLock) so a
+//    live sibling is never yanked, while a real corpse still frees once
+//    mtime goes stale.
+//  - foreign pid: probed with kill(pid, 0); ESRCH ⇒ dead, else live.
+function _ownerIsLive(owner) {
+  if (owner.pid === null) return false;
+  if (owner.pid === process.pid) return true;
+  try {
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code !== 'ESRCH';
+  }
+}
+
+// Our own pid but a foreign (present, non-matching) token: either a
+// recycled-pid corpse or a live sibling worker_thread. Reclaimable only
+// once mtime is past staleMs (handled by the pidless-style stale gate).
+function _ownerIsSelfForeign(owner) {
+  return owner.pid === process.pid
+    && owner.token !== null
+    && owner.token !== _OWNER_TOKEN;
+}
+
+// Release-time guard: unlink only if the lock still carries OUR identity
+// (our pid AND our token). Protects against deleting a lock another
+// instance stole+recreated, and against a same-pid sibling.
+function _lockOwnedBySelf(lockPath) {
+  const owner = _readLockOwner(lockPath);
+  if (owner.pid !== process.pid) return false;
+  return owner.token === null ? true : owner.token === _OWNER_TOKEN;
+}
+
+// Shared stale-lock reclaim used by BOTH withFileLockSync and withFileLock.
+// The whole operation is synchronous; the two variants differ only in how
+// they wait between attempts. Returns true iff lockPath was reclaimed.
+//
+// Reclaim decision table (owner = identity recorded in the lock file):
+//   owner pid DEAD (ESRCH / self-pid+foreign-token corpse) → reclaim
+//   owner pid NULL (empty/unparseable) AND mtime past staleMs → reclaim
+//   owner token MISMATCH on guarded re-read (new holder took over) → back off
+//   owner LIVE (foreign pid alive, or our own current token) → back off
+function _tryReclaimStaleLock(lockPath, staleMs) {
+  let st;
+  try { st = statSync(lockPath); } catch { return false; }
+  const owner = _readLockOwner(lockPath);
+  const stale = Date.now() - st.mtimeMs > staleMs;
+  const dead = owner.pid !== null && !_ownerIsLive(owner);
+  const pidless = owner.pid === null;
+  const selfForeign = _ownerIsSelfForeign(owner);
+  // A dead foreign owner reclaims immediately. A pidless corpse, or a
+  // same-pid foreign-token owner (which may still be a live sibling
+  // worker_thread), reclaims only once mtime is past staleMs; a live
+  // foreign holder is never stolen even after mtime goes stale.
+  if (!dead && !((pidless || selfForeign) && stale)) return false;
+  const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
+  if (reclaim === null) return false;
+  try {
+    let cur;
+    try { cur = statSync(lockPath); } catch { return false; }
+    const curOwner = _readLockOwner(lockPath);
+    // Re-verify the SAME identity (pid AND token) we decided to reclaim is
+    // still present. A reused-pid new holder that grabbed the lock during
+    // the guard window has a different token and is not mistaken for the
+    // corpse — so we never yank a freshly-acquired live lock.
+    if (curOwner.pid !== owner.pid || curOwner.token !== owner.token) return false;
+    const curStale = Date.now() - cur.mtimeMs > staleMs;
+    const curDead = curOwner.pid !== null && !_ownerIsLive(curOwner);
+    const curPidless = curOwner.pid === null;
+    const curSelfForeign = _ownerIsSelfForeign(curOwner);
+    if (curDead || ((curPidless || curSelfForeign) && curStale)) {
+      try { unlinkSync(lockPath); return true; } catch { return false; }
+    }
+    return false;
+  } finally {
+    _releaseReclaimGuard(reclaim);
+  }
 }
 
 function _reclaimGuardIsUnreadableAndStale(guardPath, staleMs) {
@@ -229,7 +296,16 @@ function _tryClearStaleReclaimGuard(guardPath, staleMs) {
     // This is still not a serialized primitive: correctness comes from
     // the lockPath owner-token reverify before unlinking lockPath, not
     // from making guard cleanup itself authoritative.
-    if (_pidIsDead(guardPid)) _unlinkReclaimGuardIfPidMatches(guardPath, guardPid);
+    // A guard whose pid was recycled onto a LIVE process would otherwise
+    // never clear, starving reclaim permanently; so also clear a guard
+    // past staleMs regardless of apparent pid-liveness. Safe because the
+    // guard is best-effort — the lockPath owner-token reverify still gates
+    // the actual lock unlink.
+    let guardStale = false;
+    try { guardStale = Date.now() - statSync(guardPath).mtimeMs > staleMs; } catch {}
+    if (_pidIsDead(guardPid) || guardStale) {
+      _unlinkReclaimGuardIfPidMatches(guardPath, guardPid);
+    }
     return;
   }
   // A crash between openSync('wx') and the pid write can leave an empty
@@ -294,29 +370,11 @@ export async function withFileLock(lockPath, fn, opts = {}) {
         contErr.cause = err;
         throw contErr;
       }
+      // Stale-lock reclaim (shared with the sync variant): dead owner pid,
+      // a same-pid-but-foreign-token corpse from a reused pid, or a
+      // pidless/empty corpse lock. A live foreign holder is never stolen.
       try {
-        const st = statSync(lockPath);
-        if (Date.now() - st.mtimeMs > staleMs) {
-          const deadPid = _readLockOwnerPid(lockPath);
-          if (deadPid !== null && _pidIsDead(deadPid)) {
-            const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
-            if (reclaim !== null) {
-              let reclaimed = false;
-              try {
-                const currentSt = statSync(lockPath);
-                if (Date.now() - currentSt.mtimeMs > staleMs) {
-                  const currentPid = _readLockOwnerPid(lockPath);
-                  if (currentPid === deadPid && _pidIsDead(currentPid)) {
-                    try { unlinkSync(lockPath); reclaimed = true; } catch {}
-                  }
-                }
-              } finally {
-                _releaseReclaimGuard(reclaim);
-              }
-              if (reclaimed) continue;
-            }
-          }
-        }
+        if (_tryReclaimStaleLock(lockPath, staleMs)) continue;
       } catch {}
       if (Date.now() >= deadline) break;
       const base = DEFAULT_BACKOFFS_MS[Math.min(attempt, DEFAULT_BACKOFFS_MS.length - 1)];
@@ -325,14 +383,14 @@ export async function withFileLock(lockPath, fn, opts = {}) {
       attempt += 1;
       continue;
     }
-    try { writeFileSync(fd, `${process.pid} ${Date.now()}\n`, 'utf8'); } catch {}
+    try { writeFileSync(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}\n`, 'utf8'); } catch {}
     try {
       if (opts.secret === true) _enforceOwnerOnlyAclWin32(lockPath);
       return await fn();
     } finally {
       try { closeSync(fd); } catch {}
       try {
-        if (_lockOwnedByPid(lockPath, process.pid)) unlinkSync(lockPath);
+        if (_lockOwnedBySelf(lockPath)) unlinkSync(lockPath);
       } catch {}
     }
   }

package/src/runtime/shared/child-guardian.mjs

@@ -1,18 +1,70 @@
 'use strict';
 
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 
 function positiveInt(value) {
   const n = Number(value);
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
-function guardianScript({ parentPid, childPid, childGroupPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
+// On Windows a windowless, orphaned pwsh->cli chain keeps the immediate parent
+// PID alive after its terminal window is closed, so parent-liveness alone never
+// releases the worker. When the session is genuinely interactive (a TTY), the
+// controlling console window is owned by a host process (conhost.exe) that dies
+// with the terminal — monitoring that PID turns "terminal closed" into a fatal
+// orphan signal. Returns null for non-interactive/service/hidden-console starts
+// (no TTY, or no console window) so those are never treated as terminal loss.
+function detectControllingTerminalPid() {
+  if (process.platform !== 'win32') return null;
+  // Gate on a real TTY: a service/pipe/hidden launch has no controlling
+  // terminal, and probing one there would spawn a transient console whose host
+  // dies immediately — a false "terminal lost" that would kill a healthy worker.
+  const interactive = Boolean(
+    (process.stdin && process.stdin.isTTY) || (process.stdout && process.stdout.isTTY),
+  );
+  if (!interactive) return null;
+  try {
+    const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
+    const powershell = systemRoot + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+    const script = [
+      'Add-Type @"',
+      'using System;',
+      'using System.Runtime.InteropServices;',
+      'public class MixdogTerm {',
+      '  [DllImport("kernel32.dll")] public static extern IntPtr GetConsoleWindow();',
+      '  [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr h, out int pid);',
+      '}',
+      '"@',
+      '$h=[MixdogTerm]::GetConsoleWindow()',
+      'if($h -eq [IntPtr]::Zero){ Write-Output 0 } else { $p=0; [void][MixdogTerm]::GetWindowThreadProcessId($h,[ref]$p); Write-Output $p }',
+    ].join('\n');
+    // NO windowsHide: CREATE_NO_WINDOW gives the probe its own/absent console so
+    // GetConsoleWindow() returns 0 or a foreign hwnd. A plain console app spawned
+    // from a console-attached parent (this runs at the guardian start site, in the
+    // guarded parent) inherits that console with no window flash. Under Windows
+    // Terminal/ConPTY the owner is the tab's conhost (dies on tab close), which is
+    // exactly the pid we want to monitor.
+    const res = spawnSync(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], {
+      timeout: 4000,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const pid = positiveInt(String((res && res.stdout) || '').trim());
+    // Ignore our own PID: that would make the guardian its own kill trigger.
+    if (pid && pid !== process.pid) return pid;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function guardianScript({ parentPid, childPid, childGroupPid, terminalPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
   return `
 const { spawnSync } = require('node:child_process');
 const parentPid = ${JSON.stringify(parentPid)};
 const childPid = ${JSON.stringify(childPid)};
 const childGroupPid = ${JSON.stringify(childGroupPid || childPid)};
+const terminalPid = ${JSON.stringify(terminalPid || 0)};
 const platform = ${JSON.stringify(platform)};
 const pollMs = ${JSON.stringify(pollMs)};
 const orphanGraceMs = ${JSON.stringify(orphanGraceMs)};
@@ -42,7 +94,12 @@ let killing = false;
 let orphanedAt = 0;
 const timer = setInterval(() => {
   if (!alive(childPid)) process.exit(0);
-  if (alive(parentPid)) {
+  // Orphaned when the parent PID dies OR (interactive only) the controlling
+  // terminal's console host dies — the latter catches a windowless pwsh->cli
+  // chain that outlives its closed terminal window. terminalPid is 0 for
+  // non-interactive starts, so those fall back to pure parent-liveness.
+  const terminalLost = terminalPid > 0 && !alive(terminalPid);
+  if (alive(parentPid) && !terminalLost) {
     orphanedAt = 0;
     return;
   }
@@ -77,6 +134,7 @@ export function startChildGuardian({
         parentPid: parent,
         childPid: child,
         childGroupPid: positiveInt(childGroupPid) || child,
+        terminalPid: detectControllingTerminalPid() || 0,
         platform: process.platform,
         pollMs: Math.max(100, Math.floor(Number(pollMs) || 750)),
         orphanGraceMs: Math.max(100, Math.floor(Number(orphanGraceMs) || Number(graceMs) || 3000)),

package/src/session-runtime/boot-profile.mjs

@@ -0,0 +1,36 @@
+import { performance } from 'node:perf_hooks';
+import { envFlag } from './env.mjs';
+
+// Boot-timing profiler + instrumented dynamic import. Extracted verbatim from
+// mixdog-session-runtime.mjs during the facade split. `profiledImport` resolves
+// relative specifiers against this module's directory (src/session-runtime/),
+// which matches runtime-core.mjs, so callers keep passing the same specifiers.
+const BOOT_PROFILE_ENABLED = envFlag('MIXDOG_BOOT_PROFILE');
+const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
+
+export function bootProfile(event, fields = {}) {
+  if (!BOOT_PROFILE_ENABLED) return;
+  const elapsedMs = performance.now() - BOOT_PROFILE_START;
+  const parts = [`[mixdog-boot] +${elapsedMs.toFixed(1)}ms`, event];
+  for (const [key, value] of Object.entries(fields || {})) {
+    if (value === undefined || value === null || value === '') continue;
+    parts.push(`${key}=${String(value).replace(/\s+/g, '_')}`);
+  }
+  try { process.stderr.write(`${parts.join(' ')}\n`); } catch {}
+}
+
+export async function profiledImport(label, spec, { optional = false } = {}) {
+  const startedAt = performance.now();
+  try {
+    const mod = await import(spec);
+    bootProfile(`import:${label}`, { ms: (performance.now() - startedAt).toFixed(1) });
+    return mod;
+  } catch (error) {
+    bootProfile(`import:${label}:failed`, {
+      ms: (performance.now() - startedAt).toFixed(1),
+      error: error?.message || String(error),
+    });
+    if (optional) return null;
+    throw error;
+  }
+}

package/src/session-runtime/channel-config-api.mjs

@@ -0,0 +1,70 @@
+import {
+  channelSetup,
+  deleteSchedule,
+  deleteWebhook,
+  setChannel,
+  saveSchedule,
+  saveWebhook,
+  setScheduleEnabled,
+  setWebhookEnabled,
+  setWebhookConfig,
+} from '../standalone/channel-admin.mjs';
+
+// Channel/webhook/schedule config surface. Extracted verbatim from the runtime
+// API object; the mutating admin helpers are imported directly here and the
+// runtime injects only the closure-owned callbacks (backend flush, channel
+// worker handle, soft reload).
+export function createChannelConfigApi({ flushBackendSave, channels, reloadChannelsSoon }) {
+  return {
+    getChannelSetup() {
+      // Flush a pending debounced backend switch first so setup readers
+      // (Settings → Channel Setting, remote toggles) never observe the
+      // previous backend during the 150ms debounce window.
+      try { flushBackendSave(); } catch {}
+      return channelSetup();
+    },
+    getChannelWorkerStatus() {
+      return channels.status();
+    },
+    setChannel(entry) {
+      const result = setChannel(entry);
+      reloadChannelsSoon();
+      return result;
+    },
+    setWebhookConfig(patch) {
+      const result = setWebhookConfig(patch);
+      reloadChannelsSoon();
+      return result;
+    },
+    saveSchedule(entry) {
+      const result = saveSchedule(entry);
+      reloadChannelsSoon();
+      return result;
+    },
+    deleteSchedule(name) {
+      const result = deleteSchedule(name);
+      reloadChannelsSoon();
+      return result;
+    },
+    setScheduleEnabled(name, enabled) {
+      const result = setScheduleEnabled(name, enabled);
+      reloadChannelsSoon();
+      return result;
+    },
+    saveWebhook(entry) {
+      const result = saveWebhook(entry);
+      reloadChannelsSoon();
+      return result;
+    },
+    deleteWebhook(name) {
+      const result = deleteWebhook(name);
+      reloadChannelsSoon();
+      return result;
+    },
+    setWebhookEnabled(name, enabled) {
+      const result = setWebhookEnabled(name, enabled);
+      reloadChannelsSoon();
+      return result;
+    },
+  };
+}

package/src/session-runtime/context-status.mjs

@@ -0,0 +1,181 @@
+import {
+  estimateRequestReserveTokens,
+  estimateToolSchemaTokens,
+  estimateTranscriptContextUsage,
+  resolveCompactBufferTokens,
+  resolveCompactTriggerTokens,
+  summarizeContextMessages,
+} from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
+
+// Live /context gauge computation + its self-owned memoization cache. Extracted
+// verbatim from the runtime API object; the runtime injects live getters for
+// the mutable session/route/cwd/mode locals. The cache (key + value) is owned
+// here now, so invalidateContextStatusCache() is returned for the runtime to
+// call from the same places it used to clear the inline locals.
+export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMode }) {
+  let contextStatusCacheKey = null;
+  let contextStatusCacheValue = null;
+
+  function contextStatusCacheKeyFor({ messages, tools }) {
+    const session = getSession();
+    const route = getRoute();
+    const compaction = session?.compaction || {};
+    const lastMessage = messages[messages.length - 1] || null;
+    return {
+      session,
+      sessionId: session?.id || null,
+      provider: route.provider,
+      model: route.model,
+      cwd: getCurrentCwd(),
+      mode: getMode(),
+      messages,
+      messageCount: messages.length,
+      lastMessage,
+      lastMessageRole: lastMessage?.role || null,
+      lastMessageContent: lastMessage?.content || null,
+      tools,
+      toolCount: tools.length,
+      contextWindow: session?.contextWindow || null,
+      rawContextWindow: session?.rawContextWindow || null,
+      effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
+      autoCompactTokenLimit: Number(session?.autoCompactTokenLimit || 0),
+      lastContextTokens: Number(session?.lastContextTokens || 0),
+      lastContextTokensUpdatedAt: Number(session?.lastContextTokensUpdatedAt || 0),
+      lastContextTokensStaleAfterCompact: session?.lastContextTokensStaleAfterCompact === true,
+      lastInputTokens: Number(session?.lastInputTokens || 0),
+      lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
+      lastOutputTokens: Number(session?.lastOutputTokens || 0),
+      lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
+      lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+      totalInputTokens: Number(session?.totalInputTokens || 0),
+      totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
+      totalOutputTokens: Number(session?.totalOutputTokens || 0),
+      totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
+      totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+      compactBoundaryTokens: Number(session?.compactBoundaryTokens || 0),
+      compactionBoundaryTokens: Number(compaction.boundaryTokens || 0),
+      compactionTriggerTokens: Number(compaction.triggerTokens || 0),
+      compactionLastChangedAt: Number(compaction.lastChangedAt || 0),
+      compactionLastCompactAt: Number(compaction.lastCompactAt || 0),
+    };
+  }
+
+  function sameContextStatusCacheKey(a, b) {
+    if (!a || !b) return false;
+    for (const key of Object.keys(a)) {
+      if (!Object.is(a[key], b[key])) return false;
+    }
+    return true;
+  }
+
+  function invalidateContextStatusCache() {
+    contextStatusCacheKey = null;
+    contextStatusCacheValue = null;
+  }
+
+  function contextStatus() {
+    const session = getSession();
+    const route = getRoute();
+    // Prefer the in-flight working transcript while a turn is running so the
+    // context gauge reflects LIVE growth (user turn + tool calls/results) as
+    // it accumulates, instead of freezing at the pre-turn committed snapshot.
+    // askSession() sets session.liveTurnMessages for the turn duration and
+    // clears it on commit/cancel/error, after which we fall back to the
+    // authoritative committed transcript.
+    const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
+    const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
+    const tools = Array.isArray(session?.tools) ? session.tools : [];
+    const cacheKey = contextStatusCacheKeyFor({ messages, tools });
+    if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
+      return contextStatusCacheValue;
+    }
+
+    const messageSummary = summarizeContextMessages(messages);
+    const toolSchemaTokens = estimateToolSchemaTokens(tools);
+    const toolSchemaBreakdown = estimateToolSchemaBreakdown(tools);
+    const requestReserveTokens = estimateRequestReserveTokens(tools);
+    const requestOverheadTokens = Math.max(0, requestReserveTokens - toolSchemaTokens);
+    const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
+    const effectiveWindow = Number(session?.contextWindow || rawWindow || 0);
+    const lastContextTokens = Number(session?.lastContextTokens || 0);
+    const estimatedContextTokens = estimateTranscriptContextUsage(messages, tools, {
+      messageCount: messageSummary.count,
+    });
+    const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
+    const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);
+    const lastUsageStale = !!lastContextTokens && (
+      session?.lastContextTokensStaleAfterCompact === true
+      || (compactAt > 0 && usageAt > 0 && usageAt <= compactAt)
+      || (compactAt > 0 && usageAt <= 0)
+    );
+    const compactBoundaryTokens = Number(session?.compactBoundaryTokens || session?.compaction?.boundaryTokens || 0);
+    const displayWindow = compactBoundaryTokens || effectiveWindow;
+    // The transcript estimate is the single source of truth for the displayed
+    // context footprint. Provider-reported input_tokens (lastContextTokens)
+    // swing non-monotonically and are not window-bounded on some providers
+    // (e.g. OpenAI gpt-5.5 Responses API), so they are kept only as secondary
+    // metadata (lastApiRequestTokens / usage.lastContextTokens) and never feed
+    // the gauge numerator.
+    const usedTokens = estimatedContextTokens;
+    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
+    // Use the same shared compact-policy math as manager/loop. Do not trust
+    // persisted trigger telemetry as an independent policy input: it is an
+    // output snapshot and was the source of repeated /context false positives.
+    const compactTriggerTokens = resolveCompactTriggerTokens(session || {}, compactBoundaryTokens) || 0;
+    const compactBufferTokens = compactBoundaryTokens
+      ? Math.max(0, compactBoundaryTokens - compactTriggerTokens)
+      : resolveCompactBufferTokens(compactBoundaryTokens, session?.compaction || {});
+    const value = {
+      sessionId: session?.id || null,
+      provider: route.provider,
+      model: route.model,
+      cwd: getCurrentCwd(),
+      toolMode: getMode(),
+      contextWindow: displayWindow || effectiveWindow || null,
+      effectiveContextWindow: effectiveWindow || null,
+      rawContextWindow: rawWindow || null,
+      effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
+      usedTokens,
+      usedSource: 'estimated',
+      currentEstimatedTokens: estimatedContextTokens,
+      lastApiRequestTokens: lastContextTokens || 0,
+      lastApiRequestStale: lastUsageStale,
+      freeTokens,
+      compaction: {
+        ...(session?.compaction || {}),
+        boundaryTokens: compactBoundaryTokens || null,
+        triggerTokens: compactTriggerTokens || null,
+        bufferTokens: compactBufferTokens || null,
+        currentEstimatedTokens: estimatedContextTokens,
+        lastApiRequestTokens: lastContextTokens || 0,
+        lastApiRequestStale: lastUsageStale,
+      },
+      messages: messageSummary,
+      request: {
+        toolSchemaTokens,
+        toolSchemaBreakdown,
+        requestOverheadTokens,
+        reserveTokens: requestReserveTokens,
+      },
+      usage: {
+        lastInputTokens: Number(session?.lastInputTokens || 0),
+        lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
+        lastOutputTokens: Number(session?.lastOutputTokens || 0),
+        lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
+        lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+        lastContextTokens,
+        totalInputTokens: Number(session?.totalInputTokens || 0),
+        totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
+        totalOutputTokens: Number(session?.totalOutputTokens || 0),
+        totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
+        totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+      },
+    };
+    contextStatusCacheKey = cacheKey;
+    contextStatusCacheValue = value;
+    return value;
+  }
+
+  return { contextStatus, invalidateContextStatusCache };
+}