@wrongstack/core 0.5.7 → 0.6.1

package/dist/index.js

@@ -1,23 +1,109 @@
 import * as crypto2 from 'crypto';
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash } from 'crypto';
-import * as fs from 'fs';
 import * as fsp2 from 'fs/promises';
-import { readFile, readdir, writeFile, stat, mkdir } from 'fs/promises';
+import { readFile, readdir, stat, mkdir } from 'fs/promises';
 import * as path6 from 'path';
 import { join, extname, relative } from 'path';
+import * as fs2 from 'fs';
 import * as os4 from 'os';
+import { execFile, spawn } from 'child_process';
+import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import { createGunzip } from 'zlib';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
-import { spawn } from 'child_process';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/atomic-write.ts
+var atomic_write_exports = {};
+__export(atomic_write_exports, {
+  atomicWrite: () => atomicWrite,
+  ensureDir: () => ensureDir
+});
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path6.dirname(targetPath);
+  await fsp2.mkdir(dir, { recursive: true });
+  const tmp = path6.join(dir, `.${path6.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fsp2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fsp2.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fsp2.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat8 = await fsp2.stat(targetPath);
+      mode = stat8.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fsp2.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fsp2.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fsp2.mkdir(dir, { recursive: true });
+}
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fsp2.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fsp2.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve5) => setTimeout(resolve5, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+var TRANSIENT_RENAME_CODES;
+var init_atomic_write = __esm({
+  "src/utils/atomic-write.ts"() {
+    TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+  }
+});
 
 // src/types/errors.ts
 var WrongStackError = class extends Error {
@@ -823,6 +909,7 @@ function providerStatusToCode(status, type) {
 var ENCRYPTED_PREFIX = "enc:v1:";
 
 // src/security/secret-vault.ts
+init_atomic_write();
 var KEY_BYTES = 32;
 var IV_BYTES = 12;
 var TAG_BYTES = 16;
@@ -867,7 +954,7 @@ var DefaultSecretVault = class {
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
-      const buf = fs.readFileSync(this.keyFile);
+      const buf = fs2.readFileSync(this.keyFile);
       if (buf.length !== KEY_BYTES) {
         throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
       }
@@ -876,13 +963,13 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs.mkdirSync(path6.dirname(this.keyFile), { recursive: true });
+    fs2.mkdirSync(path6.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
     try {
-      fs.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
+      fs2.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const buf = fs.readFileSync(this.keyFile);
+      const buf = fs2.readFileSync(this.keyFile);
       if (buf.length !== KEY_BYTES) {
         throw new Error(`SecretVault: key file ${this.keyFile} has wrong size`);
       }
@@ -944,7 +1031,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
   await fsp2.mkdir(path6.dirname(configPath), { recursive: true });
-  await fsp2.writeFile(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+  await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   try {
     await fsp2.chmod(configPath, 384);
   } catch {
@@ -966,7 +1053,7 @@ async function migratePlaintextSecrets(configPath, vault) {
   const counter = { n: 0 };
   const migrated = walkCount(parsed, vault, counter);
   if (counter.n === 0) return { migrated: 0, file: configPath };
-  await fsp2.writeFile(configPath, JSON.stringify(migrated, null, 2), { mode: 384 });
+  await atomicWrite(configPath, JSON.stringify(migrated, null, 2), { mode: 384 });
   try {
     await fsp2.chmod(configPath, 384);
   } catch {
@@ -1076,7 +1163,7 @@ var DefaultLogger = class _DefaultLogger {
     this.pretty = opts.pretty ?? true;
     if (this.file) {
       try {
-        fs.mkdirSync(path6.dirname(this.file), { recursive: true });
+        fs2.mkdirSync(path6.dirname(this.file), { recursive: true });
       } catch {
       }
     }
@@ -1115,7 +1202,7 @@ var DefaultLogger = class _DefaultLogger {
     }
     if (this.file) {
       try {
-        fs.appendFileSync(this.file, `${JSON.stringify(entry)}
+        fs2.appendFileSync(this.file, `${JSON.stringify(entry)}
 `);
       } catch {
       }
@@ -1597,7 +1684,7 @@ var DefaultPathResolver = class {
     while (dir !== root) {
       for (const marker of PROJECT_MARKERS) {
         try {
-          fs.accessSync(path6.join(dir, marker));
+          fs2.accessSync(path6.join(dir, marker));
           return dir;
         } catch {
         }
@@ -1612,7 +1699,7 @@ var DefaultPathResolver = class {
     const abs = path6.isAbsolute(input) ? input : path6.resolve(this.cwd, input);
     let real;
     try {
-      real = fs.realpathSync(abs);
+      real = fs2.realpathSync(abs);
     } catch {
       real = path6.normalize(abs);
     }
@@ -1666,7 +1753,7 @@ function buildRecoveryStrategies(opts) {
       async attempt(err) {
         if (!(err instanceof ProviderError) || err.status !== 429) return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
-        const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+        const delay = Math.min(6e4, Math.max(1e3, delayMs));
         await new Promise((r) => setTimeout(r, delay));
         return { action: "retry", reason: "rate_limit_backoff" };
       }
@@ -1819,15 +1906,15 @@ var PATTERNS = [
   { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g },
   {
     type: "bearer_token",
-    // Bounded at 512 chars to prevent catastrophic backtracking on adversarial input.
-    // Negative lookahead is a simple single-char check — no backtracking risk.
-    regex: /(?<![A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{20,512}=*(?![A-Za-z0-9_.~+/-])/g
+    // Anchored with alternation instead of negative lookahead — avoids V8
+    // backtracking risk on adversarial input. Bounded at 512 chars.
+    regex: /(?:^|[^A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{20,512}=*(?:$|[^A-Za-z0-9_.~+/-])/g
   },
   {
     type: "high_entropy_env",
-    // Value bounded at 512 chars; negative lookahead simplified to avoid
-    // nested quantifier backtracking on adversarial input.
-    regex: /\b([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?/g
+    // Anchored with alternation instead of lookbehind to avoid backtracking.
+    // Value bounded at 512 chars.
+    regex: /(?:^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?:\s|$)/g
   }
 ];
 var SCRUB_CHUNK_BYTES = 64 * 1024;
@@ -1879,72 +1966,9 @@ var DefaultSecretScrubber = class {
     return visit(obj);
   }
 };
-async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path6.dirname(targetPath);
-  await fsp2.mkdir(dir, { recursive: true });
-  const tmp = path6.join(dir, `.${path6.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
-  try {
-    if (typeof content === "string") {
-      await fsp2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
-    } else {
-      await fsp2.writeFile(tmp, content, { flag: "wx" });
-    }
-    try {
-      const fh = await fsp2.open(tmp, "r+");
-      try {
-        await fh.sync();
-      } finally {
-        await fh.close();
-      }
-    } catch {
-    }
-    let mode;
-    try {
-      const stat8 = await fsp2.stat(targetPath);
-      mode = stat8.mode & 511;
-    } catch {
-      mode = opts.mode;
-    }
-    if (mode !== void 0) {
-      await fsp2.chmod(tmp, mode);
-    }
-    await renameWithRetry(tmp, targetPath);
-  } catch (err) {
-    try {
-      await fsp2.unlink(tmp);
-    } catch {
-    }
-    throw err;
-  }
-}
-async function ensureDir(dir) {
-  await fsp2.mkdir(dir, { recursive: true });
-}
-var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
-async function renameWithRetry(from, to) {
-  if (process.platform !== "win32") {
-    await fsp2.rename(from, to);
-    return;
-  }
-  const delays = [10, 25, 60, 120, 250];
-  let lastErr;
-  for (let i = 0; i <= delays.length; i++) {
-    try {
-      await fsp2.rename(from, to);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err?.code;
-      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
-        throw err;
-      }
-      await new Promise((resolve5) => setTimeout(resolve5, delays[i]));
-    }
-  }
-  throw lastErr;
-}
 
 // src/models/models-registry.ts
+init_atomic_write();
 var DEFAULT_URL = "https://models.dev/api.json";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var FAMILY_BY_NPM = {
@@ -2910,13 +2934,17 @@ var ToolExecutor = class {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
     const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    let cleanupCalled = false;
+    let caught = false;
     try {
       if (typeof tool.executeStream === "function") {
         return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
       }
       return await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
+      caught = true;
       if (combined.aborted && typeof tool.cleanup === "function") {
+        cleanupCalled = true;
         try {
           await tool.cleanup(input, ctx);
         } catch {
@@ -2925,6 +2953,16 @@ var ToolExecutor = class {
       throw err;
     } finally {
       clearTimeout(timer);
+      if (combined.aborted && !caught) {
+        if (!cleanupCalled && typeof tool.cleanup === "function") {
+          try {
+            await tool.cleanup(input, ctx);
+          } catch {
+          }
+        }
+        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
+        throw reason;
+      }
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -2982,7 +3020,8 @@ var ToolExecutor = class {
     if (subjectKey) {
       const v = obj[subjectKey];
       if (typeof v === "string") {
-        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+        const isPathKey = subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+        return isPathKey ? normalizePath(v) : escapeGlob(v);
       }
     }
     if (toolName === "bash" && typeof obj.command === "string") {
@@ -3297,6 +3336,9 @@ function renderPlainText(meta, events) {
   return lines.join("\n");
 }
 
+// src/utils/index.ts
+init_atomic_write();
+
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
   if (input.length > maxBytes) {
@@ -3725,6 +3767,11 @@ function looksSecret(name) {
 function buildChildEnv(optsOrSessionId) {
   const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
   const passthrough = process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[WrongStack] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
   const out = {};
   for (const [k, v] of Object.entries(process.env)) {
     if (v === void 0) continue;
@@ -3755,11 +3802,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path25, errors) {
+function walk2(value, schema, path26, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path25 || "<root>",
+        path: path26 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3768,7 +3815,7 @@ function walk2(value, schema, path25, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path25 || "<root>",
+        path: path26 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3778,19 +3825,19 @@ function walk2(value, schema, path25, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path25, req), message: "required property missing" });
+        errors.push({ path: joinPath(path26, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path25, key), errors);
+          walk2(obj[key], subSchema, joinPath(path26, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path25}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path26}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -3842,6 +3889,9 @@ function deepEqual(a, b) {
   }
   return false;
 }
+
+// src/storage/session-store.ts
+init_atomic_write();
 var DefaultSessionStore = class {
   dir;
   events;
@@ -3885,19 +3935,25 @@ var DefaultSessionStore = class {
         { cause: err }
       );
     }
-    const writer = new FileSessionWriter(
-      id,
-      handle,
-      (/* @__PURE__ */ new Date()).toISOString(),
-      {
+    try {
+      const writer = new FileSessionWriter(
         id,
-        model: data.metadata.model,
-        provider: data.metadata.provider
-      },
-      this.events,
-      { resumed: true, dir: this.dir, filePath: file }
-    );
-    return { writer, data };
+        handle,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        {
+          id,
+          model: data.metadata.model,
+          provider: data.metadata.provider
+        },
+        this.events,
+        { resumed: true, dir: this.dir, filePath: file }
+      );
+      return { writer, data };
+    } catch (err) {
+      await handle.close().catch(() => {
+      });
+      throw err;
+    }
   }
   async load(id) {
     const file = path6.join(this.dir, `${id}.jsonl`);
@@ -3943,7 +3999,7 @@ var DefaultSessionStore = class {
       const full = path6.join(this.dir, `${id}.jsonl`);
       const stat8 = await fsp2.stat(full);
       const summary = await this.summarize(id, stat8.mtime.toISOString());
-      await fsp2.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+      await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
           err instanceof Error ? err.message : String(err)
@@ -4171,7 +4227,7 @@ var FileSessionWriter = class {
     this.closed = true;
     if (this.manifestFile) {
       try {
-        await fsp2.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+        await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
       } catch {
       }
     }
@@ -4267,6 +4323,9 @@ function userInputTitle(content) {
   const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
+
+// src/storage/queue-store.ts
+init_atomic_write();
 var QueueStore = class {
   file;
   constructor(opts) {
@@ -4317,6 +4376,9 @@ function isPersistedQueueItem(v) {
   const o = v;
   return typeof o["displayText"] === "string" && Array.isArray(o["blocks"]);
 }
+
+// src/storage/attachment-store.ts
+init_atomic_write();
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)\]/g;
 var DefaultAttachmentStore = class {
@@ -4338,7 +4400,9 @@ var DefaultAttachmentStore = class {
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp2.mkdir(this.spoolDir, { recursive: true });
       spooledPath = path6.join(this.spoolDir, `${id}.bin`);
-      await fsp2.writeFile(spooledPath, input.data, input.kind === "image" ? "base64" : "utf8");
+      await atomicWrite(spooledPath, input.data, {
+        encoding: input.kind === "image" ? "base64" : "utf8"
+      });
       data = void 0;
     }
     const att = {
@@ -4437,6 +4501,9 @@ function mergeAdjacentText(blocks) {
   }
   return out;
 }
+
+// src/storage/memory-store.ts
+init_atomic_write();
 var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
@@ -4449,12 +4516,13 @@ var DefaultMemoryStore = class {
    * issue order. Different scopes still proceed in parallel.
    *
    * The chain tracks only the last pending write. If a write fails, its
-   * error is caught and swallowed (line 43) so the chain stays alive for
-   * subsequent calls. A crash between atomicWrite() and backup copy leaves
-   * the file at its new content with no backup — acceptable for an optional
-   * backup whose worst case is losing a memory consolidation pass.
+   * error is caught and swallowed so the chain stays alive for subsequent
+   * calls. The error is stored in `writeErrors` so callers can learn about
+   * it on the next read operation.
    */
   writeChain = /* @__PURE__ */ new Map();
+  /** Last write error per scope — surfaced as warnings on the next readAll(). */
+  writeErrors = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
@@ -4464,10 +4532,16 @@ var DefaultMemoryStore = class {
   }
   async runSerialized(scope, work) {
     const prior = this.writeChain.get(scope) ?? Promise.resolve();
+    prior.catch((err) => {
+      this.writeErrors.set(scope, err);
+    });
     const next = prior.catch(() => void 0).then(work);
     this.writeChain.set(scope, next);
     try {
       return await next;
+    } catch (err) {
+      this.writeErrors.set(scope, err);
+      throw err;
     } finally {
       if (this.writeChain.get(scope) === next) {
         this.writeChain.delete(scope);
@@ -4477,6 +4551,10 @@ var DefaultMemoryStore = class {
   async readAll() {
     const parts = [];
     for (const scope of ["project-agents", "project-memory", "user-memory"]) {
+      const writeErr = this.writeErrors.get(scope);
+      if (writeErr) {
+        parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr.message}`);
+      }
       const body = await this.read(scope);
       if (body.trim()) parts.push(`## ${labelOf(scope)}
 
@@ -4969,6 +5047,9 @@ function runConfigMigrations(input, targetVersion, migrations) {
   return { config: current, applied, shouldPersist };
 }
 var DEFAULT_CONFIG_MIGRATIONS = [];
+
+// src/storage/recovery-lock.ts
+init_atomic_write();
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -5189,6 +5270,9 @@ var SessionAnalyzer = class {
     return last - first;
   }
 };
+
+// src/storage/todos-checkpoint.ts
+init_atomic_write();
 async function loadTodosCheckpoint(filePath) {
   let raw;
   try {
@@ -5257,6 +5341,9 @@ function attachTodosCheckpoint(state, filePath, sessionId) {
     }
   };
 }
+
+// src/storage/plan-store.ts
+init_atomic_write();
 async function loadPlan(filePath) {
   let raw;
   try {
@@ -5491,6 +5578,9 @@ ${cat}:`);
   }
   return lines.join("\n");
 }
+
+// src/storage/director-state.ts
+init_atomic_write();
 async function loadDirectorState(filePath) {
   let raw;
   try {
@@ -5669,6 +5759,9 @@ var DirectorStateCheckpoint = class {
     }
   }
 };
+
+// src/security/permission-policy.ts
+init_atomic_write();
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -6199,17 +6292,23 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
           handleTextDelta(state, ev.text);
           events.emit("provider.text_delta", { ctx, text: ev.text });
           break;
-        case "tool_use_start":
-          handleToolUseStart(state, ev);
-          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
+        case "tool_use_start": {
+          const idVal = ev.id;
+          const nameVal = ev.name;
+          handleToolUseStart(state, { id: idVal, name: nameVal });
+          const emittedPayload = { ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
+          events.emit("provider.tool_use_start", emittedPayload);
           break;
+        }
         case "tool_use_input_delta":
           handleToolUseInputDelta(state, ev);
           break;
-        case "tool_use_stop":
+        case "tool_use_stop": {
+          const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
           handleToolUseStop(state, ev);
-          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
+          events.emit("provider.tool_use_stop", { ctx, id: ev.id, name: stoppedName });
           break;
+        }
         case "thinking_start":
           handleThinkingStart(state, ev);
           break;
@@ -7164,31 +7263,794 @@ var AutonomousRunner = class {
           this.opts.onDone?.(timeoutResult);
           return timeoutResult;
         }
-        this.stopped = true;
-        const failedResult = {
-          status: "failed",
-          error: toWrongStackError(e),
-          iterations: this.iterations,
-          toolCalls: this.toolCalls,
-          reason: e instanceof Error ? e.message : String(e)
+        this.stopped = true;
+        const failedResult = {
+          status: "failed",
+          error: toWrongStackError(e),
+          iterations: this.iterations,
+          toolCalls: this.toolCalls,
+          reason: e instanceof Error ? e.message : String(e)
+        };
+        this.opts.onDone?.(failedResult);
+        return failedResult;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    return {
+      status: "aborted",
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      reason: "stopped externally"
+    };
+  }
+  stop() {
+    this.stopped = true;
+  }
+};
+
+// src/storage/goal-store.ts
+init_atomic_write();
+var MAX_JOURNAL_ENTRIES = 500;
+function goalFilePath(projectRoot) {
+  return path6.join(projectRoot, ".wrongstack", "goal.json");
+}
+async function loadGoal(filePath) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveGoal(filePath, goal) {
+  await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+}
+function emptyGoal(goal) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    goal,
+    setAt: now,
+    lastActivityAt: now,
+    iterations: 0,
+    engineState: "idle",
+    goalState: "active",
+    todoAttempts: {},
+    journal: []
+  };
+}
+function appendJournal(goal, entry) {
+  const iteration = goal.iterations + 1;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const full = { ...entry, iteration, at };
+  const journal = [...goal.journal, full];
+  const trimmed = journal.length > MAX_JOURNAL_ENTRIES ? journal.slice(journal.length - MAX_JOURNAL_ENTRIES) : journal;
+  return {
+    ...goal,
+    iterations: iteration,
+    lastActivityAt: at,
+    journal: trimmed
+  };
+}
+function summarizeUsage(goal) {
+  let totalCostUsd = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let iterationsWithUsage = 0;
+  for (const e of goal.journal) {
+    if (typeof e.costUsd === "number") totalCostUsd += e.costUsd;
+    if (e.tokens) {
+      totalInputTokens += e.tokens.input;
+      totalOutputTokens += e.tokens.output;
+    }
+    if (typeof e.costUsd === "number" || e.tokens) iterationsWithUsage++;
+  }
+  return { totalCostUsd, totalInputTokens, totalOutputTokens, iterationsWithUsage };
+}
+function formatGoal(goal, journalLimit = 10) {
+  const lines = [];
+  lines.push(`Goal: ${goal.goal}`);
+  lines.push(`Set: ${goal.setAt}`);
+  lines.push(`Last activity: ${goal.lastActivityAt}`);
+  lines.push(`Iterations: ${goal.iterations}`);
+  lines.push(`Mission: ${goal.goalState ?? "active"}`);
+  lines.push(`Engine: ${goal.engineState}`);
+  const usage = summarizeUsage(goal);
+  if (usage.iterationsWithUsage > 0) {
+    lines.push(
+      `Spent: $${usage.totalCostUsd.toFixed(4)}  (in ${usage.totalInputTokens} / out ${usage.totalOutputTokens} tokens across ${usage.iterationsWithUsage} iterations)`
+    );
+  }
+  if (goal.journal.length > 0) {
+    lines.push("");
+    lines.push(`Recent journal (last ${Math.min(journalLimit, goal.journal.length)}):`);
+    const tail = goal.journal.slice(-journalLimit);
+    for (const e of tail) {
+      const mark = e.status === "success" ? "\u2713" : e.status === "failure" ? "\u2717" : e.status === "aborted" ? "\u2298" : "\xB7";
+      const note = e.note ? ` \u2014 ${e.note}` : "";
+      const cost = typeof e.costUsd === "number" ? ` ($${e.costUsd.toFixed(4)})` : "";
+      lines.push(`  #${e.iteration} ${mark} [${e.source}] ${e.task}${cost}${note}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/execution/eternal-autonomy.ts
+var execFileP = promisify(execFile);
+var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
+var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]?complete\]\s*$/im;
+var EternalAutonomyEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.goalPath = goalFilePath(opts.projectRoot);
+  }
+  opts;
+  state = "idle";
+  stopRequested = false;
+  consecutiveFailures = 0;
+  consecutiveBrainstormDone = 0;
+  /**
+   * Count of consecutive transient (recoverable) provider failures. Drives
+   * the exponential backoff between iterations. Reset on the first
+   * successful iteration so a single bad afternoon doesn't permanently
+   * slow the loop down.
+   */
+  consecutiveTransientRetries = 0;
+  currentCtrl = null;
+  iterationsSinceCompact = 0;
+  goalPath;
+  /** Current engine state — readable for UIs. */
+  get currentState() {
+    return this.state;
+  }
+  /** Synchronously request stop. Resolves once the running iteration aborts. */
+  stop() {
+    this.stopRequested = true;
+    this.currentCtrl?.abort();
+    void this.persistEngineState("stopped").catch(() => {
+    });
+    this.state = "stopped";
+  }
+  /**
+   * Mark the engine as 'running' on disk + reset stop state so a new
+   * batch of `runOneIteration()` calls can proceed. Called by the REPL
+   * when the user invokes `/autonomy eternal`. Idempotent.
+   */
+  async prime() {
+    this.stopRequested = false;
+    this.state = "running";
+    await this.persistEngineState("running").catch(() => {
+    });
+  }
+  /**
+   * Main loop. Returns when stop() is called or the goal file is removed.
+   * Does NOT throw — every iteration is wrapped to keep the loop alive.
+   */
+  async run() {
+    this.state = "running";
+    await this.persistEngineState("running");
+    try {
+      while (!this.stopRequested) {
+        let iterationOk = false;
+        try {
+          iterationOk = await this.runOneIteration();
+        } catch (err) {
+          this.consecutiveFailures++;
+          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
+          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+        }
+        if (iterationOk) {
+          this.consecutiveFailures = 0;
+        }
+        if (this.stopRequested) break;
+        await sleep(this.opts.cycleGapMs ?? 1e3);
+      }
+    } finally {
+      this.state = "stopped";
+      await this.persistEngineState("stopped").catch(() => {
+      });
+    }
+  }
+  /**
+   * Execute a single sense-decide-execute-reflect cycle.
+   * Returns true on success, false on handled failure / no-op.
+   *
+   * Exposed publicly so the REPL can pace iterations from its main loop
+   * — running the engine and the REPL as a single sequential consumer of
+   * `agent.run()` avoids race conditions on the shared Context.
+   */
+  async runOneIteration() {
+    const goal = await loadGoal(this.goalPath);
+    if (!goal) {
+      this.stopRequested = true;
+      return false;
+    }
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") {
+      this.stopRequested = true;
+      return false;
+    }
+    const action = await this.decide(goal);
+    if (!action) {
+      if (!this.stopRequested) {
+        await sleep(5e3);
+      }
+      return false;
+    }
+    const ctrl = new AbortController();
+    this.currentCtrl = ctrl;
+    const timer = setTimeout(
+      () => ctrl.abort(),
+      this.opts.iterationTimeoutMs ?? 5 * 6e4
+    );
+    let status = "success";
+    let note;
+    let finalText = "";
+    let isTransientFailure = false;
+    const tc = this.opts.agent.ctx?.tokenCounter;
+    const beforeUsage = tc?.total?.();
+    const beforeCost = tc?.estimateCost?.().total;
+    try {
+      const result = await this.opts.agent.run(
+        [{ type: "text", text: action.directive }],
+        {
+          signal: ctrl.signal,
+          // Enable per-call autonomous continuation so the agent can chain
+          // multiple internal tool/response cycles end-to-end on one
+          // directive instead of returning to the engine after a single
+          // round-trip. The model uses `[continue]` / `[done]` markers
+          // (or the `continue_to_next_iteration` tool) to control the
+          // inner loop. Without this flag the engine produced shallow
+          // iterations and almost never let a real task finish.
+          autonomousContinue: true,
+          // Cap the inner loop so a runaway agent.run can't burn through
+          // the iteration timeout — the engine's own outer loop is the
+          // long-running thing, each tick should be bounded.
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+        }
+      );
+      if (result.status === "aborted") {
+        status = "aborted";
+        note = "stopped by user";
+      } else if (result.status === "failed") {
+        status = "failure";
+        note = result.error?.describe?.() ?? "agent run failed";
+        isTransientFailure = result.error?.recoverable === true;
+      } else if (result.status === "max_iterations") {
+        status = "failure";
+        note = `max iterations (${result.iterations})`;
+      } else {
+        status = "success";
+        finalText = result.finalText ?? "";
+        const tail = finalText.slice(0, 240).replace(/\s+/g, " ").trim();
+        if (tail) note = tail;
+      }
+    } catch (err) {
+      const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
+      status = isAbort ? "aborted" : "failure";
+      note = err instanceof Error ? err.message : String(err);
+      if (!isAbort && typeof err?.recoverable === "boolean") {
+        isTransientFailure = err.recoverable;
+      }
+    } finally {
+      clearTimeout(timer);
+      this.currentCtrl = null;
+    }
+    if (action.source === "todo" && action.todoId && status !== "success") {
+      await this.bumpTodoAttempt(action.todoId);
+    }
+    const afterUsage = tc?.total?.();
+    const afterCost = tc?.estimateCost?.().total;
+    const tokens = beforeUsage && afterUsage ? {
+      input: Math.max(0, afterUsage.input - beforeUsage.input),
+      output: Math.max(0, afterUsage.output - beforeUsage.output)
+    } : void 0;
+    const costUsd = typeof beforeCost === "number" && typeof afterCost === "number" ? Math.max(0, afterCost - beforeCost) : void 0;
+    await this.appendIterationEntry({
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      costUsd
+    });
+    let iterationIndex = 0;
+    try {
+      const reloaded = await loadGoal(this.goalPath);
+      iterationIndex = reloaded?.iterations ?? 0;
+    } catch {
+    }
+    this.opts.onIteration?.({
+      at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      iteration: iterationIndex,
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      costUsd
+    });
+    if (status === "failure") {
+      if (isTransientFailure) {
+        this.consecutiveTransientRetries++;
+        const delay = this.computeTransientBackoffMs();
+        if (delay > 0) {
+          await this.sleepInterruptible(delay);
+        }
+        return false;
+      }
+      this.consecutiveFailures++;
+      return false;
+    }
+    if (status === "aborted") {
+      if (this.stopRequested) return false;
+      this.consecutiveFailures++;
+      return false;
+    }
+    this.consecutiveTransientRetries = 0;
+    if (GOAL_COMPLETE_MARKER.test(finalText)) {
+      await this.markGoalCompleted(action, finalText);
+      this.stopRequested = true;
+      return true;
+    }
+    this.iterationsSinceCompact++;
+    await this.maybeCompact().catch((err) => {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
+    });
+    return true;
+  }
+  /**
+   * Run compaction when either trigger fires:
+   *   - We've done >= compactEveryNIterations since the last compact.
+   *   - Current request tokens exceed aggressiveCompactRatio * maxContext.
+   *
+   * The second check uses *aggressive* mode to free more headroom; the
+   * cadence check uses non-aggressive (cheaper).
+   */
+  async maybeCompact() {
+    const compactor = this.opts.compactor;
+    if (!compactor) return;
+    const ctx = this.opts.agent.ctx;
+    if (!ctx) return;
+    const cadence = this.opts.compactEveryNIterations ?? 25;
+    const threshold = this.opts.aggressiveCompactRatio ?? 0.85;
+    const maxCtx = this.opts.maxContextTokens;
+    let aggressive = false;
+    let shouldRun = false;
+    if (this.iterationsSinceCompact >= cadence) {
+      shouldRun = true;
+    }
+    if (maxCtx && maxCtx > 0) {
+      const used = ctx.tokenCounter?.currentRequestTokens?.();
+      if (used) {
+        const total = used.input + used.cacheRead;
+        if (total / maxCtx >= threshold) {
+          shouldRun = true;
+          aggressive = true;
+        }
+      }
+    }
+    if (!shouldRun) return;
+    const report = await compactor.compact(ctx, { aggressive });
+    this.iterationsSinceCompact = 0;
+    const saved = report.before - report.after;
+    await this.appendIterationEntry({
+      source: "manual",
+      task: `compaction (${aggressive ? "aggressive" : "cadence"})`,
+      status: "success",
+      note: `saved ~${saved} tokens (${report.before}\u2192${report.after})`
+    });
+  }
+  /**
+   * Hybrid idea source.
+   *   1. Pending todos on the agent's context.
+   *   2. Dirty git working tree → propose a "review and finish this" task.
+   *   3. Otherwise: brainstorm via the LLM against the goal.
+   *
+   * After failureBudget consecutive failures, force brainstorm so the
+   * engine doesn't loop on the same broken todo or stuck git state.
+   */
+  async decide(goal) {
+    const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
+    if (!forceBrainstorm) {
+      const todo = this.pickPendingTodo(goal);
+      if (todo) {
+        return {
+          source: "todo",
+          task: todo.content,
+          todoId: todo.id,
+          directive: this.buildDirective(goal, "todo", todo.content)
         };
-        this.opts.onDone?.(failedResult);
-        return failedResult;
-      } finally {
-        clearTimeout(timeout);
       }
+      const gitTask = await this.pickGitTask();
+      if (gitTask) {
+        return {
+          source: "git",
+          task: gitTask,
+          directive: this.buildDirective(goal, "git", gitTask)
+        };
+      }
+    }
+    const brainstormed = await this.brainstormTask(goal);
+    if (brainstormed === BRAINSTORM_DONE) {
+      this.consecutiveBrainstormDone++;
+      const threshold = this.opts.brainstormDoneStopThreshold ?? 3;
+      if (this.consecutiveBrainstormDone >= threshold) {
+        await this.markGoalCompleted(
+          { source: "brainstorm", task: "no further work", directive: "" },
+          `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row`
+        );
+        this.stopRequested = true;
+      }
+      return null;
     }
+    if (!brainstormed) return null;
+    this.consecutiveBrainstormDone = 0;
     return {
-      status: "aborted",
-      iterations: this.iterations,
-      toolCalls: this.toolCalls,
-      reason: "stopped externally"
+      source: "brainstorm",
+      task: brainstormed,
+      directive: this.buildDirective(goal, "brainstorm", brainstormed)
     };
   }
-  stop() {
-    this.stopped = true;
+  pickPendingTodo(goal) {
+    const todos = this.opts.agent.ctx.todos;
+    if (!Array.isArray(todos)) return null;
+    const attempts = goal.todoAttempts ?? {};
+    const ceiling = this.opts.todoMaxAttempts ?? 3;
+    for (const t2 of todos) {
+      if (t2.status !== "pending") continue;
+      const used = attempts[t2.id] ?? 0;
+      if (used >= ceiling) continue;
+      return t2;
+    }
+    return null;
+  }
+  async pickGitTask() {
+    let out;
+    try {
+      out = await (this.opts.gitStatusReader?.() ?? this.readGitStatus());
+    } catch {
+      return null;
+    }
+    const dirty = out.trim();
+    if (!dirty) return null;
+    const lines = dirty.split("\n").slice(0, 8);
+    const preview = lines.join(", ");
+    return `Inspect the dirty working tree and either finish the in-progress work or revert it. Files: ${preview}`;
+  }
+  async readGitStatus() {
+    const { stdout } = await execFileP("git", ["status", "--porcelain"], {
+      cwd: this.opts.projectRoot,
+      timeout: 5e3
+    });
+    return stdout;
+  }
+  async brainstormTask(goal) {
+    const lastFew = goal.journal.slice(-5).map((e) => `  - [${e.status}] ${e.task}`).join("\n");
+    const directive = [
+      "You are deciding the next action in an autonomous loop pursuing a long-running goal.",
+      "",
+      `Goal: ${goal.goal}`,
+      "",
+      lastFew ? `Recent iterations:
+${lastFew}` : "No prior iterations yet.",
+      "",
+      "Output ONE concrete, immediately-actionable task that advances the goal.",
+      "Constraints:",
+      "- One sentence, imperative form, under 200 chars.",
+      "- No preamble, no explanation, no markdown \u2014 just the task line.",
+      "- If recent iterations show repeated failures on the same target, pivot.",
+      "- If the goal appears fully accomplished AND you can name a concrete",
+      "  artifact / test / output that proves it, output exactly: DONE",
+      "- Be conservative with DONE: if the recent journal contains failures",
+      "  or aborted entries, the goal is almost certainly NOT done."
+    ].join("\n");
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      try {
+        const result = await this.opts.agent.run(
+          [{ type: "text", text: directive }],
+          { signal: ctrl.signal, maxIterations: 1 }
+        );
+        if (result.status !== "done") return null;
+        const text = (result.finalText ?? "").trim();
+        if (!text) return null;
+        if (/^DONE\.?$/i.test(text)) return BRAINSTORM_DONE;
+        const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
+        if (!firstLine) return null;
+        if (/^DONE\.?$/i.test(firstLine)) return BRAINSTORM_DONE;
+        return firstLine.slice(0, 240);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return null;
+    }
+  }
+  buildDirective(goal, source, task) {
+    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
+    return [
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 iteration directive \u2550\u2550\u2550",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations + 1}`,
+      `Source: ${source}`,
+      `Task: ${task}`,
+      "",
+      recentJournal ? `Recent journal (last 5):
+${recentJournal}` : "No prior iterations.",
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "You are inside a long-running autonomous loop. Each iteration you",
+      "execute ONE concrete task that advances the Mission. No user is",
+      "available to clarify \u2014 make defensible decisions and move forward.",
+      "",
+      "1. EXECUTE END-TO-END",
+      "   \u2022 Use multiple tool calls freely. Emit `[continue]` on its own line",
+      "     to chain to the next internal step without returning.",
+      "   \u2022 When this iteration's Task is finished (real artifact / passing",
+      "     test / applied diff / clean output), emit `[done]` on its own line.",
+      "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
+      "     approaches before giving up. YOLO is active; no confirmations.",
+      "",
+      "2. UPDATE TODO STATE (when Source is `todo`)",
+      "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
+      "   \u2022 Mark it `completed` on success, with a one-line outcome note.",
+      "   \u2022 If you cannot make progress after 2 distinct attempts, mark it",
+      "     `cancelled` with the obstacle. The loop will skip it next time.",
+      "",
+      "3. MISSION-COMPLETE PROTOCOL",
+      "   \u2022 If \u2014 and ONLY if \u2014 the OVERALL Mission (not just this Task) is",
+      "     verifiably accomplished, emit on its own line:",
+      "         [GOAL_COMPLETE]",
+      "     followed by a one-paragraph verification recipe (artifact path,",
+      "     test command, or 10-second reproduction). This halts the loop.",
+      "   \u2022 NEVER emit [GOAL_COMPLETE] on optimism, partial progress, or",
+      '     "looks fine". Required: a concrete artifact that proves it AND',
+      "     no recent journal failures contradicting completion.",
+      "   \u2022 If unsure, emit `[done]` instead and let the next iteration",
+      "     decide. The loop is patient; false completion is not.",
+      "",
+      "4. NO INTERACTIVITY",
+      "   \u2022 Do not ask questions, do not request confirmation, do not propose",
+      "     options. Pick the best path and execute. The user is asleep."
+    ].join("\n");
+  }
+  /**
+   * Exponential backoff for transient provider errors. `2^N * base`
+   * capped at `transientBackoffMaxMs`. Zero base disables backoff.
+   * Public-private to keep `runOneIteration` readable; the value is
+   * recomputed each call from the current retry count, so callers
+   * don't have to track state.
+   */
+  computeTransientBackoffMs() {
+    const base = this.opts.transientBackoffBaseMs ?? 2e3;
+    const cap = this.opts.transientBackoffMaxMs ?? 6e4;
+    if (base <= 0) return 0;
+    const exponent = Math.max(0, this.consecutiveTransientRetries - 1);
+    return Math.min(cap, base * Math.pow(2, exponent));
+  }
+  /**
+   * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
+   * so SIGINT / `/autonomy stop` can land in the middle of a long
+   * backoff instead of waiting up to a minute for the timer.
+   */
+  async sleepInterruptible(totalMs) {
+    const step = 250;
+    let remaining = totalMs;
+    while (remaining > 0 && !this.stopRequested) {
+      const chunk = Math.min(step, remaining);
+      await sleep(chunk);
+      remaining -= chunk;
+    }
+  }
+  async appendIterationEntry(entry) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) {
+      return;
+    }
+    const updated = appendJournal(current, entry);
+    await saveGoal(this.goalPath, updated);
+  }
+  /**
+   * Persistent per-todo failure counter. Skipped silently when the goal
+   * file has been removed (graceful clear). Each non-success iteration
+   * against a todo source bumps the counter by 1; `pickPendingTodo` reads
+   * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
+   */
+  async bumpTodoAttempt(todoId) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const attempts = { ...current.todoAttempts ?? {} };
+    attempts[todoId] = (attempts[todoId] ?? 0) + 1;
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+  }
+  /**
+   * Flip the mission to `completed` and journal it. Called from two
+   * paths: (a) `[GOAL_COMPLETE]` marker in a successful iteration's
+   * finalText, (b) `brainstorm` returning DONE consecutively past the
+   * configured threshold. Idempotent — re-entry is a no-op once the
+   * goal is already `completed`.
+   */
+  async markGoalCompleted(action, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.goalState === "completed") return;
+    const withFlag = { ...current, goalState: "completed" };
+    const withEntry = appendJournal(withFlag, {
+      source: action.source,
+      task: `MISSION COMPLETE \u2014 ${action.task}`.slice(0, 240),
+      status: "success",
+      note: note.slice(0, 240)
+    });
+    await saveGoal(this.goalPath, withEntry);
+  }
+  async appendFailure(task, note) {
+    await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
+  }
+  async persistEngineState(state) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.engineState === state) return;
+    await saveGoal(this.goalPath, { ...current, engineState: state });
   }
 };
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/execution/autonomy-prompt-contributor.ts
+function makeAutonomyPromptContributor(opts) {
+  return async (ctx) => {
+    if (ctx.subagent) return [];
+    if (!opts.enabled()) return [];
+    let goal;
+    try {
+      goal = await loadGoal(opts.goalPath);
+    } catch {
+      return [];
+    }
+    if (!goal) return [];
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") return [];
+    const tailSize = opts.journalTailSize ?? 5;
+    const journalTail = goal.journal.slice(-tailSize).map((e) => {
+      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
+      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
+    });
+    const text = [
+      "## ETERNAL AUTONOMY \u2014 active mission",
+      "",
+      "You are inside a long-running autonomous loop. The user is asleep",
+      "and is not available to confirm decisions. Each turn you receive a",
+      "directive describing one concrete sub-task that advances the mission.",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations}`,
+      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
+${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
+      "",
+      "### Loop control markers",
+      "Emit these on their own line in your final text \u2014 case-insensitive,",
+      "whitespace-tolerant, but they must occupy the entire line:",
+      "- `[continue]` \u2014 chain to the next internal step without returning.",
+      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
+      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
+      "  verifiably done. Must be followed by a one-paragraph verification",
+      "  recipe (artifact path, test command, or 10-second reproduction).",
+      "  The engine halts on this marker \u2014 false positives waste real",
+      "  human time. If unsure, emit `[done]` and let the next iteration",
+      "  decide.",
+      "",
+      "### Operating principles",
+      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
+      "  options. Pick the best path and execute it.",
+      "- Use tools freely; multiple calls per turn are normal and expected.",
+      "- When working on a todo, mark it `in_progress` via the todos tool",
+      "  before tool work and `completed` (or `cancelled` with a reason)",
+      "  when done. The loop reads todo state between iterations.",
+      "- If an approach fails twice in a row, pivot. Don't grind on the",
+      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
+      "  surface the obstacle via `[done]` and let the next iteration",
+      "  re-plan."
+    ].join("\n");
+    return [
+      {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  };
+}
+
+// src/execution/goal-preamble.ts
+function buildGoalPreamble(goal) {
+  return [
+    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
+    "The user granted you full autonomy. Read these constraints once, then act.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- You can tell the user HOW to verify it themselves in 10 seconds.",
+    '- You have NOT hedged. None of: "looks like it should work", "I',
+    '  believe this fixes it", "the changes appear correct".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
+
+// src/coordination/director.ts
+init_atomic_write();
 
 // src/coordination/director-prompts.ts
 var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
@@ -7497,7 +8359,7 @@ var BudgetThresholdSignal = class extends Error {
     this.decision = decision;
   }
 };
-var SubagentBudget = class {
+var SubagentBudget = class _SubagentBudget {
   limits;
   iterations = 0;
   toolCalls = 0;
@@ -7506,6 +8368,26 @@ var SubagentBudget = class {
   costUsd = 0;
   startTime = null;
   _onThreshold;
+  /**
+   * Tracks which budget kinds currently have an extension request
+   * in flight. While a kind is here, further `checkLimit` calls for the
+   * same kind are no-ops — without this dedup, every `recordIteration`
+   * after the limit is reached spawns a fresh decision Promise (until
+   * the first one lands and patches limits), flooding the FleetBus
+   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * respond before defaulting to 'stop'. Without this fallback an absent
+   * or hung listener (Director not built / event filter detached mid-run)
+   * leaves the budget over-limit and never enforces anything, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Hardcoded for now — most fleets set their own per-task timeout that
+   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   */
+  static DECISION_TIMEOUT_MS = 3e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -7548,56 +8430,92 @@ var SubagentBudget = class {
     if (kind === "timeout" || !this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
-    void this.checkLimitAsync(kind, used, limit);
+    const bus = this._events;
+    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    if (this.pendingExtensions.has(kind)) return;
+    this.pendingExtensions.add(kind);
+    const decision = this.negotiateExtension(kind, used, limit);
+    throw new BudgetThresholdSignal(kind, limit, used, decision);
   }
   /**
-   * Async threshold negotiation with the coordinator. Fire-and-forget —
-   * any error thrown here becomes an unhandled rejection in the test environment
-   * because the runner's catch only handles the synchronous throw from `checkLimit`.
+   * Drive the threshold handler to a decision. Resolves with `'stop'`
+   * (signal the runner to abort) or `{ extend: ... }` (limits already
+   * patched in-place; the runner should not abort). Always releases the
+   * `pendingExtensions` slot in `finally`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching, next overrun will
+   * fire a fresh signal.
    */
-  async checkLimitAsync(kind, used, limit) {
-    const result = this._onThreshold({
-      kind,
-      used,
-      limit,
-      // Inject a requestDecision helper the handler can call to emit the
-      // budget.threshold_reached event and wait for the coordinator's verdict.
-      // The runner wires this by injecting its EventBus into ctx.budget._events.
-      requestDecision: () => {
-        return new Promise((resolve5) => {
-          this._events?.emit("budget.threshold_reached", {
-            kind,
-            used,
-            limit,
-            timeoutMs: 3e4,
-            extend: (extra) => resolve5({ extend: extra }),
-            deny: () => resolve5("stop")
+  async negotiateExtension(kind, used, limit) {
+    try {
+      const result = this._onThreshold({
+        kind,
+        used,
+        limit,
+        // Inject a requestDecision helper the handler can call to emit the
+        // budget.threshold_reached event and wait for the coordinator's verdict.
+        // A hard fallback timer guarantees the promise eventually resolves
+        // even if no listener responds — without it, an absent/detached
+        // Director would leave the budget permanently in "asking" state.
+        requestDecision: () => {
+          const bus = this._events;
+          if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolve5) => {
+            let resolved = false;
+            const respond = (d) => {
+              if (resolved) return;
+              resolved = true;
+              resolve5(d);
+            };
+            const fallback = setTimeout(
+              () => respond("stop"),
+              _SubagentBudget.DECISION_TIMEOUT_MS
+            );
+            bus.emit("budget.threshold_reached", {
+              kind,
+              used,
+              limit,
+              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+              extend: (extra) => {
+                clearTimeout(fallback);
+                respond({ extend: extra });
+              },
+              deny: () => {
+                clearTimeout(fallback);
+                respond("stop");
+              }
+            });
           });
-        });
+        }
+      });
+      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 (result === "throw") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    if (result === "continue") {
-      return;
-    }
-    const decision = await result;
-    if (decision === "stop") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    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.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;
+      }
+      return decision;
+    } finally {
+      this.pendingExtensions.delete(kind);
     }
   }
   recordIteration() {
@@ -7880,6 +8798,19 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
@@ -8139,14 +9070,65 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.recordCompletion(result);
   }
   async executeWithTimeout(runner, task, ctx, budget) {
-    const timeoutMs = budget.limits.timeoutMs;
-    if (timeoutMs === void 0) return runner(task, ctx);
+    const initialTimeoutMs = budget.limits.timeoutMs;
+    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        this.subagents.get(ctx.subagentId)?.abortController.abort();
-        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
-      }, timeoutMs);
+      const armFor = (ms) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+          const elapsed = Date.now() - start;
+          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
+          if (!budget.onThreshold) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+            return;
+          }
+          try {
+            const result = budget.onThreshold({
+              kind: "timeout",
+              used: elapsed,
+              limit,
+              requestDecision: () => new Promise((resolveDecision) => {
+                budget._events?.emit("budget.threshold_reached", {
+                  kind: "timeout",
+                  used: elapsed,
+                  limit,
+                  timeoutMs: 3e4,
+                  extend: (extra) => resolveDecision({ extend: extra }),
+                  deny: () => resolveDecision("stop")
+                });
+              })
+            });
+            const decision = typeof result === "string" ? result : await result;
+            if (decision === "continue") {
+              armFor(Math.max(1e3, limit));
+              return;
+            }
+            if (decision === "throw" || decision === "stop") {
+              this.subagents.get(ctx.subagentId)?.abortController.abort();
+              reject(new BudgetExceededError("timeout", limit, elapsed));
+              return;
+            }
+            if (decision.extend.timeoutMs !== void 0) {
+              budget.limits.timeoutMs = decision.extend.timeoutMs;
+              const newLimit = decision.extend.timeoutMs;
+              const remaining = Math.max(1e3, newLimit - elapsed);
+              armFor(remaining);
+              return;
+            }
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+          } catch (err) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(
+              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+            );
+          }
+        }, ms);
+      };
+      armFor(initialTimeoutMs);
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -8685,7 +9667,9 @@ var Director = class {
     }, opts.checkpointDebounceMs ?? 250) : null;
     this.fleetManager = opts.fleetManager;
     if (this.sharedScratchpadPath) {
-      void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
+      void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(
+        (err) => this.logShutdownError("shared_scratchpad_mkdir", err)
+      );
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -8755,7 +9739,7 @@ var Director = class {
         return;
       }
       extendCounts.set(guardKey, prior + 1);
-      setTimeout(() => {
+      setImmediate(() => {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
@@ -8770,9 +9754,12 @@ var Director = class {
           case "cost":
             extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
             break;
+          case "timeout":
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            break;
         }
         payload.extend(extra);
-      }, Math.min(payload.timeoutMs, 3e4));
+      });
     });
   }
   /** Best-effort session-writer append. Swallows failures — the director
@@ -8791,7 +9778,9 @@ var Director = class {
     if (this.manifestTimer) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
-      void this.writeManifest().catch(() => void 0);
+      void this.writeManifest().catch(
+        (err) => this.logShutdownError("manifest_write_debounced", err)
+      );
     }, this.manifestDebounceMs);
   }
   /**
@@ -8982,7 +9971,7 @@ var Director = class {
       usage: this.usage.snapshot()
     };
     await fsp2.mkdir(path6.dirname(this.manifestPath), { recursive: true });
-    await fsp2.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
   /**
@@ -9511,9 +10500,11 @@ async function readSubagentPartial(opts, subagentId) {
     candidates.push(path6.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
-      const runDirs = await fsp2.readdir(opts.sessionsRoot);
-      for (const r of runDirs) {
-        candidates.push(path6.join(opts.sessionsRoot, r, `${subagentId}.jsonl`));
+      const entries = await fsp2.readdir(opts.sessionsRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          candidates.push(path6.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+        }
       }
     } catch {
       return void 0;
@@ -9563,6 +10554,7 @@ function makeAgentSubagentRunner(opts) {
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
@@ -9711,6 +10703,9 @@ function makeDirectorSessionFactory(opts) {
 
 // src/coordination/null-fleet-bus.ts
 var NULL_FLEET_BUS = new FleetBus();
+
+// src/models/mode-store.ts
+init_atomic_write();
 var DefaultModeStore = class {
   activeModeId = null;
   modes;
@@ -9769,10 +10764,9 @@ var DefaultModeStore = class {
     try {
       await fsp2.mkdir(this.configDir, { recursive: true });
       const configPath = path6.join(this.configDir, "mode.json");
-      await fsp2.writeFile(
+      await atomicWrite(
         configPath,
-        JSON.stringify({ activeMode: this.activeModeId }, null, 2),
-        "utf8"
+        JSON.stringify({ activeMode: this.activeModeId }, null, 2)
       );
     } catch {
     }
@@ -10626,6 +11620,9 @@ var SpecDrivenDev = class {
     }));
   }
 };
+
+// src/sdd/spec-store.ts
+init_atomic_write();
 var SpecStore = class {
   baseDir;
   indexPath;
@@ -10735,6 +11732,9 @@ var SpecStore = class {
     await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
   }
 };
+
+// src/sdd/task-graph-store.ts
+init_atomic_write();
 function graphToJSON(graph) {
   const serialisable = {
     ...graph,
@@ -11036,10 +12036,11 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp15 = await import('fs/promises');
-      const path25 = await import('path');
-      await fsp15.mkdir(path25.dirname(this.sessionPath), { recursive: true });
-      await fsp15.writeFile(this.sessionPath, JSON.stringify(this.session, null, 2), "utf8");
+      const fsp16 = await import('fs/promises');
+      const path26 = await import('path');
+      const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
+      await fsp16.mkdir(path26.dirname(this.sessionPath), { recursive: true });
+      await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
   }
@@ -11047,8 +12048,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp15 = await import('fs/promises');
-      const raw = await fsp15.readFile(this.sessionPath, "utf8");
+      const fsp16 = await import('fs/promises');
+      const raw = await fsp16.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -11062,14 +12063,21 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp15 = await import('fs/promises');
-      await fsp15.unlink(this.sessionPath);
+      const fsp16 = await import('fs/promises');
+      await fsp16.unlink(this.sessionPath);
     } catch {
     }
   }
-  /** Auto-save helper — calls saveSession() but never throws. */
+  /** Auto-save helper — calls saveSession() but never throws.
+   *  Failures are surfaced via process.emitWarning so a persistent
+   *  ENOSPC / EACCES doesn't silently strand session edits in memory. */
   autoSave() {
-    this.saveSession().catch(() => {
+    this.saveSession().catch((err) => {
+      const detail = err instanceof Error ? err.message : String(err);
+      process.emitWarning(
+        `SpecBuilder autoSave failed: ${detail}`,
+        "SpecBuilderWarning"
+      );
     });
   }
   // ── Session Lifecycle ─────────────────────────────────────────────────────
@@ -11741,15 +12749,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path25 = [];
+  const path26 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path25.unshift(current);
+    path26.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path25;
+  return path26;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -12459,7 +13467,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path25 = opts.path ?? "/metrics";
+  const path26 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -12469,7 +13477,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path25) {
+    if (url === path26) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -12533,7 +13541,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path25}`,
+    url: `${protocol}://${host}:${boundPort}${path26}`,
     close: () => new Promise((resolve5, reject) => {
       server.close((err) => err ? reject(err) : resolve5());
     })
@@ -13260,6 +14268,9 @@ function stripTopDir(p) {
   if (idx === -1) return "";
   return p.slice(idx + 1);
 }
+
+// src/skills/manifest-store.ts
+init_atomic_write();
 var SkillManifestStore = class {
   manifestPath;
   cache;
@@ -13284,7 +14295,7 @@ var SkillManifestStore = class {
   async write(data) {
     const dir = path6.dirname(this.manifestPath);
     await fsp2.mkdir(dir, { recursive: true });
-    await fsp2.writeFile(this.manifestPath, JSON.stringify(data, null, 2) + "\n", "utf8");
+    await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2) + "\n");
     this.cache = data;
   }
   async addEntry(entry) {
@@ -13615,6 +14626,9 @@ async function collectFiles(dir, baseDir) {
   }
   return results;
 }
+
+// src/storage/session-rewinder.ts
+init_atomic_write();
 var DefaultSessionRewinder = class {
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
@@ -13748,7 +14762,7 @@ async function revertSnapshots(snapshots) {
       try {
         if (file.action === "deleted") {
           if (file.before !== null) {
-            await fsp2.writeFile(file.path, file.before, { mode: 420 });
+            await atomicWrite(file.path, file.before, { mode: 420 });
             revertedFiles.push(file.path);
           }
         } else if (file.action === "created") {
@@ -13756,7 +14770,7 @@ async function revertSnapshots(snapshots) {
           revertedFiles.push(file.path);
         } else if (file.action === "modified") {
           if (file.before !== null) {
-            await fsp2.writeFile(file.path, file.before, { mode: 420 });
+            await atomicWrite(file.path, file.before, { mode: 420 });
             revertedFiles.push(file.path);
           }
         }
@@ -14542,10 +15556,10 @@ var SecurityScanner = class {
     for (const pattern of patterns) {
       if (!this.matchesCategory(pattern)) continue;
       for (const regex of pattern.patterns) {
-        regex.lastIndex = 0;
         for (let lineNum = 0; lineNum < lines.length; lineNum++) {
           const line = lines[lineNum];
           if (!line) continue;
+          regex.lastIndex = 0;
           if (regex.test(line)) {
             if (this.isFalsePositive(line, pattern.falsePositiveMarkers)) {
               continue;
@@ -14607,6 +15621,9 @@ var SecurityScanner = class {
   }
 };
 var defaultSecurityScanner = new SecurityScanner();
+
+// src/security-scanner/report-generator.ts
+init_atomic_write();
 var DEFAULT_REPORT_OPTIONS = {
   outputDir: "security-reports",
   format: "markdown",
@@ -14634,7 +15651,7 @@ var ReportGenerator = class {
       default:
         content = this.generateMarkdown(scanResult);
     }
-    await writeFile(filepath, content, "utf-8");
+    await atomicWrite(filepath, content);
     return filepath;
   }
   async ensureOutputDir() {
@@ -14826,6 +15843,9 @@ var ReportGenerator = class {
   }
 };
 var defaultReportGenerator = new ReportGenerator();
+
+// src/security-scanner/gitignore-updater.ts
+init_atomic_write();
 var DEFAULT_OPTIONS2 = {
   gitignorePath: ".gitignore",
   entries: ["security-reports/", "security-reports/*"]
@@ -14852,12 +15872,12 @@ var GitignoreUpdater = class {
       }
       if (added.length > 0) {
         const newContent = [...lines].filter(Boolean).join("\n") + "\n";
-        await writeFile(this.options.gitignorePath, newContent, "utf-8");
+        await atomicWrite(this.options.gitignorePath, newContent);
       }
     } catch (err) {
       if (err.code === "ENOENT") {
         const content = this.options.entries.join("\n") + "\n";
-        await writeFile(this.options.gitignorePath, content, "utf-8");
+        await atomicWrite(this.options.gitignorePath, content);
         added.push(...this.options.entries);
       } else {
         errors.push(`Failed to update .gitignore: ${err}`);
@@ -14876,6 +15896,9 @@ var GitignoreUpdater = class {
   }
 };
 var defaultGitignoreUpdater = new GitignoreUpdater();
+
+// src/security-scanner/orchestrator.ts
+init_atomic_write();
 var NETWORK_ERR_RE2 = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 var SecurityScannerOrchestrator = class {
   constructor(retryPolicy, errorHandler) {
@@ -14921,7 +15944,7 @@ var SecurityScannerOrchestrator = class {
    */
   async run(ctx, options) {
     const { projectRoot, reportOptions, skipGitignore, model: explicitModel } = options;
-    const provider = "provider" in ctx ? ctx.provider : ctx;
+    const provider = "provider" in ctx && ctx.provider ? ctx.provider : ctx;
     const model = explicitModel ?? ("model" in ctx ? ctx.model : void 0);
     const detectionResult = await this.detector.detect(projectRoot);
     if (detectionResult.detectedStacks.length === 0) {
@@ -15260,7 +16283,7 @@ Be specific about the vulnerabilities found and how to fix them.`;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
     const filename = `security-report-${timestamp}.${format}`;
     const filepath = join(outputDir, filename);
-    await writeFile(filepath, content, "utf-8");
+    await atomicWrite(filepath, content);
     return filepath;
   }
   /**
@@ -15434,11 +16457,21 @@ Show a previous security report.
     }
   };
 }
+function getProviderFromContext(ctx) {
+  if (ctx.provider && typeof ctx.provider.complete === "function") {
+    return { provider: ctx.provider, model: ctx.model };
+  }
+  return null;
+}
 async function handleScan(args, ctx) {
   const options = parseArgs(args);
   const projectRoot = ctx.projectRoot || ctx.cwd || process.cwd();
   try {
-    const result = await defaultOrchestrator.run(ctx, {
+    const providerInfo = getProviderFromContext(ctx);
+    if (!providerInfo) {
+      return { message: "\u274C Security scan requires an active LLM provider. No provider configured." };
+    }
+    const result = await defaultOrchestrator.run(providerInfo, {
       projectRoot,
       scanOptions: {
         depth: options.depth || "standard",
@@ -15487,7 +16520,11 @@ async function handleScan(args, ctx) {
 async function handleAudit(ctx) {
   const projectRoot = ctx.projectRoot || ctx.cwd || process.cwd();
   try {
-    const result = await defaultOrchestrator.run(ctx, {
+    const providerInfo = getProviderFromContext(ctx);
+    if (!providerInfo) {
+      return { message: "\u274C Security audit requires an active LLM provider. No provider configured." };
+    }
+    const result = await defaultOrchestrator.run(providerInfo, {
       projectRoot,
       reportOptions: { format: "markdown" }
     });
@@ -15543,16 +16580,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = parseInt(reportId, 10) - 1;
     if (!isNaN(index) && reports[index]) {
-      const { readFile: readFile28 } = await import('fs/promises');
-      const content = await readFile28(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile30 } = await import('fs/promises');
+      const content = await readFile30(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile28 } = await import('fs/promises');
-      const content = await readFile28(join(reportsDir, match), "utf-8");
+      const { readFile: readFile30 } = await import('fs/promises');
+      const content = await readFile30(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -15602,6 +16639,9 @@ function getHelpMessage() {
 `;
 }
 var securitySlashCommand = createSecuritySlashCommand();
+
+// src/coordination/fleet-manager.ts
+init_atomic_write();
 var FleetManager = class {
   /** The fleet-wide event bus. */
   fleet;
@@ -15749,7 +16789,7 @@ var FleetManager = class {
       usage: this.usage.snapshot()
     };
     await fsp2.mkdir(path6.dirname(this.manifestPath), { recursive: true });
-    await fsp2.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
   /**
@@ -15769,7 +16809,13 @@ var FleetManager = class {
     if (this.manifestTimer) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
-      void this.writeManifest().catch(() => void 0);
+      void this.writeManifest().catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.emitWarning(
+          `FleetManager manifest write failed: ${detail}`,
+          "FleetManagerWarning"
+        );
+      });
     }, this.manifestDebounceMs);
   }
   /** Best-effort session event writer. Swallows failures. */
@@ -15798,6 +16844,226 @@ var FleetManager = class {
     return { pending, live: [] };
   }
 };
+function createMcpControlTool(opts) {
+  const { getConfig, configPath, registry } = opts;
+  const inputSchema = {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "search", "enable", "disable", "restart"],
+        description: "The management action to perform."
+      },
+      /** Filter for `search`. Matches server name or description case-insensitively. */
+      query: {
+        type: "string",
+        description: "Search term for `search` action. Matches server name or description."
+      },
+      /** Target server name for `enable`, `disable`, `restart`. */
+      server: {
+        type: "string",
+        description: 'Server name (e.g. "github", "filesystem", "brave-search").'
+      }
+    },
+    required: ["action"]
+  };
+  return {
+    name: "mcp_control",
+    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers.",
+    category: "mcp",
+    permission: "auto",
+    mutating: false,
+    riskTier: "standard",
+    inputSchema,
+    async execute(raw, ctx) {
+      const input = raw;
+      return mcpControlDispatch(input, { getConfig, configPath, registry });
+    }
+  };
+}
+async function mcpControlDispatch(input, deps) {
+  const { action, query, server } = input;
+  switch (action) {
+    case "list":
+      return renderList(deps);
+    case "search":
+      return renderSearch(query ?? "", deps);
+    case "enable":
+      return runEnable(server, deps);
+    case "disable":
+      return runDisable(server, deps);
+    case "restart":
+      return runRestart(server, deps);
+    default:
+      return `Unknown action "${action}". Use one of: list, search, enable, disable, restart.`;
+  }
+}
+function renderList(deps) {
+  const configured = deps.getConfig().mcpServers ?? {};
+  const live = deps.registry.describe();
+  if (Object.keys(configured).length === 0) {
+    return [
+      "No MCP servers configured.",
+      '  Use `mcp_control({ action: "search" })` to see available presets,',
+      '  then `mcp_control({ action: "enable", server: "<name>" })` to add one.'
+    ].join("\n");
+  }
+  const lines = [];
+  const liveMap = new Map(live.map((s) => [s.name, s]));
+  for (const [name, cfg] of Object.entries(configured)) {
+    const liveInfo = liveMap.get(name);
+    const toolCount = liveInfo ? ` (${liveInfo.toolCount} tools)` : "";
+    const stateStr = liveInfo ? badge(liveInfo.state) : dim("\u25CB not loaded");
+    const enabled = cfg.enabled === false ? `${dim("disabled")}  ` : `${green("\u25CF enabled")}  `;
+    lines.push(`  ${bold(name)}  ${enabled}${stateStr}${toolCount}`);
+    if (cfg.description) lines.push(`    ${dim(cfg.description)}`);
+  }
+  lines.push("");
+  lines.push(dim('  Use `mcp_control({ action: "search", query: "<keyword>" })` to find servers.'));
+  lines.push(dim('  Use `mcp_control({ action: "enable", server: "<name>" })` to start a server.'));
+  return lines.join("\n");
+}
+function renderSearch(query, deps) {
+  const configured = deps.getConfig().mcpServers ?? {};
+  const all = allServers();
+  const q = query.toLowerCase();
+  const configuredNames = new Set(Object.keys(configured));
+  const configuredEntries = Object.entries(configured).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const unconfiguredEntries = Object.entries(all).filter(([name]) => !configuredNames.has(name)).filter(
+    ([name, cfg]) => name.toLowerCase().includes(q) || (cfg.description ?? "").toLowerCase().includes(q)
+  );
+  const lines = [];
+  if (configuredEntries.length > 0) {
+    lines.push(bold('Configured servers matching "') + query + '":');
+    for (const [name, cfg] of configuredEntries) {
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}`);
+    }
+    lines.push("");
+  }
+  if (unconfiguredEntries.length > 0) {
+    lines.push(bold('Available presets matching "') + query + '":');
+    for (const [name, cfg] of unconfiguredEntries) {
+      const warn = cfg.permission === "deny" ? red(" \u26A0 confirm required") : "";
+      lines.push(`  ${bold(name)}  ${cfg.description ?? cfg.transport}${warn}`);
+    }
+    lines.push("");
+  }
+  if (configuredEntries.length === 0 && unconfiguredEntries.length === 0) {
+    return `No servers match "${query}". Try a shorter keyword or \`mcp_control({ action: "list" })\`.`;
+  }
+  const total = configuredEntries.length + unconfiguredEntries.length;
+  lines.push(dim(`  ${total} server${total !== 1 ? "s" : ""} shown. Run \`enable\` on one to activate it.`));
+  return lines.join("\n");
+}
+async function runEnable(name, deps) {
+  if (!name) return '`server` is required for enable. Example: { action: "enable", server: "github" }';
+  const all = allServers();
+  const configured = deps.getConfig().mcpServers ?? {};
+  const cfg = configured[name] ?? all[name];
+  if (!cfg) {
+    const known = Object.keys(all).join(", ");
+    return `Unknown server "${name}". Available presets: ${known}`;
+  }
+  const full = await readConfig(deps.configPath);
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
+  mcpServers[name] = { ...cfg, enabled: true };
+  full.mcpServers = mcpServers;
+  await writeConfig(deps.configPath, full);
+  try {
+    const live = deps.registry.describe().find((s) => s.name === name);
+    if (live && live.state === "connected") {
+      return `${green("\u25CF")} Server "${name}" is already running (${live.toolCount} tools registered).`;
+    }
+    await deps.registry.start({ ...cfg, enabled: true });
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `${green("\u2713 Enabled and started")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `${red("\u2717 Failed to start")} "${name}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function runDisable(name, deps) {
+  if (!name) return '`server` is required for disable. Example: { action: "disable", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not in config. Add it with \`mcp_control({ action: "enable", server: "${name}" })\`.`;
+  }
+  const full = await readConfig(deps.configPath);
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
+  const existing = mcpServers[name];
+  mcpServers[name] = { ...existing, enabled: false };
+  full.mcpServers = mcpServers;
+  await writeConfig(deps.configPath, full);
+  try {
+    await deps.registry.stop(name);
+    return `${yellow("\u25CB Disabled")} "${name}". It will not be started on next boot.`;
+  } catch {
+    return `${yellow("\u25CB Disabled")} "${name}" (it was not running). Config updated.`;
+  }
+}
+async function runRestart(name, deps) {
+  if (!name) return '`server` is required for restart. Example: { action: "restart", server: "github" }';
+  const configured = deps.getConfig().mcpServers ?? {};
+  if (!configured[name]) {
+    return `Server "${name}" is not configured. Use \`mcp_control({ action: "enable", server: "${name}" })\` first.`;
+  }
+  try {
+    await deps.registry.restart(name);
+    const updated = deps.registry.describe().find((s) => s.name === name);
+    return `${green("\u2713 Restarted")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+  } catch (err) {
+    return `${red("\u2717 Restart failed")} for "${name}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function readConfig(p) {
+  try {
+    return JSON.parse(await fsp2.readFile(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(p, cfg) {
+  const raw = JSON.stringify(cfg, null, 2);
+  const tmp = p + ".tmp";
+  await fsp2.writeFile(tmp, raw, "utf8");
+  await fsp2.rename(tmp, p);
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+function dim(s) {
+  return `\x1B[2m${s}\x1B[0m`;
+}
+function green(s) {
+  return `\x1B[32m${s}\x1B[0m`;
+}
+function yellow(s) {
+  return `\x1B[33m${s}\x1B[0m`;
+}
+function red(s) {
+  return `\x1B[31m${s}\x1B[0m`;
+}
+function badge(state) {
+  switch (state) {
+    case "connected":
+      return green("\u25CF connected");
+    case "connecting":
+      return `\x1B[36m\u25D0 connecting\x1B[0m`;
+    case "reconnecting":
+      return `\x1B[36m\u25D1 reconnecting\x1B[0m`;
+    case "disconnected":
+      return dim("\u25CB disconnected");
+    case "failed":
+      return red("\u2717 failed");
+    default:
+      return dim(state);
+  }
+}
 
 // src/extension/registry.ts
 var ExtensionRegistry = class {
@@ -15827,7 +17093,8 @@ var ExtensionRegistry = class {
    */
   async buildSystemPromptContributions(ctx) {
     const blocks = [];
-    for (const c of this.promptContributors) {
+    const snapshot = [...this.promptContributors];
+    for (const c of snapshot) {
       try {
         const contributed = await c(ctx);
         blocks.push(...contributed);
@@ -16149,16 +17416,7 @@ var Agent = class {
     this.tracer = init.tracer;
     this.extensions = init.extensions ?? new ExtensionRegistry();
     this.extensions.setLogger(this.container.resolve(TOKENS.Logger));
-    this.toolExecutor = new ToolExecutor(this.tools, {
-      permissionPolicy: init.permissionPolicy ?? this.permission,
-      secretScrubber: this.scrubber,
-      renderer: this.renderer,
-      events: this.events,
-      confirmAwaiter: init.confirmAwaiter,
-      iterationTimeoutMs: this.iterationTimeoutMs,
-      perIterationOutputCapBytes: this.perIterationOutputCapBytes,
-      tracer: this.tracer
-    });
+    this.toolExecutor = init.toolExecutor;
   }
   get logger() {
     return this.container.resolve(TOKENS.Logger);
@@ -16268,6 +17526,7 @@ var Agent = class {
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
     let recoveryRetries = 0;
+    const autonomousContinue = opts.autonomousContinue ?? this.autonomousContinue;
     const diRunner = this.container.has(TOKENS.ProviderRunner) ? this.container.resolve(TOKENS.ProviderRunner) : null;
     const baseRunner = diRunner ? (ctx, req) => diRunner.run({
       provider: ctx.provider,
@@ -16294,7 +17553,7 @@ var Agent = class {
       if (controller.signal.aborted) {
         return { status: "aborted", iterations };
       }
-      if (this.autonomousContinue) {
+      if (autonomousContinue) {
         consumeAutonomousContinue(this.ctx);
       }
       const limitCheck = await this.checkIterationLimit(
@@ -16373,18 +17632,18 @@ var Agent = class {
       const toolUses = res.content.filter(isToolUseBlock);
       if (toolUses.length === 0) {
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
-        if (this.autonomousContinue && responseResult.directive === "continue") {
+        if (autonomousContinue && responseResult.directive === "continue") {
           await this.compactContextIfNeeded();
           await this.extensions.runAfterIteration(this.ctx, i);
           continue;
         }
-        if (this.autonomousContinue && responseResult.directive === "stop") {
+        if (autonomousContinue && responseResult.directive === "stop") {
           return { status: "done", iterations, finalText };
         }
         return { status: "done", iterations, finalText };
       }
       await this.executeTools(toolUses);
-      if (this.autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+      if (autonomousContinue && consumeAutonomousContinue(this.ctx)) {
         this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
         await this.compactContextIfNeeded();
         await this.extensions.runAfterIteration(this.ctx, i);
@@ -16393,10 +17652,10 @@ var Agent = class {
       this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
       await this.compactContextIfNeeded();
       await this.extensions.runAfterIteration(this.ctx, i);
-      if (this.autonomousContinue && responseResult.directive === "continue") {
+      if (autonomousContinue && responseResult.directive === "continue") {
         continue;
       }
-      if (this.autonomousContinue && responseResult.directive === "stop") {
+      if (autonomousContinue && responseResult.directive === "stop") {
         return { status: "done", iterations, finalText };
       }
     }
@@ -16486,7 +17745,7 @@ var Agent = class {
       }
     }
     let directive = "none";
-    if (this.autonomousContinue && finalText) {
+    if (finalText) {
       directive = parseContinueDirective(finalText);
     }
     return { finalText, aborted: false, done: false, directive };
@@ -18082,6 +19341,6 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeContinueToNextIterationTool, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map