@wrongstack/core 0.5.6 → 0.6.0

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 = {
@@ -3297,6 +3321,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 +3752,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 +3787,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path24, errors) {
+function walk2(value, schema, path26, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path24 || "<root>",
+        path: path26 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3768,7 +3800,7 @@ function walk2(value, schema, path24, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path24 || "<root>",
+        path: path26 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3778,19 +3810,19 @@ function walk2(value, schema, path24, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path24, 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(path24, 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, `${path24}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path26}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -3842,6 +3874,9 @@ function deepEqual(a, b) {
   }
   return false;
 }
+
+// src/storage/session-store.ts
+init_atomic_write();
 var DefaultSessionStore = class {
   dir;
   events;
@@ -3885,19 +3920,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 +3984,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 +4212,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 +4308,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 +4361,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 +4385,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 +4486,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 +4501,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 +4517,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 +4536,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 +5032,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 +5255,9 @@ var SessionAnalyzer = class {
     return last - first;
   }
 };
+
+// src/storage/todos-checkpoint.ts
+init_atomic_write();
 async function loadTodosCheckpoint(filePath) {
   let raw;
   try {
@@ -5257,6 +5326,9 @@ function attachTodosCheckpoint(state, filePath, sessionId) {
     }
   };
 }
+
+// src/storage/plan-store.ts
+init_atomic_write();
 async function loadPlan(filePath) {
   let raw;
   try {
@@ -5491,6 +5563,9 @@ ${cat}:`);
   }
   return lines.join("\n");
 }
+
+// src/storage/director-state.ts
+init_atomic_write();
 async function loadDirectorState(filePath) {
   let raw;
   try {
@@ -5669,6 +5744,9 @@ var DirectorStateCheckpoint = class {
     }
   }
 };
+
+// src/security/permission-policy.ts
+init_atomic_write();
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -7070,6 +7148,14 @@ var DoneConditionChecker = class {
           };
         }
         break;
+      case "directive":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return { done: true, reason: `max iterations (${this.condition.maxIterations}) reached`, ...state };
+        }
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
+        }
+        break;
     }
     return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
   }
@@ -7089,10 +7175,16 @@ var AutonomousRunner = class {
     const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
       this.toolCalls++;
     });
+    const offIterationCompleted = this.opts.agent.events?.on?.("iteration.completed", () => {
+      if (this.opts.enableAutonomousContinue && this.opts.doneCondition.type === "directive") {
+        this.iterations++;
+      }
+    });
     try {
       return await this.runLoop();
     } finally {
       offToolExecuted?.();
+      offIterationCompleted?.();
     }
   }
   async runLoop() {
@@ -7116,12 +7208,14 @@ var AutonomousRunner = class {
       const ctrl = new AbortController();
       const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
       try {
+        const isDirectiveMode = this.opts.doneCondition.type === "directive" && this.opts.enableAutonomousContinue;
         const result = await this.opts.agent.run("", {
           signal: ctrl.signal,
-          maxIterations: 1,
-          executionStrategy: "sequential"
+          maxIterations: isDirectiveMode ? this.opts.doneCondition.maxIterations ?? 100 : 1,
+          executionStrategy: "sequential",
+          autonomousContinue: isDirectiveMode ? true : void 0
         });
-        this.iterations++;
+        if (!isDirectiveMode) this.iterations++;
         if (result.status === "done") {
           this.lastOutput = result.finalText;
         }
@@ -7156,23 +7250,469 @@ var AutonomousRunner = class {
           toolCalls: this.toolCalls,
           reason: e instanceof Error ? e.message : String(e)
         };
-        this.opts.onDone?.(failedResult);
-        return failedResult;
-      } finally {
-        clearTimeout(timeout);
+        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",
+    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(`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 EternalAutonomyEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.goalPath = goalFilePath(opts.projectRoot);
+  }
+  opts;
+  state = "idle";
+  stopRequested = false;
+  consecutiveFailures = 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 action = await this.decide(goal);
+    if (!action) {
+      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;
+    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 }
+      );
+      if (result.status === "aborted") {
+        status = "aborted";
+        note = "stopped by user";
+      } else if (result.status === "failed") {
+        status = "failure";
+        note = result.error?.describe?.() ?? "agent run failed";
+      } else if (result.status === "max_iterations") {
+        status = "failure";
+        note = `max iterations (${result.iterations})`;
+      } else {
+        status = "success";
+        const tail = (result.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);
+    } finally {
+      clearTimeout(timer);
+      this.currentCtrl = null;
+    }
+    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") {
+      this.consecutiveFailures++;
+      return false;
+    }
+    if (status === "aborted") {
+      if (this.stopRequested) return false;
+      this.consecutiveFailures++;
+      return false;
+    }
+    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();
+      if (todo) {
+        return {
+          source: "todo",
+          task: todo.content,
+          directive: this.buildDirective(goal, "todo", todo.content)
+        };
+      }
+      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) return null;
     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() {
+    const todos = this.opts.agent.ctx.todos;
+    if (!Array.isArray(todos)) return null;
+    return todos.find((t2) => t2.status === "pending") ?? 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, output exactly: 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 || text === "DONE") return null;
+        const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
+        if (!firstLine) return null;
+        return firstLine.slice(0, 240);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return null;
+    }
+  }
+  buildDirective(goal, source, task) {
+    return [
+      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "",
+      `Goal: ${goal.goal}`,
+      `Source: ${source}`,
+      `Task: ${task}`,
+      "",
+      "Execute this task end-to-end using the tools available to you. Make the",
+      "changes, run tests if relevant, and commit / push as appropriate. Do not",
+      "ask for confirmation \u2014 YOLO mode is active. When the task is done, stop;",
+      "the loop will pick the next action."
+    ].join("\n");
+  }
+  async appendIterationEntry(entry) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) {
+      return;
+    }
+    const updated = appendJournal(current, entry);
+    await saveGoal(this.goalPath, updated);
+  }
+  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/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
@@ -8318,10 +8858,10 @@ function makeSpawnTool(director, roster) {
         const subagentId = await director.spawn(cfg);
         return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
       } catch (err) {
-        if (err instanceof DirectorBudgetError) {
+        if (err instanceof FleetSpawnBudgetError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
-        if (err instanceof DirectorCostCapError) {
+        if (err instanceof FleetCostCapError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
         return { error: err instanceof Error ? err.message : String(err) };
@@ -8522,7 +9062,7 @@ function makeFleetHealthTool(director) {
 }
 
 // src/coordination/director.ts
-var DirectorBudgetError = class extends Error {
+var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
@@ -8530,13 +9070,13 @@ var DirectorBudgetError = class extends Error {
     super(
       kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
     );
-    this.name = "DirectorBudgetError";
+    this.name = "FleetSpawnBudgetError";
     this.kind = kind;
     this.limit = limit;
     this.observed = observed;
   }
 };
-var DirectorCostCapError = class extends Error {
+var FleetCostCapError = class extends Error {
   kind;
   limit;
   observed;
@@ -8544,16 +9084,34 @@ var DirectorCostCapError = class extends Error {
     super(
       `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
     );
-    this.name = "DirectorCostCapError";
+    this.name = "FleetCostCapError";
     this.kind = "max_cost_usd";
     this.limit = limit;
     this.observed = observed;
   }
 };
 var Director = class {
+  /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
+  get coordinatorId() {
+    return this.id;
+  }
   id;
+  /**
+   * The fleet event bus. Backed by `fleetManager?.fleet` when a FleetManager
+   * is injected; otherwise own FleetBus instance (preserves existing behavior).
+   */
   fleet;
+  /**
+   * Usage rollup. Backed by `fleetManager?.usage` when a FleetManager is
+   * injected; otherwise own FleetUsageAggregator.
+   */
   usage;
+  /**
+   * Optional fleet-level policy container. When provided the Director
+   * delegates spawn budgeting, manifest entries, and checkpointing to it
+   * instead of managing those internally. All other behavior is unchanged.
+   */
+  fleetManager;
   /**
    * Director-side bridge endpoint. Subagents are wired to the same
    * in-memory transport so the director can `ask()` them synchronously
@@ -8604,8 +9162,8 @@ var Director = class {
   /** Debounce timer for periodic manifest writes. */
   manifestTimer = null;
   manifestDebounceMs;
-  /** Fleet-wide cost cap. Infinity means no cap. */
-  maxCostUsd;
+  /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
+  maxFleetCostUsd;
   /** Max auto-extensions per subagent per budget kind before denying. */
   maxBudgetExtensions;
   /** Sessions root for direct subagent JSONL reads (fleet_session tool). */
@@ -8638,7 +9196,7 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
-    this.maxCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
@@ -8649,20 +9207,28 @@ var Director = class {
       maxSpawnDepth: this.maxSpawnDepth,
       directorBudget: opts.directorBudget
     }, 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(
       { agentId: this.id, coordinatorId: this.id },
       this.transport
     );
-    this.fleet = new FleetBus();
-    this.usage = new FleetUsageAggregator(
-      this.fleet,
-      (id) => this.priceLookups.get(id),
-      (id) => this.subagentMeta.get(id)
-    );
+    if (this.fleetManager) {
+      this.fleet = this.fleetManager.fleet;
+      this.usage = this.fleetManager.usage;
+    } else {
+      this.fleet = new FleetBus();
+      this.usage = new FleetUsageAggregator(
+        this.fleet,
+        (id) => this.priceLookups.get(id),
+        (id) => this.subagentMeta.get(id)
+      );
+    }
     this.coordinator = new DefaultMultiAgentCoordinator(
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
@@ -8751,7 +9317,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);
   }
   /**
@@ -8764,58 +9332,73 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
-    if (this.spawnDepth >= this.maxSpawnDepth) {
-      throw new DirectorBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
-    }
-    if (this.spawnCount >= this.maxSpawns) {
-      throw new DirectorBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
-    }
-    if (this.maxCostUsd < Number.POSITIVE_INFINITY) {
-      const totalCost = this.usage.snapshot().total?.cost ?? 0;
-      if (totalCost >= this.maxCostUsd) {
-        throw new DirectorCostCapError(this.maxCostUsd, totalCost);
+    if (this.fleetManager) {
+      const rejection = this.fleetManager.canSpawn(config);
+      if (rejection) {
+        if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+      }
+    } else {
+      if (this.spawnDepth >= this.maxSpawnDepth) {
+        throw new FleetSpawnBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
+      }
+      if (this.spawnCount >= this.maxSpawns) {
+        throw new FleetSpawnBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+      }
+      if (this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+        const totalCost = this.usage.snapshot().total?.cost ?? 0;
+        if (totalCost >= this.maxFleetCostUsd) {
+          throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
+        }
       }
     }
     const result = await this.coordinator.spawn(config);
-    this.spawnCount += 1;
-    this.subagentMeta.set(result.subagentId, {
-      provider: config.provider,
-      model: config.model
-    });
-    if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    if (this.fleetManager) {
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+    } else {
+      this.spawnCount += 1;
+      this.subagentMeta.set(result.subagentId, {
+        provider: config.provider,
+        model: config.model
+      });
+      if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    }
     const subagentBridge = new InMemoryAgentBridge(
       { agentId: result.subagentId, coordinatorId: this.id },
       this.transport
     );
     this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
     this.subagentBridges.set(result.subagentId, subagentBridge);
-    this.manifestEntries.set(result.subagentId, {
-      subagentId: result.subagentId,
-      name: config.name,
-      role: config.role,
-      provider: config.provider,
-      model: config.model,
-      taskIds: []
-    });
-    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.stateCheckpoint?.recordSpawn(
-      {
-        id: result.subagentId,
+    if (!this.fleetManager) {
+      this.manifestEntries.set(result.subagentId, {
+        subagentId: result.subagentId,
         name: config.name,
         role: config.role,
         provider: config.provider,
         model: config.model,
-        spawnedAt
-      },
-      this.spawnCount
-    );
-    void this.appendSessionEvent({
-      type: "agent_spawned",
-      ts: spawnedAt,
-      agentId: result.subagentId,
-      role: config.role ?? config.name
-    });
-    this.scheduleManifest();
+        taskIds: []
+      });
+      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stateCheckpoint?.recordSpawn(
+        {
+          id: result.subagentId,
+          name: config.name,
+          role: config.role,
+          provider: config.provider,
+          model: config.model,
+          spawnedAt
+        },
+        this.spawnCount
+      );
+      void this.appendSessionEvent({
+        type: "agent_spawned",
+        ts: spawnedAt,
+        agentId: result.subagentId,
+        role: config.role ?? config.name
+      });
+      this.scheduleManifest();
+    }
     return result.subagentId;
   }
   /**
@@ -8927,7 +9510,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;
   }
   /**
@@ -8982,8 +9565,12 @@ var Director = class {
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
     if (task.subagentId) {
-      const entry = this.manifestEntries.get(task.subagentId);
-      if (entry) entry.taskIds.push(taskWithId.id);
+      if (this.fleetManager) {
+        this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
+      } else {
+        const entry = this.manifestEntries.get(task.subagentId);
+        if (entry) entry.taskIds.push(taskWithId.id);
+      }
     }
     await this.coordinator.assign(taskWithId);
     this.taskDescriptions.set(taskWithId.id, taskWithId.description);
@@ -9181,8 +9768,9 @@ var Director = class {
    * still permission-checked normally.
    */
   tools(roster) {
+    const effectiveRoster = roster ?? this.roster;
     const t2 = [
-      makeSpawnTool(this, roster),
+      makeSpawnTool(this, effectiveRoster),
       makeAssignTool(this),
       makeAwaitTasksTool(this),
       makeAskTool(this),
@@ -9451,9 +10039,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;
@@ -9648,6 +10238,12 @@ 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;
@@ -9706,10 +10302,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 {
     }
@@ -10563,6 +11158,9 @@ var SpecDrivenDev = class {
     }));
   }
 };
+
+// src/sdd/spec-store.ts
+init_atomic_write();
 var SpecStore = class {
   baseDir;
   indexPath;
@@ -10672,6 +11270,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,
@@ -10973,10 +11574,11 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp14 = await import('fs/promises');
-      const path24 = await import('path');
-      await fsp14.mkdir(path24.dirname(this.sessionPath), { recursive: true });
-      await fsp14.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 {
     }
   }
@@ -10984,8 +11586,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp14 = await import('fs/promises');
-      const raw = await fsp14.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;
@@ -10999,14 +11601,21 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp14 = await import('fs/promises');
-      await fsp14.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 ─────────────────────────────────────────────────────
@@ -11678,15 +12287,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path24 = [];
+  const path26 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path24.unshift(current);
+    path26.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path24;
+  return path26;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -12396,7 +13005,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path24 = opts.path ?? "/metrics";
+  const path26 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -12406,7 +13015,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path24) {
+    if (url === path26) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -12470,7 +13079,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path24}`,
+    url: `${protocol}://${host}:${boundPort}${path26}`,
     close: () => new Promise((resolve5, reject) => {
       server.close((err) => err ? reject(err) : resolve5());
     })
@@ -13197,6 +13806,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;
@@ -13221,7 +13833,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) {
@@ -13552,6 +14164,9 @@ async function collectFiles(dir, baseDir) {
   }
   return results;
 }
+
+// src/storage/session-rewinder.ts
+init_atomic_write();
 var DefaultSessionRewinder = class {
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
@@ -13685,7 +14300,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") {
@@ -13693,7 +14308,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);
           }
         }
@@ -14479,10 +15094,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;
@@ -14544,6 +15159,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",
@@ -14571,15 +15189,15 @@ var ReportGenerator = class {
       default:
         content = this.generateMarkdown(scanResult);
     }
-    await writeFile(filepath, content, "utf-8");
+    await atomicWrite(filepath, content);
     return filepath;
   }
   async ensureOutputDir() {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir10 } = await import('fs/promises');
-      await mkdir10(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir11 } = await import('fs/promises');
+      await mkdir11(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -14763,6 +15381,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/*"]
@@ -14789,12 +15410,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}`);
@@ -14813,6 +15434,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) {
@@ -14858,7 +15482,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) {
@@ -15197,7 +15821,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;
   }
   /**
@@ -15371,11 +15995,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",
@@ -15424,7 +16058,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" }
     });
@@ -15480,16 +16118,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: readFile29 } = await import('fs/promises');
+      const content = await readFile29(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: readFile29 } = await import('fs/promises');
+      const content = await readFile29(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -15540,6 +16178,211 @@ function getHelpMessage() {
 }
 var securitySlashCommand = createSecuritySlashCommand();
 
+// src/coordination/fleet-manager.ts
+init_atomic_write();
+var FleetManager = class {
+  /** The fleet-wide event bus. */
+  fleet;
+  /** Usage rollup across all subagents. */
+  usage;
+  manifestPath;
+  sessionsRoot;
+  directorRunId;
+  /** Spawn cap (lifetime total). Infinity means unlimited. */
+  maxSpawns;
+  /** Nesting cap. */
+  maxSpawnDepth;
+  /** This director's depth in a director chain. Root = 0. */
+  spawnDepth;
+  /** Live spawn counter. */
+  spawnCount = 0;
+  stateCheckpoint;
+  sessionWriter;
+  manifestTimer = null;
+  manifestDebounceMs;
+  /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
+   *  which track per-subagent spend — this field caps the entire fleet total. */
+  maxFleetCostUsd;
+  manifestEntries = /* @__PURE__ */ new Map();
+  /** Pending tasks with their descriptions — populated by `addPendingTask`
+   *  and cleared by `removePendingTask`. Replaces the host-side `pending`
+   *  Map so task descriptions live in one place (FleetManager). */
+  pendingTasks = /* @__PURE__ */ new Map();
+  subagentMeta = /* @__PURE__ */ new Map();
+  priceLookups = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.manifestPath = opts.manifestPath;
+    this.sessionsRoot = opts.sessionsRoot;
+    this.directorRunId = opts.directorRunId ?? randomUUID();
+    this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
+    this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
+    this.spawnDepth = opts.spawnDepth ?? 0;
+    this.sessionWriter = opts.sessionWriter ?? null;
+    this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
+      opts.stateCheckpointPath,
+      {
+        directorRunId: this.directorRunId,
+        maxSpawns: opts.maxSpawns,
+        spawnDepth: this.spawnDepth,
+        maxSpawnDepth: this.maxSpawnDepth,
+        directorBudget: opts.directorBudget
+      },
+      opts.checkpointDebounceMs ?? 250
+    ) : null;
+    this.fleet = new FleetBus();
+    this.usage = new FleetUsageAggregator(
+      this.fleet,
+      (id) => this.priceLookups.get(id),
+      (id) => this.subagentMeta.get(id)
+    );
+  }
+  // -----------------------------------------------------------------------
+  // IFleetManager surface
+  // -----------------------------------------------------------------------
+  get fleetBus() {
+    return this.fleet;
+  }
+  snapshot() {
+    return this.usage.snapshot();
+  }
+  getSubagentMeta(id) {
+    return this.subagentMeta.get(id);
+  }
+  /**
+   * Returns null if the spawn is allowed, or an object describing
+   * which cap was exceeded. Does NOT throw — the caller decides
+   * how to surface the rejection.
+   */
+  canSpawn(config) {
+    if (this.spawnDepth >= this.maxSpawnDepth) {
+      return { kind: "max_spawn_depth", limit: this.maxSpawnDepth, observed: this.spawnDepth };
+    }
+    if (this.spawnCount >= this.maxSpawns) {
+      return { kind: "max_spawns", limit: this.maxSpawns, observed: this.spawnCount + 1 };
+    }
+    if (this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+      const totalCost = this.usage.snapshot().total?.cost ?? 0;
+      if (totalCost >= this.maxFleetCostUsd) {
+        return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
+      }
+    }
+    return null;
+  }
+  /**
+   * Records a spawn: increments counter, stores metadata, updates state checkpoint,
+   * and schedules a debounced manifest write. Call AFTER the coordinator
+   * has successfully spawned the subagent.
+   *
+   * @param subagentId The subagent's id (from coordinator.spawn result)
+   * @param config The SubagentConfig that was used
+   * @param priceLookup Optional per-subagent pricing data
+   */
+  recordSpawn(subagentId, config, priceLookup) {
+    this.spawnCount += 1;
+    this.subagentMeta.set(subagentId, {
+      provider: config.provider,
+      model: config.model
+    });
+    if (priceLookup) this.priceLookups.set(subagentId, priceLookup);
+    this.manifestEntries.set(subagentId, {
+      subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      taskIds: []
+    });
+    this.stateCheckpoint?.recordSpawn({
+      id: subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, this.spawnCount);
+    void this.appendSessionEvent({
+      type: "agent_spawned",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: subagentId,
+      role: config.role ?? config.name
+    });
+    this.scheduleManifest();
+  }
+  async writeManifest() {
+    if (!this.manifestPath) return null;
+    const manifest = {
+      version: 1,
+      directorRunId: this.directorRunId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      children: Array.from(this.manifestEntries.values()).map((entry) => ({
+        id: entry.subagentId,
+        name: entry.name,
+        role: entry.role,
+        provider: entry.provider,
+        model: entry.model,
+        taskIds: entry.taskIds
+      })),
+      usage: this.usage.snapshot()
+    };
+    await fsp2.mkdir(path6.dirname(this.manifestPath), { recursive: true });
+    await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    return this.manifestPath;
+  }
+  /**
+   * Attach task ids to an already-spawned subagent. Called by
+   * `Director.assign()` after the coordinator assigns a task.
+   */
+  addTaskToSubagent(subagentId, taskId) {
+    const entry = this.manifestEntries.get(subagentId);
+    if (entry) entry.taskIds.push(taskId);
+  }
+  /**
+   * Debounced manifest write. Call after any state mutation
+   * (spawn, assign, complete) so a burst collapses into one write.
+   */
+  scheduleManifest() {
+    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
+    if (this.manifestTimer) return;
+    this.manifestTimer = setTimeout(() => {
+      this.manifestTimer = null;
+      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. */
+  async appendSessionEvent(event) {
+    if (!this.sessionWriter) return;
+    try {
+      await this.sessionWriter.append(event);
+    } catch {
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Pending task management — eliminates host-side state duplication
+  // -----------------------------------------------------------------------
+  addPendingTask(taskId, subagentId, description) {
+    this.pendingTasks.set(taskId, { subagentId, description });
+  }
+  removePendingTask(taskId) {
+    this.pendingTasks.delete(taskId);
+  }
+  getFleetStatus() {
+    const pending = Array.from(this.pendingTasks.entries()).map(([taskId, v]) => ({
+      taskId,
+      description: v.description,
+      subagentId: v.subagentId
+    }));
+    return { pending, live: [] };
+  }
+};
+
 // src/extension/registry.ts
 var ExtensionRegistry = class {
   extensions = [];
@@ -15568,7 +16411,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);
@@ -15748,6 +16592,50 @@ var ExtensionRegistry = class {
   }
 };
 
+// src/core/continue-to-next-iteration.ts
+function parseContinueDirective(text) {
+  const LINE_MARKERS = /^\s*\[(continue|next step|proceed|done)\]\s*$/gim;
+  let match;
+  let lastDirective = "none";
+  while ((match = LINE_MARKERS.exec(text)) !== null) {
+    const value = (match[1] ?? "").toLowerCase();
+    if (value === "continue" || value === "next step" || value === "proceed") {
+      lastDirective = "continue";
+    } else if (value === "done") {
+      lastDirective = "stop";
+    }
+  }
+  return lastDirective;
+}
+var META_KEY = "_autonomousContinue";
+function setAutonomousContinue(ctx) {
+  ctx.meta[META_KEY] = true;
+}
+function consumeAutonomousContinue(ctx) {
+  const val = ctx.meta[META_KEY] === true;
+  delete ctx.meta[META_KEY];
+  return val;
+}
+function makeContinueToNextIterationTool() {
+  const inputSchema = {
+    type: "object",
+    properties: {},
+    required: [],
+    description: "Signal that the agent should continue to the next iteration immediately, without waiting for user input. Use this when you have completed a step and want to proceed automatically to the next step in your plan."
+  };
+  return {
+    name: "continue_to_next_iteration",
+    description: "Continue to the next iteration without returning to the user. Call this when you have finished a step and want to keep working autonomously.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(_input, ctx) {
+      setAutonomousContinue(ctx);
+      return { continue: true };
+    }
+  };
+}
+
 // src/core/iteration-limit.ts
 function requestLimitExtension(opts) {
   const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
@@ -15826,6 +16714,8 @@ var Agent = class {
   plugins = [];
   toolExecutor;
   autoExtendLimit;
+  /** Enables autonomous continue: model can signal `[continue]` or call continue_to_next_iteration() to re-run. */
+  autonomousContinue;
   tracer;
   extensions;
   constructor(init) {
@@ -15840,19 +16730,11 @@ var Agent = class {
     this.executionStrategy = init.executionStrategy ?? "smart";
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
+    this.autonomousContinue = init.autonomousContinue ?? false;
     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);
@@ -15988,6 +16870,9 @@ var Agent = class {
       if (controller.signal.aborted) {
         return { status: "aborted", iterations };
       }
+      if (this.autonomousContinue) {
+        consumeAutonomousContinue(this.ctx);
+      }
       const limitCheck = await this.checkIterationLimit(
         i,
         effectiveLimit,
@@ -16064,12 +16949,32 @@ 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") {
+          await this.compactContextIfNeeded();
+          await this.extensions.runAfterIteration(this.ctx, i);
+          continue;
+        }
+        if (this.autonomousContinue && responseResult.directive === "stop") {
+          return { status: "done", iterations, finalText };
+        }
         return { status: "done", iterations, finalText };
       }
       await this.executeTools(toolUses);
+      if (this.autonomousContinue && consumeAutonomousContinue(this.ctx)) {
+        this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
+        await this.compactContextIfNeeded();
+        await this.extensions.runAfterIteration(this.ctx, i);
+        continue;
+      }
       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") {
+        continue;
+      }
+      if (this.autonomousContinue && responseResult.directive === "stop") {
+        return { status: "done", iterations, finalText };
+      }
     }
   }
   /**
@@ -16156,7 +17061,11 @@ var Agent = class {
         if (!streamed) this.renderer?.write(rendered);
       }
     }
-    return { finalText, aborted: false, done: false };
+    let directive = "none";
+    if (this.autonomousContinue && finalText) {
+      directive = parseContinueDirective(finalText);
+    }
+    return { finalText, aborted: false, done: false, directive };
   }
   /**
    * Execute tools and append tool results to context.
@@ -17749,6 +18658,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, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, 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, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, 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, 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, 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, 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