@wrongstack/core 0.270.0 → 0.272.1

package/dist/index.js

@@ -1,5 +1,5 @@
 import * as crypto2 from 'crypto';
-import { randomBytes, randomUUID, createHash, createCipheriv, createDecipheriv } from 'crypto';
+import { randomBytes, randomUUID, createHash, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
 import * as fsp3 from 'fs/promises';
 import { readFile, readdir, stat, mkdir } from 'fs/promises';
 import * as path3 from 'path';
@@ -9,6 +9,8 @@ import * as net from 'net';
 import * as os6 from 'os';
 import { hostname } from 'os';
 import * as fs3 from 'fs';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
@@ -59,8 +61,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat15 = await fsp3.stat(targetPath);
-      mode = stat15.mode & 511;
+      const stat16 = await fsp3.stat(targetPath);
+      mode = stat16.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -100,8 +102,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat15 = await fsp3.stat(lockPath);
-        if (Date.now() - stat15.mtimeMs > staleMs) {
+        const stat16 = await fsp3.stat(lockPath);
+        if (Date.now() - stat16.mtimeMs > staleMs) {
           await fsp3.unlink(lockPath);
           continue;
         }
@@ -111,7 +113,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
       if (Date.now() - started >= timeoutMs) {
         throw new Error(`Timed out waiting for file lock: ${targetPath}`);
       }
-      await new Promise((resolve18) => setTimeout(resolve18, 25));
+      await new Promise((resolve19) => setTimeout(resolve19, 25));
     }
   }
   try {
@@ -144,7 +146,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve18) => setTimeout(resolve18, delays[i]));
+      await new Promise((resolve19) => setTimeout(resolve19, delays[i]));
     }
   }
   throw lastErr;
@@ -430,11 +432,11 @@ var init_session_registry = __esm({
        */
       async breakStaleLock(lockPath) {
         try {
-          const [stat15, content] = await Promise.all([
+          const [stat16, content] = await Promise.all([
             fsp3.stat(lockPath),
             fsp3.readFile(lockPath, "utf8").catch(() => "")
           ]);
-          const ageMs = Date.now() - stat15.mtimeMs;
+          const ageMs = Date.now() - stat16.mtimeMs;
           const ownerPid = Number.parseInt(content.trim(), 10);
           const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
           if (ownerDead || ageMs > STALE_LOCK_MS) {
@@ -477,9 +479,9 @@ var init_session_registry = __esm({
           for (const name of await fsp3.readdir(dir)) {
             const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
             if (!isTemp) continue;
-            const stat15 = await fsp3.stat(path3.join(dir, name)).catch(() => null);
-            if (!stat15) continue;
-            if (now - stat15.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat15.mtimeMs });
+            const stat16 = await fsp3.stat(path3.join(dir, name)).catch(() => null);
+            if (!stat16) continue;
+            if (now - stat16.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat16.mtimeMs });
           }
           stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
           await Promise.all(
@@ -562,6 +564,25 @@ function looksSecret(name) {
   }
   return false;
 }
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
 function buildChildEnv(optsOrSessionId) {
   const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
   const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
@@ -582,11 +603,17 @@ function buildChildEnv(optsOrSessionId) {
       continue;
     }
     const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
     if (ALLOWED_KEYS.has(upper)) {
       out[k] = v;
       continue;
     }
     if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
     if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
     // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
     // vault). Forwarding keeps child wstack processes — e.g. ones spawned
@@ -676,7 +703,7 @@ function envFlag(value) {
   return !/^(0|false|no|off)$/i.test(value.trim());
 }
 var COLOR = isColorTty();
-var wrap = (open7, close) => (s) => COLOR ? `\x1B[${open7}m${s}\x1B[${close}m` : s;
+var wrap = (open10, close) => (s) => COLOR ? `\x1B[${open10}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -727,9 +754,9 @@ async function updateJsonObjectFile(filePath, mutator) {
   await writeJsonObjectFile(filePath, next);
   return next;
 }
-function getJsonPath(root, path48) {
+function getJsonPath(root, path51) {
   let current = root;
-  for (const segment of path48) {
+  for (const segment of path51) {
     if (typeof segment === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[segment];
@@ -740,13 +767,13 @@ function getJsonPath(root, path48) {
   }
   return current;
 }
-function setJsonPath(root, path48, value) {
-  if (path48.length === 0) {
+function setJsonPath(root, path51, value) {
+  if (path51.length === 0) {
     if (!isJsonObject(value)) throw new Error("Root config value must be an object");
     return value;
   }
-  const parent = ensureJsonParent(root, path48);
-  const leaf = lastPathSegment(path48);
+  const parent = ensureJsonParent(root, path51);
+  const leaf = lastPathSegment(path51);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent)) throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
     parent[leaf] = value;
@@ -756,10 +783,10 @@ function setJsonPath(root, path48, value) {
   }
   return root;
 }
-function removeJsonPath(root, path48) {
-  if (path48.length === 0) return false;
-  const parent = getJsonPath(root, path48.slice(0, -1));
-  const leaf = lastPathSegment(path48);
+function removeJsonPath(root, path51) {
+  if (path51.length === 0) return false;
+  const parent = getJsonPath(root, path51.slice(0, -1));
+  const leaf = lastPathSegment(path51);
   if (typeof leaf === "number") {
     if (!Array.isArray(parent) || leaf < 0 || leaf >= parent.length) return false;
     parent.splice(leaf, 1);
@@ -769,27 +796,27 @@ function removeJsonPath(root, path48) {
   delete parent[leaf];
   return true;
 }
-async function setJsonPathInFile(filePath, path48, value) {
-  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path48, value));
+async function setJsonPathInFile(filePath, path51, value) {
+  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path51, value));
 }
-async function removeJsonPathInFile(filePath, path48) {
+async function removeJsonPathInFile(filePath, path51) {
   return updateJsonObjectFile(filePath, (config) => {
-    removeJsonPath(config, path48);
+    removeJsonPath(config, path51);
   });
 }
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastPathSegment(path48) {
-  const segment = path48[path48.length - 1];
+function lastPathSegment(path51) {
+  const segment = path51[path51.length - 1];
   if (segment === void 0) throw new Error("Invalid empty JSON path");
   return segment;
 }
-function ensureJsonParent(root, path48) {
+function ensureJsonParent(root, path51) {
   let current = root;
-  for (let i = 0; i < path48.length - 1; i += 1) {
-    const segment = path48[i];
-    const nextSegment = path48[i + 1];
+  for (let i = 0; i < path51.length - 1; i += 1) {
+    const segment = path51[i];
+    const nextSegment = path51[i + 1];
     if (segment === void 0) throw new Error("Invalid empty JSON path segment");
     const nextContainer = typeof nextSegment === "number" ? [] : {};
     if (typeof segment === "number") {
@@ -808,6 +835,9 @@ var MAX_TOOL_CALLS = 80;
 var MAX_FACTS = 40;
 var MAX_ERRORS = 20;
 var MAX_DIGEST_CHARS = 4e3;
+var RECENT_TOOL_CALL_SCAN_LIMIT = 20;
+var EXTRACT_CONTENT_CAP_CHARS = 1e4;
+var EXTRACT_ERROR_TAIL_LINES = 200;
 var WRITE_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "replace", "patch"]);
 var READ_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob", "ls", "tree"]);
 function createContextEvidenceState() {
@@ -833,8 +863,9 @@ function recordUserIntentEvidence(ctx, text) {
 }
 function recordToolOutputEvidence(ctx, input) {
   const state = ensureEvidence(ctx);
-  const files = extractFiles(ctx, input.toolName, input.input, input.content);
-  const symbols = extractSymbols(input.content, input.input);
+  const scanContent = input.content.length > EXTRACT_CONTENT_CAP_CHARS ? input.content.slice(0, EXTRACT_CONTENT_CAP_CHARS) : input.content;
+  const files = extractFiles(ctx, input.toolName, input.input, scanContent);
+  const symbols = extractSymbols(scanContent, input.input);
   const commands = extractCommands(input.toolName, input.input);
   const errors = extractErrors(input.content);
   const summary = summarizeToolOutput(input.toolName, input.input, input.content, {
@@ -877,7 +908,8 @@ function markAssistantReferencedEvidence(ctx, text) {
   const state = ensureEvidence(ctx);
   const haystack = text.toLowerCase();
   if (!haystack.trim()) return;
-  for (const tool of state.toolCalls) {
+  const recent = state.toolCalls.length > RECENT_TOOL_CALL_SCAN_LIMIT ? state.toolCalls.slice(-RECENT_TOOL_CALL_SCAN_LIMIT) : state.toolCalls;
+  for (const tool of recent) {
     if (!metadataReferencedByText(tool, haystack)) continue;
     tool.status = "referenced";
     tool.referenceCount++;
@@ -1032,7 +1064,8 @@ function extractCommands(toolName, input) {
   return [command.slice(0, 220)];
 }
 function extractErrors(content) {
-  const lines = content.split(/\r?\n/);
+  const allLines = content.split(/\r?\n/);
+  const lines = allLines.length > EXTRACT_ERROR_TAIL_LINES ? allLines.slice(-EXTRACT_ERROR_TAIL_LINES) : allLines;
   const errors = [];
   for (const line of lines) {
     if (!/\b(error|exception|failed|failure|fatal|panic|timeout|denied|enoent|eacces|eperm|typeerror|syntaxerror)\b/i.test(line)) continue;
@@ -1441,8 +1474,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat15 = await fsp3.stat(full);
-          if (stat15.isDirectory()) await walk3(full, rest);
+          const stat16 = await fsp3.stat(full);
+          if (stat16.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -1459,8 +1492,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat15 = await fsp3.stat(full);
-          if (stat15.isDirectory()) await walk3(full, rest);
+          const stat16 = await fsp3.stat(full);
+          if (stat16.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -1476,6 +1509,7 @@ function escapeRegex(s) {
 }
 var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
 var CACHE_MAX_SIZE = 2e3;
+var NEVER_MATCH = /[^\s\S]/;
 function getCachedGlob(pattern) {
   const cached = COMPILED_GLOB_CACHE.get(pattern);
   if (cached) return cached;
@@ -1485,7 +1519,12 @@ function getCachedGlob(pattern) {
       COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
     }
   }
-  const re = compileGlob(pattern);
+  let re;
+  try {
+    re = compileGlob(pattern);
+  } catch {
+    re = NEVER_MATCH;
+  }
   COMPILED_GLOB_CACHE.set(pattern, re);
   return re;
 }
@@ -1733,11 +1772,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path48, errors) {
+function walk(value, schema, path51, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path48 || "<root>",
+        path: path51 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1746,7 +1785,7 @@ function walk(value, schema, path48, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path48 || "<root>",
+        path: path51 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -1756,20 +1795,20 @@ function walk(value, schema, path48, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path48, req), message: "required property missing" });
+        errors.push({ path: joinPath(path51, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path48, key), errors);
+          walk(obj[key], subSchema, joinPath(path51, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path48}[${i}]`, errors);
+      walk(value[i], schema.items, `${path51}[${i}]`, errors);
     }
   }
 }
@@ -2168,7 +2207,7 @@ function stripSingleLineComments(s) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 
 // src/utils/string.ts
@@ -2431,18 +2470,20 @@ var MODEL_FAMILY_RATIO = {
   deepseek: 3.5
 };
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var _estimateCacheOrder = [];
 var ESTIMATE_CACHE_MAX_SIZE = 5e4;
 function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    for (const k of ESTIMATE_CACHE.keys()) {
-      if (ESTIMATE_CACHE.size <= Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) break;
-      ESTIMATE_CACHE.delete(k);
+    while (ESTIMATE_CACHE.size > Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) {
+      const oldest = _estimateCacheOrder.shift();
+      if (oldest !== void 0) ESTIMATE_CACHE.delete(oldest);
     }
   }
   const estimate = compute(key);
   ESTIMATE_CACHE.set(key, estimate);
+  _estimateCacheOrder.push(key);
   return estimate;
 }
 function estimateToolInputTokens(input) {
@@ -4463,11 +4504,88 @@ var ALGO = "aes-256-gcm";
 var KEY_FILE_MODE = 384;
 var KEY_FILE_MAGIC = Buffer.from("WSKV", "ascii");
 var VERSIONED_KEY_FILE_SIZE = KEY_FILE_MAGIC.length + 1 + KEY_BYTES;
+var KEK_MAGIC = Buffer.from("WSKW", "ascii");
+var KEK_SALT_BYTES = 16;
+var WRAPPED_KEY_FILE_SIZE = KEK_MAGIC.length + 1 + KEK_SALT_BYTES + IV_BYTES + TAG_BYTES + KEY_BYTES;
+var SCRYPT_N = 1 << 15;
+var SCRYPT_R = 8;
+var SCRYPT_P = 1;
+var SCRYPT_MAXMEM = 64 * 1024 * 1024;
+function getVaultPassphrase() {
+  const v = process.env["WRONGSTACK_VAULT_PASSPHRASE"];
+  return v && v.length > 0 ? v : void 0;
+}
+function isWrappedKeyFile(buf) {
+  return buf.length === WRAPPED_KEY_FILE_SIZE && buf.subarray(0, KEK_MAGIC.length).equals(KEK_MAGIC);
+}
+function deriveKEK(passphrase, salt) {
+  return scryptSync(passphrase, salt, KEY_BYTES, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: SCRYPT_MAXMEM
+  });
+}
+function wrapDataKey(dataKey, keyVersion, passphrase) {
+  const salt = randomBytes(KEK_SALT_BYTES);
+  const iv = randomBytes(IV_BYTES);
+  const kek = deriveKEK(passphrase, salt);
+  const cipher = createCipheriv(ALGO, kek, iv);
+  const ct = Buffer.concat([cipher.update(dataKey), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const out = Buffer.alloc(WRAPPED_KEY_FILE_SIZE);
+  let off = 0;
+  KEK_MAGIC.copy(out, off);
+  off += KEK_MAGIC.length;
+  out[off] = keyVersion & 255;
+  off += 1;
+  salt.copy(out, off);
+  off += KEK_SALT_BYTES;
+  iv.copy(out, off);
+  off += IV_BYTES;
+  tag.copy(out, off);
+  off += TAG_BYTES;
+  ct.copy(out, off);
+  return out;
+}
+function unwrapDataKey(buf, keyFile) {
+  const passphrase = getVaultPassphrase();
+  if (!passphrase) {
+    throw new ConfigError({
+      message: `SecretVault: key file ${keyFile} is passphrase-protected \u2014 set the WRONGSTACK_VAULT_PASSPHRASE environment variable to unlock it.`,
+      code: ERROR_CODES.CONFIG_INVALID,
+      context: { keyFile }
+    });
+  }
+  let off = KEK_MAGIC.length;
+  const version = buf[off];
+  off += 1;
+  const salt = buf.subarray(off, off + KEK_SALT_BYTES);
+  off += KEK_SALT_BYTES;
+  const iv = buf.subarray(off, off + IV_BYTES);
+  off += IV_BYTES;
+  const tag = buf.subarray(off, off + TAG_BYTES);
+  off += TAG_BYTES;
+  const ct = buf.subarray(off, off + KEY_BYTES);
+  const kek = deriveKEK(passphrase, salt);
+  const decipher = createDecipheriv(ALGO, kek, iv);
+  decipher.setAuthTag(tag);
+  try {
+    const key = Buffer.concat([decipher.update(ct), decipher.final()]);
+    return { key: Buffer.from(key), version };
+  } catch {
+    throw new ConfigError({
+      message: `SecretVault: failed to unlock key file ${keyFile} \u2014 wrong WRONGSTACK_VAULT_PASSPHRASE (key unwrap authentication failed).`,
+      code: ERROR_CODES.CONFIG_INVALID,
+      context: { keyFile }
+    });
+  }
+}
 function checkKeyFilePermissions(keyFile) {
   if (process.platform === "win32") return;
   try {
-    const stat15 = fs3.statSync(keyFile);
-    const actualMode = stat15.mode & 511;
+    const stat16 = fs3.statSync(keyFile);
+    const actualMode = stat16.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       console.warn(JSON.stringify({
         level: "warn",
@@ -4555,25 +4673,56 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
-    KEY_FILE_MAGIC.copy(keyFileBuf, 0);
-    keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
-    newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
     fs3.mkdirSync(path3.dirname(this.keyFile), { recursive: true });
-    fs3.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    const passphrase = getVaultPassphrase();
+    if (passphrase) {
+      fs3.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
+    } else {
+      const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
+      KEY_FILE_MAGIC.copy(keyFileBuf, 0);
+      keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
+      newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
+      fs3.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    }
     checkKeyFilePermissions(this.keyFile);
     this.key = newKey;
     this._keyVersion = newVersion;
     return { oldVersion, newVersion };
   }
+  /**
+   * If WRONGSTACK_VAULT_PASSPHRASE is set but the key on disk is still stored
+   * unwrapped (legacy v1 / versioned v2), re-write it in passphrase-wrapped (v3)
+   * form. The data key is preserved, so all existing ciphertext keeps
+   * decrypting. Best-effort: a write failure leaves the working unwrapped file
+   * in place and is not fatal to load.
+   */
+  migrateToWrappedIfPassphrase() {
+    const passphrase = getVaultPassphrase();
+    if (!passphrase || !this.key) return;
+    try {
+      fs3.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
+        mode: 384
+      });
+      checkKeyFilePermissions(this.keyFile);
+    } catch {
+    }
+  }
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
       const buf = fs3.readFileSync(this.keyFile);
+      if (isWrappedKeyFile(buf)) {
+        const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
+        this.key = key2;
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
         checkKeyFilePermissions(this.keyFile);
+        this.migrateToWrappedIfPassphrase();
         return this.key;
       }
       if (buf.length === VERSIONED_KEY_FILE_SIZE) {
@@ -4597,6 +4746,7 @@ var DefaultSecretVault = class {
         this.key = Buffer.from(key2);
         this._keyVersion = version;
         checkKeyFilePermissions(this.keyFile);
+        this.migrateToWrappedIfPassphrase();
         return this.key;
       }
       throw new ConfigError({
@@ -4609,11 +4759,20 @@ var DefaultSecretVault = class {
     }
     fs3.mkdirSync(path3.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
+    const passphrase = getVaultPassphrase();
+    const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
     try {
-      fs3.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
+      fs3.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       const buf = fs3.readFileSync(this.keyFile);
+      if (isWrappedKeyFile(buf)) {
+        const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
+        this.key = winnerKey;
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
@@ -5217,17 +5376,9 @@ function findPreserveStart(messages, preserveK) {
     const prev = messages[preserveStart - 1];
     if (!first || !prev || first.role !== "user" || prev.role !== "assistant") break;
     if (typeof first.content === "string" || typeof prev.content === "string") break;
-    const resultIds = /* @__PURE__ */ new Set();
-    for (const block of first.content) {
-      pairRepairInnerIterations++;
-      if (block.type === "tool_result") resultIds.add(block.tool_use_id);
-    }
-    if (resultIds.size === 0) break;
-    const hasMatchingUse = prev.content.some((block) => {
-      pairRepairInnerIterations++;
-      return block.type === "tool_use" && resultIds.has(block.id);
-    });
-    if (!hasMatchingUse) break;
+    const pairCheck = hasMatchingToolPair(first.content, prev.content);
+    pairRepairInnerIterations += pairCheck.iterations;
+    if (!pairCheck.matched) break;
     preserveStart--;
   }
   if (compactionDebugEnabled()) {
@@ -5246,9 +5397,34 @@ function findPreserveStart(messages, preserveK) {
   }
   return preserveStart;
 }
+function hasMatchingToolPair(resultContent, useContent) {
+  let iterations = 0;
+  let firstResultId;
+  let resultIds;
+  for (const block of resultContent) {
+    iterations++;
+    if (block.type !== "tool_result") continue;
+    if (firstResultId === void 0) {
+      firstResultId = block.tool_use_id;
+    } else {
+      resultIds ??= /* @__PURE__ */ new Set([firstResultId]);
+      resultIds.add(block.tool_use_id);
+    }
+  }
+  if (firstResultId === void 0) return { matched: false, iterations };
+  for (const block of useContent) {
+    iterations++;
+    if (block.type !== "tool_use") continue;
+    if (resultIds ? resultIds.has(block.id) : block.id === firstResultId) {
+      return { matched: true, iterations };
+    }
+  }
+  return { matched: false, iterations };
+}
 function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
   let hasOversized = false;
+  let firstOversizedIndex = -1;
   let fastPathIterations = 0;
   let fastPathInnerIterations = 0;
   for (let i = 0; i < preserveStart && !hasOversized; i++) {
@@ -5260,6 +5436,7 @@ function eliseOldToolResults(messages, opts) {
       const oversized = b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold || b.type === "tool_use" && estimateToolInputTokens(b.input) >= opts.eliseThreshold;
       if (oversized) {
         hasOversized = true;
+        firstOversizedIndex = i;
         break;
       }
     }
@@ -5282,26 +5459,29 @@ function eliseOldToolResults(messages, opts) {
   let changed = false;
   let fullPassIterations = 0;
   let fullPassInnerIterations = 0;
-  const next = new Array(messages.length);
-  for (let i = 0; i < messages.length; i++) {
+  let next;
+  for (let i = firstOversizedIndex; i < preserveStart; i++) {
     fullPassIterations++;
     const msg = messages[i];
-    if (i >= preserveStart || !msg || !Array.isArray(msg.content)) {
-      next[i] = msg;
-      continue;
-    }
+    if (!msg || !Array.isArray(msg.content)) continue;
     const original = msg.content;
-    const newContent = original.map((b) => {
+    let newContent;
+    for (let idx = 0; idx < original.length; idx++) {
+      fullPassInnerIterations++;
+      const b = original[idx];
+      if (!b) continue;
       if (b.type === "tool_use") {
         const tokens2 = estimateToolInputTokens(b.input);
-        if (tokens2 < opts.eliseThreshold) return b;
+        if (tokens2 < opts.eliseThreshold) continue;
         const elidedInput = summarizeToolUseInputElision(b, tokens2);
         saved += Math.max(0, tokens2 - estimateToolInputTokens(elidedInput));
-        return { ...b, input: elidedInput };
+        newContent ??= original.slice();
+        newContent[idx] = { ...b, input: elidedInput };
+        continue;
       }
-      if (b.type !== "tool_result") return b;
+      if (b.type !== "tool_result") continue;
       const tokens = estimateToolResultTokens(b.content);
-      if (tokens < opts.eliseThreshold) return b;
+      if (tokens < opts.eliseThreshold) continue;
       saved += tokens;
       const elided = {
         type: "tool_result",
@@ -5309,15 +5489,14 @@ function eliseOldToolResults(messages, opts) {
         content: summarizeToolResultElision(b, tokens),
         is_error: b.is_error
       };
-      return elided;
-    });
-    if (newContent.every((b, idx) => b === original[idx])) {
-      next[i] = msg;
-    } else {
+      newContent ??= original.slice();
+      newContent[idx] = elided;
+    }
+    if (newContent) {
+      next ??= messages.slice();
       next[i] = { ...msg, content: newContent };
       changed = true;
     }
-    fullPassInnerIterations += original.length;
     if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
@@ -5344,7 +5523,7 @@ function eliseOldToolResults(messages, opts) {
     tokensSaved: saved,
     changed
   });
-  return { messages: changed ? next : messages, saved, changed };
+  return { messages: changed && next ? next : messages, saved, changed };
 }
 function summarizeToolUseInputElision(block, tokens) {
   const fields = {};
@@ -6096,6 +6275,7 @@ var DefaultSecretScrubber = class {
 // src/models/models-registry.ts
 init_atomic_write();
 var DEFAULT_URL = "https://models.dev/api.json";
+var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var DEFAULT_REFRESH_TIMEOUT_MS = 15e3;
 var FAMILY_BY_NPM = {
@@ -6141,7 +6321,7 @@ var DefaultModelsRegistry = class {
   overlayCacheFile;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
-    this.url = opts.url ?? DEFAULT_URL;
+    this.url = opts.url ?? process.env[ENV_URL_KEY] ?? DEFAULT_URL;
     this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
     this.fetchImpl = opts.fetchImpl ?? fetch;
     this.seed = opts.seed;
@@ -6186,6 +6366,10 @@ var DefaultModelsRegistry = class {
       const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
         this.fetchedAt = new Date(cached.fetchedAt);
+        const ageSeconds = Math.floor((Date.now() - this.fetchedAt.getTime()) / 1e3);
+        console.warn(
+          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`
+        );
         return cached.payload;
       }
       if (overlayAvailable) {
@@ -6271,7 +6455,13 @@ var DefaultModelsRegistry = class {
       return json;
     } catch {
       const cached = await this.readCacheAt(this.overlayCacheFile);
-      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) return cached.payload;
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
+        const ageSeconds = Math.floor((Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3);
+        console.warn(
+          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`
+        );
+        return cached.payload;
+      }
       return void 0;
     }
   }
@@ -6368,6 +6558,16 @@ var DefaultModelsRegistry = class {
     return path3.resolve(this.cacheFile);
   }
 };
+function formatAge(seconds) {
+  if (seconds < 60) return "<1m";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor(seconds % 3600 / 60);
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+  }
+  return `${Math.floor(seconds / 86400)}d`;
+}
 function hasEntries(payload) {
   return payload !== void 0 && Object.keys(payload).length > 0;
 }
@@ -6863,7 +7063,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -6882,7 +7082,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve18,
+        resolve: resolve19,
         reject,
         timer
       });
@@ -8176,6 +8376,8 @@ function generateSessionId(startedAt, model) {
   const modelPart = model ? `_${sanitizeModel(model)}` : "";
   return `${date}/${time}Z${modelPart}_${suffix}`;
 }
+
+// src/storage/session-store.ts
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
@@ -8193,6 +8395,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   _loadCache = /* @__PURE__ */ new Map();
   _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
+  static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
@@ -8209,7 +8412,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this._loadCache.clear();
     }
   }
-  // ── Storage event helpers ───────────────────────────────────────────────────
+  // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
       sessionId,
@@ -8324,7 +8527,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         this.events,
         {
           resumed: true,
-          // Shard directory (sessions/<date>/) — must match create() so the
+          // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
           dir: path3.dirname(file),
@@ -8354,9 +8557,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp3.stat(file);
-      const stat15 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat16 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat15.mtimeMs && cached.size === stat15.size) {
+      if (cached && cached.mtimeMs === stat16.mtimeMs && cached.size === stat16.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -8365,26 +8568,100 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const raw = await fsp3.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
+      let sessionStartEvent;
+      let sessionEndEvent;
+      let sessionModel;
+      let sessionProvider;
+      let sessionPendingToolUses;
+      const messages = [];
+      const openToolUses = /* @__PURE__ */ new Set();
+      let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
           if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            events.push(parsed);
+            const ev = parsed;
+            events.push(ev);
+            if (ev.type === "session_start" && !sessionStartEvent) {
+              sessionStartEvent = ev;
+              sessionModel = ev.model;
+              sessionProvider = ev.provider;
+            }
+            if (ev.type === "session_end") {
+              sessionEndEvent = ev;
+              sessionPendingToolUses = ev.pendingToolUses;
+            }
+            if (ev.type === "user_input") {
+              openToolUses.clear();
+              messages.push({ role: "user", content: ev.content, ts: ev.ts });
+            } else if (ev.type === "llm_response") {
+              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+              for (const b of ev.content) {
+                if (b.type === "tool_use") openToolUses.add(b.id);
+              }
+              usage = {
+                input: usage.input + (ev.usage.input ?? 0),
+                output: usage.output + (ev.usage.output ?? 0),
+                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+              };
+            } else if (ev.type === "tool_result") {
+              if (!openToolUses.has(ev.id)) {
+                this.events?.emit("session.damaged", {
+                  sessionId: id,
+                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
+                });
+                continue;
+              }
+              openToolUses.delete(ev.id);
+              const resultBlock = {
+                type: "tool_result",
+                tool_use_id: ev.id,
+                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
+                is_error: ev.isError
+              };
+              const last = messages[messages.length - 1];
+              const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
+              if (lastIsToolResultUser && Array.isArray(last.content)) {
+                last.content.push(resultBlock);
+              } else {
+                messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
+              }
+            }
           }
         } catch {
         }
       }
-      const meta = this.metaFromEvents(id, events);
-      const { messages, usage } = this.replay(events, id);
+      if (openToolUses.size > 0) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+        });
+      }
+      const repaired = repairToolUseAdjacency(messages);
+      if (repaired.report.changed) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+        });
+      }
+      const meta = {
+        id,
+        startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        endedAt: sessionEndEvent?.ts,
+        model: sessionModel,
+        provider: sessionProvider,
+        pendingToolUses: sessionPendingToolUses
+      };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
       if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
         const oldest = this._loadCache.keys().next().value;
         if (oldest !== void 0) {
           this._loadCache.delete(oldest);
         }
       }
-      this._loadCache.set(id, { mtimeMs: stat15.mtimeMs, size: stat15.size, data });
+      this._loadCache.set(id, { mtimeMs: stat16.mtimeMs, size: stat16.size, data });
       return data;
     } catch (err) {
       outcome = "failure";
@@ -8415,20 +8692,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
         });
         return indexed.slice(0, limit);
       }
-      const ids = await this.collectSessionIds(this.dir);
-      const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
-      const out = sessions.filter((s) => s !== null);
-      out.sort((a, b) => {
-        if (a.startedAt < b.startedAt) return 1;
-        if (a.startedAt > b.startedAt) return -1;
-        return a.id.localeCompare(b.id);
-      });
-      return out.slice(0, limit);
+      return await this.listFromDirectoryScan(limit);
     } catch {
       return [];
     }
   }
-  // ── Session index (_index.jsonl) ─────────────────────────────────────────
+  // ── Session index (_index.jsonl) ─────────────────────────────────────────
   //
   // One JSON line per closed session, appended atomically on close().
   // When a session is deleted, a tombstone {action:"delete",id:"..."} is
@@ -8494,15 +8763,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat15;
+    let stat16;
     try {
       const s = await fsp3.stat(this.indexFile);
-      stat15 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat16 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat15.mtimeMs && this._indexCache.size === stat15.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat16.mtimeMs && this._indexCache.size === stat16.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -8530,7 +8799,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       }
     }
     const summaries = Array.from(seen.values());
-    this._indexCache = { ...stat15, summaries };
+    this._indexCache = { ...stat16, summaries };
     return [...summaries];
   }
   /**
@@ -8548,46 +8817,105 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this._indexCache = null;
     return valid.length;
   }
+  async listFromDirectoryScan(limit) {
+    const refs = await this.collectSessionFiles(this.dir);
+    const candidates = await mapWithConcurrency(
+      refs,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (ref) => {
+        const manifest = await this.readSummaryManifest(ref.id);
+        if (manifest) return { summary: manifest, needsBackfill: false };
+        const summary = await this.summaryHeaderFor(ref);
+        return summary ? { summary, needsBackfill: true } : null;
+      }
+    );
+    const out = candidates.filter((s) => s !== null);
+    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
+    const selected = out.slice(0, limit);
+    const summaries = await mapWithConcurrency(
+      selected,
+      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
+      async (candidate) => {
+        if (!candidate.needsBackfill) return candidate.summary;
+        return await this.summaryFor(candidate.summary.id).catch(() => candidate.summary);
+      }
+    );
+    return summaries.filter((s) => s !== null);
+  }
+  async collectSessionFiles(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const dirEntries = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
+      if (entry.isDirectory()) {
+        dirEntries.push(entry);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        const id = prefix ? `${prefix}/${base}` : base;
+        files.push({ id, filePath: path3.join(dir, entry.name) });
+      }
+    }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path3.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childFileArrays.flat(), ...files];
+  }
   /** Recursively collect session IDs from date-shard subdirectories.
-   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
    *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
    *  sub-directories that belong to fleet/subagent sessions. */
   async collectSessionIds(dir, prefix = "", depth = 0) {
-    const ids = [];
     let entries;
     try {
       entries = await fsp3.readdir(dir, { withFileTypes: true });
     } catch {
-      return ids;
+      return [];
     }
+    const dirEntries = [];
+    const fileIds = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
       if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
         continue;
       if (entry.isDirectory()) {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        ids.push(...await this.collectSessionIds(path3.join(dir, entry.name), childPrefix, depth + 1));
+        dirEntries.push(entry);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
-        ids.push(prefix ? `${prefix}/${base}` : base);
+        fileIds.push(prefix ? `${prefix}/${base}` : base);
       }
     }
-    return ids;
+    const childIdArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionIds(path3.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childIdArrays.flat(), ...fileIds];
   }
   async summaryFor(id) {
     const manifest = this.sessionPath(id, ".summary.json");
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    const fromManifest = await this.readSummaryManifest(id, t0);
+    if (fromManifest) return fromManifest;
     try {
-      const raw = await fsp3.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
-      return JSON.parse(raw);
-    } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat15 = await fsp3.stat(full);
-      const summary = await this.summarize(id, stat15.mtime.toISOString());
+      const stat16 = await fsp3.stat(full);
+      const summary = await this.summarize(id, stat16.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -8600,9 +8928,81 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }));
       });
       outcome = "failure";
-      errorMsg = "summary fallback \u2014 manifest rebuilt";
+      errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
       this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
       return summary;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  async readSummaryManifest(id, startTime = Date.now()) {
+    const manifest = this.sessionPath(id, ".summary.json");
+    try {
+      const raw = await fsp3.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async summaryHeaderFor(ref) {
+    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      const stat16 = await fsp3.stat(ref.filePath);
+      if (!stat16.isFile()) {
+        return {
+          id: ref.id,
+          title: "(damaged)",
+          startedAt: stat16.mtime.toISOString(),
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0
+        };
+      }
+      mtime = stat16.mtime.toISOString();
+    } catch {
+      return null;
+    }
+    try {
+      for await (const event of this.iterSessionEvents(ref.filePath)) {
+        if (event.type === "session_start") {
+          return {
+            id: ref.id,
+            title: "(empty session)",
+            startedAt: event.ts,
+            model: event.model ?? "unknown",
+            provider: event.provider ?? "unknown",
+            tokenTotal: 0
+          };
+        }
+      }
+      return {
+        id: ref.id,
+        title: "(empty session)",
+        startedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    } catch {
+      return {
+        id: ref.id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
   }
   /**
@@ -8669,8 +9069,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path3.join(dir, name);
       try {
-        const stat15 = await fsp3.stat(jsonlPath);
-        if (stat15.mtimeMs >= cutoff) return;
+        const stat16 = await fsp3.stat(jsonlPath);
+        if (stat16.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -8727,39 +9127,62 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async summarize(id, mtime) {
     try {
-      const data = await this.load(id);
-      const firstUser = data.events.find((e) => e.type === "user_input");
-      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      const file = this.sessionPath(id, ".jsonl");
+      let title = "(empty session)";
+      let startedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+      let endedAt;
+      let model = "unknown";
+      let provider = "unknown";
+      let tokenIn = 0;
+      let tokenOut = 0;
       let iterationCount = 0;
       let toolCallCount = 0;
       let toolErrorCount = 0;
       let fileChangeCount = 0;
       const toolBreakdown = {};
       let outcome;
-      const lastEvent = data.events[data.events.length - 1];
-      for (const e of data.events) {
-        if (e.type === "in_flight_start") iterationCount++;
+      let lastEventType;
+      let hasError = false;
+      let sawStart = false;
+      for await (const e of this.iterSessionEvents(file)) {
+        lastEventType = e.type;
+        if (e.type === "session_start") {
+          if (!sawStart) {
+            sawStart = true;
+            startedAt = e.ts;
+            model = e.model ?? "unknown";
+            provider = e.provider ?? "unknown";
+          }
+        } else if (e.type === "session_end") {
+          endedAt = e.ts;
+        } else if (e.type === "user_input") {
+          if (title === "(empty session)") title = userInputTitle(e.content);
+        } else if (e.type === "llm_response") {
+          tokenIn += e.usage.input ?? 0;
+          tokenOut += e.usage.output ?? 0;
+        } else if (e.type === "in_flight_start") iterationCount++;
         else if (e.type === "tool_call_start") {
           toolCallCount++;
           toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
         } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
         else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
+        else if (e.type === "error" || e.type === "provider_error") hasError = true;
       }
-      if (lastEvent?.type === "session_end") {
+      if (lastEventType === "session_end") {
         outcome = "completed";
-      } else if (lastEvent?.type === "in_flight_start") {
+      } else if (lastEventType === "in_flight_start") {
         outcome = "aborted";
-      } else if (data.events.some((e) => e.type === "error")) {
+      } else if (hasError) {
         outcome = "error";
       }
       return {
         id,
         title,
-        startedAt: data.metadata.startedAt,
-        endedAt: data.metadata.endedAt,
-        model: data.metadata.model ?? "unknown",
-        provider: data.metadata.provider ?? "unknown",
-        tokenTotal: data.usage.input + data.usage.output,
+        startedAt,
+        endedAt,
+        model,
+        provider,
+        tokenTotal: tokenIn + tokenOut,
         iterationCount: iterationCount > 0 ? iterationCount : void 0,
         toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
         toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
@@ -8778,75 +9201,24 @@ var DefaultSessionStore = class _DefaultSessionStore {
       };
     }
   }
-  metaFromEvents(id, events) {
-    const start = events.find((e) => e.type === "session_start");
-    const end = events.findLast((e) => e.type === "session_end");
-    return {
-      id,
-      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-      endedAt: end?.ts,
-      model: start?.model,
-      provider: start?.provider,
-      pendingToolUses: end?.pendingToolUses
-    };
-  }
-  replay(events, sessionId = "unknown") {
-    const messages = [];
-    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-    const openToolUses = /* @__PURE__ */ new Set();
-    for (const e of events) {
-      if (e.type === "user_input") {
-        openToolUses.clear();
-        messages.push({ role: "user", content: e.content, ts: e.ts });
-      } else if (e.type === "llm_response") {
-        messages.push({ role: "assistant", content: e.content, ts: e.ts });
-        for (const b of e.content) {
-          if (b.type === "tool_use") openToolUses.add(b.id);
-        }
-        usage = {
-          input: usage.input + (e.usage.input ?? 0),
-          output: usage.output + (e.usage.output ?? 0),
-          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
-          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
-        };
-      } else if (e.type === "tool_result") {
-        if (!openToolUses.has(e.id)) {
-          this.events?.emit("session.damaged", {
-            sessionId,
-            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
-          });
-          continue;
-        }
-        openToolUses.delete(e.id);
-        const resultBlock = {
-          type: "tool_result",
-          tool_use_id: e.id,
-          content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
-          is_error: e.isError
-        };
-        const last = messages[messages.length - 1];
-        const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
-        if (lastIsToolResultUser && Array.isArray(last.content)) {
-          last.content.push(resultBlock);
-        } else {
-          messages.push({ role: "user", content: [resultBlock], ts: e.ts });
+  async *iterSessionEvents(file) {
+    const stream = createReadStream(file, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            yield parsed;
+          }
+        } catch {
         }
       }
+    } finally {
+      lines.close();
+      stream.destroy();
     }
-    if (openToolUses.size > 0) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
-      });
-    }
-    const repaired = repairToolUseAdjacency(messages);
-    if (repaired.report.changed) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
-      });
-    }
-    return { messages: repaired.messages, usage };
   }
 };
 function extractToolCallEnds(events) {
@@ -8906,7 +9278,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Lazy session_start/session_resumed init, shared by all appenders.
    * A single promise (not a boolean) so a second append racing the first
-   * can't push its event into the buffer BEFORE the first append's event —
+   * can't push its event into the buffer BEFORE the first append's event —
    * every appender awaits the same init and resumes in FIFO call order.
    */
   initPromise = null;
@@ -8919,24 +9291,24 @@ var FileSessionWriter = class _FileSessionWriter {
   lastAppendWarnAt = 0;
   secretScrubber;
   onCloseCb;
-  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
-  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
+  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
   //
   // Every append() pushes the scrubbed event into an in-memory buffer instead
   // of calling handle.appendFile() synchronously. The buffer flushes to disk
   // when it reaches FLUSH_SIZE events OR after FLUSH_INTERVAL_MS of inactivity.
   // This cuts the number of disk writes by ~95% without changing the on-disk
-  // format — the JSONL is still one JSON object per line.
+  // format — the JSONL is still one JSON object per line.
   writeBuffer = [];
   flushTimer = null;
   static FLUSH_INTERVAL_MS = 500;
   static FLUSH_SIZE = 50;
-  // ── Write serialization ─────────────────────────────────────────────────
+  // ── Write serialization ─────────────────────────────────────────────────
   //
   // All disk writes are funneled through a FIFO promise chain. Without it,
   // a timer-driven flush racing an explicit flush()/close() issues two
-  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
+  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
   // may complete them out of order (chronology breaks) or, for large
   // batches, interleave partial writes (torn JSONL lines). The chain keeps
   // exactly one write in flight; failures don't break the chain.
@@ -8950,7 +9322,7 @@ var FileSessionWriter = class _FileSessionWriter {
     );
     return write;
   }
-  // ── Enriched summary tracking ──────────────────────────────────────────
+  // ── Enriched summary tracking ──────────────────────────────────────────
   iterationCount = 0;
   toolCallCount = 0;
   toolErrorCount = 0;
@@ -9042,7 +9414,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * (user_input, llm_response) call this so they survive SIGKILL/crash
    * instead of sitting in the in-memory buffer for up to 500ms.
    *
-   * Idempotent — cancels any pending timer and writes whatever has
+   * Idempotent — cancels any pending timer and writes whatever has
    * accumulated in the buffer. Safe to call even when the buffer
    * is empty (no-op).
    */
@@ -9065,7 +9437,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Flush all buffered events to disk as a single appendFile call.
    * Errors use the same throttled-warning pattern the old per-event
-   * append path used — one warning every 5s with a suppressed count.
+   * append path used — one warning every 5s with a suppressed count.
    * On failure the buffer is cleared (events are best-effort, same as
    * the old per-event path where a failed write was silently dropped).
    */
@@ -9248,7 +9620,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Truncate the session file to the checkpoint with the given promptIndex,
    * removing all events that follow it. Uses a single-pass byte-offset scan
-   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
   async truncateToCheckpoint(targetPromptIndex) {
@@ -9405,7 +9777,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await fsp3.writeFile(this.filePath, record, "utf8");
   }
   /**
-   * Idea #1 — write an in-flight marker. The agent loop should call
+   * Idea #1 — write an in-flight marker. The agent loop should call
    * this at the start of each long-running operation; a matching
    * `clearInFlightMarker` follows on clean exit. A stale marker
    * (no end) is what `SessionRecovery.detectStale` looks for.
@@ -9422,9 +9794,9 @@ var FileSessionWriter = class _FileSessionWriter {
     this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
   /**
-   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
    * (you can call it after a successful iteration even if you
-   * didn't open one this round) — but the session log records
+   * didn't open one this round) — but the session log records
    * every call so postmortem tooling can see "the agent finished
    * cleanly X times, then died without finishing Y".
    */
@@ -9441,6 +9813,27 @@ function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
+function compareSessionSummaries(a, b) {
+  if (a.startedAt < b.startedAt) return 1;
+  if (a.startedAt > b.startedAt) return -1;
+  return a.id.localeCompare(b.id);
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+  if (items.length === 0) return [];
+  const out = new Array(items.length);
+  let next = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) return;
+      const item = items[idx];
+      if (item !== void 0) out[idx] = await fn(item);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
 
 // src/storage/queue-store.ts
 init_atomic_write();
@@ -10016,6 +10409,20 @@ var DefaultMemoryStore = class {
    */
   persistBackup;
   backupDir;
+  /**
+   * Per-scope tracked byte sizes — incremented on `remember()`, decremented on
+   * `forget()`, recalculated after `consolidate()`. Eliminates the redundant
+   * readAll() call that previously checked the file size after every write.
+   */
+  _trackedByteSizes = {};
+  /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
+  _scoreCache = /* @__PURE__ */ new Map();
+  /**
+   * Per-entry cached lowercase strings — computed once per scoreRelevant() call,
+   * stored here so repeated scoring of the same entries avoids re-computation.
+   * Cleared on every mutation (remember/forget/consolidate/clear).
+   */
+  _cachedLower = null;
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
@@ -10049,6 +10456,20 @@ var DefaultMemoryStore = class {
       }
     }
   }
+  /**
+   * Recalculate the tracked byte size for a scope by re-reading the file and
+   * summing the serialized byte length of each line. Called after consolidate()
+   * (which modifies the file) to keep the tracker accurate.
+   */
+  async _recalcTrackedByteSize(scope) {
+    const raw = await this.backend.readAll(scope, this.files[scope]);
+    let total = 0;
+    for (const line of raw.split("\n")) {
+      if (line.trim()) total += Buffer.byteLength(line, "utf8");
+    }
+    this._trackedByteSizes[scope] = total;
+    return total;
+  }
   async readAll() {
     const parts = [];
     for (const scope of ["project-agents", "project-memory", "user-memory"]) {
@@ -10149,6 +10570,7 @@ ${body.trim()}`);
       const t0 = Date.now();
       try {
         await this.backend.remember(scope, entry, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -10173,16 +10595,21 @@ ${body.trim()}`);
         });
         throw err;
       }
-      const raw = await this.backend.readAll(scope, this.files[scope]);
-      if (Buffer.byteLength(raw, "utf8") > MAX_BYTES_TOTAL) {
+      let trackedSize = this._trackedByteSizes[scope];
+      if (trackedSize === void 0) {
+        trackedSize = await this._recalcTrackedByteSize(scope);
+      }
+      if (trackedSize > MAX_BYTES_TOTAL) {
         const removed = await this.backend.consolidate(scope, this.files[scope]);
         if (removed > 0) {
           this.events?.emit("memory.consolidated", {
             scope,
             removed
           });
+          await this._recalcTrackedByteSize(scope);
         }
       }
+      this._trackedByteSizes[scope] = (this._trackedByteSizes[scope] ?? 0) + Buffer.byteLength(JSON.stringify(entry), "utf8");
       await this.mirrorBackup(scope);
       this.events?.emit("memory.remembered", {
         scope,
@@ -10201,16 +10628,30 @@ ${body.trim()}`);
   async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
     const all = await this.list(scope);
     if (all.length === 0) return [];
+    const ctxHash = `${scope}|${ctx.currentTask}|${(ctx.activeSkills ?? []).join(",")}|${(ctx.toolNames ?? []).join(",")}`;
+    const now = Date.now();
+    const TTL_MS = 3e4;
+    const cached = this._scoreCache.get(ctxHash);
+    if (cached && cached.expiresAt > now && cached.entries === all) {
+      return cached.scored.slice(0, Math.min(limit, 15));
+    }
     const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
     const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
     const toolWords = (ctx.toolNames ?? []).flatMap((t2) => t2.toLowerCase().split("_"));
-    const now = Date.now();
+    this._cachedLower = /* @__PURE__ */ new WeakMap();
     const scored = [];
     for (const entry of all) {
       let score = 0;
       const reasons = [];
-      const textLower = entry.text.toLowerCase();
-      const tagsLower = (entry.tags ?? []).map((t2) => t2.toLowerCase());
+      let cachedLower = this._cachedLower.get(entry);
+      if (!cachedLower) {
+        cachedLower = {
+          textLower: entry.text.toLowerCase(),
+          tagsLower: (entry.tags ?? []).map((t2) => t2.toLowerCase())
+        };
+        this._cachedLower.set(entry, cachedLower);
+      }
+      const { textLower, tagsLower } = cachedLower;
       let taskHits = 0;
       for (const w of taskWords) {
         if (textLower.includes(w)) {
@@ -10296,6 +10737,7 @@ ${body.trim()}`);
     const relevant = scored.filter(
       (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
     );
+    this._scoreCache.set(ctxHash, { entries: all, scored: relevant, expiresAt: now + TTL_MS });
     return relevant.slice(0, Math.min(limit, 15));
   }
   async forget(query, scope = "project-memory") {
@@ -10305,6 +10747,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.forget(scope, query, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -10336,6 +10779,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
       return removed;
     });
@@ -10347,6 +10791,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.consolidate(scope, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -10377,6 +10822,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
     });
   }
@@ -10387,6 +10833,7 @@ ${body.trim()}`);
         const t0 = Date.now();
         try {
           await this.backend.clear(scope, filePath);
+          this._scoreCache.clear();
           const dur = Date.now() - t0;
           this.events?.emit("storage.write", {
             sessionId: "~memory~",
@@ -10413,6 +10860,7 @@ ${body.trim()}`);
         }
         this.events?.emit("memory.cleared", { scope });
         await this.mirrorBackup(scope);
+        this._trackedByteSizes[scope] = 0;
       });
       return;
     }
@@ -10470,8 +10918,8 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile14, mkdir: mkdir23 } = await import('fs/promises');
-      await mkdir23(this.backupDir, { recursive: true });
+      const { writeFile: writeFile14, mkdir: mkdir24 } = await import('fs/promises');
+      await mkdir24(this.backupDir, { recursive: true });
       await writeFile14(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }
@@ -10657,6 +11105,51 @@ var defaultIndexing = {
   watchExternal: true,
   debounceMs: 400
 };
+var IN_PROJECT_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "provider",
+  "apiKey",
+  "baseUrl",
+  "providers",
+  "mcpServers",
+  "hooks",
+  "plugins",
+  "sync",
+  "yolo",
+  "extensions"
+]);
+function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => console.warn(msg)) {
+  const stripped = [];
+  const out = {};
+  for (const [k, v] of Object.entries(inProject)) {
+    if (IN_PROJECT_FORBIDDEN_KEYS.has(k)) {
+      stripped.push(k);
+      continue;
+    }
+    out[k] = v;
+  }
+  if (stripped.length > 0) {
+    warn(
+      JSON.stringify({
+        level: "warn",
+        event: "config.in_project_unsafe_fields_ignored",
+        path: sourcePath,
+        ignoredKeys: stripped,
+        message: `Ignored ${stripped.length} unsafe field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. These can only be set in your personal ~/.wrongstack/config.json, not in a project-committed file.`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  return out;
+}
+function samePath(a, b) {
+  let ra = path3.resolve(a);
+  let rb = path3.resolve(b);
+  if (process.platform === "win32" || process.platform === "darwin") {
+    ra = ra.toLowerCase();
+    rb = rb.toLowerCase();
+  }
+  return ra === rb;
+}
 function deepMerge2(base, patch) {
   const opts = { arrayMode: "concat-primitives" };
   if (envBoolOptional(process.env.WRONGSTACK_DEBUG_CONFIG)) {
@@ -10685,14 +11178,15 @@ var DefaultConfigLoader = class {
   }
   async load(opts = {}) {
     let cfg = { ...BEHAVIOR_DEFAULTS };
+    const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
     const [global, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
       this.readJson(this.paths.projectLocalConfig),
-      this.readJson(this.paths.inProjectConfig)
+      inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
     cfg = deepMerge2(cfg, global);
     cfg = deepMerge2(cfg, local);
-    cfg = deepMerge2(cfg, inProject);
+    cfg = deepMerge2(cfg, stripUnsafeInProjectFields(inProject, this.paths.inProjectConfig));
     for (const [key, fn] of Object.entries(ENV_MAP)) {
       const v = process.env[key];
       if (v) fn(cfg, v);
@@ -12085,6 +12579,9 @@ function isClearlyDestructiveBashCommand(command, projectRoot) {
 }
 
 // src/security/permission-policy.ts
+function matchesTrust(patterns, subject) {
+  return patterns.includes(subject) || matchAny(patterns, subject);
+}
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -12221,7 +12718,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(cacheKey, decision);
       return decision;
     }
-    if (entry?.deny && subject && matchAny(entry.deny, subject)) {
+    if (entry?.deny && subject && matchesTrust(entry.deny, subject)) {
       const decision = { permission: "deny", source: "deny", reason: "matched deny pattern" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -12231,7 +12728,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(cacheKey, decision);
       return decision;
     }
-    if (entry?.allow && subject && matchAny(entry.allow, subject)) {
+    if (entry?.allow && subject && matchesTrust(entry.allow, subject)) {
       const decision = { permission: "auto", source: "trust", reason: "matched allow pattern" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -12767,6 +13264,16 @@ function handleMessageStop(state, ev) {
 async function streamProviderToResponse(provider, req, signal, ctx, events, logger) {
   const state = createStreamingState(req.model);
   logger.debug("Stream started", { providerId: provider.id, model: req.model });
+  const TEXT_BATCH_SIZE = 4;
+  let pendingText = "";
+  let pendingCount = 0;
+  const flushText = () => {
+    if (pendingCount > 0) {
+      events.emit("provider.text_delta", { ctx, text: pendingText });
+      pendingText = "";
+      pendingCount = 0;
+    }
+  };
   const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
   try {
     for (; ; ) {
@@ -12786,9 +13293,12 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             break;
           case "text_delta":
             handleTextDelta(state, ev.text);
-            events.emit("provider.text_delta", { ctx, text: ev.text });
+            pendingText += ev.text;
+            pendingCount++;
+            if (pendingCount >= TEXT_BATCH_SIZE) flushText();
             break;
           case "tool_use_start": {
+            flushText();
             const idVal = ev.id;
             const nameVal = ev.name;
             handleToolUseStart(state, { id: idVal, name: nameVal });
@@ -12800,6 +13310,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             handleToolUseInputDelta(state, ev);
             break;
           case "tool_use_stop": {
+            flushText();
             const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
             handleToolUseStop(state, ev);
             events.emit("provider.tool_use_stop", { ctx, id: ev.id, name: stoppedName });
@@ -12809,6 +13320,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             handleThinkingStart(state, ev);
             break;
           case "thinking_delta":
+            flushText();
             handleThinkingDelta(state, ev.text);
             events.emit("provider.thinking_delta", { ctx, text: ev.text });
             break;
@@ -12840,6 +13352,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
           eventType: String(evAny.type),
           errorMessage: errMsg
         });
+        flushText();
         events.emit("provider.stream_error", {
           ctx,
           eventType: String(evAny.type),
@@ -12850,6 +13363,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
   } catch (err) {
     if (signal.aborted) {
       state.stopReason = "end_turn";
+      flushText();
       logger.debug("Stream aborted \u2014 returning partial state", {
         providerId: provider.id,
         model: req.model,
@@ -12868,8 +13382,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve18) => {
-            drainTimer = setTimeout(resolve18, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve19) => {
+            drainTimer = setTimeout(resolve19, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -12878,6 +13392,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
     } catch {
     }
   }
+  flushText();
   logger.debug("Stream completed", {
     providerId: provider.id,
     model: req.model,
@@ -12975,7 +13490,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve18, reject) => {
+      await new Promise((resolve19, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t2);
@@ -12991,7 +13506,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve18();
+          resolve19();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -14734,7 +15249,14 @@ var EternalAutonomyEngine = class {
     try {
       const reloaded = await loadGoal(this.goalPath, this.opts.events);
       iterationIndex = reloaded?.iterations ?? 0;
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "autonomy.goal_reload_failed",
+        message: toErrorMessage(err),
+        context: { goalPath: this.goalPath },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     }
     this.opts.onIteration?.({
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
@@ -14969,7 +15491,14 @@ ${lastFew}` : "No prior iterations yet.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "autonomy.brainstorm_failed",
+        message: toErrorMessage(err),
+        context: { goal: goal.goal.slice(0, 100) },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       return null;
     }
   }
@@ -15492,13 +16021,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve18(d);
+        resolve19(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       bus.emit("budget.threshold_reached", {
@@ -18849,6 +19378,68 @@ Working rules:
 - When in doubt, flag as medium rather than ignoring potential issues`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
+var SHADOW_AGENT = {
+  id: "shadow-agent",
+  name: "Shadow",
+  role: "shadow-agent",
+  prompt: `You are the Shadow Agent \u2014 a silent background monitor for the WrongStack fleet.
+
+Your job is to observe, detect anomalies, and be ready to intervene \u2014 but only when commanded.
+
+## Core Responsibilities
+
+1. **Fleet Monitoring** (every 30s)
+   - Call \`fleet_status\` + \`fleet_health\` on each heartbeat
+   - Track what each agent is doing (task descriptions)
+   - Detect stuck agents (>5min no events), idle agents, crashed agents
+
+2. **FleetBus Subscription**
+   - Subscribe to \`subagent.*\` events to track lifecycle
+   - Subscribe to \`tool.executed\` to monitor activity
+   - Track agent joins (subagent.started) and leaves (subagent.stopped)
+
+3. **Mailbox Surveillance**
+   - Monitor for \`control\` type messages starting with "hoop"
+   - Detect orphan assigns (assign without result within 5min)
+   - Cross-session awareness via shared project mailbox
+
+4. **Spike Detection**
+   - Track task duration per agent
+   - Flag agents that spawn and die within <5 seconds
+   - Log spike events with reason (completed/error/killed/timeout)
+
+5. **Intervention Commands**
+   Parse these from mailbox control messages:
+   - \`hoop <agentId>\` \u2014 terminate specific agent
+   - \`hoop all\` \u2014 terminate all running agents
+   - \`shadow status\` \u2014 report current fleet snapshot
+   - \`shadow mute\` \u2014 pause heartbeat monitoring
+   - \`shadow resume\` \u2014 resume heartbeat monitoring
+   - \`shadow interval <ms>\` \u2014 change heartbeat interval
+   - \`shadow model <model-id>\` \u2014 change analysis model
+
+## Operating Rules
+
+- **Silent by default**: Use DEBUG level logging unless anomaly detected
+- **Deterministic**: Same state always produces same actions \u2014 no randomness
+- **Report on anomaly**: When anomaly detected, use \`mail_send\` to broadcast warning
+- **Never auto-intervene**: Always report unless explicitly commanded
+- **Minimal footprint**: Small state, efficient snapshots
+
+## Startup Sequence
+
+1. Send broadcast: \`shadow:started { intervalMs, model, startTime }\`
+2. Subscribe to FleetBus for all relevant events
+3. Schedule heartbeat cron job at configured interval
+4. Wait for commands or anomalies
+
+## Shutdown Sequence
+
+1. Cancel all cron jobs (\`cron_cancel\`)
+2. Send broadcast: \`shadow:stopped { reason, finalState }\`
+3. Clean up FleetBus subscriptions`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
 var CRITIC_AGENT = {
   id: "critic",
   name: "Critic",
@@ -18889,6 +19480,7 @@ var FLEET_ROSTER = {
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
   "critic": CRITIC_AGENT,
+  "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
@@ -18900,6 +19492,8 @@ var FLEET_ROSTER_BUDGETS = {
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  "shadow-agent": { timeoutMs: 24 * 60 * 60 * 1e3, maxIterations: 1e4, maxToolCalls: 5e3 },
+  // Long-running background monitor
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -19338,7 +19932,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -19347,7 +19941,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve18(result);
+              resolve19(result);
             }
           };
           this.on("task.completed", handler);
@@ -19615,12 +20209,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve18 = (d) => {
+              const resolve19 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve18("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve19("stop"), DECISION_TIMEOUT_MS);
               budget._events?.emit("budget.threshold_reached", {
                 kind: "timeout",
                 used,
@@ -19636,11 +20230,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve18({ extend: extra }));
+                  queueMicrotask(() => resolve19({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve18("stop");
+                  resolve19("stop");
                 }
               });
             });
@@ -20107,7 +20701,14 @@ ${personaLine}Task: ${task}
             subagentIds.push(subagentId);
             taskIds.push(taskId);
             await coordinator.assign(spec);
-          } catch {
+          } catch (err) {
+            console.error(JSON.stringify({
+              level: "warn",
+              event: "parallel_engine.spawn_failed",
+              message: toErrorMessage(err),
+              context: { slot: i, task, subagentId },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }));
           }
         })()
       );
@@ -20132,7 +20733,14 @@ ${personaLine}Task: ${task}
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "parallel_engine.brainstorm_results_failed",
+        message: toErrorMessage(err),
+        context: { slotCount, taskIds },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       results = coordinator.results().slice(-taskIds.length);
     }
     await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
@@ -20166,7 +20774,14 @@ ${personaLine}Task: ${task}
             if (file) tasks.push(`[git] inspect and fix: ${file}`);
           }
         }
-      } catch {
+      } catch (err) {
+        console.error(JSON.stringify({
+          level: "warn",
+          event: "parallel_engine.git_status_failed",
+          message: toErrorMessage(err),
+          context: { projectRoot: this.opts.projectRoot },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       }
     }
     if (tasks.length < this.slots) {
@@ -20520,7 +21135,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat15] = await Promise.all([
+        const [content, stat16] = await Promise.all([
           fsp3.readFile(filePath, "utf8"),
           fsp3.stat(filePath)
         ]);
@@ -20530,8 +21145,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat15.mtimeMs,
-          snapshotSizeBytes: stat15.size
+          snapshotMtimeMs: stat16.mtimeMs,
+          snapshotSizeBytes: stat16.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -20944,9 +21559,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat15 = await fsp3.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat15.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat15.size !== file.snapshotSizeBytes;
+        const stat16 = await fsp3.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat16.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat16.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -22865,11 +23480,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve18;
+        let resolve19;
         const promise = new Promise((res) => {
-          resolve18 = res;
+          resolve19 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve18 });
+        this.taskWaiters.set(id, { promise, resolve: resolve19 });
         return promise;
       })
     );
@@ -23265,7 +23880,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve18) => {
+        const result = await new Promise((resolve19) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -23275,7 +23890,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve18(value);
+            resolve19(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -23707,8 +24322,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path3.join(modesDir, entry);
-      const stat15 = await fsp3.stat(filePath);
-      if (!stat15.isFile()) continue;
+      const stat16 = await fsp3.stat(filePath);
+      if (!stat16.isFile()) continue;
       const content = await fsp3.readFile(filePath, "utf8");
       const id = path3.basename(entry, path3.extname(entry));
       modes.push({
@@ -25045,10 +25660,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp25 = await import('fs/promises');
-      const path48 = await import('path');
+      const fsp26 = await import('fs/promises');
+      const path51 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp25.mkdir(path48.dirname(this.sessionPath), { recursive: true });
+      await fsp26.mkdir(path51.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -25057,8 +25672,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp25 = await import('fs/promises');
-      const raw = await fsp25.readFile(this.sessionPath, "utf8");
+      const fsp26 = await import('fs/promises');
+      const raw = await fsp26.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -25072,8 +25687,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp25 = await import('fs/promises');
-      await fsp25.unlink(this.sessionPath);
+      const fsp26 = await import('fs/promises');
+      await fsp26.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -25775,15 +26390,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path48 = [];
+  const path51 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path48.unshift(current);
+    path51.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path48;
+  return path51;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -26606,9 +27221,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve18) => {
+    const timeout = new Promise((resolve19) => {
       timer = setTimeout(
-        () => resolve18({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve19({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -26791,7 +27406,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path48 = opts.path ?? "/metrics";
+  const path51 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -26801,7 +27416,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path48) {
+    if (url === path51) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -26847,14 +27462,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve18, reject) => {
+  await new Promise((resolve19, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve18();
+      resolve19();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -26865,9 +27480,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path48}`,
-    close: () => new Promise((resolve18, reject) => {
-      server.close((err) => err ? reject(err) : resolve18());
+    url: `${protocol}://${host}:${boundPort}${path51}`,
+    close: () => new Promise((resolve19, reject) => {
+      server.close((err) => err ? reject(err) : resolve19());
     })
   };
 }
@@ -27804,13 +28419,13 @@ var SkillInstaller = class {
               context: { reason: "path_traversal", skillName: skill.name }
             });
           }
-          const stat15 = await fsp3.stat(srcPath);
-          if (stat15.size > MAX_SKILL_FILE_SIZE) {
+          const stat16 = await fsp3.stat(srcPath);
+          if (stat16.size > MAX_SKILL_FILE_SIZE) {
             throw new FsError({
-              message: `Skill file "${file}" is too large (${(stat15.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
+              message: `Skill file "${file}" is too large (${(stat16.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
               code: ERROR_CODES.FS_WRITE_FAILED,
               path: srcPath,
-              context: { skillName: skill.name, fileSize: stat15.size, maxSize: MAX_SKILL_FILE_SIZE }
+              context: { skillName: skill.name, fileSize: stat16.size, maxSize: MAX_SKILL_FILE_SIZE }
             });
           }
           await fsp3.mkdir(path3.dirname(destPath), { recursive: true });
@@ -28068,6 +28683,12 @@ var GraphMemoryBackend = class {
   edges = [];
   loadedScope = null;
   loaded = false;
+  /**
+   * Promise that resolves when the current in-flight _saveGraph completes.
+   * Tests call flush() to await this before deleting the backend or its temp dir.
+   * Each save operation chains onto the previous one so concurrent saves are serialised.
+   */
+  _saveDone = Promise.resolve();
   constructor(opts) {
     this.file = new FileMemoryBackend({ paths: opts.paths });
     this.graphFile = opts.graphPath ?? `${opts.paths.projectDir}/memory-graph.json`;
@@ -28094,7 +28715,8 @@ var GraphMemoryBackend = class {
         tags: entry.tags,
         priority: entry.priority
       });
-      for (const [, other] of this.nodes) {
+      const recentNodes = [...this.nodes.values()].slice(-100);
+      for (const other of recentNodes) {
         if (other.id === nodeId) continue;
         const sim = wordOverlap(entry.text, other.entry.text);
         const tagSim = sharedTags(entry.tags ?? [], other.tags ?? []);
@@ -28110,7 +28732,8 @@ var GraphMemoryBackend = class {
         }
       }
     }
-    await this.saveGraph(scope);
+    this._saveDone = this._saveGraph(scope);
+    await this._saveDone;
   }
   async forget(scope, query, filePath) {
     const removed = await this.file.forget(scope, query, filePath);
@@ -28125,7 +28748,8 @@ var GraphMemoryBackend = class {
       }
       for (const id of toRemove) this.nodes.delete(id);
       this.edges = this.edges.filter((e) => !toRemove.includes(e.from) && !toRemove.includes(e.to));
-      await this.saveGraph(scope);
+      this._saveDone = this._saveGraph(scope);
+      await this._saveDone;
     }
     return removed;
   }
@@ -28237,7 +28861,8 @@ var GraphMemoryBackend = class {
     this.loadedScope = scope;
     this.loaded = true;
   }
-  async saveGraph(scope) {
+  /** Fire-and-forget graph persistence. Named _saveGraph to signal it must not be awaited. */
+  async _saveGraph(scope) {
     this.loadedScope = scope;
     this.loaded = true;
     try {
@@ -28245,16 +28870,21 @@ var GraphMemoryBackend = class {
         nodes: [...this.nodes.entries()],
         edges: this.edges
       };
-      await fsp3.mkdir(
-        this.graphFile.substring(0, this.graphFile.lastIndexOf("/")),
-        { recursive: true }
-      );
+      const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
+      await fsp3.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
       await fsp3.writeFile(tmp, JSON.stringify(data));
       await fsp3.rename(tmp, this.graphFile);
     } catch {
     }
   }
+  /**
+   * Wait for all in-flight _saveGraph operations to complete.
+   * Call this before deleting the backend or its temp directory.
+   */
+  async flush() {
+    await this._saveDone;
+  }
 };
 function wordOverlap(a, b) {
   const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -28355,84 +28985,89 @@ var SessionMemoryConsolidator = class {
     this.minIterations = opts.minIterations ?? 2;
     this.maxExistingEntries = opts.maxExistingEntries ?? 15;
   }
-  afterRun = async (ctx, result) => {
+  afterRun = (ctx, result) => {
     if (result.status !== "done") return;
     if (!result.finalText || result.finalText.trim().length < 20) return;
     if (result.iterations < this.minIterations) return;
     const provider = this.provider ?? ctx.provider;
     if (!provider?.complete) return;
-    try {
-      const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
-      const prompt = buildConsolidationPrompt(
-        result.finalText,
-        result.iterations,
-        existingEntries
-      );
-      const signal = AbortSignal.timeout(15e3);
-      const response = await provider.complete(
-        {
-          model: this.model ?? ctx.model,
-          system: [{ type: "text", text: prompt }],
-          messages: [
-            { role: "user", content: "Review the session and return memory operations as JSON." }
-          ],
-          maxTokens: 500
-        },
-        { signal }
-      );
-      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-      if (!text) return;
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) return;
-      const parsed = JSON.parse(jsonMatch[0]);
-      if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
-      let added = 0;
-      let edited = 0;
-      let deleted = 0;
-      for (const op of parsed.operations) {
-        switch (op.action) {
-          case "add": {
-            if (op.text?.trim()) {
-              await this.memoryStore.remember(op.text.trim(), void 0, {
-                type: op.type,
-                tags: op.tags,
-                priority: op.priority
-              });
-              added++;
+    const _finalText = result.finalText;
+    const _iterations = result.iterations;
+    const _model = this.model ?? ctx.model;
+    void (async () => {
+      try {
+        const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+        const prompt = buildConsolidationPrompt(
+          _finalText,
+          _iterations,
+          existingEntries
+        );
+        const signal = AbortSignal.timeout(15e3);
+        const response = await provider.complete(
+          {
+            model: _model,
+            system: [{ type: "text", text: prompt }],
+            messages: [
+              { role: "user", content: "Review the session and return memory operations as JSON." }
+            ],
+            maxTokens: 500
+          },
+          { signal }
+        );
+        const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+        if (!text) return;
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) return;
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
+        let added = 0;
+        let edited = 0;
+        let deleted = 0;
+        for (const op of parsed.operations) {
+          switch (op.action) {
+            case "add": {
+              if (op.text?.trim()) {
+                await this.memoryStore.remember(op.text.trim(), void 0, {
+                  type: op.type,
+                  tags: op.tags,
+                  priority: op.priority
+                });
+                added++;
+              }
+              break;
             }
-            break;
-          }
-          case "edit": {
-            if (op.query && op.text?.trim()) {
-              await this.memoryStore.forget(op.query);
-              await this.memoryStore.remember(op.text.trim(), void 0, {
-                type: op.type,
-                tags: op.tags,
-                priority: op.priority
-              });
-              edited++;
+            case "edit": {
+              if (op.query && op.text?.trim()) {
+                await this.memoryStore.forget(op.query);
+                await this.memoryStore.remember(op.text.trim(), void 0, {
+                  type: op.type,
+                  tags: op.tags,
+                  priority: op.priority
+                });
+                edited++;
+              }
+              break;
             }
-            break;
-          }
-          case "delete": {
-            if (op.query) {
-              const n = await this.memoryStore.forget(op.query);
-              deleted += n;
+            case "delete": {
+              if (op.query) {
+                const n = await this.memoryStore.forget(op.query);
+                deleted += n;
+              }
+              break;
             }
-            break;
           }
         }
-      }
-      if (added > 0 || edited > 0 || deleted > 0) {
-        const parts = [];
-        if (added) parts.push(`${added} added`);
-        if (edited) parts.push(`${edited} edited`);
-        if (deleted) parts.push(`${deleted} deleted`);
-        process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
+        if (added > 0 || edited > 0 || deleted > 0) {
+          const parts = [];
+          if (added) parts.push(`${added} added`);
+          if (edited) parts.push(`${edited} edited`);
+          if (deleted) parts.push(`${deleted} deleted`);
+          process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
 `);
+        }
+      } catch {
       }
-    } catch {
-    }
+    })();
   };
 };
 function sessionScopedPath(dir, sessionId, suffix) {
@@ -29059,15 +29694,15 @@ var SessionRecovery = class {
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
     const TAIL_SIZE = 8192;
-    let stat15;
+    let stat16;
     try {
-      stat15 = await fsp3.stat(fp);
+      stat16 = await fsp3.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat15.size === 0) return null;
-    const position = Math.max(0, stat15.size - TAIL_SIZE);
+    if (stat16.size === 0) return null;
+    const position = Math.max(0, stat16.size - TAIL_SIZE);
     const buf = Buffer.alloc(TAIL_SIZE);
     let fh;
     try {
@@ -29545,6 +30180,9 @@ var AgentStatusTracker = class {
   leaderName;
   // Live agent map: agentId → AgentEntry
   agents = /* @__PURE__ */ new Map();
+  // Last full agent list flushed (leader + subagents). Lets external consumers
+  // read the current state synchronously without re-deriving it.
+  lastAgents = [];
   // Leader tracking
   leaderStatus = "idle";
   leaderCurrentTool;
@@ -29556,6 +30194,7 @@ var AgentStatusTracker = class {
   leaderCtxPct;
   leaderModel;
   leaderPartialText = "";
+  leaderStartedAt;
   unsubscribers = [];
   onUpdate;
   sweepTimer = null;
@@ -29566,9 +30205,17 @@ var AgentStatusTracker = class {
     this.leaderName = opts.leaderName ?? "leader";
     this.onUpdate = opts.onUpdate;
   }
+  /** Current full agent list (leader + subagents) as of the last flush. */
+  getAgents() {
+    return this.lastAgents.length > 0 ? [...this.lastAgents] : [];
+  }
   start() {
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.started", () => {
+      this.events.onPattern("agent.run.started", (_event, payload) => {
+        const p = payload;
+        this.markLeaderStarted(p?.at);
+        this.captureLeaderContext(p?.ctx);
+        if (p?.model) this.leaderModel = p.model;
         this.leaderStatus = "running";
         this.leaderIterations++;
         this.flush();
@@ -29576,25 +30223,36 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("iteration.started", (_e, payload) => {
-        const ctx = payload?.ctx;
-        if (!ctx) return;
-        if (ctx.model) this.leaderModel = ctx.model;
-        if (typeof ctx.tokenCount === "number" && typeof ctx.maxContext === "number" && ctx.maxContext > 0) {
-          this.leaderCtxPct = Math.round(ctx.tokenCount / ctx.maxContext * 100);
+        const p = payload;
+        const ctx = p?.ctx;
+        this.markLeaderStarted();
+        this.leaderStatus = "running";
+        if (typeof p?.index === "number") {
+          this.leaderIterations = Math.max(this.leaderIterations, p.index + 1);
         }
+        if (!ctx) {
+          this.flush();
+          return;
+        }
+        this.captureLeaderContext(ctx);
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.completed", () => {
-        this.leaderStatus = "idle";
+      this.events.onPattern("agent.run.completed", (_event, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
+        this.leaderStatus = p?.status === "failed" ? "error" : "idle";
         this.leaderCurrentTool = void 0;
         this.leaderPartialText = "";
+        if (this.leaderStatus === "idle") this.leaderStartedAt = void 0;
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.error", () => {
+      this.events.onPattern("agent.run.error", (_event, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "error";
         this.leaderCurrentTool = void 0;
         this.leaderPartialText = "";
@@ -29605,6 +30263,7 @@ var AgentStatusTracker = class {
       this.events.onPattern("tool.started", (_event, payload) => {
         const p = payload;
         if (p?.name) {
+          this.markLeaderStarted();
           this.leaderCurrentTool = p.name;
           this.leaderToolCalls++;
         }
@@ -29620,12 +30279,14 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("brain.ask_human", () => {
+        this.markLeaderStarted();
         this.leaderStatus = "waiting_user";
         this.flush();
       })
     );
     this.unsubscribers.push(
       this.events.onPattern("llm.stream_started", () => {
+        this.markLeaderStarted();
         this.leaderStatus = "streaming";
         this.leaderPartialText = "";
         this.flush();
@@ -29633,14 +30294,42 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("provider.text_delta", (_e, payload) => {
-        const text = payload?.text;
+        const p = payload;
+        const text = p?.text;
         if (!text) return;
+        this.markLeaderStarted();
+        this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "streaming";
         const next = this.leaderPartialText + text;
         this.leaderPartialText = next.length > PARTIAL_TEXT_CAP ? next.slice(next.length - PARTIAL_TEXT_CAP) : next;
         this.schedulePartialFlush();
       })
     );
+    this.unsubscribers.push(
+      this.events.onPattern("provider.response", (_e, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("provider.fallback", (_e, payload) => {
+        const p = payload;
+        if (p?.to?.model) {
+          this.leaderModel = p.to.providerId ? `${p.to.providerId}/${p.to.model}` : p.to.model;
+          this.flush();
+        }
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("ctx.pct", (_e, payload) => {
+        const p = payload;
+        if (typeof p?.load === "number" && Number.isFinite(p.load)) {
+          this.leaderCtxPct = Math.round(p.load * 100);
+          this.flush();
+        }
+      })
+    );
     this.unsubscribers.push(
       this.events.onPattern("token.accounted", (_e, payload) => {
         const p = payload;
@@ -29654,7 +30343,8 @@ var AgentStatusTracker = class {
     const touch = (id) => {
       let entry = this.agents.get(id);
       if (!entry) {
-        entry = { id, name: id, status: "idle", iterations: 0, toolCalls: 0, lastActivityAt: (/* @__PURE__ */ new Date()).toISOString() };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        entry = { id, name: id, status: "idle", iterations: 0, toolCalls: 0, startedAt: now, lastActivityAt: now };
         this.agents.set(id, entry);
       }
       entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -29667,6 +30357,7 @@ var AgentStatusTracker = class {
         const entry = touch(p.subagentId);
         entry.name = p.name?.trim() || entry.name;
         if (p.model) entry.model = p.model;
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.status = "running";
         this.flush();
       })
@@ -29686,6 +30377,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.iterations++;
         this.flush();
       })
@@ -29696,6 +30388,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.currentTool = p.name;
         entry.toolCalls++;
         this.flush();
@@ -29707,6 +30400,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (typeof p.iteration === "number") entry.iterations = p.iteration;
         if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
         if (typeof p.costUsd === "number") entry.costUsd = p.costUsd;
@@ -29794,6 +30488,7 @@ var AgentStatusTracker = class {
     const leaderEntry = {
       id: "leader",
       name: this.leaderName,
+      startedAt: this.leaderStartedAt,
       status: this.leaderStatus,
       currentTool: this.leaderCurrentTool,
       iterations: this.leaderIterations,
@@ -29807,6 +30502,11 @@ var AgentStatusTracker = class {
       lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const allAgents = [leaderEntry, ...this.agents.values()];
+    this.lastAgents = allAgents;
+    try {
+      this.events.emit("session.agents_updated", { agents: allAgents });
+    } catch {
+    }
     this.registry.updateAgents(allAgents).then(() => {
       try {
         this.onUpdate?.();
@@ -29814,6 +30514,23 @@ var AgentStatusTracker = class {
       }
     }).catch(() => void 0);
   }
+  markLeaderStarted(startedAt) {
+    if (this.leaderStartedAt && (this.leaderStatus === "running" || this.leaderStatus === "streaming" || this.leaderStatus === "waiting_user")) {
+      return;
+    }
+    this.leaderStartedAt = startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  }
+  captureLeaderContext(ctx) {
+    if (typeof ctx !== "object" || ctx === null) return;
+    const c = ctx;
+    if (typeof c.model === "string" && c.model.length > 0) this.leaderModel = c.model;
+    const metaLimit = c.meta?.["effectiveMaxContext"];
+    const providerMax = c.provider?.capabilities?.maxContext;
+    const maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : void 0;
+    if (typeof c.lastRequestTokens === "number" && c.lastRequestTokens > 0 && maxContext !== void 0) {
+      this.leaderCtxPct = Math.round(c.lastRequestTokens / maxContext * 100);
+    }
+  }
 };
 var INSTANCES_FILE = "webui-instances.json";
 var DISCOVERY_TTL_MS = 2500;
@@ -30466,8 +31183,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat15 = await fsp3.stat(localPath);
-        if (stat15.isDirectory()) {
+        const stat16 = await fsp3.stat(localPath);
+        if (stat16.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp3.readFile(file, "utf8");
@@ -30492,8 +31209,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat15 = await fsp3.stat(localPath);
-        if (stat15.isDirectory()) {
+        const stat16 = await fsp3.stat(localPath);
+        if (stat16.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp3.readFile(file);
@@ -30684,7 +31401,13 @@ function parseHqFrame(raw) {
     }
   }
 }
-var KNOWN_HQ_EVENT_PAYLOAD_TYPES = /* @__PURE__ */ new Set(["mailbox.snapshot", "mailbox.event"]);
+var KNOWN_HQ_EVENT_PAYLOAD_TYPES = /* @__PURE__ */ new Set([
+  "mailbox.snapshot",
+  "mailbox.event",
+  "session.snapshot",
+  "session.transcript",
+  "session.ended"
+]);
 function isHqMailboxMessageSummary(x) {
   if (typeof x !== "object" || x === null) return false;
   const v = x;
@@ -30731,6 +31454,52 @@ function isHqMailboxEventPayload(x) {
   if (v.agent !== void 0 && !isHqMailboxAgentSummary(v.agent)) return false;
   return true;
 }
+var HQ_SESSION_AGENT_STATUSES = /* @__PURE__ */ new Set([
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error"
+]);
+function isHqSessionAgentSummary(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.id === "string" && typeof v.name === "string" && typeof v.status === "string" && HQ_SESSION_AGENT_STATUSES.has(v.status) && typeof v.iterations === "number" && typeof v.toolCalls === "number" && typeof v.lastActivityAt === "string";
+}
+var HQ_SESSION_STATUSES = /* @__PURE__ */ new Set(["active", "idle", "closing", "stale"]);
+function isHqSessionSnapshotPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.sessionId !== "string" || typeof v.clientKind !== "string" || typeof v.machineId !== "string" || typeof v.projectId !== "string" || typeof v.projectName !== "string" || typeof v.projectRoot !== "string" || typeof v.status !== "string" || !HQ_SESSION_STATUSES.has(v.status) || typeof v.startedAt !== "string" || typeof v.lastActivityAt !== "string" || typeof v.agentCount !== "number" || !Array.isArray(v.agents)) {
+    return false;
+  }
+  for (const agent of v.agents) {
+    if (!isHqSessionAgentSummary(agent)) return false;
+  }
+  return true;
+}
+var HQ_TRANSCRIPT_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "error"]);
+function isHqTranscriptEntry(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.ts === "string" && typeof v.role === "string" && HQ_TRANSCRIPT_ROLES.has(v.role) && typeof v.text === "string";
+}
+function isHqTranscriptAppendPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  if (typeof v.sessionId !== "string" || typeof v.fromSeq !== "number" || !Array.isArray(v.entries)) {
+    return false;
+  }
+  for (const entry of v.entries) {
+    if (!isHqTranscriptEntry(entry)) return false;
+  }
+  return true;
+}
+function isHqSessionEndedPayload(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const v = x;
+  return typeof v.sessionId === "string" && typeof v.endedAt === "string";
+}
 function parseHqEventPayload(eventType, payload) {
   if (!KNOWN_HQ_EVENT_PAYLOAD_TYPES.has(eventType)) {
     return { ok: true, payload };
@@ -30740,6 +31509,12 @@ function parseHqEventPayload(eventType, payload) {
       return isHqMailboxSnapshotPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
     case "mailbox.event":
       return isHqMailboxEventPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.snapshot":
+      return isHqSessionSnapshotPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.transcript":
+      return isHqTranscriptAppendPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
+    case "session.ended":
+      return isHqSessionEndedPayload(payload) ? { ok: true, payload } : { ok: false, reason: "malformed-payload" };
     default: {
       const _exhaustive = eventType;
       return _exhaustive;
@@ -31210,6 +31985,41 @@ var HqPublisher = class {
       ...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
     });
   }
+  /** The client identity this publisher announced (clientId, kind, machineId, …). */
+  get identity() {
+    return this.options.client;
+  }
+  /** The project identity this publisher is bound to. */
+  get project() {
+    return this.options.project;
+  }
+  /** Publish a live session/terminal snapshot (state + agents). */
+  publishSessionSnapshot(payload, opts) {
+    return this.publishEvent({
+      type: "session.snapshot",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
+  /** Publish an incremental batch of transcript turns for a session. */
+  publishTranscriptAppend(payload, opts) {
+    return this.publishEvent({
+      type: "session.transcript",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
+  /** Mark a session/terminal as ended. */
+  publishSessionEnded(payload, opts) {
+    return this.publishEvent({
+      type: "session.ended",
+      payload,
+      sessionId: payload.sessionId,
+      ...opts?.timestamp !== void 0 ? { timestamp: opts.timestamp } : {}
+    });
+  }
   pollCommands() {
     this.sendFrame({
       type: "client.command_poll",
@@ -31395,7 +32205,7 @@ var GlobalMailbox = class {
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
-   * @param hqPublisher — optional HQ publisher for cross-project telemetry
+   * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
    */
   constructor(projectDir, events, hqPublisher) {
     this.messagePath = path3.join(projectDir, MAILBOX_FILE);
@@ -31407,15 +32217,19 @@ var GlobalMailbox = class {
   get hqMailboxId() {
     return `${path3.basename(path3.dirname(this.messagePath))}:mailbox`;
   }
+  get hqPublisher() {
+    return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
+  }
   publishHqMailboxEvent(input) {
     try {
-      this._hqPublisher?.publishMailboxEvent(input);
+      this.hqPublisher?.publishMailboxEvent(input);
     } catch {
     }
   }
   publishHqMailboxSnapshot() {
-    if (this._hqPublisher === void 0) return;
-    void this._hqPublisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
+    const publisher = this.hqPublisher;
+    if (publisher === void 0) return;
+    void publisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
     });
   }
   // ── Messages ────────────────────────────────────────────────────────────
@@ -31777,30 +32591,69 @@ var GlobalMailbox = class {
   async _readMessages() {
     try {
       const raw = await fsp3.readFile(this.messagePath, "utf8");
-      const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
-      const messages = [];
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (!parsed["readBy"]) {
-            const readBy = {};
-            if (parsed["read"] && parsed["readAt"]) {
-              readBy[parsed["to"]] = parsed["readAt"];
-            }
-            parsed["readBy"] = readBy;
-            delete parsed["read"];
-            delete parsed["readAt"];
-          }
-          messages.push(parsed);
-        } catch {
-        }
-      }
-      return messages;
+      return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
   }
+  /**
+   * Read only newly-appended bytes from the file and append them to the
+   * in-memory cache. This avoids re-reading and re-parsing the entire file
+   * when another process appended messages since our last read.
+   *
+   * Only safe when the file grew in size (messages are append-only). When
+   * the file was rewritten (ack/purge changed existing content), callers
+   * must fall back to {@link _readMessages}.
+   *
+   * @returns The (now up-to-date) message cache.
+   */
+  async _readNewMessagesOnly(fd, oldSize, newSize) {
+    const tailLen = newSize - oldSize;
+    const buf = Buffer.alloc(tailLen);
+    await fd.read(buf, 0, tailLen, oldSize);
+    const tail = buf.toString("utf8");
+    for (const line of tail.split(LINE_SEPARATOR)) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"]] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        this._messageCache.push(parsed);
+      } catch {
+      }
+    }
+    return this._messageCache;
+  }
+  /** Parse a JSONL string into MailboxMessage[], including migration. */
+  _parseLines(raw) {
+    const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"]] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        messages.push(parsed);
+      } catch {
+      }
+    }
+    return messages;
+  }
   /**
    * Read messages, then adopt the result as the in-memory cache. Use this
    * from writers that just took the file lock — the read reflects the
@@ -31820,6 +32673,10 @@ var GlobalMailbox = class {
    * stat matches the cached mtime+size we return the cached array — no
    * file read and no JSON.parse — collapsing the per-iteration query
    * cost on the mailbox-loop hot path.
+   *
+   * When the file only grew (new messages appended by another process),
+   * we read and parse just the tail bytes instead of the entire file.
+   * This avoids re-parsing the full 10K-message history on every check.
    */
   async _readMessagesCached() {
     try {
@@ -31827,6 +32684,17 @@ var GlobalMailbox = class {
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
+      if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
+        const fd = await fsp3.open(this.messagePath, "r");
+        try {
+          const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
+          this._messageCacheMtime = st.mtimeMs;
+          this._messageCacheSize = st.size;
+          return updated;
+        } finally {
+          await fd.close();
+        }
+      }
       const all = await this._readMessages();
       this._setMessageCache(all, st.mtimeMs, st.size);
       return all;
@@ -32191,7 +33059,7 @@ function resolveHqConfig(options = {}) {
   };
 }
 function stableMachineId() {
-  return createHash("sha256").update(`${hostname()}:${process.pid}`).digest("hex").slice(0, 12);
+  return createHash("sha256").update(hostname()).digest("hex").slice(0, 12);
 }
 function deriveProjectId(projectRoot) {
   return createHash("sha256").update(projectRoot).digest("hex").slice(0, 12);
@@ -32233,6 +33101,381 @@ function createHqPublisherFromEnv(options) {
 function createGlobalMailbox(options) {
   return new GlobalMailbox(options.projectDir, options.events, options.hqPublisher);
 }
+
+// src/hq/agent-bridge.ts
+function startAgentMonitorEventBridge(opts) {
+  const { events, clientId, projectId, publish } = opts;
+  const seq = { current: 0 };
+  function nextSeq() {
+    seq.current += 1;
+    return seq.current;
+  }
+  function buildEnvelope(type, payload) {
+    return createHqEventEnvelope({
+      id: `${Date.now().toString(36)}-${nextSeq()}`,
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      clientId,
+      projectId,
+      seq: nextSeq(),
+      payload
+    });
+  }
+  const offMessage = events.on("agent.timeline.message", (payload) => {
+    if (!publish) return;
+    const msgPayload = {
+      subagentId: payload.subagentId,
+      agentName: payload.agentName,
+      content: payload.content,
+      kind: payload.kind,
+      iteration: payload.iteration,
+      ts: payload.ts
+    };
+    if (payload.toolName !== void 0) msgPayload.toolName = payload.toolName;
+    if (payload.costUsd !== void 0) msgPayload.costUsd = payload.costUsd;
+    publish(buildEnvelope("agent.message", msgPayload));
+  });
+  const offStatus = events.on("agent.status_changed", (payload) => {
+    if (!publish) return;
+    const statusPayload = {
+      subagentId: payload.subagentId,
+      agentName: payload.agentName,
+      status: payload.status,
+      ts: payload.ts
+    };
+    if (payload.summary !== void 0) statusPayload.summary = payload.summary;
+    if (payload.task !== void 0) statusPayload.task = payload.task;
+    publish(buildEnvelope("agent.status", statusPayload));
+  });
+  return () => {
+    offMessage();
+    offStatus();
+  };
+}
+
+// src/hq/transcript-mapper.ts
+function blocksToText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(
+      (b) => !!b && typeof b === "object" && b.type === "text" && typeof b.text === "string"
+    ).map((b) => b.text).join("\n");
+  }
+  return "";
+}
+function asString(v) {
+  if (typeof v === "string") return v;
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}
+function argsEntry(ts, name, input, id) {
+  return {
+    ts,
+    role: "tool",
+    tool: String(name ?? "tool"),
+    toolInput: input !== void 0 && input !== null ? asString(input) : "{}",
+    text: "",
+    ...typeof id === "string" ? { toolUseId: id } : {}
+  };
+}
+function mapSessionEventToEntries(ev) {
+  const ts = typeof ev["ts"] === "string" ? ev["ts"] : "";
+  const make = (role, text, extra) => ({
+    ts,
+    role,
+    text,
+    ...extra
+  });
+  switch (ev["type"]) {
+    case "user_input": {
+      const t2 = blocksToText(ev["content"]);
+      return t2.trim() ? [make("user", t2)] : [];
+    }
+    case "llm_response": {
+      const out = [];
+      const t2 = blocksToText(ev["content"]);
+      if (t2.trim()) out.push(make("assistant", t2));
+      const content = ev["content"];
+      if (Array.isArray(content)) {
+        for (const b of content) {
+          if (b && typeof b === "object" && b.type === "tool_use") {
+            const block = b;
+            out.push(argsEntry(ts, block.name, block.input, block.id));
+          }
+        }
+      }
+      return out;
+    }
+    case "tool_use":
+      return [argsEntry(ts, ev["name"], ev["input"], ev["id"])];
+    case "tool_call_start":
+      return [argsEntry(ts, ev["name"], ev["input"] ?? ev["args"], ev["id"])];
+    case "tool_result": {
+      const isError = ev["isError"] === true;
+      const content = ev["content"] ?? ev["output"];
+      const outStr = content !== void 0 && content !== null ? asString(content) : "";
+      return [
+        make(isError ? "error" : "tool", outStr, {
+          tool: "\u21B3 result",
+          ...isError ? { isError: true } : {},
+          ...typeof ev["id"] === "string" ? { toolUseId: ev["id"] } : {}
+        })
+      ];
+    }
+    case "tool_call_end": {
+      const isError = ev["isError"] === true;
+      const content = ev["output"] ?? ev["content"];
+      const outStr = content !== void 0 && content !== null ? asString(content) : "";
+      if (!outStr.trim() && !isError && typeof ev["durationMs"] !== "number") return [];
+      return [
+        make(isError ? "error" : "tool", outStr, {
+          tool: typeof ev["name"] === "string" ? String(ev["name"]) : "\u21B3 result",
+          ...typeof ev["durationMs"] === "number" ? { durationMs: ev["durationMs"] } : {},
+          ...isError ? { isError: true } : {},
+          ...typeof ev["id"] === "string" ? { toolUseId: ev["id"] } : {}
+        })
+      ];
+    }
+    case "error":
+    case "provider_error":
+      return [make("error", String(ev["message"] ?? "error"))];
+    case "agent_spawned":
+      return [make("system", `spawned ${String(ev["role"] ?? "agent")}`)];
+    case "task_completed":
+      return [make("system", `task done: ${String(ev["title"] ?? "")}`)];
+    case "task_failed":
+      return [make("system", `task failed: ${String(ev["title"] ?? "")}`)];
+    default:
+      return [];
+  }
+}
+function isResultEntry(e) {
+  return (e.role === "tool" || e.role === "error") && e.toolUseId !== void 0 && e.toolInput === void 0;
+}
+function mergeToolResults(flat) {
+  const out = [];
+  const argsById = /* @__PURE__ */ new Map();
+  for (const src of flat) {
+    const e = { ...src };
+    if (isResultEntry(e) && e.toolUseId !== void 0) {
+      const tgt = argsById.get(e.toolUseId);
+      if (tgt) {
+        tgt.text = e.text || "";
+        if (e.durationMs !== void 0) tgt.durationMs = e.durationMs;
+        if (e.isError) {
+          tgt.role = "error";
+          tgt.isError = true;
+        }
+        continue;
+      }
+    }
+    out.push(e);
+    if (e.role === "tool" && e.toolUseId !== void 0 && e.toolInput !== void 0) {
+      argsById.set(e.toolUseId, e);
+    }
+  }
+  return out;
+}
+function buildTranscriptFromEvents(events) {
+  const flat = [];
+  for (const ev of events) {
+    for (const e of mapSessionEventToEntries(ev)) flat.push(e);
+  }
+  return mergeToolResults(flat);
+}
+
+// src/hq/session-bridge.ts
+var VALID_AGENT_STATUS = /* @__PURE__ */ new Set([
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error"
+]);
+function toAgentSummary(a) {
+  const status = VALID_AGENT_STATUS.has(a.status) ? a.status : "idle";
+  return {
+    id: a.id,
+    name: a.name,
+    status,
+    iterations: a.iterations,
+    toolCalls: a.toolCalls,
+    lastActivityAt: a.lastActivityAt,
+    ...a.startedAt !== void 0 ? { startedAt: a.startedAt } : {},
+    ...a.currentTool !== void 0 ? { currentTool: a.currentTool } : {},
+    ...a.costUsd !== void 0 ? { costUsd: a.costUsd } : {},
+    ...a.tokensIn !== void 0 ? { tokensIn: a.tokensIn } : {},
+    ...a.tokensOut !== void 0 ? { tokensOut: a.tokensOut } : {},
+    ...a.ctxPct !== void 0 ? { ctxPct: a.ctxPct } : {},
+    ...a.model !== void 0 ? { model: a.model } : {},
+    ...a.partialText !== void 0 ? { partialText: a.partialText } : {}
+  };
+}
+function deriveSessionStatus(agents) {
+  return agents.some(
+    (a) => a.status === "running" || a.status === "streaming" || a.status === "waiting_user"
+  ) ? "active" : "idle";
+}
+function startSessionTelemetryBridge(opts) {
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const publisher = opts.publisher;
+  const identity = publisher.identity;
+  const project = publisher.project;
+  const startedAt = opts.startedAt ?? now();
+  const wpaths = resolveWstackPaths({
+    projectRoot: opts.projectRoot,
+    ...opts.globalRoot !== void 0 ? { globalRoot: opts.globalRoot } : {}
+  });
+  const sessionFile = path3.join(wpaths.projectSessions, `${opts.sessionId}.jsonl`);
+  let agents = (opts.initialAgents ?? []).map(toAgentSummary);
+  let lastActivityAt = agents.reduce(
+    (latest, agent) => agent.lastActivityAt > latest ? agent.lastActivityAt : latest,
+    startedAt
+  );
+  let lastSnapshotHash = "";
+  let disposed = false;
+  function buildSnapshot() {
+    return {
+      sessionId: opts.sessionId,
+      clientKind: identity.kind,
+      machineId: identity.machineId,
+      projectId: project.projectId,
+      projectName: opts.projectName ?? project.projectName,
+      projectRoot: opts.projectRoot,
+      status: deriveSessionStatus(agents),
+      startedAt,
+      lastActivityAt,
+      agentCount: agents.length,
+      agents,
+      ...identity.hostname !== void 0 ? { hostname: identity.hostname } : {},
+      ...identity.pid !== void 0 ? { pid: identity.pid } : {},
+      ...opts.gitBranch !== void 0 ? { gitBranch: opts.gitBranch } : {}
+    };
+  }
+  function publishSnapshot(force = false) {
+    if (disposed) return;
+    const snap = buildSnapshot();
+    const hash = JSON.stringify({ ...snap, lastActivityAt: "" });
+    if (!force && hash === lastSnapshotHash) return;
+    lastSnapshotHash = hash;
+    try {
+      publisher.publishSessionSnapshot(snap);
+    } catch {
+    }
+  }
+  const offAgents = opts.events?.on("session.agents_updated", (payload) => {
+    agents = payload.agents.map(toAgentSummary);
+    lastActivityAt = now();
+    publishSnapshot();
+  });
+  publishSnapshot(true);
+  let offset = 0;
+  let partial = "";
+  let seqEmitted = 0;
+  let tailing = false;
+  let watcher = null;
+  let watchPending = false;
+  function setupWatcher() {
+    if (disposed || watcher) return;
+    try {
+      const nextWatcher = fs3.watch(sessionFile, () => {
+        if (watchPending || disposed) return;
+        watchPending = true;
+        setTimeout(() => {
+          watchPending = false;
+          void tail();
+        }, 25);
+      });
+      nextWatcher.on("error", () => {
+        try {
+          nextWatcher.close();
+        } catch {
+        }
+        if (watcher === nextWatcher) watcher = null;
+      });
+      watcher = nextWatcher;
+    } catch {
+      watcher = null;
+    }
+  }
+  async function tail() {
+    if (disposed || tailing) return;
+    tailing = true;
+    try {
+      const stat16 = await fsp3.stat(sessionFile).catch(() => null);
+      if (disposed) return;
+      if (!stat16) return;
+      setupWatcher();
+      if (stat16.size <= offset) return;
+      const fd = await fsp3.open(sessionFile, "r");
+      try {
+        if (disposed) return;
+        const len = stat16.size - offset;
+        const buf = Buffer.allocUnsafe(len);
+        await fd.read(buf, 0, len, offset);
+        offset = stat16.size;
+        partial += buf.toString("utf8");
+        const lines = partial.split("\n");
+        partial = lines.pop() ?? "";
+        const entries = [];
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          let obj;
+          try {
+            obj = JSON.parse(trimmed);
+          } catch {
+            continue;
+          }
+          for (const entry of mapSessionEventToEntries(obj)) entries.push(entry);
+        }
+        if (entries.length > 0) {
+          try {
+            publisher.publishTranscriptAppend({
+              sessionId: opts.sessionId,
+              fromSeq: seqEmitted,
+              entries
+            });
+          } catch {
+          }
+          seqEmitted += entries.length;
+          lastActivityAt = now();
+        }
+      } finally {
+        await fd.close();
+      }
+    } catch {
+    } finally {
+      tailing = false;
+    }
+  }
+  const snapshotTimer = setInterval(() => publishSnapshot(true), opts.snapshotIntervalMs ?? 2500);
+  const tailTimer = setInterval(() => void tail(), opts.transcriptIntervalMs ?? 500);
+  snapshotTimer.unref?.();
+  tailTimer.unref?.();
+  void tail();
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    offAgents?.();
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    clearInterval(snapshotTimer);
+    clearInterval(tailTimer);
+    try {
+      publisher.publishSessionEnded({ sessionId: opts.sessionId, endedAt: now() });
+    } catch {
+    }
+  };
+}
 var MATCHERS = {
   pnpmWorkspace: (files) => files.includes("pnpm-workspace.yaml"),
   gradlew: (_files, dirs) => dirs.includes("gradlew"),
@@ -33110,8 +34353,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir23 } = await import('fs/promises');
-      await mkdir23(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir24 } = await import('fs/promises');
+      await mkdir24(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -33399,7 +34642,7 @@ var SecurityScannerOrchestrator = class {
         message: errAsErr.message,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
-      await new Promise((resolve18) => setTimeout(resolve18, delay));
+      await new Promise((resolve19) => setTimeout(resolve19, delay));
       return this.completeWithRetry(provider, request, abortController, attempt + 1);
     }
   }
@@ -34532,12 +35775,12 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve18) => {
-      const entry = { request, resolve: resolve18 };
+    const pending = new Promise((resolve19) => {
+      const entry = { request, resolve: resolve19 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
-          resolve18({ type: "deny", reason: "Brain human decision timed out." });
+          resolve19({ type: "deny", reason: "Brain human decision timed out." });
         }, this.opts.timeoutMs);
       }
       this.pending.set(request.id, entry);
@@ -34639,6 +35882,10 @@ var DefaultMailbox = class {
   _messageCache = null;
   _messageCacheMtime = -1;
   _messageCacheSize = -1;
+  /** Primary index: recipient → Set of messages (points into _messageCache). */
+  _byTo = /* @__PURE__ */ new Map();
+  /** Secondary index: sender → Set of messages (points into _messageCache). */
+  _byFrom = /* @__PURE__ */ new Map();
   constructor(sessionDir) {
     this.filePath = path3.join(sessionDir, MAILBOX_FILE2);
   }
@@ -34674,12 +35921,30 @@ var DefaultMailbox = class {
   }
   // ── Query ─────────────────────────────────────────────────────────────
   async query(q) {
-    const all = await this._readAllCached();
+    const needFullScan = q.unreadBy !== void 0 || q.since !== void 0;
+    let candidates;
+    if (needFullScan) {
+      candidates = await this._readAllCached();
+    } else {
+      await this._readAllCached();
+      if (q.to !== void 0) {
+        const direct = this._byTo.get(q.to);
+        const broadcast = this._byTo.get("*");
+        const combined = /* @__PURE__ */ new Map();
+        if (direct) for (const m of direct) combined.set(m.id, m);
+        if (broadcast) for (const m of broadcast) combined.set(m.id, m);
+        candidates = Array.from(combined.values());
+      } else if (q.from !== void 0) {
+        candidates = Array.from(this._byFrom.get(q.from) ?? []);
+      } else {
+        candidates = await this._readAllCached();
+      }
+    }
     const limit = q.limit ?? 50;
     const order = q.minPriority !== void 0 ? { low: 0, normal: 1, high: 2 } : null;
     const minPriorityRank = order && q.minPriority !== void 0 ? order[q.minPriority] : 0;
     const filtered = [];
-    for (const msg of all) {
+    for (const msg of candidates) {
       if (q.to !== void 0 && msg.to !== q.to && msg.to !== "*") continue;
       if (q.from !== void 0 && msg.from !== q.from) continue;
       if (q.unreadBy !== void 0 && q.unreadBy in msg.readBy) continue;
@@ -34780,6 +36045,8 @@ var DefaultMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._byTo.clear();
+    this._byFrom.clear();
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
@@ -34838,36 +36105,81 @@ var DefaultMailbox = class {
   async _readAll() {
     try {
       const raw = await fsp3.readFile(this.filePath, "utf8");
-      const lines = raw.split(LINE_SEPARATOR2).filter((l) => l.trim().length > 0);
-      const messages = [];
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (!parsed["readBy"]) {
-            const readBy = {};
-            if (parsed["read"] && parsed["readAt"]) {
-              readBy[parsed["to"] ?? "unknown"] = parsed["readAt"];
-            }
-            parsed["readBy"] = readBy;
-            delete parsed["read"];
-            delete parsed["readAt"];
-          }
-          messages.push(parsed);
-        } catch {
-        }
-      }
-      return messages;
+      return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
   }
+  /**
+   * Read only newly-appended bytes from the file and append them to the
+   * in-memory cache, avoiding a full re-read when the file only grew.
+   */
+  async _readNewMessagesOnly(fd, oldSize, newSize) {
+    const tailLen = newSize - oldSize;
+    const buf = Buffer.alloc(tailLen);
+    await fd.read(buf, 0, tailLen, oldSize);
+    const tail = buf.toString("utf8");
+    for (const line of tail.split(LINE_SEPARATOR2)) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"] ?? "unknown"] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        const msg = parsed;
+        this._messageCache.push(msg);
+        this._indexMsg(msg);
+      } catch {
+      }
+    }
+    return this._messageCache;
+  }
+  /** Parse a JSONL string into MailboxMessage[], including migration. */
+  _parseLines(raw) {
+    const lines = raw.split(LINE_SEPARATOR2).filter((l) => l.trim().length > 0);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (!parsed["readBy"]) {
+          const readBy = {};
+          if (parsed["read"] && parsed["readAt"]) {
+            readBy[parsed["to"] ?? "unknown"] = parsed["readAt"];
+          }
+          parsed["readBy"] = readBy;
+          delete parsed["read"];
+          delete parsed["readAt"];
+        }
+        messages.push(parsed);
+      } catch {
+      }
+    }
+    return messages;
+  }
   async _readAllCached() {
     try {
       const st = await fsp3.stat(this.filePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
+      if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
+        const fd = await fsp3.open(this.filePath, "r");
+        try {
+          const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
+          this._messageCacheMtime = st.mtimeMs;
+          this._messageCacheSize = st.size;
+          return updated;
+        } finally {
+          await fd.close();
+        }
+      }
       const all = await this._readAll();
       this._setMessageCache(all, st.mtimeMs, st.size);
       return all;
@@ -34884,9 +36196,12 @@ var DefaultMailbox = class {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
+      this._byTo.clear();
+      this._byFrom.clear();
       return;
     }
     this._messageCache = messages;
+    this._buildIndexes(messages);
     if (mtime !== void 0 && size !== void 0) {
       this._messageCacheMtime = mtime;
       this._messageCacheSize = size;
@@ -34904,9 +36219,35 @@ var DefaultMailbox = class {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
+      this._byTo.clear();
+      this._byFrom.clear();
       return;
     }
     this._messageCache.push(msg);
+    this._indexMsg(msg);
+  }
+  /** Rebuild both indexes from a full message list. */
+  _buildIndexes(messages) {
+    this._byTo.clear();
+    this._byFrom.clear();
+    for (const msg of messages) {
+      this._indexMsg(msg);
+    }
+  }
+  /** Add a single message to both indexes. */
+  _indexMsg(msg) {
+    const toSet = this._byTo.get(msg.to);
+    if (toSet) {
+      toSet.add(msg);
+    } else {
+      this._byTo.set(msg.to, /* @__PURE__ */ new Set([msg]));
+    }
+    const fromSet = this._byFrom.get(msg.from);
+    if (fromSet) {
+      fromSet.add(msg);
+    } else {
+      this._byFrom.set(msg.from, /* @__PURE__ */ new Set([msg]));
+    }
   }
 };
 var BrainMonitor = class {
@@ -38053,17 +39394,17 @@ ${input.detail}`
   _waitForDagProgress(timeoutMs) {
     const before = this._dagProgressKey();
     if (this.dag.isDone()) return Promise.resolve();
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       let off;
       const timer = setTimeout(() => {
         off?.();
-        resolve18();
+        resolve19();
       }, timeoutMs);
       off = this.dag.onEvent(() => {
         if (this._dagProgressKey() === before) return;
         clearTimeout(timer);
         off?.();
-        resolve18();
+        resolve19();
       });
     });
   }
@@ -38337,6 +39678,442 @@ ${input.detail}`
     this.onCoordinatorEvent?.(event);
   }
 };
+var AgentMonitorService = class {
+  _fleetBus;
+  _events;
+  _transcriptsDir;
+  _maxEntries;
+  _streamEnabled;
+  _onEntry;
+  /** Per-subagent virtual sessions. */
+  _sessions = /* @__PURE__ */ new Map();
+  /** Disposers for FleetBus subscriptions, keyed by subagentId. */
+  _subscriptions = /* @__PURE__ */ new Map();
+  /** Generic fleet-wide subscription disposer. */
+  _fleetDisposer;
+  /** Track whether service is running. */
+  _started = false;
+  constructor(opts) {
+    this._fleetBus = opts.fleetBus;
+    this._events = opts.events;
+    this._transcriptsDir = opts.transcriptsDir;
+    this._maxEntries = opts.maxEntriesPerAgent ?? 500;
+    this._streamEnabled = opts.streamEnabled ?? false;
+    this._onEntry = opts.onEntry;
+  }
+  // ── Public API ────────────────────────────────────────────────────
+  /** Set the FleetBus to listen on. Must be called before `start()`. */
+  setFleetBus(bus) {
+    this._fleetBus = bus;
+  }
+  get streamEnabled() {
+    return this._streamEnabled;
+  }
+  /** Enable/disable streaming agent conversations to the main chat timeline. */
+  setStreamEnabled(enabled) {
+    this._streamEnabled = enabled;
+  }
+  /** Get a snapshot of all known agent sessions. */
+  getAllSessions() {
+    return Array.from(this._sessions.values());
+  }
+  /** Get a specific agent's virtual session, or undefined. */
+  getSession(subagentId) {
+    return this._sessions.get(subagentId);
+  }
+  /** Get transcript entries for a specific agent, newest first. */
+  getTranscript(subagentId, limit = 50) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return [];
+    return session.transcript.slice(-limit).reverse();
+  }
+  /** Set a callback for each new timeline entry (HQ bridge). */
+  setOnEntry(handler) {
+    this._onEntry = handler;
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────
+  /** Start listening to FleetBus events. */
+  start() {
+    if (this._started) return;
+    if (!this._fleetBus) {
+      this._started = true;
+      return;
+    }
+    this._started = true;
+    this._fleetDisposer = this._fleetBus.onAny((event) => {
+      this._routeEvent(event.subagentId, event.type, event.payload);
+    });
+  }
+  /** Stop listening and clean up all subscriptions. */
+  stop() {
+    if (!this._started) return;
+    this._started = false;
+    if (this._fleetDisposer) {
+      this._fleetDisposer();
+      this._fleetDisposer = void 0;
+    }
+    for (const disposer of this._subscriptions.values()) {
+      disposer();
+    }
+    this._subscriptions.clear();
+  }
+  /** Ensure a subagent is being tracked. Called when a subagent spawns. */
+  trackSubagent(subagentId, agentName, task) {
+    if (this._sessions.has(subagentId)) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      subagentId,
+      agentName,
+      createdAt: now,
+      status: "spawned",
+      task,
+      transcript: []
+    };
+    this._sessions.set(subagentId, session);
+    this._addEntry(subagentId, {
+      id: this._uid(),
+      subagentId,
+      agentName,
+      ts: now,
+      kind: "system",
+      content: task ? `\u{1F3AF} Spawned: ${task}` : "\u{1F916} Agent spawned",
+      iteration: 0
+    });
+    this._events.emit("agent.status_changed", {
+      subagentId,
+      agentName,
+      status: "spawned",
+      ts: now,
+      summary: task,
+      task
+    });
+  }
+  /** Mark a subagent as completed/failed/etc. Called on subagent finish. */
+  completeSubagent(subagentId, status, summary) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    session.status = status;
+    this._addEntry(subagentId, {
+      id: this._uid(),
+      subagentId,
+      agentName: session.agentName,
+      ts: now,
+      kind: "status",
+      content: summary ?? `Agent ${status}`,
+      iteration: 999
+    });
+    this._events.emit("agent.status_changed", {
+      subagentId,
+      agentName: session.agentName,
+      status,
+      ts: now,
+      summary,
+      task: session.task
+    });
+  }
+  // ── Internal ───────────────────────────────────────────────────────
+  _routeEvent(subagentId, type, payload) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    switch (type) {
+      case "provider.text_delta": {
+        const text = payload.text;
+        if (!text || text.length === 0) return;
+        const iteration = payload.iteration ?? 0;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "text",
+          content: text,
+          iteration
+        });
+        break;
+      }
+      case "provider.thinking_delta": {
+        const text = payload.text;
+        if (!text || text.length === 0) return;
+        const iteration = payload.iteration ?? 0;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "text",
+          content: `\u{1F9E0} ${text}`,
+          iteration
+        });
+        break;
+      }
+      case "tool.started": {
+        const name = payload.name;
+        if (!name) return;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "tool_use",
+          content: `\u{1F527} ${name}()`,
+          iteration: payload.iteration ?? 0,
+          toolName: name
+        });
+        break;
+      }
+      case "tool.executed": {
+        const name = payload.name;
+        const ok = payload.ok;
+        const durationMs = payload.durationMs;
+        if (!name) return;
+        const statusIcon2 = ok ? "\u2705" : "\u274C";
+        const duration = durationMs !== void 0 ? ` (${durationMs}ms)` : "";
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "tool_result",
+          content: `${statusIcon2} ${name}${duration}`,
+          iteration: payload.iteration ?? 0,
+          toolName: name,
+          toolOk: ok
+        });
+        break;
+      }
+      case "iteration.completed": {
+        const index = payload.index ?? 0;
+        if (index > 0 && index % 5 === 0) {
+          this._addEntry(subagentId, {
+            id: this._uid(),
+            subagentId,
+            agentName: session.agentName,
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            kind: "status",
+            content: `\u{1F504} Iteration ${index}`,
+            iteration: index
+          });
+        }
+        break;
+      }
+    }
+  }
+  _addEntry(subagentId, entry) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    session.transcript.push(entry);
+    if (session.transcript.length > this._maxEntries) {
+      session.transcript.splice(0, session.transcript.length - this._maxEntries);
+    }
+    this._appendToFile(subagentId, entry).catch(() => {
+    });
+    this._events.emit("agent.timeline.message", {
+      subagentId: entry.subagentId,
+      agentName: entry.agentName,
+      content: entry.content,
+      kind: entry.kind === "tool_result" ? "tool_use" : entry.kind === "system" ? "status" : entry.kind,
+      iteration: entry.iteration,
+      ts: entry.ts,
+      toolName: entry.toolName,
+      costUsd: entry.costUsd
+    });
+    this._onEntry?.(entry);
+  }
+  async _appendToFile(subagentId, entry) {
+    const dir = path3.join(this._transcriptsDir, subagentId);
+    await fsp3.mkdir(dir, { recursive: true });
+    const filePath = path3.join(dir, "transcript.jsonl");
+    const line = JSON.stringify(entry) + "\n";
+    await fsp3.appendFile(filePath, line, { encoding: "utf8" });
+  }
+  _uid() {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  }
+};
+function createAgentMonitorService(opts) {
+  return new AgentMonitorService(opts);
+}
+
+// src/coordination/adaptive-concurrency.ts
+var DEFAULT_CONFIG = Object.freeze({
+  enabled: false,
+  minConcurrent: 1,
+  maxConcurrent: 16,
+  decreaseFactor: 0.5,
+  successThreshold: 10,
+  recoveryIntervalMs: 3e4
+});
+var AdaptiveConcurrencyController = class {
+  config;
+  state;
+  disposers = [];
+  stateChangeHandlers = [];
+  constructor(fleetBus, setMaxConcurrent, config = {}, onStateChange) {
+    this.config = {
+      enabled: config.enabled ?? DEFAULT_CONFIG.enabled,
+      minConcurrent: config.minConcurrent ?? DEFAULT_CONFIG.minConcurrent,
+      maxConcurrent: config.maxConcurrent ?? DEFAULT_CONFIG.maxConcurrent,
+      decreaseFactor: config.decreaseFactor ?? DEFAULT_CONFIG.decreaseFactor,
+      successThreshold: config.successThreshold ?? DEFAULT_CONFIG.successThreshold,
+      recoveryIntervalMs: config.recoveryIntervalMs ?? DEFAULT_CONFIG.recoveryIntervalMs
+    };
+    this.state = {
+      current: this.config.maxConcurrent,
+      min: this.config.minConcurrent,
+      max: this.config.maxConcurrent,
+      consecutiveSuccesses: 0,
+      consecutiveFailures: 0,
+      totalDecreases: 0,
+      totalIncreases: 0,
+      enabled: this.config.enabled
+    };
+    if (onStateChange) {
+      this.stateChangeHandlers.push(onStateChange);
+    }
+    if (this.config.enabled) {
+      setMaxConcurrent(this.state.current);
+    }
+    this.setupEventHandlers(fleetBus, setMaxConcurrent);
+  }
+  setupEventHandlers(fleetBus, setMaxConcurrent) {
+    if (!this.config.enabled) return;
+    const off = fleetBus.onAny((event) => {
+      if (!this.config.enabled) return;
+      if (event.type === "error" || event.type === "provider_error") {
+        const payload = event.payload;
+        if (payload?.status === 429 || payload?.code === "rate_limit_error" || payload?.kind === "rate_limit") {
+          this.handleRateLimit(setMaxConcurrent);
+        }
+      }
+    });
+    this.disposers.push(off);
+  }
+  /**
+   * Handle a rate limit (429) error - decrease concurrency
+   */
+  handleRateLimit(setMaxConcurrent) {
+    if (this.state.current <= this.config.minConcurrent) {
+      this.state.consecutiveFailures++;
+      this.state.consecutiveSuccesses = 0;
+      this.notifyStateChange();
+      return;
+    }
+    const newConcurrent = Math.max(
+      this.config.minConcurrent,
+      Math.floor(this.state.current * this.config.decreaseFactor)
+    );
+    if (newConcurrent < this.state.current) {
+      const previousConcurrent = this.state.current;
+      this.state.current = newConcurrent;
+      this.state.consecutiveFailures++;
+      this.state.consecutiveSuccesses = 0;
+      this.state.totalDecreases++;
+      setMaxConcurrent(this.state.current);
+      this.notifyStateChange();
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          event: "adaptive_concurrency.decreased",
+          reason: "rate_limit",
+          previousConcurrent,
+          newConcurrent: this.state.current,
+          decreaseFactor: this.config.decreaseFactor,
+          totalDecreases: this.state.totalDecreases
+        })
+      );
+    }
+  }
+  /**
+   * Force a decrease (e.g., manual trigger or other error types)
+   */
+  decrease(target) {
+    if (!this.config.enabled) return;
+    const newConcurrent = target ?? Math.max(
+      this.config.minConcurrent,
+      Math.floor(this.state.current * this.config.decreaseFactor)
+    );
+    if (newConcurrent < this.state.current) {
+      const previousConcurrent = this.state.current;
+      this.state.current = newConcurrent;
+      this.state.consecutiveSuccesses = 0;
+      this.state.totalDecreases++;
+      this.notifyStateChange();
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          event: "adaptive_concurrency.decreased",
+          reason: "manual",
+          previousConcurrent,
+          newConcurrent: this.state.current,
+          totalDecreases: this.state.totalDecreases
+        })
+      );
+    }
+  }
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Update configuration at runtime
+   */
+  updateConfig(config) {
+    if (config.enabled !== void 0) {
+      this.config.enabled = config.enabled;
+    }
+    if (config.minConcurrent !== void 0) {
+      this.config.minConcurrent = config.minConcurrent;
+    }
+    if (config.maxConcurrent !== void 0) {
+      this.config.maxConcurrent = config.maxConcurrent;
+    }
+    if (config.decreaseFactor !== void 0) {
+      this.config.decreaseFactor = config.decreaseFactor;
+    }
+    if (config.successThreshold !== void 0) {
+      this.config.successThreshold = config.successThreshold;
+    }
+    if (config.recoveryIntervalMs !== void 0) {
+      this.config.recoveryIntervalMs = config.recoveryIntervalMs;
+    }
+    this.state.current = Math.max(this.config.minConcurrent, Math.min(this.state.current, this.config.maxConcurrent));
+    this.state.enabled = this.config.enabled;
+    this.state.min = this.config.minConcurrent;
+    this.state.max = this.config.maxConcurrent;
+    this.notifyStateChange();
+  }
+  /**
+   * Dispose of the controller and clean up event listeners
+   */
+  dispose() {
+    for (const dispose of this.disposers) {
+      dispose();
+    }
+    this.disposers.length = 0;
+    this.stateChangeHandlers = [];
+  }
+  notifyStateChange() {
+    const state = this.getState();
+    for (const handler of this.stateChangeHandlers) {
+      handler(state);
+    }
+  }
+  /**
+   * Register a state change handler
+   */
+  onStateChange(handler) {
+    this.stateChangeHandlers.push(handler);
+    return () => {
+      const index = this.stateChangeHandlers.indexOf(handler);
+      if (index !== -1) {
+        this.stateChangeHandlers.splice(index, 1);
+      }
+    };
+  }
+};
 
 // src/tools/mcp-control.ts
 function createMcpControlTool(opts) {
@@ -38364,11 +40141,18 @@ function createMcpControlTool(opts) {
   };
   return {
     name: "mcp_control",
-    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers. Use activate/deactivate to ephemerally toggle tool registration without disconnecting \u2014 ideal for token-saving mode where MCP tools are lazy-loaded on demand.",
+    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers. Use activate/deactivate to ephemerally toggle tool registration without disconnecting \u2014 ideal for token-saving mode where MCP tools are lazy-loaded on demand. NOTE: `enable`/`restart` start a server process, which for the built-in stdio presets runs `npx -y <package>` \u2014 i.e. it fetches and executes an npm package from the network. Treat it as code execution.",
     category: "mcp",
     permission: "auto",
     mutating: true,
-    riskTier: "standard",
+    // `enable`/`restart` spawn a server process that, for the stdio presets,
+    // fetches and runs an npm package (`npx -y <pkg>`) — effectively remote
+    // code execution. Marking the tool destructive means the YOLO
+    // `confirmDestructive` safety net still prompts before it runs (plain
+    // non-YOLO already confirms via the CONFIG_MUTATE dangerous-capability
+    // net in the executor). Read-only actions (list/search) ride the same
+    // tool but are cheap to confirm/trust once.
+    riskTier: "destructive",
     capabilities: [ToolCapabilities.CONFIG_MUTATE],
     inputSchema,
     async execute(raw) {
@@ -38890,13 +40674,13 @@ function createAgentToolHandler(a) {
     }
   }
   function waitForConfirm(info) {
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       a.events.emit("tool.confirm_needed", {
         tool: info.tool,
         input: info.input,
         toolUseId: info.toolUseId,
         suggestedPattern: info.suggestedPattern,
-        resolve: resolve18
+        resolve: resolve19
       });
     });
   }
@@ -39433,12 +41217,12 @@ function attachMailboxCheckerInner(a, source) {
 // src/core/iteration-limit.ts
 function requestLimitExtension(opts) {
   const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     let resolved = false;
     const timerFired = () => {
       if (!resolved) {
         resolved = true;
-        resolve18(0);
+        resolve19(0);
       }
     };
     const timer = setTimeout(timerFired, timeoutMs);
@@ -39447,14 +41231,14 @@ function requestLimitExtension(opts) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve18(0);
+        resolve19(0);
       }
     };
     const grant = (extra) => {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve18(Math.max(0, extra));
+        resolve19(Math.max(0, extra));
       }
     };
     events.emit("iteration.limit_reached", {
@@ -39468,7 +41252,7 @@ function requestLimitExtension(opts) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve18(100);
+          resolve19(100);
         }
       });
     }
@@ -39489,25 +41273,29 @@ function createAgentLoopHandler(a, handlers) {
   const checkMailbox = attachMailboxChecker(a);
   async function compactContextIfNeeded() {
     const msgCount = a.ctx.messages.length;
-    if (_lastCompactionMsgCount === msgCount && _lastCompactionWasNoop && _maxContext > 0) {
+    const maxContext = currentMaxContext();
+    if (_lastCompactionMsgCount === msgCount && _lastCompactionWasNoop && _lastCompactionMaxContext === maxContext && maxContext > 0) {
       return;
     }
     await a.pipelines.contextWindow.run(a.ctx);
     _lastCompactionMsgCount = msgCount;
+    _lastCompactionMaxContext = maxContext;
     const stashed = a.ctx.lastRequestTokens;
     const tokens = typeof stashed === "number" && stashed > 0 ? stashed : 0;
-    const load = _maxContext > 0 ? tokens / _maxContext : 0;
+    const load = maxContext > 0 ? tokens / maxContext : 0;
     _lastCompactionWasNoop = tokens > 0 && load < 0.5;
   }
   const calibrationKey = (model = a.ctx.model) => `${a.ctx.provider?.id ?? "unknown"}/${model}`;
   function emitContextPct() {
     const msgCount = a.ctx.messages.length;
     const toolCount = (a.ctx.tools ?? []).length;
-    if (msgCount === _lastEmittedMsgCount && toolCount === _lastEmittedToolCount && _maxContext > 0) {
+    const maxContext = currentMaxContext();
+    if (msgCount === _lastEmittedMsgCount && toolCount === _lastEmittedToolCount && maxContext === _lastEmittedMaxContext && maxContext > 0) {
       return;
     }
     _lastEmittedMsgCount = msgCount;
     _lastEmittedToolCount = toolCount;
+    _lastEmittedMaxContext = maxContext;
     if (msgCount !== _lastPreFlightMsgCount) {
       a.ctx.lastRequestTokens = estimateRequestTokens(
         a.ctx.messages,
@@ -39517,11 +41305,6 @@ function createAgentLoopHandler(a, handlers) {
       _lastPreFlightMsgCount = msgCount;
       a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount };
     }
-    if (!_maxContext) {
-      const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
-      const providerMax = a.ctx.provider.capabilities.maxContext;
-      _maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
-    }
     let total;
     const stashed = a.ctx.lastRequestTokens;
     if (typeof stashed === "number" && stashed > 0) {
@@ -39536,13 +41319,19 @@ function createAgentLoopHandler(a, handlers) {
       );
       total = est.total;
     }
-    a.events.emit("ctx.pct", { load: total / _maxContext, tokens: total, maxContext: _maxContext });
+    a.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
+  }
+  function currentMaxContext() {
+    const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
+    const providerMax = a.ctx.provider.capabilities.maxContext;
+    return typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
   }
-  let _maxContext = 0;
   let _lastEmittedMsgCount = -1;
   let _lastEmittedToolCount = -1;
+  let _lastEmittedMaxContext = -1;
   let _lastPreFlightMsgCount = -1;
   let _lastCompactionMsgCount = -1;
+  let _lastCompactionMaxContext = -1;
   let _lastCompactionWasNoop = false;
   function foldBlockIntoConversation(block) {
     const messages = a.ctx.messages;
@@ -39612,7 +41401,8 @@ function createAgentLoopHandler(a, handlers) {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       content: inputPayload.content
     });
-    await a.ctx.session.flush();
+    void a.ctx.session.flush().catch(() => {
+    });
     const promptIndex = a.ctx.messages.filter((m) => m.role === "user").length - 1;
     const preview = inputPayload.text.slice(0, 80) + (inputPayload.text.length > 80 ? "\u2026" : "");
     await a.ctx.session.writeCheckpoint(promptIndex, preview);
@@ -39993,12 +41783,26 @@ var Agent = class {
     const { blocks, text } = normalizeInput(userInput);
     const inputPayload = { content: blocks, text, ctx: this.ctx };
     await this.extensions.runBeforeRun(this.ctx, inputPayload);
+    const runStartedAt = Date.now();
+    const runStartedIso = new Date(runStartedAt).toISOString();
     try {
+      this.events.emit("agent.run.started", {
+        ctx: this.ctx,
+        model: opts.model ?? this.ctx.model,
+        at: runStartedIso
+      });
       const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
       const result = await this._loopHandler.runInner(inputPayload, opts, controller, autonomousContinue);
       span?.setAttribute("agent.status", result.status);
       span?.setAttribute("agent.iterations", result.iterations);
       await this.extensions.runAfterRun(this.ctx, result);
+      this.events.emit("agent.run.completed", {
+        ctx: this.ctx,
+        status: result.status,
+        iterations: result.iterations,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - runStartedAt
+      });
       return result;
     } catch (err) {
       const wse = err instanceof AgentError ? err : toWrongStackError(err);
@@ -40013,6 +41817,21 @@ var Agent = class {
         abortReason: signal.aborted ? signalAbortReason(signal) : void 0
       };
       await this.extensions.runAfterRun(this.ctx, result);
+      if (result.status === "failed") {
+        this.events.emit("agent.run.error", {
+          ctx: this.ctx,
+          err: safeError,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - runStartedAt
+        });
+      }
+      this.events.emit("agent.run.completed", {
+        ctx: this.ctx,
+        status: result.status,
+        iterations: result.iterations,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - runStartedAt
+      });
       return result;
     } finally {
       span?.end();
@@ -40170,13 +41989,13 @@ async function runShellHook(spec, input, logger) {
     logger?.warn?.(`hook rejected: command not in allowlist: ${spec.command}`);
     return null;
   }
-  return await new Promise((resolve18) => {
+  return await new Promise((resolve19) => {
     let settled = false;
     const done = (v) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve18(v);
+      resolve19(v);
     };
     let child;
     try {
@@ -40189,7 +42008,7 @@ async function runShellHook(spec, input, logger) {
       });
     } catch (err2) {
       logger?.warn?.(`hook spawn failed: ${toErrorMessage(err2)}`);
-      return resolve18(null);
+      return resolve19(null);
     }
     const timer = setTimeout(() => {
       logger?.warn?.(`hook command timed out after ${timeoutMs}ms: ${spec.command}`);
@@ -40365,14 +42184,20 @@ var HookRunner = class {
 };
 
 // src/execution/model-runtime.ts
-function resolveModelRuntime(settings, reasoning) {
+function resolveModelRuntime(settings, reasoning, capabilities) {
   const warnings = [];
   if (!settings) {
-    return { reasoning: void 0, cache: void 0, warnings };
+    return { reasoning: void 0, cache: void 0, parameters: void 0, warnings };
   }
   const reasoningField = resolveReasoningForRequest(settings, reasoning, warnings);
   const cacheField = resolveCacheForRequest(settings);
-  return { reasoning: reasoningField, cache: cacheField, warnings };
+  const paramsField = resolveParametersForRequest(settings.parameters, capabilities);
+  return {
+    reasoning: reasoningField,
+    cache: cacheField,
+    parameters: paramsField,
+    warnings
+  };
 }
 function resolveReasoningForRequest(settings, rc, warnings) {
   const cfg = settings.reasoning;
@@ -40430,11 +42255,38 @@ function resolveCacheForRequest(settings, _warnings) {
   const out = { ttl };
   return out;
 }
+function resolveParametersForRequest(params, caps, _warnings) {
+  if (!params) return void 0;
+  const out = {};
+  if (params.topK !== void 0 && caps?.topK !== false) {
+    out.topK = params.topK;
+  }
+  if (params.frequencyPenalty !== void 0 && caps?.frequencyPenalty !== false) {
+    out.frequencyPenalty = params.frequencyPenalty;
+  }
+  if (params.presencePenalty !== void 0 && caps?.presencePenalty !== false) {
+    out.presencePenalty = params.presencePenalty;
+  }
+  if (params.seed !== void 0 && caps?.seed !== false) {
+    out.seed = params.seed;
+  }
+  if (params.user !== void 0) {
+    out.user = params.user;
+  }
+  if (params.logprobs !== void 0 && caps?.logprobs !== false) {
+    out.logprobs = params.logprobs;
+    if (params.topLogprobs !== void 0) {
+      out.topLogprobs = params.topLogprobs;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function applyModelRuntime(req, opts) {
   const settings = opts.getSettings();
   if (!settings) return req;
   const rc = opts.getReasoningConfig();
-  const resolved = resolveModelRuntime(settings, rc);
+  const caps = opts.getCapabilities?.();
+  const resolved = resolveModelRuntime(settings, rc, caps);
   for (const w of resolved.warnings) opts.onWarning?.(w);
   const next = { ...req };
   if (resolved.reasoning !== void 0) {
@@ -40443,6 +42295,9 @@ function applyModelRuntime(req, opts) {
   if (resolved.cache !== void 0) {
     next.cache = resolved.cache;
   }
+  if (resolved.parameters !== void 0) {
+    Object.assign(next, resolved.parameters);
+  }
   return next;
 }
 async function bootConfig(options = {}) {
@@ -40765,8 +42620,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path48 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path48}]`;
+    const path51 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path51}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -40915,9 +42770,9 @@ var DefaultSystemPromptBuilder = class {
   skillBodyCache;
   /** Tools from last build — used for memory relevance scoring. */
   _lastBuildTools;
-  /** Cached rendered online agents string, keyed by array reference. */
+  /** Cached rendered online agents string, keyed by content fingerprint. */
   _lastOnlineAgents;
-  /** Cached full buildToolUsage output — keyed by tools array + online agents refs. */
+  /** Cached full buildToolUsage output — keyed by tools array ref + agents fingerprint. */
   _toolsUsageCache;
   /**
    * Normalizes `tokenSavingMode` to a boolean for backward-compatible boolean checks.
@@ -41053,13 +42908,13 @@ var DefaultSystemPromptBuilder = class {
     if (!planPath) return "";
     let raw;
     try {
-      const stat15 = await fsp3.stat(planPath);
-      if (this._planCache && this._planCache.path === planPath && this._planCache.mtimeMs === stat15.mtimeMs) {
+      const stat16 = await fsp3.stat(planPath);
+      if (this._planCache && this._planCache.path === planPath && this._planCache.mtimeMs === stat16.mtimeMs) {
         return this._planCache.text;
       }
       raw = await fsp3.readFile(planPath, "utf8");
       const text = this._formatPlan(raw);
-      this._planCache = { path: planPath, mtimeMs: stat15.mtimeMs, text };
+      this._planCache = { path: planPath, mtimeMs: stat16.mtimeMs, text };
       return text;
     } catch {
       this._planCache = void 0;
@@ -41074,8 +42929,8 @@ var DefaultSystemPromptBuilder = class {
       return "";
     }
     if (!Array.isArray(parsed.items) || parsed.items.length === 0) return "";
-    const open7 = parsed.items.filter((i) => i?.status !== "done");
-    if (open7.length === 0) return "";
+    const open10 = parsed.items.filter((i) => i?.status !== "done");
+    if (open10.length === 0) return "";
     const lines = ["## Active plan"];
     if (parsed.title) lines.push(`*${parsed.title}*`, "");
     parsed.items.forEach((it, idx) => {
@@ -41090,7 +42945,8 @@ var DefaultSystemPromptBuilder = class {
   }
   buildToolUsage(tools, ctx) {
     if (tools.length === 0) return "## Tool usage\n\nNo tools registered.";
-    if (this._toolsUsageCache?.toolsRef === tools && this._toolsUsageCache?.agentsRef === ctx.onlineAgents) {
+    const agentsHash = this.agentsFingerprint(ctx.onlineAgents);
+    if (this._toolsUsageCache?.toolsRef === tools && this._toolsUsageCache?.agentsHash === agentsHash) {
       return this._toolsUsageCache.text;
     }
     const byCat = /* @__PURE__ */ new Map();
@@ -41377,7 +43233,7 @@ the server connection \u2014 only tool visibility changes.`);
 
 Use \`context_manager\` to manage context. Call \`{"action":"check"}\` to see token budget.`);
       } else {
-        const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
+        const maxCtx = this.modelCapabilities()?.maxContextTokens ?? 128e3;
         const threshold = maxCtx <= 32e3 ? "50" : "70";
         lines.push(`
 ## Context management
@@ -41395,15 +43251,38 @@ summarize it, and let the tool result hold only the summary.`);
       }
     }
     const text = lines.join("\n");
-    this._toolsUsageCache = { toolsRef: tools, agentsRef: ctx.onlineAgents, text };
+    this._toolsUsageCache = { toolsRef: tools, agentsHash, text };
     return text;
   }
   /**
-   * Render the online agents list, cached by array reference. The agents
+   * Cheap content fingerprint of the online agents array. The mailbox
+   * rebuilds the array as a fresh object on every status check, so caching
+   * by reference always misses — this lets the renderOnlineAgents and
+   * buildToolUsage caches detect membership changes instead.
+   *
+   * O(n) over agent names with no per-element string concatenation. Uses
+   * FNV-1a over character codes so two different agent sets collide only
+   * if they produce the identical sequence of name characters — astronomically
+   * unlikely. A collision would produce a stale agent list in the prompt,
+   * a cosmetic issue, not a correctness bug.
+   */
+  agentsFingerprint(agents) {
+    if (!agents || agents.length === 0) return "0";
+    let h = 2166136261;
+    for (const a of agents) {
+      for (let i = 0; i < a.name.length; i++) {
+        h ^= a.name.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+      }
+    }
+    return `${agents.length}:${h.toString(36)}`;
+  }
+  /**
+   * Render the online agents list, cached by content fingerprint. The agents
    * list changes at join/leave pace (seconds to minutes), not every prompt
-   * build turn (hundreds of ms). Reference equality avoids re-stringifying
-   * the same array on every iteration while still being correct when the
-   * caller passes a fresh array.
+   * build turn (hundreds of ms). The fingerprint detects membership changes
+   * without holding the array reference — the mailbox rebuilds the array as
+   * a fresh object on every status check, so reference equality always misses.
    *
    * Tier behaviour:
    * - 'off' / 'medium' / 'aggressive' → full list with names, sessions, sources
@@ -41411,13 +43290,14 @@ summarize it, and let the tool result hold only the summary.`);
    */
   renderOnlineAgents(agents) {
     if (!agents || agents.length === 0) return "";
-    if (this._lastOnlineAgents?.ref === agents) {
+    const hash = this.agentsFingerprint(agents);
+    if (this._lastOnlineAgents?.hash === hash) {
       return this._lastOnlineAgents.text;
     }
     const totalCount = agents.length;
     if (this.tier === "minimal" || this.tier === "light") {
       const text2 = ` (${totalCount} agent${totalCount !== 1 ? "s" : ""} online)`;
-      this._lastOnlineAgents = { ref: agents, text: text2 };
+      this._lastOnlineAgents = { hash, text: text2 };
       return text2;
     }
     const agentList = agents.map(
@@ -41427,11 +43307,21 @@ summarize it, and let the tool result hold only the summary.`);
 
 **Currently online (${totalCount} agent${totalCount !== 1 ? "s" : ""}):**
 ${agentList}`;
-    this._lastOnlineAgents = { ref: agents, text };
+    this._lastOnlineAgents = { hash, text };
     return text;
   }
   async buildEnvironment(ctx) {
-    const cached = this.envCacheByRoot.get(ctx.projectRoot);
+    const modelCapabilities = this.modelCapabilities();
+    const cacheKey = [
+      ctx.projectRoot,
+      ctx.provider ?? "",
+      ctx.model ?? "",
+      modelCapabilities?.maxContextTokens ?? 0,
+      modelCapabilities?.supportsTools ? 1 : 0,
+      modelCapabilities?.supportsVision ? 1 : 0,
+      modelCapabilities?.supportsReasoning ? 1 : 0
+    ].join("\0");
+    const cached = this.envCacheByRoot.get(cacheKey);
     if (cached) return cached;
     const today = this.opts.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const platform2 = `${os6.platform()} ${os6.release()}`;
@@ -41463,15 +43353,15 @@ ${agentList}`;
             `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
           );
         }
-        if (this.opts.modelCapabilities) {
+        if (modelCapabilities) {
           lines.push(
-            `- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
+            `- Context window: ${modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
           );
         }
       }
-      if (tier !== "aggressive" && this.opts.modelCapabilities) {
+      if (tier !== "aggressive" && modelCapabilities) {
         lines.push(
-          `- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
+          `- Context window: ${modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
         );
       }
       if (tier !== "aggressive" && (ctx.provider || ctx.model)) {
@@ -41493,9 +43383,13 @@ ${agentList}`;
       );
     }
     const text = lines.join("\n");
-    this.envCacheByRoot.set(ctx.projectRoot, text);
+    this.envCacheByRoot.set(cacheKey, text);
     return text;
   }
+  modelCapabilities() {
+    const caps = this.opts.modelCapabilities;
+    return typeof caps === "function" ? caps() : caps;
+  }
   async buildMemoryAndSkills() {
     const parts = [];
     const memoryCount = this.tier === "minimal" ? 3 : this.tier === "light" ? 5 : 8;
@@ -41621,19 +43515,19 @@ ${clean.trim()}`);
   }
   async dirExists(p) {
     try {
-      const stat15 = await fsp3.stat(p);
-      return stat15.isDirectory();
+      const stat16 = await fsp3.stat(p);
+      return stat16.isDirectory();
     } catch {
       return false;
     }
   }
   async gitStatus(root) {
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       let settled = false;
       const finish = (s) => {
         if (settled) return;
         settled = true;
-        resolve18(s);
+        resolve19(s);
       };
       let proc;
       const timer = setTimeout(() => {
@@ -42554,18 +44448,21 @@ Rules:
 - Be concise: one tight instruction per version (a few sentences at most). No preamble, no explanation, no quotes, no markdown headers.
 - If the message is already clear and complete, return it essentially unchanged.
 
-You MUST output TWO versions of the refined request, separated by a line containing only "---".
-- First version: refined in the SAME LANGUAGE the user wrote in (if Turkish \u2192 Turkish, if Spanish \u2192 Spanish, etc.).
-- Second version: refined in ENGLISH (translate the intent into clear English while preserving all concrete details).
+Detect the language of the user's LATEST message and output accordingly:
+
+- If that message is ALREADY in English: output exactly ONE refined version, in English. Nothing else \u2014 no "---" line, no second copy.
+- If that message is in ANY OTHER language (Turkish, Spanish, \u2026): output TWO versions separated by a line containing only "---":
+    - First version: refined in the SAME LANGUAGE the user wrote in.
+    - Second version: refined in ENGLISH (translate the intent into clear English while preserving all concrete details).
 
-Output format:
+Output format for non-English input:
 <refined in user's language>
 ---
 <refined in English>
 
-When earlier conversation turns are provided, they are CONTEXT ONLY. Use them to resolve references in the user's latest message \u2014 "it", "that", "the same", "the other one", "this file", "again" \u2014 so the refined instruction is self-contained. Refine ONLY the user's latest message; do not answer it, do not act on or restate earlier turns, and do not summarize the conversation.
+When earlier conversation turns are provided, they are CONTEXT ONLY. Use them to resolve references in the user's latest message \u2014 "it", "that", "the same", "the other one", "this file", "again" \u2014 so the refined instruction is self-contained. Refine ONLY the user's latest message; do not answer it, do not act on or restate earlier turns, and do not summarize the conversation. The conversation language does NOT decide the output language \u2014 only the language of the latest message does.
 
-Output ONLY the two versions separated by "---" \u2014 nothing else.`;
+Output ONLY the refined request(s) in the format above \u2014 nothing else.`;
 var AFFIRMATION_RE = /^(y|n|yes|no|yep|nope|ok|okay|sure|go|go ahead|continue|proceed|stop|cancel|done|next|skip|retry|again|please do|do it)\b[.! ]*$/i;
 function shouldEnhance(text) {
   const t2 = text.trim();
@@ -42578,6 +44475,24 @@ function shouldEnhance(text) {
   if (words.length < 3) return false;
   return true;
 }
+var EFFORT_PREFERENCE = [
+  "low",
+  "minimal",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "none"
+];
+function gatedEnhancerReasoning(rc) {
+  if (!rc) return void 0;
+  if (rc.effortSupported && rc.effortLevels.length > 0) {
+    const lowest = EFFORT_PREFERENCE.find((e) => rc.effortLevels.includes(e)) ?? rc.effortLevels[0];
+    if (lowest) return { effort: lowest };
+  }
+  if (rc.disableSupported) return { enabled: false };
+  return void 0;
+}
 function normalizedEqual(a, b) {
   const norm = (s) => s.trim().replace(/\s+/g, " ").toLowerCase();
   return norm(a) === norm(b);
@@ -42601,11 +44516,17 @@ async function enhanceUserPrompt(opts) {
     model,
     system: [{ type: "text", text: ENHANCER_SYSTEM_PROMPT }],
     messages: [{ role: "user", content: buildRefinerInput(text, opts.history) }],
-    maxTokens
+    maxTokens,
     // NOTE: deliberately NO `temperature`. The main agent loop never sets it,
     // and reasoning models (DeepSeek reasoner, o1/o3, …) return HTTP 400 when
     // `temperature` is present — which would make every refine call fail and
     // silently fall back to the original (no panel shown).
+    //
+    // A reasoning hint is forwarded ONLY when the caller supplies one (it must
+    // already be gated to the model's advertised support — see
+    // `gatedEnhancerReasoning`). Absent it, no reasoning field is sent, which
+    // is identical to the original behavior.
+    ...opts.reasoning ? { reasoning: opts.reasoning } : {}
   };
   const timer = new AbortController();
   const to = setTimeout(() => timer.abort(new Error("enhancer timeout")), timeoutMs);
@@ -42619,7 +44540,6 @@ async function enhanceUserPrompt(opts) {
     }
     const sepIdx = raw.indexOf("\n---\n");
     if (sepIdx === -1) {
-      opts.onError?.("model did not produce two versions");
       return { refined: raw, english: raw };
     }
     const refined = raw.slice(0, sepIdx).trim();
@@ -43090,7 +45010,7 @@ var PhaseOrchestrator = class {
   async mergeOne(phase, handle) {
     if (!this.worktrees) return;
     try {
-      const resolve18 = this.ctx.resolveConflict ? async (info) => {
+      const resolve19 = this.ctx.resolveConflict ? async (info) => {
         const shouldResolve = await this.shouldAttemptConflictResolution(phase, info);
         if (!shouldResolve) return false;
         this.emit("phase.conflictResolving", {
@@ -43104,7 +45024,7 @@ var PhaseOrchestrator = class {
       const mergeOpts = {
         squash: true
       };
-      if (resolve18 !== void 0) mergeOpts.resolve = resolve18;
+      if (resolve19 !== void 0) mergeOpts.resolve = resolve19;
       const result = await this.worktrees.merge(handle, mergeOpts);
       if (result.resolved) {
         this.emit("phase.conflictResolved", { phaseId: phase.id, name: phase.name });
@@ -43455,7 +45375,7 @@ var PhaseOrchestrator = class {
     }
   }
   delay(ms) {
-    return new Promise((resolve18) => setTimeout(resolve18, ms));
+    return new Promise((resolve19) => setTimeout(resolve19, ms));
   }
 };
 
@@ -44516,8 +46436,8 @@ var CollaborationBus = class {
     if (this.isPaused()) return false;
     this.pausedAtMs = Date.now();
     this.pausedBy = byParticipant;
-    this.pausePromise = new Promise((resolve18) => {
-      this.pauseResolve = resolve18;
+    this.pausePromise = new Promise((resolve19) => {
+      this.pauseResolve = resolve19;
     });
     return true;
   }
@@ -44553,8 +46473,8 @@ var CollaborationBus = class {
       return true;
     }
     let timer;
-    const timeoutPromise = new Promise((resolve18) => {
-      timer = setTimeout(() => resolve18("timeout"), timeoutMs);
+    const timeoutPromise = new Promise((resolve19) => {
+      timer = setTimeout(() => resolve19("timeout"), timeoutMs);
     });
     const resumedPromise = this.pausePromise.then(() => "resumed").catch(() => "resumed");
     const winner = await Promise.race([resumedPromise, timeoutPromise]);
@@ -44573,6 +46493,24 @@ var CollaborationBus = class {
   // "skip the bash call, just give it the answer I typed". The
   // injection is matched by tool_use_id, consumed once, and discarded.
   injectionQueue = /* @__PURE__ */ new Map();
+  onConsumed;
+  /**
+   * Register a listener fired when `collabInjectMiddleware` actually splices a
+   * queued injection into a tool call (Phase 4 feedback loop). The webui's
+   * CollaborationWebSocketHandler uses it to broadcast a
+   * `collab.injection.granted` with phase `'consumed'` so observers learn the
+   * injection was applied (and to which real tool). Last registration wins.
+   */
+  onInjectionConsumed(fn) {
+    this.onConsumed = fn;
+  }
+  /**
+   * Invoked by `collabInjectMiddleware` immediately after it replaces a tool
+   * call's result with a queued injection. No-op when no listener is set.
+   */
+  notifyInjectionConsumed(info) {
+    this.onConsumed?.(info);
+  }
   /**
    * Queue a manual tool result. The next time the agent's toolCall
    * pipeline sees a matching `toolUse.id`, the
@@ -44835,7 +46773,7 @@ async function gitOtherWorktrees(cwd, signal) {
   return branches.slice(1);
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let stdout = "";
     let stderr = "";
     const child = spawn("git", args, {
@@ -44854,7 +46792,7 @@ function runGit(args, cwd, signal) {
     });
     child.on("error", (err) => reject(err));
     child.on("close", (code) => {
-      if (code === 0) resolve18(stdout);
+      if (code === 0) resolve19(stdout);
       else reject(new Error(stderr || `git ${args[0]} exited ${code}`));
     });
   });
@@ -44967,8 +46905,8 @@ function extractManifestPath(msg) {
   }
   return void 0;
 }
-function isManifestFile(path48) {
-  const name = pathBasename(path48).toLowerCase();
+function isManifestFile(path51) {
+  const name = pathBasename(path51).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -45068,6 +47006,13 @@ function collabInjectMiddleware(bus, opts = {}) {
       content: typeof injected.content === "string" ? injected.content : JSON.stringify(injected.content),
       is_error: injected.isError
     };
+    bus.notifyInjectionConsumed({
+      toolUseId: payload.toolUse.id,
+      toolName: payload.toolUse.name,
+      authorId: injected.authorId,
+      reason: injected.reason,
+      isError: injected.isError
+    });
   };
 }
 
@@ -45472,7 +47417,7 @@ function createGitPlugin() {
 }
 async function runGit2(args, cwd) {
   try {
-    return await new Promise((resolve18, reject) => {
+    return await new Promise((resolve19, reject) => {
       const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], signal: AbortSignal.timeout(3e4), windowsHide: true });
       let stdout = "";
       let stderr = "";
@@ -45493,7 +47438,7 @@ async function runGit2(args, cwd) {
           })
         );
       });
-      child.on("close", (code) => resolve18({ stdout, stderr, code: code ?? 0 }));
+      child.on("close", (code) => resolve19({ stdout, stderr, code: code ?? 0 }));
     });
   } catch (err) {
     if (err instanceof WrongStackError) throw err;
@@ -46295,7 +48240,7 @@ If NOTHING worth flagging:
 ## \u{1F982} Chimera Review \u2014 all clear \u2705
 No issues found in N changed files.`;
 async function runGit3(args, cwd) {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     let child;
     try {
       child = spawn("git", args, {
@@ -46316,8 +48261,8 @@ async function runGit3(args, cwd) {
     child.stderr?.on("data", (d) => {
       stderr += d;
     });
-    child.on("error", () => resolve18({ stdout, stderr, code: 1 }));
-    child.on("close", (code) => resolve18({ stdout, stderr, code: code ?? 0 }));
+    child.on("error", () => resolve19({ stdout, stderr, code: 1 }));
+    child.on("close", (code) => resolve19({ stdout, stderr, code: code ?? 0 }));
   });
 }
 async function isGitRepo2(cwd) {
@@ -46471,6 +48416,6 @@ function createChimeraPlugin() {
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousBrain, AutonomousCoordinator, AutonomousRunner, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, ChangeManager, CheckpointManager, CloudSync, CollabSession, CollaborationBus, ConfigError, ConfigMigrationError, ConsensusProtocol, Container, Context, ConversationState, DANGEROUS_FOR_SUBAGENTS, DECISION_TIMEOUT_MS, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_HQ_REDACTION_POLICY, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_QUALITY_CHECKS, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEFAULT_TUI_THINKING_WORD, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorAlertLevel, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetNotifier, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HEAVY_BUDGET, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HookRegistry, HookRunner, HqPublisher, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, KNOWLEDGE_AGENTS, KnowledgeGraph, LAYER_1_IDENTITY, LIGHT_BUDGET, LLMSelector, LargeAnswerStore, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MAX_TUI_THINKING_WORD_LENGTH, MEDIUM_BUDGET, MEMORY_TYPE_LABELS, META_AGENTS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PLANNING_AGENTS, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TOKENS, TaskAuctioneer, TaskDAG, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolCapabilities, ToolError, ToolErrorCategory, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WIDE_SUBAGENT_CAPABILITIES, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyModelRuntime, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, assessCommitSafety, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildContextEvidenceDigest, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compactSchemaDescriptions, compactToolDefinitionForWire, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextEvidenceState, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxChecker, createMailboxEventPayload, createMailboxHooks, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultHqDataDir, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, definePlugin, deriveTodosFromPlanItem, describeCatalogModel, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyHqAuthFile, emptyPlan, emptyTaskFile, encryptConfigSecrets, encryptedPrefixForVersion, enhanceUserPrompt, ensureDir, ensureHqFirstRunAuthFile, escapeGlobSubject, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expandIPv6, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getDangerousCapabilities, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getJsonPath, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasCapability, hasDangerousCapabilityForSubagents, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, hqAuthFilePath, hqRuntimeFilePath, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isJsonObject, isPathSubjectKey, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, jsonObjectFileExists, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, markAssistantReferencedEvidence, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizePathSubject, normalizeRecipient, normalizeToLf, normalizeTokenSavingTier, normalizeTuiThinkingWord, normalizedEqual, onResize, parseContinueDirective, parseEncryptedVersion, parseEntries, parseHqEventPayload, parseHqFrame, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, playwrightServer, projectHash, projectSlug, readHqAuthFile, readHqRuntimeFileSync, readJsonObjectFile, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, recordToolOutputEvidence, recordUserIntentEvidence, redactHqEvent, redactHqValue, removeJsonPath, removeJsonPathInFile, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, repeatedReadPressure, resetCalibration, resolveAuditLevel, resolveCacheForRequest, resolveChimeraConfig, resolveContextWindowPolicy, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, resolveMailboxIdentity, resolveModelMatrix, resolveModelRuntime, resolveProjectDir, resolveProviderModelList, resolveReasoningForRequest, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, rotateConfigKeys, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, scrubAndTruncateHqPreview, securitySlashCommand, sentinelServer, setBtwNote, setJsonPath, setJsonPathInFile, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, sshManagerServer, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, subjectForToolInput, summarizeHqToolArgs, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updateJsonObjectFile, updatePackageOutdatedStatus, validateAgainstSchema, watchHqAuthFile, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, writeHqAuthFile, writeHqRuntimeFile, writeJsonObjectFile, writeOut, wstackGlobalRoot, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, Agent, AgentError, AgentMonitorService, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousBrain, AutonomousCoordinator, AutonomousRunner, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, ChangeManager, CheckpointManager, CloudSync, CollabSession, CollaborationBus, ConfigError, ConfigMigrationError, ConsensusProtocol, Container, Context, ConversationState, DANGEROUS_FOR_SUBAGENTS, DECISION_TIMEOUT_MS, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_HQ_REDACTION_POLICY, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_QUALITY_CHECKS, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEFAULT_TUI_THINKING_WORD, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorAlertLevel, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetNotifier, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HEAVY_BUDGET, HQ_AUTH_FILE_VERSION, HQ_PROTOCOL_VERSION, HookRegistry, HookRunner, HqPublisher, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, KNOWLEDGE_AGENTS, KnowledgeGraph, LAYER_1_IDENTITY, LIGHT_BUDGET, LLMSelector, LargeAnswerStore, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MAX_TUI_THINKING_WORD_LENGTH, MEDIUM_BUDGET, MEMORY_TYPE_LABELS, META_AGENTS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PLANNING_AGENTS, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TOKENS, TaskAuctioneer, TaskDAG, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolCapabilities, ToolError, ToolErrorCategory, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WIDE_SUBAGENT_CAPABILITIES, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyModelRuntime, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, assessCommitSafety, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildContextEvidenceDigest, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, buildTranscriptFromEvents, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compactSchemaDescriptions, compactToolDefinitionForWire, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAgentMonitorService, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextEvidenceState, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createGlobalMailbox, createHqEventEnvelope, createHqPublisherFromEnv, createMailboxChecker, createMailboxEventPayload, createMailboxHooks, createMailboxSnapshotPayload, createMailboxSnapshotPayloadFromMailbox, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultHqDataDir, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, definePlugin, deriveTodosFromPlanItem, describeCatalogModel, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyHqAuthFile, emptyPlan, emptyTaskFile, encryptConfigSecrets, encryptedPrefixForVersion, enhanceUserPrompt, ensureDir, ensureHqFirstRunAuthFile, escapeGlobSubject, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expandIPv6, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, gatedEnhancerReasoning, generateSessionId, getAgentDefinition, getCalibrationState, getContextWindowMode, getDangerousCapabilities, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getJsonPath, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasCapability, hasDangerousCapabilityForSubagents, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, hqAuthFilePath, hqRuntimeFilePath, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isJsonObject, isPathSubjectKey, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, jsonObjectFileExists, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, mapMailboxAgentToHqSummary, mapMailboxMessageToHqSummary, mapSessionEventToEntries, markAssistantReferencedEvidence, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, mergeToolResults, migratePlaintextSecrets, miniMaxVisionServer, mintHqBrowserToken, mintHqToken, mutateHqAuthFile, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizePathSubject, normalizeRecipient, normalizeToLf, normalizeTokenSavingTier, normalizeTuiThinkingWord, normalizedEqual, onResize, parseContinueDirective, parseEncryptedVersion, parseEntries, parseHqEventPayload, parseHqFrame, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, playwrightServer, projectHash, projectSlug, readHqAuthFile, readHqRuntimeFileSync, readJsonObjectFile, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, recordToolOutputEvidence, recordUserIntentEvidence, redactHqEvent, redactHqValue, removeJsonPath, removeJsonPathInFile, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, repeatedReadPressure, resetCalibration, resolveAuditLevel, resolveCacheForRequest, resolveChimeraConfig, resolveContextWindowPolicy, resolveHqConfig, resolveHqConfigFromEnv, resolveHqDataDir, resolveMailboxIdentity, resolveModelMatrix, resolveModelRuntime, resolveProjectDir, resolveProviderModelList, resolveReasoningForRequest, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, rotateConfigKeys, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, sanitizeModel, sanitizeNodeOptions, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, scrubAndTruncateHqPreview, securitySlashCommand, sentinelServer, setBtwNote, setJsonPath, setJsonPathInFile, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, sshManagerServer, stableStringify, startAgentMonitorEventBridge, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startSessionTelemetryBridge, startTechStackConsumer, stripAnsi, subjectForToolInput, summarizeHqToolArgs, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updateJsonObjectFile, updatePackageOutdatedStatus, validateAgainstSchema, watchHqAuthFile, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, writeHqAuthFile, writeHqRuntimeFile, writeJsonObjectFile, writeOut, wstackGlobalRoot, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map