@wrongstack/core 0.298.3 → 0.300.0

package/dist/defaults/index.js

@@ -295,7 +295,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve19, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -314,7 +314,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve17,
+        resolve: resolve19,
         reject,
         timer
       });
@@ -663,13 +663,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve17(d);
+        resolve19(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -1374,7 +1374,9 @@ function safeProfileName(name) {
 function activeProfileName(globalRoot) {
   try {
     const parsed = JSON.parse(fs.readFileSync(path.join(globalRoot, "config.json"), "utf8"));
-    return safeProfileName(typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0);
+    return safeProfileName(
+      typeof parsed.activeProfile === "string" ? parsed.activeProfile : void 0
+    );
   } catch {
     return "default";
   }
@@ -1454,6 +1456,7 @@ function resolveWstackPaths(opts) {
     projectPlan: path.join(projectDir, "plan.json"),
     projectAutophase: path.join(projectDir, "autophase"),
     projectSddBoards: path.join(projectDir, "sdd-boards"),
+    projectRequirementIntakes: path.join(projectDir, "requirement-intakes"),
     syncConfig: path.join(profileDir, "sync.json"),
     configHistoryDir: path.join(globalRoot, "config-history"),
     projectStatus: (projectHash2) => path.join(globalRoot, "projects", projectHash2, "status.json")
@@ -5303,7 +5306,7 @@ function createDelegateTool(opts) {
   };
 }
 async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
-  return new Promise((resolve17) => {
+  return new Promise((resolve19) => {
     let settled = false;
     let timer;
     let offAbort = () => {
@@ -5316,7 +5319,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
       offIter();
       offProgress();
       offAbort();
-      resolve17(value);
+      resolve19(value);
     };
     const arm = () => {
       if (timer) clearTimeout(timer);
@@ -5658,6 +5661,21 @@ var DirectorStateCheckpoint = class {
   resume(snapshot) {
     this.snapshot = snapshot;
   }
+  /**
+   * After resume, pin the live spawn ceiling from the current profile/flag
+   * while preserving `spawnCount` (cumulative used budget). Checkpoint
+   * metadata previously stored a historical `maxSpawns` that can diverge
+   * from the live runtime ceiling — operators need the live value to win.
+   */
+  applyLiveMaxSpawns(maxSpawns) {
+    if (this.snapshot.maxSpawns === maxSpawns) return;
+    this.snapshot = {
+      ...this.snapshot,
+      maxSpawns
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
   current() {
     return this.snapshot;
   }
@@ -7170,10 +7188,10 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (result) => resolve17({
+        resolve: (result) => resolve19({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         })
@@ -7181,7 +7199,7 @@ var DirectorTaskRegistry = class _DirectorTaskRegistry {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve17({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve19({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -7299,11 +7317,11 @@ ${JSON.stringify(result.result, null, 2)}
         this.makeStoppedResult(taskId, "director", `Unknown task id "${taskId}" \u2014 never assigned`)
       );
     }
-    let resolve17;
+    let resolve19;
     const promise = new Promise((done) => {
-      resolve17 = done;
+      resolve19 = done;
     });
-    this.taskWaiters.set(taskId, { promise, resolve: resolve17 });
+    this.taskWaiters.set(taskId, { promise, resolve: resolve19 });
     return promise;
   }
   recordAssignment(task) {
@@ -9397,7 +9415,7 @@ function truncate(s, max) {
 var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)(?:\s+(?:has|have))?(?:\s+been)?[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|usage[-_\s]*limit[-_\s]*(?:reached|exceeded)/i;
 
 // src/types/provider.ts
-var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|input.{0,12}too (?:large|long)|context_length_exceeded/i;
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|(?:prompt|request|input|messages?).{0,12}too (?:large|long)|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
 var RATE_LIMIT_EXCEEDED_RE = /rate[-_\s]*limit[-_\s]*exceeded/i;
 function classifyProviderError(status, body, message) {
@@ -9407,7 +9425,7 @@ function classifyProviderError(status, body, message) {
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
   if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
-  if (status === 429 && body?.message && RATE_LIMIT_EXCEEDED_RE.test(body.message)) {
+  if (status === 429 && body?.message && body.type !== "rate_limit_exceeded" && RATE_LIMIT_EXCEEDED_RE.test(body.message)) {
     return "quota_exhausted";
   }
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
@@ -9467,7 +9485,7 @@ var ProviderError = class extends WrongStackError {
     const e = err;
     const name = e.name;
     if (typeof name !== "string" || !name.endsWith("Error")) return false;
-    return typeof e.status === "number" && typeof e.retryable === "boolean" && typeof e.kind === "string";
+    return typeof e.status === "number" && typeof e.retryable === "boolean" && typeof e.kind === "string" && typeof e.describe === "function";
   }
   constructor(message, status, retryable, providerId, opts = {}) {
     const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
@@ -11057,7 +11075,7 @@ async function spawn(host, config, priceLookup) {
     if (host.spawnDepth >= maxSpawnDepth) {
       throw new FleetSpawnBudgetError("max_spawn_depth", maxSpawnDepth, host.spawnDepth);
     }
-    if (host.spawnCount >= host.maxSpawns) {
+    if (host.spawnCount >= host.maxSpawns && !config.spawnBudgetExempt) {
       throw new FleetSpawnBudgetError("max_spawns", host.maxSpawns, host.spawnCount + 1);
     }
     if (host.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
@@ -11108,7 +11126,9 @@ async function spawn(host, config, priceLookup) {
       ...Number.isFinite(budget?.remainingSpawns ?? host.maxSpawns - host.spawnCount) ? {
         remainingSpawns: Math.max(
           0,
-          (budget?.remainingSpawns ?? host.maxSpawns - host.spawnCount) - 1
+          // Exempt spawns don't consume leader budget, so the reported
+          // headroom is not decremented for them.
+          (budget?.remainingSpawns ?? host.maxSpawns - host.spawnCount) - (config.spawnBudgetExempt ? 0 : 1)
         )
       } : {},
       ...Number.isFinite(maxFleetTokens) ? { maxTokens: maxFleetTokens } : {},
@@ -11121,7 +11141,9 @@ async function spawn(host, config, priceLookup) {
   if (host.fleetManager) {
     host.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
   } else {
-    host.spawnCount += 1;
+    if (!config.spawnBudgetExempt) {
+      host.spawnCount += 1;
+    }
     host.subagentMeta.set(result.subagentId, {
       provider: config.provider,
       model: config.model
@@ -11473,12 +11495,12 @@ async function executeSubagentWithTimeout({
           }
           return new Promise((resolveDecision) => {
             let settled = false;
-            const resolve17 = (d) => {
+            const resolve19 = (d) => {
               if (settled) return;
               settled = true;
               resolveDecision(d);
             };
-            const fallback = setTimeout(() => resolve17("stop"), DECISION_TIMEOUT_MS);
+            const fallback = setTimeout(() => resolve19("stop"), DECISION_TIMEOUT_MS);
             const sessionId = currentSessionId();
             budget._events?.emit("budget.threshold_reached", {
               ...sessionId ? { sessionId } : {},
@@ -11488,11 +11510,11 @@ async function executeSubagentWithTimeout({
               timeoutMs: DECISION_TIMEOUT_MS,
               extend: (extra) => {
                 clearTimeout(fallback);
-                queueMicrotask(() => resolve17({ extend: extra }));
+                queueMicrotask(() => resolve19({ extend: extra }));
               },
               deny: () => {
                 clearTimeout(fallback);
-                resolve17("stop");
+                resolve19("stop");
               }
             });
           });
@@ -11879,7 +11901,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((resolve17, reject) => {
+        return new Promise((resolve19, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -11888,7 +11910,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve17(result);
+              resolve19(result);
             }
           };
           this.on("task.completed", handler);
@@ -11913,13 +11935,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((resolve17) => {
+    return new Promise((resolve19) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve17({
+        resolve19({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -11927,7 +11949,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve17({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve19({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -12046,8 +12068,17 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       durationMs: 0
     };
     this.completedResults.push(synthetic);
+    this.trimCompletedResults();
     this.emit("task.completed", { task, result: synthetic });
   }
+  trimCompletedResults() {
+    if (this.completedResults.length > _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS) {
+      this.completedResults.splice(
+        0,
+        this.completedResults.length - _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS
+      );
+    }
+  }
   async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
@@ -12181,12 +12212,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   }
   recordCompletion(result) {
     this.completedResults.push(result);
-    if (this.completedResults.length > _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS) {
-      this.completedResults.splice(
-        0,
-        this.completedResults.length - _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS
-      );
-    }
+    this.trimCompletedResults();
     this.totalIterations += result.iterations;
     if (this.inFlight > 0) {
       this.inFlight--;
@@ -13604,10 +13630,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path40, errors, depth) {
+function walk(value, schema, path42, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path40 || "<root>",
+      path: path42 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -13615,7 +13641,7 @@ function walk(value, schema, path40, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path40 || "<root>",
+        path: path42 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -13624,7 +13650,7 @@ function walk(value, schema, path40, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path40 || "<root>",
+        path: path42 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -13636,7 +13662,7 @@ function walk(value, schema, path40, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path40, req),
+          path: joinPath(path42, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -13644,14 +13670,14 @@ function walk(value, schema, path40, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path40, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path42, 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, `${path40}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path42}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -13947,7 +13973,7 @@ function invalid(sessionId) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 
 // src/utils/slug.ts
@@ -16218,7 +16244,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve17) => {
+  return new Promise((resolve19) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -16261,8 +16287,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve17(result(1, err.message)));
-    child.on("close", (code) => resolve17(result(code ?? 1)));
+    child.on("error", (err) => resolve19(result(1, err.message)));
+    child.on("close", (code) => resolve19(result(code ?? 1)));
   });
 }
 
@@ -16311,14 +16337,14 @@ function sessionIdResolutionError(resolution) {
 }
 
 // src/storage/session-read-scrubber.ts
-function scrubPersistedSessionEvent(event, scrubber) {
-  return scrubber.scrubObject(event);
+function scrubPersistedSessionEvent(event, scrubber2) {
+  return scrubber2.scrubObject(event);
 }
-function scrubPersistedSessionData(data, scrubber) {
-  return scrubber.scrubObject(data);
+function scrubPersistedSessionData(data, scrubber2) {
+  return scrubber2.scrubObject(data);
 }
-function scrubPersistedSessionSummary(summary, scrubber) {
-  const scrubbed = scrubber.scrubObject(summary);
+function scrubPersistedSessionSummary(summary, scrubber2) {
+  const scrubbed = scrubber2.scrubObject(summary);
   const { name: _name, lastUserMessage: _lastUserMessage, ...rest } = scrubbed;
   const title = sessionContentText(scrubbed.title) || "(empty session)";
   const name = scrubbed.name === void 0 ? "" : sessionContentText(scrubbed.name);
@@ -18902,6 +18928,7 @@ var Director = class _Director {
   }
   setCheckpointState(snapshot) {
     setCheckpointState(this.checkpointHost(), snapshot);
+    this.applyResumeBudget(snapshot);
   }
   async readSession(subagentId, tail) {
     return readDirectorSubagentSession({
@@ -18953,6 +18980,22 @@ var Director = class _Director {
   }
   resumeFromCheckpoint(snapshot) {
     resumeFromCheckpoint(this.checkpointHost(), snapshot);
+    this.applyResumeBudget(snapshot);
+  }
+  /**
+   * After re-attaching checkpoint metadata, pin the live maxSpawns ceiling
+   * (profile/flag/env wins over historical checkpoint metadata). The
+   * historical cumulative spawn counter is deliberately NOT restored — the
+   * lifetime budget is scoped to this director run, so a restarted session
+   * resumes with a fresh budget rather than a possibly-exhausted counter.
+   */
+  applyResumeBudget(snapshot) {
+    if (this.fleetManager) {
+      this.fleetManager.restoreFromCheckpoint(snapshot);
+    }
+    this.stateCheckpoint?.applyLiveMaxSpawns(
+      Number.isFinite(this.maxSpawns) ? this.maxSpawns : void 0
+    );
   }
 };
 
@@ -21620,12 +21663,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path40, text } of files) {
+  for (const { path: path42, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason, axis = "color") => {
-        violations.push({ file: path40, line: lineNo, snippet: snippet.slice(0, 80), reason, axis });
+        violations.push({ file: path42, line: lineNo, snippet: snippet.slice(0, 80), reason, axis });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -22308,9 +22351,9 @@ function buildRecoveryStrategies(opts) {
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
         if (ctx?.signal) {
-          await new Promise((resolve17) => {
+          await new Promise((resolve19) => {
             if (ctx.signal.aborted) {
-              resolve17();
+              resolve19();
               return;
             }
             let settled = false;
@@ -22321,7 +22364,7 @@ function buildRecoveryStrategies(opts) {
               settled = true;
               if (timer !== void 0) clearTimeout(timer);
               ctx.signal.removeEventListener("abort", onAbort);
-              resolve17();
+              resolve19();
             };
             timer = setTimeout(finish, delay);
             ctx.signal.addEventListener("abort", onAbort, { once: true });
@@ -24514,8 +24557,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve17) => {
-            drainTimer = setTimeout(resolve17, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve19) => {
+            drainTimer = setTimeout(resolve19, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -24675,8 +24718,54 @@ function runWithNetworkTelemetry(context, run) {
   return storage.run(context, run);
 }
 
+// src/security/error-sanitize.ts
+import { homedir as homedir2 } from "node:os";
+var scrubber = new DefaultSecretScrubber();
+function scrubErrorText(text) {
+  if (!text) return text;
+  let out = scrubber.scrub(text);
+  const home = safeHomedir();
+  if (home && home.length > 2) {
+    out = replaceAllCaseInsensitive(out, home, "~");
+    const alt = home.includes("\\") ? home.replace(/\\/g, "/") : home.replace(/\//g, "\\");
+    if (alt !== home) out = replaceAllCaseInsensitive(out, alt, "~");
+  }
+  return out;
+}
+function safeHomedir() {
+  try {
+    return homedir2();
+  } catch {
+    return "";
+  }
+}
+function replaceAllCaseInsensitive(haystack, needle, replacement) {
+  const lowerHay = haystack.toLowerCase();
+  const lowerNeedle = needle.toLowerCase();
+  let idx = lowerHay.indexOf(lowerNeedle);
+  if (idx === -1) return haystack;
+  let out = "";
+  let from = 0;
+  while (idx !== -1) {
+    out += haystack.slice(from, idx) + replacement;
+    from = idx + needle.length;
+    idx = lowerHay.indexOf(lowerNeedle, from);
+  }
+  return out + haystack.slice(from);
+}
+
 // src/core/provider-runner.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
+function scrubProviderBody(body) {
+  if (!body) return void 0;
+  return {
+    ...body,
+    ...body.type !== void 0 ? { type: scrubErrorText(body.type) } : {},
+    ...body.message !== void 0 ? { message: scrubErrorText(body.message) } : {},
+    ...body.raw !== void 0 ? { raw: scrubErrorText(body.raw) } : {},
+    ...body.requestId !== void 0 ? { requestId: scrubErrorText(body.requestId) } : {}
+  };
+}
 function providerLogCtx(p, r) {
   return {
     providerId: p.id,
@@ -24761,7 +24850,10 @@ async function runProviderWithRetry(opts) {
       const isProviderErr = err instanceof ProviderError || ProviderError.isProviderError(err);
       const errAsErr = err instanceof Error ? err : new Error(String(err));
       const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
-      const description = isProviderErr ? err.describe() : errAsErr.message;
+      const providerErrorBody = isProviderErr ? scrubProviderBody(err.body) : void 0;
+      const description = scrubErrorText(
+        isProviderErr ? err.describe() : errAsErr.message
+      );
       const delay = canRetry ? Math.round(retry.delayMs(attempt, isProviderErr ? err : errAsErr)) : void 0;
       events.emit("provider.attempt.failed", {
         ...correlation,
@@ -24774,7 +24866,8 @@ async function runProviderWithRetry(opts) {
         retryable: canRetry,
         retryScheduled: canRetry,
         ...delay !== void 0 ? { retryDelayMs: delay } : {},
-        ...isProviderErr && err.body?.requestId ? { providerRequestId: err.body.requestId } : {}
+        ...providerErrorBody?.requestId ? { providerRequestId: providerErrorBody.requestId } : {},
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
       });
       if (!canRetry) {
         events.emit("provider.error", {
@@ -24782,13 +24875,15 @@ async function runProviderWithRetry(opts) {
           providerId: isProviderErr ? err.providerId : provider.id,
           status: isProviderErr ? err.status : 0,
           description,
-          retryable: false
+          retryable: false,
+          ...providerErrorBody ? { errorBody: providerErrorBody } : {}
         });
         logger.error(`Provider call failed after ${attempt + 1} attempt(s) \u2014 ${description}`, {
           ...providerLogCtx(provider, request),
           attempts: attempt + 1,
           errorDescription: description,
           status: isProviderErr ? err.status : void 0,
+          errorBody: providerErrorBody,
           errorName: err instanceof Error ? err.name : void 0,
           errorStack: err instanceof Error ? err.stack?.split("\n").slice(0, 3).join("\n") : void 0
         });
@@ -24802,7 +24897,8 @@ async function runProviderWithRetry(opts) {
         maxAttempts,
         delayMs: delay,
         errorDescription: description,
-        status: isProviderErr ? err.status : void 0
+        status: isProviderErr ? err.status : void 0,
+        errorBody: providerErrorBody
       });
       events.emit("provider.retry", {
         sessionId: resolveEventSessionId(ctx),
@@ -24810,9 +24906,10 @@ async function runProviderWithRetry(opts) {
         attempt: attemptNum,
         delayMs: delay,
         status: isProviderErr ? err.status : 0,
-        description
+        description,
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
       });
-      await new Promise((resolve17, reject) => {
+      await new Promise((resolve19, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -24828,7 +24925,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve17();
+          resolve19();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -26580,14 +26677,14 @@ ${head}${TOOL_OUTPUT_ARTIFACT_OMISSION}${tail}`;
     return content;
   }
 }
-function hashPermissionInput(input, scrubber) {
+function hashPermissionInput(input, scrubber2) {
   let serialized;
   try {
     serialized = JSON.stringify(input) ?? "";
   } catch {
     serialized = String(input);
   }
-  return createHash7("sha256").update(scrubber.scrub(serialized), "utf8").digest("hex");
+  return createHash7("sha256").update(scrubber2.scrub(serialized), "utf8").digest("hex");
 }
 function sliceUtf8Prefix(text, maxBytes) {
   if (maxBytes <= 0) return "";
@@ -27090,18 +27187,18 @@ ${errorDetails}`,
         if (this.opts.confirmAwaiter) {
           const awaiter = this.opts.confirmAwaiter;
           const choice = await new Promise(
-            (resolve17, reject) => {
+            (resolve19, reject) => {
               const signal = ctx.signal;
-              const onAbort = () => resolve17("abort");
+              const onAbort = () => resolve19("abort");
               if (signal.aborted) {
-                resolve17("abort");
+                resolve19("abort");
                 return;
               }
               signal.addEventListener("abort", onAbort, { once: true });
               awaiter(tool, use.input, use.id, suggestedPattern).then(
                 (c) => {
                   signal.removeEventListener("abort", onAbort);
-                  resolve17(c);
+                  resolve19(c);
                 },
                 (e) => {
                   signal.removeEventListener("abort", onAbort);
@@ -27439,7 +27536,7 @@ ${post.additionalContext}`;
     toolPromise.catch(() => {
     });
     try {
-      output = await new Promise((resolve17, reject) => {
+      output = await new Promise((resolve19, reject) => {
         const onAbort = () => {
           setTimeout(() => reject(abortReasonToError(combined.reason)), 0);
         };
@@ -27447,7 +27544,7 @@ ${post.additionalContext}`;
         toolPromise.then(
           (v) => {
             combined.removeEventListener("abort", onAbort);
-            resolve17(v);
+            resolve19(v);
           },
           (e) => {
             combined.removeEventListener("abort", onAbort);
@@ -27902,6 +27999,38 @@ var sshManagerServer = () => ({
   permission: "confirm",
   requestTimeoutMs: 18e4
 });
+var requirementIntakeServer = () => ({
+  name: "requirement-intake",
+  description: "WrongStack Requirements Intake \u2014 list intake records and file new ones (project-scoped, --writable)",
+  transport: "stdio",
+  command: "wstack-requirement-intake-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "auto"
+});
+var kanbanServer = () => ({
+  name: "kanban",
+  description: "WrongStack Kanban \u2014 inspect and manage project work boards (project-scoped, manage tier, no destructive ops)",
+  transport: "stdio",
+  command: "wstack-kanban-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "confirm"
+});
+var mailboxServer = () => ({
+  name: "mailbox",
+  description: "WrongStack Mailbox \u2014 read and send project agent mail (project-scoped, no admin/credentials)",
+  transport: "stdio",
+  command: "wstack-mailbox-mcp",
+  args: ["--project-root", ".", "--actor", "external-agent", "--writable"],
+  permission: "auto"
+});
+var codebaseIndexServer = () => ({
+  name: "codebase-index",
+  description: "WrongStack Codebase Index \u2014 symbol search and dependency graphs (project-scoped, --writable)",
+  transport: "stdio",
+  command: "wstack-codebase-index-mcp",
+  args: ["--project-root", ".", "--writable"],
+  permission: "auto"
+});
 var allServers = () => ({
   filesystem: { ...filesystemServer(), enabled: false },
   github: { ...githubServer(), enabled: false },
@@ -27916,7 +28045,11 @@ var allServers = () => ({
   "zai-vision": { ...zaiVisionServer(), enabled: false },
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false },
   playwright: { ...playwrightServer(), enabled: false },
-  ssh: { ...sshManagerServer(), enabled: false }
+  ssh: { ...sshManagerServer(), enabled: false },
+  kanban: { ...kanbanServer(), enabled: false },
+  mailbox: { ...mailboxServer(), enabled: false },
+  "codebase-index": { ...codebaseIndexServer(), enabled: false },
+  "requirement-intake": { ...requirementIntakeServer(), enabled: false }
 });
 
 // src/models/codex-catalog.ts
@@ -28359,7 +28492,7 @@ var DefaultModelsRegistry = class {
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
     if (this.seed) {
-      this.payload = this.seed;
+      this.payload = this.withExtraOverlay(this.seed);
       this.fetchedAt = /* @__PURE__ */ new Date();
       return this.payload;
     }
@@ -28979,9 +29112,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve17) => {
+    const timeout = new Promise((resolve19) => {
       timer = setTimeout(
-        () => resolve17({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve19({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -29179,7 +29312,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path40 = opts.path ?? "/metrics";
+  const path42 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const token = opts.token;
@@ -29202,7 +29335,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path40) {
+    if (url === path42) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -29248,14 +29381,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import("node:http");
     server = createServer(listener);
   }
-  await new Promise((resolve17, reject) => {
+  await new Promise((resolve19, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve17();
+      resolve19();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -29266,9 +29399,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path40}`,
-    close: () => new Promise((resolve17, reject) => {
-      server.close((err) => err ? reject(err) : resolve17());
+    url: `${protocol}://${host}:${boundPort}${path42}`,
+    close: () => new Promise((resolve19, reject) => {
+      server.close((err) => err ? reject(err) : resolve19());
     })
   };
 }
@@ -29539,6 +29672,7 @@ function startOtlpTraceExporter(opts) {
 
 // src/security/permission-policy.ts
 import * as fs12 from "node:fs/promises";
+import * as path36 from "node:path";
 
 // src/security/permission-policy-schema.ts
 var TRUST_POLICY_LIMITS = Object.freeze({
@@ -29583,19 +29717,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, path40, message) {
-  diagnostics.push({ severity: "error", code, path: path40, message });
+function error(diagnostics, code, path42, message) {
+  diagnostics.push({ severity: "error", code, path: path42, message });
 }
-function validatePatterns(value, path40, diagnostics) {
+function validatePatterns(value, path42, diagnostics) {
   if (!Array.isArray(value)) {
-    error(diagnostics, "invalid_pattern_list", path40, "must be an array of strings");
+    error(diagnostics, "invalid_pattern_list", path42, "must be an array of strings");
     return void 0;
   }
   if (value.length > TRUST_POLICY_LIMITS.maxPatternsPerRule) {
     error(
       diagnostics,
       "too_many_patterns",
-      path40,
+      path42,
       `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
     );
     return void 0;
@@ -29603,7 +29737,7 @@ function validatePatterns(value, path40, diagnostics) {
   const patterns = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, pattern] of value.entries()) {
-    const itemPath = `${path40}[${index}]`;
+    const itemPath = `${path42}[${index}]`;
     if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
       error(
         diagnostics,
@@ -30018,6 +30152,8 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
 };
 
 // src/security/permission-helpers.ts
+import { realpathSync } from "node:fs";
+import * as path35 from "node:path";
 function matchesTrust(patterns, subject) {
   return patterns.includes(subject) || matchAny(patterns, subject);
 }
@@ -30088,9 +30224,51 @@ var SHELL_READ_VERBS = /* @__PURE__ */ new Set([
 function stripShellQuotes(value) {
   return value.replace(/^['"]|['"]$/g, "");
 }
+var AGENT_STATE_SENSITIVE_BASENAMES = /^(?:config\.json|config\.local\.json|trust\.json|auth\.json|\.key)$/i;
+function unescapeGlobSubject(value) {
+  return value.replace(/\\([*?[\]])/g, "$1");
+}
+function normalizeForCompare(value) {
+  const forward = unescapeGlobSubject(value).replace(/\\/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? forward.toLowerCase() : forward;
+}
+function realpathOfNearestExisting(p) {
+  let probe = p;
+  const tail = [];
+  for (; ; ) {
+    try {
+      return tail.length === 0 ? realpathSync(probe) : path35.join(realpathSync(probe), ...tail);
+    } catch {
+      const parent = path35.dirname(probe);
+      if (parent === probe) return p;
+      tail.unshift(path35.basename(probe));
+      probe = parent;
+    }
+  }
+}
+var agentStateRootRealCache = /* @__PURE__ */ new Map();
+function isInsideAgentStateRoot(absPath) {
+  const lexicalRoot = normalizeForCompare(path35.resolve(wstackGlobalRoot()));
+  if (!lexicalRoot) return false;
+  const target = normalizeForCompare(absPath);
+  if (target === lexicalRoot || target.startsWith(`${lexicalRoot}/`)) return true;
+  let realRoot = agentStateRootRealCache.get(lexicalRoot);
+  if (realRoot === void 0) {
+    realRoot = normalizeForCompare(realpathOfNearestExisting(path35.resolve(wstackGlobalRoot())));
+    agentStateRootRealCache.set(lexicalRoot, realRoot);
+  }
+  if (!realRoot || realRoot === lexicalRoot) return false;
+  const realTarget = normalizeForCompare(realpathOfNearestExisting(absPath));
+  return realTarget === realRoot || realTarget.startsWith(`${realRoot}/`);
+}
+function isProtectedAgentStatePath(absPath) {
+  if (!isInsideAgentStateRoot(absPath)) return false;
+  return AGENT_STATE_SENSITIVE_BASENAMES.test(path35.basename(normalizeForCompare(absPath)));
+}
 function pathLooksSensitive(rawPath) {
   const normalized = stripShellQuotes(rawPath).replace(/\\/g, "/");
-  return SENSITIVE_READ_PATHS.some((pattern) => pattern.test(normalized));
+  if (SENSITIVE_READ_PATHS.some((pattern) => pattern.test(normalized))) return true;
+  return isProtectedAgentStatePath(normalized);
 }
 function inputPathLooksSensitive(input) {
   if (!input || typeof input !== "object") return false;
@@ -30114,6 +30292,34 @@ function shellCommandReadsSensitivePath(command) {
 }
 
 // src/security/permission-policy.ts
+function fsWriteTargetPaths(input) {
+  const out = [];
+  if (!input || typeof input !== "object") return out;
+  const obj = input;
+  for (const key of [
+    "path",
+    "file_path",
+    "file",
+    "filePath",
+    "files",
+    "target",
+    "targetPath",
+    "out",
+    "directory",
+    "cwd",
+    "template"
+  ]) {
+    const value = obj[key];
+    if (typeof value === "string") {
+      if (value.length > 0) out.push(value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string" && item.length > 0) out.push(item);
+      }
+    }
+  }
+  return out;
+}
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -30199,6 +30405,30 @@ var DefaultPermissionPolicy = class {
   getYoloDestructive() {
     return this.yoloDestructive;
   }
+  /**
+   * True when this call is an FS_WRITE whose target lands inside WrongStack's
+   * own state root.
+   *
+   * FS_WRITE tools disagree on where the target path lives: write/edit use
+   * `path`, replace/format/git `files` (string OR array), patch `directory`,
+   * design `out`, scaffold writes under `cwd`/`template`. Checking only
+   * `path`/`file_path` let a state-root write merely switch tools, so every
+   * path-bearing key is inspected.
+   *
+   * Shared by the YOLO carve-out and the eval-cache guard so the two cannot
+   * drift: the carve-out scans all path keys while the cache key fingerprints
+   * only the subject key, so the cache must consult the same predicate or a
+   * secondary state-root key can be replayed a cached `auto`.
+   */
+  hasAgentStateWriteTarget(tool, input, ctx) {
+    if (!hasCapability(tool, ToolCapabilities.FS_WRITE)) return false;
+    for (const targetPath of fsWriteTargetPaths(input)) {
+      const base = ctx.workingDir ?? ctx.cwd;
+      const resolved = base ? path36.resolve(base, targetPath) : path36.resolve(targetPath);
+      if (isInsideAgentStateRoot(resolved)) return true;
+    }
+    return false;
+  }
   /**
    * True when YOLO is on but this specific call is a destructive shell command
    * the user has not opted to auto-approve. Shared by `evaluate()` and the
@@ -30206,6 +30436,7 @@ var DefaultPermissionPolicy = class {
    */
   yoloBlockedAsDestructive(tool, input, ctx) {
     if (!this.yolo || this.yoloDestructive) return false;
+    if (this.hasAgentStateWriteTarget(tool, input, ctx)) return true;
     const isShellSurface = tool.name === "bash" || tool.name === "exec" || (tool.capabilities ?? []).includes("shell.arbitrary");
     if (!isShellSurface) return false;
     const command = getInputString(input, "command") ?? shellCommandLineFromInput(input);
@@ -30312,7 +30543,7 @@ var DefaultPermissionPolicy = class {
     const subject = subjectForToolInput(tool.name, input, tool.subjectKey);
     const cacheKey = `${tool.name}::${subject ?? tool.name}`;
     const evalKey = `${cacheKey}::${permissionFingerprint(tool)}`;
-    if (tool.name !== "write") {
+    if (tool.name !== "write" && !this.hasAgentStateWriteTarget(tool, input, ctx)) {
       const cached = this._evalCache.get(evalKey);
       if (cached !== void 0) return cached;
     }
@@ -30420,7 +30651,7 @@ var DefaultPermissionPolicy = class {
       return decision;
     }
     if (tool.name === "write" && subject) {
-      if (ctx.hasRead(subject)) {
+      if (ctx.hasRead(subject) && !isInsideAgentStateRoot(subject)) {
         return {
           permission: "auto",
           source: "context",
@@ -30770,13 +31001,14 @@ var DefaultPermissionPolicy = class {
     }
     add("yolo", false, "auto", "yolo", "YOLO mode is not active");
     if (tool.name === "write" && subject) {
-      const hasRead = ctx.hasRead(subject);
+      const isAgentState = isInsideAgentStateRoot(subject);
+      const hasRead = ctx.hasRead(subject) && !isAgentState;
       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`
+        isAgentState ? `file "${subject}" is WrongStack's own state \u2014 bypass never applies, write always confirms` : 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;
@@ -30861,7 +31093,7 @@ var DefaultPermissionPolicy = class {
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, scryptSync } from "node:crypto";
 import * as fs13 from "node:fs";
 import * as fsp22 from "node:fs/promises";
-import * as path35 from "node:path";
+import * as path37 from "node:path";
 
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
@@ -31154,7 +31386,7 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes3(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs13.mkdirSync(path35.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path37.dirname(this.keyFile), { recursive: true });
     const passphrase = getVaultPassphrase();
     if (passphrase) {
       writeKeyFileAtomicSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase));
@@ -31241,7 +31473,7 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs13.mkdirSync(path35.dirname(this.keyFile), { recursive: true });
+    fs13.mkdirSync(path37.dirname(this.keyFile), { recursive: true });
     const key = randomBytes3(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
@@ -31301,7 +31533,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fsp22.mkdir(path35.dirname(configPath), { recursive: true });
+  await fsp22.mkdir(path37.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   await restrictFilePermissions2(configPath);
   await vault.flushHardening?.();
@@ -31356,7 +31588,7 @@ function walkCount(node, vault, counter) {
 // src/storage/attachment-store.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
 import * as fsp23 from "node:fs/promises";
-import * as path36 from "node:path";
+import * as path38 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -31377,7 +31609,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp23.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path36.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path38.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -31866,6 +32098,15 @@ var IN_PROJECT_DENIED_PATHS = [
     reason: "Extends the exec allow-list; a repo could authorise its own binaries."
   },
   { path: "tools.exec.danger", reason: "Weakens the destructive-command banner." },
+  {
+    // The whole subtree, not just the dangerous leaves: a persona's
+    // `instruction` is rendered into the voter SYSTEM prompt, a profile seat
+    // may pin providerId/model, and `defaultProfile` selects which of those
+    // runs when the agent names no profile. Denying the parent leaves no leaf
+    // to reclassify wrongly later.
+    path: "tools.council",
+    reason: "Council tool panel definitions: persona instructions are injected into the voter SYSTEM prompt and profile seats can pin an attacker-chosen providerId/model."
+  },
   { path: "skills.extraDirs", reason: "Loads skill definitions from repo-chosen directories." },
   { path: "skills.registryUrl", reason: "Redirects skill installs to a repo-chosen host." },
   // Deliberately NOT denied: skills.mode and skills.eagerMaxChars. The audit
@@ -31901,8 +32142,8 @@ var IN_PROJECT_DENIED_PATHS = [
     reason: "The other half of the filesystem confinement switch."
   }
 ];
-function deleteNestedPath(target, path40) {
-  const segments = path40.split(".");
+function deleteNestedPath(target, path42) {
+  const segments = path42.split(".");
   const last = segments[segments.length - 1];
   if (last === void 0) return false;
   let cursor = target;
@@ -31959,16 +32200,16 @@ function assertInProjectAllowListComplete() {
     );
   }
   const orphanedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path40 }) => !IN_PROJECT_ALLOWED_KEYS.has(path40.split(".")[0] ?? "")
-  ).map(({ path: path40 }) => path40);
+    ({ path: path42 }) => !IN_PROJECT_ALLOWED_KEYS.has(path42.split(".")[0] ?? "")
+  ).map(({ path: path42 }) => path42);
   if (orphanedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) whose top-level parent is not allowed: ` + orphanedPaths.join(", ") + ". The parent is already stripped wholesale, so the nested denial is dead \u2014 remove it."
     );
   }
   const malformedPaths = IN_PROJECT_DENIED_PATHS.filter(
-    ({ path: path40 }) => path40.split(".").length < 2 || path40.split(".").some((s) => s.length === 0)
-  ).map(({ path: path40 }) => path40);
+    ({ path: path42 }) => path42.split(".").length < 2 || path42.split(".").some((s) => s.length === 0)
+  ).map(({ path: path42 }) => path42);
   if (malformedPaths.length > 0) {
     problems.push(
       `IN_PROJECT_DENIED_PATHS entr(ies) are not dotted nested paths: ` + malformedPaths.join(", ") + ". Top-level keys belong in KNOWN_DENIED_IN_PROJECT instead."
@@ -31996,8 +32237,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
     }
     stripped.push(k);
   }
-  for (const { path: path40 } of IN_PROJECT_DENIED_PATHS) {
-    if (deleteNestedPath(out, path40)) stripped.push(path40);
+  for (const { path: path42 } of IN_PROJECT_DENIED_PATHS) {
+    if (deleteNestedPath(out, path42)) stripped.push(path42);
   }
   if (stripped.length > 0) {
     warn(
@@ -32186,10 +32427,10 @@ function removeLegacySageEngine(config) {
 }
 
 // src/storage/config-loader/path-identity.ts
-import * as path37 from "node:path";
+import * as path39 from "node:path";
 function samePath(a, b) {
-  let ra = path37.resolve(a);
-  let rb = path37.resolve(b);
+  let ra = path39.resolve(a);
+  let rb = path39.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -33170,7 +33411,7 @@ ${cat}:`);
 
 // src/storage/queue-store.ts
 import * as fsp25 from "node:fs/promises";
-import * as path38 from "node:path";
+import * as path40 from "node:path";
 var QUEUE_MAX_ITEMS = 100;
 var QUEUE_MAX_BYTES = 16 * 1024 * 1024;
 var QUEUE_MAX_ITEM_BYTES = 8 * 1024 * 1024;
@@ -33203,7 +33444,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path38.join(opts.dir, "queue.json");
+    this.file = path40.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -33419,7 +33660,7 @@ function isPersistedQueueItem(v) {
 // src/storage/recovery-lock.ts
 import * as fsp26 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path39 from "node:path";
+import * as path41 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -33430,7 +33671,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path39.join(opts.dir, LOCK_FILE);
+    this.file = path41.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os2.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -33504,7 +33745,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path39.dirname(this.file));
+    await ensureDir(path41.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,