@wrongstack/core 0.264.0 → 0.265.1

package/dist/index.js

@@ -59,8 +59,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat13 = await fsp3.stat(targetPath);
-      mode = stat13.mode & 511;
+      const stat14 = await fsp3.stat(targetPath);
+      mode = stat14.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -100,8 +100,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat13 = await fsp3.stat(lockPath);
-        if (Date.now() - stat13.mtimeMs > staleMs) {
+        const stat14 = await fsp3.stat(lockPath);
+        if (Date.now() - stat14.mtimeMs > staleMs) {
           await fsp3.unlink(lockPath);
           continue;
         }
@@ -111,7 +111,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((resolve14) => setTimeout(resolve14, 25));
+      await new Promise((resolve15) => setTimeout(resolve15, 25));
     }
   }
   try {
@@ -144,7 +144,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve14) => setTimeout(resolve14, delays[i]));
+      await new Promise((resolve15) => setTimeout(resolve15, delays[i]));
     }
   }
   throw lastErr;
@@ -183,16 +183,24 @@ function getSessionRegistry(globalRoot) {
 function hasSessionRegistry() {
   return _instance !== null;
 }
-var REGISTRY_FILE, HEARTBEAT_INTERVAL_MS, STALE_TIMEOUT_MS, SessionRegistry, _instance;
+var REGISTRY_FILE, HEARTBEAT_INTERVAL_MS, STALE_TIMEOUT_MS, CLOSING_GRACE_MS, STALE_LOCK_MS, SessionRegistry, _instance;
 var init_session_registry = __esm({
   "src/session-registry.ts"() {
     REGISTRY_FILE = "session-registry.json";
     HEARTBEAT_INTERVAL_MS = 5e3;
     STALE_TIMEOUT_MS = 3e4;
+    CLOSING_GRACE_MS = 15e3;
+    STALE_LOCK_MS = 1e4;
     SessionRegistry = class {
       filePath;
       heartbeatTimer = null;
       currentSessionId = null;
+      /**
+       * Last full entry this process registered. Kept so the heartbeat can
+       * re-create our entry if it ever goes missing — e.g. our initial register()
+       * write was dropped (a wedged lock), the file was reset, or we were pruned.
+       */
+      lastEntry = null;
       constructor(globalRoot) {
         this.filePath = path2.join(globalRoot, REGISTRY_FILE);
       }
@@ -214,6 +222,7 @@ var init_session_registry = __esm({
           agentCount: entry.agents?.length ?? 0,
           agents: entry.agents ?? []
         };
+        this.lastEntry = full;
         await this.atomicUpdate((registry) => {
           const now = Date.now();
           for (const [id, existing] of Object.entries(registry)) {
@@ -239,16 +248,28 @@ var init_session_registry = __esm({
        */
       async updateAgents(agents) {
         if (!this.currentSessionId) return;
+        const hasRunning = agents.some((a) => a.status === "running" || a.status === "streaming");
+        const hasWaiting = agents.some((a) => a.status === "waiting_user");
+        const hasError = agents.some((a) => a.status === "error");
+        const status = hasRunning || hasWaiting || hasError ? "active" : "idle";
+        const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+        if (this.lastEntry) {
+          this.lastEntry.agents = agents;
+          this.lastEntry.agentCount = agents.length;
+          this.lastEntry.status = status;
+          this.lastEntry.lastHeartbeatAt = nowIso;
+        }
         await this.atomicUpdate((registry) => {
-          const entry = registry[this.currentSessionId];
-          if (!entry) return;
+          let entry = registry[this.currentSessionId];
+          if (!entry) {
+            if (!this.lastEntry) return;
+            entry = { ...this.lastEntry };
+            registry[this.currentSessionId] = entry;
+          }
           entry.agents = agents;
           entry.agentCount = agents.length;
-          const hasRunning = agents.some((a) => a.status === "running" || a.status === "streaming");
-          const hasWaiting = agents.some((a) => a.status === "waiting_user");
-          const hasError = agents.some((a) => a.status === "error");
-          entry.status = hasRunning ? "active" : hasWaiting ? "active" : hasError ? "active" : "idle";
-          entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+          entry.status = status;
+          entry.lastHeartbeatAt = nowIso;
         });
       }
       /**
@@ -326,6 +347,12 @@ var init_session_registry = __esm({
               entry.status = hasRunning ? "active" : "idle";
             }
             await this.writeAtomic(registry);
+          } else if (this.lastEntry) {
+            await this.atomicUpdate((reg) => {
+              if (!reg[this.currentSessionId] && this.lastEntry) {
+                reg[this.currentSessionId] = { ...this.lastEntry, lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+              }
+            });
           }
         } catch {
         }
@@ -338,6 +365,11 @@ var init_session_registry = __esm({
           let pruned = false;
           for (const [id, entry] of Object.entries(registry)) {
             const heartbeatAge = now - new Date(entry.lastHeartbeatAt).getTime();
+            if (entry.status === "closing" && heartbeatAge > CLOSING_GRACE_MS) {
+              delete registry[id];
+              pruned = true;
+              continue;
+            }
             if (heartbeatAge > STALE_TIMEOUT_MS && !pidAlive(entry.pid)) {
               entry.status = "stale";
               const startedAge = now - new Date(entry.startedAt).getTime();
@@ -357,17 +389,23 @@ var init_session_registry = __esm({
       }
       async atomicUpdate(fn) {
         const lockPath = `${this.filePath}.lock`;
-        const maxRetries = 5;
+        const maxRetries = 8;
         const retryDelayMs = 20;
         for (let attempt = 0; attempt < maxRetries; attempt++) {
           try {
             await fsp3.mkdir(path2.dirname(this.filePath), { recursive: true });
-            const lockHandle = await fsp3.open(lockPath, "wx").catch(() => null);
+            let lockHandle = await fsp3.open(lockPath, "wx").catch(() => null);
             if (!lockHandle) {
-              await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
-              continue;
+              if (await this.breakStaleLock(lockPath)) {
+                lockHandle = await fsp3.open(lockPath, "wx").catch(() => null);
+              }
+              if (!lockHandle) {
+                await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
+                continue;
+              }
             }
             try {
+              await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
               const raw = await fsp3.readFile(this.filePath, "utf8").catch(() => "{}");
               const registry = JSON.parse(raw);
               fn(registry);
@@ -382,6 +420,31 @@ var init_session_registry = __esm({
           }
         }
       }
+      /**
+       * Break a contended lock if it is stale: the recorded owner pid is no longer
+       * alive, or the lock is older than {@link STALE_LOCK_MS}. Returns true when the
+       * lock was removed (caller should retry acquisition). Best-effort and
+       * race-tolerant — a fresh lock (age ~0, live owner) is never broken, so the
+       * common concurrent case self-heals on the next heartbeat.
+       */
+      async breakStaleLock(lockPath) {
+        try {
+          const [stat14, content] = await Promise.all([
+            fsp3.stat(lockPath),
+            fsp3.readFile(lockPath, "utf8").catch(() => "")
+          ]);
+          const ageMs = Date.now() - stat14.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) {
+            await fsp3.unlink(lockPath).catch(() => void 0);
+            return true;
+          }
+          return false;
+        } catch {
+          return true;
+        }
+      }
       async writeAtomicLocked(registry) {
         const tmp = `${this.filePath}.${randomUUID().slice(0, 8)}.tmp`;
         await fsp3.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
@@ -1061,7 +1124,8 @@ function resolveWstackPaths(opts) {
     projectSddSession: path2.join(projectDir, "sdd-session.json"),
     projectPlan: path2.join(projectDir, "plan.json"),
     projectAutophase: path2.join(projectDir, "autophase"),
-    syncConfig: path2.join(globalRoot, "sync.json")
+    syncConfig: path2.join(globalRoot, "sync.json"),
+    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
 
@@ -1162,7 +1226,7 @@ function buildChildEnv(optsOrSessionId) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 
 // src/utils/assert-never.ts
@@ -1320,12 +1384,9 @@ function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    let evicted = 0;
-    const maxEvict = Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4);
     for (const k of ESTIMATE_CACHE.keys()) {
-      if (evicted >= maxEvict) break;
+      if (ESTIMATE_CACHE.size <= Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) break;
       ESTIMATE_CACHE.delete(k);
-      evicted++;
     }
   }
   const estimate = compute(key);
@@ -1567,11 +1628,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path43, errors) {
+function walk(value, schema, path44, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path43 || "<root>",
+        path: path44 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1580,7 +1641,7 @@ function walk(value, schema, path43, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path43 || "<root>",
+        path: path44 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -1590,20 +1651,20 @@ function walk(value, schema, path43, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path43, req), message: "required property missing" });
+        errors.push({ path: joinPath(path44, 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(path43, key), errors);
+          walk(obj[key], subSchema, joinPath(path44, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path43}[${i}]`, errors);
+      walk(value[i], schema.items, `${path44}[${i}]`, errors);
     }
   }
 }
@@ -1779,8 +1840,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat13 = await fsp3.stat(full);
-          if (stat13.isDirectory()) await walk3(full, rest);
+          const stat14 = await fsp3.stat(full);
+          if (stat14.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -1797,8 +1858,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat13 = await fsp3.stat(full);
-          if (stat13.isDirectory()) await walk3(full, rest);
+          const stat14 = await fsp3.stat(full);
+          if (stat14.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -2870,7 +2931,7 @@ function makePatternMatcher(pattern) {
 }
 
 // src/kernel/tokens.ts
-var t = (name) => Symbol(name);
+var t = (name) => /* @__PURE__ */ Symbol.for(`@wrongstack/core/kernel#${name}`);
 var TOKENS = {
   Logger: t("Logger"),
   TokenCounter: t("TokenCounter"),
@@ -3109,6 +3170,20 @@ function providerStatusToCode(status, type) {
   return ERROR_CODES.PROVIDER_INVALID_REQUEST;
 }
 
+// src/types/config.ts
+function normalizeTokenSavingTier(val) {
+  if (val === void 0) return "off";
+  if (typeof val === "boolean") return val ? "medium" : "off";
+  const validTiers = /* @__PURE__ */ new Set([
+    "off",
+    "minimal",
+    "light",
+    "medium",
+    "aggressive"
+  ]);
+  return validTiers.has(val) ? val : "off";
+}
+
 // src/types/default-config.ts
 var DEFAULT_TOOLS_CONFIG = Object.freeze({
   defaultExecutionStrategy: "smart",
@@ -3116,7 +3191,8 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   iterationTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
-  autoExtendLimit: true
+  autoExtendLimit: true,
+  restrictToProjectRoot: false
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
   preserveK: 10,
@@ -3125,6 +3201,10 @@ var DEFAULT_CONTEXT_CONFIG = Object.freeze({
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
 });
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = Object.freeze({
+  enabled: false,
+  autoKillResetMs: 6e4
+});
 var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
   auditLevel: "standard",
   sampling: {
@@ -3136,11 +3216,19 @@ var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
 var DEFAULT_SESSION_PRUNE_DAYS = 30;
 
 // src/types/secret-vault.ts
-var ENCRYPTED_PREFIX = "enc:v1:";
+var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
+function encryptedPrefixForVersion(version) {
+  return `enc:v${version}:`;
+}
+function parseEncryptedVersion(value) {
+  const match = value.match(ENCRYPTED_PREFIX_PATTERN);
+  return match ? Number.parseInt(match[1], 10) : void 0;
+}
 var noOpVault = {
   encrypt: (v) => v,
   decrypt: (v) => v,
-  isEncrypted: () => false
+  isEncrypted: () => false,
+  keyVersion: 1
 };
 
 // src/security/secret-vault.ts
@@ -3150,11 +3238,13 @@ var IV_BYTES = 12;
 var TAG_BYTES = 16;
 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;
 function checkKeyFilePermissions(keyFile) {
   if (process.platform === "win32") return;
   try {
-    const stat13 = fs2.statSync(keyFile);
-    const actualMode = stat13.mode & 511;
+    const stat14 = fs2.statSync(keyFile);
+    const actualMode = stat14.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       console.warn(JSON.stringify({
         level: "warn",
@@ -3172,11 +3262,17 @@ function checkKeyFilePermissions(keyFile) {
 var DefaultSecretVault = class {
   keyFile;
   key;
+  _keyVersion = 1;
   constructor(opts) {
     this.keyFile = opts.keyFile;
   }
+  /** Current key version. Starts at 1; incremented by rotateKey(). */
+  get keyVersion() {
+    if (!this.key) this.loadOrCreateKey();
+    return this._keyVersion;
+  }
   isEncrypted(value) {
-    return typeof value === "string" && value.startsWith(ENCRYPTED_PREFIX);
+    return typeof value === "string" && ENCRYPTED_PREFIX_PATTERN.test(value);
   }
   encrypt(plaintext) {
     if (this.isEncrypted(plaintext)) return plaintext;
@@ -3185,11 +3281,20 @@ var DefaultSecretVault = class {
     const cipher = createCipheriv(ALGO, key, iv);
     const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
     const tag = cipher.getAuthTag();
-    return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
+    const prefix = encryptedPrefixForVersion(this._keyVersion);
+    return `${prefix}${iv.toString("base64")}:${tag.toString("base64")}:${ct.toString("base64")}`;
   }
   decrypt(value) {
     if (!this.isEncrypted(value)) return value;
-    const rest = value.slice(ENCRYPTED_PREFIX.length);
+    const prefixMatch = value.match(ENCRYPTED_PREFIX_PATTERN);
+    if (!prefixMatch) {
+      throw new ConfigError({
+        message: "SecretVault: malformed encrypted value",
+        code: ERROR_CODES.CONFIG_PARSE_FAILED,
+        context: { field: "encrypted_value" }
+      });
+    }
+    const rest = value.slice(prefixMatch[0].length);
     const parts = rest.split(":");
     if (parts.length !== 3) {
       throw new ConfigError({
@@ -3218,20 +3323,64 @@ var DefaultSecretVault = class {
     const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
     return pt.toString("utf8");
   }
+  /**
+   * Generate a new encryption key, write it to disk, and increment the key version.
+   * After rotation, encrypt() emits the new version prefix (e.g. enc:v2:).
+   * The caller must re-encrypt existing config values (see rotateConfigKeys()).
+   */
+  rotateKey() {
+    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);
+    fs2.mkdirSync(path2.dirname(this.keyFile), { recursive: true });
+    fs2.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    checkKeyFilePermissions(this.keyFile);
+    this.key = newKey;
+    this._keyVersion = newVersion;
+    return { oldVersion, newVersion };
+  }
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
       const buf = fs2.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new ConfigError({
-          message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`,
-          code: ERROR_CODES.CONFIG_INVALID,
-          context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
-        });
+      if (buf.length === KEY_BYTES) {
+        this.key = buf;
+        this._keyVersion = 1;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
+      if (buf.length === VERSIONED_KEY_FILE_SIZE) {
+        const magic = buf.subarray(0, KEY_FILE_MAGIC.length);
+        if (!magic.equals(KEY_FILE_MAGIC)) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has invalid magic header`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile }
+          });
+        }
+        const version = buf[KEY_FILE_MAGIC.length];
+        const key2 = buf.subarray(KEY_FILE_MAGIC.length + 1);
+        if (key2.length !== KEY_BYTES) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has wrong key size (${key2.length} bytes, expected ${KEY_BYTES})`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: key2.length }
+          });
+        }
+        this.key = Buffer.from(key2);
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
       }
-      this.key = buf;
-      checkKeyFilePermissions(this.keyFile);
-      return this.key;
+      throw new ConfigError({
+        message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES} for v1 or ${VERSIONED_KEY_FILE_SIZE} for v2+). Remove it manually to generate a new key.`,
+        code: ERROR_CODES.CONFIG_INVALID,
+        context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
+      });
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -3242,18 +3391,36 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       const buf = fs2.readFileSync(this.keyFile);
-      if (buf.length !== KEY_BYTES) {
-        throw new ConfigError({
-          message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES}). Remove it manually to generate a new key.`,
-          code: ERROR_CODES.CONFIG_INVALID,
-          context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
-        });
+      if (buf.length === KEY_BYTES) {
+        this.key = buf;
+        this._keyVersion = 1;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
+      if (buf.length === VERSIONED_KEY_FILE_SIZE) {
+        const magic = buf.subarray(0, KEY_FILE_MAGIC.length);
+        if (!magic.equals(KEY_FILE_MAGIC)) {
+          throw new ConfigError({
+            message: `SecretVault: key file ${this.keyFile} has invalid magic header`,
+            code: ERROR_CODES.CONFIG_INVALID,
+            context: { keyFile: this.keyFile }
+          });
+        }
+        const version = buf[KEY_FILE_MAGIC.length];
+        const winnerKey = buf.subarray(KEY_FILE_MAGIC.length + 1);
+        this.key = Buffer.from(winnerKey);
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
       }
-      this.key = buf;
-      checkKeyFilePermissions(this.keyFile);
-      return this.key;
+      throw new ConfigError({
+        message: `SecretVault: key file ${this.keyFile} is ${buf.length} bytes (expected ${KEY_BYTES} for v1 or ${VERSIONED_KEY_FILE_SIZE} for v2+). Remove it manually to generate a new key.`,
+        code: ERROR_CODES.CONFIG_INVALID,
+        context: { keyFile: this.keyFile, expectedBytes: KEY_BYTES, actualBytes: buf.length }
+      });
     }
     this.key = key;
+    this._keyVersion = 1;
     return key;
   }
 };
@@ -3334,6 +3501,80 @@ async function migratePlaintextSecrets(configPath, vault, logger) {
   );
   return { migrated: counter.n, file: configPath };
 }
+async function rotateConfigKeys(configPath, vault, logger) {
+  const log = logger?.info ?? (() => {
+  });
+  const warn = logger?.warn ?? ((msg) => console.warn(msg));
+  let raw;
+  try {
+    raw = await fsp3.readFile(configPath, "utf8");
+  } catch {
+    const { oldVersion: oldVersion2, newVersion: newVersion2 } = vault.rotateKey();
+    log(`[secret-vault] Key rotated (v${oldVersion2} \u2192 v${newVersion2}) \u2014 no config file to re-encrypt`);
+    return { rotated: 0, oldVersion: oldVersion2, newVersion: newVersion2, file: configPath };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`[secret-vault] Config file ${configPath} is not valid JSON \u2014 skipping rotation`);
+    return { rotated: 0, oldVersion: vault.keyVersion, newVersion: vault.keyVersion, file: configPath };
+  }
+  const counter = { n: 0 };
+  const decrypted = walkDecryptCount(parsed, vault, counter);
+  if (counter.n === 0) {
+    const { oldVersion: oldVersion2, newVersion: newVersion2 } = vault.rotateKey();
+    log(`[secret-vault] Key rotated (v${oldVersion2} \u2192 v${newVersion2}) \u2014 no encrypted fields to re-encrypt`);
+    return { rotated: 0, oldVersion: oldVersion2, newVersion: newVersion2, file: configPath };
+  }
+  const { oldVersion, newVersion } = vault.rotateKey();
+  const reencrypted = walkReencrypt(decrypted, vault);
+  await atomicWrite(configPath, JSON.stringify(reencrypted, null, 2), { mode: 384 });
+  await restrictFilePermissions(configPath, { warn });
+  log(`[secret-vault] Key rotated (v${oldVersion} \u2192 v${newVersion}) \u2014 re-encrypted ${counter.n} field(s)`);
+  return { rotated: counter.n, oldVersion, newVersion, file: configPath };
+}
+function walkDecryptCount(node, vault, counter) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walkDecryptCount(item, vault, counter));
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && vault.isEncrypted(v)) {
+      try {
+        out[k] = vault.decrypt(v);
+        counter.n++;
+      } catch {
+        out[k] = v;
+      }
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walkDecryptCount(v, vault, counter);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function walkReencrypt(node, vault) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walkReencrypt(item, vault));
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && isSecretField(k) && v.length > 0 && !vault.isEncrypted(v)) {
+      out[k] = vault.encrypt(v);
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walkReencrypt(v, vault);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
 async function restrictFilePermissions(filePath, opts) {
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   if (process.platform === "win32") {
@@ -3684,7 +3925,11 @@ var MEMORY_TYPE_LABELS = {
 };
 
 // src/execution/compaction-core.ts
+function compactionDebugEnabled() {
+  return process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1";
+}
 function emitCompactionMetrics(event, metrics) {
+  if (!compactionDebugEnabled()) return;
   console.log(
     JSON.stringify({
       level: "debug",
@@ -3739,18 +3984,20 @@ function findPreserveStart(messages, preserveK) {
       }
     }
   }
-  console.log(
-    JSON.stringify({
-      level: "debug",
-      event: "compaction.find_preserve_start.ended",
-      messageCount: messages.length,
-      preserveK,
-      preserveStart,
-      forwardWalkIterations,
-      forwardWalkInnerIterations,
-      forwardWalkInnerPerOuter: forwardWalkIterations > 0 ? forwardWalkInnerIterations / forwardWalkIterations : 0
-    })
-  );
+  if (compactionDebugEnabled()) {
+    console.log(
+      JSON.stringify({
+        level: "debug",
+        event: "compaction.find_preserve_start.ended",
+        messageCount: messages.length,
+        preserveK,
+        preserveStart,
+        forwardWalkIterations,
+        forwardWalkInnerIterations,
+        forwardWalkInnerPerOuter: forwardWalkIterations > 0 ? forwardWalkInnerIterations / forwardWalkIterations : 0
+      })
+    );
+  }
   return preserveStart;
 }
 function eliseOldToolResults(messages, opts) {
@@ -3817,7 +4064,7 @@ function eliseOldToolResults(messages, opts) {
       changed = true;
     }
     fullPassInnerIterations += original.length;
-    if (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1") {
+    if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
         console.error(
@@ -4374,6 +4621,27 @@ var PATTERNS = [
   { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
   { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
   { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g },
+  // AI/ML provider keys — modern LLM services with well-known prefixes
+  {
+    type: "huggingface_token",
+    // HuggingFace tokens: hf_ followed by 34 alphanumeric chars
+    regex: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{34}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "replicate_token",
+    // Replicate tokens: r8_ followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "perplexity_key",
+    // Perplexity API keys: pplx- followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])pplx-[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "groq_key",
+    // Groq API keys: gsk_ followed by 40+ alphanumeric chars
+    regex: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g
+  },
   {
     type: "bearer_token",
     // Anchored with alternation instead of negative lookahead — avoids V8
@@ -4407,6 +4675,10 @@ function hasCredentialAnchors(text) {
   text.includes("xox") || // Slack token (xoxa/xoxb/xoxp/xoxo/xoxs)
   text.includes("Bearer ") || // Bearer token (space suffix reduces false positives)
   text.includes("/bot") || // Telegram bot token (URL path pattern)
+  text.includes("hf_") || // HuggingFace token
+  text.includes("r8_") || // Replicate token
+  text.includes("pplx-") || // Perplexity API key
+  text.includes("gsk_") || // Groq API key
   text.includes("_KEY=") || // High-entropy env vars: API_KEY=, SECRET_KEY=, ...
   text.includes("_TOKEN=") || // ACCESS_TOKEN=, AUTH_TOKEN=, ...
   text.includes("_SECRET=") || // API_SECRET=, CLIENT_SECRET=, ...
@@ -5243,7 +5515,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -5262,7 +5534,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve14,
+        resolve: resolve15,
         reject,
         timer
       });
@@ -6062,6 +6334,13 @@ var Context = class {
   projectRoot;
   /** Mutable working directory — starts as `cwd`. Change via `setWorkingDir()`. */
   workingDir;
+  /**
+   * When true, file tools (via `_util.ts`) and `setWorkingDir()` reject paths
+   * outside `projectRoot`. When false, those boundary checks are bypassed so
+   * tools may reach paths outside the project (still gated by permission
+   * tiers). Mutable so `/settings` can toggle it live on the running session.
+   */
+  allowOutsideProjectRoot;
   model;
   tools = [];
   meta = {};
@@ -6075,11 +6354,6 @@ var Context = class {
    * so storage operations can include it in `storage.*` events.
    */
   traceId;
-  /**
-   * When true, tools can access any path on the filesystem.
-   * When false or undefined, tools are restricted to the project root.
-   */
-  allowOutsideProjectRoot;
   /** Callbacks fired when `setWorkingDir()` changes the working directory. */
   _onWorkingDirChanged = [];
   /**
@@ -6111,12 +6385,13 @@ var Context = class {
     this.cwd = init.cwd;
     this.projectRoot = init.projectRoot;
     this.workingDir = init.workingDir ?? init.cwd;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
     this.model = init.model;
     this.tools = init.tools ?? [];
     this.agentId = init.agentId ?? "unknown";
     this.agentName = init.agentName ?? "Unknown Agent";
     this.traceId = init.traceId;
-    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? true;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
     this.session.traceId = init.traceId;
   }
   /**
@@ -6182,12 +6457,14 @@ var Context = class {
    */
   setWorkingDir(dir) {
     const resolved = path2.isAbsolute(dir) ? path2.resolve(dir) : path2.resolve(this.projectRoot, dir);
-    const root = path2.resolve(this.projectRoot);
-    const rel = path2.relative(root, resolved);
-    if (rel.startsWith("..") || path2.isAbsolute(rel)) {
-      throw new Error(
-        `Working directory "${resolved}" is outside project root "${root}"`
-      );
+    if (!this.allowOutsideProjectRoot) {
+      const root = path2.resolve(this.projectRoot);
+      const rel = path2.relative(root, resolved);
+      if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+        throw new Error(
+          `Working directory "${resolved}" is outside project root "${root}"`
+        );
+      }
     }
     const old = this.workingDir;
     this.workingDir = resolved;
@@ -6509,11 +6786,34 @@ var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  /**
+   * In-memory cache for load() results, keyed by session ID. The cache is
+   * invalidated when the file's mtimeMs or size changes (indicating the
+   * file was written to). This eliminates redundant full-file reads and
+   * JSON parses when the same session is loaded multiple times within the
+   * store's lifetime (e.g., webui session detail views, list() fallbacks).
+   *
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
+   */
+  _loadCache = /* @__PURE__ */ new Map();
+  static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  /**
+   * Clear the load() cache. Useful for testing or when the caller knows
+   * the file has changed externally (e.g., another process wrote to it).
+   */
+  clearLoadCache(sessionId) {
+    if (sessionId !== void 0) {
+      this._loadCache.delete(sessionId);
+    } else {
+      this._loadCache.clear();
+    }
+  }
   // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
@@ -6656,7 +6956,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    let cacheHit = false;
     try {
+      let stat14;
+      try {
+        const s = await fsp3.stat(file);
+        stat14 = { mtimeMs: s.mtimeMs, size: s.size };
+      } catch (err) {
+        throw err;
+      }
+      const cached = this._loadCache.get(id);
+      if (cached && cached.mtimeMs === stat14.mtimeMs && cached.size === stat14.size) {
+        cacheHit = true;
+        return cached.data;
+      }
       const raw = await fsp3.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
@@ -6672,13 +6985,30 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const meta = this.metaFromEvents(id, events);
       const { messages, usage } = this.replay(events, id);
       const toolCallEnds = extractToolCallEnds(events);
-      return { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, 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: stat14.mtimeMs, size: stat14.size, data });
+      return data;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
       this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: "load",
+          durationMs: Date.now() - t0
+        });
+      }
     }
   }
   async list(limit = 20) {
@@ -6846,8 +7176,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat13 = await fsp3.stat(full);
-      const summary = await this.summarize(id, stat13.mtime.toISOString());
+      const stat14 = await fsp3.stat(full);
+      const summary = await this.summarize(id, stat14.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -6929,8 +7259,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path2.join(dir, name);
       try {
-        const stat13 = await fsp3.stat(jsonlPath);
-        if (stat13.mtimeMs >= cutoff) return;
+        const stat14 = await fsp3.stat(jsonlPath);
+        if (stat14.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -8754,7 +9084,8 @@ var BEHAVIOR_DEFAULTS = {
     iterationTimeoutMs: DEFAULT_TOOLS_CONFIG.iterationTimeoutMs,
     sessionTimeoutMs: DEFAULT_TOOLS_CONFIG.sessionTimeoutMs,
     perIterationOutputCapBytes: DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
-    autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit
+    autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
+    restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot
   },
   log: { level: "info" },
   features: {
@@ -9747,6 +10078,7 @@ async function savePlan(filePath, plan, events) {
       outcome: "success",
       durationMs: Date.now() - t0
     });
+    return true;
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: "~boot~",
@@ -9760,6 +10092,7 @@ async function savePlan(filePath, plan, events) {
       "[plan-store] save failed:",
       toErrorMessage(err)
     );
+    return false;
   }
 }
 function emptyPlan(sessionId, title) {
@@ -9861,7 +10194,10 @@ async function mutatePlan(filePath, sessionId, fn) {
   return withFileLock(filePath, async () => {
     const plan = await loadPlan(filePath) ?? emptyPlan(sessionId);
     const updated = await fn(plan);
-    await savePlan(filePath, updated);
+    const persisted = await savePlan(filePath, updated);
+    if (!persisted) {
+      throw new Error(`Failed to persist plan to ${filePath} \u2014 the change was NOT saved.`);
+    }
     return updated;
   });
 }
@@ -10691,12 +11027,12 @@ var DefaultSkillLoader = class {
   }
   async find(name) {
     const all = await this.list();
-    return all.find((s) => s.name === name);
+    const lower = name.toLowerCase();
+    return all.find((s) => s.name.toLowerCase() === lower);
   }
   async manifestText() {
-    const skills = await this.list();
-    if (skills.length === 0) return "";
     const entries = await this.listEntries();
+    if (entries.length === 0) return "";
     const lines = ["## Available skills"];
     for (const e of entries) {
       const scopeTag = e.scope.length > 0 ? ` \u2014 ${e.scope.slice(0, 3).join(", ")}` : "";
@@ -10710,12 +11046,8 @@ var DefaultSkillLoader = class {
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
-      try {
-        const raw = await fsp3.readFile(s.path, "utf8");
-        const { trigger, scope } = parseDescription(raw);
-        entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
-      } catch {
-      }
+      const { trigger, scope } = parseDescriptionFromText(s.description ?? "");
+      entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
     }
     this.entriesCache = entries;
     return entries;
@@ -10726,16 +11058,17 @@ var DefaultSkillLoader = class {
     this.bodyCache.clear();
   }
   async readBody(name) {
-    const cached = this.bodyCache.get(name);
+    const key = name.toLowerCase();
+    const cached = this.bodyCache.get(key);
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const body = await fsp3.readFile(m.path, "utf8");
-    this.bodyCache.set(name, body);
+    this.bodyCache.set(key, body);
     return body;
   }
   async readSaveBody(name) {
-    const key = `save:${name}`;
+    const key = `save:${name.toLowerCase()}`;
     const cached = this.bodyCache.get(key);
     if (cached !== void 0) return cached;
     const m = await this.find(name);
@@ -10796,9 +11129,7 @@ function parseFrontmatter(raw) {
   flush();
   return out;
 }
-function parseDescription(raw) {
-  const fm = parseFrontmatter(raw);
-  const desc = fm.description ?? "";
+function parseDescriptionFromText(desc) {
   const firstSentenceEnd = desc.indexOf(". ");
   const trigger = firstSentenceEnd !== -1 ? desc.slice(0, firstSentenceEnd + 1).trim() : desc.trim().split("\n")[0] ?? "";
   const scope = [];
@@ -11056,8 +11387,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve14) => {
-            drainTimer = setTimeout(resolve14, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve15) => {
+            drainTimer = setTimeout(resolve15, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -11163,7 +11494,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve14, reject) => {
+      await new Promise((resolve15, reject) => {
         let settled = false;
         const onAbort = () => {
           if (settled) return;
@@ -11176,7 +11507,7 @@ async function runProviderWithRetry(opts) {
           settled = true;
           clearTimeout(t2);
           signal.removeEventListener("abort", onAbort);
-          resolve14();
+          resolve15();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -11306,7 +11637,12 @@ var IntelligentCompactor = class {
     };
     const ac = ctx.signal ? void 0 : new AbortController();
     const signal = ctx.signal ?? ac?.signal;
-    const res = await this.provider.complete(req, { signal });
+    let res;
+    try {
+      res = await this.provider.complete(req, { signal });
+    } finally {
+      ac?.abort();
+    }
     const textBlocks = res.content.filter(isTextBlock);
     return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
   }
@@ -11350,9 +11686,9 @@ Rules:
 - If unsure, keep rather than collapse (errors are more costly than waste)
 
 Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
-function formatMessages(messages, maxChars = 8e3) {
+function formatMessages(messages, maxTokens = 2048) {
   const lines = [];
-  let used = 0;
+  let usedTokens = 0;
   for (let i = 0; i < messages.length; i++) {
     const m = expectDefined(messages[i]);
     const role = m.role.padEnd(10, " ");
@@ -11364,13 +11700,14 @@ function formatMessages(messages, maxChars = 8e3) {
       text = content.filter(isTextBlock).map((b) => b.text).join(" ");
       const toolUses = content.filter((b) => b.type === "tool_use");
       if (toolUses.length > 0) {
-        text += ` [tools: ${toolUses.map((b) => b.name).join(", ")}]`;
+        text += ` [tools: ${toolUses.map((b) => b.name).filter(Boolean).join(", ")}]`;
       }
     }
     const line = `[${i}][${role}]: ${text}`;
-    if (used + line.length > maxChars) break;
+    const lineTokens = estimateTextTokens(line);
+    if (usedTokens + lineTokens > maxTokens) break;
     lines.push(line);
-    used += line.length;
+    usedTokens += lineTokens;
   }
   return lines.join("\n");
 }
@@ -11379,20 +11716,29 @@ var LLMSelector = class {
   model;
   maxContextTokens;
   systemPrompt;
+  maxOutputTokens;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
+    if (this.model === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      console.warn(
+        "[LLMSelector] model not set \u2014 selector will use the provider default. Set `model` explicitly in LLMSelectorOptions to silence this warning."
+      );
+    }
     this.maxContextTokens = opts.maxContextTokens ?? 4e4;
     this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.maxOutputTokens = opts.maxOutputTokens ?? 1024;
   }
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
-    const historyText = formatMessages(messages);
     const totalTokens = estimateMessageTokens(messages);
     const systemText = `${this.systemPrompt}
 
 Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
 `;
+    const systemTokens = estimateTextTokens(systemText);
+    const historyBudget = Math.max(512, effectiveBudget - systemTokens - this.maxOutputTokens);
+    const historyText = formatMessages(messages, historyBudget);
     const budgetInstruction = totalTokens > effectiveBudget ? `
 
 IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
@@ -11400,18 +11746,26 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       model: this.model,
       system: [{ type: "text", text: systemText + budgetInstruction }],
       messages: [{ role: "user", content: historyText }],
-      maxTokens: 1024
+      maxTokens: this.maxOutputTokens
     };
     let raw;
+    const ac = new AbortController();
     try {
-      const ac = new AbortController();
-      const res = await this.provider.complete(req, { signal: ac.signal });
+      const timeoutSignal = AbortSignal.timeout(3e4);
+      const res = await this.provider.complete(req, {
+        signal: AbortSignal.any([ac.signal, timeoutSignal])
+      });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (_err) {
+    } catch (err) {
+      if (err instanceof Error) {
+        console.warn("[LLMSelector] selector call failed, using recency fallback:", err.message);
+      }
       return this.fallbackSelect(messages, effectiveBudget);
+    } finally {
+      ac.abort();
     }
-    return this.parseSelectorOutput(raw, messages.length);
+    return this.parseSelectorOutput(raw, messages);
   }
   fallbackSelect(messages, budget) {
     const toKeep = [];
@@ -11438,34 +11792,63 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
     };
   }
-  parseSelectorOutput(raw, messageCount) {
+  /**
+   * Parse and validate the raw LLM output into a SelectorResult.
+   * Falls back to recency-based selection if the LLM output is malformed,
+   * out-of-bounds, or internally inconsistent.
+   */
+  parseSelectorOutput(raw, messages) {
+    const messageCount = messages.length;
+    if (messageCount === 0) {
+      return { kept: [], collapsed: [], reasoning: "empty session" };
+    }
     const jsonStart = raw.indexOf("{");
     const jsonEnd = raw.lastIndexOf("}");
     if (jsonStart === -1 || jsonEnd === -1) {
-      return this.fallbackSelect(
-        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
-        this.maxContextTokens
-      );
+      return this.fallbackSelect(messages, this.maxContextTokens);
     }
     let parsed;
     try {
       parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
     } catch {
-      return this.fallbackSelect(
-        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
-        this.maxContextTokens
-      );
+      return this.fallbackSelect(messages, this.maxContextTokens);
     }
     const obj = parsed;
-    const kept = obj.kept ?? [];
-    const collapsed = obj.collapsed ?? [];
-    return {
-      kept: kept.map((k) => ({
+    const keptRaw = obj.kept ?? [];
+    const collapsedRaw = obj.collapsed ?? [];
+    const kept = [];
+    for (const k of keptRaw) {
+      if (typeof k.from !== "number" || typeof k.to !== "number" || k.from < 0 || k.to >= messageCount || k.from > k.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      kept.push({
         from: k.from,
         to: k.to,
         importance: k.importance ?? "medium"
-      })),
-      collapsed: collapsed.map((c) => ({ from: c.from, to: c.to, summary: c.summary })),
+      });
+    }
+    const collapsed = [];
+    for (const c of collapsedRaw) {
+      if (typeof c.from !== "number" || typeof c.to !== "number" || c.from < 0 || c.to >= messageCount || c.from > c.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      collapsed.push({ from: c.from, to: c.to, summary: c.summary });
+    }
+    const allRanges = [...kept, ...collapsed];
+    for (let i = 0; i < allRanges.length; i++) {
+      const a = allRanges[i];
+      if (!a) continue;
+      for (let j = i + 1; j < allRanges.length; j++) {
+        const b = allRanges[j];
+        if (!b) continue;
+        if (a.from <= b.to && a.to >= b.from) {
+          return this.fallbackSelect(messages, this.maxContextTokens);
+        }
+      }
+    }
+    return {
+      kept,
+      collapsed,
       reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
     };
   }
@@ -11485,7 +11868,7 @@ var SelectiveCompactor = class {
   summarizerPrompt;
   constructor(opts) {
     this.provider = opts.provider;
-    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel });
+    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
     this.warnThreshold = opts.warnThreshold ?? 0.6;
     this.softThreshold = opts.softThreshold ?? 0.75;
     this.hardThreshold = opts.hardThreshold ?? 0.9;
@@ -11493,6 +11876,11 @@ var SelectiveCompactor = class {
     this.preserveK = opts.preserveK ?? 4;
     this.eliseThreshold = opts.eliseThreshold ?? 500;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel ?? "unknown";
+    if (this.summarizerModel === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      console.warn(
+        "[SelectiveCompactor] summarizerModel not set \u2014 will use provider default. Set `summarizerModel` explicitly to silence this warning."
+      );
+    }
     this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of messages, produce a concise summary that preserves all factual information, decisions, file changes, and state changes. Do not add commentary or opinions.";
   }
   async compact(ctx, opts = {}) {
@@ -11604,8 +11992,9 @@ Summarize the following message range:`;
       maxTokens: 512
     };
     try {
+      const timeoutSignal = AbortSignal.timeout(3e4);
       const res = await this.provider.complete(req, {
-        signal: ctx.signal ?? new AbortController().signal
+        signal: AbortSignal.any([ctx.signal, timeoutSignal])
       });
       return res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim() || "(empty)";
     } catch {
@@ -11739,6 +12128,7 @@ var ProviderBackedCompactor = class {
       return new SelectiveCompactor({
         ...common,
         selectorModel: this.opts.summarizerModel,
+        selectorMaxOutputTokens: this.opts.selectorMaxOutputTokens,
         summarizerModel: this.opts.summarizerModel
       });
     }
@@ -13282,6 +13672,7 @@ ${recentJournal}` : ""
 
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
+var DECISION_TIMEOUT_MS = 6e4;
 var BudgetExceededError = class extends Error {
   kind;
   limit;
@@ -13311,6 +13702,31 @@ var BudgetThresholdSignal = class extends Error {
 };
 var SubagentBudget = class _SubagentBudget {
   limits;
+  /** Patch one or more budget limits in-place after construction.
+   * Used by the coordinator watchdog when granting an extension.
+   * All fields are optional — only provided fields are updated.
+   * This is the single write path for limit mutations so that future
+   * validation or side-effects live in one place (M1). */
+  patchLimits(ext) {
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+    if (ext.timeoutMs !== void 0) {
+      this.limits.timeoutMs = ext.timeoutMs;
+    }
+    if (ext.idleTimeoutMs !== void 0) {
+      this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+    }
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -13331,12 +13747,44 @@ var SubagentBudget = class _SubagentBudget {
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
    */
-  static DECISION_TIMEOUT_MS = 6e4;
+  static DECISION_TIMEOUT_MS = DECISION_TIMEOUT_MS;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Guard against dual-path races between the coordinator watchdog
+   * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
+   * Both paths detect `elapsed >= timeoutMs` and can emit
+   * `budget.threshold_reached` for kind `'timeout'` simultaneously.
+   * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
+   * calling `onThreshold`, and cleared after the negotiation resolves.
+   * `checkTimeout()` skips its wall-clock check while this is set so
+   * the coordinator's watchdog is the sole source of wall-clock timeout
+   * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
+   */
+  _watchdogActive;
+  /** Returns the timeout ceiling currently being negotiated by the watchdog,
+   * or `undefined` when no wall-clock negotiation is in flight.
+   * Used by `executeWithTimeout` to detect a stale lock (M3). */
+  get watchdogActive() {
+    return this._watchdogActive;
+  }
+  /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
+   * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
+   * the budget's own `checkTimeout()` from emitting a second
+   * `budget.threshold_reached` event while the watchdog is already
+   * negotiating the same wall-clock deadline (C1). */
+  setWatchdogNegotiation(timeoutMs) {
+    this._watchdogActive = timeoutMs;
+  }
+  /** Clears the watchdog guard after negotiation resolves. Called in the
+   * `finally` block of both the pre-empt and deadline branches so it fires
+   * on every exit path: grant, deny, throw, or error. */
+  clearWatchdogNegotiation() {
+    this._watchdogActive = void 0;
+  }
   /**
    * Negotiation mode — controls whether a threshold hit tries to emit
    * `budget.threshold_reached` and wait for a coordinator decision, or
@@ -13437,7 +13885,8 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
     }
@@ -13451,19 +13900,99 @@ var SubagentBudget = class _SubagentBudget {
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus) {
       const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+    if (bus.hasListenerFor("budget.threshold_reached")) {
+      for (const entry of exceeded) {
+        if (this._pendingNegotiations.has(entry.kind)) continue;
+        this._pendingNegotiations.set(entry.kind, this._negotiateExtension(entry));
+      }
+      const decision = this._pendingNegotiations.get(first.kind);
+      if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
+      throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    }
+    let hardStop = null;
     for (const entry of exceeded) {
       if (this._pendingNegotiations.has(entry.kind)) continue;
-      const decision2 = this._negotiateExtension(entry.kind, exceeded);
-      this._pendingNegotiations.set(entry.kind, decision2);
+      const marker = Promise.resolve("stop");
+      this._pendingNegotiations.set(entry.kind, marker);
+      void marker.finally(() => this._pendingNegotiations.delete(entry.kind));
+      const sync = this._invokeHandlerSync(entry);
+      if (!sync) hardStop ??= new BudgetExceededError(entry.kind, entry.limit, entry.used);
+    }
+    if (hardStop) throw hardStop;
+    return exceeded;
+  }
+  /**
+   * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
+   * whether it decided synchronously. Returns `true` when the handler returned
+   * a synchronous decision (already honored — an `extend` patched the limits),
+   * or `false` when it returned a Promise (async; the caller hard-stops, since
+   * there is no listener to resolve the negotiation). The handler is given the
+   * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
+   * recording handlers and policy handlers work without a wired listener.
+   */
+  _invokeHandlerSync(entry) {
+    const handler = this._onThreshold;
+    if (!handler) return false;
+    let extendArg;
+    const result = handler({
+      kind: entry.kind,
+      used: entry.used,
+      limit: entry.limit,
+      requestDecision: () => this._busRequestDecision(entry),
+      // Direct hooks for synchronous policy/recording handlers.
+      extend: (extra) => {
+        extendArg = extra;
+      },
+      deny: () => {
+      }
+    });
+    if (result && typeof result.then === "function") return false;
+    if (result === "throw") return false;
+    if (result && typeof result === "object" && "extend" in result) {
+      extendArg = result.extend;
     }
-    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
-    const decision = this._pendingNegotiations.get(first.kind);
-    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
-    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    if (extendArg) this.patchLimits(extendArg);
+    return true;
+  }
+  /**
+   * Emit `budget.threshold_reached` and resolve to the listener's verdict.
+   * Resolves to `'stop'` immediately when there is no listener (or no bus) so
+   * no negotiation can hang and no fallback timer leaks. Mirrors the
+   * coordinator watchdog's own request path so both agree on the no-listener
+   * default.
+   */
+  _busRequestDecision(entry) {
+    const bus = this._events;
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+      return Promise.resolve("stop");
+    }
+    return new Promise((resolve15) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve15(d);
+      };
+      const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
+      bus.emit("budget.threshold_reached", {
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+        // deny() wins over a same-dispatch extend(): a listener that both grants
+        // and denies (or two listeners disagreeing) is resolved as a stop. The
+        // grant is deferred a microtask so a synchronous deny in the same emit
+        // pre-empts it; async grants still resolve normally.
+        extend: (extra) => queueMicrotask(() => respond({ extend: extra })),
+        deny: () => respond("stop")
+      });
+    });
   }
   /**
    * Per-kind in-flight negotiation Promises. Each budget kind can have its
@@ -13483,77 +14012,33 @@ var SubagentBudget = class _SubagentBudget {
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async _negotiateExtension(kind, exceeded) {
+  async _negotiateExtension(entry) {
     if (!this._onThreshold) {
       return "stop";
     }
     try {
-      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
-        kind: first.kind,
-        used: first.used,
-        limit: first.limit,
-        requestDecision: () => {
-          const bus = this._events;
-          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-            return Promise.resolve("stop");
-          }
-          return new Promise((resolve14) => {
-            let resolved = false;
-            const respond = (d) => {
-              if (resolved) return;
-              resolved = true;
-              resolve14(d);
-            };
-            const fallback = setTimeout(
-              () => respond("stop"),
-              _SubagentBudget.DECISION_TIMEOUT_MS
-            );
-            for (const { kind: kind2, used, limit } of exceeded) {
-              bus.emit("budget.threshold_reached", {
-                kind: kind2,
-                used,
-                limit,
-                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-                extend: (extra) => {
-                  clearTimeout(fallback);
-                  respond({ extend: extra });
-                },
-                deny: () => {
-                  clearTimeout(fallback);
-                  respond("stop");
-                }
-              });
-            }
-          });
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        // One event for THIS kind only — each exceeded kind has its own
+        // negotiation (and its own resolve), so there is no cross-kind
+        // first-wins drop and no O(N^2) re-emission.
+        requestDecision: () => this._busRequestDecision(entry),
+        extend: (extra) => {
+          this.patchLimits(extra);
+        },
+        deny: () => {
         }
       });
       if (result === "throw") return "stop";
       if (result === "continue") return { extend: {} };
       const decision = await result;
       if (decision === "stop") return "stop";
-      const ext = decision.extend;
-      if (ext.maxIterations !== void 0) {
-        this.limits.maxIterations = ext.maxIterations;
-      }
-      if (ext.maxToolCalls !== void 0) {
-        this.limits.maxToolCalls = ext.maxToolCalls;
-      }
-      if (ext.maxTokens !== void 0) {
-        this.limits.maxTokens = ext.maxTokens;
-      }
-      if (ext.maxCostUsd !== void 0) {
-        this.limits.maxCostUsd = ext.maxCostUsd;
-      }
-      if (ext.timeoutMs !== void 0) {
-        this.limits.timeoutMs = ext.timeoutMs;
-      }
-      if (ext.idleTimeoutMs !== void 0) {
-        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
-      }
+      this.patchLimits(decision.extend);
       return decision;
     } finally {
-      this._pendingNegotiations.delete(kind);
+      this._pendingNegotiations.delete(entry.kind);
     }
   }
   recordIteration() {
@@ -13596,7 +14081,8 @@ var SubagentBudget = class _SubagentBudget {
     const { timeoutMs, idleTimeoutMs } = this.limits;
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
+    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed);
@@ -17104,6 +17590,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
+    this.setMaxListeners(0);
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
@@ -17301,7 +17788,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((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -17310,7 +17797,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve14(result);
+              resolve15(result);
             }
           };
           this.on("task.completed", handler);
@@ -17498,7 +17985,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     let result;
     budget.start();
     try {
-      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      const outcome = await this.executeWithTimeout(
+        this.runner,
+        task,
+        runCtx,
+        budget,
+        subagent.config.preemptFraction
+      );
       result = {
         subagentId,
         taskId: task.id,
@@ -17525,7 +18018,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction = TIMEOUT_PREEMPT_FRACTION) {
     const initialTimeoutMs = budget.limits.timeoutMs;
     const idleLimitMs = budget.limits.idleTimeoutMs;
     if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
@@ -17533,8 +18026,21 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const start = Date.now();
     let timer = null;
-    let preemptedForLimit = null;
+    let PreemptState;
+    ((PreemptState2) => {
+      PreemptState2["ACTIVE"] = "active";
+      PreemptState2["LOCKED"] = "locked";
+    })(PreemptState || (PreemptState = {}));
+    let preemptedCeiling = null;
+    let preemptState = "active" /* ACTIVE */;
+    let lastGrantActivityTs = -1;
     const timeoutPromise = new Promise((_, reject) => {
+      const terminate = (kind, limit, used) => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(
+          budget._events?.hasListenerFor("budget.threshold_reached") ? new Error(`subagent stopped: budget ${kind} (limit=${limit}, used=${used})`) : new BudgetExceededError(kind, limit, used)
+        );
+      };
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(onTick, Math.max(0, ms));
@@ -17543,7 +18049,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
         const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
         const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-        const preemptRemaining = initialTimeoutMs === void 0 || preemptedForLimit === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * TIMEOUT_PREEMPT_FRACTION - (Date.now() - start);
+        const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
         armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
       };
       const negotiateTimeout = async (used, limit) => {
@@ -17553,16 +18059,42 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           kind: "timeout",
           used,
           limit,
-          requestDecision: () => new Promise((resolveDecision) => {
-            budget._events?.emit("budget.threshold_reached", {
-              kind: "timeout",
-              used,
-              limit,
-              timeoutMs: 6e4,
-              extend: (extra) => resolveDecision({ extend: extra }),
-              deny: () => resolveDecision("stop")
+          requestDecision: () => {
+            if (!budget._events?.hasListenerFor("budget.threshold_reached")) {
+              return Promise.resolve("stop");
+            }
+            return new Promise((resolveDecision) => {
+              let settled = false;
+              const resolve15 = (d) => {
+                if (settled) return;
+                settled = true;
+                resolveDecision(d);
+              };
+              const fallback = setTimeout(() => resolve15("stop"), DECISION_TIMEOUT_MS);
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used,
+                limit,
+                // Informational: the budget's own decision deadline. Listeners may use
+                // this to display a countdown. The coordinator does NOT enforce it —
+                // it is the budget's own `setTimeout(fallback)` that races against
+                // the listener's `extend()`/`deny()` call to guarantee progress.
+                timeoutMs: DECISION_TIMEOUT_MS,
+                // deny() wins over a same-dispatch extend(): defer the grant a
+                // microtask so a synchronous deny in the same emit pre-empts it
+                // (a listener that both grants and denies, or two listeners
+                // disagreeing, resolves as a stop). Async grants still resolve.
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  queueMicrotask(() => resolve15({ extend: extra }));
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  resolve15("stop");
+                }
+              });
             });
-          })
+          }
         });
         return typeof result === "string" ? result : await result;
       };
@@ -17573,21 +18105,45 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
+          budget._events?.emit("budget.threshold_reached", {
+            kind: "idle_timeout",
+            used: budget.idleMs(),
+            limit: idleLimit ?? 0,
+            timeoutMs: DECISION_TIMEOUT_MS,
+            extend: () => {
+            },
+            deny: () => {
+            }
+          });
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
+          reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
-        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptedForLimit !== wallLimit && elapsed >= wallLimit * TIMEOUT_PREEMPT_FRACTION) {
+        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+          const activityTs = Date.now() - budget.idleMs();
+          if (activityTs <= lastGrantActivityTs) {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+            scheduleNext();
+            return;
+          }
+          budget.setWatchdogNegotiation(wallLimit);
           try {
             const decision = await negotiateTimeout(elapsed, wallLimit);
             if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              preemptedForLimit = null;
+              budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+              lastGrantActivityTs = Date.now() - budget.idleMs();
+              preemptState = "active" /* ACTIVE */;
+              preemptedCeiling = null;
             } else {
-              preemptedForLimit = wallLimit;
+              preemptState = "locked" /* LOCKED */;
+              preemptedCeiling = wallLimit;
             }
           } catch {
-            preemptedForLimit = wallLimit;
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+          } finally {
+            budget.clearWatchdogNegotiation();
           }
           scheduleNext();
           return;
@@ -17602,26 +18158,41 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           reject(new BudgetExceededError("timeout", limit, elapsed));
           return;
         }
+        budget.setWatchdogNegotiation(limit);
         try {
           const decision = await negotiateTimeout(elapsed, limit);
-          if (decision === "continue" || decision === "throw" || decision === "stop") {
-            preemptedForLimit = null;
+          if (decision === "throw") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
+          if (decision === "continue") {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
             armFor(Math.max(1e3, limit));
             return;
           }
+          if (decision === "stop") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
           if (decision.extend.timeoutMs !== void 0) {
-            budget.limits.timeoutMs = decision.extend.timeoutMs;
-            preemptedForLimit = null;
+            budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+            lastGrantActivityTs = Date.now() - budget.idleMs();
+            preemptState = "active" /* ACTIVE */;
+            preemptedCeiling = null;
             scheduleNext();
             return;
           }
-          this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", limit, elapsed));
+          terminate("timeout", limit, elapsed);
+          return;
         } catch (err) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(
             err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
           );
+          return;
+        } finally {
+          budget.clearWatchdogNegotiation();
         }
       };
       scheduleNext();
@@ -18398,7 +18969,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat13] = await Promise.all([
+        const [content, stat14] = await Promise.all([
           fsp3.readFile(filePath, "utf8"),
           fsp3.stat(filePath)
         ]);
@@ -18408,8 +18979,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat13.mtimeMs,
-          snapshotSizeBytes: stat13.size
+          snapshotMtimeMs: stat14.mtimeMs,
+          snapshotSizeBytes: stat14.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -18822,9 +19393,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 stat13 = await fsp3.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat13.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat13.size !== file.snapshotSizeBytes;
+        const stat14 = await fsp3.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat14.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat14.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -20718,11 +21289,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve14;
+        let resolve15;
         const promise = new Promise((res) => {
-          resolve14 = res;
+          resolve15 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve14 });
+        this.taskWaiters.set(id, { promise, resolve: resolve15 });
         return promise;
       })
     );
@@ -21118,7 +21689,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve14) => {
+        const result = await new Promise((resolve15) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -21128,7 +21699,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve14(value);
+            resolve15(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -21439,6 +22010,7 @@ function attachAutoExtend(events, policy = {}) {
   const extendCounts = /* @__PURE__ */ new Map();
   let progress = 0;
   let lastTimeoutProgress = -1;
+  let lastSeenKey = null;
   const unsubs = [
     events.on("tool.executed", () => {
       progress++;
@@ -21448,6 +22020,9 @@ function attachAutoExtend(events, policy = {}) {
     }),
     events.on("budget.threshold_reached", (e) => {
       const { kind, limit, extend, deny } = e;
+      const key = `${kind}:${limit}`;
+      if (key === lastSeenKey) return;
+      lastSeenKey = key;
       if (kind === "timeout" || kind === "idle_timeout") {
         if (progress > lastTimeoutProgress) {
           lastTimeoutProgress = progress;
@@ -21556,8 +22131,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path2.join(modesDir, entry);
-      const stat13 = await fsp3.stat(filePath);
-      if (!stat13.isFile()) continue;
+      const stat14 = await fsp3.stat(filePath);
+      if (!stat14.isFile()) continue;
       const content = await fsp3.readFile(filePath, "utf8");
       const id = path2.basename(entry, path2.extname(entry));
       modes.push({
@@ -22866,9 +23441,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp25 = await import('fs/promises');
-      const path43 = await import('path');
+      const path44 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp25.mkdir(path43.dirname(this.sessionPath), { recursive: true });
+      await fsp25.mkdir(path44.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -23595,15 +24170,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path43 = [];
+  const path44 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path43.unshift(current);
+    path44.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path43;
+  return path44;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -24426,9 +25001,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve14) => {
+    const timeout = new Promise((resolve15) => {
       timer = setTimeout(
-        () => resolve14({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve15({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -24611,7 +25186,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path43 = opts.path ?? "/metrics";
+  const path44 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -24621,7 +25196,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path43) {
+    if (url === path44) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -24667,14 +25242,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve14, reject) => {
+  await new Promise((resolve15, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve14();
+      resolve15();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -24685,9 +25260,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path43}`,
-    close: () => new Promise((resolve14, reject) => {
-      server.close((err) => err ? reject(err) : resolve14());
+    url: `${protocol}://${host}:${boundPort}${path44}`,
+    close: () => new Promise((resolve15, reject) => {
+      server.close((err) => err ? reject(err) : resolve15());
     })
   };
 }
@@ -25002,11 +25577,12 @@ function createContextManagerTool(opts = {}) {
       const applyMessages = (next) => {
         const repaired = repairToolUseAdjacency(next);
         const finalMessages = repaired.messages;
+        if (finalMessages === messages) return repaired.report;
         if (ctx.state) {
           ctx.state.replaceMessages(finalMessages);
         } else {
           messages.length = 0;
-          messages.splice(0, 0, ...finalMessages);
+          messages.push(...finalMessages);
         }
         return repaired.report;
       };
@@ -25081,9 +25657,15 @@ function createContextManagerTool(opts = {}) {
           }
           const report = await opts.compactor.compact(ctx);
           ctx.clearFileTracking();
-          const repair = applyMessages([...ctx.messages]);
-          const afterTokens = repair.changed ? roughEstimate(ctx.messages) : report.after;
-          const repaired = report.repaired ?? (repair.changed ? repair : void 0);
+          let repaired = report.repaired;
+          let afterTokens;
+          if (!ctx.state) {
+            const repair = applyMessages([...ctx.messages]);
+            repaired = report.repaired ?? (repair.changed ? repair : void 0);
+            afterTokens = repair.changed ? roughEstimate(ctx.messages) : report.after;
+          } else {
+            afterTokens = report.after;
+          }
           const reduced = report.fullRequestTokensBefore > report.fullRequestTokensAfter;
           const repairedSomething = !!report.repaired;
           if (reduced || repairedSomething) {
@@ -25603,13 +26185,13 @@ var SkillInstaller = class {
               context: { reason: "path_traversal", skillName: skill.name }
             });
           }
-          const stat13 = await fsp3.stat(srcPath);
-          if (stat13.size > MAX_SKILL_FILE_SIZE) {
+          const stat14 = await fsp3.stat(srcPath);
+          if (stat14.size > MAX_SKILL_FILE_SIZE) {
             throw new FsError({
-              message: `Skill file "${file}" is too large (${(stat13.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
+              message: `Skill file "${file}" is too large (${(stat14.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: stat13.size, maxSize: MAX_SKILL_FILE_SIZE }
+              context: { skillName: skill.name, fileSize: stat14.size, maxSize: MAX_SKILL_FILE_SIZE }
             });
           }
           await fsp3.mkdir(path2.dirname(destPath), { recursive: true });
@@ -26833,15 +27415,15 @@ var SessionRecovery = class {
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
     const TAIL_SIZE = 8192;
-    let stat13;
+    let stat14;
     try {
-      stat13 = await fsp3.stat(fp);
+      stat14 = await fsp3.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat13.size === 0) return null;
-    const position = Math.max(0, stat13.size - TAIL_SIZE);
+    if (stat14.size === 0) return null;
+    const position = Math.max(0, stat14.size - TAIL_SIZE);
     const buf = Buffer.alloc(TAIL_SIZE);
     let fh;
     try {
@@ -27309,6 +27891,10 @@ function sortKeys2(value) {
 init_session_registry();
 
 // src/agent-status-tracker.ts
+var AGENT_REAP_MS = 3e4;
+var AGENT_SWEEP_INTERVAL_MS = 1e4;
+var PARTIAL_TEXT_CAP = 1200;
+var PARTIAL_FLUSH_THROTTLE_MS = 300;
 var AgentStatusTracker = class {
   events;
   registry;
@@ -27320,11 +27906,21 @@ var AgentStatusTracker = class {
   leaderCurrentTool;
   leaderIterations = 0;
   leaderToolCalls = 0;
+  leaderCostUsd = 0;
+  leaderTokensIn = 0;
+  leaderTokensOut = 0;
+  leaderCtxPct;
+  leaderModel;
+  leaderPartialText = "";
   unsubscribers = [];
+  onUpdate;
+  sweepTimer = null;
+  partialTimer = null;
   constructor(opts) {
     this.events = opts.events;
     this.registry = opts.registry;
     this.leaderName = opts.leaderName ?? "leader";
+    this.onUpdate = opts.onUpdate;
   }
   start() {
     this.unsubscribers.push(
@@ -27334,10 +27930,22 @@ var AgentStatusTracker = class {
         this.flush();
       })
     );
+    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);
+        }
+        this.flush();
+      })
+    );
     this.unsubscribers.push(
       this.events.onPattern("agent.run.completed", () => {
         this.leaderStatus = "idle";
         this.leaderCurrentTool = void 0;
+        this.leaderPartialText = "";
         this.flush();
       })
     );
@@ -27345,6 +27953,7 @@ var AgentStatusTracker = class {
       this.events.onPattern("agent.run.error", () => {
         this.leaderStatus = "error";
         this.leaderCurrentTool = void 0;
+        this.leaderPartialText = "";
         this.flush();
       })
     );
@@ -27374,74 +27983,120 @@ var AgentStatusTracker = class {
     this.unsubscribers.push(
       this.events.onPattern("llm.stream_started", () => {
         this.leaderStatus = "streaming";
+        this.leaderPartialText = "";
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.spawned", (_event, payload) => {
+      this.events.onPattern("provider.text_delta", (_e, payload) => {
+        const text = payload?.text;
+        if (!text) return;
+        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("token.accounted", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          this.agents.set(p.subagentId, {
-            id: p.subagentId,
-            name: p.name ?? p.subagentId,
-            status: "idle",
-            iterations: 0,
-            toolCalls: 0,
-            lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          this.flush();
-        }
+        if (!p) return;
+        this.leaderTokensIn += p.usage?.input ?? 0;
+        this.leaderTokensOut += p.usage?.output ?? 0;
+        this.leaderCostUsd += p.cost?.total ?? 0;
+        this.flush();
       })
     );
+    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() };
+        this.agents.set(id, entry);
+      }
+      entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+      return entry;
+    };
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.task_started", (_event, payload) => {
+      this.events.onPattern("subagent.spawned", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "running";
-            entry.iterations++;
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.name = p.name?.trim() || entry.name;
+        if (p.model) entry.model = p.model;
+        entry.status = "running";
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.task_completed", (_event, payload) => {
+      this.events.onPattern("subagent.ctx_pct", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "idle";
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        if (typeof p.load === "number") entry.ctxPct = Math.round(p.load * 100);
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.error", (_event, payload) => {
+      this.events.onPattern("subagent.task_started", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "error";
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        entry.iterations++;
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.stopped", (_event, payload) => {
+      this.events.onPattern("subagent.tool_executed", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          this.agents.delete(p.subagentId);
-          this.flush();
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        entry.currentTool = p.name;
+        entry.toolCalls++;
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.iteration_summary", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        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;
+        if (p.currentTool) entry.currentTool = p.currentTool;
+        if (typeof p.partialText === "string") {
+          entry.partialText = p.partialText.length > PARTIAL_TEXT_CAP ? p.partialText.slice(p.partialText.length - PARTIAL_TEXT_CAP) : p.partialText;
         }
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.task_completed", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        const entry = this.agents.get(p.subagentId);
+        if (!entry) return;
+        entry.status = p.status === "failed" || p.status === "timeout" ? "error" : "idle";
+        entry.currentTool = void 0;
+        entry.partialText = void 0;
+        if (typeof p.iterations === "number") entry.iterations = p.iterations;
+        if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
+        entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.flush();
       })
     );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.stopped", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        if (this.agents.delete(p.subagentId)) this.flush();
+      })
+    );
+    this.sweepTimer = setInterval(() => this.sweep(), AGENT_SWEEP_INTERVAL_MS);
+    if (typeof this.sweepTimer.unref === "function") this.sweepTimer.unref();
   }
   stop() {
     for (const unsub of this.unsubscribers) {
@@ -27451,6 +28106,45 @@ var AgentStatusTracker = class {
       }
     }
     this.unsubscribers = [];
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    if (this.partialTimer) {
+      clearTimeout(this.partialTimer);
+      this.partialTimer = null;
+    }
+  }
+  /**
+   * Coalesce streamed-text flushes: at most one registry write per
+   * {@link PARTIAL_FLUSH_THROTTLE_MS} while text streams in, so per-token
+   * deltas never thrash the cross-process registry file.
+   */
+  schedulePartialFlush() {
+    if (this.partialTimer) return;
+    this.partialTimer = setTimeout(() => {
+      this.partialTimer = null;
+      this.flush();
+    }, PARTIAL_FLUSH_THROTTLE_MS);
+    if (typeof this.partialTimer.unref === "function") this.partialTimer.unref();
+  }
+  /**
+   * Remove subagents that have been finished (idle/error) for longer than
+   * {@link AGENT_REAP_MS}. Running / streaming / waiting_user agents are kept
+   * regardless of age — only *not-working* agents are reaped.
+   */
+  sweep() {
+    const now = Date.now();
+    let removed = false;
+    for (const [id, a] of this.agents) {
+      const finished = a.status !== "running" && a.status !== "streaming" && a.status !== "waiting_user";
+      const age = now - Date.parse(a.lastActivityAt);
+      if (finished && Number.isFinite(age) && age > AGENT_REAP_MS) {
+        this.agents.delete(id);
+        removed = true;
+      }
+    }
+    if (removed) this.flush();
   }
   flush() {
     const leaderEntry = {
@@ -27460,12 +28154,105 @@ var AgentStatusTracker = class {
       currentTool: this.leaderCurrentTool,
       iterations: this.leaderIterations,
       toolCalls: this.leaderToolCalls,
+      costUsd: this.leaderCostUsd,
+      tokensIn: this.leaderTokensIn,
+      tokensOut: this.leaderTokensOut,
+      ctxPct: this.leaderCtxPct,
+      model: this.leaderModel,
+      partialText: this.leaderPartialText || void 0,
       lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const allAgents = [leaderEntry, ...this.agents.values()];
-    this.registry.updateAgents(allAgents).catch(() => void 0);
+    this.registry.updateAgents(allAgents).then(() => {
+      try {
+        this.onUpdate?.();
+      } catch {
+      }
+    }).catch(() => void 0);
+  }
+};
+var INSTANCES_FILE = "webui-instances.json";
+var DISCOVERY_TTL_MS = 2500;
+var COALESCE_MS = 50;
+var POST_TIMEOUT_MS = 500;
+function pidAlive2(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function normRoot(root) {
+  const resolved = path2.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+var FleetNotifier = class {
+  baseDir;
+  projectRoot;
+  selfPid;
+  doPost;
+  cache = null;
+  timer = null;
+  disposed = false;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.projectRoot = normRoot(opts.projectRoot);
+    this.selfPid = opts.selfPid ?? process.pid;
+    this.doPost = opts.post ?? defaultPost;
+  }
+  /** Coalesced, best-effort nudge. Safe to call on every status change. */
+  notify() {
+    if (this.disposed || this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, COALESCE_MS);
+    if (typeof this.timer.unref === "function") this.timer.unref();
+  }
+  /** Resolve same-project WebUI ping URLs (cached briefly). Exposed for tests. */
+  async endpoints() {
+    const now = Date.now();
+    if (this.cache && now - this.cache.at < DISCOVERY_TTL_MS) return this.cache.urls;
+    const urls = await this.discover();
+    this.cache = { at: now, urls };
+    return urls;
+  }
+  dispose() {
+    this.disposed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  async flush() {
+    const urls = await this.endpoints();
+    await Promise.all(urls.map((u) => this.doPost(u).catch(() => void 0)));
+  }
+  async discover() {
+    try {
+      const raw = await fsp3.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const data = JSON.parse(raw);
+      const list = Array.isArray(data?.instances) ? data.instances : [];
+      return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
+        const host = i.host === "0.0.0.0" || i.host === "::" || !i.host ? "127.0.0.1" : i.host;
+        return `http://${host}:${i.httpPort}/api/fleet/ping`;
+      });
+    } catch {
+      return [];
+    }
   }
 };
+async function defaultPost(url) {
+  const ac = new AbortController();
+  const t2 = setTimeout(() => ac.abort(), POST_TIMEOUT_MS);
+  try {
+    await fetch(url, { method: "POST", signal: ac.signal });
+  } finally {
+    clearTimeout(t2);
+  }
+}
 
 // src/storage/session-rewinder.ts
 init_atomic_write();
@@ -27715,6 +28502,7 @@ async function saveTasks(filePath, tasks, events, traceId) {
       durationMs: Date.now() - t0,
       ...traceId !== void 0 && { traceId }
     });
+    return true;
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -27730,13 +28518,17 @@ async function saveTasks(filePath, tasks, events, traceId) {
       "[task-store] save failed:",
       toErrorMessage(err)
     );
+    return false;
   }
 }
 async function mutateTasks(filePath, sessionId, fn, events, traceId) {
   return withFileLock(filePath, async () => {
     const file = await loadTasks(filePath, events, traceId) ?? emptyTaskFile(sessionId);
     const updated = await fn(file);
-    await saveTasks(filePath, updated, events, traceId);
+    const persisted = await saveTasks(filePath, updated, events, traceId);
+    if (!persisted) {
+      throw new Error(`Failed to persist tasks to ${filePath} \u2014 the change was NOT saved.`);
+    }
     return updated;
   });
 }
@@ -28033,8 +28825,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fsp3.stat(localPath);
-        if (stat13.isDirectory()) {
+        const stat14 = await fsp3.stat(localPath);
+        if (stat14.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp3.readFile(file, "utf8");
@@ -28059,8 +28851,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fsp3.stat(localPath);
-        if (stat13.isDirectory()) {
+        const stat14 = await fsp3.stat(localPath);
+        if (stat14.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp3.readFile(file);
@@ -28087,6 +28879,7 @@ var CloudSync = class {
         return this.paths.globalMemory;
       case "history":
         return this.paths.historyFile;
+      /* v8 ignore next -- unreachable: SyncCategory is exhaustively matched above */
       default:
         return null;
     }
@@ -29316,7 +30109,7 @@ var SecurityScannerOrchestrator = class {
         message: errAsErr.message,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
-      await new Promise((resolve14) => setTimeout(resolve14, delay));
+      await new Promise((resolve15) => setTimeout(resolve15, delay));
       return this.completeWithRetry(provider, request, abortController, attempt + 1);
     }
   }
@@ -29980,16 +30773,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile47 } = await import('fs/promises');
-      const content = await readFile47(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile48 } = await import('fs/promises');
+      const content = await readFile48(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile47 } = await import('fs/promises');
-      const content = await readFile47(join(reportsDir, match), "utf-8");
+      const { readFile: readFile48 } = await import('fs/promises');
+      const content = await readFile48(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -30449,12 +31242,12 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve14) => {
-      const entry = { request, resolve: resolve14 };
+    const pending = new Promise((resolve15) => {
+      const entry = { request, resolve: resolve15 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
-          resolve14({ type: "deny", reason: "Brain human decision timed out." });
+          resolve15({ type: "deny", reason: "Brain human decision timed out." });
         }, this.opts.timeoutMs);
       }
       this.pending.set(request.id, entry);
@@ -30868,7 +31661,8 @@ var BrainMonitor = class {
             id: "steer",
             label: "Steer the agent with corrective guidance",
             consequence: "A steer message is injected before its next step.",
-            risk: "low"
+            risk: "low",
+            recommended: true
           },
           {
             id: "continue",
@@ -30877,9 +31671,9 @@ var BrainMonitor = class {
           }
         ],
         risk: "medium",
-        // Without an LLM layer the policy brain resolves this fallback to
-        // "continue" — the monitor observes but never interferes.
-        fallback: "continue"
+        // 'ask_human' routes to the LLM-backed autonomous layer via
+        // createTieredBrainArbiter before any human escalation.
+        fallback: "ask_human"
       };
       const decision = await this.opts.brain.decide(request);
       const intervened = await this.maybeIntervene(kind, request, decision);
@@ -31979,6 +32773,10 @@ function makeDependencyWatcherConfig(opts) {
   return {
     watchPaths: unique,
     debounceMs,
+    dispose() {
+      for (const t2 of pending.values()) clearTimeout(t2);
+      pending.clear();
+    },
     async onChange(entry) {
       if (entry.event === "delete") return;
       if (!matchesPattern(entry.path)) return;
@@ -32399,6 +33197,10 @@ var KnowledgeGraph = class {
   pendingDeliveries = /* @__PURE__ */ new Map();
   filePath;
   graphFilePath;
+  /** Exposed for unit-testing only: read current index contents. */
+  getIndex() {
+    return this.index;
+  }
   constructor(sessionDir) {
     this.filePath = path2.join(sessionDir, "_knowledge_graph");
     this.graphFilePath = path2.join(this.filePath, "graph.jsonl");
@@ -32411,7 +33213,7 @@ var KnowledgeGraph = class {
   async add(node) {
     const full = { id: randomUUID(), ...node };
     this.nodes.set(full.id, full);
-    this._index(full);
+    this._addToIndex(full, this._indexKeys(full));
     await this._persist(full);
     this._deliver(full);
     return full;
@@ -32420,8 +33222,10 @@ var KnowledgeGraph = class {
   async update(id, patch) {
     const existing = this.nodes.get(id);
     if (!existing) return null;
+    this._removeFromIndex(existing, this._indexKeys(existing));
     const updated = { ...existing, ...patch };
     this.nodes.set(id, updated);
+    this._addToIndex(updated, this._indexKeys(updated));
     this._deliver(updated);
     await this._append(updated);
     return updated;
@@ -32507,15 +33311,10 @@ var KnowledgeGraph = class {
     return { passed: checks.every((c) => c.passed), checks };
   }
   // ── Private ────────────────────────────────────────────────────────────
-  _index(node) {
-    const add = (key) => {
-      let set = this.index.get(key);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        this.index.set(key, set);
-      }
-      set.add(node.id);
-    };
+  /** Pure: compute the set of index keys a node would belong to. */
+  _indexKeys(node) {
+    const keys = /* @__PURE__ */ new Set();
+    const add = (key) => keys.add(key);
     add(`type:${node.type}`);
     if (node.type === "fact") {
       const f = node;
@@ -32524,6 +33323,8 @@ var KnowledgeGraph = class {
       add(`by:${f.discoveredBy}`);
       for (const tag of f.tags) add(`tag:${tag}`);
       add(`key:${f.key}`);
+      add(`subject:${f.subject}`);
+      if (f.detail) add(`detail:${f.detail}`);
     }
     if (node.type === "goal") {
       const g = node;
@@ -32538,6 +33339,24 @@ var KnowledgeGraph = class {
       add(`by:${c.proposedBy}`);
       for (const g of c.satisfiesGoals) add(`goal:${g}`);
     }
+    return keys;
+  }
+  /** Mutate the index: add a node's id to every set for the given keys. */
+  _addToIndex(node, keys) {
+    for (const key of keys) {
+      let set = this.index.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.index.set(key, set);
+      }
+      set.add(node.id);
+    }
+  }
+  /** Remove a node's id from all index sets for the given keys. */
+  _removeFromIndex(node, keys) {
+    for (const key of keys) {
+      this.index.get(key)?.delete(node.id);
+    }
   }
   _matches(node, f) {
     if (f.type && node.type !== f.type) return false;
@@ -32587,11 +33406,15 @@ var KnowledgeGraph = class {
         try {
           const parsed = JSON.parse(line);
           if (parsed.op === "update") {
+            const oldNode = this.nodes.get(parsed.node.id);
+            if (oldNode) {
+              this._removeFromIndex(oldNode, this._indexKeys(oldNode));
+            }
             this.nodes.set(parsed.node.id, parsed.node);
-            this._index(parsed.node);
+            this._addToIndex(parsed.node, this._indexKeys(parsed.node));
           } else {
             this.nodes.set(parsed.id, parsed);
-            this._index(parsed);
+            this._addToIndex(parsed, this._indexKeys(parsed));
           }
         } catch {
         }
@@ -32892,7 +33715,7 @@ var TaskDAG = class {
       if (visited.has(current)) continue;
       visited.add(current);
       const node = this.nodes.get(current);
-      if (node) stack.push(...node.dependents);
+      if (node) stack.push(...node.deps);
     }
     return false;
   }
@@ -32995,8 +33818,10 @@ var ConsensusProtocol = class {
     return this._resolve(changeId, change.votes, eligible);
   }
   // ── Private ───────────────────────────────────────────────────────────
-  _eligibleVoters(_change) {
-    return Array.from(this.voters.keys());
+  _eligibleVoters(change) {
+    return Array.from(this.voters.keys()).filter(
+      (agentId) => agentId !== change.proposedBy
+    );
   }
   _resolve(changeId, votes, eligible) {
     const totalEligible = eligible.length;
@@ -33041,7 +33866,7 @@ var ConsensusProtocol = class {
     if (!quorumMet) {
       return {
         changeId,
-        outcome: "pending",
+        outcome: "quorum_not_met",
         votes,
         approveCount: approve.length,
         rejectCount: reject.length,
@@ -33418,7 +34243,7 @@ var AutonomousBrain = class {
       }
       return { type: "deny", reason: `Brain LLM failed: ${String(err)}` };
     }
-    void this._recordDecision({
+    this._recordDecision({
       id,
       decisionType,
       question,
@@ -33427,6 +34252,7 @@ var AutonomousBrain = class {
       rationale: result.rationale,
       madeBy: "autonomous-brain",
       context: JSON.stringify(context)
+    }).catch(() => {
     });
     if (requiresConsensus) {
       this._emit("brain.decision", { id, decisionType, optionId: result.optionId, rationale: result.rationale, consensusRequired: true });
@@ -33705,10 +34531,16 @@ var TaskAuctioneer = class {
   maxTasksPerAgent;
   minConfidence;
   // minimum dispatcher confidence to accept a bid
+  maxBidRetries;
+  // max republished attempts before marking task failed
   /** Pending bids keyed by taskId. */
   pendingBids = /* @__PURE__ */ new Map();
   /** Active bid windows keyed by taskId. */
   bidTimers = /* @__PURE__ */ new Map();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
+  /** How many times a task has been republished with no bids received. */
+  bidRetryCounts = /* @__PURE__ */ new Map();
   /** Agent → current task count (from graph + in-flight). */
   agentTaskCounts = /* @__PURE__ */ new Map();
   constructor(opts) {
@@ -33719,8 +34551,26 @@ var TaskAuctioneer = class {
     this.bidWindowMs = opts.bidWindowMs ?? 3e4;
     this.maxTasksPerAgent = opts.maxTasksPerAgent ?? 3;
     this.minConfidence = opts.minConfidence ?? 0.3;
-    this.fleet?.filter("task:bid", (e) => this._onBidEvent(e));
-    this.fleet?.filter("task:claimed", (e) => this._onClaimedEvent(e));
+    this.maxBidRetries = opts.maxBidRetries ?? 3;
+    const offBid = this.fleet?.filter("task:bid", (e) => this._onBidEvent(e));
+    const offClaimed = this.fleet?.filter("task:claimed", (e) => this._onClaimedEvent(e));
+    if (offBid) this.unsubs.push(offBid);
+    if (offClaimed) this.unsubs.push(offClaimed);
+  }
+  /**
+   * Detach all FleetBus subscriptions and cancel any open bid-window timers.
+   * Call when the owning coordinator stops/restarts so handlers and timers
+   * don't accumulate across cycles.
+   */
+  dispose() {
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    for (const t2 of this.bidTimers.values()) clearTimeout(t2);
+    this.bidTimers.clear();
   }
   // ── Publish a task ────────────────────────────────────────────────────
   /**
@@ -33730,14 +34580,16 @@ var TaskAuctioneer = class {
    * If `targetAgent` is specified, the task is assigned directly without auction.
    */
   async publishTask(input) {
+    const blockedBy = input.blockedBy ?? [];
+    const hasOpenBlockers = blockedBy.length > 0 && blockedBy.some((id) => this.graph.get(id)?.status !== "done");
     const goal = await this.graph.add({
       type: "goal",
       title: input.title,
       description: input.description,
-      status: input.targetAgent ? "in_progress" : "pending",
+      status: input.targetAgent ? "in_progress" : hasOpenBlockers ? "blocked" : "pending",
       priority: input.priority ?? "medium",
       assignee: input.targetAgent,
-      blockedBy: [],
+      blockedBy,
       dependsOn: input.satisfiesGoals ?? [],
       createdBy: this.selfAgentId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -33754,6 +34606,12 @@ var TaskAuctioneer = class {
         });
       }
     }
+    for (const blockerId of blockedBy) {
+      const blocker = this.graph.get(blockerId);
+      if (blocker && !blocker.children.includes(goal.id)) {
+        await this.graph.update(blockerId, { children: [...blocker.children, goal.id] });
+      }
+    }
     if (input.targetAgent) {
       await this._assignDirect(goal.id, input.targetAgent);
     } else {
@@ -33865,9 +34723,12 @@ Priority: ${goal.priority}`,
       status: "done",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
     for (const childId of goal.children) {
       const child = this.graph.get(childId);
-      if (child) {
+      if (child && child.status === "blocked") {
         const allUnblocked = child.blockedBy.every((blockedId) => {
           const blocked = this.graph.get(blockedId);
           return blocked?.status === "done";
@@ -33876,6 +34737,7 @@ Priority: ${goal.priority}`,
           await this.graph.update(childId, { status: "pending", updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
           const unblockedGoal = this.graph.get(childId);
           await this._broadcastTask(unblockedGoal);
+          this._startBidWindow(childId);
         }
       }
     }
@@ -33901,6 +34763,9 @@ ${_result ?? "No result provided."}`
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       result: error
     });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
     this._emit("task:failed", { taskId, agentId, error });
     await this._mailboxPublish({
       type: "note",
@@ -33979,7 +34844,7 @@ Assignee: ${agentId}`
       priority: goal.priority,
       tags: goal.tags
     });
-    void this._mailboxPublish({
+    this._mailboxPublish({
       type: "broadcast",
       subject: `[task] ${goal.title} (${goal.priority})`,
       body: `New task available: "${goal.title}"
@@ -33990,6 +34855,7 @@ Task ID: ${goal.id}
 Tags: ${goal.tags.join(", ") || "none"}
 
 Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
+    }).catch(() => {
     });
   }
   async _mailboxPublish(msg) {
@@ -34023,9 +34889,10 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
   }
   _startBidWindow(taskId) {
     this._cancelBidWindow(taskId);
-    const timer = setTimeout(async () => {
+    const timer = setTimeout(() => {
       this.bidTimers.delete(taskId);
-      await this._evaluateBids(taskId);
+      void this._evaluateBids(taskId).catch(() => {
+      });
     }, this.bidWindowMs);
     this.bidTimers.set(taskId, timer);
   }
@@ -34039,6 +34906,13 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
   async _evaluateBids(taskId) {
     const bids = this.pendingBids.get(taskId);
     if (!bids || bids.length === 0) {
+      const retryCount = (this.bidRetryCounts.get(taskId) ?? 0) + 1;
+      this.bidRetryCounts.set(taskId, retryCount);
+      if (retryCount >= this.maxBidRetries) {
+        await this.fail(taskId, `No bids received after ${this.maxBidRetries} attempts`);
+        this.bidRetryCounts.delete(taskId);
+        return;
+      }
       const goal = this.graph.get(taskId);
       if (goal) {
         await this._broadcastTask(goal);
@@ -34047,7 +34921,15 @@ Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
       return;
     }
     bids.sort((a, b) => b.score - a.score);
-    const winner = bids[0];
+    const winner = bids.find((b) => this._getAgentTaskCount(b.agentId) < this.maxTasksPerAgent);
+    if (!winner) {
+      const goal = this.graph.get(taskId);
+      if (goal) {
+        await this._broadcastTask(goal);
+        this._startBidWindow(taskId);
+      }
+      return;
+    }
     await this.claim(taskId, winner.agentId, winner.agentName);
   }
   async _assignDirect(taskId, agentId) {
@@ -34094,16 +34976,24 @@ var AutonomousCoordinator = class {
   selfAgentId;
   fleet;
   fleetManager;
+  director;
   mailbox;
   events;
+  onCoordinatorEvent;
   running = false;
   iterationCount = 0;
+  /** Tasks already handled by _onSubagentTerminated (to avoid double goal:failed on fleet event). */
+  _handledBySubagent = /* @__PURE__ */ new Set();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
   constructor(opts) {
     this.selfAgentId = opts.selfAgentId;
     this.fleet = opts.fleet ?? void 0;
     this.fleetManager = opts.fleetManager ?? void 0;
+    this.director = opts.director ?? void 0;
     this.mailbox = opts.mailbox ?? void 0;
     this.events = opts.events ?? void 0;
+    this.onCoordinatorEvent = opts.onCoordinatorEvent;
     this.graph = new KnowledgeGraph(opts.sessionDir);
     this.dag = new TaskDAG();
     this.auction = new TaskAuctioneer({
@@ -34139,9 +35029,19 @@ var AutonomousCoordinator = class {
     this.dag.onEvent((event) => {
       this._onDagEvent(event);
     });
-    this.fleet?.filter("subagent.terminated", (e) => {
+    const offCompleted = this.fleet?.filter("subagent.completed", (e) => {
       this._onSubagentTerminated(e);
     });
+    if (offCompleted) this.unsubs.push(offCompleted);
+    const offFailed = this.fleet?.filter("task:failed", (e) => {
+      const payload = e.payload;
+      const taskId = payload?.taskId;
+      if (!taskId || this._handledBySubagent.has(taskId)) return;
+      this._handledBySubagent.add(taskId);
+      this._emit({ type: "goal:failed", goalId: taskId, text: payload?.error ?? "Task failed" });
+    });
+    if (offFailed) this.unsubs.push(offFailed);
+    this._emit({ type: "coordinator:mode", mode: this.fleet ? "fleet" : "standalone" });
   }
   // ── Public API ───────────────────────────────────────────────────────
   /**
@@ -34155,11 +35055,13 @@ var AutonomousCoordinator = class {
     const maxIterations = opts.maxIterations ?? 100;
     const goal = opts.goal ?? "Improve the codebase";
     const maxCost = opts.maxCostUsd;
-    await this.graph.load();
     try {
+      await this.graph.load();
       const goalConfigs = await this._decomposeGoal(goal);
       for (const g of goalConfigs) {
-        await this.auction.publishTask(g);
+        const goalId = await this.auction.publishTask(g);
+        this.dag.addNode(goalId, g.description, []);
+        this._emit({ type: "goal:added", goalId, title: g.title, text: g.description });
       }
       while (this.running) {
         this.iterationCount++;
@@ -34186,6 +35088,7 @@ var AutonomousCoordinator = class {
           const blocked = this.dag.getBlocked();
           if (blocked.length > 0 && this.dag.hasDeadlock()) {
             (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
             this.running = false;
           }
           break;
@@ -34202,7 +35105,15 @@ var AutonomousCoordinator = class {
         }
         const pendingChanges = this.changes.getPendingReviews();
         for (const change of pendingChanges) {
-          await this._handlePendingChange(change);
+          try {
+            await this._handlePendingChange(change);
+          } catch (err) {
+            this._emit({
+              type: "goal:failed",
+              goalId: change.id,
+              text: `Consensus handling failed: ${err instanceof Error ? err.message : String(err)}`
+            });
+          }
         }
       }
     } finally {
@@ -34212,7 +35123,26 @@ var AutonomousCoordinator = class {
   }
   /** Stop the autonomous loop. */
   stop() {
+    if (!this.running) return;
     this.running = false;
+    console.error(`[AutonomousCoordinator] stop signal received \u2014 shutting down (iteration ${this.iterationCount})`);
+  }
+  /**
+   * Tear down the coordinator for good: stop the loop and detach all FleetBus
+   * subscriptions (this coordinator's + the auctioneer's) plus any open bid
+   * timers. Call this when discarding the instance (e.g. `/coordinator stop`
+   * that recreates a fresh coordinator on the next start) so handlers and
+   * timers don't accumulate across cycles. `stop()` only pauses the loop.
+   */
+  dispose() {
+    this.stop();
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    this.auction.dispose();
   }
   /** Get a stats snapshot. */
   getStats() {
@@ -34267,6 +35197,7 @@ var AutonomousCoordinator = class {
       body: `**${input.category}**${input.file ? ` in ${input.file}${input.line ? `:${input.line}` : ""}` : ""}
 ${input.detail}`
     });
+    this._emit({ type: "knowledge:added", knowledgeId: fact.id, title: input.subject, text: input.detail });
     return fact;
   }
   // ── Goal creation helpers ────────────────────────────────────────────
@@ -34279,7 +35210,10 @@ ${input.detail}`
       title: input.title,
       description: input.description,
       priority: resolvedPriority,
-      ...input.tags ? { tags: input.tags } : {}
+      ...input.tags ? { tags: input.tags } : {},
+      // Mirror the dependency edges into the auction so blocked goals aren't
+      // biddable until their deps complete (the DAG tracks the same edges).
+      ...input.deps && input.deps.length > 0 ? { blockedBy: input.deps } : {}
     });
     const goal = this.graph.get(goalId);
     for (const depId of input.deps ?? []) {
@@ -34320,30 +35254,34 @@ ${input.detail}`
   async _processGoal(goalId) {
     const ready = this.dag.getReady();
     if (ready.length === 0) return;
-    const next = ready.find((n) => n.id === goalId) ?? ready[0];
-    this.dag.start(next.id, "auctioneer");
-    const existingAgent = this.auction.getTasksForAgent(this.selfAgentId).find((g) => g.id === next.id);
-    if (!existingAgent) {
-      await this.auction.publishTask({
-        title: next.description,
-        description: next.description,
-        priority: this._dagPriorityToGoal(next.priority),
-        tags: next.tags
+    const dagNode = ready.find((n) => n.id === goalId) ?? ready[0];
+    this.dag.start(dagNode.id, "auctioneer");
+    const goalNode = this.graph.get(goalId);
+    if (!goalNode) return;
+    const title = goalNode.title || dagNode.description;
+    const taskId = await this.auction.publishTask({
+      title,
+      description: goalNode.description,
+      priority: this._dagPriorityToGoal(dagNode.priority),
+      tags: dagNode.tags
+    });
+    this._emit({ type: "task:ready", goalId, taskId, title });
+    if (this.director) {
+      const config = {
+        name: `worker-${goalId.slice(0, 8)}`,
+        role: "general",
+        maxIterations: 100,
+        timeoutMs: 6e5
+        // 10 minutes per goal
+      };
+      const subagentId = await this.director.spawn(config);
+      await this.auction.claim(taskId, subagentId, config.name);
+      await this.director.assign({
+        id: goalId,
+        subagentId,
+        description: goalNode.description
       });
     }
-    await this._waitForClaim(next.id);
-  }
-  async _waitForClaim(taskId) {
-    const maxWait = 6e4;
-    const pollInterval = 2e3;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      const goal = this.graph.get(taskId);
-      if (goal?.status === "in_progress" || goal?.status === "done") {
-        return;
-      }
-      await this._sleep(pollInterval);
-    }
   }
   async _handlePendingChange(change) {
     const result = this.consensus.getStatus(change.id);
@@ -34357,6 +35295,17 @@ ${input.detail}`
       );
       if (voteResult.outcome === "approved") {
         await this.changes.markApplied(change.id, (/* @__PURE__ */ new Date()).toISOString());
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change approved and applied" });
+      }
+    } else {
+      const voteResult = await this.consensus.castVote(
+        change.id,
+        this.selfAgentId,
+        "reject",
+        `Quality gate failed: ${change.qualityGate.checks.map((c) => `${c.name}=${c.passed}`).join(", ")}`
+      );
+      if (voteResult.outcome === "rejected" || voteResult.outcome === "vetoed") {
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change rejected by quality gate" });
       }
     }
   }
@@ -34367,10 +35316,6 @@ ${input.detail}`
         (this.events?.emit)("autonomous:task_ready", { taskId: event.nodeId, description: node.description });
       }
     }
-    if (event.type === "deadlock") {
-      (this.events?.emit)("autonomous:deadlock", { blocked: event.blocked });
-      this.running = false;
-    }
     if (event.type === "graph:done") {
       (this.events?.emit)("autonomous:all_done", this.getStats());
     }
@@ -34378,13 +35323,16 @@ ${input.detail}`
   _onSubagentTerminated(e) {
     const payload = e.payload;
     const subagentId = payload?.subagentId ?? e.subagentId;
-    const stopReason = payload?.stopReason ?? "unknown";
+    const stopReason = payload?.stopReason ?? (payload?.status === "ok" ? "end_turn" : payload?.status ?? "unknown");
     const tasks = this.auction.getTasksForAgent(subagentId);
     for (const task of tasks) {
+      this._handledBySubagent.add(task.id);
       if (stopReason === "end_turn") {
         void this.auction.complete(task.id, "Subagent completed successfully");
+        this._emit({ type: "task:completed", goalId: task.id, taskId: task.id, text: "Subagent completed successfully" });
       } else {
         void this.auction.fail(task.id, `Subagent terminated: ${stopReason}`);
+        this._emit({ type: "goal:failed", goalId: task.id, text: `Subagent terminated: ${stopReason}` });
       }
     }
   }
@@ -34398,6 +35346,10 @@ ${input.detail}`
   }
   _buildVoters() {
     return [
+      // The coordinator itself casts the quality-gate auto-vote in
+      // _handlePendingChange — it MUST be a registered, eligible voter or
+      // castVote throws "unknown voter" and tears down the run() loop.
+      { agentId: this.selfAgentId, agentName: "Coordinator", role: "coordinator", weight: 1 },
       { agentId: "critic", agentName: "Critic", role: "critic", weight: 2, veto: true },
       { agentId: "bug-hunter", agentName: "Bug Hunter", role: "bug-hunter", weight: 1.5 },
       { agentId: "security-scanner", agentName: "Security Scanner", role: "security-scanner", weight: 1.5 },
@@ -34435,8 +35387,9 @@ ${input.detail}`
     } catch {
     }
   }
-  _sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+  /** Emit a CoordinatorEvent to the subscriber (e.g. TUI panel timeline). */
+  _emit(event) {
+    this.onCoordinatorEvent?.(event);
   }
 };
 function createMcpControlTool(opts) {
@@ -34999,13 +35952,13 @@ function createAgentToolHandler(a) {
     }
   }
   function waitForConfirm(info) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       a.events.emit("tool.confirm_needed", {
         tool: info.tool,
         input: info.input,
         toolUseId: info.toolUseId,
         suggestedPattern: info.suggestedPattern,
-        resolve: resolve14
+        resolve: resolve15
       });
     });
   }
@@ -35433,7 +36386,7 @@ async function injectPendingMailboxMessages(checkMailbox, foldFn, a) {
   try {
     messages = await checkMailbox();
   } catch {
-    return;
+    return { interrupt: false };
   }
   for (const m of messages) {
     a.events.emit("mailbox.received", {
@@ -35443,14 +36396,22 @@ async function injectPendingMailboxMessages(checkMailbox, foldFn, a) {
       subject: m.subject
     });
   }
-  if (messages.length === 0) return;
-  try {
-    foldFn(buildMailboxBlock(messages));
-  } catch (err) {
-    (a.logger.debug ?? console.debug)?.(
-      `mailbox: failed to fold messages: ${toErrorMessage(err)}`
-    );
+  if (messages.length === 0) return { interrupt: false };
+  const control = messages.filter((m) => m.type === "control");
+  const content = messages.filter((m) => m.type !== "control");
+  if (content.length > 0) {
+    try {
+      foldFn(buildMailboxBlock(content));
+    } catch (err) {
+      (a.logger.debug ?? console.debug)?.(
+        `mailbox: failed to fold messages: ${toErrorMessage(err)}`
+      );
+    }
   }
+  const interruptMsg = control.find(
+    (m) => /\b(interrupt|stop|halt|abort|cancel)\b/i.test(`${m.subject} ${m.body}`)
+  );
+  return interruptMsg ? { interrupt: true, interruptReason: interruptMsg.body || interruptMsg.subject || "operator interrupt" } : { interrupt: false };
 }
 
 // src/mailbox-attach.ts
@@ -35516,12 +36477,12 @@ function attachMailboxCheckerInner(a, source) {
 // src/core/iteration-limit.ts
 function requestLimitExtension(opts) {
   const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     let resolved = false;
     const timerFired = () => {
       if (!resolved) {
         resolved = true;
-        resolve14(0);
+        resolve15(0);
       }
     };
     const timer = setTimeout(timerFired, timeoutMs);
@@ -35530,14 +36491,14 @@ function requestLimitExtension(opts) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve14(0);
+        resolve15(0);
       }
     };
     const grant = (extra) => {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve14(Math.max(0, extra));
+        resolve15(Math.max(0, extra));
       }
     };
     events.emit("iteration.limit_reached", {
@@ -35551,7 +36512,7 @@ function requestLimitExtension(opts) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve14(100);
+          resolve15(100);
         }
       });
     }
@@ -35736,12 +36697,20 @@ function createAgentLoopHandler(a, handlers) {
         a.events.emit("iteration.started", { ctx: a.ctx, index: i });
         injectPendingBtwNotes();
         injectQueueAwareness();
-        await injectPendingMailboxMessages(checkMailbox, foldBlockIntoConversation, {
-          // Cast to the broad parameter type — injectPendingMailboxMessages only
-          // calls emit('mailbox.received', ...) and uses logger.debug optionally.
-          events: a.events,
-          logger: a.logger
-        });
+        const mailboxResult = await injectPendingMailboxMessages(
+          checkMailbox,
+          foldBlockIntoConversation,
+          {
+            // Cast to the broad parameter type — injectPendingMailboxMessages only
+            // calls emit('mailbox.received', ...) and uses logger.debug optionally.
+            events: a.events,
+            logger: a.logger
+          }
+        );
+        if (mailboxResult.interrupt) {
+          const reason = `interrupted: ${mailboxResult.interruptReason ?? "operator request"}`;
+          return { status: "aborted", iterations, abortReason: reason, finalText };
+        }
         const req = await handlers.response.buildAndRunRequestPipeline(opts);
         const preFlight = estimateRequestTokens(
           req.messages,
@@ -36182,13 +37151,13 @@ async function runShellHook(spec, input, logger) {
     logger?.warn?.(`hook rejected: command not in allowlist: ${spec.command}`);
     return null;
   }
-  return await new Promise((resolve14) => {
+  return await new Promise((resolve15) => {
     let settled = false;
     const done = (v) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve14(v);
+      resolve15(v);
     };
     let child;
     try {
@@ -36201,7 +37170,7 @@ async function runShellHook(spec, input, logger) {
       });
     } catch (err2) {
       logger?.warn?.(`hook spawn failed: ${toErrorMessage(err2)}`);
-      return resolve14(null);
+      return resolve15(null);
     }
     const timer = setTimeout(() => {
       logger?.warn?.(`hook command timed out after ${timeoutMs}ms: ${spec.command}`);
@@ -36456,6 +37425,12 @@ function flagsToConfigPatch(flags) {
     patch.features ??= {};
     patch.features.tokenSavingMode = true;
   }
+  if (typeof flags["token-saving-tier"] === "string") {
+    patch.features ??= {};
+    patch.features.tokenSavingMode = normalizeTokenSavingTier(
+      flags["token-saving-tier"]
+    );
+  }
   return patch;
 }
 async function writeProjectMeta(paths, projectRoot) {
@@ -36687,8 +37662,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path43 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path43}]`;
+    const path44 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path44}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -36782,26 +37757,30 @@ Never silently skip a failure \u2014 always report it, even when you choose not
 
 ## After-task suggestions
 
-**You are the leader agent.** After completing a significant task, end your
-response with 2\u20134 suggested next actions in a \`<next_steps>\` block. Use this
-exact format so the user can select them with \`/next 1\`, \`/next 2\`, or
-\`/next 1 2 3\`:
+**You are the leader agent.** After completing a significant task, you MAY end your
+response with 2\u20134 suggested next prompt options in a \`<next_steps>\` block.
+The \`/next 1\`, \`/next 2\`, \`/next 1 2 3\` shortcuts let the user select one
+and continue in a new agent session.
+
+Format:
 
 \`\`\`
 <next_steps>
-1. First suggestion \u2014 imperative, specific, actionable
-2. Second suggestion
-3. Third suggestion
+1. Prompt option 1 \u2014 a concrete next action phrased as what to type
+2. Prompt option 2
+3. Prompt option 3 (optional)
 </next_steps>
 \`\`\`
 
 Rules:
-- Each line is a single imperative sentence the user can act on immediately.
-- Be specific: mention file names, tool names, or commands.
-- **Concrete actions only** \u2014 never write declarations of intent ("we should fix X", "consider refactoring Y") or manual suggestions ("manually check Z"). Write exactly what should be done: "Fix null deref in auth/session.ts:42", "Run pnpm typecheck".
+- Each item is a **prompt the user can type** \u2014 not an instruction to a human.
+  Write "pnpm test" not "Run the test suite."
+- Human-only actions (e.g., "open DevTools") go outside the tag as plain text,
+  not inside \`<next_steps>\`.
+- Items marked \`auto="true"\` must include the exact input content for copy-paste.
 - Order by priority. Keep each suggestion to one line.
 - Skip during multi-step operations \u2014 only show after completion.
-- If nothing is pending, say "No pending actions."
+- If nothing is pending, omit the tag entirely.
 
 **After a significant task**, also post a status update to the inter-agent
 mailbox so other agents in the fleet can discover what you finished and
@@ -36835,6 +37814,43 @@ var DefaultSystemPromptBuilder = class {
   _lastOnlineAgents;
   /** Cached full buildToolUsage output — keyed by tools array + online agents refs. */
   _toolsUsageCache;
+  /**
+   * Normalizes `tokenSavingMode` to a boolean for backward-compatible boolean checks.
+   * - `undefined` / `false` / `'off'` → false
+   * - `true` / any tier string other than `'off'` → true
+   */
+  get isCompact() {
+    const val = this.opts.tokenSavingMode;
+    if (!val) return false;
+    if (typeof val === "boolean") return val;
+    return val !== "off";
+  }
+  /** Exposes the normalized `TokenSavingTier` for tier-aware guidance decisions. */
+  get tier() {
+    const val = this.opts.tokenSavingMode;
+    if (typeof val === "string") return val;
+    if (val === true) return "medium";
+    return "off";
+  }
+  /**
+   * Returns the max tool description length for the current tier.
+   * Per the design doc: off=80, minimal=40, light=50, medium=60, aggressive=70.
+   */
+  toolDescLimit() {
+    switch (this.tier) {
+      case "minimal":
+        return 40;
+      case "light":
+        return 50;
+      case "medium":
+        return 60;
+      case "aggressive":
+        return 70;
+      case "off":
+      default:
+        return 80;
+    }
+  }
   async build(ctx) {
     this._lastBuildTools = ctx.tools;
     if (this.opts.skillLoader && !this.skillCache) {
@@ -36933,13 +37949,13 @@ var DefaultSystemPromptBuilder = class {
     if (!planPath) return "";
     let raw;
     try {
-      const stat13 = await fsp3.stat(planPath);
-      if (this._planCache && this._planCache.path === planPath && this._planCache.mtimeMs === stat13.mtimeMs) {
+      const stat14 = await fsp3.stat(planPath);
+      if (this._planCache && this._planCache.path === planPath && this._planCache.mtimeMs === stat14.mtimeMs) {
         return this._planCache.text;
       }
       raw = await fsp3.readFile(planPath, "utf8");
       const text = this._formatPlan(raw);
-      this._planCache = { path: planPath, mtimeMs: stat13.mtimeMs, text };
+      this._planCache = { path: planPath, mtimeMs: stat14.mtimeMs, text };
       return text;
     } catch {
       this._planCache = void 0;
@@ -36988,12 +38004,13 @@ var DefaultSystemPromptBuilder = class {
       }
     }
     const lines = ["## Tool usage"];
+    const descLimit = this.toolDescLimit();
     for (const [cat, catTools] of byCat) {
       lines.push(`
 ### ${cat}`);
       for (const t2 of catTools) {
         const hint = t2.usageHint ?? t2.description;
-        const desc = this.opts.tokenSavingMode ? hint.length > 60 ? hint.slice(0, hint.indexOf(".", 20) + 1 || 60) + (hint.length > 60 ? "\u2026" : "") : hint.trim() : hint.length > 80 ? `${hint.slice(0, 77)}...` : hint.trim();
+        const desc = hint.length > descLimit ? hint.slice(0, hint.indexOf(".", 20) + 1 || descLimit) + (hint.length > descLimit ? "\u2026" : "") : hint.trim();
         lines.push(`- **${t2.name}** \u2014 ${desc}`);
       }
     }
@@ -37006,7 +38023,7 @@ var DefaultSystemPromptBuilder = class {
 ${hint.trim()}`);
       }
     }
-    if (!this.opts.tokenSavingMode) {
+    if (this.tier !== "minimal") {
       lines.push(`
 ## Common patterns
 
@@ -37026,7 +38043,7 @@ When unsure about a file's current state, read it first rather than assuming.`);
         return Array.isArray(role) ? role.filter((r) => typeof r === "string") : [];
       })();
       const roleList = enumValues.length > 0 ? enumValues.join(", ") : "(no roster configured)";
-      if (this.opts.tokenSavingMode) {
+      if (this.tier === "minimal") ; else if (this.tier === "light" || this.tier === "medium") {
         lines.push(`## Delegation
 
 Use \`delegate\` to hand work to a subagent (roles: ${roleList}).`);
@@ -37099,9 +38116,9 @@ one by one, roll up results), use \`spawn_subagent\` + \`assign_task\` +
     const hasMailbox = tools.some(
       (t2) => t2.name === "mailbox" || t2.name === "mail_send" || t2.name === "mail_inbox"
     );
-    if (hasMailbox) {
+    if (hasMailbox && this.tier !== "minimal") {
       const onlineAgentsInfo = this.renderOnlineAgents(ctx.onlineAgents);
-      if (this.opts.tokenSavingMode) {
+      if (this.tier === "light" || this.tier === "medium") {
         lines.push(`
 ## Inter-agent mailbox${onlineAgentsInfo}
 
@@ -37179,9 +38196,19 @@ To catch up explicitly:
     }
     const hasMcpControl = tools.some((t2) => t2.name === "mcp_control");
     const hasMcpUse = tools.some((t2) => t2.name === "mcp_use");
-    if (hasMcpControl && this.opts.tokenSavingMode) {
-      if (hasMcpUse) {
-        lines.push(`
+    if (hasMcpControl) {
+      if (this.tier === "minimal" || this.tier === "light") {
+        lines.push(
+          hasMcpUse ? `
+## MCP tools (lazy-loaded)
+
+Use \`mcp_use({ server: "<name>", tool: "<bare-tool>", input: { ... } })\` to activate and call MCP tools.` : `
+## MCP tools (lazy-loaded)
+
+Use \`mcp_control({ action: "list" })\` to see available servers, \`mcp_control({ action: "activate", server: "<name>" })\` to register tools.`
+        );
+      } else {
+        lines.push(hasMcpUse ? `
 ## MCP tools (lazy-loaded)
 
 MCP server tools are NOT registered by default in token-saving mode to keep
@@ -37200,9 +38227,7 @@ deactivates \u2014 all in one call. No need to track activate/deactivate state.
 4. \`mcp_control({ action: "deactivate", server: "<name>" })\` \u2014 clean up
 
 Activation/deactivation is ephemeral (no config writes) and does NOT affect
-the server connection \u2014 only tool visibility changes.`);
-      } else {
-        lines.push(`
+the server connection \u2014 only tool visibility changes.` : `
 ## MCP tools (lazy-loaded)
 
 MCP server tools are NOT registered by default in token-saving mode to keep
@@ -37220,10 +38245,16 @@ the server connection \u2014 only tool visibility changes.`);
       }
     }
     const hasContextManager = tools.some((t2) => t2.name === "context_manager");
-    if (hasContextManager && !this.opts.tokenSavingMode) {
-      const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
-      const threshold = maxCtx <= 32e3 ? "50" : "70";
-      lines.push(`
+    if (hasContextManager) {
+      if (this.tier === "minimal" || this.tier === "light") ; else if (this.tier === "medium") {
+        lines.push(`
+## Context management
+
+Use \`context_manager\` to manage context. Call \`{"action":"check"}\` to see token budget.`);
+      } else {
+        const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
+        const threshold = maxCtx <= 32e3 ? "50" : "70";
+        lines.push(`
 ## Context management
 
 When the conversation grows long and context window usage exceeds what you can track,
@@ -37236,6 +38267,7 @@ use the context_manager tool proactively \u2014 do NOT wait to be told:
 
 **Never** stuff redundant information into a tool result. If you summarize a file, do not paste its full content \u2014
 summarize it, and let the tool result hold only the summary.`);
+      }
     }
     const text = lines.join("\n");
     this._toolsUsageCache = { toolsRef: tools, agentsRef: ctx.onlineAgents, text };
@@ -37247,6 +38279,10 @@ summarize it, and let the tool result hold only the summary.`);
    * 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.
+   *
+   * Tier behaviour:
+   * - 'off' / 'medium' / 'aggressive' → full list with names, sessions, sources
+   * - 'minimal' / 'light' → count only (no list)
    */
   renderOnlineAgents(agents) {
     if (!agents || agents.length === 0) return "";
@@ -37254,6 +38290,11 @@ summarize it, and let the tool result hold only the summary.`);
       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 };
+      return text2;
+    }
     const agentList = agents.map(
       (a) => `- **${a.name}** (${a.source ?? "unknown"}${a.sessionId ? `, session: ${a.sessionId.slice(0, 8)}` : ""})`
     ).join("\n");
@@ -37276,28 +38317,46 @@ ${agentList}`;
       isGit ? this.gitStatus(ctx.projectRoot) : Promise.resolve("not a git repo"),
       this.detectLanguages(ctx.projectRoot)
     ]);
-    const lines = [
-      "## Environment",
-      "",
-      `- Operating system: ${platform2}`,
-      `- Shell: ${shell}`,
-      `- Node.js: ${node}`,
-      `- Detected languages: ${langs}`,
-      `- Git status: ${git}`,
-      `- Today's date: ${today}`
-    ];
-    if (ctx.provider || ctx.model) {
-      lines.push(
-        `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
-      );
-    }
-    if (this.opts.modeId && this.opts.modeId !== "default") {
-      lines.push(`- Mode: ${this.opts.modeId}`);
-    }
-    if (this.opts.modelCapabilities) {
-      lines.push(
-        `- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
-      );
+    const tier = this.tier;
+    const lines = ["## Environment"];
+    if (tier === "minimal") {
+      lines.push(`- Git: ${git} | Date: ${today}`);
+    } else {
+      lines.push(`- Operating system: ${platform2}`);
+      if (tier !== "light") {
+        lines.push(`- Shell: ${shell}`);
+        lines.push(`- Node.js: ${node}`);
+      }
+      if (tier === "off" || tier === "medium" || tier === "aggressive") {
+        lines.push(`- Detected languages: ${langs}`);
+      }
+      lines.push(`- Git status: ${git}`);
+      lines.push(`- Today's date: ${today}`);
+      if (tier === "aggressive") {
+        if (ctx.provider || ctx.model) {
+          lines.push(
+            `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
+          );
+        }
+        if (this.opts.modelCapabilities) {
+          lines.push(
+            `- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
+          );
+        }
+      }
+      if (tier !== "aggressive" && this.opts.modelCapabilities) {
+        lines.push(
+          `- Context window: ${this.opts.modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
+        );
+      }
+      if (tier !== "aggressive" && (ctx.provider || ctx.model)) {
+        lines.push(
+          `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
+        );
+      }
+      if (tier !== "aggressive" && this.opts.modeId && this.opts.modeId !== "default") {
+        lines.push(`- Mode: ${this.opts.modeId}`);
+      }
     }
     if (this.skillCache) {
       lines.push(
@@ -37305,7 +38364,7 @@ ${agentList}`;
         "## Skills in scope for this session",
         this.skillCache,
         "",
-        this.opts.tokenSavingMode ? "Compact skill instructions are injected in the Active Skills block below (Overview + Rules only)." : "Full skill instructions are injected in the Active Skills block below."
+        this.isCompact ? "Compact skill instructions are injected in the Active Skills block below (Overview + Rules only)." : "Full skill instructions are injected in the Active Skills block below."
       );
     }
     const text = lines.join("\n");
@@ -37314,6 +38373,8 @@ ${agentList}`;
   }
   async buildMemoryAndSkills() {
     const parts = [];
+    const memoryCount = this.tier === "minimal" ? 3 : this.tier === "light" ? 5 : 8;
+    const compactMemory = this.tier === "minimal";
     if (this.opts.memoryStore) {
       try {
         if (this.opts.memoryStore.scoreRelevant) {
@@ -37324,14 +38385,18 @@ ${agentList}`;
               toolNames
             },
             "project-memory",
-            8
+            memoryCount
           );
           if (scored.length > 0) {
             const lines = ["# Relevant Memory"];
             for (const e of scored) {
-              const badge2 = e.type ? `[\`${e.type.replace("_", "-")}\`] ` : "";
-              const priorityMark = e.priority === "critical" ? "\u26A1" : e.priority === "high" ? "\u25B2" : "";
-              lines.push(`- ${priorityMark}${badge2}${e.text}${e.tags ? ` \`#${e.tags.join(" #")}\`` : ""}`);
+              if (compactMemory) {
+                lines.push(`- ${e.text}`);
+              } else {
+                const badge2 = e.type ? `[\`${e.type.replace("_", "-")}\`] ` : "";
+                const priorityMark = e.priority === "critical" ? "\u26A1" : e.priority === "high" ? "\u25B2" : "";
+                lines.push(`- ${priorityMark}${badge2}${e.text}${e.tags ? ` \`#${e.tags.join(" #")}\`` : ""}`);
+              }
             }
             parts.push(lines.join("\n"));
           }
@@ -37345,7 +38410,7 @@ ${mem}`);
       }
     }
     if (this.opts.skillLoader) {
-      if (this.opts.tokenSavingMode) {
+      if (this.isCompact) {
         if (this.skillBodyCache === void 0) {
           await this.buildCompactSkillBodies();
         }
@@ -37431,19 +38496,19 @@ ${clean.trim()}`);
   }
   async dirExists(p) {
     try {
-      const stat13 = await fsp3.stat(p);
-      return stat13.isDirectory();
+      const stat14 = await fsp3.stat(p);
+      return stat14.isDirectory();
     } catch {
       return false;
     }
   }
   async gitStatus(root) {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       let settled = false;
       const finish = (s) => {
         if (settled) return;
         settled = true;
-        resolve14(s);
+        resolve15(s);
       };
       let proc;
       const timer = setTimeout(() => {
@@ -37871,173 +38936,6 @@ var SlashCommandRegistry = class {
   }
 };
 
-// src/plugin/api.ts
-var DefaultPluginAPI = class {
-  container;
-  events;
-  pipelines;
-  tools;
-  providers;
-  mcp;
-  slashCommands;
-  extensions;
-  session;
-  metrics;
-  config;
-  log;
-  configStore;
-  hookRegistry;
-  ownerName;
-  pluginCleanupFns = [];
-  constructor(init) {
-    const owner = init.ownerName;
-    this.ownerName = owner;
-    this.hookRegistry = init.hookRegistry;
-    this.container = init.container;
-    this.events = init.events;
-    this.config = init.config;
-    this.configStore = init.configStore;
-    this.log = init.log.child({ plugin: owner });
-    this.extensions = init.extensions ?? new ExtensionRegistry();
-    this.session = init.sessionWriter ?? noopSession;
-    this.metrics = init.metricsSink ? scopedMetrics(init.metricsSink, owner) : noopMetrics;
-    const pipelines = init.pipelines;
-    const readonlyPipelines = {};
-    for (const [key, pipeline2] of Object.entries(pipelines)) {
-      readonlyPipelines[key] = pipeline2.asReadonly();
-    }
-    this.pipelines = readonlyPipelines;
-    const tr = init.toolRegistry;
-    const isOfficial = init.official === true;
-    const capabilities = init.capabilities;
-    const assertCanMutateTool = (name, op) => {
-      if (isOfficial) return;
-      const currentOwner = tr.ownerOf(name);
-      if (currentOwner === void 0) return;
-      const ownedSolelyByMe = currentOwner.split("+").every((seg) => seg === owner);
-      if (ownedSolelyByMe) return;
-      const toolCaps = tr.get(name)?.capabilities ?? [];
-      const pluginMutateCaps = capabilities?.toolMutateCapabilities ?? [];
-      const hasRequiredCap = toolCaps.some((c) => pluginMutateCaps.includes(c));
-      if (!hasRequiredCap) {
-        throw new Error(
-          `Plugin "${owner}" may not ${op} tool "${name}" \u2014 it is owned by "${currentOwner}". Tool capabilities: [${toolCaps.join(", ") || "none"}]. Plugin toolMutateCapabilities: [${pluginMutateCaps.join(", ") || "none"}]. Missing required capability to mutate this tool.`
-        );
-      }
-    };
-    this.tools = {
-      register: (t2) => tr.register(t2, owner),
-      unregister: (name) => {
-        assertCanMutateTool(name, "unregister");
-        return tr.unregister(name);
-      },
-      wrap: (name, wrapper) => {
-        assertCanMutateTool(name, "wrap");
-        tr.wrap(name, wrapper, owner);
-      },
-      get: (name) => tr.get(name),
-      list: () => tr.list()
-    };
-    const pr = init.providerRegistry;
-    this.providers = {
-      register: (f) => pr.register(f),
-      create: (cfg) => pr.create(cfg),
-      list: () => pr.list()
-    };
-    this.mcp = init.mcpRegistry ?? noopMcp;
-    const scr = init.slashCommandRegistry;
-    const official = init.official === true;
-    this.slashCommands = scr ? {
-      register: (cmd) => scr.register(cmd, owner, { official }),
-      unregister: (name) => scr.unregister(name),
-      get: (name) => scr.get(name),
-      list: () => scr.list()
-    } : noopSlashCommands;
-  }
-  onEvent(event, handler) {
-    const off = this.events.on(event, handler);
-    this.pluginCleanupFns.push(off);
-    return off;
-  }
-  onPattern(pattern, handler) {
-    const off = this.events.onPattern(pattern, handler);
-    this.pluginCleanupFns.push(off);
-    return off;
-  }
-  emitCustom(event, payload) {
-    this.events.emitCustom(event, payload);
-  }
-  onConfigChange(handler) {
-    if (!this.configStore) return () => {
-    };
-    return this.configStore.watch(handler);
-  }
-  /** Called by the plugin loader when uninstalling the plugin. */
-  drainCleanup() {
-    for (const fn of this.pluginCleanupFns.splice(0)) {
-      try {
-        fn();
-      } catch {
-      }
-    }
-  }
-  registerSystemPromptContributor(c) {
-    return this.extensions.registerSystemPromptContributor(c);
-  }
-  registerHook(event, matcher, hook) {
-    if (!this.hookRegistry) return () => {
-    };
-    const off = this.hookRegistry.registerInProcess(event, matcher, hook, this.ownerName);
-    this.pluginCleanupFns.push(off);
-    return off;
-  }
-};
-var noopMcp = {
-  start: async () => void 0,
-  stop: async () => void 0,
-  restart: async () => void 0,
-  list: () => []
-};
-var noopSlashCommands = {
-  register() {
-  },
-  unregister() {
-    return false;
-  },
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-};
-var noopSession = {
-  append: async () => {
-  }
-};
-var noopMetrics = {
-  counter() {
-  },
-  histogram() {
-  },
-  gauge() {
-  }
-};
-function scopedMetrics(sink, pluginName) {
-  const prefix = `plugin.${pluginName}.`;
-  return {
-    counter(name, value, labels) {
-      sink.counter(`${prefix}${name}`, value, labels);
-    },
-    histogram(name, value, labels) {
-      sink.histogram(`${prefix}${name}`, value, labels);
-    },
-    gauge(name, value, labels) {
-      sink.gauge(`${prefix}${name}`, value, labels);
-    }
-  };
-}
-
 // src/plugin/loader.ts
 var pluginApiMap = /* @__PURE__ */ new WeakMap();
 var KERNEL_API_VERSION = "0.1.10";
@@ -38202,12 +39100,23 @@ async function loadPlugins(plugins, opts) {
     try {
       const rawApi = opts.apiFactory(plugin);
       const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, opts.enforceCapabilities) : rawApi;
-      await plugin.setup(api);
+      const setupTimeoutMs = opts.setupTimeoutMs ?? 3e4;
+      const setupController = new AbortController();
+      const setupTimeout = setTimeout(() => setupController.abort(), setupTimeoutMs);
+      try {
+        await plugin.setup(api, { signal: setupController.signal });
+      } finally {
+        clearTimeout(setupTimeout);
+      }
       pluginApiMap.set(plugin, api);
       loaded.push(plugin);
       opts.log.info(`Plugin "${plugin.name}" loaded`);
     } catch (err) {
-      opts.log.error(`Plugin "${plugin.name}" setup failed`, err);
+      const isAbort = err instanceof DOMException && err.name === "AbortError";
+      opts.log.error(
+        `Plugin "${plugin.name}" setup failed`,
+        isAbort ? { err, reason: "setup timed out or aborted" } : { err }
+      );
       failed.push({ plugin, err });
     }
   }
@@ -38224,11 +39133,22 @@ async function unloadPlugins(loadedPlugins, opts) {
           `Plugin "${plugin.name}" API not found in pluginApiMap \u2014 was setup() called?`
         );
       }
-      await plugin.teardown(api);
+      const teardownTimeoutMs = opts.teardownTimeoutMs ?? 1e4;
+      const teardownController = new AbortController();
+      const teardownTimeout = setTimeout(() => teardownController.abort(), teardownTimeoutMs);
+      try {
+        await plugin.teardown(api, { signal: teardownController.signal });
+      } finally {
+        clearTimeout(teardownTimeout);
+      }
       pluginApiMap.delete(plugin);
       opts.log.info(`Plugin "${plugin.name}" torn down`);
     } catch (err) {
-      opts.log.error(`Plugin "${plugin.name}" teardown failed`, err);
+      const isAbort = err instanceof DOMException && err.name === "AbortError";
+      opts.log.error(
+        `Plugin "${plugin.name}" teardown failed`,
+        isAbort ? { err, reason: "teardown timed out or aborted" } : { err }
+      );
     }
   }
 }
@@ -38312,9 +39232,194 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
+// src/plugin/api.ts
+var DefaultPluginAPI = class {
+  container;
+  events;
+  pipelines;
+  tools;
+  providers;
+  mcp;
+  slashCommands;
+  extensions;
+  session;
+  metrics;
+  config;
+  log;
+  configStore;
+  hookRegistry;
+  ownerName;
+  pluginCleanupFns = [];
+  constructor(init) {
+    const owner = init.ownerName;
+    this.ownerName = owner;
+    this.hookRegistry = init.hookRegistry;
+    this.container = init.container;
+    this.events = init.events;
+    this.config = init.config;
+    this.configStore = init.configStore;
+    this.log = init.log.child({ plugin: owner });
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.session = init.sessionWriter ?? noopSession;
+    this.metrics = init.metricsSink ? scopedMetrics(init.metricsSink, owner) : noopMetrics;
+    const pipelines = init.pipelines;
+    const readonlyPipelines = {};
+    for (const [key, pipeline2] of Object.entries(pipelines)) {
+      readonlyPipelines[key] = pipeline2.asReadonly();
+    }
+    this.pipelines = readonlyPipelines;
+    const tr = init.toolRegistry;
+    const isOfficial = init.official === true;
+    const capabilities = init.capabilities;
+    const assertCanMutateTool = (name, op) => {
+      if (isOfficial) return;
+      const currentOwner = tr.ownerOf(name);
+      if (currentOwner === void 0) return;
+      const ownedSolelyByMe = currentOwner.split("+").every((seg) => seg === owner);
+      if (ownedSolelyByMe) return;
+      const toolCaps = tr.get(name)?.capabilities ?? [];
+      const pluginMutateCaps = capabilities?.toolMutateCapabilities ?? [];
+      const hasRequiredCap = toolCaps.some((c) => pluginMutateCaps.includes(c));
+      if (!hasRequiredCap) {
+        throw new Error(
+          `Plugin "${owner}" may not ${op} tool "${name}" \u2014 it is owned by "${currentOwner}". Tool capabilities: [${toolCaps.join(", ") || "none"}]. Plugin toolMutateCapabilities: [${pluginMutateCaps.join(", ") || "none"}]. Missing required capability to mutate this tool.`
+        );
+      }
+    };
+    this.tools = {
+      register: (t2) => tr.register(t2, owner),
+      unregister: (name) => {
+        assertCanMutateTool(name, "unregister");
+        return tr.unregister(name);
+      },
+      wrap: (name, wrapper) => {
+        assertCanMutateTool(name, "wrap");
+        tr.wrap(name, wrapper, owner);
+      },
+      get: (name) => tr.get(name),
+      list: () => tr.list()
+    };
+    const pr = init.providerRegistry;
+    this.providers = {
+      register: (f) => pr.register(f),
+      create: (cfg) => pr.create(cfg),
+      list: () => pr.list()
+    };
+    this.mcp = init.mcpRegistry ?? noopMcp;
+    const scr = init.slashCommandRegistry;
+    const official = init.official === true;
+    this.slashCommands = scr ? {
+      register: (cmd) => scr.register(cmd, owner, { official }),
+      unregister: (name) => scr.unregister(name),
+      get: (name) => scr.get(name),
+      list: () => scr.list()
+    } : noopSlashCommands;
+  }
+  onEvent(event, handler) {
+    const off = this.events.on(event, handler);
+    this.pluginCleanupFns.push(off);
+    return off;
+  }
+  onPattern(pattern, handler) {
+    const off = this.events.onPattern(pattern, handler);
+    this.pluginCleanupFns.push(off);
+    return off;
+  }
+  emitCustom(event, payload) {
+    this.events.emitCustom(event, payload);
+  }
+  onConfigChange(handler) {
+    if (!this.configStore) return () => {
+    };
+    return this.configStore.watch(handler);
+  }
+  /** Called by the plugin loader when uninstalling the plugin. */
+  drainCleanup() {
+    for (const fn of this.pluginCleanupFns.splice(0)) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+  registerSystemPromptContributor(c) {
+    return this.extensions.registerSystemPromptContributor(c);
+  }
+  registerHook(event, matcher, hook) {
+    if (!this.hookRegistry) return () => {
+    };
+    const off = this.hookRegistry.registerInProcess(event, matcher, hook, this.ownerName);
+    this.pluginCleanupFns.push(off);
+    return off;
+  }
+};
+var noopMcp = {
+  start: async () => void 0,
+  stop: async () => void 0,
+  restart: async () => void 0,
+  list: () => []
+};
+var noopSlashCommands = {
+  register() {
+  },
+  unregister() {
+    return false;
+  },
+  get() {
+    return void 0;
+  },
+  list() {
+    return [];
+  }
+};
+var noopSession = {
+  append: async () => {
+  }
+};
+var noopMetrics = {
+  counter() {
+  },
+  histogram() {
+  },
+  gauge() {
+  }
+};
+function scopedMetrics(sink, pluginName) {
+  const prefix = `plugin.${pluginName}.`;
+  return {
+    counter(name, value, labels) {
+      sink.counter(`${prefix}${name}`, value, labels);
+    },
+    histogram(name, value, labels) {
+      sink.histogram(`${prefix}${name}`, value, labels);
+    },
+    gauge(name, value, labels) {
+      sink.gauge(`${prefix}${name}`, value, labels);
+    }
+  };
+}
+function definePlugin(metadata, factory) {
+  return {
+    name: metadata.name,
+    version: metadata.version,
+    description: metadata.description,
+    capabilities: metadata.capabilities,
+    configSchema: metadata.configSchema,
+    defaultConfig: metadata.defaultConfig,
+    dependsOn: metadata.dependsOn,
+    optionalDeps: metadata.optionalDeps,
+    conflictsWith: metadata.conflictsWith,
+    apiVersion: KERNEL_API_VERSION,
+    // Cast the factory to match the Plugin.setup signature.
+    // The opts parameter ({ signal }) is accepted by Plugin.setup but the
+    // definePlugin factory doesn't need to declare it — the host always passes
+    // it at the call site; the factory just doesn't have to care about it.
+    setup: (api) => factory(api, metadata.defaultConfig)
+  };
+}
+
 // src/execution/prompt-enhancer.ts
 var ENHANCER_SYSTEM_PROMPT = `You are a request refiner embedded in a coding agent. Your ONLY job is to rewrite the user's message into clearer, unambiguous instructions that the coding agent can act on confidently.
-import { toErrorMessage } from '../utils/error.js';
 
 Rules:
 - Preserve the user's intent and scope EXACTLY. Do not add new requirements, features, constraints, or steps the user did not ask for. Do not remove anything they did ask for.
@@ -38408,6 +39513,7 @@ async function enhanceUserPrompt(opts) {
     opts.onError?.(toErrorMessage(err));
     return null;
   } finally {
+    timer.abort();
     clearTimeout(to);
   }
 }
@@ -38859,7 +39965,7 @@ var PhaseOrchestrator = class {
   async mergeOne(phase, handle) {
     if (!this.worktrees) return;
     try {
-      const resolve14 = this.ctx.resolveConflict ? async (info) => {
+      const resolve15 = this.ctx.resolveConflict ? async (info) => {
         const shouldResolve = await this.shouldAttemptConflictResolution(phase, info);
         if (!shouldResolve) return false;
         this.emit("phase.conflictResolving", {
@@ -38873,7 +39979,7 @@ var PhaseOrchestrator = class {
       const mergeOpts = {
         squash: true
       };
-      if (resolve14 !== void 0) mergeOpts.resolve = resolve14;
+      if (resolve15 !== void 0) mergeOpts.resolve = resolve15;
       const result = await this.worktrees.merge(handle, mergeOpts);
       if (result.resolved) {
         this.emit("phase.conflictResolved", { phaseId: phase.id, name: phase.name });
@@ -39224,7 +40330,7 @@ var PhaseOrchestrator = class {
     }
   }
   delay(ms) {
-    return new Promise((resolve14) => setTimeout(resolve14, ms));
+    return new Promise((resolve15) => setTimeout(resolve15, ms));
   }
 };
 
@@ -40277,8 +41383,8 @@ var CollaborationBus = class {
     if (this.isPaused()) return false;
     this.pausedAtMs = Date.now();
     this.pausedBy = byParticipant;
-    this.pausePromise = new Promise((resolve14) => {
-      this.pauseResolve = resolve14;
+    this.pausePromise = new Promise((resolve15) => {
+      this.pauseResolve = resolve15;
     });
     return true;
   }
@@ -40314,8 +41420,8 @@ var CollaborationBus = class {
       return true;
     }
     let timer;
-    const timeoutPromise = new Promise((resolve14) => {
-      timer = setTimeout(() => resolve14("timeout"), timeoutMs);
+    const timeoutPromise = new Promise((resolve15) => {
+      timer = setTimeout(() => resolve15("timeout"), timeoutMs);
     });
     const resumedPromise = this.pausePromise.then(() => "resumed").catch(() => "resumed");
     const winner = await Promise.race([resumedPromise, timeoutPromise]);
@@ -40558,8 +41664,8 @@ function extractManifestPath(msg) {
   }
   return void 0;
 }
-function isManifestFile(path43) {
-  const name = pathBasename(path43).toLowerCase();
+function isManifestFile(path44) {
+  const name = pathBasename(path44).toLowerCase();
   const manifests = [
     "package.json",
     "package-lock.json",
@@ -41063,7 +42169,7 @@ function createGitPlugin() {
 }
 async function runGit(args, cwd) {
   try {
-    return await new Promise((resolve14, reject) => {
+    return await new Promise((resolve15, reject) => {
       const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], signal: AbortSignal.timeout(3e4), windowsHide: true });
       let stdout = "";
       let stderr = "";
@@ -41084,7 +42190,7 @@ async function runGit(args, cwd) {
           })
         );
       });
-      child.on("close", (code) => resolve14({ stdout, stderr, code: code ?? 0 }));
+      child.on("close", (code) => resolve15({ stdout, stderr, code: code ?? 0 }));
     });
   } catch (err) {
     if (err instanceof WrongStackError) throw err;
@@ -41887,7 +42993,7 @@ If NOTHING worth flagging:
 ## \u{1F982} Chimera Review \u2014 all clear \u2705
 No issues found in N changed files.`;
 async function runGit2(args, cwd) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let child;
     try {
       child = spawn("git", args, {
@@ -41908,8 +43014,8 @@ async function runGit2(args, cwd) {
     child.stderr?.on("data", (d) => {
       stderr += d;
     });
-    child.on("error", () => resolve14({ stdout, stderr, code: 1 }));
-    child.on("close", (code) => resolve14({ stdout, stderr, code: code ?? 0 }));
+    child.on("error", () => resolve15({ stdout, stderr, code: 1 }));
+    child.on("close", (code) => resolve15({ stdout, stderr, code: code ?? 0 }));
   });
 }
 async function isGitRepo2(cwd) {
@@ -42063,6 +43169,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, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, 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, 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, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HEAVY_BUDGET, HookRegistry, HookRunner, 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, 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, TOKENS, TaskAuctioneer, TaskDAG, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMailboxHooks, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, 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, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, 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, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, 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, 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, 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_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, 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, HookRegistry, HookRunner, 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, 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, ToolError, ToolExecutor, ToolRegistry, VERIFY_AGENTS, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMailboxHooks, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, definePlugin, deriveTodosFromPlanItem, detectEcosystem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, encryptedPrefixForVersion, enhanceUserPrompt, ensureDir, 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, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, 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, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizeTokenSavingTier, normalizedEqual, onResize, parseContinueDirective, parseEncryptedVersion, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, rotateConfigKeys, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toErrorMessage, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withDisabledToolFiltering, withFileLock, wrapAsState, writeErr, writeOut, wstackGlobalRoot, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map