@wrongstack/core 0.291.0 → 0.291.2

package/dist/defaults/index.js

@@ -382,6 +382,37 @@ var color = {
   bgGreen: wrap("42", "49")
 };
 
+// src/utils/config-backup.ts
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+function configHistoryDir(globalRoot) {
+  return path2.join(globalRoot, "config-history");
+}
+function configSlug(absolutePath, globalRoot) {
+  const rel = path2.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 fs2.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 = path2.join(backupDir, `${slug}-${ts}.json`);
+  try {
+    await fs2.mkdir(backupDir, { recursive: true });
+    await fs2.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
+  } catch {
+  }
+}
+
 // src/utils/context-evidence.ts
 var MAX_DIGEST_CHARS = 4e3;
 function createContextEvidenceState() {
@@ -841,10 +872,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path29, errors, depth) {
+function walk(value, schema, path30, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path29 || "<root>",
+      path: path30 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -852,7 +883,7 @@ function walk(value, schema, path29, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path29 || "<root>",
+        path: path30 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -861,7 +892,7 @@ function walk(value, schema, path29, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path29 || "<root>",
+        path: path30 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -873,7 +904,7 @@ function walk(value, schema, path29, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path29, req),
+          path: joinPath(path30, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -881,14 +912,14 @@ function walk(value, schema, path29, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path29, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path30, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path29}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path30}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -1082,16 +1113,6 @@ function stripUndefined(obj) {
 }
 
 // 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 = [];
@@ -1178,6 +1199,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);
 }
@@ -1255,14 +1291,14 @@ function safeStringify(value, pretty = false) {
 }
 
 // src/utils/session-scoped-path.ts
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path2.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path2.relative(path2.resolve(dir), resolved);
-  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+  const resolved = path3.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path3.relative(path3.resolve(dir), resolved);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -2316,23 +2352,23 @@ function ulid(seedTime = Date.now()) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os from "node:os";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 function canonicalProjectRoot(absRoot) {
-  const checkoutRoot = path3.resolve(absRoot);
-  const dotGit = path3.join(checkoutRoot, ".git");
+  const checkoutRoot = path4.resolve(absRoot);
+  const dotGit = path4.join(checkoutRoot, ".git");
   try {
-    if (!fs2.statSync(dotGit).isFile()) return checkoutRoot;
-    const gitDirLine = fs2.readFileSync(dotGit, "utf8").trim();
+    if (!fs3.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs3.readFileSync(dotGit, "utf8").trim();
     const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
     if (!match?.[1]) return checkoutRoot;
-    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);
+    const gitDir = path4.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path4.join(gitDir, "commondir");
+    if (!fs3.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path4.resolve(gitDir, fs3.readFileSync(commonDirFile, "utf8").trim());
+    if (path4.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path4.dirname(commonDir);
   } catch {
     return checkoutRoot;
   }
@@ -2342,7 +2378,7 @@ function projectHash(absRoot) {
 }
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
-  const base = slugify2(path3.basename(identityRoot));
+  const base = slugify2(path4.basename(identityRoot));
   const hash2 = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash2}`;
 }
@@ -2351,66 +2387,83 @@ function slugify2(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
-  return path3.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv);
+  return path4.join(os.homedir(), ".wrongstack");
 }
 function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path4.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
   const hash2 = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
-  const projectDir = path3.join(globalRoot, "projects", slug);
+  const projectDir = path4.join(globalRoot, "projects", slug);
   return {
     globalRoot,
     projectRoot: opts.projectRoot,
     homeDir,
     configDir: globalRoot,
-    globalConfig: path3.join(globalRoot, "config.json"),
-    profilesDir: path3.join(globalRoot, "profiles"),
+    globalConfig: path4.join(globalRoot, "config.json"),
+    profilesDir: path4.join(globalRoot, "profiles"),
     profileConfig: (name) => {
       const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
-      return path3.join(globalRoot, "profiles", safe || "default", "config.json");
+      return path4.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
+    profileStatuslineConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path4.join(globalRoot, "profiles", safe || "default", "statusline.json");
+    },
+    profileModeConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path4.join(globalRoot, "profiles", safe || "default", "mode.json");
     },
-    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"),
+    profileProviderStatus: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path4.join(globalRoot, "profiles", safe || "default", "provider-status.json");
+    },
+    profileUpdateCache: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path4.join(globalRoot, "profiles", safe || "default", "update-cache.json");
+    },
+    secretsKey: path4.join(globalRoot, ".key"),
+    globalMemory: path4.join(globalRoot, "memory.md"),
+    globalSkills: path4.join(globalRoot, "skills"),
+    globalClaudeSkills: path4.join(homeDir, ".claude", "skills"),
+    globalDesignKits: path4.join(globalRoot, "design-kits"),
+    globalPrompts: path4.join(globalRoot, "prompts"),
+    globalInstructions: path4.join(globalRoot, "instructions"),
+    promptUsage: path4.join(globalRoot, "prompt-usage.json"),
+    cacheDir: path4.join(globalRoot, "cache"),
+    modelsCache: path4.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path4.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path4.join(globalRoot, "history"),
+    logFile: path4.join(globalRoot, "logs", "wrongstack.log"),
     projectDir,
-    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"),
+    projectCodebaseIndex: path4.join(projectDir, "codebase-index"),
+    projectMemory: path4.join(projectDir, "memory.md"),
+    projectSessions: path4.join(projectDir, "sessions"),
+    projectTrust: path4.join(projectDir, "trust.json"),
+    projectMeta: path4.join(projectDir, "meta.json"),
+    projectLocalConfig: path4.join(projectDir, "config.local.json"),
+    inProjectConfig: path4.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path4.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path4.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectClaudeSkills: path4.join(opts.projectRoot, ".claude", "skills"),
+    inProjectPrompts: path4.join(opts.projectRoot, ".wrongstack", "prompts"),
+    inProjectInstructions: path4.join(opts.projectRoot, ".wrongstack", "instructions"),
+    inProjectDesignKits: path4.join(opts.projectRoot, ".wrongstack", "design-kits"),
+    inProjectWorktrees: path4.join(opts.projectRoot, ".wrongstack", "worktrees"),
     projectHash: hash2,
     projectSlug: slug,
-    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"),
-    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
+    projectGoal: path4.join(projectDir, "goal.json"),
+    projectInputHistory: path4.join(projectDir, "input-history.json"),
+    projectSpecs: path4.join(projectDir, "specs"),
+    projectTaskGraphs: path4.join(projectDir, "task-graphs"),
+    projectSddSession: path4.join(projectDir, "sdd-session.json"),
+    projectPlan: path4.join(projectDir, "plan.json"),
+    projectAutophase: path4.join(projectDir, "autophase"),
+    projectSddBoards: path4.join(projectDir, "sdd-boards"),
+    syncConfig: path4.join(globalRoot, "sync.json"),
+    configHistoryDir: path4.join(globalRoot, "config-history"),
+    projectStatus: (projectHash2) => path4.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
 
@@ -3719,7 +3772,7 @@ var TOOLS = {
 // src/coordination/agents/agent-prompts.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as os2 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { fileURLToPath } from "node:url";
 var promptCache = /* @__PURE__ */ new Map();
 var candidateCache = /* @__PURE__ */ new Map();
@@ -3732,7 +3785,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync2(path4.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync2(path5.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -3741,20 +3794,20 @@ function agentPrompt(id) {
   return resolved;
 }
 function agentPromptDirCandidates(envDir) {
-  const globalRoot = process.env["WRONGSTACK_HOME"] || path4.join(os2.homedir(), ".wrongstack");
+  const globalRoot = process.env["WRONGSTACK_HOME"] || path5.join(os2.homedir(), ".wrongstack");
   const candKey = `${envDir}\0${globalRoot}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path4.dirname(fileURLToPath(import.meta.url));
+  const here = path5.dirname(fileURLToPath(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...explicitDir ? [path4.resolve(explicitDir)] : [],
-    path4.join(globalRoot, "instructions", "agents"),
-    path4.resolve(here, "../../../../instructions/agents"),
-    path4.resolve(here, "../../../instructions/agents"),
-    path4.resolve(here, "../../instructions/agents"),
-    path4.resolve(here, "../instructions/agents"),
-    path4.resolve(here, "instructions/agents")
+    ...explicitDir ? [path5.resolve(explicitDir)] : [],
+    path5.join(globalRoot, "instructions", "agents"),
+    path5.resolve(here, "../../../../instructions/agents"),
+    path5.resolve(here, "../../../instructions/agents"),
+    path5.resolve(here, "../../instructions/agents"),
+    path5.resolve(here, "../instructions/agents"),
+    path5.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   candidateCache.set(candKey, ordered);
@@ -5357,7 +5410,7 @@ function attachAutoExtend(events, policy = {}) {
 
 // src/coordination/delegate-tool.ts
 import * as fsp2 from "node:fs/promises";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/coordination/fleet.ts
@@ -5978,13 +6031,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path5.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path6.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
       const entries = await fsp2.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path5.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path6.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -6031,7 +6084,7 @@ async function readSubagentPartial(opts, subagentId) {
 // src/coordination/director.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import * as fsp5 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // src/storage/director-state.ts
 import * as fsp3 from "node:fs/promises";
@@ -7101,7 +7154,7 @@ var DirectorBtwNotes = class {
 
 // src/utils/instruction-file.ts
 import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
@@ -7111,7 +7164,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync3(path6.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync3(path7.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -7127,11 +7180,11 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path6.dirname(fileURLToPath2(import.meta.url));
+  const here = path7.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path6.resolve(here, "../../instructions"),
-    path6.resolve(here, "../instructions"),
-    path6.resolve(here, "instructions")
+    path7.resolve(here, "../../instructions"),
+    path7.resolve(here, "../instructions"),
+    path7.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   return rootCandidates;
@@ -10679,6 +10732,10 @@ var Director = class _Director {
   largeAnswerStore;
   /** Shared provider/model status tracker, or undefined. */
   statusTracker;
+  /** Session/leader's provider id — absolute last-resort fallback for every spawn. */
+  sessionProvider;
+  /** Session/leader's model id — paired with sessionProvider above. */
+  sessionModel;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID6();
     this.brain = opts.brain;
@@ -10719,6 +10776,8 @@ var Director = class _Director {
     this.fleetManager = opts.fleetManager;
     this.statusTracker = opts.statusTracker;
     this.logger = opts.logger;
+    this.sessionProvider = opts.sessionProvider;
+    this.sessionModel = opts.sessionModel;
     if (this.sharedScratchpadPath) {
       void fsp5.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
@@ -11227,20 +11286,31 @@ var Director = class _Director {
     return result.subagentId;
   }
   resolveSpawnModel(config) {
+    if (config.provider?.trim() === "") config.provider = void 0;
+    if (config.model?.trim() === "") config.model = void 0;
     if (!config.model && this.modelMatrix) {
       const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
       const resolution = resolveModelMatrixResolution(matrix, config.role);
       const entry = resolution?.source === "default" && roleNeedsIndependentReviewModel(config.role) ? void 0 : resolution?.entry;
-      if (entry?.model) {
-        config.model = entry.model;
+      if (entry) {
+        if (entry.model) config.model = entry.model;
         if (entry.provider) config.provider = entry.provider;
         if (entry.fallbackProfile) config.fallbackProfile = entry.fallbackProfile;
         if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
-      } else if (entry?.fallbackProfile) {
-        config.fallbackProfile = entry.fallbackProfile;
-        if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
       }
     }
+    if (!config.provider && this.sessionProvider) {
+      config.provider = this.sessionProvider;
+      this.logger?.info(
+        `spawn: provider="${config.provider}" for role "${config.role ?? "?"}" fell back to session provider (matrix resolution left it undefined)`
+      );
+    }
+    if (!config.model && this.sessionModel) {
+      config.model = this.sessionModel;
+      this.logger?.info(
+        `spawn: model="${config.model}" for role "${config.role ?? "?"}" fell back to session model (matrix resolution left it undefined)`
+      );
+    }
     if (this.statusTracker && config.provider && config.model) {
       if (!this.statusTracker.isAvailable(config.provider, config.model)) {
         this.logger?.warn(
@@ -11455,7 +11525,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp5.mkdir(path7.dirname(this.manifestPath), { recursive: true });
+    await fsp5.mkdir(path8.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -11859,7 +11929,7 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path7.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path8.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
       raw = await fsp5.readFile(filePath, "utf8");
@@ -12013,19 +12083,19 @@ var Director = class _Director {
 };
 
 // src/coordination/director-session.ts
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // src/storage/session-store.ts
 import { createHash as createHash4 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import * as fsp9 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { createInterface } from "node:readline";
 
 // src/storage/file-session-writer.ts
 import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
 import * as fsp6 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 
 // src/storage/session-helpers.ts
 function userInputTitle(content) {
@@ -12042,7 +12112,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path8.join(opts.dir, `${path8.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path9.join(opts.dir, `${path9.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
@@ -12824,7 +12894,7 @@ var FileSessionWriter = class _FileSessionWriter {
 import { spawn } from "node:child_process";
 import { createHash as createHash2, randomUUID as randomUUID7 } from "node:crypto";
 import * as fsp7 from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 
 // src/storage/storage-concurrency.ts
 async function mapWithConcurrency(items, concurrency, mapper) {
@@ -12855,29 +12925,29 @@ function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative5 = path9.relative(root, target);
-  return relative5 === "" || !relative5.startsWith("..") && !path9.isAbsolute(relative5);
+  const relative6 = path10.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path10.isAbsolute(relative6);
 }
 function normalizeRelative(input) {
-  if (!input || path9.isAbsolute(input)) return null;
+  if (!input || path10.isAbsolute(input)) return null;
   const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
-  const resolved = path9.posix.normalize(normalized);
+  const resolved = path10.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(relative5) {
-  return relative5 === ".wrongstack/worktrees" || relative5.startsWith(".wrongstack/worktrees/");
+function isWrongStackWorktreePath(relative6) {
+  return relative6 === ".wrongstack/worktrees" || relative6.startsWith(".wrongstack/worktrees/");
 }
 var SessionCheckpointCas = class {
   rootDir;
   projectRoot;
   runGit;
   constructor(opts) {
-    this.rootDir = path9.resolve(opts.rootDir);
-    this.projectRoot = path9.resolve(opts.projectRoot);
+    this.rootDir = path10.resolve(opts.rootDir);
+    this.projectRoot = path10.resolve(opts.projectRoot);
     this.runGit = opts.runGit ?? defaultRunGit;
   }
   async capture(_sessionId, _promptIndex) {
@@ -12895,46 +12965,46 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative5) => !isWrongStackWorktreePath(relative5)).sort();
+    ].filter((relative6) => !isWrongStackWorktreePath(relative6)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative5) => {
-        const absolute = path9.resolve(this.projectRoot, ...relative5.split("/"));
+      async (relative6) => {
+        const absolute = path10.resolve(this.projectRoot, ...relative6.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative5, reason: "path escapes project root" });
+          unresolved.push({ path: relative6, reason: "path escapes project root" });
           return null;
         }
         try {
           const stat13 = await fsp7.lstat(absolute);
           if (stat13.isSymbolicLink()) {
             const linkTarget = await fsp7.readlink(absolute);
-            const resolvedLink = path9.resolve(path9.dirname(absolute), linkTarget);
-            if (path9.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+            const resolvedLink = path10.resolve(path10.dirname(absolute), linkTarget);
+            if (path10.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
-                path: relative5,
+                path: relative6,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative5, state: "symlink", linkTarget };
+            return { path: relative6, state: "symlink", linkTarget };
           }
           if (!stat13.isFile()) {
-            unresolved.push({ path: relative5, reason: "changed path is not a regular file" });
+            unresolved.push({ path: relative6, reason: "changed path is not a regular file" });
             return null;
           }
           if (stat13.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative5,
+              path: relative6,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
           if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative5,
+              path: relative6,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
@@ -12943,12 +13013,12 @@ var SessionCheckpointCas = class {
           const content = await fsp7.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative5, state: "file", blobHash, mode: stat13.mode & 511 };
+          return { path: relative6, state: "file", blobHash, mode: stat13.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative5, state: "absent" };
+            return { path: relative6, state: "absent" };
           }
-          unresolved.push({ path: relative5, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative6, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -12974,7 +13044,7 @@ var SessionCheckpointCas = class {
     };
   }
   async materialize(checkpoint, targetRoot) {
-    const target = path9.resolve(targetRoot);
+    const target = path10.resolve(targetRoot);
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
@@ -13014,10 +13084,10 @@ var SessionCheckpointCas = class {
       try {
         const output = await this.safeOutputPath(target, realTarget, entry.path);
         if (entry.state === "symlink") {
-          if (path9.isAbsolute(entry.linkTarget)) {
+          if (path10.isAbsolute(entry.linkTarget)) {
             throw new Error("absolute symlink target refused");
           }
-          const resolvedLink = path9.resolve(path9.dirname(output), entry.linkTarget);
+          const resolvedLink = path10.resolve(path10.dirname(output), entry.linkTarget);
           if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
@@ -13045,7 +13115,7 @@ var SessionCheckpointCas = class {
           await fsp7.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp7.mkdir(path9.dirname(output), { recursive: true });
+          await fsp7.mkdir(path10.dirname(output), { recursive: true });
           await fsp7.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
@@ -13062,15 +13132,15 @@ var SessionCheckpointCas = class {
   }
   objectPath(hash2) {
     if (!HASH_RE.test(hash2)) throw new Error(`Invalid CAS object hash: ${hash2}`);
-    return path9.join(this.rootDir, "objects", hash2.slice(0, 2), hash2.slice(2));
+    return path10.join(this.rootDir, "objects", hash2.slice(0, 2), hash2.slice(2));
   }
   manifestPath(hash2) {
     if (!HASH_RE.test(hash2)) throw new Error(`Invalid checkpoint manifest hash: ${hash2}`);
-    return path9.join(this.rootDir, "manifests", `${hash2}.json`);
+    return path10.join(this.rootDir, "manifests", `${hash2}.json`);
   }
   async putBlob(hash2, content) {
     const target = this.objectPath(hash2);
-    await fsp7.mkdir(path9.dirname(target), { recursive: true });
+    await fsp7.mkdir(path10.dirname(target), { recursive: true });
     try {
       const existing = await fsp7.readFile(target);
       if (sha256(existing) !== hash2) throw new Error(`Corrupt CAS object collision: ${hash2}`);
@@ -13078,9 +13148,9 @@ var SessionCheckpointCas = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    const temp = path9.join(
-      path9.dirname(target),
-      `.${path9.basename(target)}.${process.pid}.${randomUUID7()}.tmp`
+    const temp = path10.join(
+      path10.dirname(target),
+      `.${path10.basename(target)}.${process.pid}.${randomUUID7()}.tmp`
     );
     let handle;
     try {
@@ -13138,10 +13208,10 @@ var SessionCheckpointCas = class {
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative5) {
-    const normalized = normalizeRelative(relative5);
+  async safeOutputPath(target, realTarget, relative6) {
+    const normalized = normalizeRelative(relative6);
     if (!normalized) throw new Error("invalid relative path");
-    const output = path9.resolve(target, ...normalized.split("/"));
+    const output = path10.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
     let probe = output;
     for (; ; ) {
@@ -13151,7 +13221,7 @@ var SessionCheckpointCas = class {
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path9.dirname(probe);
+        const parent = path10.dirname(probe);
         if (parent === probe) throw err;
         probe = parent;
       }
@@ -13217,13 +13287,13 @@ function generateSessionId(startedAt, _model) {
 // src/storage/session-resume-validation.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fsp8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative5 = path10.relative(root, target);
-  return relative5 === "" || !relative5.startsWith("..") && !path10.isAbsolute(relative5);
+  const relative6 = path11.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path11.isAbsolute(relative6);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -13234,7 +13304,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 = path10.resolve(projectRoot, event.path);
+    const normalized = path11.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -13292,7 +13362,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path10.resolve(projectRoot);
+  const lexicalRoot = path11.resolve(projectRoot);
   const realRoot = await fsp8.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
@@ -13308,10 +13378,10 @@ async function validateResumeFileObservations(events, projectRoot) {
 }
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path10.resolve(projectRoot);
+  const root = path11.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative5 = path10.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative5 || "." : entry.path;
+    const relative6 = path11.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative6 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
   const omitted = validation.staleFiles.length - shown.length;
@@ -13444,9 +13514,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path11.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path12.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path11.join(this.dir, "_cas"),
+      rootDir: path12.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     this.events = opts.events;
@@ -13512,17 +13582,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path11.join(this.dir, "_index.jsonl");
+    return path12.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 ? path11.join(this.dir, shardKey, "_manifest.json") : path11.join(this.dir, "_manifest.json");
+    return shardKey ? path12.join(this.dir, shardKey, "_manifest.json") : path12.join(this.dir, "_manifest.json");
   }
   shardKeyForSessionId(id) {
-    const dirName = path11.dirname(id);
+    const dirName = path12.dirname(id);
     return dirName === "." ? "" : dirName;
   }
   invalidateShardManifestBySessionId(id) {
@@ -13534,7 +13604,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path11.dirname(sessionScopedPath(this.dir, id, ""));
+    const dirPath = path12.dirname(sessionScopedPath(this.dir, id, ""));
     await ensureDir(dirPath);
     return dirPath;
   }
@@ -13698,7 +13768,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: path11.dirname(file),
+          dir: path12.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           checkpointCas: this.checkpointCas,
@@ -14319,7 +14389,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return entry;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path11.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path12.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("/"));
   }
@@ -14342,13 +14412,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: path11.join(dir, entry.name) });
+        files.push({ id, filePath: path12.join(dir, entry.name) });
       }
     }
     const childFileArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path11.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionFiles(path12.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childFileArrays.flat(), ...files];
@@ -14381,7 +14451,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(path11.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionIds(path12.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childIdArrays.flat(), ...fileIds];
@@ -14496,9 +14566,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path11.dirname(jsonlPath);
-    const base = path11.basename(id);
-    const sessDir = path11.join(shardDir, base);
+    const shardDir = path12.dirname(jsonlPath);
+    const base = path12.basename(id);
+    const sessDir = path12.join(shardDir, base);
     const deletions = [
       fsp9.unlink(jsonlPath),
       fsp9.unlink(summaryPath),
@@ -14543,7 +14613,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async readActiveSessionId() {
     try {
-      const raw = await fsp9.readFile(path11.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp9.readFile(path12.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       return active.sessionId ?? null;
     } catch {
@@ -14606,7 +14676,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 = path11.join(dir, name);
+      const jsonlPath = path12.join(dir, name);
       try {
         const stat13 = await fsp9.stat(jsonlPath);
         if (stat13.mtimeMs >= cutoff) return;
@@ -14626,7 +14696,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         continue;
       }
       if (!entry.isDirectory()) continue;
-      const dateDir = path11.join(this.dir, entry.name);
+      const dateDir = path12.join(this.dir, entry.name);
       const files = await fsp9.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
@@ -14638,7 +14708,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dateDir = path11.join(this.dir, entry.name);
+      const dateDir = path12.join(this.dir, entry.name);
       try {
         const remaining = await fsp9.readdir(dateDir);
         if (remaining.length === 0) {
@@ -14769,9 +14839,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path12.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path13.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path12.join(opts.sessionsRoot, runId);
+    dir = path13.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -16117,8 +16187,8 @@ function isDesignStack(v) {
 
 // src/execution/design-kit-loader.ts
 import { existsSync } from "node:fs";
-import * as fs3 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path14 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var KIT_FILE = "KIT.md";
 var TOKENS_FILE = "tokens.json";
@@ -16225,15 +16295,15 @@ var DefaultDesignKitLoader = class {
     for (const { dir, source } of this.dirs) {
       let entries;
       try {
-        entries = await fs3.readdir(dir, { withFileTypes: true });
+        entries = await fs4.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (!e.isDirectory()) continue;
-        const kitFile = path13.join(dir, e.name, KIT_FILE);
+        const kitFile = path14.join(dir, e.name, KIT_FILE);
         try {
-          const raw = await fs3.readFile(kitFile, "utf8");
+          const raw = await fs4.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
           const id = fm.id ?? e.name;
           if (!fm.name) continue;
@@ -16294,7 +16364,7 @@ var DefaultDesignKitLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(id);
     if (!m) throw new Error(`Design kit "${id}" not found`);
-    const raw = await fs3.readFile(m.path, "utf8");
+    const raw = await fs4.readFile(m.path, "utf8");
     const body = narrowStackSections(stripFrontmatter(raw), stack);
     this.bodyCache.set(key, body);
     return body;
@@ -16305,9 +16375,9 @@ var DefaultDesignKitLoader = class {
     const m = await this.find(id);
     let tokens;
     if (m) {
-      const tokensPath = path13.join(path13.dirname(m.path), TOKENS_FILE);
+      const tokensPath = path14.join(path14.dirname(m.path), TOKENS_FILE);
       try {
-        const raw = await fs3.readFile(tokensPath, "utf8");
+        const raw = await fs4.readFile(tokensPath, "utf8");
         const parsed = JSON.parse(raw);
         tokens = parsed;
       } catch {
@@ -16332,12 +16402,12 @@ var DefaultDesignKitLoader = class {
 };
 function resolveBundledDesignKitsDir() {
   try {
-    const here = path13.dirname(fileURLToPath3(import.meta.url));
+    const here = path14.dirname(fileURLToPath3(import.meta.url));
     const candidates = [
-      path13.join(here, "design-kits"),
-      path13.join(here, "..", "design-kits"),
-      path13.join(here, "..", "..", "design-kits"),
-      path13.join(here, "..", "..", "..", "design-kits")
+      path14.join(here, "design-kits"),
+      path14.join(here, "..", "design-kits"),
+      path14.join(here, "..", "..", "design-kits"),
+      path14.join(here, "..", "..", "..", "design-kits")
     ];
     for (const c of candidates) {
       if (existsSync(c)) return c;
@@ -16365,11 +16435,11 @@ function _resetDesignKitLoaderMemo() {
 
 // src/execution/design-project-store.ts
 import { existsSync as existsSync2 } from "node:fs";
-import * as fs4 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as fs5 from "node:fs/promises";
+import * as path15 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
-  return path14.join(projectRoot, DESIGN_DIR);
+  return path15.join(projectRoot, DESIGN_DIR);
 }
 var RULE_FILES = ["rules.md", "RULES.md", "design.md"];
 var rulesCache = /* @__PURE__ */ new Map();
@@ -16378,7 +16448,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs4.readFile(path14.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs5.readFile(path15.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -16399,7 +16469,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs4.readFile(path14.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs5.readFile(path15.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -16432,11 +16502,11 @@ function applyTokenOverrides(tokens, overrides) {
 }
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
-  await fs4.mkdir(dir, { recursive: true });
-  const gi = path14.join(dir, ".gitignore");
+  await fs5.mkdir(dir, { recursive: true });
+  const gi = path15.join(dir, ".gitignore");
   if (!existsSync2(gi)) {
     try {
-      await fs4.writeFile(gi, "*\n");
+      await fs5.writeFile(gi, "*\n");
     } catch {
     }
   }
@@ -16447,11 +16517,11 @@ async function recordKitChoice(projectRoot, kit, stack, source, isoTime, overrid
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit, stack: stack ?? null };
     if (overrides && Object.keys(overrides).length > 0) record.overrides = overrides;
-    await fs4.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs5.writeFile(path15.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs4.appendFile(path14.join(dir, "decisions.md"), line);
+    await fs5.appendFile(path15.join(dir, "decisions.md"), line);
   } catch {
   }
 }
@@ -16467,11 +16537,11 @@ async function recordOverrides(projectRoot, patch, isoTime) {
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit: active.kit, stack: active.stack ?? null };
     if (Object.keys(merged).length > 0) record.overrides = merged;
-    await fs4.writeFile(path14.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs5.writeFile(path15.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const keys = Object.keys(patch).join(",");
-    await fs4.appendFile(
-      path14.join(dir, "decisions.md"),
+    await fs5.appendFile(
+      path15.join(dir, "decisions.md"),
       `- ${isoTime} \xB7 kit=${active.kit} \xB7 override=${keys} \xB7 via=set
 `
     );
@@ -16481,7 +16551,7 @@ async function recordOverrides(projectRoot, patch, isoTime) {
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs4.rm(path14.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs5.rm(path15.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -16597,12 +16667,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path29, text } of files) {
+  for (const { path: path30, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path29, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path30, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -16654,14 +16724,14 @@ var SKIP_DIR = /* @__PURE__ */ new Set([
   ".design"
 ]);
 async function walkUiFiles(root, max = 200) {
-  const { default: fs15 } = await import("node:fs/promises");
+  const { default: fs16 } = await import("node:fs/promises");
   const { default: nodePath } = await import("node:path");
   const found = [];
   async function rec(dir, depth) {
     if (found.length >= max || depth > 8) return;
     let entries;
     try {
-      entries = await fs15.readdir(dir, { withFileTypes: true });
+      entries = await fs16.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -16679,13 +16749,13 @@ async function walkUiFiles(root, max = 200) {
   return found;
 }
 async function runDesignVerify(projectRoot, tokens, explicitFiles) {
-  const { default: fs15 } = await import("node:fs/promises");
+  const { default: fs16 } = await import("node:fs/promises");
   const { default: nodePath } = await import("node:path");
   const abs = explicitFiles && explicitFiles.length > 0 ? explicitFiles.map((f) => nodePath.isAbsolute(f) ? f : nodePath.join(projectRoot, f)) : await walkUiFiles(projectRoot);
   const files = [];
   for (const a of abs) {
     try {
-      files.push({ path: nodePath.relative(projectRoot, a), text: await fs15.readFile(a, "utf8") });
+      files.push({ path: nodePath.relative(projectRoot, a), text: await fs16.readFile(a, "utf8") });
     } catch {
     }
   }
@@ -16816,10 +16886,10 @@ function makeDesignVerifyToolCallMiddleware() {
         const p = typeof input?.path === "string" ? input.path : "";
         if (!p || !detectFrontendFile(p)) return out;
         const ctx = out.ctx;
-        const { default: fs15 } = await import("node:fs/promises");
+        const { default: fs16 } = await import("node:fs/promises");
         const { default: nodePath } = await import("node:path");
         const abs = nodePath.isAbsolute(p) ? p : nodePath.join(ctx.projectRoot, p);
-        const text = await fs15.readFile(abs, "utf8").catch(() => "");
+        const text = await fs16.readFile(abs, "utf8").catch(() => "");
         if (!text) return out;
         const loader = getDesignKitLoader(ctx.projectRoot);
         const rawTokens = await loader.readTokens(state.activeKit);
@@ -19915,8 +19985,8 @@ Summarize the following message range:`;
 };
 
 // src/execution/skill-loader.ts
-import * as fs5 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path16 from "node:path";
 
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
@@ -20146,7 +20216,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs5.stat(path15.join(dir, entry.name))).isDirectory();
+      return (await fs6.stat(path16.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -20167,7 +20237,7 @@ var DefaultSkillLoader = class {
       for (const tool of FOREIGN_SKILL_TOOLS) {
         if (!foreignIds.includes(tool.id)) continue;
         dirs.push({
-          dir: path15.join(root, "." + tool.id, tool.subdir),
+          dir: path16.join(root, "." + tool.id, tool.subdir),
           source: "foreign",
           originTool: tool.id
         });
@@ -20189,14 +20259,14 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = (await fs5.readdir(dir, { withFileTypes: true })).sort(
+        const entries = (await fs6.readdir(dir, { withFileTypes: true })).sort(
           (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
         );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
-          const skillFile = path15.join(dir, e.name, "SKILL.md");
+          const skillFile = path16.join(dir, e.name, "SKILL.md");
           try {
-            const raw = await fs5.readFile(skillFile, "utf8");
+            const raw = await fs6.readFile(skillFile, "utf8");
             const fm = parseSkillFrontmatter(raw);
             if (!fm.name || !fm.description) continue;
             if (!isValidSkillNameFormat(fm.name)) continue;
@@ -20268,7 +20338,7 @@ var DefaultSkillLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const body = await fs5.readFile(m.path, "utf8");
+    const body = await fs6.readFile(m.path, "utf8");
     this.bodyCache.set(key, body);
     return body;
   }
@@ -20278,12 +20348,12 @@ var DefaultSkillLoader = class {
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const savePath = path15.join(path15.dirname(m.path), "SKILL.save.md");
+    const savePath = path16.join(path16.dirname(m.path), "SKILL.save.md");
     let result;
     try {
-      result = await fs5.readFile(savePath, "utf8");
+      result = await fs6.readFile(savePath, "utf8");
     } catch {
-      const full = await fs5.readFile(m.path, "utf8");
+      const full = await fs6.readFile(m.path, "utf8");
       const body = stripFrontmatter2(full);
       const compact = compactSkillBody(body);
       if (compact) {
@@ -20311,12 +20381,12 @@ function parseDescriptionFromText(desc) {
 }
 
 // src/execution/prompt-loader.ts
-import * as fs7 from "node:fs/promises";
-import * as path17 from "node:path";
+import * as fs8 from "node:fs/promises";
+import * as path18 from "node:path";
 
 // src/storage/prompt-store.ts
-import * as fs6 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path17 from "node:path";
 var SCHEMA_VERSION = 2;
 function migratePromptEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -20377,12 +20447,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs6.readdir(this.dir);
+      const files = await fs7.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs6.readFile(path16.join(this.dir, file), "utf8")
+            await fs7.readFile(path17.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -20396,9 +20466,9 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path16.join(this.dir, `${id}.json`);
+    const file = path17.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs6.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs7.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -20406,14 +20476,14 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path16.join(this.dir, `${entry.id}.json`);
+    const file = path17.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 = path16.join(this.dir, `${id}.json`);
+    const file = path17.join(this.dir, `${id}.json`);
     try {
-      await fs6.unlink(file);
+      await fs7.unlink(file);
       return true;
     } catch {
       return false;
@@ -20500,7 +20570,7 @@ var DefaultPromptLoader = class {
   constructor(opts) {
     this.projectStore = typeof opts.paths.inProjectPrompts === "string" ? new DefaultPromptStore(opts.paths.inProjectPrompts) : void 0;
     this.userStore = typeof opts.paths.globalPrompts === "string" ? new DefaultPromptStore(opts.paths.globalPrompts) : void 0;
-    this.builtinDir = opts.bundledDir ? path17.join(opts.bundledDir, "prompts") : void 0;
+    this.builtinDir = opts.bundledDir ? path18.join(opts.bundledDir, "prompts") : void 0;
   }
   async list() {
     if (this.cache) return this.cache;
@@ -20613,7 +20683,7 @@ var DefaultPromptLoader = class {
     const files = await walkJson(dir);
     for (const file of files) {
       try {
-        const parsed = JSON.parse(await fs7.readFile(file, "utf8"));
+        const parsed = JSON.parse(await fs8.readFile(file, "utf8"));
         const migrated = migratePromptEntry(parsed);
         if (migrated) out.push({ ...migrated, source: "builtin" });
       } catch {
@@ -20627,12 +20697,12 @@ async function walkJson(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs7.readdir(dir, { withFileTypes: true });
+    entries = await fs8.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const e of entries) {
-    const full = path17.join(dir, e.name);
+    const full = path18.join(dir, e.name);
     if (e.isDirectory()) {
       out.push(...await walkJson(full));
     } else if (e.name.endsWith(".json") && e.name !== "index.json" && e.name !== "schema.json") {
@@ -20818,7 +20888,7 @@ function readPolicy(ctx) {
 }
 
 // src/execution/tool-executor.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID11 } from "node:crypto";
 
 // src/observability/process-telemetry.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -20829,12 +20899,12 @@ function runWithProcessTelemetry(context, run) {
 
 // src/execution/tool-executor.ts
 import { isDeepStrictEqual } from "node:util";
-import * as fs8 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path20 from "node:path";
 
 // src/security/kanban-boundary.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import {
   evaluateKanbanBoundaryOpaque,
   evaluateKanbanBoundaryPath,
@@ -20909,10 +20979,10 @@ function resolveKanbanIdentity(ctx) {
 async function extractCandidatePaths(toolName, input, ctx) {
   if (toolName === "patch" && typeof input["patch"] === "string") {
     const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
-    const directory = path18.isAbsolute(directoryInput) ? directoryInput : path18.resolve(ctx.workingDir, directoryInput);
+    const directory = path19.isAbsolute(directoryInput) ? directoryInput : path19.resolve(ctx.workingDir, directoryInput);
     const strip = Math.max(1, numericValue(input["strip"]) ?? 1);
     const targets = extractPatchTargets(input["patch"], strip).map(
-      (target) => relativeToProject(path18.resolve(directory, target), ctx.projectRoot)
+      (target) => relativeToProject(path19.resolve(directory, target), ctx.projectRoot)
     );
     return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
   }
@@ -20922,7 +20992,7 @@ async function extractCandidatePaths(toolName, input, ctx) {
   collectPathValues(input, values, pathKeys);
   if (toolName === "scaffold" && typeof input["name"] === "string") {
     const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
-    values.push(path18.join(cwd, input["name"]));
+    values.push(path19.join(cwd, input["name"]));
   }
   const candidates = [
     ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
@@ -20930,21 +21000,21 @@ async function extractCandidatePaths(toolName, input, ctx) {
   return Promise.all(candidates.map((candidate) => canonicalizeCandidatePath(candidate, ctx)));
 }
 async function canonicalizeCandidatePath(candidate, ctx) {
-  if (path18.isAbsolute(candidate)) return candidate;
-  const absolute = path18.resolve(ctx.projectRoot, candidate);
+  if (path19.isAbsolute(candidate)) return candidate;
+  const absolute = path19.resolve(ctx.projectRoot, candidate);
   const canonicalRoot = await realpath3(ctx.projectRoot).catch(() => ctx.projectRoot);
   let probe = absolute;
   const missingSegments = [];
   while (true) {
     try {
-      const canonical = path18.join(await realpath3(probe), ...missingSegments);
+      const canonical = path19.join(await realpath3(probe), ...missingSegments);
       return relativeToProject(canonical, canonicalRoot);
     } catch (cause) {
       const code = cause.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return absolute;
-      const parent = path18.dirname(probe);
+      const parent = path19.dirname(probe);
       if (parent === probe) return absolute;
-      missingSegments.unshift(path18.basename(probe));
+      missingSegments.unshift(path19.basename(probe));
       probe = parent;
     }
   }
@@ -20967,12 +21037,12 @@ function splitPathList(value) {
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
 function resolveInputPath(value, ctx) {
-  const absolute = path18.isAbsolute(value) ? value : path18.resolve(ctx.workingDir, value);
+  const absolute = path19.isAbsolute(value) ? value : path19.resolve(ctx.workingDir, value);
   return relativeToProject(absolute, ctx.projectRoot);
 }
 function relativeToProject(absolute, projectRoot) {
-  const relative5 = path18.relative(projectRoot, absolute).replace(/\\/g, "/");
-  return relative5.startsWith("../") || path18.isAbsolute(relative5) ? absolute : relative5 || ".";
+  const relative6 = path19.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative6.startsWith("../") || path19.isAbsolute(relative6) ? absolute : relative6 || ".";
 }
 function extractPatchTargets(patchText, strip) {
   const targets = [];
@@ -21226,12 +21296,30 @@ ${errorDetails}`,
       const policy = this.opts.permissionPolicy;
       const yolo = policy.getYolo?.() === true;
       const authoritativeAuto = decision.source === "yolo";
-      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto) {
+      const capabilityDowngraded = toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto;
+      if (capabilityDowngraded) {
         effectivePermission = "confirm";
       }
       if (boundary.decision === "confirm" && effectivePermission !== "deny") {
         effectivePermission = "confirm";
       }
+      this.opts.events?.emit("permission.evaluated", {
+        sessionId: ctx.session.id,
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        ...ctx.agentId ? { agentId: ctx.agentId } : {},
+        name: tool.name,
+        id: use.id,
+        inputHash: hashPermissionInput(use.input, this.opts.secretScrubber),
+        policyDecision: decision.permission,
+        effectiveDecision: effectivePermission,
+        decisionSource: decision.source,
+        ...decision.reason ? { reason: decision.reason } : {},
+        ...decision.riskTier ?? tool.riskTier ? { riskTier: decision.riskTier ?? tool.riskTier } : {},
+        yoloEnabled: yolo,
+        boundaryDecision: boundary.decision,
+        ...boundary.reason ? { boundaryReason: boundary.reason } : {},
+        capabilityDowngraded
+      });
       if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
         budget = this.budgetForString(result.content, budget);
@@ -21298,10 +21386,10 @@ ${errorDetails}`,
         const inputPath = use.input && typeof use.input === "object" ? use.input.path : void 0;
         const caps = tool.capabilities ?? [];
         const hasFileCapability = caps.includes("fs.read") || caps.includes("fs.write");
-        const absPath = hasFileCapability && typeof inputPath === "string" ? path19.isAbsolute(inputPath) ? inputPath : path19.resolve(ctx.projectRoot, inputPath) : void 0;
+        const absPath = hasFileCapability && typeof inputPath === "string" ? path20.isAbsolute(inputPath) ? inputPath : path20.resolve(ctx.projectRoot, inputPath) : void 0;
         let writeTargetExisted;
         if (tool.name === "write" && caps.includes("fs.write") && absPath) {
-          writeTargetExisted = await fs8.stat(absPath).then(
+          writeTargetExisted = await fs9.stat(absPath).then(
             (stat13) => stat13.isFile(),
             (error2) => error2.code === "ENOENT" ? false : void 0
           );
@@ -21890,12 +21978,12 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path19.join(wstackGlobalRoot(), "tool-output");
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path20.join(wstackGlobalRoot(), "tool-output");
+    await fs9.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = path19.join(dir, `${stamp}-${safeTool}-${randomUUID11()}.log`);
-    await fs8.writeFile(filePath, content, "utf8");
+    const filePath = path20.join(dir, `${stamp}-${safeTool}-${randomUUID11()}.log`);
+    await fs9.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
     const previewBytes = Math.min(
@@ -21913,6 +22001,15 @@ ${head}${TOOL_OUTPUT_ARTIFACT_OMISSION}${tail}`;
     return content;
   }
 }
+function hashPermissionInput(input, scrubber) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(input) ?? "";
+  } catch {
+    serialized = String(input);
+  }
+  return createHash6("sha256").update(scrubber.scrub(serialized), "utf8").digest("hex");
+}
 function sliceUtf8Prefix(text, maxBytes) {
   if (maxBytes <= 0) return "";
   if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
@@ -22206,7 +22303,7 @@ var contextManagerTool = createContextManagerTool();
 
 // src/infrastructure/logger.ts
 import * as fsp11 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 var LEVEL_RANK2 = {
   error: 0,
   warn: 1,
@@ -22270,7 +22367,7 @@ var DefaultLogger = class _DefaultLogger {
     this.stderr = opts.stderr !== false;
     this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
     if (this.file) {
-      const dir = path20.dirname(this.file);
+      const dir = path21.dirname(this.file);
       this._tail = this._tail.then(async () => {
         await fsp11.mkdir(dir, { recursive: true });
       }).catch(() => void 0);
@@ -22591,28 +22688,28 @@ function codexModelMeta(id) {
 }
 
 // src/models/mode-store.ts
-import * as fs9 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as fs10 from "node:fs/promises";
+import * as path23 from "node:path";
 
 // src/types/mode-prompts.ts
 import { readFileSync as readFileSync4, statSync as statSync4 } from "node:fs";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync4(path21.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync4(path22.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
   return "";
 }
 function modePromptDirCandidates() {
-  const here = path21.dirname(fileURLToPath4(import.meta.url));
+  const here = path22.dirname(fileURLToPath4(import.meta.url));
   const candidates = [
-    path21.resolve(here, "../../instructions/modes"),
-    path21.resolve(here, "../instructions/modes"),
-    path21.resolve(here, "instructions/modes")
+    path22.resolve(here, "../../instructions/modes"),
+    path22.resolve(here, "../instructions/modes"),
+    path22.resolve(here, "instructions/modes")
   ];
   return candidates.sort((a, b) => Number(!isDirectory3(a)) - Number(!isDirectory3(b)));
 }
@@ -22844,8 +22941,8 @@ var DefaultModeStore = class {
   }
   async loadActiveMode() {
     try {
-      const configPath = path22.join(this.configDir, "mode.json");
-      const content = await fs9.readFile(configPath, "utf8");
+      const configPath = path23.join(this.configDir, "mode.json");
+      const content = await fs10.readFile(configPath, "utf8");
       const data = JSON.parse(content);
       this.activeModeId = data.activeMode ?? null;
     } catch {
@@ -22854,8 +22951,8 @@ var DefaultModeStore = class {
   }
   async saveActiveMode() {
     try {
-      await fs9.mkdir(this.configDir, { recursive: true });
-      const configPath = path22.join(this.configDir, "mode.json");
+      await fs10.mkdir(this.configDir, { recursive: true });
+      const configPath = path23.join(this.configDir, "mode.json");
       await atomicWrite(
         configPath,
         JSON.stringify({ activeMode: this.activeModeId }, null, 2)
@@ -22867,14 +22964,14 @@ var DefaultModeStore = class {
 async function loadProjectModes(modesDir) {
   const modes = [];
   try {
-    const entries = await fs9.readdir(modesDir);
+    const entries = await fs10.readdir(modesDir);
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
-      const filePath = path22.join(modesDir, entry);
-      const stat13 = await fs9.stat(filePath);
+      const filePath = path23.join(modesDir, entry);
+      const stat13 = await fs10.stat(filePath);
       if (!stat13.isFile()) continue;
-      const content = await fs9.readFile(filePath, "utf8");
-      const id = path22.basename(entry, path22.extname(entry));
+      const content = await fs10.readFile(filePath, "utf8");
+      const id = path23.basename(entry, path23.extname(entry));
       modes.push({
         id,
         name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
@@ -22890,8 +22987,8 @@ async function loadProjectModes(modesDir) {
 async function loadUserModes(modesDir) {
   const modes = [];
   try {
-    const manifestPath = path22.join(modesDir, "modes.json");
-    const content = await fs9.readFile(manifestPath, "utf8");
+    const manifestPath = path23.join(modesDir, "modes.json");
+    const content = await fs10.readFile(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     for (const mode of manifest.modes) {
       modes.push(mode);
@@ -22902,8 +22999,8 @@ async function loadUserModes(modesDir) {
 }
 
 // src/models/models-registry.ts
-import * as fs10 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as fs11 from "node:fs/promises";
+import * as path24 from "node:path";
 var DEFAULT_URL = "https://models.dev/api.json";
 var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
@@ -22979,7 +23076,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path23.join(path23.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path24.join(path24.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -23144,7 +23241,7 @@ var DefaultModelsRegistry = class {
   async readOverlayFile() {
     if (!this.overlayFile) return void 0;
     try {
-      const raw = await fs10.readFile(this.overlayFile, "utf8");
+      const raw = await fs11.readFile(this.overlayFile, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -23223,7 +23320,7 @@ var DefaultModelsRegistry = class {
   }
   async readCacheAt(file) {
     try {
-      const raw = await fs10.readFile(file, "utf8");
+      const raw = await fs11.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -23231,7 +23328,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path23.resolve(this.cacheFile);
+    return path24.resolve(this.cacheFile);
   }
 };
 function formatAge(seconds) {
@@ -23655,7 +23752,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path29 = opts.path ?? "/metrics";
+  const path30 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -23665,7 +23762,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path29) {
+    if (url === path30) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -23729,7 +23826,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path29}`,
+    url: `${protocol}://${host}:${boundPort}${path30}`,
     close: () => new Promise((resolve14, reject) => {
       server.close((err) => err ? reject(err) : resolve14());
     })
@@ -24001,7 +24098,7 @@ function startOtlpTraceExporter(opts) {
 }
 
 // src/security/permission-policy.ts
-import * as fs11 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 
 // src/security/permission-policy-schema.ts
 var TRUST_POLICY_LIMITS = Object.freeze({
@@ -24046,19 +24143,19 @@ var UNSAFE_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function error(diagnostics, code, path29, message) {
-  diagnostics.push({ severity: "error", code, path: path29, message });
+function error(diagnostics, code, path30, message) {
+  diagnostics.push({ severity: "error", code, path: path30, message });
 }
-function validatePatterns(value, path29, diagnostics) {
+function validatePatterns(value, path30, diagnostics) {
   if (!Array.isArray(value)) {
-    error(diagnostics, "invalid_pattern_list", path29, "must be an array of strings");
+    error(diagnostics, "invalid_pattern_list", path30, "must be an array of strings");
     return void 0;
   }
   if (value.length > TRUST_POLICY_LIMITS.maxPatternsPerRule) {
     error(
       diagnostics,
       "too_many_patterns",
-      path29,
+      path30,
       `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
     );
     return void 0;
@@ -24066,7 +24163,7 @@ function validatePatterns(value, path29, diagnostics) {
   const patterns = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, pattern] of value.entries()) {
-    const itemPath = `${path29}[${index}]`;
+    const itemPath = `${path30}[${index}]`;
     if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
       error(
         diagnostics,
@@ -24390,7 +24487,7 @@ var DefaultPermissionPolicy = class {
     this.policyDiagnostics = [];
     this.policyInvalid = false;
     try {
-      const raw = await fs11.readFile(this.trustFile, "utf8");
+      const raw = await fs12.readFile(this.trustFile, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok) {
         this.policy = {};
@@ -24640,6 +24737,136 @@ var DefaultPermissionPolicy = class {
     this.sessionAllowed.set(`${rule.tool}::${rule.pattern}`, true);
     this._evalCache.clear();
   }
+  /**
+   * Side-effect-free permission evaluation trace. Mirrors `evaluate()`
+   * step-by-step without prompting the user, writing to trust files, or
+   * mutating session state. Returns the full ordered trace and winner.
+   */
+  async explain(tool, input, ctx) {
+    if (!this.loaded) await this.reload();
+    const subject = subjectForToolInput(tool.name, input, tool.subjectKey);
+    const steps = [];
+    let winnerIndex = -1;
+    const add = (rule, matched, decision, source, detail) => {
+      steps.push({ rule, matched, decision, source, detail });
+    };
+    if (this.policyInvalid) {
+      add("policy invalid", true, "deny", "deny", "trust policy is invalid; all tools are denied");
+      winnerIndex = 0;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "deny", source: "deny", reason: "trust policy is invalid" } };
+    }
+    add("policy valid", false, "auto", "default", "trust policy loaded successfully");
+    const namespaceEntry = this.findNamespaceEntry(tool.name);
+    const entry = this.policy[tool.name] ?? namespaceEntry;
+    const namespaceSource = namespaceEntry ? `wildcard entry matched (${Object.keys(this.policy).find((k) => k.includes("*") && matchGlob(k, tool.name))})` : "no namespace match";
+    const cacheKey = `${tool.name}::${subject ?? tool.name}`;
+    if (this.sessionDenied.has(cacheKey)) {
+      add("session soft deny", true, "deny", "deny", 'user pressed "no" earlier in this session \u2014 blocked until reload');
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" } };
+    }
+    add("session soft deny", false, "deny", "deny", "no session-level soft deny for this tool+subject");
+    if (this.sessionAllowed.has(cacheKey)) {
+      add("session soft allow", true, "auto", "trust", 'user pressed "yes" in current session \u2014 one-shot auto-approve (consumed)');
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "trust", reason: "session one-shot allow (user pressed yes)" } };
+    }
+    add("session soft allow", false, "auto", "trust", "no session-level one-shot allow for this tool+subject");
+    if (entry?.deny && subject && matchesTrust(entry.deny, subject)) {
+      add("trust deny", true, "deny", "deny", `subject "${subject}" matched a deny pattern in trust file`);
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "deny", source: "deny", reason: "matched deny pattern" } };
+    }
+    add("trust deny", false, "deny", "deny", `no deny pattern matched (namespace: ${namespaceSource})`);
+    if (tool.permission === "deny") {
+      add("tool default deny", true, "deny", "default", `tool "${tool.name}" has permission: deny by default`);
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "deny", source: "default", reason: "tool default deny" } };
+    }
+    add("tool default deny", false, "deny", "default", `tool "${tool.name}" has permission: "${tool.permission}"`);
+    if (entry?.allow && subject && matchesTrust(entry.allow, subject)) {
+      add("trust allow", true, "auto", "trust", `subject "${subject}" matched an allow pattern in trust file`);
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "trust", reason: "matched allow pattern" } };
+    }
+    add("trust allow", false, "auto", "trust", `no allow pattern matched (namespace: ${namespaceSource})`);
+    if (entry?.auto) {
+      add("trust auto", true, "auto", "trust", `trust file has auto: true for "${tool.name}"`);
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "trust", reason: "trust auto" } };
+    }
+    add("trust auto", false, "auto", "trust", `no auto flag for "${tool.name}" in trust file`);
+    if (!this.yolo && this.isSensitiveReadCall(tool, input)) {
+      const hasDelegate2 = this.promptDelegate !== void 0;
+      add(
+        "sensitive read",
+        true,
+        hasDelegate2 ? "confirm" : "confirm",
+        "default",
+        hasDelegate2 ? "sensitive file read detected \u2014 would prompt user for approval" : "sensitive file read detected \u2014 returns confirm (no prompt delegate)"
+      );
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "confirm", source: "default", riskTier: "standard", reason: "sensitive file read needs explicit approval" } };
+    }
+    add("sensitive read", false, "confirm", "default", "not a sensitive read call (or YOLO bypasses this check)");
+    if (this.yolo) {
+      add("yolo", true, "auto", "yolo", "YOLO mode is active \u2014 auto-approving every non-denied call");
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "yolo" } };
+    }
+    add("yolo", false, "auto", "yolo", "YOLO mode is not active");
+    if (tool.name === "write" && subject) {
+      const hasRead = ctx.hasRead(subject);
+      add(
+        "write smart bypass",
+        hasRead,
+        "auto",
+        "context",
+        hasRead ? `file "${subject}" was already read in this session \u2014 auto-approving write` : `file "${subject}" was not read in this session \u2014 bypass does not apply`
+      );
+      if (hasRead) {
+        winnerIndex = steps.length - 1;
+        return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "context", reason: "file already read in this session" } };
+      }
+    } else {
+      add("write smart bypass", false, "auto", "context", 'tool is not "write" or has no subject \u2014 bypass does not apply');
+    }
+    const hasWriteCap = hasCapability(tool, ToolCapabilities.FS_WRITE);
+    const hasShellCap = hasCapability(tool, [
+      ToolCapabilities.SHELL_ARBITRARY,
+      ToolCapabilities.SHELL_RESTRICTED,
+      ToolCapabilities.SHELL_EXEC
+    ]);
+    const hasInstallCap = hasCapability(tool, ToolCapabilities.PACKAGE_INSTALL);
+    const hasConfigCap = hasCapability(tool, ToolCapabilities.CONFIG_MUTATE);
+    const hasSubagentCap = hasCapability(tool, ToolCapabilities.SUBAGENT_SPAWN);
+    const isMutating = tool.mutating || hasWriteCap || hasShellCap || hasInstallCap || hasConfigCap || hasSubagentCap;
+    if (tool.permission === "auto" && !isMutating) {
+      add("safe default auto", true, "auto", "default", `tool "${tool.name}" has auto permission and is not mutating \u2014 safe to auto-approve`);
+      winnerIndex = steps.length - 1;
+      return { toolName: tool.name, subject, steps, winnerIndex, decision: { permission: "auto", source: "default" } };
+    }
+    add(
+      "mutating default confirm",
+      true,
+      "confirm",
+      "default",
+      isMutating ? `tool "${tool.name}" is mutating (default auto not enough) \u2014 needs confirmation` : `tool "${tool.name}" has "${tool.permission}" permission \u2014 needs confirmation`
+    );
+    winnerIndex = steps.length - 1;
+    const hasDelegate = this.promptDelegate !== void 0;
+    return {
+      toolName: tool.name,
+      subject,
+      steps,
+      winnerIndex,
+      decision: {
+        permission: "confirm",
+        source: "default",
+        ...hasDelegate ? { reason: "would prompt user via delegate" } : {}
+      }
+    };
+  }
   findNamespaceEntry(toolName) {
     for (const { pattern, value } of this.wildcardEntries) {
       if (matchGlob(pattern, toolName)) return value;
@@ -24685,6 +24912,24 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
   }
   allowOnce() {
   }
+  async explain(tool) {
+    const decision = await this.evaluate(tool);
+    return {
+      toolName: tool.name,
+      subject: null,
+      steps: [
+        {
+          rule: "subagent auto",
+          matched: decision.permission === "auto",
+          decision: decision.permission,
+          source: decision.source,
+          detail: decision.reason ?? `subagent policy: ${decision.permission}`
+        }
+      ],
+      winnerIndex: 0,
+      decision
+    };
+  }
   async reload() {
   }
 };
@@ -24885,9 +25130,9 @@ var DefaultSecretScrubber = class {
 
 // src/security/secret-vault.ts
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes4, scryptSync } from "node:crypto";
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as fsp12 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
@@ -25027,7 +25272,7 @@ function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
-    const stat13 = fs12.statSync(keyFile);
+    const stat13 = fs13.statSync(keyFile);
     const actualMode = stat13.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       warn(
@@ -25124,16 +25369,16 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes4(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs12.mkdirSync(path24.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path25.dirname(this.keyFile), { recursive: true });
     const passphrase = getVaultPassphrase();
     if (passphrase) {
-      fs12.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
+      fs13.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
     } else {
       const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
       KEY_FILE_MAGIC.copy(keyFileBuf, 0);
       keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
       newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
-      fs12.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+      fs13.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
     }
     checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
     this.key = newKey;
@@ -25151,7 +25396,7 @@ var DefaultSecretVault = class {
     const passphrase = getVaultPassphrase();
     if (!passphrase || !this.key) return;
     try {
-      fs12.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
+      fs13.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
         mode: 384
       });
       checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
@@ -25161,7 +25406,7 @@ var DefaultSecretVault = class {
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
-      const buf = fs12.readFileSync(this.keyFile);
+      const buf = fs13.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
@@ -25208,15 +25453,15 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs12.mkdirSync(path24.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path25.dirname(this.keyFile), { recursive: true });
     const key = randomBytes4(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
     try {
-      fs12.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
+      fs13.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const buf = fs12.readFileSync(this.keyFile);
+      const buf = fs13.readFileSync(this.keyFile);
       if (isWrappedKeyFile(buf)) {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
@@ -25266,7 +25511,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fsp12.mkdir(path24.dirname(configPath), { recursive: true });
+  await fsp12.mkdir(path25.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   await restrictFilePermissions(configPath);
 }
@@ -25350,7 +25595,7 @@ function walkCount(node, vault, counter) {
 // src/storage/attachment-store.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import * as fsp13 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -25371,7 +25616,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp13.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path25.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path26.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -25490,8 +25735,8 @@ function mergeAdjacentText(blocks) {
 }
 
 // src/storage/config-loader.ts
-import * as fs13 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as fs14 from "node:fs/promises";
+import * as path27 from "node:path";
 
 // src/types/config.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
@@ -25975,8 +26220,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   return out;
 }
 function samePath(a, b) {
-  let ra = path26.resolve(a);
-  let rb = path26.resolve(b);
+  let ra = path27.resolve(a);
+  let rb = path27.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -25998,7 +26243,7 @@ function deepMerge2(base, patch) {
     opts
   );
 }
-var DefaultConfigLoader = class {
+var DefaultConfigLoader = class _DefaultConfigLoader {
   paths;
   strict;
   vault;
@@ -26105,6 +26350,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();
@@ -26113,7 +26363,7 @@ var DefaultConfigLoader = class {
         let parsed;
         let fileExisted = true;
         try {
-          const raw = await fs13.readFile(fp, "utf8");
+          const raw = await fs14.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -26142,9 +26392,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) {
@@ -26153,7 +26406,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~",
@@ -26165,9 +26422,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", {
@@ -26193,77 +26447,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 fs13.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 fs14.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
@@ -26313,7 +26582,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fs13.readFile(fp, "utf8");
+      const raw = await fs14.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -26375,7 +26644,7 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat13 = await fs13.stat(file);
+      const stat13 = await fs14.stat(file);
       mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
@@ -26405,7 +26674,7 @@ var DefaultConfigLoader = class {
     }
     let raw;
     try {
-      raw = await fs13.readFile(file, "utf8");
+      raw = await fs14.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -26936,7 +27205,7 @@ ${cat}:`);
 
 // src/storage/queue-store.ts
 import * as fsp15 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -26945,7 +27214,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path27.join(opts.dir, "queue.json");
+    this.file = path28.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -27103,7 +27372,7 @@ function isPersistedQueueItem(v) {
 // src/storage/recovery-lock.ts
 import * as fsp16 from "node:fs/promises";
 import * as os3 from "node:os";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -27114,7 +27383,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path28.join(opts.dir, LOCK_FILE);
+    this.file = path29.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os3.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -27175,7 +27444,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path28.dirname(this.file));
+    await ensureDir(path29.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -27474,7 +27743,7 @@ function resolveSessionLoggingConfig(cfg) {
 }
 
 // src/storage/session-reader.ts
-import * as fs14 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 var DefaultSessionReader = class _DefaultSessionReader {
   store;
   eventCache = /* @__PURE__ */ new Map();
@@ -27492,7 +27761,7 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat13 = await fs14.stat(sessionPath);
+      const stat13 = await fs15.stat(sessionPath);
       mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);