@wrongstack/core 0.292.1 → 0.293.0

package/dist/defaults/index.js

@@ -1625,15 +1625,30 @@ function deepEqual(a, b) {
 }
 
 // src/utils/merge-models-payload.ts
+var REMOVE_PROVIDERS_KEY = "_removeProviders";
+var REMOVE_MODELS_KEY = "_removeModels";
 function mergeModelsPayload(base, overlay) {
+  const removeProviders = Array.isArray(overlay[REMOVE_PROVIDERS_KEY]) ? overlay[REMOVE_PROVIDERS_KEY] : [];
+  const removeModels = overlay[REMOVE_MODELS_KEY] && typeof overlay[REMOVE_MODELS_KEY] === "object" ? overlay[REMOVE_MODELS_KEY] : {};
   const out = {};
   for (const [id, provider] of Object.entries(base)) {
     out[id] = cloneProvider(provider);
   }
   for (const [id, ovProvider] of Object.entries(overlay)) {
+    if (id === REMOVE_PROVIDERS_KEY || id === REMOVE_MODELS_KEY) continue;
     const existing = out[id];
     out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
   }
+  for (const providerId of removeProviders) {
+    delete out[providerId];
+  }
+  for (const [providerId, modelIds] of Object.entries(removeModels)) {
+    const provider = out[providerId];
+    if (!provider || !provider.models) continue;
+    for (const modelId of modelIds) {
+      delete provider.models[modelId];
+    }
+  }
   return out;
 }
 function mergeProvider(base, overlay) {
@@ -15077,25 +15092,30 @@ var WHITESPACE_COLLAPSE_PATTERN = /\s+/g;
 function compactionDebugEnabled() {
   return process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1";
 }
+var _debugLogger;
+function setCompactionDebugLogger(logger) {
+  _debugLogger = logger;
+}
 function emitCompactionMetrics(event, metrics) {
   if (!compactionDebugEnabled()) return;
-  console.log(
-    JSON.stringify({
-      level: "debug",
-      event,
-      messageCount: metrics.messageCount,
-      preserveStart: metrics.preserveStart,
-      fastPathIterations: metrics.fastPathIterations,
-      fastPathInnerIterations: metrics.fastPathInnerIterations,
-      // Ratios — anything > 2.0 indicates the inner loop is running more than expected
-      fastPathInnerPerOuter: metrics.fastPathIterations > 0 ? metrics.fastPathInnerIterations / metrics.fastPathIterations : 0,
-      fullPassIterations: metrics.fullPassIterations,
-      fullPassInnerIterations: metrics.fullPassInnerIterations,
-      fullPassInnerPerOuter: metrics.fullPassIterations > 0 ? metrics.fullPassInnerIterations / metrics.fullPassIterations : 0,
-      tokensSaved: metrics.tokensSaved,
-      changed: metrics.changed
-    })
-  );
+  const ctx = {
+    event,
+    messageCount: metrics.messageCount,
+    preserveStart: metrics.preserveStart,
+    fastPathIterations: metrics.fastPathIterations,
+    fastPathInnerIterations: metrics.fastPathInnerIterations,
+    fastPathInnerPerOuter: metrics.fastPathIterations > 0 ? metrics.fastPathInnerIterations / metrics.fastPathIterations : 0,
+    fullPassIterations: metrics.fullPassIterations,
+    fullPassInnerIterations: metrics.fullPassInnerIterations,
+    fullPassInnerPerOuter: metrics.fullPassIterations > 0 ? metrics.fullPassInnerIterations / metrics.fullPassIterations : 0,
+    tokensSaved: metrics.tokensSaved,
+    changed: metrics.changed
+  };
+  if (_debugLogger) {
+    _debugLogger.debug(`compaction: ${event}`, ctx);
+  } else {
+    console.log(JSON.stringify({ level: "debug", ...ctx }));
+  }
 }
 var estimateMessages = estimateMessageTokens;
 function hasTextContent(m) {
@@ -15127,18 +15147,20 @@ function findPreserveStart(messages, preserveK) {
     preserveStart--;
   }
   if (compactionDebugEnabled()) {
-    console.log(
-      JSON.stringify({
-        level: "debug",
-        event: "compaction.find_preserve_start.ended",
-        messageCount: messages.length,
-        preserveK,
-        preserveStart,
-        pairRepairIterations,
-        pairRepairInnerIterations,
-        pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
-      })
-    );
+    const ctx = {
+      event: "compaction.find_preserve_start.ended",
+      messageCount: messages.length,
+      preserveK,
+      preserveStart,
+      pairRepairIterations,
+      pairRepairInnerIterations,
+      pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
+    };
+    if (_debugLogger) {
+      _debugLogger.debug("compaction: find_preserve_start.ended", ctx);
+    } else {
+      console.log(JSON.stringify({ level: "debug", ...ctx }));
+    }
   }
   return preserveStart;
 }
@@ -15253,16 +15275,18 @@ function eliseOldToolResults(messages, opts) {
     if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
-        console.error(
-          JSON.stringify({
-            level: "error",
-            event: "compaction.elision.regression",
-            message: `fullPassInnerPerOuter=${ratio.toFixed(2)} exceeds threshold 10 \u2014 possible O(n\xB7m) regression`,
-            messageCount: messages.length,
-            fullPassIterations,
-            fullPassInnerIterations
-          })
-        );
+        const ctx = {
+          event: "compaction.elision.regression",
+          message: `fullPassInnerPerOuter=${ratio.toFixed(2)} exceeds threshold 10 \u2014 possible O(n\xB7m) regression`,
+          messageCount: messages.length,
+          fullPassIterations,
+          fullPassInnerIterations
+        };
+        if (_debugLogger) {
+          _debugLogger.error(`compaction: elision.regression \u2014 ratio ${ratio.toFixed(2)}`, ctx);
+        } else {
+          console.error(JSON.stringify({ level: "error", ...ctx }));
+        }
       }
     }
   }
@@ -16287,6 +16311,207 @@ function resolveContextWindowPolicy(config = {}, overrideMode) {
   };
 }
 
+// src/infrastructure/logger.ts
+import * as fsp10 from "node:fs/promises";
+import * as path14 from "node:path";
+var LEVEL_RANK2 = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var COLORS = {
+  error: color.red,
+  warn: color.yellow,
+  info: color.cyan,
+  debug: color.gray,
+  trace: color.dim
+};
+var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
+var LOG_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
+var DefaultLogger = class _DefaultLogger {
+  /** How many file writes between rotation size checks (statSync is not free). */
+  static ROTATE_CHECK_EVERY = 100;
+  level;
+  file;
+  bindings;
+  format;
+  stderr;
+  maxFileBytes;
+  writesSinceRotateCheck = 0;
+  /**
+   * Serialized async tail for file writes. Every appendFile (and any
+   * chained rotation) is awaited through this promise so file I/O
+   * never overlaps itself — preserving the per-line ordering the
+   * sync version had, but without blocking the caller thread. Any
+   * rejection is swallowed (`catch(() => {})`) because logging must
+   * never crash the host.
+   *
+   * Children share the parent's tail: `child.tail === parent.tail`
+   * for the lifetime of the chain. Read/write access goes through
+   * `_tail` so that, when a child has been wired to a parent, both
+   * `enqueueRotate` and `log` always observe the parent's current tail
+   * rather than a stale snapshot taken at `child()` time.
+   */
+  tail = Promise.resolve();
+  parent = null;
+  /**
+   * Resolve the current tail. For the root logger this is the field;
+   * for a child logger we always read through the parent so that a
+   * child's appends land on the parent's most recent tail, and a
+   * parent's `flush()` waits for everything the child chained.
+   */
+  get _tail() {
+    return this.parent ? this.parent._tail : this.tail;
+  }
+  set _tail(next) {
+    if (this.parent) this.parent.tail = next;
+    else this.tail = next;
+  }
+  constructor(opts = {}) {
+    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
+    this.file = opts.file;
+    this.bindings = opts.bindings ?? {};
+    this.format = opts.format ?? parseLogFormat(process.env.WRONGSTACK_LOG_FORMAT);
+    this.stderr = opts.stderr !== false;
+    this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
+    if (this.file) {
+      const dir = path14.dirname(this.file);
+      this._tail = this._tail.then(async () => {
+        await fsp10.mkdir(dir, { recursive: true });
+      }).catch(() => void 0);
+    }
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  trace(msg, ctx) {
+    this.log("trace", msg, ctx);
+  }
+  child(bindings) {
+    const child = Object.create(_DefaultLogger.prototype);
+    child.level = this.level;
+    child.file = this.file;
+    child.bindings = { ...this.bindings, ...bindings };
+    child.format = this.format;
+    child.stderr = this.stderr;
+    child.maxFileBytes = this.maxFileBytes;
+    child.parent = this;
+    child.writesSinceRotateCheck = this.writesSinceRotateCheck;
+    return child;
+  }
+  /**
+   * Wait until all queued file writes (and any pending rotation) have
+   * completed. `log()` is fire-and-forget by design — the caller never
+   * blocks on disk — so tests, shutdown handlers, and processes that
+   * need a deterministic "everything is on disk now" guarantee should
+   * `await logger.flush()` before reading the file or exiting.
+   */
+  flush() {
+    return this._tail;
+  }
+  /**
+   * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
+   * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
+   * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
+   * Best-effort: a rename can fail on Windows while another process holds
+   * the file — the next check retries. Multiple processes appending to the
+   * same log all run this check; whoever crosses the threshold first wins.
+   *
+   * Async: the rotation runs on the file-write tail (so its writes don't
+   * interleave with the next append), and the caller never blocks on a
+   * statSync / renameSync syscall on the hot log path.
+   */
+  enqueueRotate(file) {
+    if (this.writesSinceRotateCheck++ % _DefaultLogger.ROTATE_CHECK_EVERY !== 0) return;
+    this._tail = this._tail.then(async () => {
+      let st;
+      try {
+        st = await fsp10.stat(file);
+      } catch {
+        return;
+      }
+      if (st.size < this.maxFileBytes) return;
+      try {
+        await fsp10.rm(`${file}.1`, { force: true });
+        await fsp10.rename(file, `${file}.1`);
+      } catch {
+      }
+    }).catch(() => void 0);
+  }
+  log(level, msg, ctx) {
+    const r = LEVEL_RANK2[level];
+    const allowed = LEVEL_RANK2[this.level];
+    if (r > allowed) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts, level, msg, ...this.bindings };
+    if (ctx !== void 0) {
+      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
+    }
+    if (this.file) {
+      this.enqueueRotate(this.file);
+      const line = `${JSON.stringify(entry)}
+`;
+      this._tail = this._tail.then(() => fsp10.appendFile(this.file, line)).catch(() => void 0);
+    }
+    if (!this.stderr) return;
+    if (this.format === "json") {
+      writeErr(`${JSON.stringify(entry)}
+`);
+    } else {
+      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
+      if (ctx !== void 0) {
+        writeErr(`${head} ${formatCtx(ctx)}
+`);
+      } else {
+        writeErr(`${head}
+`);
+      }
+    }
+  }
+};
+function parseLogLevel(raw) {
+  return raw && LOG_LEVELS.has(raw) ? raw : "info";
+}
+function parseLogFormat(raw) {
+  return raw && LOG_FORMATS.has(raw) ? raw : "pretty";
+}
+function formatCtx(ctx) {
+  if (ctx instanceof Error) return color.dim(ctx.message);
+  if (typeof ctx === "string") return color.dim(ctx);
+  try {
+    return color.dim(JSON.stringify(ctx));
+  } catch {
+    return color.dim(String(ctx));
+  }
+}
+var noOpLogger = {
+  // 'error' is the quietest level the Logger contract offers; the methods
+  // discard everything regardless, this only matters to level checks.
+  level: "error",
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  trace: () => {
+  },
+  child: () => noOpLogger
+};
+
 // src/types/default-config.ts
 var DEFAULT_TOOLS_CONFIG = Object.freeze({
   defaultExecutionStrategy: "smart",
@@ -16332,10 +16557,13 @@ var HybridCompactor = class {
   preserveK;
   eliseThreshold;
   smart;
+  logger;
   constructor(opts = {}) {
     this.preserveK = opts.preserveK ?? 5;
     this.eliseThreshold = opts.eliseThreshold ?? 2e3;
     this.smart = opts.smart ?? false;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -16673,7 +16901,7 @@ var AutonomousRunner = class {
 };
 
 // src/storage/goal-store.ts
-import * as fsp10 from "node:fs/promises";
+import * as fsp11 from "node:fs/promises";
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
@@ -16682,7 +16910,7 @@ async function loadGoal(filePath, events, warn) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp10.readFile(filePath, "utf8");
+    raw = await fsp11.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -16871,7 +17099,7 @@ function isDesignStack(v) {
 // src/execution/design-kit-loader.ts
 import { existsSync } from "node:fs";
 import * as fs4 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var KIT_FILE = "KIT.md";
 var TOKENS_FILE = "tokens.json";
@@ -16984,7 +17212,7 @@ var DefaultDesignKitLoader = class {
       }
       for (const e of entries) {
         if (!e.isDirectory()) continue;
-        const kitFile = path14.join(dir, e.name, KIT_FILE);
+        const kitFile = path15.join(dir, e.name, KIT_FILE);
         try {
           const raw = await fs4.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
@@ -17058,7 +17286,7 @@ var DefaultDesignKitLoader = class {
     const m = await this.find(id);
     let tokens;
     if (m) {
-      const tokensPath = path14.join(path14.dirname(m.path), TOKENS_FILE);
+      const tokensPath = path15.join(path15.dirname(m.path), TOKENS_FILE);
       try {
         const raw = await fs4.readFile(tokensPath, "utf8");
         const parsed = JSON.parse(raw);
@@ -17085,12 +17313,12 @@ var DefaultDesignKitLoader = class {
 };
 function resolveBundledDesignKitsDir() {
   try {
-    const here = path14.dirname(fileURLToPath3(import.meta.url));
+    const here = path15.dirname(fileURLToPath3(import.meta.url));
     const candidates = [
-      path14.join(here, "design-kits"),
-      path14.join(here, "..", "design-kits"),
-      path14.join(here, "..", "..", "design-kits"),
-      path14.join(here, "..", "..", "..", "design-kits")
+      path15.join(here, "design-kits"),
+      path15.join(here, "..", "design-kits"),
+      path15.join(here, "..", "..", "design-kits"),
+      path15.join(here, "..", "..", "..", "design-kits")
     ];
     for (const c of candidates) {
       if (existsSync(c)) return c;
@@ -17119,10 +17347,10 @@ function _resetDesignKitLoaderMemo() {
 // src/execution/design-project-store.ts
 import { existsSync as existsSync2 } from "node:fs";
 import * as fs5 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
-  return path15.join(projectRoot, DESIGN_DIR);
+  return path16.join(projectRoot, DESIGN_DIR);
 }
 var RULE_FILES = ["rules.md", "RULES.md", "design.md"];
 var rulesCache = /* @__PURE__ */ new Map();
@@ -17131,7 +17359,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs5.readFile(path15.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs5.readFile(path16.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -17152,7 +17380,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs5.readFile(path15.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs5.readFile(path16.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -17186,7 +17414,7 @@ function applyTokenOverrides(tokens, overrides) {
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
   await fs5.mkdir(dir, { recursive: true });
-  const gi = path15.join(dir, ".gitignore");
+  const gi = path16.join(dir, ".gitignore");
   if (!existsSync2(gi)) {
     try {
       await fs5.writeFile(gi, "*\n");
@@ -17200,11 +17428,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 fs5.writeFile(path15.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs5.writeFile(path16.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs5.appendFile(path15.join(dir, "decisions.md"), line);
+    await fs5.appendFile(path16.join(dir, "decisions.md"), line);
   } catch {
   }
 }
@@ -17220,11 +17448,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 fs5.writeFile(path15.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs5.writeFile(path16.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const keys = Object.keys(patch).join(",");
     await fs5.appendFile(
-      path15.join(dir, "decisions.md"),
+      path16.join(dir, "decisions.md"),
       `- ${isoTime} \xB7 kit=${active.kit} \xB7 override=${keys} \xB7 via=set
 `
     );
@@ -17234,7 +17462,7 @@ async function recordOverrides(projectRoot, patch, isoTime) {
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs5.rm(path15.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs5.rm(path16.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -19018,6 +19246,7 @@ var IntelligentCompactor = class {
   summarizerPrompt;
   summarizerModel;
   oneShotOrchestrator;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.warnThreshold = opts.warnThreshold ?? 0.5;
@@ -19029,6 +19258,8 @@ var IntelligentCompactor = class {
     this.summarizerPrompt = opts.summarizerPrompt ?? readBundledInstructionText("llm/intelligent-compactor-summarizer.md");
     this.summarizerModel = opts.summarizerModel;
     this.oneShotOrchestrator = opts.oneShotOrchestrator;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -20422,11 +20653,13 @@ var LLMSelector = class {
   systemPrompt;
   maxOutputTokens;
   oneShotOrchestrator;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
+    this.logger = opts.logger ?? noOpLogger;
     if (this.model === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
-      console.warn(
+      this.logger.warn(
         "[LLMSelector] model not set \u2014 selector will use the provider default. Set `model` explicitly in LLMSelectorOptions to silence this warning."
       );
     }
@@ -20476,14 +20709,9 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       }
     } catch (err) {
       if (err instanceof Error) {
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "llm_selector.call_failed",
-            message: `selector call failed, using recency fallback: ${err.message}`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          })
-        );
+        this.logger.warn(`selector call failed, using recency fallback: ${err.message}`, {
+          event: "llm_selector.call_failed"
+        });
       }
       return this.fallbackSelect(messages, effectiveBudget);
     } finally {
@@ -20590,6 +20818,7 @@ var SelectiveCompactor = class {
   eliseThreshold;
   summarizerModel;
   summarizerPrompt;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
@@ -20600,8 +20829,10 @@ var SelectiveCompactor = class {
     this.preserveK = opts.preserveK ?? 4;
     this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
     if (this.summarizerModel === void 0 && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
-      console.warn(
+      this.logger.warn(
         "[SelectiveCompactor] summarizerModel not set \u2014 will fall back to ctx.model at summarize time. Set `summarizerModel` explicitly to silence this warning."
       );
     }
@@ -20830,7 +21061,7 @@ Summarize the following message range:`;
 
 // src/execution/skill-loader.ts
 import * as fs6 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
@@ -20980,7 +21211,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs6.stat(path16.join(dir, entry.name))).isDirectory();
+      return (await fs6.stat(path17.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -21001,7 +21232,7 @@ var DefaultSkillLoader = class {
       for (const tool of FOREIGN_SKILL_TOOLS) {
         if (!foreignIds.includes(tool.id)) continue;
         dirs.push({
-          dir: path16.join(root, "." + tool.id, tool.subdir),
+          dir: path17.join(root, "." + tool.id, tool.subdir),
           source: "foreign",
           originTool: tool.id
         });
@@ -21028,7 +21259,7 @@ var DefaultSkillLoader = class {
         );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
-          const skillFile = path16.join(dir, e.name, "SKILL.md");
+          const skillFile = path17.join(dir, e.name, "SKILL.md");
           try {
             const raw = await fs6.readFile(skillFile, "utf8");
             const fm = parseSkillFrontmatter(raw);
@@ -21112,7 +21343,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 savePath = path16.join(path16.dirname(m.path), "SKILL.save.md");
+    const savePath = path17.join(path17.dirname(m.path), "SKILL.save.md");
     let result;
     try {
       result = await fs6.readFile(savePath, "utf8");
@@ -21146,11 +21377,11 @@ function parseDescriptionFromText(desc) {
 
 // src/execution/prompt-loader.ts
 import * as fs8 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 
 // src/storage/prompt-store.ts
 import * as fs7 from "node:fs/promises";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 var SCHEMA_VERSION = 2;
 function migratePromptEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -21216,7 +21447,7 @@ var DefaultPromptStore = class {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs7.readFile(path17.join(this.dir, file), "utf8")
+            await fs7.readFile(path18.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -21230,7 +21461,7 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path17.join(this.dir, `${id}.json`);
+    const file = path18.join(this.dir, `${id}.json`);
     try {
       const raw = JSON.parse(await fs7.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
@@ -21240,12 +21471,12 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path17.join(this.dir, `${entry.id}.json`);
+    const file = path18.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 = path17.join(this.dir, `${id}.json`);
+    const file = path18.join(this.dir, `${id}.json`);
     try {
       await fs7.unlink(file);
       return true;
@@ -21334,7 +21565,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 ? path18.join(opts.bundledDir, "prompts") : void 0;
+    this.builtinDir = opts.bundledDir ? path19.join(opts.bundledDir, "prompts") : void 0;
   }
   async list() {
     if (this.cache) return this.cache;
@@ -21466,7 +21697,7 @@ async function walkJson(dir) {
     return out;
   }
   for (const e of entries) {
-    const full = path18.join(dir, e.name);
+    const full = path19.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") {
@@ -21665,11 +21896,11 @@ function runWithProcessTelemetry(context, run) {
 // src/execution/tool-executor.ts
 import { isDeepStrictEqual } from "node:util";
 import * as fs9 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 
 // src/security/kanban-boundary.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 import {
   evaluateKanbanBoundaryOpaque,
   evaluateKanbanBoundaryPath,
@@ -21744,10 +21975,10 @@ function resolveKanbanIdentity(ctx) {
 async function extractCandidatePaths(toolName, input, ctx) {
   if (toolName === "patch" && typeof input["patch"] === "string") {
     const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
-    const directory = path19.isAbsolute(directoryInput) ? directoryInput : path19.resolve(ctx.workingDir, directoryInput);
+    const directory = path20.isAbsolute(directoryInput) ? directoryInput : path20.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)
+      (target) => relativeToProject(path20.resolve(directory, target), ctx.projectRoot)
     );
     return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
   }
@@ -21757,7 +21988,7 @@ async function extractCandidatePaths(toolName, input, ctx) {
   collectPathValues(input, values, pathKeys);
   if (toolName === "scaffold" && typeof input["name"] === "string") {
     const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
-    values.push(path19.join(cwd, input["name"]));
+    values.push(path20.join(cwd, input["name"]));
   }
   const candidates = [
     ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
@@ -21765,21 +21996,21 @@ async function extractCandidatePaths(toolName, input, 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);
+  if (path20.isAbsolute(candidate)) return candidate;
+  const absolute = path20.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);
+      const canonical = path20.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);
+      const parent = path20.dirname(probe);
       if (parent === probe) return absolute;
-      missingSegments.unshift(path19.basename(probe));
+      missingSegments.unshift(path20.basename(probe));
       probe = parent;
     }
   }
@@ -21802,12 +22033,12 @@ 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);
+  const absolute = path20.isAbsolute(value) ? value : path20.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 || ".";
+  const relative6 = path20.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative6.startsWith("../") || path20.isAbsolute(relative6) ? absolute : relative6 || ".";
 }
 function extractPatchTargets(patchText, strip) {
   const targets = [];
@@ -22151,7 +22382,7 @@ ${errorDetails}`,
         const inputPath = use.input && typeof use.input === "object" ? use.input.path : void 0;
         const caps = tool.capabilities ?? [];
         const hasFileCapability = caps.includes("fs.read") || caps.includes("fs.write");
-        const absPath = hasFileCapability && typeof inputPath === "string" ? path20.isAbsolute(inputPath) ? inputPath : path20.resolve(ctx.projectRoot, inputPath) : void 0;
+        const absPath = hasFileCapability && typeof inputPath === "string" ? path21.isAbsolute(inputPath) ? inputPath : path21.resolve(ctx.projectRoot, inputPath) : void 0;
         let writeTargetExisted;
         if (tool.name === "write" && caps.includes("fs.write") && absPath) {
           writeTargetExisted = await fs9.stat(absPath).then(
@@ -22743,11 +22974,11 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path20.join(wstackGlobalRoot(), "tool-output");
+    const dir = path21.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 = path20.join(dir, `${stamp}-${safeTool}-${randomUUID11()}.log`);
+    const filePath = path21.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");
@@ -23066,191 +23297,6 @@ function createContextManagerTool(opts = {}) {
 }
 var contextManagerTool = createContextManagerTool();
 
-// src/infrastructure/logger.ts
-import * as fsp11 from "node:fs/promises";
-import * as path21 from "node:path";
-var LEVEL_RANK2 = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
-};
-var COLORS = {
-  error: color.red,
-  warn: color.yellow,
-  info: color.cyan,
-  debug: color.gray,
-  trace: color.dim
-};
-var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
-var LOG_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
-var DefaultLogger = class _DefaultLogger {
-  /** How many file writes between rotation size checks (statSync is not free). */
-  static ROTATE_CHECK_EVERY = 100;
-  level;
-  file;
-  bindings;
-  format;
-  stderr;
-  maxFileBytes;
-  writesSinceRotateCheck = 0;
-  /**
-   * Serialized async tail for file writes. Every appendFile (and any
-   * chained rotation) is awaited through this promise so file I/O
-   * never overlaps itself — preserving the per-line ordering the
-   * sync version had, but without blocking the caller thread. Any
-   * rejection is swallowed (`catch(() => {})`) because logging must
-   * never crash the host.
-   *
-   * Children share the parent's tail: `child.tail === parent.tail`
-   * for the lifetime of the chain. Read/write access goes through
-   * `_tail` so that, when a child has been wired to a parent, both
-   * `enqueueRotate` and `log` always observe the parent's current tail
-   * rather than a stale snapshot taken at `child()` time.
-   */
-  tail = Promise.resolve();
-  parent = null;
-  /**
-   * Resolve the current tail. For the root logger this is the field;
-   * for a child logger we always read through the parent so that a
-   * child's appends land on the parent's most recent tail, and a
-   * parent's `flush()` waits for everything the child chained.
-   */
-  get _tail() {
-    return this.parent ? this.parent._tail : this.tail;
-  }
-  set _tail(next) {
-    if (this.parent) this.parent.tail = next;
-    else this.tail = next;
-  }
-  constructor(opts = {}) {
-    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
-    this.file = opts.file;
-    this.bindings = opts.bindings ?? {};
-    this.format = opts.format ?? parseLogFormat(process.env.WRONGSTACK_LOG_FORMAT);
-    this.stderr = opts.stderr !== false;
-    this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
-    if (this.file) {
-      const dir = path21.dirname(this.file);
-      this._tail = this._tail.then(async () => {
-        await fsp11.mkdir(dir, { recursive: true });
-      }).catch(() => void 0);
-    }
-  }
-  error(msg, ctx) {
-    this.log("error", msg, ctx);
-  }
-  warn(msg, ctx) {
-    this.log("warn", msg, ctx);
-  }
-  info(msg, ctx) {
-    this.log("info", msg, ctx);
-  }
-  debug(msg, ctx) {
-    this.log("debug", msg, ctx);
-  }
-  trace(msg, ctx) {
-    this.log("trace", msg, ctx);
-  }
-  child(bindings) {
-    const child = Object.create(_DefaultLogger.prototype);
-    child.level = this.level;
-    child.file = this.file;
-    child.bindings = { ...this.bindings, ...bindings };
-    child.format = this.format;
-    child.stderr = this.stderr;
-    child.maxFileBytes = this.maxFileBytes;
-    child.parent = this;
-    child.writesSinceRotateCheck = this.writesSinceRotateCheck;
-    return child;
-  }
-  /**
-   * Wait until all queued file writes (and any pending rotation) have
-   * completed. `log()` is fire-and-forget by design — the caller never
-   * blocks on disk — so tests, shutdown handlers, and processes that
-   * need a deterministic "everything is on disk now" guarantee should
-   * `await logger.flush()` before reading the file or exiting.
-   */
-  flush() {
-    return this._tail;
-  }
-  /**
-   * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
-   * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
-   * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
-   * Best-effort: a rename can fail on Windows while another process holds
-   * the file — the next check retries. Multiple processes appending to the
-   * same log all run this check; whoever crosses the threshold first wins.
-   *
-   * Async: the rotation runs on the file-write tail (so its writes don't
-   * interleave with the next append), and the caller never blocks on a
-   * statSync / renameSync syscall on the hot log path.
-   */
-  enqueueRotate(file) {
-    if (this.writesSinceRotateCheck++ % _DefaultLogger.ROTATE_CHECK_EVERY !== 0) return;
-    this._tail = this._tail.then(async () => {
-      let st;
-      try {
-        st = await fsp11.stat(file);
-      } catch {
-        return;
-      }
-      if (st.size < this.maxFileBytes) return;
-      try {
-        await fsp11.rm(`${file}.1`, { force: true });
-        await fsp11.rename(file, `${file}.1`);
-      } catch {
-      }
-    }).catch(() => void 0);
-  }
-  log(level, msg, ctx) {
-    const r = LEVEL_RANK2[level];
-    const allowed = LEVEL_RANK2[this.level];
-    if (r > allowed) return;
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const entry = { ts, level, msg, ...this.bindings };
-    if (ctx !== void 0) {
-      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
-    }
-    if (this.file) {
-      this.enqueueRotate(this.file);
-      const line = `${JSON.stringify(entry)}
-`;
-      this._tail = this._tail.then(() => fsp11.appendFile(this.file, line)).catch(() => void 0);
-    }
-    if (!this.stderr) return;
-    if (this.format === "json") {
-      writeErr(`${JSON.stringify(entry)}
-`);
-    } else {
-      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
-      if (ctx !== void 0) {
-        writeErr(`${head} ${formatCtx(ctx)}
-`);
-      } else {
-        writeErr(`${head}
-`);
-      }
-    }
-  }
-};
-function parseLogLevel(raw) {
-  return raw && LOG_LEVELS.has(raw) ? raw : "info";
-}
-function parseLogFormat(raw) {
-  return raw && LOG_FORMATS.has(raw) ? raw : "pretty";
-}
-function formatCtx(ctx) {
-  if (ctx instanceof Error) return color.dim(ctx.message);
-  if (typeof ctx === "string") return color.dim(ctx);
-  try {
-    return color.dim(JSON.stringify(ctx));
-  } catch {
-    return color.dim(String(ctx));
-  }
-}
-
 // src/infrastructure/mcp-servers.ts
 var filesystemServer = () => ({
   name: "filesystem",
@@ -23829,6 +23875,7 @@ var DefaultModelsRegistry = class {
   overlayUrl;
   overlayFile;
   overlayCacheFile;
+  logger;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
     this.url = opts.url ?? process.env[ENV_URL_KEY] ?? DEFAULT_URL;
@@ -23842,6 +23889,7 @@ var DefaultModelsRegistry = class {
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
     this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path24.join(path24.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.logger = opts.logger ?? noOpLogger;
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -23890,16 +23938,18 @@ var DefaultModelsRegistry = class {
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
         this.fetchedAt = new Date(cached.fetchedAt);
         const ageSeconds = Math.floor((Date.now() - this.fetchedAt.getTime()) / 1e3);
-        console.warn(
-          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`
+        this.logger.warn(
+          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`,
+          { event: "models_registry.stale_cache_fallback" }
         );
         return cached.payload;
       }
       if (overlayAvailable) {
-        console.warn(
+        this.logger.warn(
           `ModelsRegistry: models.dev unavailable (${toErrorMessage(
             err
-          )}); serving curated overlay only.`
+          )}); serving curated overlay only.`,
+          { event: "models_registry.overlay_only_fallback" }
         );
         return {};
       }
@@ -23995,8 +24045,9 @@ var DefaultModelsRegistry = class {
       const cached = await this.readCacheAt(this.overlayCacheFile);
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
         const ageSeconds = Math.floor((Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3);
-        console.warn(
-          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`
+        this.logger.warn(
+          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`,
+          { event: "models_registry.overlay_stale_fallback", ageSeconds }
         );
         return cached.payload;
       }
@@ -25149,9 +25200,6 @@ var DefaultPermissionPolicy = class {
   loaded = false;
   trustFile;
   yolo;
-  yoloDestructive;
-  /** Deprecated compatibility flag; no longer gates YOLO calls. */
-  confirmDestructive;
   /**
    * Session-scoped "soft deny" map. When the user presses 'n' (block once),
    * the tool+pattern is added here. If the LLM retries in the same session,
@@ -25204,8 +25252,6 @@ var DefaultPermissionPolicy = class {
   constructor(opts) {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
-    this.yoloDestructive = opts.yoloDestructive ?? opts.forceAllYolo ?? false;
-    this.confirmDestructive = opts.confirmDestructive ?? false;
     this.promptDelegate = opts.promptDelegate;
   }
   /**
@@ -25226,24 +25272,6 @@ var DefaultPermissionPolicy = class {
   getYolo() {
     return this.yolo;
   }
-  /** Toggle the destructive YOLO override at runtime. */
-  setYoloDestructive(enabled) {
-    if (this.yoloDestructive !== enabled) this._evalCache.clear();
-    this.yoloDestructive = enabled;
-  }
-  /** Check whether the destructive YOLO override is active. */
-  getYoloDestructive() {
-    return this.yoloDestructive;
-  }
-  /** Toggle deprecated destructive confirmation compatibility flag. */
-  setConfirmDestructive(enabled) {
-    if (this.confirmDestructive !== enabled) this._evalCache.clear();
-    this.confirmDestructive = enabled;
-  }
-  /** Check deprecated destructive confirmation compatibility flag. */
-  getConfirmDestructive() {
-    return this.confirmDestructive;
-  }
   /** Read-only diagnostics for policy inspector/editor surfaces. */
   getPolicyDiagnostics() {
     return this.policyDiagnostics.map((diagnostic) => ({ ...diagnostic }));
@@ -26544,9 +26572,10 @@ var BEHAVIOR_DEFAULTS = {
     prompts: true,
     // 'auto' → resolveTokenSavingTier picks a concrete tier from the model's
     // context window ONCE per session (cache-safe): lean prompt on small
-    // windows (<32k medium, <96k light) where the fixed identity+tool prose is
-    // a big fraction; full prompt (off) on 96k+ so nothing changes for the
-    // common large-window case. Explicit tiers are respected verbatim.
+    // windows (<32k medium, <128k light) where the fixed identity+tool prose
+    // is a big fraction; minimal trimming on >=128k so modern large-window
+    // models still get cost savings without capability loss. Explicit tiers
+    // are respected verbatim.
     tokenSavingMode: "auto",
     allowOutsideProjectRoot: true
   },
@@ -26614,7 +26643,7 @@ var BEHAVIOR_DEFAULTS = {
     // Mirrored from the top-level yolo default so the autonomy subsystem
     // (which reads autonomy.yolo) stays consistent with config.yolo.
     yolo: false,
-    streamFleet: true,
+    fleetChatVerbosity: "off",
     chime: false,
     confirmExit: true,
     mouseMode: false,
@@ -26632,7 +26661,7 @@ var BEHAVIOR_DEFAULTS = {
     // silently omitted, and surfaced as a per-request warning. Users who
     // want a specific effort can opt in via `/settings` or the WebUI panel.
     reasoning: { mode: "auto" },
-    cache: {}
+    cache: { ttl: "1h" }
   }
 };
 function isPlainRecord(value) {