@wrongstack/core 0.5.7 → 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, 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 +3800,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 +3810,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 +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;
@@ -7190,6 +7268,452 @@ var AutonomousRunner = class {
   }
 };
 
+// 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 {
+      source: "brainstorm",
+      task: brainstormed,
+      directive: this.buildDirective(goal, "brainstorm", brainstormed)
+    };
+  }
+  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
 subagents by spawning them, assigning tasks, awaiting completions, and
@@ -8685,7 +9209,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(
@@ -8791,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);
   }
   /**
@@ -8982,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;
   }
   /**
@@ -9511,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;
@@ -9711,6 +10241,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 +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 {
     }
@@ -10626,6 +11158,9 @@ var SpecDrivenDev = class {
     }));
   }
 };
+
+// src/sdd/spec-store.ts
+init_atomic_write();
 var SpecStore = class {
   baseDir;
   indexPath;
@@ -10735,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,
@@ -11036,10 +11574,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 +11586,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 +11601,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 +12287,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 +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 path25 = opts.path ?? "/metrics";
+  const path26 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -12469,7 +13015,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 +13079,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 +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;
@@ -13284,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) {
@@ -13615,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;
@@ -13748,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") {
@@ -13756,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);
           }
         }
@@ -14542,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;
@@ -14607,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",
@@ -14634,7 +15189,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 +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/*"]
@@ -14852,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}`);
@@ -14876,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) {
@@ -14921,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) {
@@ -15260,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;
   }
   /**
@@ -15434,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",
@@ -15487,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" }
     });
@@ -15543,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}` };
@@ -15602,6 +16177,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 +16327,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 +16347,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. */
@@ -15827,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);
@@ -16149,16 +16734,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);
@@ -18082,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, 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, 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