@wrongstack/core 0.89.1 → 0.89.3

package/dist/index.js

@@ -6,6 +6,7 @@ import * as path6 from 'path';
 import { join, extname, relative, isAbsolute, resolve, sep } from 'path';
 import * as fs2 from 'fs';
 import * as os7 from 'os';
+import { hostname } from 'os';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
@@ -15,12 +16,6 @@ import { pipeline } from 'stream/promises';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -1713,13 +1708,25 @@ function round4(n) {
   return Math.round(n * 1e4) / 1e4;
 }
 
-// src/utils/token-estimate.ts
-function expectDefined(value) {
+// src/types/memory.ts
+var MEMORY_TYPE_LABELS = {
+  fact: "Fact",
+  decision: "Decision",
+  convention: "Convention",
+  preference: "Preference",
+  reference: "Reference",
+  anti_pattern: "Anti-pattern"
+};
+
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
+    throw new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
   }
   return value;
 }
+
+// src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var _cal = {
   ratio: 1,
@@ -1853,12 +1860,6 @@ function resetCalibration() {
 }
 
 // src/utils/message-invariants.ts
-function expectDefined2(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -1866,7 +1867,7 @@ function repairToolUseAdjacency(messages) {
   let changed = false;
   const out = [];
   for (let i = 0; i < messages.length; i++) {
-    const original = expectDefined2(messages[i]);
+    const original = expectDefined(messages[i]);
     let msg = original;
     if (hasToolUse(msg)) {
       const nextIds = toolResultIds(messages[i + 1]);
@@ -3024,12 +3025,6 @@ Remember: your job is to make the user a better developer, not just to complete
 ];
 
 // src/types/context-window.ts
-function expectDefined3(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DEFAULT_CONTEXT_WINDOW_MODE_ID = "balanced";
 var CONTEXT_WINDOW_MODES = Object.freeze([
   {
@@ -3086,7 +3081,7 @@ function isContextWindowModeId(id) {
 }
 function resolveContextWindowPolicy(config = {}, overrideMode) {
   const requested = overrideMode ?? config.mode ?? DEFAULT_CONTEXT_WINDOW_MODE_ID;
-  const mode = getContextWindowMode(requested) ?? expectDefined3(getContextWindowMode(DEFAULT_CONTEXT_WINDOW_MODE_ID));
+  const mode = getContextWindowMode(requested) ?? expectDefined(getContextWindowMode(DEFAULT_CONTEXT_WINDOW_MODE_ID));
   if (mode.id !== DEFAULT_CONTEXT_WINDOW_MODE_ID) {
     return mode;
   }
@@ -3566,12 +3561,6 @@ function sizeSignals(toolName, content) {
 }
 
 // src/execution/tool-executor.ts
-function expectDefined4(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var ToolExecutor = class {
   constructor(registry, opts) {
     this.registry = registry;
@@ -3978,7 +3967,7 @@ function hasMalformedArguments(input) {
 function extractMalformedRaw(input) {
   if (!hasMalformedArguments(input)) return void 0;
   const obj = input;
-  const value = obj[expectDefined4(Object.keys(obj)[0])];
+  const value = obj[expectDefined(Object.keys(obj)[0])];
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string") return value;
   try {
@@ -4025,12 +4014,6 @@ function compileUserRegex(pattern, flags) {
 }
 
 // src/storage/session-reader.ts
-function expectDefined5(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DefaultSessionReader = class {
   store;
   constructor(opts) {
@@ -4092,7 +4075,7 @@ var DefaultSessionReader = class {
         continue;
       }
       for (let i = 0; i < data.events.length; i++) {
-        const ev = expectDefined5(data.events[i]);
+        const ev = expectDefined(data.events[i]);
         if (allowedTypes && !allowedTypes.has(ev.type)) continue;
         const text = eventText(ev);
         if (text === null) continue;
@@ -4460,12 +4443,6 @@ function formatTodosList(todos) {
 }
 
 // src/utils/glob-match.ts
-function expectDefined6(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function escapeRegex(s) {
   return s.replace(/[.+^${}()|\\]/g, "\\$&");
 }
@@ -4477,7 +4454,7 @@ function getCachedGlob(pattern) {
   if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
     const keys = [...COMPILED_GLOB_CACHE.keys()];
     for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
-      COMPILED_GLOB_CACHE.delete(expectDefined6(keys[i]));
+      COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
     }
   }
   const re = compileGlob(pattern);
@@ -4837,20 +4814,6 @@ function buildChildEnv(optsOrSessionId) {
 function sleep(ms) {
   return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
-
-// src/utils/expect-defined.ts
-function expectDefined7(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
-function expectDefined8(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
 var IS_WINDOWS = process.platform === "win32";
 var SEP = IS_WINDOWS ? "\\" : "/";
@@ -4864,7 +4827,7 @@ function globToRegex(pat) {
   let i = 0;
   let re = "^";
   while (i < pat.length) {
-    const c = expectDefined8(pat[i]);
+    const c = expectDefined(pat[i]);
     if (c === "*") {
       if (pat[i + 1] === "*") {
         re += ".*";
@@ -4903,7 +4866,7 @@ function globToRegex(pat) {
 }
 function baseDir(pat) {
   let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(expectDefined8(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
+  while (i >= 0 && !GLOB_CHARS.has(expectDefined(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
   const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
   return cut < 0 ? "." : pat.slice(0, cut);
 }
@@ -4968,12 +4931,6 @@ async function expandGlob(pattern) {
 }
 
 // src/utils/json-repair.ts
-function expectDefined9(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function completePartialObject(s) {
   if (!s.trim().startsWith("{")) return s;
   if (tryParse(s).ok) return s;
@@ -4985,7 +4942,7 @@ function completePartialObject(s) {
   let contentEnd = 0;
   let stringBraceDepth = 0;
   for (let i = 0; i < s.length; i++) {
-    const ch = expectDefined9(s[i]);
+    const ch = expectDefined(s[i]);
     if (inString) {
       contentEnd = i + 1;
       if (escaped) {
@@ -5081,12 +5038,6 @@ function mergeCustomModelDefs(providerCustomModels, configModels) {
 
 // src/storage/session-store.ts
 init_atomic_write();
-function expectDefined10(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function sanitizeModel(model) {
   return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
@@ -5797,7 +5748,7 @@ var FileSessionWriter = class {
     let targetCheckpointLine = -1;
     let afterTarget = false;
     for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined10(lines[i]);
+      const line = expectDefined(lines[i]);
       if (!line.trim()) continue;
       let event;
       try {
@@ -6092,12 +6043,224 @@ function mergeAdjacentText(blocks) {
   }
   return out;
 }
+init_atomic_write();
+var TYPE_PRIORITY_RE = /^\[(\w+)\|(\w+)\]\s+/;
+var TAG_RE = /#([\w-]+)/g;
+function formatMetadata(entry) {
+  const parts = [];
+  if (entry.type && entry.priority) {
+    parts.push(`[${entry.type}|${entry.priority}]`);
+  } else if (entry.type) {
+    parts.push(`[${entry.type}]`);
+  } else if (entry.priority) {
+    parts.push(`[${entry.priority}]`);
+  }
+  if (entry.tags && entry.tags.length > 0) {
+    parts.push(entry.tags.map((t2) => `#${t2}`).join(" "));
+  }
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function lineToEntry(line, scope) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("- [")) return null;
+  const tsMatch = trimmed.match(/^-\s*\[([^\]]+)\]/);
+  if (!tsMatch) return null;
+  const ts = tsMatch[1] ?? "";
+  let rest = trimmed.slice(tsMatch[0].length).trim();
+  let type;
+  let priority;
+  const tpMatch = rest.match(TYPE_PRIORITY_RE);
+  if (tpMatch) {
+    const a = tpMatch[1] ?? "";
+    const b = tpMatch[2] ?? "";
+    if (isMemoryType(a)) {
+      type = a;
+      priority = isPriority(b) ? b : void 0;
+    } else if (isPriority(a)) {
+      priority = a;
+    }
+    rest = rest.slice(tpMatch[0].length).trim();
+  }
+  const idMatch = rest.match(/^mem_\d+_\w+\s+/);
+  let text;
+  if (idMatch) {
+    text = rest.slice(idMatch[0].length).trim();
+  } else {
+    text = rest.trim();
+  }
+  const tags = [];
+  let tagMatch;
+  TAG_RE.lastIndex = 0;
+  while ((tagMatch = TAG_RE.exec(text)) !== null) {
+    tags.push(tagMatch[1] ?? "");
+  }
+  const cleanText = text.replace(TAG_RE, "").replace(/\s{2,}/g, " ").trim();
+  if (!cleanText) return null;
+  return {
+    scope,
+    text: cleanText,
+    ts,
+    type,
+    priority,
+    tags: tags.length > 0 ? tags : void 0
+  };
+}
+function isMemoryType(s) {
+  return s in MEMORY_TYPE_LABELS;
+}
+function isPriority(s) {
+  return s === "critical" || s === "high" || s === "medium" || s === "low";
+}
+var FileMemoryBackend = class {
+  kind = "file";
+  files;
+  constructor(opts) {
+    this.files = {
+      "project-agents": opts.paths.inProjectAgentsFile,
+      "project-memory": opts.paths.projectMemory,
+      "user-memory": opts.paths.globalMemory
+    };
+  }
+  resolveFile(filePath, scope) {
+    return filePath || this.files[scope];
+  }
+  async remember(scope, entry, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    await ensureDir(path6.dirname(file));
+    let existing = "";
+    try {
+      existing = await fsp3.readFile(file, "utf8");
+    } catch {
+    }
+    const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const meta = formatMetadata(entry);
+    const line = `
+- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
+`;
+    const next = existing.trim() ? existing.replace(/\n+$/, "") + line : `# WrongStack Memory
+${line}`;
+    await atomicWrite(file, next);
+  }
+  async forget(scope, query, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    let existing;
+    try {
+      existing = await fsp3.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const needle = query.toLowerCase();
+    const idMatcher = /mem_\d+_\w+/;
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      if (idMatcher.test(query)) {
+        const entryIdMatch = /mem_\d+_\w+/.exec(trimmed);
+        if (entryIdMatch && entryIdMatch[0] === query) {
+          removed++;
+          return false;
+        }
+      }
+      if (trimmed.toLowerCase().includes(needle)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    if (removed > 0) {
+      if (lines.length === 0 || lines.length === 1 && !lines[0]?.trim()) {
+        await atomicWrite(file, "");
+      } else {
+        await atomicWrite(file, lines.join("\n"));
+      }
+    }
+    return removed;
+  }
+  async readAll(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    try {
+      return await fsp3.readFile(file, "utf8");
+    } catch {
+      return "";
+    }
+  }
+  async list(scope, filePath, limit) {
+    const raw = await this.readAll(scope, filePath);
+    if (!raw.trim()) return [];
+    const entries = parseEntries(raw, scope);
+    return limit ? entries.slice(0, limit) : entries;
+  }
+  async search(scope, query, filePath, limit) {
+    const entries = await this.list(scope, filePath);
+    const needle = query.toLowerCase().split(/\s+/);
+    const scored = entries.map((e) => {
+      const words = e.text.toLowerCase().split(/\s+/);
+      let score = 0;
+      for (const n of needle) {
+        if (words.some((w) => w.includes(n))) score += 1;
+        if (e.tags?.some((t2) => t2.toLowerCase().includes(n))) score += 2;
+      }
+      return { entry: e, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const matched = scored.filter((s) => s.score > 0).map((s) => s.entry);
+    return limit ? matched.slice(0, limit) : matched;
+  }
+  async clear(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    await atomicWrite(file, "");
+  }
+  async consolidate(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    let existing;
+    try {
+      existing = await fsp3.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      const norm = trimmed.replace(/\[[^\]]+\]/g, "").replace(/\bmem_\d+_\w+\s*/, "").replace(/#[\w-]+/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+      if (seen.has(norm)) {
+        removed++;
+        return false;
+      }
+      seen.add(norm);
+      return true;
+    });
+    const next = lines.join("\n");
+    const backup = `${file}.bak.${Date.now()}`;
+    try {
+      await fsp3.copyFile(file, backup);
+    } catch {
+    }
+    try {
+      await atomicWrite(file, next);
+    } catch {
+      return 0;
+    }
+    return removed;
+  }
+};
+function parseEntries(raw, scope = "project-memory") {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const entry = lineToEntry(line, scope);
+    if (entry) entries.push(entry);
+  }
+  return entries.reverse();
+}
 
 // src/storage/memory-store.ts
-init_atomic_write();
 var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
+  events;
+  backend;
   /**
    * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
    * `clear` are read-modify-write against a single file; without a lock,
@@ -6114,12 +6277,29 @@ var DefaultMemoryStore = class {
   writeChain = /* @__PURE__ */ new Map();
   /** Last write error per scope — surfaced as warnings on the next readAll(). */
   writeErrors = /* @__PURE__ */ new Map();
+  /**
+   * When the global root is a temporary directory (opencode, CI sandboxes),
+   * memory files are also mirrored to the project tree so they survive
+   * session cleanup. The primary path stays in the temp root for isolation;
+   * this backup ensures memory is never lost.
+   */
+  persistBackup;
+  backupDir;
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
       "project-memory": opts.paths.projectMemory,
       "user-memory": opts.paths.globalMemory
     };
+    this.events = opts.events;
+    this.backend = opts.backend ?? new FileMemoryBackend({ paths: opts.paths });
+    const root = opts.paths.globalRoot.toLowerCase();
+    this.persistBackup = /[/\\](tmp|temp|cache)[/\\]/.test(root);
+    this.backupDir = this.persistBackup ? opts.paths.inProjectAgentsFile.replace(/AGENTS\.md$/, "memory-persist") : "";
+  }
+  /** Expose the backend for plugin introspection and advanced queries. */
+  getBackend() {
+    return this.backend;
   }
   async runSerialized(scope, work) {
     const prior = this.writeChain.get(scope) ?? Promise.resolve();
@@ -6146,7 +6326,7 @@ var DefaultMemoryStore = class {
       if (writeErr2) {
         parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr2.message}`);
       }
-      const body = await this.read(scope);
+      const body = await this.backend.readAll(scope, this.files[scope]);
       if (body.trim()) parts.push(`## ${labelOf(scope)}
 
 ${body.trim()}`);
@@ -6154,117 +6334,214 @@ ${body.trim()}`);
     return parts.join("\n\n");
   }
   async read(scope) {
-    try {
-      return await fsp3.readFile(this.files[scope], "utf8");
-    } catch {
-      return "";
+    return this.backend.readAll(scope, this.files[scope]);
+  }
+  /**
+   * List entries from a scope, newest first. Delegates to the backend
+   * so graph/semantic backends can return enriched or filtered results.
+   */
+  async list(scope = "project-memory", limit) {
+    return this.backend.list(scope, this.files[scope], limit);
+  }
+  /**
+   * Find memories related to the given text via graph traversal.
+   * Falls back to content search when no graph backend is available.
+   */
+  async findRelated(text, scope = "project-memory", limit = 5) {
+    if (this.backend.findRelated) {
+      return this.backend.findRelated(scope, this.files[scope], text, limit);
     }
+    return this.search(text, scope, limit);
+  }
+  async search(query, scope = "project-memory", limit) {
+    return this.backend.search(scope, query, this.files[scope], limit);
   }
-  async remember(text, scope = "project-memory") {
+  async remember(text, scope = "project-memory", metadata) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
     return this.runSerialized(scope, async () => {
-      const file = this.files[scope];
-      await ensureDir(path6.dirname(file));
-      let existing = "";
-      try {
-        existing = await fsp3.readFile(file, "utf8");
-      } catch {
-      }
-      const ts = (/* @__PURE__ */ new Date()).toISOString();
-      const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
-      const entry = `
-- [${ts}] ${id} ${text.replace(/\n/g, " ")}
-`;
-      const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
-${entry}`;
-      await atomicWrite(file, next);
-      const buf = Buffer.byteLength(next, "utf8");
-      if (buf > MAX_BYTES_TOTAL) {
-        await this.consolidateUnsafe(scope);
+      const entry = { scope, text, ts, ...metadata };
+      await this.backend.remember(scope, entry, this.files[scope]);
+      const raw = await this.backend.readAll(scope, this.files[scope]);
+      if (Buffer.byteLength(raw, "utf8") > MAX_BYTES_TOTAL) {
+        const removed = await this.backend.consolidate(scope, this.files[scope]);
+        if (removed > 0) {
+          this.events?.emit("memory.consolidated", {
+            scope,
+            removed
+          });
+        }
       }
+      await this.mirrorBackup(scope);
+      this.events?.emit("memory.remembered", {
+        scope,
+        text,
+        ts,
+        type: entry.type,
+        tags: entry.tags,
+        priority: entry.priority
+      });
     });
   }
-  async forget(query, scope = "project-memory") {
-    return this.runSerialized(scope, async () => this.forgetUnsafe(query, scope));
-  }
-  async forgetUnsafe(query, scope) {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp3.readFile(file, "utf8");
-    } catch {
-      return 0;
-    }
-    const needle = query.toLowerCase();
-    const idMatcher = /mem_\d+_\w+/;
-    let removed = 0;
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      if (idMatcher.test(query)) {
-        const afterBracket = trimmed.indexOf("] ");
-        if (afterBracket !== -1) {
-          const afterTs = trimmed.slice(afterBracket + 2);
-          const entryIdMatch = /^mem_\d+_\w+/.exec(afterTs);
-          if (entryIdMatch && entryIdMatch[0] === query) {
-            removed++;
-            return false;
-          }
+  /**
+   * Score and rank memories by relevance to the current context.
+   * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
+   */
+  async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
+    const all = await this.list(scope);
+    if (all.length === 0) return [];
+    const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+    const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
+    const toolWords = (ctx.toolNames ?? []).flatMap((t2) => t2.toLowerCase().split("_"));
+    const now = Date.now();
+    const scored = [];
+    for (const entry of all) {
+      let score = 0;
+      const reasons = [];
+      const textLower = entry.text.toLowerCase();
+      const tagsLower = (entry.tags ?? []).map((t2) => t2.toLowerCase());
+      let taskHits = 0;
+      for (const w of taskWords) {
+        if (textLower.includes(w)) {
+          taskHits++;
+          score += 2;
+        }
+        if (tagsLower.some((t2) => t2.includes(w))) {
+          taskHits++;
+          score += 3;
         }
       }
-      if (trimmed.toLowerCase().includes(needle)) {
-        removed++;
-        return false;
+      if (taskHits > 0) reasons.push(`task match (${taskHits})`);
+      let skillHits = 0;
+      for (const w of skillWords) {
+        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t2) => t2.includes(w)))) {
+          skillHits++;
+        }
+      }
+      score += skillHits;
+      if (skillHits > 0) reasons.push(`skill match (${skillHits})`);
+      for (const w of toolWords) {
+        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t2) => t2.includes(w)))) {
+          score += 1;
+          reasons.push(`tool mention: ${w}`);
+        }
+      }
+      switch (entry.priority) {
+        case "critical":
+          score += 5;
+          reasons.push("critical");
+          break;
+        case "high":
+          score += 3;
+          reasons.push("high priority");
+          break;
+        case "medium":
+          score += 1;
+          break;
+        case "low":
+          score -= 2;
+          reasons.push("low priority");
+          break;
+      }
+      switch (entry.type) {
+        case "decision":
+          score += 2;
+          reasons.push("decision");
+          break;
+        case "convention":
+          score += 2;
+          reasons.push("convention");
+          break;
+        case "anti_pattern":
+          score += 3;
+          reasons.push("anti-pattern");
+          break;
+        case "preference":
+          score += 1;
+          reasons.push("preference");
+          break;
+      }
+      const ageDays = (now - new Date(entry.ts).getTime()) / (1e3 * 60 * 60 * 24);
+      if (ageDays < 1) score += 1;
+      else if (ageDays > 30) score -= 1;
+      if (entry.confidence !== void 0 && entry.confidence < 0.5) {
+        score -= 2;
+        reasons.push("low confidence");
+      }
+      if (entry.lastAccessed) {
+        const hoursSinceAccess = (now - new Date(entry.lastAccessed).getTime()) / (1e3 * 60 * 60);
+        if (hoursSinceAccess < 1) score -= 1;
+      }
+      if (score > 0) {
+        scored.push({
+          ...entry,
+          score,
+          matchReason: reasons.join(", ") || "keyword match"
+        });
       }
-      return true;
-    });
-    if (removed > 0) {
-      await atomicWrite(file, lines.join("\n"));
     }
-    return removed;
+    scored.sort((a, b) => b.score - a.score);
+    const threshold = 2;
+    const relevant = scored.filter(
+      (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
+    );
+    return relevant.slice(0, Math.min(limit, 15));
   }
-  async consolidate(scope) {
-    return this.runSerialized(scope, async () => this.consolidateUnsafe(scope));
+  async forget(query, scope = "project-memory") {
+    return this.runSerialized(scope, async () => {
+      const removed = await this.backend.forget(scope, query, this.files[scope]);
+      if (removed > 0) {
+        this.events?.emit("memory.forgotten", {
+          scope,
+          query,
+          removed
+        });
+        await this.mirrorBackup(scope);
+      }
+      return removed;
+    });
   }
-  async consolidateUnsafe(scope) {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp3.readFile(file, "utf8");
-    } catch {
-      return;
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      const norm = trimmed.replace(/\[[^\]]+\]/, "").replace(/\bmem_\d+_\w+\s*/, "").trim().toLowerCase();
-      if (seen.has(norm)) return false;
-      seen.add(norm);
-      return true;
+  async consolidate(scope) {
+    return this.runSerialized(scope, async () => {
+      const removed = await this.backend.consolidate(scope, this.files[scope]);
+      if (removed > 0) {
+        this.events?.emit("memory.consolidated", {
+          scope,
+          removed
+        });
+        await this.mirrorBackup(scope);
+      }
     });
-    const next = lines.join("\n");
-    const backup = `${file}.bak.${Date.now()}`;
-    try {
-      await fsp3.copyFile(file, backup);
-    } catch {
-    }
-    try {
-      await atomicWrite(file, next);
-    } catch {
-      return;
-    }
   }
   async clear(scope) {
     if (scope) {
-      await this.runSerialized(scope, async () => atomicWrite(this.files[scope], ""));
+      await this.runSerialized(scope, async () => {
+        await this.backend.clear(scope, this.files[scope]);
+        this.events?.emit("memory.cleared", { scope });
+        await this.mirrorBackup(scope);
+      });
       return;
     }
     await Promise.all(
       ["project-agents", "project-memory", "user-memory"].map(
-        (s) => this.runSerialized(s, async () => atomicWrite(this.files[s], ""))
+        (s) => this.runSerialized(s, async () => {
+          await this.backend.clear(s, this.files[s]);
+          this.events?.emit("memory.cleared", { scope: s });
+          await this.mirrorBackup(s);
+        })
       )
     );
   }
+  /** Mirror current memory content to the persistent backup directory. */
+  async mirrorBackup(scope) {
+    if (!this.persistBackup || scope === "project-agents") return;
+    try {
+      const content = await this.backend.readAll(scope, this.files[scope]);
+      const { writeFile: writeFile11, mkdir: mkdir17 } = await import('fs/promises');
+      await mkdir17(this.backupDir, { recursive: true });
+      await writeFile11(`${this.backupDir}/${scope}.md`, content, "utf8");
+    } catch {
+    }
+  }
 };
 function labelOf(scope) {
   switch (scope) {
@@ -7085,7 +7362,10 @@ function attachTodosCheckpoint(state, filePath, sessionId) {
   let pending = null;
   let writeChain = Promise.resolve();
   const enqueueWrite = (todos) => {
-    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos));
+    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos)).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[TodosCheckpoint] save failed for session ${sessionId}: ${msg}`);
+    });
     return writeChain;
   };
   const flush = () => {
@@ -7389,7 +7669,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   }
   const lock = {
     pid: processId,
-    hostname: __require("os").hostname(),
+    hostname: hostname(),
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
@@ -8611,12 +8891,6 @@ var IntelligentCompactor = class {
 };
 
 // src/models/llm-selector.ts
-function expectDefined11(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
 
 Output a JSON object with this structure:
@@ -8657,7 +8931,7 @@ function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
   for (let i = 0; i < messages.length; i++) {
-    const m = expectDefined11(messages[i]);
+    const m = expectDefined(messages[i]);
     const role = m.role.padEnd(10, " ");
     let text;
     if (typeof m.content === "string") {
@@ -8722,7 +8996,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let tokenCount = 0;
     let startIdx = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
-      const m = expectDefined11(messages[i]);
+      const m = expectDefined(messages[i]);
       const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
         (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
         0
@@ -10010,8 +10284,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink13 } = await import('fs/promises');
-      await unlink13(this.goalPath);
+      const { unlink: unlink14 } = await import('fs/promises');
+      await unlink14(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -10390,15 +10664,7 @@ function makeAgentSubagentRunner(opts) {
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
-        err.decision.then((decision) => {
-          if (decision === "stop") {
-            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-            aborter.abort();
-          }
-        }).catch(() => {
-          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-          aborter.abort();
-        });
+        budgetError = err;
         return;
       }
       aborter.abort();
@@ -10506,15 +10772,23 @@ function makeAgentSubagentRunner(opts) {
     }
     if (budgetError) {
       if ("decision" in budgetError) {
-        const decision = await budgetError.decision;
-        if (decision === "stop") {
+        try {
+          const decision = await budgetError.decision;
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(
+              budgetError.kind,
+              budgetError.limit,
+              budgetError.used
+            );
+          } else {
+            budgetError = null;
+          }
+        } catch {
           budgetError = new BudgetExceededError(
             budgetError.kind,
             budgetError.limit,
             budgetError.used
           );
-        } else {
-          budgetError = null;
         }
       }
       if (budgetError) throw budgetError;
@@ -14010,12 +14284,6 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/execution/parallel-eternal-engine.ts
-function expectDefined12(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
@@ -14171,7 +14439,7 @@ var ParallelEternalEngine = class {
   // Fan-out
   // -------------------------------------------------------------------------
   async fanOut(goal, tasks) {
-    const coordinator = expectDefined12(this.coordinator);
+    const coordinator = expectDefined(this.coordinator);
     const slotCount = Math.min(this.slots, tasks.length);
     const routes = this.dispatchEnabled ? await Promise.all(
       tasks.slice(0, slotCount).map(
@@ -14203,7 +14471,7 @@ ${recentJournal}` : "No prior iterations.",
     const routeInfo = [];
     const spawnPromises = [];
     for (let i = 0; i < slotCount; i++) {
-      const task = expectDefined12(tasks[i]);
+      const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
       const taskId = randomUUID();
@@ -14562,6 +14830,7 @@ var CollabSession = class extends EventEmitter {
   settled = false;
   timeoutMs;
   cancelled = false;
+  _raceResolved = false;
   alerts = [];
   snapshotWarnings = [];
   /** Tracks tool call counts per subagent for progress-based timeout decisions. */
@@ -14658,7 +14927,7 @@ var CollabSession = class extends EventEmitter {
    * Safe to call multiple times (idempotent after first call).
    */
   cancel(reason = "Director cancelled collab session") {
-    if (this.settled) return;
+    if (this.cancelled) return;
     this.cancelled = true;
     if (this._timeoutTimer) {
       clearTimeout(this._timeoutTimer);
@@ -14696,6 +14965,7 @@ var CollabSession = class extends EventEmitter {
     this.subagentIds.set("critic", criticId);
     const timeout = new Promise((_, reject) => {
       this._timeoutTimer = setTimeout(() => {
+        if (this._raceResolved) return;
         this.cancel("Session-level timeout reached");
         reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
       }, this.timeoutMs);
@@ -14711,6 +14981,7 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      this._raceResolved = true;
       if (this._timeoutTimer) {
         clearTimeout(this._timeoutTimer);
         this._timeoutTimer = void 0;
@@ -14725,6 +14996,7 @@ var CollabSession = class extends EventEmitter {
     }
     this.snapshotWarnings = await this.checkSnapshotFreshness();
     const report = this.assembleReport();
+    this._raceResolved = true;
     this.cleanup();
     this.emit("session.done", report);
     return report;
@@ -18790,12 +19062,6 @@ var TaskGraphStore = class {
 };
 
 // src/sdd/spec-builder.ts
-function expectDefined13(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -18841,7 +19107,7 @@ function buildQuestioningPrompt(session, min, max) {
   if (answered > 0) {
     lines.push("", "**Conversation so far:**");
     for (let i = 0; i < answered; i++) {
-      const a = expectDefined13(session.answers[i]);
+      const a = expectDefined(session.answers[i]);
       lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
     }
   }
@@ -19583,12 +19849,6 @@ function truncate2(str, maxLen) {
 }
 
 // src/sdd/critical-path.ts
-function expectDefined14(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -19664,7 +19924,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = expectDefined14(queue.shift());
+    const current = expectDefined(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -19710,7 +19970,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = expectDefined14(allIds[0]);
+  let maxId = expectDefined(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id) ?? 0;
     if (d > maxDist) {
@@ -20179,12 +20439,6 @@ var SddTaskDecomposer = class {
     return nodes.some((n) => n.status === "blocked");
   }
 };
-function expectDefined15(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var SddParallelRun = class {
   constructor(opts) {
     this.opts = opts;
@@ -20333,8 +20587,8 @@ var SddParallelRun = class {
     const successCount = results.filter((r) => r.status === "success").length;
     const failCount = results.length - successCount;
     for (let i = 0; i < results.length; i++) {
-      const result = expectDefined15(results[i]);
-      const taskId = expectDefined15(taskIds[i]);
+      const result = expectDefined(results[i]);
+      const taskId = expectDefined(taskIds[i]);
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
       } else {
@@ -21441,12 +21695,6 @@ var allServers = () => ({
   "zai-vision": { ...zaiVisionServer(), enabled: false },
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
-function expectDefined16(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function parseSkillRef(input) {
   const trimmed = input.trim().replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
   const atIdx = trimmed.indexOf("@");
@@ -21463,7 +21711,7 @@ function parseSkillRef(input) {
   if (parts.length < 2) {
     throw new Error(`Invalid skill reference "${input}". Expected format: user/repo or user/repo@ref`);
   }
-  return { owner: expectDefined16(parts[0]), repo: expectDefined16(parts[1]), ref };
+  return { owner: expectDefined(parts[0]), repo: expectDefined(parts[1]), ref };
 }
 var MAX_TARBALL_SIZE = 50 * 1024 * 1024;
 async function downloadGitHubTarball(parsed) {
@@ -21632,12 +21880,6 @@ var SkillManifestStore = class {
 };
 
 // src/skills/skill-installer.ts
-function expectDefined17(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var MAX_SKILL_FILE_SIZE = 100 * 1024;
 var SkillInstaller = class {
   opts;
@@ -21762,7 +22004,7 @@ var SkillInstaller = class {
       bySource.get(key)?.push(entry);
     }
     for (const [, entries] of bySource) {
-      const first = expectDefined17(entries[0]);
+      const first = expectDefined(entries[0]);
       const scope = first.scope;
       const isGlobal = scope === "user";
       try {
@@ -21929,15 +22171,387 @@ async function collectFiles(dir, baseDir2) {
   }
   return results;
 }
+var GraphMemoryBackend = class {
+  kind = "graph";
+  file;
+  graphFile;
+  // In-memory graph state — lazily loaded, saved on mutation.
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  loadedScope = null;
+  loaded = false;
+  constructor(opts) {
+    this.file = new FileMemoryBackend({ paths: opts.paths });
+    this.graphFile = opts.graphPath ?? `${opts.paths.projectDir}/memory-graph.json`;
+  }
+  // ── Backend interface ──────────────────────────────────────────────
+  async remember(scope, entry, filePath) {
+    await this.file.remember(scope, entry, filePath);
+    await this.loadGraph(scope);
+    const nodeId = this.nodeId(entry);
+    const existing = this.nodes.get(nodeId);
+    if (existing) {
+      existing.count++;
+      existing.entry = entry;
+      existing.type = entry.type;
+      existing.tags = entry.tags;
+      existing.priority = entry.priority;
+    } else {
+      this.nodes.set(nodeId, {
+        id: nodeId,
+        entry,
+        firstSeen: entry.ts,
+        count: 1,
+        type: entry.type,
+        tags: entry.tags,
+        priority: entry.priority
+      });
+      for (const [, other] of this.nodes) {
+        if (other.id === nodeId) continue;
+        const sim = wordOverlap(entry.text, other.entry.text);
+        const tagSim = sharedTags(entry.tags ?? [], other.tags ?? []);
+        const weight = Math.max(sim, tagSim * 0.5);
+        if (weight > 0.15) {
+          this.edges.push({
+            from: nodeId,
+            to: other.id,
+            relation: sim >= tagSim ? "similar" : "same_turn",
+            weight,
+            ts: entry.ts
+          });
+        }
+      }
+    }
+    await this.saveGraph(scope);
+  }
+  async forget(scope, query, filePath) {
+    const removed = await this.file.forget(scope, query, filePath);
+    if (removed > 0) {
+      await this.loadGraph(scope);
+      const n = query.toLowerCase();
+      const toRemove = [];
+      for (const [id, node] of this.nodes) {
+        if (node.entry.text.toLowerCase().includes(n)) {
+          toRemove.push(id);
+        }
+      }
+      for (const id of toRemove) this.nodes.delete(id);
+      this.edges = this.edges.filter((e) => !toRemove.includes(e.from) && !toRemove.includes(e.to));
+      await this.saveGraph(scope);
+    }
+    return removed;
+  }
+  async readAll(scope, filePath) {
+    return this.file.readAll(scope, filePath);
+  }
+  async list(scope, filePath, limit) {
+    await this.loadGraph(scope);
+    const fileEntries = await this.file.list(scope, filePath);
+    const nodeMap = new Map(this.nodes.entries());
+    const enriched = fileEntries.map((fe) => {
+      const nodeId = this.nodeId(fe);
+      const node = nodeMap.get(nodeId);
+      if (node) {
+        return {
+          ...fe,
+          type: node.type ?? fe.type,
+          tags: node.tags ?? fe.tags,
+          priority: node.priority ?? fe.priority
+        };
+      }
+      return fe;
+    });
+    const fileIds = new Set(fileEntries.map((e) => this.nodeId(e)));
+    for (const [id, node] of this.nodes) {
+      if (!fileIds.has(id)) {
+        enriched.push(node.entry);
+      }
+    }
+    enriched.sort((a, b) => b.ts.localeCompare(a.ts));
+    return limit ? enriched.slice(0, limit) : enriched;
+  }
+  async search(scope, query, filePath, limit) {
+    await this.loadGraph(scope);
+    const needle = query.toLowerCase().split(/\s+/);
+    const all = await this.list(scope, filePath);
+    const scored = all.map((entry) => {
+      const words = entry.text.toLowerCase().split(/\s+/);
+      let score = 0;
+      for (const n of needle) {
+        if (words.some((w) => w.includes(n))) score += 1;
+        if (entry.tags?.some((t2) => t2.toLowerCase().includes(n))) score += 2;
+      }
+      const node = this.nodes.get(this.nodeId(entry));
+      if (node) {
+        if (node.priority === "critical") score += 3;
+        else if (node.priority === "high") score += 2;
+        score += node.count * 0.5;
+      }
+      return { entry, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const matched = scored.filter((s) => s.score > 0).map((s) => s.entry);
+    return limit ? matched.slice(0, limit) : matched;
+  }
+  async clear(scope, filePath) {
+    await this.file.clear(scope, filePath);
+    this.nodes.clear();
+    this.edges = [];
+    this.loadedScope = scope;
+    this.loaded = true;
+    try {
+      await fsp3.unlink(this.graphFile);
+    } catch {
+    }
+  }
+  async consolidate(scope, filePath) {
+    return this.file.consolidate(scope, filePath);
+  }
+  // ── Graph-specific queries ─────────────────────────────────────────
+  /**
+   * Find memories related to the given entry, ordered by edge weight.
+   */
+  async findRelated(scope, _filePath, entryText, limit = 5) {
+    await this.loadGraph(scope);
+    const targetId = this.nodeId({ scope, text: entryText, ts: "" });
+    const related = this.edges.filter((e) => e.from === targetId || e.to === targetId).sort((a, b) => b.weight - a.weight).slice(0, limit);
+    const result = [];
+    for (const edge of related) {
+      const otherId = edge.from === targetId ? edge.to : edge.from;
+      const node = this.nodes.get(otherId);
+      if (node) result.push(node.entry);
+    }
+    return result;
+  }
+  /**
+   * Get all edges for visualization or traversal.
+   */
+  getGraph() {
+    return {
+      nodes: [...this.nodes.values()],
+      edges: [...this.edges]
+    };
+  }
+  // ── Persistence ────────────────────────────────────────────────────
+  nodeId(entry) {
+    const norm = entry.text.toLowerCase().trim().replace(/\s+/g, " ");
+    return `${entry.scope ?? "mem"}::${simpleHash(norm)}`;
+  }
+  async loadGraph(scope) {
+    if (this.loaded && this.loadedScope === scope) return;
+    try {
+      const raw = await fsp3.readFile(this.graphFile, "utf8");
+      const data = JSON.parse(raw);
+      this.nodes = new Map(data.nodes);
+      this.edges = data.edges;
+    } catch {
+      this.nodes = /* @__PURE__ */ new Map();
+      this.edges = [];
+    }
+    this.loadedScope = scope;
+    this.loaded = true;
+  }
+  async saveGraph(scope) {
+    this.loadedScope = scope;
+    this.loaded = true;
+    try {
+      const data = {
+        nodes: [...this.nodes.entries()],
+        edges: this.edges
+      };
+      await fsp3.mkdir(
+        this.graphFile.substring(0, this.graphFile.lastIndexOf("/")),
+        { recursive: true }
+      );
+      const tmp = `${this.graphFile}.tmp`;
+      await fsp3.writeFile(tmp, JSON.stringify(data));
+      await fsp3.rename(tmp, this.graphFile);
+    } catch {
+    }
+  }
+};
+function wordOverlap(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  return intersection / Math.max(wordsA.size, wordsB.size);
+}
+function sharedTags(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const setB = new Set(b);
+  let shared = 0;
+  for (const t2 of a) if (setB.has(t2)) shared++;
+  return shared / Math.max(a.length, b.length);
+}
+function simpleHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return Math.abs(h).toString(36);
+}
+
+// src/storage/memory-consolidator.ts
+function buildConsolidationPrompt(finalText, iterations, existingEntries) {
+  const existingBlock = existingEntries.length > 0 ? `
+
+Existing memory entries:
+${existingEntries.map((e) => `- [${e.ts.slice(0, 10)}] ${e.text}`).join("\n")}` : "";
+  return `You are a memory consolidator. Review the following session summary and decide what key facts, conventions, decisions, or learnings should be persisted to long-term memory.
+
+Session summary (${iterations} iterations):
+${finalText.slice(0, 3e3)}${existingBlock}
+
+Return a JSON object with an "operations" array. Each operation must have an "action" field:
+- "add": create a new memory entry. Include "text", and optionally "type", "tags", "priority".
+- "edit": replace an existing entry. Include "query" (to match) and "text" (replacement).
+- "delete": remove an entry. Include "query" (to match).
+
+Memory types:
+- "fact": Objective truth about the project (e.g. "uses pnpm workspaces")
+- "decision": A choice that was made (e.g. "decided to use biome over eslint")
+- "convention": A recurring pattern or standard (e.g. "commit messages use conventional format")
+- "preference": User or team preference (e.g. "prefers short variable names")
+- "reference": Pointer to a file or location (e.g. "auth logic in packages/core/src/auth/")
+- "anti_pattern": Something to avoid (e.g. "never use any in TypeScript")
+
+Priority levels:
+- "critical": Must always be known (e.g. security constraints)
+- "high": Important for most tasks
+- "medium": Useful context
+- "low": Nice to know
+
+Rules:
+- Only persist facts likely useful across multiple future sessions.
+- Do NOT persist task progress, temporary state, or one-off observations.
+- Prefer "add" over "edit" unless the existing entry is clearly outdated.
+- Assign a type and priority to every "add" operation.
+- Use 1-3 hashtag tags for each entry (e.g. #typescript #build).
+- Be concise \u2014 each memory entry should be one clear sentence.
+
+Return ONLY valid JSON, no markdown, no explanation:
+{
+  "operations": [
+    { 
+      "action": "add", 
+      "text": "Project uses pnpm workspaces with TypeScript strict mode",
+      "type": "convention",
+      "priority": "high",
+      "tags": ["pnpm", "typescript", "build"]
+    },
+    { 
+      "action": "edit", 
+      "query": "pnpm", 
+      "text": "Project uses pnpm v9+ with ESM-only modules",
+      "type": "fact",
+      "priority": "medium"
+    },
+    { "action": "delete", "query": "outdated convention" }
+  ]
+}`;
+}
+var SessionMemoryConsolidator = class {
+  name = "session-memory-consolidator";
+  owner = "core";
+  memoryStore;
+  provider;
+  model;
+  minIterations;
+  maxExistingEntries;
+  constructor(opts) {
+    this.memoryStore = opts.memoryStore;
+    this.provider = opts.provider;
+    this.model = opts.model;
+    this.minIterations = opts.minIterations ?? 2;
+    this.maxExistingEntries = opts.maxExistingEntries ?? 15;
+  }
+  afterRun = async (ctx, result) => {
+    if (result.status !== "done") return;
+    if (!result.finalText || result.finalText.trim().length < 20) return;
+    if (result.iterations < this.minIterations) return;
+    const provider = this.provider ?? ctx.provider;
+    if (!provider || !provider.complete) return;
+    try {
+      const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+      const prompt = buildConsolidationPrompt(
+        result.finalText,
+        result.iterations,
+        existingEntries
+      );
+      const signal = AbortSignal.timeout(15e3);
+      const response = await provider.complete(
+        {
+          model: this.model ?? ctx.model,
+          system: [{ type: "text", text: prompt }],
+          messages: [
+            { role: "user", content: "Review the session and return memory operations as JSON." }
+          ],
+          maxTokens: 500
+        },
+        { signal }
+      );
+      const 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;
+      let edited = 0;
+      let deleted = 0;
+      for (const op of parsed.operations) {
+        switch (op.action) {
+          case "add": {
+            if (op.text && op.text.trim()) {
+              await this.memoryStore.remember(op.text.trim(), void 0, {
+                type: op.type,
+                tags: op.tags,
+                priority: op.priority
+              });
+              added++;
+            }
+            break;
+          }
+          case "edit": {
+            if (op.query && op.text && op.text.trim()) {
+              await this.memoryStore.forget(op.query);
+              await this.memoryStore.remember(op.text.trim(), void 0, {
+                type: op.type,
+                tags: op.tags,
+                priority: op.priority
+              });
+              edited++;
+            }
+            break;
+          }
+          case "delete": {
+            if (op.query) {
+              const n = await this.memoryStore.forget(op.query);
+              deleted += n;
+            }
+            break;
+          }
+        }
+      }
+      if (added > 0 || edited > 0 || deleted > 0) {
+        const parts = [];
+        if (added) parts.push(`${added} added`);
+        if (edited) parts.push(`${edited} edited`);
+        if (deleted) parts.push(`${deleted} deleted`);
+        process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
+`);
+      }
+    } catch {
+    }
+  };
+};
 
 // src/storage/annotations-store.ts
 init_atomic_write();
-function expectDefined18(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
 var MAX_ANNOTATIONS = 1e3;
@@ -22030,7 +22644,7 @@ var AnnotationsStore = class {
           return;
         }
         const next = {
-          ...expectDefined18(all[idx]),
+          ...expectDefined(all[idx]),
           resolved: true,
           resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
           resolvedBy: input.resolvedBy
@@ -22268,12 +22882,6 @@ var ReplayLogStore = class {
     return next;
   }
 };
-function expectDefined19(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var SessionRecovery = class {
   constructor(dir) {
     this.dir = dir;
@@ -22314,7 +22922,7 @@ var SessionRecovery = class {
       const lines = raw.split("\n").filter((l) => l.trim());
       for (let i = lines.length - 1; i >= 0; i--) {
         try {
-          const ev = JSON.parse(expectDefined19(lines[i]));
+          const ev = JSON.parse(expectDefined(lines[i]));
           if (ev.type === "in_flight_start") {
             return {
               sessionId,
@@ -22367,12 +22975,12 @@ var SessionRecovery = class {
     let lastCheckpointIdx = -1;
     for (let i = 0; i < events.length; i++) {
       if (events[i]?.type === "checkpoint") {
-        lastCheckpoint = expectDefined19(events[i]);
+        lastCheckpoint = expectDefined(events[i]);
         lastCheckpointIdx = i;
       }
     }
     const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
-    const lastEv = expectDefined19(events[events.length - 1]);
+    const lastEv = expectDefined(events[events.length - 1]);
     const inFlightStart = lastEv.type === "in_flight_start" ? lastEv : null;
     const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
     return {
@@ -22418,12 +23026,6 @@ var SessionRecovery = class {
 
 // src/storage/tool-audit-log.ts
 init_atomic_write();
-function expectDefined20(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
@@ -22504,7 +23106,7 @@ var ToolAuditLog = class {
     }
     let prevHash = GENESIS_PREV;
     for (let i = 0; i < entries.length; i++) {
-      const e = expectDefined20(entries[i]);
+      const e = expectDefined(entries[i]);
       if (e.prevHash !== prevHash) {
         return {
           ok: false,
@@ -22624,12 +23226,6 @@ function sortKeys2(value) {
 
 // src/storage/session-rewinder.ts
 init_atomic_write();
-function expectDefined21(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
@@ -22668,7 +23264,7 @@ var DefaultSessionRewinder = class {
     const events = parseEvents(raw);
     let targetIdx = -1;
     for (let i = 0; i < events.length; i++) {
-      const event = expectDefined21(events[i]);
+      const event = expectDefined(events[i]);
       if (event.type === "checkpoint") {
         const checkpointEvent = event;
         if (checkpointEvent.promptIndex === checkpointIndex) {
@@ -22682,7 +23278,7 @@ var DefaultSessionRewinder = class {
     }
     const snapshotsToRevert = [];
     for (let i = targetIdx + 1; i < events.length; i++) {
-      const event = expectDefined21(events[i]);
+      const event = expectDefined(events[i]);
       if (event.type === "checkpoint") {
         break;
       }
@@ -22864,12 +23460,6 @@ var DefaultPromptStore = class {
     };
   }
 };
-function expectDefined22(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
   constructor(paths, getConfig, setConfig) {
@@ -22912,8 +23502,8 @@ var CloudSync = class {
     const cfg = this.getConfig();
     if (!cfg?.enabled) return { ok: false, action: "push", categories: [], message: "Not enabled." };
     const parts = cfg.repo.split("/");
-    const owner = expectDefined22(parts[0]);
-    const repoName = expectDefined22(parts[1]);
+    const owner = expectDefined(parts[0]);
+    const repoName = expectDefined(parts[1]);
     const branch = "main";
     const baseTreeSha = this.state?.sha;
     const { treeEntries, rev } = await this.buildLocalTree(cfg.categories);
@@ -22965,8 +23555,8 @@ var CloudSync = class {
     const cfg = this.getConfig();
     if (!cfg?.enabled) return { ok: false, action: "pull", categories: [], message: "Not enabled." };
     const pullParts = cfg.repo.split("/");
-    const owner = expectDefined22(pullParts[0]);
-    const repoName = expectDefined22(pullParts[1]);
+    const owner = expectDefined(pullParts[0]);
+    const repoName = expectDefined(pullParts[1]);
     const branchData = await this.getRef(token, owner, repoName, "main");
     const currentSha = branchData.object.sha;
     const commitData = await this.getCommit(token, owner, repoName, currentSha);
@@ -24064,8 +24654,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir16 } = await import('fs/promises');
-      await mkdir16(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir17 } = await import('fs/promises');
+      await mkdir17(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -24312,12 +24902,6 @@ var defaultGitignoreUpdater = new GitignoreUpdater();
 
 // src/security-scanner/orchestrator.ts
 init_atomic_write();
-function expectDefined23(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var SecurityScannerOrchestrator = class {
   constructor(retryPolicy, errorHandler) {
     this.retryPolicy = retryPolicy;
@@ -24367,7 +24951,7 @@ var SecurityScannerOrchestrator = class {
     if (detectionResult.detectedStacks.length === 0) {
       throw new Error(`No supported tech stack detected in ${projectRoot}`);
     }
-    const techStack = expectDefined23(detectionResult.detectedStacks[0]);
+    const techStack = expectDefined(detectionResult.detectedStacks[0]);
     const generatedSkill = await this.generateSkillLLM(provider, model, projectRoot, techStack);
     const scanResult = await this.scanWithLLM(provider, model, projectRoot, generatedSkill, techStack, options);
     const synthesizedReport = await this.synthesizeReportLLM(provider, model, projectRoot, techStack, scanResult);
@@ -24448,7 +25032,7 @@ Return ONLY the JSON object, no markdown, no explanation.`;
       const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
       const jsonMatch = text.match(/\{[\s\S]*\}/);
       if (jsonMatch) {
-        const sanitized = sanitizeJsonString(expectDefined23(jsonMatch[0])) || expectDefined23(jsonMatch[0]);
+        const sanitized = sanitizeJsonString(expectDefined(jsonMatch[0])) || expectDefined(jsonMatch[0]);
         const skillData = JSON.parse(sanitized);
         return {
           name: skillData.name || `security-scanner-${techStack.stack}`,
@@ -24568,7 +25152,7 @@ Return ONLY the JSON array. If no issues found, return [].`;
       const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
       const jsonMatch = text.match(/\[[\s\S]*\]/);
       if (jsonMatch) {
-        const sanitized = sanitizeJsonString(expectDefined23(jsonMatch[0])) || expectDefined23(jsonMatch[0]);
+        const sanitized = sanitizeJsonString(expectDefined(jsonMatch[0])) || expectDefined(jsonMatch[0]);
         const parsed = JSON.parse(sanitized);
         return parsed.map((item, idx) => ({
           id: `llm-finding-${idx}-${Date.now()}`,
@@ -24808,7 +25392,7 @@ ${dirs.join(", ")}`);
     if (detectionResult.detectedStacks.length === 0) {
       throw new Error(`No supported tech stack detected in ${projectRoot}`);
     }
-    const techStack = expectDefined23(detectionResult.detectedStacks[0]);
+    const techStack = expectDefined(detectionResult.detectedStacks[0]);
     return {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       projectRoot,
@@ -24997,16 +25581,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile38 } = await import('fs/promises');
-      const content = await readFile38(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile39 } = await import('fs/promises');
+      const content = await readFile39(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile38 } = await import('fs/promises');
-      const content = await readFile38(join(reportsDir, match), "utf-8");
+      const { readFile: readFile39 } = await import('fs/promises');
+      const content = await readFile39(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -25416,12 +26000,6 @@ var FleetManager = class {
     this.usage.dispose();
   }
 };
-function expectDefined24(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function createMcpControlTool(opts) {
   const { getConfig, configPath, registry } = opts;
   const inputSchema = {
@@ -25573,7 +26151,7 @@ async function runDisable(name, deps) {
   const mcpServers = {
     ...full.mcpServers ?? {}
   };
-  const existing = expectDefined24(mcpServers[name]);
+  const existing = expectDefined(mcpServers[name]);
   mcpServers[name] = { ...existing, enabled: false };
   full.mcpServers = mcpServers;
   await writeConfig(deps.configPath, full);
@@ -25644,12 +26222,6 @@ function badge(state) {
 }
 
 // src/extension/registry.ts
-function expectDefined25(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var ExtensionRegistry = class {
   extensions = [];
   promptContributors = [];
@@ -25815,7 +26387,7 @@ var ExtensionRegistry = class {
    * default runner, each subsequent wrapper wraps the previous.
    */
   wrapProviderRunner(inner) {
-    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner).map((e) => ({ name: e.name, wrap: expectDefined25(e.wrapProviderRunner) }));
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner).map((e) => ({ name: e.name, wrap: expectDefined(e.wrapProviderRunner) }));
     if (wrappers.length === 0) return inner;
     let composed = inner;
     for (let i = wrappers.length - 1; i >= 0; i--) {
@@ -26832,6 +27404,7 @@ async function bootConfig(options = {}) {
   await fsp3.mkdir(wpaths.projectDir, { recursive: true });
   await fsp3.mkdir(wpaths.projectSessions, { recursive: true });
   await writeProjectMeta(wpaths, projectRoot);
+  await ensureGitignore(projectRoot);
   cleanupStaleProjects(wpaths).catch(() => {
   });
   const vault = new DefaultSecretVault({ keyFile: wpaths.secretsKey });
@@ -26907,6 +27480,22 @@ async function writeProjectMeta(paths, projectRoot) {
   } catch {
   }
 }
+var GITIGNORE_ENTRY = ".wrongstack/\n";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path6.join(projectRoot, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await fsp3.readFile(gitignorePath, "utf8");
+    } catch {
+    }
+    if (!content.includes(".wrongstack")) {
+      const updated = content ? content.endsWith("\n") ? content + GITIGNORE_ENTRY : content + "\n" + GITIGNORE_ENTRY : GITIGNORE_ENTRY;
+      await fsp3.writeFile(gitignorePath, updated, "utf8");
+    }
+  } catch {
+  }
+}
 async function cleanupStaleProjects(wpaths) {
   const projectsRoot = path6.dirname(wpaths.projectDir);
   let entries;
@@ -27344,7 +27933,10 @@ var DefaultSystemPromptBuilder = class {
   skillCache;
   /** Cached full skill bodies (after frontmatter), built once per session. */
   skillBodyCache;
+  /** Tools from last build — used for memory relevance scoring. */
+  _lastBuildTools;
   async build(ctx) {
+    this._lastBuildTools = ctx.tools;
     if (this.opts.skillLoader && !this.skillCache) {
       try {
         const entries = await this.opts.skillLoader.listEntries();
@@ -27648,10 +28240,31 @@ summarize it, and let the tool result hold only the summary.`);
     const parts = [];
     if (this.opts.memoryStore) {
       try {
-        const mem = await this.opts.memoryStore.readAll();
-        if (mem.trim()) parts.push(`# Project Memory
+        if (this.opts.memoryStore.scoreRelevant) {
+          const toolNames = this._lastBuildTools?.map((t2) => t2.name) ?? [];
+          const scored = await this.opts.memoryStore.scoreRelevant(
+            {
+              currentTask: "",
+              toolNames
+            },
+            "project-memory",
+            8
+          );
+          if (scored.length > 0) {
+            const lines = ["# Relevant Memory"];
+            for (const e of scored) {
+              const badge2 = e.type ? `[\`${e.type.replace("_", "-")}\`] ` : "";
+              const priorityMark = e.priority === "critical" ? "\u26A1" : e.priority === "high" ? "\u25B2" : "";
+              lines.push(`- ${priorityMark}${badge2}${e.text}${e.tags ? ` \`#${e.tags.join(" #")}\`` : ""}`);
+            }
+            parts.push(lines.join("\n"));
+          }
+        } else {
+          const mem = await this.opts.memoryStore.readAll();
+          if (mem.trim()) parts.push(`# Project Memory
 
 ${mem}`);
+        }
       } catch {
       }
     }
@@ -28538,20 +29151,28 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
 }
 
 // src/execution/prompt-enhancer.ts
-var ENHANCER_SYSTEM_PROMPT = `You are a request refiner embedded in a coding agent. Your ONLY job is to rewrite the user's message into a single, clearer, unambiguous instruction that the coding agent can act on confidently.
+var ENHANCER_SYSTEM_PROMPT = `You are a request refiner embedded in a coding agent. Your ONLY job is to rewrite the user's message into clearer, unambiguous instructions that the coding agent can act on confidently.
 
 Rules:
 - Preserve the user's intent and scope EXACTLY. Do not add new requirements, features, constraints, or steps the user did not ask for. Do not remove anything they did ask for.
 - Do NOT answer, solve, or perform the request. Only restate it more clearly.
 - Keep all concrete details verbatim: file paths, identifiers, code, error text, numbers, names, URLs.
 - Resolve obvious ambiguity by making the implied subject explicit, not by inventing specifics. If something is genuinely unspecified, leave it general rather than guessing.
-- Be concise: one tight instruction (a few sentences at most). No preamble, no explanation, no quotes, no markdown headers.
+- Be concise: one tight instruction per version (a few sentences at most). No preamble, no explanation, no quotes, no markdown headers.
 - If the message is already clear and complete, return it essentially unchanged.
-- Preserve the user's language (if they wrote in Turkish, refine in Turkish).
+
+You MUST output TWO versions of the refined request, separated by a line containing only "---".
+- First version: refined in the SAME LANGUAGE the user wrote in (if Turkish \u2192 Turkish, if Spanish \u2192 Spanish, etc.).
+- Second version: refined in ENGLISH (translate the intent into clear English while preserving all concrete details).
+
+Output format:
+<refined in user's language>
+---
+<refined in English>
 
 When earlier conversation turns are provided, they are CONTEXT ONLY. Use them to resolve references in the user's latest message \u2014 "it", "that", "the same", "the other one", "this file", "again" \u2014 so the refined instruction is self-contained. Refine ONLY the user's latest message; do not answer it, do not act on or restate earlier turns, and do not summarize the conversation.
 
-Output ONLY the refined request text \u2014 nothing else.`;
+Output ONLY the two versions separated by "---" \u2014 nothing else.`;
 var AFFIRMATION_RE = /^(y|n|yes|no|yep|nope|ok|okay|sure|go|go ahead|continue|proceed|stop|cancel|done|next|skip|retry|again|please do|do it)\b[.! ]*$/i;
 function shouldEnhance(text) {
   const t2 = text.trim();
@@ -28598,12 +29219,23 @@ async function enhanceUserPrompt(opts) {
   const signal = opts.signal ? AbortSignal.any([opts.signal, timer.signal]) : timer.signal;
   try {
     const res = await provider.complete(req, { signal });
-    const refined = res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim();
-    if (!refined) {
+    const raw = res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim();
+    if (!raw) {
       opts.onError?.("model returned no text");
       return null;
     }
-    return refined;
+    const sepIdx = raw.indexOf("\n---\n");
+    if (sepIdx === -1) {
+      opts.onError?.("model did not produce two versions");
+      return { refined: raw, english: raw };
+    }
+    const refined = raw.slice(0, sepIdx).trim();
+    const english = raw.slice(sepIdx + 5).trim();
+    if (!refined || !english) {
+      opts.onError?.("one or both versions empty");
+      return null;
+    }
+    return { refined, english };
   } catch (err) {
     if (opts.signal?.aborted) return null;
     if (timer.signal.aborted) {
@@ -28706,8 +29338,8 @@ var PhaseGraphBuilder = class _PhaseGraphBuilder {
     return graph;
   }
   /**
-   * Var olan bir TaskGraph'tan fazlar oluştur.
-   * Task'ları priority/type göre gruplayarak fazlara ayırır.
+   * Create phases from an existing TaskGraph.
+   * Groups tasks into phases by priority and type.
    */
   static fromTaskGraph(taskGraph, options) {
     const tasksPerPhase = options.tasksPerPhase ?? 5;
@@ -28785,8 +29417,8 @@ var PhaseOrchestrator = class {
   }
   // ─── Lifecycle ────────────────────────────────────────────────────────────
   /**
-   * Tüm faz akışını başlat.
-   * Autonomous mode'da: kök faz(lar)ı başlatır, bitince sonrakini otomatik başlatır.
+   * Start the full phase flow.
+   * In autonomous mode, starts root phases and automatically starts the next phase when they finish.
    */
   async start() {
     this.stopped = false;
@@ -28813,17 +29445,17 @@ var PhaseOrchestrator = class {
       this.tickInterval = setInterval(() => this.tick(), 1e3);
     }
   }
-  /** Bekleyen tüm faz merge'lerini (dep-sıralı + global seri) bekle. */
+  /** Wait for all pending phase merges, dependency-ordered and globally serialized. */
   async drainMerges() {
     await Promise.allSettled([...this.phaseMergePromise.values()]);
     await this.mergeQueue.catch(() => {
     });
   }
-  /** Duraklat — aktif fazlar çalışmaya devam eder ama yeni faz başlamaz */
+  /** Pause: active phases continue, but no new phase starts. */
   pause() {
     this.paused = true;
   }
-  /** Devam et — yeni fazlar başlayabilir */
+  /** Resume: new phases may start again. */
   resume() {
     this.paused = false;
     this.tick().catch((err) => {
@@ -28833,7 +29465,7 @@ var PhaseOrchestrator = class {
       );
     });
   }
-  /** Tamamen durdur — aktif fazlar da durdurulur */
+  /** Stop completely, including active phases. */
   stop() {
     this.stopped = true;
     if (this.tickInterval) {
@@ -29031,7 +29663,10 @@ var PhaseOrchestrator = class {
     const depPromises = phase.dependsOn.map((d) => this.phaseMergePromise.get(d)).filter((p) => Boolean(p));
     const merged = (async () => {
       await Promise.allSettled(depPromises);
-      this.mergeQueue = this.mergeQueue.then(() => this.mergeOne(phase, handle));
+      this.mergeQueue = this.mergeQueue.then(() => this.mergeOne(phase, handle)).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[PhaseOrchestrator] mergeOne failed for phase ${phase.id}: ${msg}`);
+      });
       await this.mergeQueue;
     })();
     this.phaseMergePromise.set(phase.id, merged);
@@ -29583,14 +30218,14 @@ var AutoPhasePlanner = class {
     this.opts = opts;
   }
   opts;
-  /** Hedefi faz+todo planına dönüştür. */
+  /** Convert the goal into a phase-and-todo plan. */
   async plan() {
     const prompt = this.buildPrompt();
     const raw = await this.opts.runOnce(prompt);
     const phases = this.parse(raw);
     return { phases, raw, parseFailed: phases.length === 0 };
   }
-  /** Modelin üreteceği plan için talimat prompt'u. */
+  /** Instruction prompt for the plan the model should produce. */
   buildPrompt() {
     const minP = this.opts.minPhases ?? 3;
     const maxP = this.opts.maxPhases ?? 8;
@@ -29638,7 +30273,7 @@ ${ctx}
       "```"
     ].filter((l) => l !== "").join("\n");
   }
-  /** Ham çıktıdan JSON'u çıkar, doğrula ve PhaseTemplate[]'e dönüştür. */
+  /** Extract JSON from raw output, validate it, and convert it to PhaseTemplate[]. */
   parse(raw) {
     const json = extractJSONArray(raw);
     if (!json) return [];
@@ -30378,7 +31013,8 @@ ${check.stderr}`);
       const child = spawn(this.gitBin, args, {
         cwd,
         env: buildChildEnv(),
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", "pipe", "pipe"],
+        signal: AbortSignal.timeout(3e4)
       });
       child.stdout?.on("data", (c) => {
         stdout += c.toString();
@@ -30746,12 +31382,6 @@ var ReplayProviderRunner = class {
 };
 
 // src/plugins/prompts-plugin.ts
-function expectDefined26(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function createPromptsPlugin(opts) {
   let store = null;
   return {
@@ -30805,7 +31435,7 @@ ${lines.join("\n")}
           if (!restJoined) return { message: "Usage: /prompts view <title>" };
           const matches = await store.find(restJoined);
           if (matches.length === 0) return { message: `No prompt matching "${restJoined}".` };
-          const entry = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? expectDefined26(matches[0]);
+          const entry = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? expectDefined(matches[0]);
           const tags = entry.tags.length > 0 ? ` [${entry.tags.join(", ")}]` : "";
           return {
             message: `# ${entry.title}${tags}
@@ -30828,7 +31458,7 @@ ${dim2(`id: ${entry.id} | created: ${entry.createdAt}`)}`
           if (!restJoined) return { message: "Usage: /prompts delete <title>" };
           const matches = await store.find(restJoined);
           if (matches.length === 0) return { message: `No prompt matching "${restJoined}".` };
-          const exact = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? expectDefined26(matches[0]);
+          const exact = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? expectDefined(matches[0]);
           const deleted = await store.delete(exact.id);
           return { message: deleted ? `Deleted "${exact.title}".` : "Delete failed." };
         }
@@ -30838,7 +31468,7 @@ ${dim2(`id: ${entry.id} | created: ${entry.createdAt}`)}`
           if (!parsed.title) return { message: 'Usage: /prompts edit "title" "new content"' };
           const matches = await store.find(parsed.title);
           if (matches.length === 0) return { message: `No prompt matching "${parsed.title}".` };
-          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title?.toLowerCase()) ?? expectDefined26(matches[0]);
+          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title?.toLowerCase()) ?? expectDefined(matches[0]);
           exact.content = parsed.content;
           exact.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
           await store.save(exact);
@@ -30850,7 +31480,7 @@ ${dim2(`id: ${entry.id} | created: ${entry.createdAt}`)}`
           if (!parsed.title) return { message: 'Usage: /prompts extend "title" <instructions>' };
           const matches = await store.find(parsed.title);
           if (matches.length === 0) return { message: `No prompt matching "${parsed.title}".` };
-          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title?.toLowerCase()) ?? expectDefined26(matches[0]);
+          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title?.toLowerCase()) ?? expectDefined(matches[0]);
           const prov = ctx.provider;
           if (!prov?.complete) return { message: "LLM not available. Configure a provider first." };
           const enhanced = await prov.complete(ctx.model, [
@@ -30885,9 +31515,9 @@ function parseTitleContent(args) {
   const trimmed = args.trim();
   if (!trimmed) return { title: "", content: "" };
   const doubleMatch = /^"([^"]+)"\s+"([^"]+)"$/.exec(trimmed) || /^'([^']+)'\s+'([^']+)'$/.exec(trimmed);
-  if (doubleMatch) return { title: expectDefined26(doubleMatch[1]), content: expectDefined26(doubleMatch[2]) };
+  if (doubleMatch) return { title: expectDefined(doubleMatch[1]), content: expectDefined(doubleMatch[2]) };
   const singleMatch = /^'([^']+)'\s+(.+)$/.exec(trimmed);
-  if (singleMatch) return { title: expectDefined26(singleMatch[1]), content: expectDefined26(singleMatch[2]) };
+  if (singleMatch) return { title: expectDefined(singleMatch[1]), content: expectDefined(singleMatch[2]) };
   const firstSpace = trimmed.indexOf(" ");
   if (firstSpace === -1) return { title: trimmed, content: "" };
   return { title: trimmed.slice(0, firstSpace), content: trimmed.slice(firstSpace + 1) };
@@ -30898,12 +31528,6 @@ function dim2(s) {
 
 // src/plugins/sync-plugin.ts
 init_atomic_write();
-function expectDefined27(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function createSyncPlugin(opts) {
   let cloud = null;
   let configStore;
@@ -30977,7 +31601,7 @@ function buildSyncCommand(cloud, configStore, vault, syncConfigPath) {
           if (!repo || !repo.includes("/")) {
             return { message: 'Invalid repo format. Expected "owner/repo".' };
           }
-          const storedToken = vault ? vault.encrypt(expectDefined27(token)) : expectDefined27(token);
+          const storedToken = vault ? vault.encrypt(expectDefined(token)) : expectDefined(token);
           const syncConfig = {
             enabled: true,
             repo,
@@ -31118,7 +31742,7 @@ function createGitPlugin() {
 async function runGit(args, cwd) {
   try {
     return await new Promise((resolve13, reject) => {
-      const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], signal: AbortSignal.timeout(3e4) });
       let stdout = "";
       let stderr = "";
       child.stdout?.on("data", (d) => {
@@ -31843,6 +32467,6 @@ ${formatPlan(updated)}`
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BudgetExceededError, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionRecovery, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined7 as expectDefined, extractRunEnv, filesystemServer, findCriticalPath, flagsToConfigPatch, formatContextWindowModeList, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getPlanTemplate, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hashRequest, hookMatcherMatches, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseSkillRef, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveContextWindowPolicy, resolveModelMatrix, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BudgetExceededError, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GraphMemoryBackend, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MEMORY_TYPE_LABELS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined, extractRunEnv, filesystemServer, findCriticalPath, flagsToConfigPatch, formatContextWindowModeList, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getPlanTemplate, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hashRequest, hookMatcherMatches, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseSkillRef, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveContextWindowPolicy, resolveModelMatrix, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map