@wrongstack/core 0.291.1 → 0.292.0

package/dist/storage/index.js

@@ -217,65 +217,6 @@ async function backupConfigFile(filePath, paths) {
   }
 }
 
-// src/utils/deep-merge.ts
-var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__"
-]);
-function isPrimitiveArray(a) {
-  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
-}
-function deepMerge(base, patch, options = {}) {
-  const {
-    conflictResolution = "prefer-patch",
-    arrayMode = "replace",
-    protectProto = true,
-    onNonPrimitiveArrayReplace
-  } = options;
-  if (typeof base !== "object" || base === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (typeof patch !== "object" || patch === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) && Array.isArray(patch)) {
-    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
-      return [.../* @__PURE__ */ new Set([...base, ...patch])];
-    }
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) || Array.isArray(patch)) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  const baseObj = base;
-  const patchObj = patch;
-  const out = { ...baseObj };
-  for (const [k, v] of Object.entries(patchObj)) {
-    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
-    const existing = out[k];
-    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
-      out[k] = deepMerge(existing, v, options);
-    } else if (Array.isArray(v) && Array.isArray(existing)) {
-      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
-        onNonPrimitiveArrayReplace(k, existing.length, v.length);
-      }
-      out[k] = deepMerge(existing, v, options);
-    } else if (v !== void 0) {
-      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
-        const existingLen = Array.isArray(existing) ? existing.length : 0;
-        onNonPrimitiveArrayReplace(k, existingLen, v.length);
-      }
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
 // src/utils/error.ts
 function toErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -397,6 +338,68 @@ function isEmptyMessage(msg) {
   return !hasMeaningfulContent(msg.content);
 }
 
+// src/types/config.ts
+var DEFAULT_TUI_THINKING_WORD = "thinking";
+
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
+}
+function deepMerge(base, patch, options = {}) {
+  const {
+    conflictResolution = "prefer-patch",
+    arrayMode = "replace",
+    protectProto = true,
+    onNonPrimitiveArrayReplace
+  } = options;
+  if (typeof base !== "object" || base === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
+      return [.../* @__PURE__ */ new Set([...base, ...patch])];
+    }
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) || Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  const baseObj = base;
+  const patchObj = patch;
+  const out = { ...baseObj };
+  for (const [k, v] of Object.entries(patchObj)) {
+    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v, options);
+    } else if (Array.isArray(v) && Array.isArray(existing)) {
+      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
+        onNonPrimitiveArrayReplace(k, existing.length, v.length);
+      }
+      out[k] = deepMerge(existing, v, options);
+    } else if (v !== void 0) {
+      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
+        const existingLen = Array.isArray(existing) ? existing.length : 0;
+        onNonPrimitiveArrayReplace(k, existingLen, v.length);
+      }
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
 var DANGEROUS_PATTERNS = [
@@ -1762,8 +1765,8 @@ function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative7 = path6.relative(root, target);
-  return relative7 === "" || !relative7.startsWith("..") && !path6.isAbsolute(relative7);
+  const relative8 = path6.relative(root, target);
+  return relative8 === "" || !relative8.startsWith("..") && !path6.isAbsolute(relative8);
 }
 function normalizeRelative(input) {
   if (!input || path6.isAbsolute(input)) return null;
@@ -1775,8 +1778,8 @@ function normalizeRelative(input) {
 function parseNulPaths(output) {
   return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
 }
-function isWrongStackWorktreePath(relative7) {
-  return relative7 === ".wrongstack/worktrees" || relative7.startsWith(".wrongstack/worktrees/");
+function isWrongStackWorktreePath(relative8) {
+  return relative8 === ".wrongstack/worktrees" || relative8.startsWith(".wrongstack/worktrees/");
 }
 var SessionCheckpointCas = class {
   rootDir;
@@ -1802,16 +1805,16 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative7) => !isWrongStackWorktreePath(relative7)).sort();
+    ].filter((relative8) => !isWrongStackWorktreePath(relative8)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative7) => {
-        const absolute = path6.resolve(this.projectRoot, ...relative7.split("/"));
+      async (relative8) => {
+        const absolute = path6.resolve(this.projectRoot, ...relative8.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative7, reason: "path escapes project root" });
+          unresolved.push({ path: relative8, reason: "path escapes project root" });
           return null;
         }
         try {
@@ -1821,27 +1824,27 @@ var SessionCheckpointCas = class {
             const resolvedLink = path6.resolve(path6.dirname(absolute), linkTarget);
             if (path6.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
-                path: relative7,
+                path: relative8,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative7, state: "symlink", linkTarget };
+            return { path: relative8, state: "symlink", linkTarget };
           }
           if (!stat13.isFile()) {
-            unresolved.push({ path: relative7, reason: "changed path is not a regular file" });
+            unresolved.push({ path: relative8, reason: "changed path is not a regular file" });
             return null;
           }
           if (stat13.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative7,
+              path: relative8,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
           if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative7,
+              path: relative8,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
@@ -1850,12 +1853,12 @@ var SessionCheckpointCas = class {
           const content = await fsp2.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative7, state: "file", blobHash, mode: stat13.mode & 511 };
+          return { path: relative8, state: "file", blobHash, mode: stat13.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative7, state: "absent" };
+            return { path: relative8, state: "absent" };
           }
-          unresolved.push({ path: relative7, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative8, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -2045,8 +2048,8 @@ var SessionCheckpointCas = class {
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative7) {
-    const normalized = normalizeRelative(relative7);
+  async safeOutputPath(target, realTarget, relative8) {
+    const normalized = normalizeRelative(relative8);
     if (!normalized) throw new Error("invalid relative path");
     const output = path6.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
@@ -2132,8 +2135,8 @@ var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative7 = path7.relative(root, target);
-  return relative7 === "" || !relative7.startsWith("..") && !path7.isAbsolute(relative7);
+  const relative8 = path7.relative(root, target);
+  return relative8 === "" || !relative8.startsWith("..") && !path7.isAbsolute(relative8);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -2220,8 +2223,8 @@ function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path7.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative7 = path7.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative7 || "." : entry.path;
+    const relative8 = path7.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative8 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
   const omitted = validation.staleFiles.length - shown.length;
@@ -4685,6 +4688,9 @@ function simpleHash(s) {
   return Math.abs(h).toString(36);
 }
 
+// src/storage/memory-consolidator.ts
+import * as path13 from "node:path";
+
 // src/utils/instruction-file.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as path12 from "node:path";
@@ -4747,6 +4753,12 @@ function toSuperMemoryKind(type) {
     case "convention":
     case "preference":
     case "anti_pattern":
+    case "warning":
+    case "workflow":
+    case "bug_root_cause":
+    case "file_note":
+    case "symbol_note":
+    case "command_note":
       return type;
     case "reference":
       return "file_note";
@@ -4768,7 +4780,7 @@ function importanceFromPriority(priority) {
       return 0.6;
   }
 }
-function buildConsolidationPrompt(finalText, iterations, existingEntries) {
+function buildConsolidationPrompt(finalText, iterations, existingEntries, evidence) {
   const existingBlock = existingEntries.length > 0 ? `
 
 Existing memory entries:
@@ -4776,9 +4788,82 @@ ${existingEntries.map((e) => `- [${e.ts.slice(0, 10)}] ${e.text}`).join("\n")}`
   return renderInstructionTemplate(readBundledInstructionText("llm/memory-consolidator.md"), {
     iterations: String(iterations),
     summary: finalText.slice(0, 3e3),
+    evidence,
     existingEntries: existingBlock
   });
 }
+function relativeEvidencePath(projectRoot, filePath) {
+  const relative8 = path13.relative(projectRoot, filePath);
+  return relative8 && !relative8.startsWith("..") && !path13.isAbsolute(relative8) ? relative8.replaceAll("\\", "/") : filePath.replaceAll("\\", "/");
+}
+function safeCommandEvidence(value) {
+  if (typeof value !== "string") return void 0;
+  const command = value.trim().replace(/\s+/g, " ").slice(0, 300);
+  if (!command) return void 0;
+  if (/(?:password|passwd|secret|token|api[_-]?key|authorization|bearer)\s*[:=]/i.test(command)) {
+    return "[redacted sensitive command]";
+  }
+  return command;
+}
+function buildSessionEvidence(ctx) {
+  const projectRoot = ctx.projectRoot ?? ctx.cwd ?? "";
+  const read = [...ctx.readFiles ?? []].slice(-20).map((file) => relativeEvidencePath(projectRoot, file));
+  const written = [...ctx.writtenFiles ?? []].slice(-20).map((file) => relativeEvidencePath(projectRoot, file));
+  const commands = (ctx.sideEffects ?? []).slice(-10).map((effect) => ({
+    tool: effect.toolName,
+    risk: effect.risk,
+    command: safeCommandEvidence(effect.input["command"]),
+    outcome: effect.outcome?.slice(0, 160)
+  }));
+  const completedTodos = (ctx.todos ?? []).filter((todo) => todo.status === "completed").slice(-10).map((todo) => todo.content.slice(0, 240));
+  return JSON.stringify(
+    {
+      projectRoot: projectRoot.replaceAll("\\", "/"),
+      readFiles: read,
+      writtenFiles: written,
+      commands,
+      completedTodos,
+      kanban: ctx.currentKanbanTaskId ? { boardId: ctx.currentKanbanBoardId, taskId: ctx.currentKanbanTaskId } : void 0
+    },
+    null,
+    2
+  ).slice(0, 6e3);
+}
+function normalizeConsolidatorAnchors(value) {
+  if (!Array.isArray(value)) return void 0;
+  const allowed = /* @__PURE__ */ new Set([
+    "file",
+    "directory",
+    "symbol",
+    "package",
+    "command",
+    "test",
+    "git"
+  ]);
+  const anchors = [];
+  for (const raw of value.slice(0, 5)) {
+    if (!raw || typeof raw !== "object") continue;
+    const candidate = raw;
+    if (!allowed.has(candidate["type"])) continue;
+    const anchor = {
+      type: candidate["type"]
+    };
+    if (typeof candidate["path"] === "string" && candidate["path"].trim()) {
+      anchor.path = candidate["path"].trim().slice(0, 500);
+    }
+    if (typeof candidate["symbol"] === "string" && candidate["symbol"].trim()) {
+      anchor.symbol = candidate["symbol"].trim().slice(0, 300);
+    }
+    if (typeof candidate["command"] === "string" && candidate["command"].trim()) {
+      anchor.command = safeCommandEvidence(candidate["command"]);
+    }
+    anchors.push(anchor);
+  }
+  return anchors.length > 0 ? anchors : void 0;
+}
+function normalizeConfidence(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0.5, Math.min(1, value)) : 0.78;
+}
 var SessionMemoryConsolidator = class {
   name = "session-memory-consolidator";
   owner = "core";
@@ -4794,11 +4879,11 @@ var SessionMemoryConsolidator = class {
     this.superMemory = opts.superMemory;
     this.provider = opts.provider;
     this.model = opts.model;
-    this.minIterations = opts.minIterations ?? 2;
+    this.minIterations = opts.minIterations ?? 1;
     this.maxExistingEntries = opts.maxExistingEntries ?? 15;
     this.oneShotOrchestrator = opts.oneShotOrchestrator;
   }
-  afterRun = (ctx, result) => {
+  afterRun = async (ctx, result) => {
     if (result.status !== "done") return;
     if (!result.finalText || result.finalText.trim().length < 20) return;
     if (result.iterations < this.minIterations) return;
@@ -4808,87 +4893,85 @@ var SessionMemoryConsolidator = class {
     const _iterations = result.iterations;
     const _model = this.model ?? ctx.model;
     const _sessionId = ctx.session.id;
-    void (async () => {
-      try {
-        let existingEntries;
-        if (this.superMemory) {
-          const records = this.superMemory.listSuper ? await this.superMemory.listSuper(["active"]) : await this.superMemory.searchSuper?.("", {
-            limit: this.maxExistingEntries,
-            scope: "project",
-            includeStatuses: ["active"]
-          }) ?? [];
-          existingEntries = toPromptEntries(records, this.maxExistingEntries);
-        } else {
-          existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
-        }
-        const prompt = buildConsolidationPrompt(
-          _finalText,
-          _iterations,
-          existingEntries
+    const _evidence = buildSessionEvidence(ctx);
+    try {
+      let existingEntries;
+      if (this.superMemory) {
+        const records = this.superMemory.listSuper ? await this.superMemory.listSuper(["active"]) : await this.superMemory.searchSuper?.("", {
+          limit: this.maxExistingEntries,
+          scope: "project",
+          includeStatuses: ["active"]
+        }) ?? [];
+        existingEntries = toPromptEntries(records, this.maxExistingEntries);
+      } else {
+        existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+      }
+      const prompt = buildConsolidationPrompt(_finalText, _iterations, existingEntries, _evidence);
+      let text;
+      if (this.oneShotOrchestrator) {
+        const oneShotResult = await this.oneShotOrchestrator.call({
+          system: prompt,
+          userPrompt: "Review the session and return memory operations as JSON.",
+          model: _model ?? "deepseek-chat",
+          maxTokens: 500,
+          timeoutMs: 15e3
+        });
+        text = oneShotResult.text;
+      } else {
+        const signal = AbortSignal.timeout(15e3);
+        const response = await provider.complete(
+          {
+            model: _model,
+            system: [{ type: "text", text: prompt }],
+            messages: [
+              { role: "user", content: "Review the session and return memory operations as JSON." }
+            ],
+            maxTokens: 500
+          },
+          { signal }
         );
-        let text;
-        if (this.oneShotOrchestrator) {
-          const oneShotResult = await this.oneShotOrchestrator.call({
-            system: prompt,
-            userPrompt: "Review the session and return memory operations as JSON.",
-            model: _model ?? "deepseek-chat",
-            maxTokens: 500,
-            timeoutMs: 15e3
-          });
-          text = oneShotResult.text;
-        } else {
-          const signal = AbortSignal.timeout(15e3);
-          const response = await provider.complete(
-            {
-              model: _model,
-              system: [{ type: "text", text: prompt }],
-              messages: [
-                { role: "user", content: "Review the session and return memory operations as JSON." }
-              ],
-              maxTokens: 500
-            },
-            { signal }
-          );
-          text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-        }
-        if (!text) return;
-        const jsonMatch = text.match(/\{[\s\S]*\}/);
-        if (!jsonMatch) return;
-        const parsed = JSON.parse(jsonMatch[0]);
-        if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
-        let added = 0;
-        for (const op of parsed.operations) {
-          try {
-            if (!op || typeof op !== "object" || op.action !== "add") continue;
-            if (typeof op.text !== "string" || !op.text.trim()) continue;
-            const memoryText = op.text.trim();
-            if (this.superMemory) {
-              await this.superMemory.rememberSuper({
-                text: memoryText,
-                scope: "project",
-                kind: toSuperMemoryKind(op.type),
-                tags: op.tags,
-                importance: importanceFromPriority(op.priority),
-                sources: [{ type: "session", sessionId: _sessionId }]
-              });
-            } else {
-              await this.memoryStore.remember(memoryText, void 0, {
-                type: op.type,
-                tags: op.tags,
-                priority: op.priority
-              });
-            }
-            added++;
-          } catch {
+        text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+      }
+      if (!text) return;
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
+      let added = 0;
+      for (const op of parsed.operations.slice(0, 5)) {
+        try {
+          if (!op || typeof op !== "object" || op.action !== "add") continue;
+          if (typeof op.text !== "string" || !op.text.trim()) continue;
+          const memoryText = op.text.trim();
+          if (this.superMemory) {
+            await this.superMemory.rememberSuper({
+              text: memoryText,
+              scope: "project",
+              kind: toSuperMemoryKind(op.type),
+              tags: op.tags,
+              importance: importanceFromPriority(op.priority),
+              confidence: normalizeConfidence(op.confidence),
+              persistence: "long_lived",
+              anchors: normalizeConsolidatorAnchors(op.anchors),
+              sources: [{ type: "session", sessionId: _sessionId }]
+            });
+          } else {
+            await this.memoryStore.remember(memoryText, void 0, {
+              type: op.type,
+              tags: op.tags,
+              priority: op.priority
+            });
           }
+          added++;
+        } catch {
         }
-        if (added > 0) {
-          process.stderr.write(`[memory] Session consolidation: ${added} added
+      }
+      if (added > 0) {
+        process.stderr.write(`[memory] Session consolidation: ${added} added
 `);
-        }
-      } catch {
       }
-    })();
+    } catch {
+    }
   };
 };
 
@@ -4966,7 +5049,7 @@ function deepFreeze(obj) {
 // src/storage/provider-config-watcher.ts
 import * as syncFs from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 
 // src/security/config-secrets.ts
 function decryptConfigSecrets(cfg, vault, opts) {
@@ -5064,7 +5147,7 @@ function serializeSnapshot(s) {
 function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   const debounceMs = opts.debounceMs ?? 200;
   const warn = opts.warn;
-  const base = path13.basename(configPath);
+  const base = path14.basename(configPath);
   let timer;
   let closed = false;
   let lastSerialized;
@@ -5075,7 +5158,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
   });
   let watcher;
   try {
-    watcher = syncFs.watch(path13.dirname(configPath), { recursive: false });
+    watcher = syncFs.watch(path14.dirname(configPath), { recursive: false });
   } catch (err) {
     warn?.(`Provider config watcher could not start: ${err.message}`);
     return { close: () => {
@@ -5119,10 +5202,7 @@ function watchProviderConfig(configPath, vault, onChange, opts = {}) {
 
 // src/storage/config-loader.ts
 import * as fs7 from "node:fs/promises";
-import * as path14 from "node:path";
-
-// src/types/config.ts
-var DEFAULT_TUI_THINKING_WORD = "thinking";
+import * as path15 from "node:path";
 
 // src/types/context-window.ts
 var DEFAULT_CONTEXT_WINDOW_MODE_ID = "frugal";
@@ -5256,7 +5336,12 @@ var BEHAVIOR_DEFAULTS = {
     modelsRegistry: true,
     skills: true,
     prompts: true,
-    tokenSavingMode: "off",
+    // '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.
+    tokenSavingMode: "auto",
     allowOutsideProjectRoot: true
   },
   superMemory: {
@@ -5266,10 +5351,14 @@ var BEHAVIOR_DEFAULTS = {
       directory: ".wrongstack/memories"
     },
     inject: {
-      turnContext: true,
+      // Keep the ordinary turn prompt clean. Project memory is surfaced
+      // on-demand beside relevant tool results, where the path/query that
+      // caused retrieval is known and the hint can be independently capped.
+      turnContext: false,
       toolResults: true,
-      maxHintsPerTool: 4,
-      maxCharsPerTool: 1200,
+      taskAware: true,
+      maxHintsPerTool: 8,
+      maxCharsPerTool: 2800,
       maxTurnMemories: 8,
       maxCharsPerTurn: 2400,
       minScore: 0.65,
@@ -5635,7 +5724,7 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
         event: "config.in_project_unsafe_fields_ignored",
         path: sourcePath,
         ignoredKeys: stripped,
-        message: `Ignored ${stripped.length} field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. Only a small allow-list of benign preferences (model, context, tools limits, features, \u2026) may be set by <project>/.wrongstack/config.json. Everything else must live in your personal ~/.wrongstack/config.json.`,
+        message: `Ignored ${stripped.length} field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. Only a small allow-list of benign preferences (model, context, tools limits, features, \u2026) may be set by <project>/.wrongstack/config.json. Everything else must live in your active profile config.`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
@@ -5643,8 +5732,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   return out;
 }
 function samePath(a, b) {
-  let ra = path14.resolve(a);
-  let rb = path14.resolve(b);
+  let ra = path15.resolve(a);
+  let rb = path15.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -5705,11 +5794,18 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
       this.readJson(this.paths.projectLocalConfig),
       inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
-    cfg = deepMerge2(cfg, bootstrap);
+    const bootstrapMetadata = {
+      ...typeof bootstrap.version === "number" ? { version: bootstrap.version } : {},
+      ...typeof bootstrap.activeProfile === "string" ? { activeProfile: bootstrap.activeProfile } : {}
+    };
+    cfg = deepMerge2(cfg, bootstrapMetadata);
     const profileName = bootstrap.activeProfile ?? "default";
     const profileCfg = await this.readJson(this.paths.profileConfig(profileName));
     if (Object.keys(profileCfg).length > 0) {
-      cfg = deepMerge2(cfg, profileCfg);
+      const profileSettings = { ...profileCfg };
+      delete profileSettings["version"];
+      delete profileSettings["activeProfile"];
+      cfg = deepMerge2(cfg, profileSettings);
     }
     cfg = deepMerge2(cfg, local);
     cfg = deepMerge2(
@@ -5815,6 +5911,7 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
           fileExisted = false;
           parsed = {};
         }
+        if (parsed["version"] !== void 0 && parsed["version"] !== 1) return;
         const profileName = parsed.activeProfile ?? "default";
         const profileFp = this.paths.profileConfig(profileName);
         await this.ensureProfileConfig(profileFp, parsed, fileExisted);
@@ -5871,11 +5968,9 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
    * with behavior defaults. Subsequent boots: fill any missing keys from
    * BEHAVIOR_DEFAULTS (keeping user settings intact).
    *
-   * CRITICAL SAFETY NET: when the profile already exists but the old global
-   * config has extra non-bootstrap keys (because WebUI/CLI persistence functions
-   * mistakenly wrote settings to the root config), those keys are merged into
-   * the profile so they are NOT silently destroyed by the subsequent bootstrap
-   * trim. This prevents the "config keeps getting emptied" bug.
+   * Once a profile file exists, settings found in the root bootstrap are
+   * ignored. This prevents stale or accidentally-written root values from
+   * becoming a hidden settings source alongside profiles.
    */
   async ensureProfileConfig(profileFp, oldGlobalParsed, oldFileExisted) {
     const t0 = Date.now();
@@ -5905,42 +6000,13 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
       existed = false;
       parsed = {};
     }
-    const profileHasContent = existed && Object.keys(parsed).some((k) => k !== "version" && k !== "activeProfile");
     let seed;
-    if (!profileHasContent && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
+    if (!existed && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
       seed = { ...oldGlobalParsed };
       delete seed["activeProfile"];
       const filled = fillMissingDefaults(seed, BEHAVIOR_DEFAULTS);
       seed = filled.value;
     } else {
-      if (existed && !_DefaultConfigLoader.isBootstrapOnly(oldGlobalParsed)) {
-        const BOOTSTRAP_KEYS = /* @__PURE__ */ new Set(["version", "activeProfile"]);
-        let merged = false;
-        for (const [k, v] of Object.entries(oldGlobalParsed)) {
-          if (!BOOTSTRAP_KEYS.has(k) && !(k in parsed)) {
-            parsed[k] = v;
-            merged = true;
-          }
-        }
-        if (merged) {
-          const filled2 = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
-          if (filled2.changed) {
-            seed = filled2.value;
-            await backupConfigFile(profileFp, this.paths);
-            await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
-            this.events?.emit("storage.write", {
-              sessionId: "~config~",
-              store: "config",
-              filePath: profileFp,
-              operation: "ensure_profile_defaults",
-              outcome: "success",
-              durationMs: Date.now() - t0,
-              ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-            });
-            return;
-          }
-        }
-      }
       const filled = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
       if (!filled.changed) return;
       seed = filled.value;
@@ -6260,7 +6326,7 @@ var DEFAULT_CONFIG_MIGRATIONS = [];
 // src/storage/recovery-lock.ts
 import * as fsp7 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -6271,7 +6337,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path15.join(opts.dir, LOCK_FILE);
+    this.file = path16.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;
@@ -6332,7 +6398,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path15.dirname(this.file));
+    await ensureDir(path16.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -7047,7 +7113,7 @@ var AnnotationsStore = class {
 
 // src/storage/replay-log-store.ts
 import * as fs10 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 
 // src/replay/hash.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -7285,13 +7351,13 @@ var ReplayLogStore = class {
       for (const entry of entries) {
         if (entry.name.startsWith(".")) continue;
         if (entry.isDirectory()) {
-          if (depth === 0) await scan(path16.join(dir, entry.name), entry.name, depth + 1);
+          if (depth === 0) await scan(path17.join(dir, entry.name), entry.name, depth + 1);
           continue;
         }
         if (!entry.isFile() || !entry.name.endsWith(".replay.jsonl")) continue;
         const base = entry.name.slice(0, -".replay.jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const fp = path16.join(dir, entry.name);
+        const fp = path17.join(dir, entry.name);
         out.push({
           sessionId,
           entryCount: await this.countEntries(fp),
@@ -7463,7 +7529,7 @@ var ReplayLogStore = class {
 
 // src/storage/session-recovery.ts
 import * as fs11 from "node:fs/promises";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 var SessionRecovery = class {
   constructor(dir) {
     this.dir = dir;
@@ -7578,7 +7644,7 @@ var SessionRecovery = class {
           continue;
         if (entry.isDirectory()) {
           if (depth === 0) {
-            await collect(path17.join(dir, entry.name), entry.name, depth + 1);
+            await collect(path18.join(dir, entry.name), entry.name, depth + 1);
           }
           continue;
         }
@@ -8097,7 +8163,7 @@ var SessionAnalyzer = class {
 // src/session-registry.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import * as fs13 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 var REGISTRY_FILE = "session-registry.json";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
@@ -8136,7 +8202,7 @@ var SessionRegistry = class {
    */
   lastEntry = null;
   constructor(globalRoot) {
-    this.filePath = path18.join(globalRoot, REGISTRY_FILE);
+    this.filePath = path19.join(globalRoot, REGISTRY_FILE);
   }
   // ── Public API ──────────────────────────────────────────────────────────
   /**
@@ -8345,7 +8411,7 @@ var SessionRegistry = class {
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
-        await fs13.mkdir(path18.dirname(this.filePath), { recursive: true });
+        await fs13.mkdir(path19.dirname(this.filePath), { recursive: true });
         let lockHandle = await fs13.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await this.breakStaleLock(lockPath)) {
@@ -8409,9 +8475,9 @@ var SessionRegistry = class {
     await this.writeAtomicFile(registry);
   }
   async writeAtomicFile(registry) {
-    const tmp = path18.join(
-      path18.dirname(this.filePath),
-      `.${path18.basename(this.filePath)}.${randomUUID5().slice(0, 8)}.tmp`
+    const tmp = path19.join(
+      path19.dirname(this.filePath),
+      `.${path19.basename(this.filePath)}.${randomUUID5().slice(0, 8)}.tmp`
     );
     try {
       const handle = await fs13.open(tmp, "w");
@@ -8429,21 +8495,21 @@ var SessionRegistry = class {
   }
   async pruneStaleTempFiles() {
     try {
-      const dir = path18.dirname(this.filePath);
-      const base = path18.basename(this.filePath);
+      const dir = path19.dirname(this.filePath);
+      const base = path19.basename(this.filePath);
       const now = Date.now();
       const stale = [];
       for (const name of await fs13.readdir(dir)) {
         const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
         if (!isTemp) continue;
-        const stat13 = await fs13.stat(path18.join(dir, name)).catch(() => null);
+        const stat13 = await fs13.stat(path19.join(dir, name)).catch(() => null);
         if (!stat13) continue;
         if (now - stat13.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat13.mtimeMs });
       }
       stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
       await Promise.all(
         stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-          await fs13.unlink(path18.join(dir, name)).catch(() => void 0);
+          await fs13.unlink(path19.join(dir, name)).catch(() => void 0);
         })
       );
     } catch {
@@ -9179,7 +9245,7 @@ var AgentStatusTracker = class {
 
 // src/fleet-notifier.ts
 import * as fs14 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 var INSTANCES_FILE = "webui-instances.json";
 var DISCOVERY_TTL_MS = 2500;
 var COALESCE_MS = 50;
@@ -9194,7 +9260,7 @@ function pidAlive2(pid) {
   }
 }
 function normRoot(root) {
-  const resolved = path19.resolve(root);
+  const resolved = path20.resolve(root);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 var FleetNotifier = class {
@@ -9241,7 +9307,7 @@ var FleetNotifier = class {
   }
   async discover() {
     try {
-      const raw = await fs14.readFile(path19.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const raw = await fs14.readFile(path20.join(this.baseDir, INSTANCES_FILE), "utf8");
       const data = JSON.parse(raw);
       const list = Array.isArray(data?.instances) ? data.instances : [];
       return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
@@ -9262,7 +9328,7 @@ async function defaultPost(url) {
 
 // src/storage/session-rewinder.ts
 import * as fsp8 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
@@ -9400,10 +9466,10 @@ async function revertSnapshots(snapshots, projectRoot) {
   for (const snapshot of [...snapshots].reverse()) {
     for (const file of [...snapshot.files].reverse()) {
       try {
-        const absPath = path20.resolve(file.path);
-        const root = path20.resolve(projectRoot);
-        const rel = path20.relative(root, absPath);
-        if (rel.startsWith("..") || path20.isAbsolute(rel)) {
+        const absPath = path21.resolve(file.path);
+        const root = path21.resolve(projectRoot);
+        const rel = path21.relative(root, absPath);
+        if (rel.startsWith("..") || path21.isAbsolute(rel)) {
           errors.push(`${file.path}: path resolves outside project root \u2014 skipping`);
           continue;
         }
@@ -10929,7 +10995,7 @@ function normalizeTitle(value) {
 // src/storage/prompt-store.ts
 import { createHash as createHash7 } from "node:crypto";
 import * as fs15 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 var SCHEMA_VERSION = 2;
 function promptChecksum(content) {
   return createHash7("sha256").update(content, "utf8").digest("hex");
@@ -10998,7 +11064,7 @@ var DefaultPromptStore = class {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs15.readFile(path21.join(this.dir, file), "utf8")
+            await fs15.readFile(path22.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -11012,7 +11078,7 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path21.join(this.dir, `${id}.json`);
+    const file = path22.join(this.dir, `${id}.json`);
     try {
       const raw = JSON.parse(await fs15.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
@@ -11022,12 +11088,12 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path21.join(this.dir, `${entry.id}.json`);
+    const file = path22.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 = path21.join(this.dir, `${id}.json`);
+    const file = path22.join(this.dir, `${id}.json`);
     try {
       await fs15.unlink(file);
       return true;
@@ -11069,7 +11135,7 @@ var DefaultPromptStore = class {
 
 // src/storage/prompt-usage-store.ts
 import * as fs16 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 var PromptUsageStore = class {
   constructor(file) {
     this.file = file;
@@ -11090,7 +11156,7 @@ var PromptUsageStore = class {
     const prev = usage[slug];
     const next = { count: (prev?.count ?? 0) + 1, lastUsedAt: at };
     usage[slug] = next;
-    await ensureDir(path22.dirname(this.file));
+    await ensureDir(path23.dirname(this.file));
     await atomicWrite(this.file, JSON.stringify({ version: 1, usage }, null, 2));
     return next;
   }
@@ -11115,7 +11181,7 @@ var PromptUsageStore = class {
 
 // src/storage/input-history-store.ts
 import * as fs17 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 var INPUT_HISTORY_DEFAULT_MAX = 100;
 var InputHistoryStore = class {
   /**
@@ -11154,7 +11220,7 @@ var InputHistoryStore = class {
    */
   async save(entries) {
     const cleaned = this.scrubAndFilter(entries);
-    await ensureDir(path23.dirname(this.file));
+    await ensureDir(path24.dirname(this.file));
     const payload = {
       version: 1,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11164,7 +11230,7 @@ var InputHistoryStore = class {
   }
   /** Truncate the file to an empty entry list (used by /clear). */
   async clear() {
-    await ensureDir(path23.dirname(this.file));
+    await ensureDir(path24.dirname(this.file));
     const payload = { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: [] };
     await atomicWrite(this.file, JSON.stringify(payload, null, 2));
   }
@@ -11195,7 +11261,7 @@ var InputHistoryStore = class {
 
 // src/storage/cloud-sync.ts
 import * as fs18 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import { createHash as createHash8 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
@@ -11203,7 +11269,7 @@ var CloudSync = class {
     this.paths = paths;
     this.getConfig = getConfig;
     this.setConfig = setConfig;
-    this.statePath = path24.join(paths.globalRoot, "sync-state.json");
+    this.statePath = path25.join(paths.globalRoot, "sync-state.json");
   }
   paths;
   getConfig;
@@ -11310,7 +11376,7 @@ var CloudSync = class {
       const rel = segments.slice(2).join("/");
       const destPath = resolvePulledCategoryPath(cat, localPath, rel, entry.path);
       const blobData = await this.getBlob(token, owner, repoName, entry.sha);
-      await fs18.mkdir(path24.dirname(destPath), { recursive: true });
+      await fs18.mkdir(path25.dirname(destPath), { recursive: true });
       await fs18.writeFile(destPath, Buffer.from(blobData, "base64"));
     }
     const localRev = await this.hashLocalCategories(cfg.categories);
@@ -11422,7 +11488,7 @@ var CloudSync = class {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fs18.readFile(file, "utf8");
-            const rel = path24.relative(localPath, file).replace(/\\/g, "/");
+            const rel = path25.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(content);
           }
@@ -11480,7 +11546,7 @@ var CloudSync = class {
     const results = [];
     const entries = await fs18.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path24.join(dir, entry.name);
+      const full = path25.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await this.walkDir(full, base));
       } else {
@@ -11502,9 +11568,9 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
     return localPath;
   }
   if (!rel) return localPath;
-  const normalizedRel = path24.normalize(rel);
-  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path24.sep}`);
-  if (path24.isAbsolute(normalizedRel) || traversesUp) {
+  const normalizedRel = path25.normalize(rel);
+  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path25.sep}`);
+  if (path25.isAbsolute(normalizedRel) || traversesUp) {
     throw new FsError({
       message: `Refusing CloudSync path traversal: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -11512,10 +11578,10 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
       context: { reason: "path_traversal", normalizedRel }
     });
   }
-  const dest = path24.resolve(localPath, normalizedRel);
-  const root = path24.resolve(localPath);
-  const relative7 = path24.relative(root, dest);
-  if (relative7.startsWith("..") || path24.isAbsolute(relative7)) {
+  const dest = path25.resolve(localPath, normalizedRel);
+  const root = path25.resolve(localPath);
+  const relative8 = path25.relative(root, dest);
+  if (relative8.startsWith("..") || path25.isAbsolute(relative8)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,