@wrongstack/core 0.289.0 → 0.291.1

package/dist/defaults/index.js

@@ -36,8 +36,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat12 = await fs.stat(targetPath);
-      mode = stat12.mode & 511;
+      const stat13 = await fs.stat(targetPath);
+      mode = stat13.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -90,8 +90,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
-        const stat12 = await fs.stat(lockPath);
-        if (Date.now() - stat12.mtimeMs > staleMs) {
+        const stat13 = await fs.stat(lockPath);
+        if (Date.now() - stat13.mtimeMs > staleMs) {
           await fs.unlink(lockPath);
           continue;
         }
@@ -127,13 +127,13 @@ async function waitForLockRelease(lockPath, remainingMs) {
   const parentDir = path.dirname(lockPath);
   const lockName = path.basename(lockPath);
   const intervalMs = Math.min(remainingMs, 100);
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     let settled = false;
     let watcher = null;
     const timer = setTimeout(() => {
       settled = true;
       watcher?.close();
-      resolve12();
+      resolve14();
     }, intervalMs);
     try {
       watcher = watchDir(parentDir, (eventType, filename) => {
@@ -142,14 +142,14 @@ async function waitForLockRelease(lockPath, remainingMs) {
           settled = true;
           clearTimeout(timer);
           watcher?.close();
-          resolve12();
+          resolve14();
         }
       });
     } catch {
       clearTimeout(timer);
       if (!settled) {
         settled = true;
-        setTimeout(resolve12, Math.min(remainingMs, 25));
+        setTimeout(resolve14, Math.min(remainingMs, 25));
       }
       return;
     }
@@ -161,7 +161,7 @@ async function waitForLockRelease(lockPath, remainingMs) {
           settled = true;
           clearTimeout(timer);
           watcher?.close();
-          resolve12();
+          resolve14();
         }
       }
     );
@@ -185,7 +185,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve12) => setTimeout(resolve12, delays[i]));
+      await new Promise((resolve14) => setTimeout(resolve14, delays[i]));
     }
   }
   throw lastErr;
@@ -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() {
@@ -631,8 +662,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat12 = await fsp.stat(full);
-          if (stat12.isDirectory()) await walk3(full, rest);
+          const stat13 = await fsp.stat(full);
+          if (stat13.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -649,8 +680,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat12 = await fsp.stat(full);
-          if (stat12.isDirectory()) await walk3(full, rest);
+          const stat13 = await fsp.stat(full);
+          if (stat13.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -841,10 +872,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path28, errors, depth) {
+function walk(value, schema, path30, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path28 || "<root>",
+      path: path30 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -852,7 +883,7 @@ function walk(value, schema, path28, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path28 || "<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, path28, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path30 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -873,7 +904,7 @@ function walk(value, schema, path28, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path28, req),
+          path: joinPath(path30, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -881,14 +912,14 @@ function walk(value, schema, path28, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path28, 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, `${path28}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path30}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -1168,9 +1199,23 @@ 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) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/regex-guard.ts
@@ -1211,7 +1256,7 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -1246,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;
@@ -1267,84 +1312,21 @@ function invalid(sessionId) {
   });
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
+}
+
 // src/utils/slug.ts
 function slugify(name, fallback = "prompt", maxLen = 64) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
 }
 
-// src/utils/ulid.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = ENCODING.length;
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function encodeTime(now, len) {
-  let mod;
-  let str = "";
-  for (let i = len - 1; i >= 0; i--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING[mod] + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-function encodeRandom(len) {
-  const bytes = randomBytes2(len);
-  let str = "";
-  for (let i = 0; i < len; i++) {
-    str += ENCODING[bytes[i] % ENCODING_LEN];
-  }
-  return str;
-}
-function ulid(seedTime = Date.now()) {
-  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
-}
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms));
-}
-
 // src/utils/string.ts
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
-// src/utils/tool-subject.ts
-var GLOB_METACHARACTERS = /[*?[\]]/g;
-function escapeGlobSubject(value) {
-  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
-}
-function normalizePathSubject(value) {
-  return escapeGlobSubject(value.replace(/\\/g, "/"));
-}
-function isPathSubjectKey(subjectKey) {
-  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
-}
-function subjectForToolInput(toolName, input, subjectKey) {
-  if (!input || typeof input !== "object") return void 0;
-  const obj = input;
-  if (subjectKey) {
-    const value = obj[subjectKey];
-    if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
-    }
-  }
-  if (toolName === "bash" && typeof obj.command === "string") {
-    return escapeGlobSubject(obj.command);
-  }
-  if (typeof obj.path === "string") {
-    return normalizePathSubject(obj.path);
-  }
-  if (typeof obj.url === "string") {
-    return escapeGlobSubject(obj.url);
-  }
-  if (typeof obj.name === "string") {
-    return escapeGlobSubject(obj.name);
-  }
-  return void 0;
-}
-
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -1361,9 +1343,11 @@ function compactToolDefinitionForWire(tool, opts = {}) {
       tool.description ?? "",
       opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
     ),
-    inputSchema: compactSchemaDescriptions(
-      tool.inputSchema,
-      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
     )
   };
   if (useDefaultOptions && typeof tool === "object" && tool !== null) {
@@ -1371,6 +1355,44 @@ function compactToolDefinitionForWire(tool, opts = {}) {
   }
   return compact;
 }
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
 function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
   const compact = compactSchemaNode(schema, maxDescriptionChars);
   return isRecord(compact) ? compact : { type: "object", properties: {} };
@@ -2265,25 +2287,88 @@ function resolveToolResultRenderMode(modes, toolName) {
   return normalizeToolResultRenderMode(modes?.[toolName]) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
 }
 
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function subjectForToolInput(toolName, input, subjectKey) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (typeof value === "string") {
+      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes2(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+
 // 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;
   }
@@ -2293,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}`;
 }
@@ -2302,61 +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"),
-    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"),
+    globalConfig: path4.join(globalRoot, "config.json"),
+    profilesDir: path4.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      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");
+    },
+    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")
   };
 }
 
@@ -2649,7 +2756,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve14, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -2668,7 +2775,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve12,
+        resolve: resolve14,
         reject,
         timer
       });
@@ -3017,13 +3124,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve12(d);
+        resolve14(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -3348,8 +3455,34 @@ function makeAgentSubagentRunner(opts) {
     const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config, task);
     const { agent, events } = factoryResult;
+    const taskContext = task.context ?? {};
+    const hasExplicitTelemetryTask = typeof taskContext["telemetryTaskId"] === "string";
+    const telemetryTaskId = hasExplicitTelemetryTask ? taskContext["telemetryTaskId"] : task.id;
+    const telemetryRunId = typeof taskContext["telemetryRunId"] === "string" ? taskContext["telemetryRunId"] : void 0;
+    const telemetryBoardId = typeof taskContext["telemetryBoardId"] === "string" ? taskContext["telemetryBoardId"] : void 0;
     const agentContext = agent.ctx;
-    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
+    if (agentContext?.meta) {
+      agentContext.meta["subagentTaskId"] = task.id;
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        agentContext.meta["kanban"] = kanbanContext;
+      }
+      if (hasExplicitTelemetryTask) {
+        agentContext.meta["telemetryTaskId"] = telemetryTaskId;
+        if (telemetryRunId) agentContext.meta["telemetryRunId"] = telemetryRunId;
+      }
+    }
+    if (hasExplicitTelemetryTask) {
+      agentContext?.setCurrentKanbanTask?.(telemetryTaskId, telemetryBoardId);
+    } else {
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        const kanban = kanbanContext;
+        const boardId = typeof kanban["boardId"] === "string" ? kanban["boardId"] : void 0;
+        const taskId = typeof kanban["taskId"] === "string" ? kanban["taskId"] : void 0;
+        if (taskId) agentContext?.setCurrentKanbanTask?.(taskId, boardId);
+      }
+    }
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -3374,6 +3507,27 @@ function makeAgentSubagentRunner(opts) {
     const unsub = [];
     unsub.push(
       events.on("tool.executed", (e) => {
+        if (hasExplicitTelemetryTask) {
+          opts.hostEvents?.emit("subagent.tool_executed", {
+            sessionId: e.sessionId,
+            subagentId: ctx.subagentId,
+            agentSessionId: e.sessionId,
+            agentName: e.agentName ?? ctx.config.name,
+            taskId: telemetryTaskId,
+            runId: telemetryRunId,
+            traceId: e.traceId,
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            // Raw tool inputs may contain credentials or sensitive arguments.
+            // Task telemetry crosses from the isolated worker bus to the shared
+            // host bus, so expose only execution metadata at this boundary.
+            outputBytes: e.outputBytes,
+            outputTokens: e.outputTokens,
+            outputLines: e.outputLines
+          });
+        }
         try {
           ctx.budget.recordToolCall();
         } catch (eb) {
@@ -3385,6 +3539,17 @@ function makeAgentSubagentRunner(opts) {
           lastToolFailed = null;
         }
       }),
+      events.on("file.event", (e) => {
+        if (!hasExplicitTelemetryTask) return;
+        if (e.runId === telemetryRunId && e.taskId === telemetryTaskId) return;
+        opts.hostEvents?.emit("file.event", {
+          ...e,
+          scope: "task",
+          taskId: telemetryTaskId,
+          boardId: telemetryBoardId,
+          runId: telemetryRunId
+        });
+      }),
       events.on("provider.response", (e) => {
         try {
           ctx.budget.recordUsage(e.usage);
@@ -3607,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();
@@ -3620,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 {
     }
@@ -3629,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);
@@ -4678,6 +4843,40 @@ var DOMAIN_AGENTS = [
         "information architecture"
       ]
     }
+  },
+  {
+    config: {
+      id: "ios",
+      name: "iOS",
+      role: "ios",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("ios")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Apple-platform app development in Swift against the latest Xcode/iOS-SDK line: SwiftUI, UIKit, SwiftData, concurrency, accessibility, and App Store submission.",
+      keywords: [
+        "ios",
+        "iphone",
+        "ipad",
+        "ipados",
+        "watchos",
+        "tvos",
+        "visionos",
+        "macos",
+        "swift",
+        "swiftui",
+        "uikit",
+        "xcode",
+        "swiftdata",
+        "app store",
+        "app intents",
+        "swift package manager",
+        "cocoapods",
+        "foundation models"
+      ]
+    }
   }
 ];
 
@@ -5211,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
@@ -5659,7 +5858,7 @@ function createDelegateTool(opts) {
   };
 }
 async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     let settled = false;
     let timer;
     let offAbort = () => {
@@ -5672,7 +5871,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
       offIter();
       offProgress();
       offAbort();
-      resolve12(value);
+      resolve14(value);
     };
     const arm = () => {
       if (timer) clearTimeout(timer);
@@ -5832,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 {
@@ -5885,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";
@@ -6368,7 +6567,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat12] = await Promise.all([
+        const [content, stat13] = await Promise.all([
           fsp4.readFile(filePath, "utf8"),
           fsp4.stat(filePath)
         ]);
@@ -6378,8 +6577,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat12.mtimeMs,
-          snapshotSizeBytes: stat12.size
+          snapshotMtimeMs: stat13.mtimeMs,
+          snapshotSizeBytes: stat13.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -6798,9 +6997,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat12 = await fsp4.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat12.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat12.size !== file.snapshotSizeBytes;
+        const stat13 = await fsp4.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat13.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat13.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -6955,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;
@@ -6965,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 {
     }
@@ -6981,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;
@@ -7063,6 +7262,8 @@ function rosterSummaryFromConfigs(roster) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   claimReadyTask,
+  describeKanbanBoundary,
+  heartbeatTaskAssignment,
   listReadyTasks,
   updateTaskAssignment
 } from "@wrongstack/kanban";
@@ -7817,13 +8018,19 @@ function makeKanbanQueueTool(director, roster) {
       const projectRoot = ctx.projectRoot;
       if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
       const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
-      const leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const baseLeaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const leaseTtlMs = i.awaitCompletion === true && i.timeoutMs !== void 0 ? Math.max(baseLeaseTtlMs, i.timeoutMs + 6e4) : baseLeaseTtlMs;
+      const heartbeatIntervalMs = Math.max(
+        5e3,
+        i.heartbeatIntervalMs ?? Math.floor(leaseTtlMs / 2)
+      );
+      const effectiveLeaseTtlMs = Math.max(leaseTtlMs, heartbeatIntervalMs * 2);
       const claimedAt = nowIso();
       const leaseSeeding = {
         leaseId: randomUUID4(),
         claimedAt,
         heartbeatAt: claimedAt,
-        leaseExpiresAt: new Date(Date.now() + leaseTtlMs).toISOString()
+        leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
       };
       const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await listReadyTasks(projectRoot, {
         ...i.boardId !== void 0 ? { boardId: i.boardId } : {}
@@ -7831,9 +8038,11 @@ function makeKanbanQueueTool(director, roster) {
       const dispatches = [];
       const errors = [];
       const resultFailures = [];
+      const budgetRejectedTaskIds = /* @__PURE__ */ new Set();
       for (let index = 0; index < maxTasks; index++) {
         const candidateTaskId = candidateTaskIds?.[index];
         if (candidateTaskIds && !candidateTaskId) break;
+        if (candidateTaskId && budgetRejectedTaskIds.has(candidateTaskId)) continue;
         const claim = await claimReadyTask(projectRoot, {
           ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
           ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
@@ -7858,14 +8067,22 @@ function makeKanbanQueueTool(director, roster) {
         if (costCeiling !== void 0) {
           const remaining = director.getRemainingBudgetUsd();
           if (remaining !== void 0 && remaining < costCeiling) {
-            await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-              status: "failed",
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`,
-              lastResult: "Skipped by kanban_queue cost gate (Sprint 3)"
-            });
+            budgetRejectedTaskIds.add(claim.task.id);
+            const budgetError = `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`;
+            await updateTaskAssignment(
+              projectRoot,
+              claim.board.id,
+              claim.task.id,
+              {
+                ...claim.task.assignment ?? {},
+                status: "failed",
+                error: budgetError
+              },
+              { expectedLeaseId: leaseSeeding.leaseId }
+            );
             errors.push({
               taskId: claim.task.id,
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`
+              error: budgetError
             });
             continue;
           }
@@ -7873,12 +8090,20 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster);
           subagentId = await director.spawn(config);
-          runTaskId = await director.assign({
-            id: randomUUID4(),
+          const dispatchTaskId = randomUUID4();
+          const taskSpec = {
+            id: dispatchTaskId,
             subagentId,
             description: buildKanbanFleetTaskPrompt(claim.board, claim.task, {
-              heartbeatIntervalMs: i.heartbeatIntervalMs ?? 6e4,
-              leaseTtlMs,
+              // The worker must heartbeat against the lease it actually holds.
+              // effectiveLeaseTtlMs is the real lease window (raised from the
+              // requested TTL when needed so the first heartbeat always lands
+              // before expiry), and the computed heartbeatIntervalMs is always
+              // strictly shorter than that window. Passing the raw requested
+              // values here would give the worker a 60s cadence against a
+              // 10s lease, letting the lease expire before its first renewal.
+              heartbeatIntervalMs,
+              leaseTtlMs: effectiveLeaseTtlMs,
               leaseId: leaseSeeding.leaseId,
               leaseExpiresAt: leaseSeeding.leaseExpiresAt
             }),
@@ -7889,16 +8114,51 @@ function makeKanbanQueueTool(director, roster) {
               kanban: {
                 boardId: claim.board.id,
                 taskId: claim.task.id,
-                origin: claim.task.origin
+                origin: claim.task.origin,
+                projectRoot
               }
             }
-          });
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "running",
-            subagentId,
-            runTaskId
-          });
+          };
+          const dispatched = await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "running",
+              subagentId,
+              runTaskId: dispatchTaskId,
+              // Renew the lease from the actual dispatch moment, not from claim
+              // time. The claim-time lease starts before spawn + queueing, so
+              // `timeoutMs + 60_000` can expire while the worker is still
+              // queued or running, letting recover_stale reclaim and duplicate
+              // the assignment (see auto-extend.ts: timeout extensions can push
+              // execution well past the original timeoutMs). Both heartbeatAt
+              // and leaseExpiresAt are stamped from now so the worker has a
+              // full lease window from the moment it was actually dispatched.
+              heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+              leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
+          if (dispatched === null) {
+            try {
+              await director.terminate(subagentId);
+            } catch (cleanupErr) {
+              errors.push({
+                taskId: claim.task.id,
+                error: `Lease lost during dispatch; orphan subagent ${subagentId} termination failed: ${toErrorMessage(cleanupErr)}`
+              });
+              continue;
+            }
+            errors.push({
+              taskId: claim.task.id,
+              error: `Lease lost during dispatch (reassigned by recovery); subagent ${subagentId} terminated.`
+            });
+            continue;
+          }
+          await director.assign(taskSpec);
+          runTaskId = dispatchTaskId;
           dispatches.push({
             boardId: claim.board.id,
             taskId: claim.task.id,
@@ -7917,28 +8177,97 @@ function makeKanbanQueueTool(director, roster) {
               message = `${message}; cleanup failed for spawned subagent ${subagentId}: ${toErrorMessage(cleanupErr)}`;
             }
           }
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "failed",
-            ...subagentId !== void 0 ? { subagentId } : {},
-            ...runTaskId !== void 0 ? { runTaskId } : {},
-            error: message
-          });
+          await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "failed",
+              ...subagentId !== void 0 ? { subagentId } : {},
+              ...runTaskId !== void 0 ? { runTaskId } : {},
+              error: message
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
           errors.push({ taskId: claim.task.id, error: message });
         }
       }
+      if (!i.awaitCompletion && dispatches.length > 0 && typeof director.fleet?.subscribe === "function") {
+        const ourLeaseId = leaseSeeding.leaseId;
+        const disposers = /* @__PURE__ */ new Map();
+        const renewalStartedAt = Date.now();
+        const maxRenewalWindowMs = 24 * 60 * 6e4;
+        const stopAll = () => {
+          clearInterval(renewalTimer);
+          for (const dispose of disposers.values()) dispose();
+          disposers.clear();
+        };
+        const renewalTimer = setInterval(() => {
+          if (disposers.size === 0 || Date.now() - renewalStartedAt > maxRenewalWindowMs) {
+            stopAll();
+            return;
+          }
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!disposers.has(dispatch.runTaskId)) continue;
+            void heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+              leaseExpiresAt: refreshedExpiry,
+              expectedLeaseId: ourLeaseId
+            }).catch(() => {
+            });
+          }
+        }, heartbeatIntervalMs);
+        renewalTimer.unref?.();
+        for (const dispatch of dispatches) {
+          const dispose = director.fleet.subscribe(dispatch.subagentId, (event) => {
+            if (event.type !== "subagent.completed" && event.type !== "subagent.stopped") return;
+            if (event.type === "subagent.completed" && event.taskId !== dispatch.runTaskId) return;
+            disposers.get(dispatch.runTaskId)?.();
+            disposers.delete(dispatch.runTaskId);
+            if (disposers.size === 0) clearInterval(renewalTimer);
+          });
+          disposers.set(dispatch.runTaskId, dispose);
+        }
+      }
       let results;
       if (i.awaitCompletion && dispatches.length > 0) {
-        results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        const ourLeaseId = leaseSeeding.leaseId;
+        const runTaskIds = new Set(dispatches.map((dispatch) => dispatch.runTaskId));
+        const heartbeatTimer = setInterval(async () => {
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!runTaskIds.has(dispatch.runTaskId)) continue;
+            try {
+              await heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+                leaseExpiresAt: refreshedExpiry,
+                expectedLeaseId: ourLeaseId
+              });
+            } catch {
+            }
+          }
+        }, heartbeatIntervalMs);
+        try {
+          results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        } finally {
+          clearInterval(heartbeatTimer);
+        }
         for (const result of results) {
           const dispatch = dispatches.find((candidate) => candidate.runTaskId === result.taskId);
           if (!dispatch) continue;
-          await updateTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
-            status: result.status === "success" ? "completed" : "failed",
-            subagentId: result.subagentId,
-            runTaskId: result.taskId,
-            ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
-          });
+          runTaskIds.delete(dispatch.runTaskId);
+          await updateTaskAssignment(
+            projectRoot,
+            dispatch.boardId,
+            dispatch.taskId,
+            {
+              status: result.status === "success" ? "completed" : "failed",
+              subagentId: result.subagentId,
+              runTaskId: result.taskId,
+              ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
+            },
+            { expectedLeaseId: ourLeaseId }
+          );
           if (result.status !== "success") {
             resultFailures.push({
               taskId: dispatch.taskId,
@@ -8046,6 +8375,16 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
     task.origin.phaseId ? `phaseId: ${task.origin.phaseId}` : "",
     task.origin.taskId ? `sourceTaskId: ${task.origin.taskId}` : ""
   ].filter(Boolean).join("\n") : "";
+  const boundaries = [
+    board.boundary?.enabled ? `board: ${describeKanbanBoundary(board.boundary)}` : "",
+    task.boundary?.enabled ? `task: ${describeKanbanBoundary(task.boundary)}` : "",
+    ...(board.boundary?.allow ?? []).map(
+      (selector) => `board allow ${selector.access} ${selector.kind}:${selector.path}`
+    ),
+    ...(task.boundary?.allow ?? []).map(
+      (selector) => `task allow ${selector.access} ${selector.kind}:${selector.path}`
+    )
+  ].filter(Boolean);
   return [
     "You are processing a claimed WrongStack Kanban task.",
     "",
@@ -8068,6 +8407,8 @@ ${checks}` : "",
     metrics ? `Goal metrics:
 ${metrics}` : "",
     task.labels?.length ? `Labels: ${task.labels.join(", ")}` : "",
+    boundaries.length ? `BOUNDARY CONTRACT (enforced by the tool runtime; do not attempt to bypass):
+${boundaries.map((line) => `- ${line}`).join("\n")}` : "",
     "Lease contract (Sprint 1):",
     `- leaseId: ${lease.leaseId}`,
     `- claimedAt: ${task.assignment?.claimedAt ?? "<unknown>"}`,
@@ -8083,10 +8424,21 @@ ${metrics}` : "",
     "Work this task end-to-end. Treat the board as a live plan, not a frozen assignment snapshot.",
     `Before material work and whenever evidence changes the plan, call kanban with action "get_board" and boardId "${board.id}" to reassess current tasks, dependencies, priorities, and peer changes.`,
     "You may use kanban add_task, update_task, split_task, merge_tasks, move_task, delete_task, or dependency actions when reassessment shows the plan should change. Preserve traceability and do not keep obsolete work merely because it existed at dispatch time.",
+    "",
+    "FIELD MAINTENANCE \u2014 keep every task detail current:",
+    '- Call "update_task" to refresh description, priority, type, labels, or estimatedHours as the work evolves.',
+    '- Call "add_note" with author and content to record progress, decisions, or roadblock context.',
+    '- Call "add_check" / "update_check" with description and status (pending/passed/failed) to track acceptance criteria.',
+    '- Call "add_goal_metric" / "update_goal_metric" with name and current/target to report measurable progress.',
+    '- Call "add_link" with url and type (issue/pr/doc/commit/design/file/url/other) to attach evidence.',
+    '- Call "update_task" to set actualHours when you have a final time estimate.',
+    "Do not leave stale or placeholder field values \u2014 the kanban board is the shared source of truth for every stakeholder.",
+    "",
+    "LEASE & LIFECYCLE:",
     "Every successful board mutation updates shared pending work and notifies the owning session. Re-read the board after mutations and adapt to changes made by other agents; never assume your initial todo list remains authoritative.",
-    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "running". Include subagentId and runTaskId when you have them.`,
-    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", and heartbeatAt set to the current time. Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt.`,
-    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "completed" or "failed". Include lastResult or error.`,
+    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "running", and expectedLeaseId "${lease.leaseId}". Include subagentId and runTaskId when you have them. The expectedLeaseId fence makes the write a safe no-op if recover_stale already reassigned the task because your lease expired.`,
+    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", heartbeatAt set to the current time, and expectedLeaseId "${lease.leaseId}". Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt. The expectedLeaseId fence makes the heartbeat a safe no-op if the lease was reassigned, so a stale worker cannot renew a successor's lease.`,
+    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "completed" or "failed", and expectedLeaseId "${lease.leaseId}". Include lastResult or error. Populate every relevant detail field before the terminal mark_assignment so the card's final state is complete.`,
     `If you cannot finish in time, call kanban with action "heartbeat_assignment" to extend the lease, or with action "release_task" to release so another worker can claim. Do NOT silently abandon the assignment.`,
     'On failure the host may call kanban with action "recover_stale" (mode: retry/release/fail); respect its decisions and do not duplicate work in parallel.',
     "When finished, report what changed, what you verified, and any remaining blockers."
@@ -8785,18 +9137,20 @@ function isTextBlock(b) {
 // src/types/provider.ts
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
+  if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
   if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
     return "auth";
   }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
   if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
     return "context_overflow";
@@ -8809,6 +9163,7 @@ function isRetryableKind(kind) {
 }
 var RETRYABLE_BY_KIND = {
   rate_limit: true,
+  quota_exhausted: false,
   overloaded: true,
   server: true,
   timeout: true,
@@ -8887,6 +9242,7 @@ var KIND_TO_CODE = {
   network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
   auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
   overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
   context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
@@ -8986,6 +9342,7 @@ function classifySubagentError(err, hints = {}) {
 function providerErrorToSubagentError(err, message, cause) {
   switch (err.kind) {
     case "rate_limit":
+    case "quota_exhausted":
       return {
         kind: "provider_rate_limit",
         message,
@@ -9393,7 +9750,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve14, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -9402,7 +9759,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve12(result);
+              resolve14(result);
             }
           };
           this.on("task.completed", handler);
@@ -9427,13 +9784,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve12({
+        resolve14({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -9441,7 +9798,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -9723,12 +10080,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve12 = (d) => {
+              const resolve14 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve12("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve14("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -9746,11 +10103,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve12({ extend: extra }));
+                  queueMicrotask(() => resolve14({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve12("stop");
+                  resolve14("stop");
                 }
               });
             });
@@ -10375,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;
@@ -10415,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));
     }
@@ -10923,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(
@@ -11151,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;
   }
@@ -11346,11 +11720,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve12;
+        let resolve14;
         const promise = new Promise((res) => {
-          resolve12 = res;
+          resolve14 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve12 });
+        this.taskWaiters.set(id, { promise, resolve: resolve14 });
         return promise;
       })
     );
@@ -11379,10 +11753,10 @@ var Director = class _Director {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (r) => resolve12({
+        resolve: (r) => resolve14({
           completed: [r],
           pending: taskIds.filter((id) => id !== r.taskId)
         })
@@ -11390,7 +11764,7 @@ var Director = class _Director {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -11555,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");
@@ -11709,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) {
@@ -11738,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;
@@ -12520,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) {
@@ -12551,29 +12925,29 @@ function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative4 = path9.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
+  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(relative4) {
-  return relative4 === ".wrongstack/worktrees" || relative4.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) {
@@ -12591,60 +12965,60 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative4) => !isWrongStackWorktreePath(relative4)).sort();
+    ].filter((relative6) => !isWrongStackWorktreePath(relative6)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative4) => {
-        const absolute = path9.resolve(this.projectRoot, ...relative4.split("/"));
+      async (relative6) => {
+        const absolute = path10.resolve(this.projectRoot, ...relative6.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative4, reason: "path escapes project root" });
+          unresolved.push({ path: relative6, reason: "path escapes project root" });
           return null;
         }
         try {
-          const stat12 = await fsp7.lstat(absolute);
-          if (stat12.isSymbolicLink()) {
+          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: relative4,
+                path: relative6,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative4, state: "symlink", linkTarget };
+            return { path: relative6, state: "symlink", linkTarget };
           }
-          if (!stat12.isFile()) {
-            unresolved.push({ path: relative4, reason: "changed path is not a regular file" });
+          if (!stat13.isFile()) {
+            unresolved.push({ path: relative6, reason: "changed path is not a regular file" });
             return null;
           }
-          if (stat12.size > MAX_BLOB_BYTES) {
+          if (stat13.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative4,
+              path: relative6,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
-          if (scheduledBytes + stat12.size > MAX_CHECKPOINT_BYTES) {
+          if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative4,
+              path: relative6,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
           }
-          scheduledBytes += stat12.size;
+          scheduledBytes += stat13.size;
           const content = await fsp7.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative4, state: "file", blobHash, mode: stat12.mode & 511 };
+          return { path: relative6, state: "file", blobHash, mode: stat13.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative4, state: "absent" };
+            return { path: relative6, state: "absent" };
           }
-          unresolved.push({ path: relative4, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative6, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -12670,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");
     }
@@ -12710,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({
@@ -12741,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;
@@ -12758,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}`);
@@ -12774,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 {
@@ -12834,10 +13208,10 @@ var SessionCheckpointCas = class {
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative4) {
-    const normalized = normalizeRelative(relative4);
+  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 (; ; ) {
@@ -12847,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;
       }
@@ -12855,7 +13229,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -12898,8 +13272,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve12(result(1, err.message)));
-    child.on("close", (code) => resolve12(result(code ?? 1)));
+    child.on("error", (err) => resolve14(result(1, err.message)));
+    child.on("close", (code) => resolve14(result(code ?? 1)));
   });
 }
 
@@ -12913,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 relative4 = path10.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path10.isAbsolute(relative4);
+  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;
@@ -12930,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(),
@@ -12967,11 +13341,11 @@ async function validateOne(observation, lexicalRoot, realRoot) {
     };
   }
   try {
-    const stat12 = await fsp8.stat(realFile);
-    if (!stat12.isFile()) {
+    const stat13 = await fsp8.stat(realFile);
+    if (!stat13.isFile()) {
       return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
     }
-    if (stat12.size > MAX_REVALIDATE_BYTES) {
+    if (stat13.size > MAX_REVALIDATE_BYTES) {
       return {
         ...base,
         status: "unreadable",
@@ -12988,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(
@@ -13004,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 relative4 = path10.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative4 || "." : 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;
@@ -13140,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;
@@ -13208,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) {
@@ -13230,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;
   }
@@ -13394,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,
@@ -13442,9 +13816,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp9.stat(file);
-      const stat12 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat13 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat12.mtimeMs && cached.size === stat12.size) {
+      if (cached && cached.mtimeMs === stat13.mtimeMs && cached.size === stat13.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -13633,7 +14007,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat12.mtimeMs, size: stat12.size, data });
+        this._loadCache.set(id, { mtimeMs: stat13.mtimeMs, size: stat13.size, data });
       }
       return data;
     } catch (err) {
@@ -13682,14 +14056,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat12;
+    let stat13;
     try {
-      stat12 = await fsp9.stat(file);
+      stat13 = await fsp9.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat12.size === 0) return [];
+    if (stat13.size === 0) return [];
     let fh;
     try {
       fh = await fsp9.open(file, "r");
@@ -13880,15 +14254,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat12;
+    let stat13;
     try {
       const s = await fsp9.stat(this.indexFile);
-      stat12 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat13 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat12.mtimeMs && this._indexCache.size === stat12.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat13.mtimeMs && this._indexCache.size === stat13.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -13921,7 +14295,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat12, summaries };
+    this._indexCache = { ...stat13, summaries };
     return [...summaries];
   }
   /**
@@ -14015,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("/"));
   }
@@ -14038,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];
@@ -14077,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];
@@ -14091,8 +14465,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat12 = await fsp9.stat(full);
-      const summary = await this.summarize(id, stat12.mtime.toISOString());
+      const stat13 = await fsp9.stat(full);
+      const summary = await this.summarize(id, stat13.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -14133,18 +14507,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat12 = await fsp9.stat(ref.filePath);
-      if (!stat12.isFile()) {
+      const stat13 = await fsp9.stat(ref.filePath);
+      if (!stat13.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat12.mtime.toISOString(),
+          startedAt: stat13.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat12.mtime.toISOString();
+      mtime = stat13.mtime.toISOString();
     } catch {
       return null;
     }
@@ -14192,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),
@@ -14239,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 {
@@ -14302,10 +14676,10 @@ 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 stat12 = await fsp9.stat(jsonlPath);
-        if (stat12.mtimeMs >= cutoff) return;
+        const stat13 = await fsp9.stat(jsonlPath);
+        if (stat13.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -14322,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;
@@ -14334,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) {
@@ -14465,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`");
@@ -15813,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";
@@ -15921,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;
@@ -15990,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;
@@ -16001,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 {
@@ -16028,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;
@@ -16061,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();
@@ -16074,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;
@@ -16095,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 {
@@ -16128,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 {
     }
   }
@@ -16143,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 {
   }
 }
@@ -16163,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
 `
     );
@@ -16177,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 {
   }
 }
@@ -16293,12 +16667,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path28, 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: path28, 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;
@@ -16350,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;
     }
@@ -16375,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 {
     }
   }
@@ -16512,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);
@@ -16807,16 +17181,20 @@ function buildRecoveryStrategies(opts) {
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
         if (ctx?.signal) {
-          await new Promise((resolve12) => {
+          await new Promise((resolve14) => {
             if (ctx.signal.aborted) {
-              resolve12();
+              resolve14();
               return;
             }
-            const timer = setTimeout(resolve12, delay);
-            ctx.signal.addEventListener("abort", () => {
-              clearTimeout(timer);
-              resolve12();
-            }, { once: true });
+            const timer = setTimeout(resolve14, delay);
+            ctx.signal.addEventListener(
+              "abort",
+              () => {
+                clearTimeout(timer);
+                resolve14();
+              },
+              { once: true }
+            );
           });
         } else {
           await new Promise((r) => setTimeout(r, delay));
@@ -16907,6 +17285,7 @@ function buildRecoveryStrategies(opts) {
 var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
 var HANDLER_KIND_BY_PROVIDER_KIND = {
   rate_limit: "rate_limit",
+  quota_exhausted: "rate_limit",
   overloaded: "overloaded",
   server: "server",
   stream_hang: "server",
@@ -18801,8 +19180,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve12) => {
-            drainTimer = setTimeout(resolve12, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve14) => {
+            drainTimer = setTimeout(resolve14, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -19097,7 +19476,7 @@ async function runProviderWithRetry(opts) {
         status: isProviderErr ? err.status : 0,
         description
       });
-      await new Promise((resolve12, reject) => {
+      await new Promise((resolve14, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -19113,7 +19492,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve12();
+          resolve14();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -19141,6 +19520,7 @@ import { randomInt } from "node:crypto";
 var MAX_RETRY_AFTER_MS = 6e4;
 var MAX_ATTEMPTS_BY_KIND = {
   rate_limit: 5,
+  quota_exhausted: 0,
   stream_hang: 5,
   // transient, worth retrying aggressively
   overloaded: 3,
@@ -19605,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 = [
@@ -19836,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;
     }
@@ -19857,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
         });
@@ -19879,12 +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 });
+        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;
@@ -19956,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;
   }
@@ -19966,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) {
@@ -19999,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;
@@ -20065,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);
@@ -20084,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;
@@ -20094,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;
@@ -20188,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;
@@ -20301,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 {
@@ -20315,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") {
@@ -20506,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";
@@ -20517,8 +20899,167 @@ function runWithProcessTelemetry(context, run) {
 
 // src/execution/tool-executor.ts
 import { isDeepStrictEqual } from "node:util";
-import * as fs8 from "node:fs/promises";
-import * as path18 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 path19 from "node:path";
+import {
+  evaluateKanbanBoundaryOpaque,
+  evaluateKanbanBoundaryPath,
+  readBoard,
+  resolveKanbanBoundaryLayers
+} from "@wrongstack/kanban";
+var PATH_KEYS = /* @__PURE__ */ new Set([
+  "path",
+  "paths",
+  "file",
+  "files",
+  "directory",
+  "dir",
+  "cwd",
+  "root",
+  "baseDir",
+  "out",
+  "outputPath",
+  "sourcePath",
+  "targetPath",
+  "destinationPath",
+  "fromPath",
+  "toPath",
+  "worktreePath"
+]);
+var TOOL_PATH_KEYS = {
+  // `target` is an identifier in tools such as plan/task/document, but a
+  // filesystem target in language_info. Keep ambiguous names tool-specific.
+  language_info: ["target"]
+};
+async function evaluateToolKanbanBoundary(tool, input, ctx) {
+  const identity = resolveKanbanIdentity(ctx);
+  if (!identity.boardId) return { decision: "allow" };
+  const board = await readBoard(identity.policyRoot ?? ctx.projectRoot, identity.boardId);
+  if (!board) return { decision: "allow" };
+  const task = identity.taskId ? board.tasks.find((candidate) => candidate.id === identity.taskId) : void 0;
+  const layers = resolveKanbanBoundaryLayers(board, task);
+  if (layers.length === 0) return { decision: "allow" };
+  const caps = tool.capabilities ?? [];
+  const access2 = caps.includes("fs.write") || caps.includes("fs.write.outside-project") ? "write" : caps.includes("fs.read") ? "read" : void 0;
+  const shellLike = caps.some((capability) => capability.startsWith("shell."));
+  const candidates = access2 ? await extractCandidatePaths(tool.name, input, ctx) : [];
+  let evaluation;
+  if (shellLike || access2 && candidates.length === 0) {
+    evaluation = evaluateKanbanBoundaryOpaque(layers, tool.name);
+  } else if (access2) {
+    const results = candidates.map(
+      (candidate) => evaluateKanbanBoundaryPath(layers, candidate, access2)
+    );
+    evaluation = results.find((result) => result.decision === "block") ?? results.find((result) => result.decision === "confirm") ?? { decision: "allow" };
+  } else {
+    evaluation = { decision: "allow" };
+  }
+  return {
+    ...evaluation,
+    boardId: board.id,
+    ...task ? { taskId: task.id } : {}
+  };
+}
+function resolveKanbanIdentity(ctx) {
+  const metaKanban = ctx.meta["kanban"];
+  const record = metaKanban && typeof metaKanban === "object" ? metaKanban : void 0;
+  const boardId = ctx.currentKanbanBoardId ?? (typeof record?.["boardId"] === "string" ? record["boardId"] : void 0);
+  const taskId = ctx.currentKanbanTaskId ?? (typeof record?.["taskId"] === "string" ? record["taskId"] : void 0);
+  const policyRoot = typeof record?.["projectRoot"] === "string" ? record["projectRoot"] : void 0;
+  return {
+    ...boardId ? { boardId } : {},
+    ...taskId ? { taskId } : {},
+    ...policyRoot ? { policyRoot } : {}
+  };
+}
+async function extractCandidatePaths(toolName, input, ctx) {
+  if (toolName === "patch" && typeof input["patch"] === "string") {
+    const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
+    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(path19.resolve(directory, target), ctx.projectRoot)
+    );
+    return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
+  }
+  const values = [];
+  const pathKeys = new Set(PATH_KEYS);
+  for (const key of TOOL_PATH_KEYS[toolName] ?? []) pathKeys.add(key);
+  collectPathValues(input, values, pathKeys);
+  if (toolName === "scaffold" && typeof input["name"] === "string") {
+    const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
+    values.push(path19.join(cwd, input["name"]));
+  }
+  const candidates = [
+    ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
+  ];
+  return Promise.all(candidates.map((candidate) => canonicalizeCandidatePath(candidate, ctx)));
+}
+async function canonicalizeCandidatePath(candidate, ctx) {
+  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 = 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 = path19.dirname(probe);
+      if (parent === probe) return absolute;
+      missingSegments.unshift(path19.basename(probe));
+      probe = parent;
+    }
+  }
+}
+function collectPathValues(value, output, pathKeys, key) {
+  if (typeof value === "string") {
+    if (key && pathKeys.has(key)) output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectPathValues(item, output, pathKeys, key);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [childKey, child] of Object.entries(value)) {
+    collectPathValues(child, output, pathKeys, childKey);
+  }
+}
+function splitPathList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function resolveInputPath(value, ctx) {
+  const absolute = path19.isAbsolute(value) ? value : path19.resolve(ctx.workingDir, value);
+  return relativeToProject(absolute, ctx.projectRoot);
+}
+function relativeToProject(absolute, projectRoot) {
+  const relative6 = path19.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative6.startsWith("../") || path19.isAbsolute(relative6) ? absolute : relative6 || ".";
+}
+function extractPatchTargets(patchText, strip) {
+  const targets = [];
+  for (const match of patchText.matchAll(/^\+\+\+\s+([^\t\r\n]+)/gm)) {
+    const raw = match[1]?.trim();
+    if (!raw || raw === "/dev/null") continue;
+    const parts = raw.replace(/\\/g, "/").split("/").filter((part) => part && part !== ".");
+    if (parts.length > strip) targets.push(parts.slice(strip).join("/"));
+  }
+  return targets;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 
 // src/types/tool-executor.ts
 var GOVERNED_TOOL_EXECUTOR_META_KEY = "toolExecutor.executeGoverned";
@@ -20739,35 +21280,68 @@ ${errorDetails}`,
           return { result, tool, durationMs: Date.now() - start };
         }
       }
+      const boundary = await evaluateToolKanbanBoundary(tool, use.input, ctx);
+      if (boundary.decision === "block") {
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" blocked by Kanban boundary. ${boundary.reason ?? ""}`.trim(),
+          is_error: true
+        };
+        budget = this.budgetForString(result.content, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
       let effectivePermission = decision.permission;
       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);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
+        const suggestedPattern = boundary.decision === "confirm" ? `kanban-boundary:${boundary.path ?? tool.name}` : subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
         if (this.opts.confirmAwaiter) {
           const awaiter = this.opts.confirmAwaiter;
           const choice = await new Promise(
-            (resolve12, reject) => {
+            (resolve14, reject) => {
               const signal = ctx.signal;
-              const onAbort = () => resolve12("abort");
+              const onAbort = () => resolve14("abort");
               if (signal.aborted) {
-                resolve12("abort");
+                resolve14("abort");
                 return;
               }
               signal.addEventListener("abort", onAbort, { once: true });
-              awaiter(tool, use.input, use.id, tool.name).then(
+              awaiter(tool, use.input, use.id, suggestedPattern).then(
                 (c) => {
                   signal.removeEventListener("abort", onAbort);
-                  resolve12(c);
+                  resolve14(c);
                 },
                 (e) => {
                   signal.removeEventListener("abort", onAbort);
@@ -20787,7 +21361,6 @@ ${errorDetails}`,
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
-          const suggestedPattern = subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
           const pending = {
             type: "tool_confirm_pending",
             toolUseId: use.id,
@@ -20795,7 +21368,8 @@ ${errorDetails}`,
             input: use.input,
             suggestedPattern,
             decisionSource: decision.source,
-            riskTier: decision.riskTier ?? tool.riskTier
+            riskTier: decision.riskTier ?? tool.riskTier,
+            ...boundary.decision === "confirm" && boundary.reason ? { boundaryReason: boundary.reason } : {}
           };
           return { result: pending, tool, durationMs: Date.now() - start };
         }
@@ -20809,6 +21383,17 @@ ${errorDetails}`,
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
+        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" ? path20.isAbsolute(inputPath) ? inputPath : path20.resolve(ctx.projectRoot, inputPath) : void 0;
+        let writeTargetExisted;
+        if (tool.name === "write" && caps.includes("fs.write") && absPath) {
+          writeTargetExisted = await fs9.stat(absPath).then(
+            (stat13) => stat13.isFile(),
+            (error2) => error2.code === "ENOENT" ? false : void 0
+          );
+        }
         const producedText = await this.produceToolOutput(tool, use, ctx, budget);
         let { block: result, bytes } = this.settleToolOutput(tool, use, producedText, budget);
         budget -= bytes;
@@ -20837,6 +21422,35 @@ ${post.additionalContext}`;
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute("tool.output_bytes", outputChars);
         this.logToolSuccess(ctx, use, tool.name, Date.now() - start, outputChars);
+        if (!result.is_error && typeof inputPath === "string" && absPath) {
+          const operation = tool.name === "read" ? "read" : caps.includes("fs.write") && tool.name === "write" ? writeTargetExisted === false ? "create" : "update" : caps.includes("fs.write") ? "update" : "read";
+          const ts = (/* @__PURE__ */ new Date()).toISOString();
+          ctx.recordFileEvent?.({
+            operation,
+            filePath: inputPath,
+            absPath,
+            toolName: tool.name,
+            toolUseId: use.id,
+            durationMs: Date.now() - start
+          });
+          this.opts.events?.emit("file.event", {
+            operation,
+            filePath: inputPath,
+            absPath,
+            sessionId: ctx.session.id,
+            agentId: ctx.agentId,
+            agentName: ctx.agentName,
+            provider: typeof ctx.provider === "object" ? ctx.provider.id : String(ctx.provider),
+            model: ctx.model,
+            toolName: tool.name,
+            toolUseId: use.id,
+            scope: ctx.currentKanbanTaskId ? "task" : "session",
+            taskId: ctx.currentKanbanTaskId,
+            boardId: ctx.currentKanbanBoardId,
+            timestamp: ts,
+            durationMs: Date.now() - start
+          });
+        }
         return { result, tool, durationMs: Date.now() - start };
       } catch (err) {
         if (isWrongStackError(err)) {
@@ -21065,7 +21679,7 @@ ${post.additionalContext}`;
     toolPromise.catch(() => {
     });
     try {
-      output = await new Promise((resolve12, reject) => {
+      output = await new Promise((resolve14, reject) => {
         const onAbort = () => {
           setTimeout(() => reject(abortReasonToError(combined.reason)), 0);
         };
@@ -21073,7 +21687,7 @@ ${post.additionalContext}`;
         toolPromise.then(
           (v) => {
             combined.removeEventListener("abort", onAbort);
-            resolve12(v);
+            resolve14(v);
           },
           (e) => {
             combined.removeEventListener("abort", onAbort);
@@ -21364,12 +21978,12 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path18.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 = path18.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(
@@ -21387,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;
@@ -21680,7 +22303,7 @@ var contextManagerTool = createContextManagerTool();
 
 // src/infrastructure/logger.ts
 import * as fsp11 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path21 from "node:path";
 var LEVEL_RANK2 = {
   error: 0,
   warn: 1,
@@ -21744,7 +22367,7 @@ var DefaultLogger = class _DefaultLogger {
     this.stderr = opts.stderr !== false;
     this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
     if (this.file) {
-      const dir = path19.dirname(this.file);
+      const dir = path21.dirname(this.file);
       this._tail = this._tail.then(async () => {
         await fsp11.mkdir(dir, { recursive: true });
       }).catch(() => void 0);
@@ -22065,28 +22688,28 @@ function codexModelMeta(id) {
 }
 
 // src/models/mode-store.ts
-import * as fs9 from "node:fs/promises";
-import * as path21 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 path20 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(path20.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync4(path22.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
   return "";
 }
 function modePromptDirCandidates() {
-  const here = path20.dirname(fileURLToPath4(import.meta.url));
+  const here = path22.dirname(fileURLToPath4(import.meta.url));
   const candidates = [
-    path20.resolve(here, "../../instructions/modes"),
-    path20.resolve(here, "../instructions/modes"),
-    path20.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)));
 }
@@ -22318,8 +22941,8 @@ var DefaultModeStore = class {
   }
   async loadActiveMode() {
     try {
-      const configPath = path21.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 {
@@ -22328,8 +22951,8 @@ var DefaultModeStore = class {
   }
   async saveActiveMode() {
     try {
-      await fs9.mkdir(this.configDir, { recursive: true });
-      const configPath = path21.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)
@@ -22341,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 = path21.join(modesDir, entry);
-      const stat12 = await fs9.stat(filePath);
-      if (!stat12.isFile()) continue;
-      const content = await fs9.readFile(filePath, "utf8");
-      const id = path21.basename(entry, path21.extname(entry));
+      const filePath = path23.join(modesDir, entry);
+      const stat13 = await fs10.stat(filePath);
+      if (!stat13.isFile()) continue;
+      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()),
@@ -22364,8 +22987,8 @@ async function loadProjectModes(modesDir) {
 async function loadUserModes(modesDir) {
   const modes = [];
   try {
-    const manifestPath = path21.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);
@@ -22376,8 +22999,8 @@ async function loadUserModes(modesDir) {
 }
 
 // src/models/models-registry.ts
-import * as fs10 from "node:fs/promises";
-import * as path22 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;
@@ -22453,7 +23076,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path22.join(path22.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;
@@ -22618,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;
@@ -22697,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;
@@ -22705,7 +23328,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path22.resolve(this.cacheFile);
+    return path24.resolve(this.cacheFile);
   }
 };
 function formatAge(seconds) {
@@ -22943,9 +23566,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve12) => {
+    const timeout = new Promise((resolve14) => {
       timer = setTimeout(
-        () => resolve12({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve14({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -23129,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 path28 = opts.path ?? "/metrics";
+  const path30 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -23139,7 +23762,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path28) {
+    if (url === path30) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -23185,14 +23808,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import("node:http");
     server = createServer(listener);
   }
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve14, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve12();
+      resolve14();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -23203,9 +23826,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path28}`,
-    close: () => new Promise((resolve12, reject) => {
-      server.close((err) => err ? reject(err) : resolve12());
+    url: `${protocol}://${host}:${boundPort}${path30}`,
+    close: () => new Promise((resolve14, reject) => {
+      server.close((err) => err ? reject(err) : resolve14());
     })
   };
 }
@@ -23475,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({
@@ -23520,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, path28, message) {
-  diagnostics.push({ severity: "error", code, path: path28, message });
+function error(diagnostics, code, path30, message) {
+  diagnostics.push({ severity: "error", code, path: path30, message });
 }
-function validatePatterns(value, path28, diagnostics) {
+function validatePatterns(value, path30, diagnostics) {
   if (!Array.isArray(value)) {
-    error(diagnostics, "invalid_pattern_list", path28, "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",
-      path28,
+      path30,
       `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
     );
     return void 0;
@@ -23540,7 +24163,7 @@ function validatePatterns(value, path28, diagnostics) {
   const patterns = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, pattern] of value.entries()) {
-    const itemPath = `${path28}[${index}]`;
+    const itemPath = `${path30}[${index}]`;
     if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
       error(
         diagnostics,
@@ -23652,8 +24275,8 @@ var LruCache = class {
     this.capacity = capacity;
   }
   get(key) {
+    if (!this.store.has(key)) return void 0;
     const value = this.store.get(key);
-    if (value === void 0) return void 0;
     this.store.delete(key);
     this.store.set(key, value);
     return value;
@@ -23864,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 = {};
@@ -24114,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;
@@ -24159,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() {
   }
 };
@@ -24359,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 path23 from "node:path";
+import * as path25 from "node:path";
 
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
@@ -24501,8 +25272,8 @@ function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
-    const stat12 = fs12.statSync(keyFile);
-    const actualMode = stat12.mode & 511;
+    const stat13 = fs13.statSync(keyFile);
+    const actualMode = stat13.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       warn(
         `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Run: chmod ${KEY_FILE_MODE.toString(8)} ${keyFile}`
@@ -24598,16 +25369,16 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes4(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs12.mkdirSync(path23.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;
@@ -24625,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) });
@@ -24635,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;
@@ -24682,15 +25453,15 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs12.mkdirSync(path23.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;
@@ -24740,7 +25511,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fsp12.mkdir(path23.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);
 }
@@ -24824,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 path24 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 {
@@ -24845,7 +25616,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp13.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path24.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path26.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -24964,8 +25735,8 @@ function mergeAdjacentText(blocks) {
 }
 
 // src/storage/config-loader.ts
-import * as fs13 from "node:fs/promises";
-import * as path25 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";
@@ -25225,6 +25996,7 @@ var defaultIndexing = {
 };
 var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "model",
   "cwd",
   "context",
@@ -25247,6 +26019,7 @@ var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "models",
   "modelMatrix",
@@ -25282,6 +26055,7 @@ var KNOWN_DENIED_IN_PROJECT = [
 ];
 var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "provider",
   "model",
   "apiKey",
@@ -25298,6 +26072,7 @@ var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "hooks",
   "plugins",
@@ -25445,8 +26220,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   return out;
 }
 function samePath(a, b) {
-  let ra = path25.resolve(a);
-  let rb = path25.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();
@@ -25468,7 +26243,7 @@ function deepMerge2(base, patch) {
     opts
   );
 }
-var DefaultConfigLoader = class {
+var DefaultConfigLoader = class _DefaultConfigLoader {
   paths;
   strict;
   vault;
@@ -25502,12 +26277,17 @@ var DefaultConfigLoader = class {
     let cfg = { ...BEHAVIOR_DEFAULTS };
     await this.ensureGlobalDefaults();
     const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
-    const [global, local, inProject] = await Promise.all([
+    const [bootstrap, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
       this.readJson(this.paths.projectLocalConfig),
       inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
-    cfg = deepMerge2(cfg, global);
+    cfg = deepMerge2(cfg, bootstrap);
+    const profileName = bootstrap.activeProfile ?? "default";
+    const profileCfg = await this.readJson(this.paths.profileConfig(profileName));
+    if (Object.keys(profileCfg).length > 0) {
+      cfg = deepMerge2(cfg, profileCfg);
+    }
     cfg = deepMerge2(cfg, local);
     cfg = deepMerge2(
       cfg,
@@ -25533,10 +26313,11 @@ var DefaultConfigLoader = class {
           cfg = deepMerge2(cfg, patch);
         }
       } catch (err) {
-        this.logWarn(
-          "Config source load failed",
-          { event: "config.source_load_failed", source: src.name, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config source load failed", {
+          event: "config.source_load_failed",
+          source: src.name,
+          message: toErrorMessage(err)
+        });
       }
     }
     if (opts.cliFlags) {
@@ -25569,14 +26350,20 @@ 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();
     try {
       await withFileLock(fp, async () => {
         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;
@@ -25595,29 +26382,46 @@ var DefaultConfigLoader = class {
               durationMs: Date.now() - t0,
               ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
             });
-            this.logWarn(
-              "Config defaults read failed",
-              { event: "config.defaults_read_failed", path: fp, message: toErrorMessage(err) }
-            );
+            this.logWarn("Config defaults read failed", {
+              event: "config.defaults_read_failed",
+              path: fp,
+              message: toErrorMessage(err)
+            });
             return;
           }
+          fileExisted = false;
           parsed = {};
         }
-        const { value, changed } = fillMissingDefaults(
-          parsed,
-          BEHAVIOR_DEFAULTS
-        );
-        if (!changed) return;
-        await atomicWrite(fp, JSON.stringify(value, null, 2), { mode: 384 });
-        this.events?.emit("storage.write", {
-          sessionId: "~config~",
-          store: "config",
-          filePath: fp,
-          operation: "ensure_defaults",
-          outcome: "success",
-          durationMs: Date.now() - t0,
-          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-        });
+        const profileName = parsed.activeProfile ?? "default";
+        const profileFp = this.paths.profileConfig(profileName);
+        await this.ensureProfileConfig(profileFp, parsed, fileExisted);
+        const bootstrap = {
+          version: 1,
+          activeProfile: profileName
+        };
+        let needsBootstrapWrite = false;
+        if (parsed.version !== 1) {
+          needsBootstrapWrite = true;
+        }
+        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~",
+            store: "config",
+            filePath: fp,
+            operation: "ensure_defaults",
+            outcome: "success",
+            durationMs: Date.now() - t0,
+            ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+          });
+        }
       });
     } catch (err) {
       this.events?.emit("storage.error", {
@@ -25631,11 +26435,104 @@ var DefaultConfigLoader = class {
         durationMs: Date.now() - t0,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config defaults write failed",
-        { event: "config.defaults_write_failed", path: fp, message: toErrorMessage(err) }
-      );
+      this.logWarn("Config defaults write failed", {
+        event: "config.defaults_write_failed",
+        path: fp,
+        message: toErrorMessage(err)
+      });
+    }
+  }
+  /**
+   * Ensure a profile config file exists at the given path.
+   * 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 {
+      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;
+          }
+        }
+        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;
+          }
+        }
+      }
+      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
@@ -25685,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", {
@@ -25736,10 +26633,10 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config sync load failed",
-        { event: "config.sync_load_failed", message: toErrorMessage(err) }
-      );
+      this.logWarn("Config sync load failed", {
+        event: "config.sync_load_failed",
+        message: toErrorMessage(err)
+      });
       return null;
     }
   }
@@ -25747,8 +26644,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat12 = await fs13.stat(file);
-      mtimeMs = stat12.mtimeMs;
+      const stat13 = await fs14.stat(file);
+      mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -25768,15 +26665,16 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config read failed (stat)",
-        { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-      );
+      this.logWarn("Config read failed (stat)", {
+        event: "config.read_failed",
+        path: file,
+        message: toErrorMessage(err)
+      });
       return {};
     }
     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", {
@@ -25789,10 +26687,11 @@ var DefaultConfigLoader = class {
           error: storageErrorString(err),
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
         });
-        this.logWarn(
-          "Config read failed (read)",
-          { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config read failed (read)", {
+          event: "config.read_failed",
+          path: file,
+          message: toErrorMessage(err)
+        });
       }
       this.jsonCache.set(file, { mtimeMs: null, value: {} });
       return {};
@@ -25809,10 +26708,10 @@ var DefaultConfigLoader = class {
         error: "parse error or empty file",
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config parse failed \u2014 falling back to defaults",
-        { event: "config.parse_failed", path: file }
-      );
+      this.logWarn("Config parse failed \u2014 falling back to defaults", {
+        event: "config.parse_failed",
+        path: file
+      });
       return {};
     }
     this.jsonCache.set(file, { mtimeMs, value: structuredClone(parsed.value) });
@@ -26306,7 +27205,7 @@ ${cat}:`);
 
 // src/storage/queue-store.ts
 import * as fsp15 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path28 from "node:path";
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -26315,7 +27214,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path26.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;
@@ -26473,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 path27 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 {
@@ -26484,7 +27383,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path27.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;
@@ -26545,7 +27444,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path27.dirname(this.file));
+    await ensureDir(path29.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -26844,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();
@@ -26862,8 +27761,8 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat12 = await fs14.stat(sessionPath);
-      mtimeMs = stat12.mtimeMs;
+      const stat13 = await fs15.stat(sessionPath);
+      mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);