@wrongstack/core 0.291.0 → 0.291.1

package/dist/storage/index.js

@@ -2,14 +2,14 @@
 import { createHash as createHash4 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import * as fsp4 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { createInterface } from "node:readline";
 
 // src/utils/atomic-write.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import { watch as watchDir } from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -186,6 +186,37 @@ var color = {
   bgGreen: wrap("42", "49")
 };
 
+// src/utils/config-backup.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function configHistoryDir(globalRoot) {
+  return path.join(globalRoot, "config-history");
+}
+function configSlug(absolutePath, globalRoot) {
+  const rel = path.relative(globalRoot, absolutePath);
+  const normalized = rel.replace(/\\/g, "/").replace(/\.json$/i, "");
+  return normalized.replace(/\//g, "-");
+}
+async function backupConfigFile(filePath, paths) {
+  let currentContent;
+  try {
+    currentContent = await fs.readFile(filePath, "utf8");
+    if (!currentContent.trim()) return;
+  } catch {
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  const slug = configSlug(filePath, paths.globalRoot);
+  const backupDir = configHistoryDir(paths.globalRoot);
+  const backupFile = path.join(backupDir, `${slug}-${ts}.json`);
+  try {
+    await fs.mkdir(backupDir, { recursive: true });
+    await fs.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
+  } catch {
+  }
+}
+
 // src/utils/deep-merge.ts
 var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
   "__proto__",
@@ -261,16 +292,6 @@ function expectDefined(value, label) {
 }
 
 // src/utils/message-invariants.ts
-function hasMeaningfulContent(content) {
-  if (typeof content === "string") return content.trim().length > 0;
-  return content.some((block) => {
-    if (block.type === "text") return block.text.trim().length > 0;
-    if (block.type === "thinking") {
-      return block.thinking.trim().length > 0 || Boolean(block.signature);
-    }
-    return true;
-  });
-}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -357,6 +378,21 @@ function mapContent(msg, fn) {
   }
   return { ...msg, content: next };
 }
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  for (const block of content) {
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
 function isEmptyMessage(msg) {
   return !hasMeaningfulContent(msg.content);
 }
@@ -413,14 +449,14 @@ function safeParse(input, maxBytes = 5e6) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path from "node:path";
+import * as path2 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path.relative(path.resolve(dir), resolved);
-  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+  const resolved = path2.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path2.relative(path2.resolve(dir), resolved);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -469,23 +505,23 @@ function ulid(seedTime = Date.now()) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function canonicalProjectRoot(absRoot) {
-  const checkoutRoot = path2.resolve(absRoot);
-  const dotGit = path2.join(checkoutRoot, ".git");
+  const checkoutRoot = path3.resolve(absRoot);
+  const dotGit = path3.join(checkoutRoot, ".git");
   try {
-    if (!fs.statSync(dotGit).isFile()) return checkoutRoot;
-    const gitDirLine = fs.readFileSync(dotGit, "utf8").trim();
+    if (!fs2.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs2.readFileSync(dotGit, "utf8").trim();
     const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
     if (!match?.[1]) return checkoutRoot;
-    const gitDir = path2.resolve(checkoutRoot, match[1].trim());
-    const commonDirFile = path2.join(gitDir, "commondir");
-    if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
-    const commonDir = path2.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
-    if (path2.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
-    return path2.dirname(commonDir);
+    const gitDir = path3.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path3.join(gitDir, "commondir");
+    if (!fs2.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path3.resolve(gitDir, fs2.readFileSync(commonDirFile, "utf8").trim());
+    if (path3.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path3.dirname(commonDir);
   } catch {
     return checkoutRoot;
   }
@@ -495,7 +531,7 @@ function projectHash(absRoot) {
 }
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
-  const base = slugify2(path2.basename(identityRoot));
+  const base = slugify2(path3.basename(identityRoot));
   const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
@@ -504,66 +540,83 @@ function slugify2(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv);
-  return path2.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
+  return path3.join(os.homedir(), ".wrongstack");
 }
 function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
-  const projectDir = path2.join(globalRoot, "projects", slug);
+  const projectDir = path3.join(globalRoot, "projects", slug);
   return {
     globalRoot,
     projectRoot: opts.projectRoot,
     homeDir,
     configDir: globalRoot,
-    globalConfig: path2.join(globalRoot, "config.json"),
-    profilesDir: path2.join(globalRoot, "profiles"),
+    globalConfig: path3.join(globalRoot, "config.json"),
+    profilesDir: path3.join(globalRoot, "profiles"),
     profileConfig: (name) => {
       const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
-      return path2.join(globalRoot, "profiles", safe || "default", "config.json");
+      return path3.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
+    profileStatuslineConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path3.join(globalRoot, "profiles", safe || "default", "statusline.json");
+    },
+    profileModeConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path3.join(globalRoot, "profiles", safe || "default", "mode.json");
+    },
+    profileProviderStatus: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path3.join(globalRoot, "profiles", safe || "default", "provider-status.json");
+    },
+    profileUpdateCache: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path3.join(globalRoot, "profiles", safe || "default", "update-cache.json");
     },
-    secretsKey: path2.join(globalRoot, ".key"),
-    globalMemory: path2.join(globalRoot, "memory.md"),
-    globalSkills: path2.join(globalRoot, "skills"),
-    globalClaudeSkills: path2.join(homeDir, ".claude", "skills"),
-    globalDesignKits: path2.join(globalRoot, "design-kits"),
-    globalPrompts: path2.join(globalRoot, "prompts"),
-    globalInstructions: path2.join(globalRoot, "instructions"),
-    promptUsage: path2.join(globalRoot, "prompt-usage.json"),
-    cacheDir: path2.join(globalRoot, "cache"),
-    modelsCache: path2.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path2.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path2.join(globalRoot, "history"),
-    logFile: path2.join(globalRoot, "logs", "wrongstack.log"),
+    secretsKey: path3.join(globalRoot, ".key"),
+    globalMemory: path3.join(globalRoot, "memory.md"),
+    globalSkills: path3.join(globalRoot, "skills"),
+    globalClaudeSkills: path3.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path3.join(globalRoot, "design-kits"),
+    globalPrompts: path3.join(globalRoot, "prompts"),
+    globalInstructions: path3.join(globalRoot, "instructions"),
+    promptUsage: path3.join(globalRoot, "prompt-usage.json"),
+    cacheDir: path3.join(globalRoot, "cache"),
+    modelsCache: path3.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path3.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path3.join(globalRoot, "history"),
+    logFile: path3.join(globalRoot, "logs", "wrongstack.log"),
     projectDir,
-    projectCodebaseIndex: path2.join(projectDir, "codebase-index"),
-    projectMemory: path2.join(projectDir, "memory.md"),
-    projectSessions: path2.join(projectDir, "sessions"),
-    projectTrust: path2.join(projectDir, "trust.json"),
-    projectMeta: path2.join(projectDir, "meta.json"),
-    projectLocalConfig: path2.join(projectDir, "config.local.json"),
-    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectClaudeSkills: path2.join(opts.projectRoot, ".claude", "skills"),
-    inProjectPrompts: path2.join(opts.projectRoot, ".wrongstack", "prompts"),
-    inProjectInstructions: path2.join(opts.projectRoot, ".wrongstack", "instructions"),
-    inProjectDesignKits: path2.join(opts.projectRoot, ".wrongstack", "design-kits"),
-    inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectCodebaseIndex: path3.join(projectDir, "codebase-index"),
+    projectMemory: path3.join(projectDir, "memory.md"),
+    projectSessions: path3.join(projectDir, "sessions"),
+    projectTrust: path3.join(projectDir, "trust.json"),
+    projectMeta: path3.join(projectDir, "meta.json"),
+    projectLocalConfig: path3.join(projectDir, "config.local.json"),
+    inProjectConfig: path3.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path3.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path3.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path3.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path3.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path3.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path3.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path3.join(opts.projectRoot, ".wrongstack", "worktrees"),
     projectHash: hash,
     projectSlug: slug,
-    projectGoal: path2.join(projectDir, "goal.json"),
-    projectInputHistory: path2.join(projectDir, "input-history.json"),
-    projectSpecs: path2.join(projectDir, "specs"),
-    projectTaskGraphs: path2.join(projectDir, "task-graphs"),
-    projectSddSession: path2.join(projectDir, "sdd-session.json"),
-    projectPlan: path2.join(projectDir, "plan.json"),
-    projectAutophase: path2.join(projectDir, "autophase"),
-    projectSddBoards: path2.join(projectDir, "sdd-boards"),
-    syncConfig: path2.join(globalRoot, "sync.json"),
-    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
+    projectGoal: path3.join(projectDir, "goal.json"),
+    projectInputHistory: path3.join(projectDir, "input-history.json"),
+    projectSpecs: path3.join(projectDir, "specs"),
+    projectTaskGraphs: path3.join(projectDir, "task-graphs"),
+    projectSddSession: path3.join(projectDir, "sdd-session.json"),
+    projectPlan: path3.join(projectDir, "plan.json"),
+    projectAutophase: path3.join(projectDir, "autophase"),
+    projectSddBoards: path3.join(projectDir, "sdd-boards"),
+    syncConfig: path3.join(globalRoot, "sync.json"),
+    configHistoryDir: path3.join(globalRoot, "config-history"),
+    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
 
@@ -701,17 +754,17 @@ var FsError = class extends WrongStackError {
 
 // src/utils/atomic-write.ts
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path3.dirname(targetPath);
-  await fs2.mkdir(dir, { recursive: true });
-  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes2(6).toString("hex")}.tmp`);
+  const dir = path4.dirname(targetPath);
+  await fs3.mkdir(dir, { recursive: true });
+  const tmp = path4.join(dir, `.${path4.basename(targetPath)}.${randomBytes2(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fs2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fs3.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fs2.writeFile(tmp, content, { flag: "wx" });
+      await fs3.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fs2.open(tmp, "r+");
+      const fh = await fs3.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -721,63 +774,63 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat13 = await fs2.stat(targetPath);
+      const stat13 = await fs3.stat(targetPath);
       mode = stat13.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fs2.chmod(tmp, mode);
+      await fs3.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fs2.chmod(targetPath, mode);
+        await fs3.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fs2.unlink(tmp);
+      await fs3.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fs2.mkdir(dir, { recursive: true });
+  await fs3.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path3.dirname(targetPath);
-  await fs2.mkdir(dir, { recursive: true });
-  const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
+  const dir = path4.dirname(targetPath);
+  await fs3.mkdir(dir, { recursive: true });
+  const lockPath = path4.join(dir, `.${path4.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 15e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
   for (; ; ) {
     try {
-      handle = await fs2.open(lockPath, "wx");
+      handle = await fs3.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       if (handle) {
         await handle.close().catch(() => {
         });
-        await fs2.unlink(lockPath).catch(() => {
+        await fs3.unlink(lockPath).catch(() => {
         });
         handle = void 0;
       }
       const code = err.code;
       if (code === "ENOENT") {
-        await fs2.mkdir(dir, { recursive: true });
+        await fs3.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
-        const stat13 = await fs2.stat(lockPath);
+        const stat13 = await fs3.stat(lockPath);
         if (Date.now() - stat13.mtimeMs > staleMs) {
-          await fs2.unlink(lockPath);
+          await fs3.unlink(lockPath);
           continue;
         }
       } catch {
@@ -803,14 +856,14 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fs2.unlink(lockPath);
+      await fs3.unlink(lockPath);
     } catch {
     }
   }
 }
 async function waitForLockRelease(lockPath, remainingMs) {
-  const parentDir = path3.dirname(lockPath);
-  const lockName = path3.basename(lockPath);
+  const parentDir = path4.dirname(lockPath);
+  const lockName = path4.basename(lockPath);
   const intervalMs = Math.min(remainingMs, 100);
   return new Promise((resolve11) => {
     let settled = false;
@@ -838,7 +891,7 @@ async function waitForLockRelease(lockPath, remainingMs) {
       }
       return;
     }
-    fs2.access(lockPath).then(
+    fs3.access(lockPath).then(
       () => {
       },
       () => {
@@ -855,14 +908,14 @@ async function waitForLockRelease(lockPath, remainingMs) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fs2.rename(from, to);
+    await fs3.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fs2.rename(from, to);
+      await fs3.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -879,7 +932,7 @@ async function renameWithRetry(from, to) {
 // src/storage/file-session-writer.ts
 import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 
 // src/storage/session-helpers.ts
 function userInputTitle(content) {
@@ -896,7 +949,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path4.join(opts.dir, `${path4.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path5.join(opts.dir, `${path5.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
@@ -1678,7 +1731,7 @@ var FileSessionWriter = class _FileSessionWriter {
 import { spawn } from "node:child_process";
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import * as fsp2 from "node:fs/promises";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
 // src/storage/storage-concurrency.ts
 async function mapWithConcurrency(items, concurrency, mapper) {
@@ -1709,29 +1762,29 @@ function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative6 = path5.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path5.isAbsolute(relative6);
+  const relative7 = path6.relative(root, target);
+  return relative7 === "" || !relative7.startsWith("..") && !path6.isAbsolute(relative7);
 }
 function normalizeRelative(input) {
-  if (!input || path5.isAbsolute(input)) return null;
+  if (!input || path6.isAbsolute(input)) return null;
   const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  const resolved = path5.posix.normalize(normalized);
+  const resolved = path6.posix.normalize(normalized);
   if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
   return resolved;
 }
 function parseNulPaths(output) {
   return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
 }
-function isWrongStackWorktreePath(relative6) {
-  return relative6 === ".wrongstack/worktrees" || relative6.startsWith(".wrongstack/worktrees/");
+function isWrongStackWorktreePath(relative7) {
+  return relative7 === ".wrongstack/worktrees" || relative7.startsWith(".wrongstack/worktrees/");
 }
 var SessionCheckpointCas = class {
   rootDir;
   projectRoot;
   runGit;
   constructor(opts) {
-    this.rootDir = path5.resolve(opts.rootDir);
-    this.projectRoot = path5.resolve(opts.projectRoot);
+    this.rootDir = path6.resolve(opts.rootDir);
+    this.projectRoot = path6.resolve(opts.projectRoot);
     this.runGit = opts.runGit ?? defaultRunGit;
   }
   async capture(_sessionId, _promptIndex) {
@@ -1749,46 +1802,46 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative6) => !isWrongStackWorktreePath(relative6)).sort();
+    ].filter((relative7) => !isWrongStackWorktreePath(relative7)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative6) => {
-        const absolute = path5.resolve(this.projectRoot, ...relative6.split("/"));
+      async (relative7) => {
+        const absolute = path6.resolve(this.projectRoot, ...relative7.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative6, reason: "path escapes project root" });
+          unresolved.push({ path: relative7, reason: "path escapes project root" });
           return null;
         }
         try {
           const stat13 = await fsp2.lstat(absolute);
           if (stat13.isSymbolicLink()) {
             const linkTarget = await fsp2.readlink(absolute);
-            const resolvedLink = path5.resolve(path5.dirname(absolute), linkTarget);
-            if (path5.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+            const resolvedLink = path6.resolve(path6.dirname(absolute), linkTarget);
+            if (path6.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
-                path: relative6,
+                path: relative7,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative6, state: "symlink", linkTarget };
+            return { path: relative7, state: "symlink", linkTarget };
           }
           if (!stat13.isFile()) {
-            unresolved.push({ path: relative6, reason: "changed path is not a regular file" });
+            unresolved.push({ path: relative7, reason: "changed path is not a regular file" });
             return null;
           }
           if (stat13.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative6,
+              path: relative7,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
           if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative6,
+              path: relative7,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
@@ -1797,12 +1850,12 @@ var SessionCheckpointCas = class {
           const content = await fsp2.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative6, state: "file", blobHash, mode: stat13.mode & 511 };
+          return { path: relative7, state: "file", blobHash, mode: stat13.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative6, state: "absent" };
+            return { path: relative7, state: "absent" };
           }
-          unresolved.push({ path: relative6, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative7, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -1828,7 +1881,7 @@ var SessionCheckpointCas = class {
     };
   }
   async materialize(checkpoint, targetRoot) {
-    const target = path5.resolve(targetRoot);
+    const target = path6.resolve(targetRoot);
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
@@ -1868,10 +1921,10 @@ var SessionCheckpointCas = class {
       try {
         const output = await this.safeOutputPath(target, realTarget, entry.path);
         if (entry.state === "symlink") {
-          if (path5.isAbsolute(entry.linkTarget)) {
+          if (path6.isAbsolute(entry.linkTarget)) {
             throw new Error("absolute symlink target refused");
           }
-          const resolvedLink = path5.resolve(path5.dirname(output), entry.linkTarget);
+          const resolvedLink = path6.resolve(path6.dirname(output), entry.linkTarget);
           if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
@@ -1899,7 +1952,7 @@ var SessionCheckpointCas = class {
           await fsp2.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp2.mkdir(path5.dirname(output), { recursive: true });
+          await fsp2.mkdir(path6.dirname(output), { recursive: true });
           await fsp2.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
@@ -1916,15 +1969,15 @@ var SessionCheckpointCas = class {
   }
   objectPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
-    return path5.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+    return path6.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
   }
   manifestPath(hash) {
     if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
-    return path5.join(this.rootDir, "manifests", `${hash}.json`);
+    return path6.join(this.rootDir, "manifests", `${hash}.json`);
   }
   async putBlob(hash, content) {
     const target = this.objectPath(hash);
-    await fsp2.mkdir(path5.dirname(target), { recursive: true });
+    await fsp2.mkdir(path6.dirname(target), { recursive: true });
     try {
       const existing = await fsp2.readFile(target);
       if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
@@ -1932,9 +1985,9 @@ var SessionCheckpointCas = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    const temp = path5.join(
-      path5.dirname(target),
-      `.${path5.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+    const temp = path6.join(
+      path6.dirname(target),
+      `.${path6.basename(target)}.${process.pid}.${randomUUID()}.tmp`
     );
     let handle;
     try {
@@ -1992,10 +2045,10 @@ var SessionCheckpointCas = class {
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative6) {
-    const normalized = normalizeRelative(relative6);
+  async safeOutputPath(target, realTarget, relative7) {
+    const normalized = normalizeRelative(relative7);
     if (!normalized) throw new Error("invalid relative path");
-    const output = path5.resolve(target, ...normalized.split("/"));
+    const output = path6.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
     let probe = output;
     for (; ; ) {
@@ -2005,7 +2058,7 @@ var SessionCheckpointCas = class {
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path5.dirname(probe);
+        const parent = path6.dirname(probe);
         if (parent === probe) throw err;
         probe = parent;
       }
@@ -2074,13 +2127,13 @@ function generateSessionId(startedAt, _model) {
 // src/storage/session-resume-validation.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fsp3 from "node:fs/promises";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative6 = path6.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path6.isAbsolute(relative6);
+  const relative7 = path7.relative(root, target);
+  return relative7 === "" || !relative7.startsWith("..") && !path7.isAbsolute(relative7);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -2091,7 +2144,7 @@ function latestObservations(events, projectRoot) {
     if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
       continue;
     }
-    const normalized = path6.resolve(projectRoot, event.path);
+    const normalized = path7.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -2149,7 +2202,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path6.resolve(projectRoot);
+  const lexicalRoot = path7.resolve(projectRoot);
   const realRoot = await fsp3.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
@@ -2165,10 +2218,10 @@ async function validateResumeFileObservations(events, projectRoot) {
 }
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path6.resolve(projectRoot);
+  const root = path7.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative6 = path6.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative6 || "." : entry.path;
+    const relative7 = path7.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative7 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
   const omitted = validation.staleFiles.length - shown.length;
@@ -2301,9 +2354,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path7.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path8.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path7.join(this.dir, "_cas"),
+      rootDir: path8.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -2369,17 +2422,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path7.join(this.dir, "_index.jsonl");
+    return path8.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
     return sessionScopedPath(this.dir, id, ext);
   }
   shardManifestPath(shardKey) {
-    return shardKey ? path7.join(this.dir, shardKey, "_manifest.json") : path7.join(this.dir, "_manifest.json");
+    return shardKey ? path8.join(this.dir, shardKey, "_manifest.json") : path8.join(this.dir, "_manifest.json");
   }
   shardKeyForSessionId(id) {
-    const dirName = path7.dirname(id);
+    const dirName = path8.dirname(id);
     return dirName === "." ? "" : dirName;
   }
   invalidateShardManifestBySessionId(id) {
@@ -2391,7 +2444,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path7.dirname(sessionScopedPath(this.dir, id, ""));
+    const dirPath = path8.dirname(sessionScopedPath(this.dir, id, ""));
     await ensureDir(dirPath);
     return dirPath;
   }
@@ -2555,7 +2608,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
-          dir: path7.dirname(file),
+          dir: path8.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           checkpointCas: this.checkpointCas,
@@ -3176,7 +3229,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return entry;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path7.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path8.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
@@ -3199,13 +3252,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
         const id = prefix ? `${prefix}/${base}` : base;
-        files.push({ id, filePath: path7.join(dir, entry.name) });
+        files.push({ id, filePath: path8.join(dir, entry.name) });
       }
     }
     const childFileArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path7.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionFiles(path8.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childFileArrays.flat(), ...files];
@@ -3238,7 +3291,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const childIdArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionIds(path7.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionIds(path8.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childIdArrays.flat(), ...fileIds];
@@ -3353,9 +3406,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path7.dirname(jsonlPath);
-    const base = path7.basename(id);
-    const sessDir = path7.join(shardDir, base);
+    const shardDir = path8.dirname(jsonlPath);
+    const base = path8.basename(id);
+    const sessDir = path8.join(shardDir, base);
     const deletions = [
       fsp4.unlink(jsonlPath),
       fsp4.unlink(summaryPath),
@@ -3400,7 +3453,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async readActiveSessionId() {
     try {
-      const raw = await fsp4.readFile(path7.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp4.readFile(path8.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       return active.sessionId ?? null;
     } catch {
@@ -3463,7 +3516,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const activeSessionId = await this.readActiveSessionId();
     const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
     const pruneFile = async (dir, name, prefix) => {
-      const jsonlPath = path7.join(dir, name);
+      const jsonlPath = path8.join(dir, name);
       try {
         const stat13 = await fsp4.stat(jsonlPath);
         if (stat13.mtimeMs >= cutoff) return;
@@ -3483,7 +3536,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         continue;
       }
       if (!entry.isDirectory()) continue;
-      const dateDir = path7.join(this.dir, entry.name);
+      const dateDir = path8.join(this.dir, entry.name);
       const files = await fsp4.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
@@ -3495,7 +3548,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dateDir = path7.join(this.dir, entry.name);
+      const dateDir = path8.join(this.dir, entry.name);
       try {
         const remaining = await fsp4.readdir(dateDir);
         if (remaining.length === 0) {
@@ -3620,7 +3673,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
 
 // src/storage/queue-store.ts
 import * as fsp5 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -3629,7 +3682,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path8.join(opts.dir, "queue.json");
+    this.file = path9.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -3787,7 +3840,7 @@ function isPersistedQueueItem(v) {
 // src/storage/attachment-store.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
 import * as fsp6 from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -3808,7 +3861,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp6.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path9.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path10.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -3928,8 +3981,8 @@ function mergeAdjacentText(blocks) {
 
 // src/storage/memory-backend.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs3 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path11 from "node:path";
 
 // src/types/memory.ts
 var MEMORY_TYPE_LABELS = {
@@ -4096,7 +4149,7 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat13 = await fs3.stat(file);
+      const stat13 = await fs4.stat(file);
       return stat13.mtimeMs;
     } catch {
       return 0;
@@ -4143,10 +4196,10 @@ var FileMemoryBackend = class {
   }
   async remember(scope, entry, filePath) {
     const file = this.resolveFile(filePath, scope);
-    await ensureDir(path10.dirname(file));
+    await ensureDir(path11.dirname(file));
     let existing = "";
     try {
-      existing = await fs3.readFile(file, "utf8");
+      existing = await fs4.readFile(file, "utf8");
     } catch {
     }
     const id = `mem_${Date.now()}_${randomUUID2().slice(0, 8)}`;
@@ -4164,7 +4217,7 @@ ${line}`;
     return withFileLock(file, async () => {
       let existing;
       try {
-        existing = await fs3.readFile(file, "utf8");
+        existing = await fs4.readFile(file, "utf8");
       } catch {
         return 0;
       }
@@ -4201,7 +4254,7 @@ ${line}`;
   async readAll(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     try {
-      return await fs3.readFile(file, "utf8");
+      return await fs4.readFile(file, "utf8");
     } catch {
       return "";
     }
@@ -4225,7 +4278,7 @@ ${line}`;
     const file = this.resolveFile(filePath, scope);
     let existing;
     try {
-      existing = await fs3.readFile(file, "utf8");
+      existing = await fs4.readFile(file, "utf8");
     } catch {
       return 0;
     }
@@ -4245,7 +4298,7 @@ ${line}`;
     const next = lines.join("\n");
     const backup = `${file}.bak.${Date.now()}`;
     try {
-      await fs3.copyFile(file, backup);
+      await fs4.copyFile(file, backup);
       await pruneConsolidateBackups(file);
     } catch {
     }
@@ -4259,14 +4312,14 @@ ${line}`;
   }
 };
 async function pruneConsolidateBackups(file) {
-  const dir = path10.dirname(file);
-  const base = path10.basename(file);
+  const dir = path11.dirname(file);
+  const base = path11.basename(file);
   const prefix = `${base}.bak.`;
-  const backups = (await fs3.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
+  const backups = (await fs4.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
   await Promise.all(
     backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
       try {
-        await fs3.unlink(path10.join(dir, name));
+        await fs4.unlink(path11.join(dir, name));
       } catch {
       }
     })
@@ -4282,7 +4335,7 @@ function parseEntries(raw, scope = "project-memory") {
 }
 
 // src/storage/memory-graph-backend.ts
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 var GraphMemoryBackend = class _GraphMemoryBackend {
   kind = "graph";
   file;
@@ -4450,7 +4503,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
     this.loadedScope = scope;
     this.loaded = true;
     try {
-      await fs4.unlink(this.graphFile);
+      await fs5.unlink(this.graphFile);
     } catch {
     }
   }
@@ -4490,7 +4543,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
   async loadGraph(scope) {
     if (this.loaded && this.loadedScope === scope) return;
     try {
-      const raw = await fs4.readFile(this.graphFile, "utf8");
+      const raw = await fs5.readFile(this.graphFile, "utf8");
       const data = JSON.parse(raw);
       this.nodes = new Map(data.nodes);
       this.edges = data.edges;
@@ -4512,10 +4565,10 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
         edges: this.edges
       };
       const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
-      await fs4.mkdir(dir, { recursive: true });
+      await fs5.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
-      await fs4.writeFile(tmp, JSON.stringify(data));
-      await fs4.rename(tmp, this.graphFile);
+      await fs5.writeFile(tmp, JSON.stringify(data));
+      await fs5.rename(tmp, this.graphFile);
     } catch {
     }
   }
@@ -4634,7 +4687,7 @@ function simpleHash(s) {
 
 // src/utils/instruction-file.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { fileURLToPath } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
@@ -4644,7 +4697,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync2(path11.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync2(path12.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -4660,11 +4713,11 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path11.dirname(fileURLToPath(import.meta.url));
+  const here = path12.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path11.resolve(here, "../../instructions"),
-    path11.resolve(here, "../instructions"),
-    path11.resolve(here, "instructions")
+    path12.resolve(here, "../../instructions"),
+    path12.resolve(here, "../instructions"),
+    path12.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   return rootCandidates;
@@ -4912,8 +4965,8 @@ function deepFreeze(obj) {
 
 // src/storage/provider-config-watcher.ts
 import * as syncFs from "node:fs";
-import * as fs5 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path13 from "node:path";
 
 // src/security/config-secrets.ts
 function decryptConfigSecrets(cfg, vault, opts) {
@@ -4959,7 +5012,7 @@ function isSecretField(name) {
 async function readProviderSnapshot(configPath, vault, warn) {
   let raw;
   try {
-    raw = await fs5.readFile(configPath, "utf8");
+    raw = await fs6.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       warn?.(`Could not read ${configPath}: ${err.message}`);
@@ -4975,7 +5028,8 @@ async function readProviderSnapshot(configPath, vault, warn) {
   }
   const decrypted = decryptConfigSecrets(parsed, vault, warn ? { warn } : {});
   const snapshot = {
-    providers: decrypted.providers ?? {}
+    providers: decrypted.providers ?? {},
+    snapshotHasProviders: decrypted.providers !== void 0
   };
   if (typeof decrypted.apiKey === "string") snapshot.apiKey = decrypted.apiKey;
   if (typeof decrypted.baseUrl === "string") snapshot.baseUrl = decrypted.baseUrl;
@@ -5010,7 +5064,7 @@ function serializeSnapshot(s) {
 function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   const debounceMs = opts.debounceMs ?? 200;
   const warn = opts.warn;
-  const base = path12.basename(configPath);
+  const base = path13.basename(configPath);
   let timer;
   let closed = false;
   let lastSerialized;
@@ -5021,7 +5075,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   });
   let watcher;
   try {
-    watcher = syncFs.watch(path12.dirname(configPath), { recursive: false });
+    watcher = syncFs.watch(path13.dirname(configPath), { recursive: false });
   } catch (err) {
     warn?.(`Provider config watcher could not start: ${err.message}`);
     return { close: () => {
@@ -5064,8 +5118,8 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
 }
 
 // src/storage/config-loader.ts
-import * as fs6 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path14 from "node:path";
 
 // src/types/config.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
@@ -5589,8 +5643,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   return out;
 }
 function samePath(a, b) {
-  let ra = path13.resolve(a);
-  let rb = path13.resolve(b);
+  let ra = path14.resolve(a);
+  let rb = path14.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -5612,7 +5666,7 @@ function deepMerge2(base, patch) {
     opts
   );
 }
-var DefaultConfigLoader = class {
+var DefaultConfigLoader = class _DefaultConfigLoader {
   paths;
   strict;
   vault;
@@ -5719,6 +5773,11 @@ var DefaultConfigLoader = class {
     }
     return Object.freeze(cfg);
   }
+  /** Check whether a config object contains only the two bootstrap keys. */
+  static isBootstrapOnly(config) {
+    const BOOTSTRAP_KEYS = /* @__PURE__ */ new Set(["version", "activeProfile"]);
+    return Object.keys(config).every((k) => BOOTSTRAP_KEYS.has(k));
+  }
   async ensureGlobalDefaults() {
     const fp = this.paths.globalConfig;
     const t0 = Date.now();
@@ -5727,7 +5786,7 @@ var DefaultConfigLoader = class {
         let parsed;
         let fileExisted = true;
         try {
-          const raw = await fs6.readFile(fp, "utf8");
+          const raw = await fs7.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -5756,9 +5815,12 @@ var DefaultConfigLoader = class {
           fileExisted = false;
           parsed = {};
         }
+        const profileName = parsed.activeProfile ?? "default";
+        const profileFp = this.paths.profileConfig(profileName);
+        await this.ensureProfileConfig(profileFp, parsed, fileExisted);
         const bootstrap = {
           version: 1,
-          activeProfile: parsed.activeProfile ?? "default"
+          activeProfile: profileName
         };
         let needsBootstrapWrite = false;
         if (parsed.version !== 1) {
@@ -5767,7 +5829,11 @@ var DefaultConfigLoader = class {
         if (parsed.activeProfile === void 0) {
           needsBootstrapWrite = true;
         }
+        if (!_DefaultConfigLoader.isBootstrapOnly(parsed)) {
+          needsBootstrapWrite = true;
+        }
         if (needsBootstrapWrite) {
+          await backupConfigFile(fp, this.paths);
           await atomicWrite(fp, JSON.stringify(bootstrap, null, 2), { mode: 384 });
           this.events?.emit("storage.write", {
             sessionId: "~config~",
@@ -5779,9 +5845,6 @@ var DefaultConfigLoader = class {
             ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
           });
         }
-        const profileName = bootstrap.activeProfile ?? "default";
-        const profileFp = this.paths.profileConfig(profileName);
-        await this.ensureProfileConfig(profileFp, parsed, fileExisted);
       });
     } catch (err) {
       this.events?.emit("storage.error", {
@@ -5807,77 +5870,92 @@ var DefaultConfigLoader = class {
    * On first boot: migrate content from the old flat global config, or seed
    * with behavior defaults. Subsequent boots: fill any missing keys from
    * BEHAVIOR_DEFAULTS (keeping user settings intact).
+   *
+   * CRITICAL SAFETY NET: when the profile already exists but the old global
+   * config has extra non-bootstrap keys (because WebUI/CLI persistence functions
+   * mistakenly wrote settings to the root config), those keys are merged into
+   * the profile so they are NOT silently destroyed by the subsequent bootstrap
+   * trim. This prevents the "config keeps getting emptied" bug.
    */
   async ensureProfileConfig(profileFp, oldGlobalParsed, oldFileExisted) {
     const t0 = Date.now();
+    let parsed;
+    let existed = true;
     try {
-      await withFileLock(profileFp, async () => {
-        let parsed;
-        let existed = true;
-        try {
-          const raw = await fs6.readFile(profileFp, "utf8");
-          const result = safeParse(raw);
-          if (!result.ok || !isPlainRecord(result.value)) {
-            this.logWarn("Profile config parse failed \u2014 falling back to defaults", {
-              event: "config.profile_parse_failed",
-              path: profileFp
-            });
-            parsed = {};
-          } else {
-            parsed = result.value;
+      const raw = await fs7.readFile(profileFp, "utf8");
+      const result = safeParse(raw);
+      if (!result.ok || !isPlainRecord(result.value)) {
+        this.logWarn("Profile config parse failed \u2014 falling back to defaults", {
+          event: "config.profile_parse_failed",
+          path: profileFp
+        });
+        parsed = {};
+      } else {
+        parsed = result.value;
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        this.logWarn("Profile config read failed", {
+          event: "config.profile_read_failed",
+          path: profileFp,
+          message: toErrorMessage(err)
+        });
+        return;
+      }
+      existed = false;
+      parsed = {};
+    }
+    const profileHasContent = existed && Object.keys(parsed).some((k) => k !== "version" && k !== "activeProfile");
+    let seed;
+    if (!profileHasContent && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
+      seed = { ...oldGlobalParsed };
+      delete seed["activeProfile"];
+      const filled = fillMissingDefaults(seed, BEHAVIOR_DEFAULTS);
+      seed = filled.value;
+    } else {
+      if (existed && !_DefaultConfigLoader.isBootstrapOnly(oldGlobalParsed)) {
+        const BOOTSTRAP_KEYS = /* @__PURE__ */ new Set(["version", "activeProfile"]);
+        let merged = false;
+        for (const [k, v] of Object.entries(oldGlobalParsed)) {
+          if (!BOOTSTRAP_KEYS.has(k) && !(k in parsed)) {
+            parsed[k] = v;
+            merged = true;
           }
-        } catch (err) {
-          if (err.code !== "ENOENT") {
-            this.logWarn("Profile config read failed", {
-              event: "config.profile_read_failed",
-              path: profileFp,
-              message: toErrorMessage(err)
+        }
+        if (merged) {
+          const filled2 = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
+          if (filled2.changed) {
+            seed = filled2.value;
+            await backupConfigFile(profileFp, this.paths);
+            await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
+            this.events?.emit("storage.write", {
+              sessionId: "~config~",
+              store: "config",
+              filePath: profileFp,
+              operation: "ensure_profile_defaults",
+              outcome: "success",
+              durationMs: Date.now() - t0,
+              ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
             });
             return;
           }
-          existed = false;
-          parsed = {};
         }
-        let seed;
-        if (!existed && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
-          seed = { ...oldGlobalParsed };
-          delete seed["activeProfile"];
-          const filled = fillMissingDefaults(seed, BEHAVIOR_DEFAULTS);
-          seed = filled.value;
-        } else {
-          const filled = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
-          if (!filled.changed) return;
-          seed = filled.value;
-        }
-        await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
-        this.events?.emit("storage.write", {
-          sessionId: "~config~",
-          store: "config",
-          filePath: profileFp,
-          operation: "ensure_profile_defaults",
-          outcome: "success",
-          durationMs: Date.now() - t0,
-          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-        });
-      });
-    } catch (err) {
-      this.events?.emit("storage.error", {
-        sessionId: "~config~",
-        store: "config",
-        filePath: profileFp,
-        operation: "ensure_profile_defaults",
-        outcome: "failure",
-        error: storageErrorString(err),
-        recoverable: false,
-        durationMs: Date.now() - t0,
-        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-      });
-      this.logWarn("Profile config defaults write failed", {
-        event: "config.profile_write_failed",
-        path: profileFp,
-        message: toErrorMessage(err)
-      });
+      }
+      const filled = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
+      if (!filled.changed) return;
+      seed = filled.value;
     }
+    await backupConfigFile(profileFp, this.paths);
+    await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
+    this.events?.emit("storage.write", {
+      sessionId: "~config~",
+      store: "config",
+      filePath: profileFp,
+      operation: "ensure_profile_defaults",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+    });
   }
   /**
    * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
@@ -5927,7 +6005,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fs6.readFile(fp, "utf8");
+      const raw = await fs7.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -5989,7 +6067,7 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat13 = await fs6.stat(file);
+      const stat13 = await fs7.stat(file);
       mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
@@ -6019,7 +6097,7 @@ var DefaultConfigLoader = class {
     }
     let raw;
     try {
-      raw = await fs6.readFile(file, "utf8");
+      raw = await fs7.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -6182,7 +6260,7 @@ var DEFAULT_CONFIG_MIGRATIONS = [];
 // src/storage/recovery-lock.ts
 import * as fsp7 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -6193,7 +6271,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path14.join(opts.dir, LOCK_FILE);
+    this.file = path15.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os2.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -6254,7 +6332,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path14.dirname(this.file));
+    await ensureDir(path15.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -6322,7 +6400,7 @@ function defaultIsPidAlive(pid) {
 }
 
 // src/storage/session-reader.ts
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 var DefaultSessionReader = class _DefaultSessionReader {
   store;
   eventCache = /* @__PURE__ */ new Map();
@@ -6340,7 +6418,7 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat13 = await fs7.stat(sessionPath);
+      const stat13 = await fs8.stat(sessionPath);
       mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
@@ -6704,7 +6782,7 @@ function renderPlainText(meta, events) {
 
 // src/storage/annotations-store.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs8 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
 var MAX_ANNOTATIONS = 1e3;
@@ -6931,7 +7009,7 @@ var AnnotationsStore = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fs8.readFile(fp, "utf8");
+      raw = await fs9.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -6968,8 +7046,8 @@ var AnnotationsStore = class {
 };
 
 // src/storage/replay-log-store.ts
-import * as fs9 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as fs10 from "node:fs/promises";
+import * as path16 from "node:path";
 
 // src/replay/hash.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -7058,12 +7136,12 @@ var ReplayLogStore = class {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat13 = await fs9.stat(fp);
+              const stat13 = await fs10.stat(fp);
               offset2 = stat13.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
-            await fs9.appendFile(fp, line, "utf8");
+            await fs10.appendFile(fp, line, "utf8");
             cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
             this.events?.emit("storage.write", {
@@ -7191,7 +7269,7 @@ var ReplayLogStore = class {
     const scan = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs9.readdir(dir, { withFileTypes: true });
+        entries = await fs10.readdir(dir, { withFileTypes: true });
       } catch (err) {
         if (depth === 0 && err.code !== "ENOENT") {
           console.warn(JSON.stringify({
@@ -7207,13 +7285,13 @@ var ReplayLogStore = class {
       for (const entry of entries) {
         if (entry.name.startsWith(".")) continue;
         if (entry.isDirectory()) {
-          if (depth === 0) await scan(path15.join(dir, entry.name), entry.name, depth + 1);
+          if (depth === 0) await scan(path16.join(dir, entry.name), entry.name, depth + 1);
           continue;
         }
         if (!entry.isFile() || !entry.name.endsWith(".replay.jsonl")) continue;
         const base = entry.name.slice(0, -".replay.jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const fp = path15.join(dir, entry.name);
+        const fp = path16.join(dir, entry.name);
         out.push({
           sessionId,
           entryCount: await this.countEntries(fp),
@@ -7229,7 +7307,7 @@ var ReplayLogStore = class {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
   async countEntries(filePath) {
-    const handle = await fs9.open(filePath, "r");
+    const handle = await fs10.open(filePath, "r");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let count = 0;
     let hasNonWhitespace2 = false;
@@ -7270,7 +7348,7 @@ var ReplayLogStore = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs9.readFile(fp, "utf8");
+      const raw = await fs10.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -7306,7 +7384,7 @@ var ReplayLogStore = class {
     const fp = this.filePath(sessionId);
     cache = /* @__PURE__ */ new Map();
     try {
-      const handle = await fs9.open(fp, "r");
+      const handle = await fs10.open(fp, "r");
       const CHUNK = 64 * 1024;
       const buffer = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -7357,7 +7435,7 @@ var ReplayLogStore = class {
   async hydrateEntry(sessionId, hash, location) {
     if (location.entry) return location.entry;
     const fp = this.filePath(sessionId);
-    const handle = await fs9.open(fp, "r");
+    const handle = await fs10.open(fp, "r");
     try {
       const buffer = Buffer.alloc(location.length);
       const { bytesRead } = await handle.read(buffer, 0, location.length, location.offset);
@@ -7384,8 +7462,8 @@ var ReplayLogStore = class {
 };
 
 // src/storage/session-recovery.ts
-import * as fs10 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as fs11 from "node:fs/promises";
+import * as path17 from "node:path";
 var SessionRecovery = class {
   constructor(dir) {
     this.dir = dir;
@@ -7411,7 +7489,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let stat13;
     try {
-      stat13 = await fs10.stat(fp);
+      stat13 = await fs11.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -7445,7 +7523,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fs10.readFile(fp, "utf8");
+      raw = await fs11.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -7490,7 +7568,7 @@ var SessionRecovery = class {
     const collect = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fs10.readdir(dir, { withFileTypes: true });
+        entries = await fs11.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -7500,7 +7578,7 @@ var SessionRecovery = class {
           continue;
         if (entry.isDirectory()) {
           if (depth === 0) {
-            await collect(path16.join(dir, entry.name), entry.name, depth + 1);
+            await collect(path17.join(dir, entry.name), entry.name, depth + 1);
           }
           continue;
         }
@@ -7541,7 +7619,7 @@ function hasNonWhitespace(line) {
 }
 async function scanLatestLifecycleBoundary(filePath, size) {
   const CHUNK_SIZE = 64 * 1024;
-  const handle = await fs10.open(filePath, "r");
+  const handle = await fs11.open(filePath, "r");
   let position = size;
   let laterLineFragment = Buffer.alloc(0);
   let latestBoundary = null;
@@ -7580,7 +7658,7 @@ async function scanLatestLifecycleBoundary(filePath, size) {
 
 // src/storage/tool-audit-log.ts
 import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
-import * as fs11 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
@@ -7650,9 +7728,9 @@ var ToolAuditLog = class {
             isError: input.isError,
             index
           };
-          await fs11.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
+          await fs12.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
           try {
-            const st = await fs11.stat(fp);
+            const st = await fs12.stat(fp);
             this.tailStat.set(input.sessionId, { mtimeMs: st.mtimeMs, size: st.size });
           } catch {
           }
@@ -7699,7 +7777,7 @@ var ToolAuditLog = class {
     const cachedStat = this.tailStat.get(sessionId);
     if (cachedHash !== void 0 && cachedIndex !== void 0 && cachedStat) {
       try {
-        const st = await fs11.stat(fp);
+        const st = await fs12.stat(fp);
         if (st.mtimeMs === cachedStat.mtimeMs && st.size === cachedStat.size) {
           return { prevHash: cachedHash, nextIndex: cachedIndex };
         }
@@ -7720,7 +7798,7 @@ var ToolAuditLog = class {
     this.tailHash.set(sessionId, prevHash);
     this.tailIndex.set(sessionId, nextIndex);
     try {
-      const st = await fs11.stat(fp);
+      const st = await fs12.stat(fp);
       this.tailStat.set(sessionId, { mtimeMs: st.mtimeMs, size: st.size });
     } catch {
     }
@@ -7841,7 +7919,7 @@ var ToolAuditLog = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fs11.readFile(fp, "utf8");
+      const raw = await fs12.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -7879,7 +7957,7 @@ var ToolAuditLog = class {
   }
   async sync(sessionId, fp) {
     try {
-      const fh = await fs11.open(fp, "r+");
+      const fh = await fs12.open(fp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -8018,8 +8096,8 @@ var SessionAnalyzer = class {
 
 // src/session-registry.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import * as fs12 from "node:fs/promises";
-import * as path17 from "node:path";
+import * as fs13 from "node:fs/promises";
+import * as path18 from "node:path";
 var REGISTRY_FILE = "session-registry.json";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
@@ -8058,7 +8136,7 @@ var SessionRegistry = class {
    */
   lastEntry = null;
   constructor(globalRoot) {
-    this.filePath = path17.join(globalRoot, REGISTRY_FILE);
+    this.filePath = path18.join(globalRoot, REGISTRY_FILE);
   }
   // ── Public API ──────────────────────────────────────────────────────────
   /**
@@ -8214,7 +8292,7 @@ var SessionRegistry = class {
   }
   async readAndPrune() {
     try {
-      const raw = await fs12.readFile(this.filePath, "utf8");
+      const raw = await fs13.readFile(this.filePath, "utf8");
       const registry = parseRegistry(raw);
       const now = Date.now();
       let pruned = false;
@@ -8267,11 +8345,11 @@ var SessionRegistry = class {
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
-        await fs12.mkdir(path17.dirname(this.filePath), { recursive: true });
-        let lockHandle = await fs12.open(lockPath, "wx").catch(() => null);
+        await fs13.mkdir(path18.dirname(this.filePath), { recursive: true });
+        let lockHandle = await fs13.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await this.breakStaleLock(lockPath)) {
-            lockHandle = await fs12.open(lockPath, "wx").catch(() => null);
+            lockHandle = await fs13.open(lockPath, "wx").catch(() => null);
           }
           if (!lockHandle) {
             await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
@@ -8280,14 +8358,14 @@ var SessionRegistry = class {
         }
         try {
           await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
-          const raw = await fs12.readFile(this.filePath, "utf8").catch(() => "{}");
+          const raw = await fs13.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = parseRegistry(raw);
           fn(registry);
           await this.writeAtomicLocked(registry);
           return;
         } finally {
           await lockHandle.close();
-          await fs12.unlink(lockPath).catch(() => void 0);
+          await fs13.unlink(lockPath).catch(() => void 0);
         }
       } catch {
         return;
@@ -8304,16 +8382,16 @@ var SessionRegistry = class {
   async breakStaleLock(lockPath) {
     try {
       const [stat13, content] = await Promise.all([
-        fs12.stat(lockPath),
+        fs13.stat(lockPath),
         /* v8 ignore start -- best-effort lock-content read; .catch only fires if the lock vanished */
-        fs12.readFile(lockPath, "utf8").catch(() => "")
+        fs13.readFile(lockPath, "utf8").catch(() => "")
         /* v8 ignore stop */
       ]);
       const ageMs = Date.now() - stat13.mtimeMs;
       const ownerPid = Number.parseInt(content.trim(), 10);
       const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
       if (ownerDead || ageMs > STALE_LOCK_MS) {
-        await fs12.unlink(lockPath).catch(() => void 0);
+        await fs13.unlink(lockPath).catch(() => void 0);
         return true;
       }
       return false;
@@ -8331,41 +8409,41 @@ var SessionRegistry = class {
     await this.writeAtomicFile(registry);
   }
   async writeAtomicFile(registry) {
-    const tmp = path17.join(
-      path17.dirname(this.filePath),
-      `.${path17.basename(this.filePath)}.${randomUUID5().slice(0, 8)}.tmp`
+    const tmp = path18.join(
+      path18.dirname(this.filePath),
+      `.${path18.basename(this.filePath)}.${randomUUID5().slice(0, 8)}.tmp`
     );
     try {
-      const handle = await fs12.open(tmp, "w");
+      const handle = await fs13.open(tmp, "w");
       try {
         await handle.writeFile(JSON.stringify(registry, null, 2), "utf8");
         await handle.sync().catch(() => void 0);
       } finally {
         await handle.close();
       }
-      await fs12.rename(tmp, this.filePath);
+      await fs13.rename(tmp, this.filePath);
     } catch (err) {
-      await fs12.unlink(tmp).catch(() => void 0);
+      await fs13.unlink(tmp).catch(() => void 0);
       throw err;
     }
   }
   async pruneStaleTempFiles() {
     try {
-      const dir = path17.dirname(this.filePath);
-      const base = path17.basename(this.filePath);
+      const dir = path18.dirname(this.filePath);
+      const base = path18.basename(this.filePath);
       const now = Date.now();
       const stale = [];
-      for (const name of await fs12.readdir(dir)) {
+      for (const name of await fs13.readdir(dir)) {
         const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
         if (!isTemp) continue;
-        const stat13 = await fs12.stat(path17.join(dir, name)).catch(() => null);
+        const stat13 = await fs13.stat(path18.join(dir, name)).catch(() => null);
         if (!stat13) continue;
         if (now - stat13.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat13.mtimeMs });
       }
       stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
       await Promise.all(
         stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-          await fs12.unlink(path17.join(dir, name)).catch(() => void 0);
+          await fs13.unlink(path18.join(dir, name)).catch(() => void 0);
         })
       );
     } catch {
@@ -9100,8 +9178,8 @@ var AgentStatusTracker = class {
 };
 
 // src/fleet-notifier.ts
-import * as fs13 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as fs14 from "node:fs/promises";
+import * as path19 from "node:path";
 var INSTANCES_FILE = "webui-instances.json";
 var DISCOVERY_TTL_MS = 2500;
 var COALESCE_MS = 50;
@@ -9116,7 +9194,7 @@ function pidAlive2(pid) {
   }
 }
 function normRoot(root) {
-  const resolved = path18.resolve(root);
+  const resolved = path19.resolve(root);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 var FleetNotifier = class {
@@ -9163,7 +9241,7 @@ var FleetNotifier = class {
   }
   async discover() {
     try {
-      const raw = await fs13.readFile(path18.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const raw = await fs14.readFile(path19.join(this.baseDir, INSTANCES_FILE), "utf8");
       const data = JSON.parse(raw);
       const list = Array.isArray(data?.instances) ? data.instances : [];
       return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
@@ -9184,7 +9262,7 @@ async function defaultPost(url) {
 
 // src/storage/session-rewinder.ts
 import * as fsp8 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
@@ -9322,10 +9400,10 @@ async function revertSnapshots(snapshots, projectRoot) {
   for (const snapshot of [...snapshots].reverse()) {
     for (const file of [...snapshot.files].reverse()) {
       try {
-        const absPath = path19.resolve(file.path);
-        const root = path19.resolve(projectRoot);
-        const rel = path19.relative(root, absPath);
-        if (rel.startsWith("..") || path19.isAbsolute(rel)) {
+        const absPath = path20.resolve(file.path);
+        const root = path20.resolve(projectRoot);
+        const rel = path20.relative(root, absPath);
+        if (rel.startsWith("..") || path20.isAbsolute(rel)) {
           errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
           continue;
         }
@@ -10850,8 +10928,8 @@ function normalizeTitle(value) {
 
 // src/storage/prompt-store.ts
 import { createHash as createHash7 } from "node:crypto";
-import * as fs14 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as fs15 from "node:fs/promises";
+import * as path21 from "node:path";
 var SCHEMA_VERSION = 2;
 function promptChecksum(content) {
   return createHash7("sha256").update(content, "utf8").digest("hex");
@@ -10915,12 +10993,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs14.readdir(this.dir);
+      const files = await fs15.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs14.readFile(path20.join(this.dir, file), "utf8")
+            await fs15.readFile(path21.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -10934,9 +11012,9 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path20.join(this.dir, `${id}.json`);
+    const file = path21.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs14.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs15.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -10944,14 +11022,14 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path20.join(this.dir, `${entry.id}.json`);
+    const file = path21.join(this.dir, `${entry.id}.json`);
     const raw = { version: SCHEMA_VERSION, entry };
     await atomicWrite(file, JSON.stringify(raw, null, 2));
   }
   async delete(id) {
-    const file = path20.join(this.dir, `${id}.json`);
+    const file = path21.join(this.dir, `${id}.json`);
     try {
-      await fs14.unlink(file);
+      await fs15.unlink(file);
       return true;
     } catch {
       return false;
@@ -10990,8 +11068,8 @@ var DefaultPromptStore = class {
 };
 
 // src/storage/prompt-usage-store.ts
-import * as fs15 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs16 from "node:fs/promises";
+import * as path22 from "node:path";
 var PromptUsageStore = class {
   constructor(file) {
     this.file = file;
@@ -10999,7 +11077,7 @@ var PromptUsageStore = class {
   file;
   async load() {
     try {
-      const raw = JSON.parse(await fs15.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs16.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && raw.usage && typeof raw.usage === "object") {
         return raw.usage;
       }
@@ -11012,7 +11090,7 @@ var PromptUsageStore = class {
     const prev = usage[slug];
     const next = { count: (prev?.count ?? 0) + 1, lastUsedAt: at };
     usage[slug] = next;
-    await ensureDir(path21.dirname(this.file));
+    await ensureDir(path22.dirname(this.file));
     await atomicWrite(this.file, JSON.stringify({ version: 1, usage }, null, 2));
     return next;
   }
@@ -11036,8 +11114,8 @@ var PromptUsageStore = class {
 };
 
 // src/storage/input-history-store.ts
-import * as fs16 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as fs17 from "node:fs/promises";
+import * as path23 from "node:path";
 var INPUT_HISTORY_DEFAULT_MAX = 100;
 var InputHistoryStore = class {
   /**
@@ -11059,7 +11137,7 @@ var InputHistoryStore = class {
    */
   async load() {
     try {
-      const raw = JSON.parse(await fs16.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs17.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && Array.isArray(raw.entries) && raw.entries.every((e) => typeof e === "string")) {
         return raw.entries.slice(0, this.maxEntries);
       }
@@ -11076,7 +11154,7 @@ var InputHistoryStore = class {
    */
   async save(entries) {
     const cleaned = this.scrubAndFilter(entries);
-    await ensureDir(path22.dirname(this.file));
+    await ensureDir(path23.dirname(this.file));
     const payload = {
       version: 1,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11086,7 +11164,7 @@ var InputHistoryStore = class {
   }
   /** Truncate the file to an empty entry list (used by /clear). */
   async clear() {
-    await ensureDir(path22.dirname(this.file));
+    await ensureDir(path23.dirname(this.file));
     const payload = { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: [] };
     await atomicWrite(this.file, JSON.stringify(payload, null, 2));
   }
@@ -11116,8 +11194,8 @@ var InputHistoryStore = class {
 };
 
 // src/storage/cloud-sync.ts
-import * as fs17 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as fs18 from "node:fs/promises";
+import * as path24 from "node:path";
 import { createHash as createHash8 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
@@ -11125,7 +11203,7 @@ var CloudSync = class {
     this.paths = paths;
     this.getConfig = getConfig;
     this.setConfig = setConfig;
-    this.statePath = path23.join(paths.globalRoot, "sync-state.json");
+    this.statePath = path24.join(paths.globalRoot, "sync-state.json");
   }
   paths;
   getConfig;
@@ -11200,7 +11278,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev: rev
     };
-    await fs17.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fs18.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -11232,8 +11310,8 @@ var CloudSync = class {
       const rel = segments.slice(2).join("/");
       const destPath = resolvePulledCategoryPath(cat, localPath, rel, entry.path);
       const blobData = await this.getBlob(token, owner, repoName, entry.sha);
-      await fs17.mkdir(path23.dirname(destPath), { recursive: true });
-      await fs17.writeFile(destPath, Buffer.from(blobData, "base64"));
+      await fs18.mkdir(path24.dirname(destPath), { recursive: true });
+      await fs18.writeFile(destPath, Buffer.from(blobData, "base64"));
     }
     const localRev = await this.hashLocalCategories(cfg.categories);
     const syncState = {
@@ -11242,7 +11320,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev
     };
-    await fs17.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fs18.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -11261,7 +11339,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fs17.readFile(this.statePath, "utf8");
+      const raw = await fs18.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -11339,17 +11417,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fs17.stat(localPath);
+        const stat13 = await fs18.stat(localPath);
         if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs17.readFile(file, "utf8");
-            const rel = path23.relative(localPath, file).replace(/\\/g, "/");
+            const content = await fs18.readFile(file, "utf8");
+            const rel = path24.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(content);
           }
         } else {
-          const content = await fs17.readFile(localPath, "utf8");
+          const content = await fs18.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(content);
         }
@@ -11365,15 +11443,15 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat13 = await fs17.stat(localPath);
+        const stat13 = await fs18.stat(localPath);
         if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs17.readFile(file);
+            const content = await fs18.readFile(file);
             hashes.push(content.toString("base64") + file);
           }
         } else {
-          const content = await fs17.readFile(localPath);
+          const content = await fs18.readFile(localPath);
           hashes.push(content.toString("base64") + localPath);
         }
       } catch {
@@ -11400,9 +11478,9 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fs17.readdir(dir, { withFileTypes: true });
+    const entries = await fs18.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path23.join(dir, entry.name);
+      const full = path24.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await this.walkDir(full, base));
       } else {
@@ -11424,9 +11502,9 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
     return localPath;
   }
   if (!rel) return localPath;
-  const normalizedRel = path23.normalize(rel);
-  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path23.sep}`);
-  if (path23.isAbsolute(normalizedRel) || traversesUp) {
+  const normalizedRel = path24.normalize(rel);
+  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path24.sep}`);
+  if (path24.isAbsolute(normalizedRel) || traversesUp) {
     throw new FsError({
       message: `Refusing CloudSync path traversal: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -11434,10 +11512,10 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
       context: { reason: "path_traversal", normalizedRel }
     });
   }
-  const dest = path23.resolve(localPath, normalizedRel);
-  const root = path23.resolve(localPath);
-  const relative6 = path23.relative(root, dest);
-  if (relative6.startsWith("..") || path23.isAbsolute(relative6)) {
+  const dest = path24.resolve(localPath, normalizedRel);
+  const root = path24.resolve(localPath);
+  const relative7 = path24.relative(root, dest);
+  if (relative7.startsWith("..") || path24.isAbsolute(relative7)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,