@wrongstack/core 0.89.1 → 0.104.0

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;
@@ -4459,13 +4442,116 @@ function formatTodosList(todos) {
   return lines.join("\n");
 }
 
-// src/utils/glob-match.ts
-function expectDefined6(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
+// src/utils/task-format.ts
+function computeTaskItemProgress(tasks) {
+  let completed = 0;
+  let pending = 0;
+  let inProgress = 0;
+  let blocked = 0;
+  let failed = 0;
+  let review = 0;
+  let estimatedHours = 0;
+  let actualHours = 0;
+  for (const t2 of tasks) {
+    switch (t2.status) {
+      case "completed":
+        completed++;
+        break;
+      case "pending":
+        pending++;
+        break;
+      case "in_progress":
+        inProgress++;
+        break;
+      case "blocked":
+        blocked++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "review":
+        review++;
+        break;
+    }
+    estimatedHours += t2.estimateHours ?? 0;
   }
-  return value;
+  return {
+    total: tasks.length,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0,
+    estimatedHours,
+    actualHours
+  };
+}
+var STATUS_ICON = {
+  pending: "\u25CB",
+  in_progress: "\u25D0",
+  blocked: "\u2298",
+  failed: "\u2717",
+  review: "\u25D1",
+  completed: "\u25CF"
+};
+var PRIORITY_ICON = {
+  critical: "\u{1F534}",
+  high: "\u{1F7E0}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F7E2}"
+};
+var TYPE_ICON = {
+  feature: "\u26A1",
+  bugfix: "\u{1F41B}",
+  refactor: "\u267B\uFE0F",
+  docs: "\u{1F4DD}",
+  test: "\u{1F9EA}",
+  chore: "\u{1F527}"
+};
+function formatTaskProgress(tasks) {
+  const p = computeTaskItemProgress(tasks);
+  if (p.total === 0) return "No tasks.";
+  const barWidth = 24;
+  const filled = Math.round(p.percentComplete / 100 * barWidth);
+  const empty = barWidth - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  return [
+    `${color.bold("Tasks")} [${bar}] ${p.percentComplete}%`,
+    `  ${color.green("\u25CF")} ${p.completed} done \u2502 ${color.yellow("\u25D0")} ${p.inProgress} active \u2502 ${color.dim("\u25CB")} ${p.pending} pending \u2502 \u2298 ${p.blocked} blocked \u2502 \u2717 ${p.failed} failed`,
+    p.estimatedHours > 0 ? `  ${color.dim(`est. ${p.estimatedHours}h`)}` : ""
+  ].filter(Boolean).join("\n");
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) return "No tasks.";
+  const order = ["in_progress", "blocked", "review", "pending", "failed", "completed"];
+  const groups = /* @__PURE__ */ new Map();
+  for (const t2 of tasks) {
+    const list = groups.get(t2.status) ?? [];
+    list.push(t2);
+    groups.set(t2.status, list);
+  }
+  const lines = [];
+  lines.push(color.dim(`Tasks (${tasks.length} total):`));
+  for (const status of order) {
+    const group = groups.get(status);
+    if (!group || group.length === 0) continue;
+    const icon = STATUS_ICON[status];
+    lines.push(`  ${icon} ${status.toUpperCase()} (${group.length})`);
+    for (const t2 of group) {
+      const prio = PRIORITY_ICON[t2.priority];
+      const type = TYPE_ICON[t2.type];
+      const deps = t2.dependsOn && t2.dependsOn.length > 0 ? ` ${color.dim("\u2190")} ${color.dim(t2.dependsOn.map((d) => d.slice(0, 8)).join(", "))}` : "";
+      const who = t2.assignee ? ` ${color.dim(`@${t2.assignee}`)}` : "";
+      const hrs = t2.estimateHours ? ` ${color.dim(`${t2.estimateHours}h`)}` : "";
+      lines.push(`    ${type} ${prio} ${t2.title}${deps}${who}${hrs}`);
+    }
+  }
+  return lines.join("\n");
 }
+
+// src/utils/glob-match.ts
 function escapeRegex(s) {
   return s.replace(/[.+^${}()|\\]/g, "\\$&");
 }
@@ -4477,7 +4563,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 +4923,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 +4936,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 +4975,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 +5040,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 +5051,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 +5147,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 +5857,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 +6152,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 +6386,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 +6435,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 +6443,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 remember(text, scope = "project-memory") {
+  async search(query, scope = "project-memory", limit) {
+    return this.backend.search(scope, query, this.files[scope], limit);
+  }
+  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 +7471,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 +7778,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 +9000,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 +9040,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 +9105,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
@@ -9405,6 +9788,14 @@ function emptyGoal(goal) {
     journal: []
   };
 }
+function setProgress(goal, progress, note) {
+  const clamped = Math.min(100, Math.max(0, progress));
+  return {
+    ...goal,
+    progress: clamped,
+    progressNote: note ?? clamped + "% complete"
+  };
+}
 function appendJournal(goal, entry) {
   const iteration = goal.iterations + 1;
   const at = (/* @__PURE__ */ new Date()).toISOString();
@@ -9433,34 +9824,110 @@ function summarizeUsage(goal) {
   }
   return { totalCostUsd, totalInputTokens, totalOutputTokens, iterationsWithUsage };
 }
+var DOLLAR = "$";
 function formatGoal(goal, journalLimit = 10) {
   const lines = [];
-  lines.push(`Goal: ${goal.goal}`);
-  lines.push(`Set: ${goal.setAt}`);
-  lines.push(`Last activity: ${goal.lastActivityAt}`);
-  lines.push(`Iterations: ${goal.iterations}`);
+  const displayGoal = goal.refinedGoal || goal.goal;
+  lines.push(color.bold("Goal") + ": " + displayGoal);
+  if (goal.refinedGoal && goal.refinedGoal !== goal.goal) {
+    const snippet = goal.goal.length > 60 ? goal.goal.slice(0, 60) + "\u2026" : goal.goal;
+    lines.push(color.dim('  (original: "' + snippet + '")'));
+  }
+  if (typeof goal.progress === "number") {
+    const pct = Math.min(100, Math.max(0, Math.round(goal.progress)));
+    const filled = Math.round(pct / 5);
+    const empty = 20 - filled;
+    const bar = color.green("\u2588".repeat(filled)) + color.dim("\u2591".repeat(empty));
+    lines.push("Progress: " + bar + " " + color.bold(pct + "%"));
+    if (goal.progressNote) {
+      lines.push("  " + color.dim(goal.progressNote));
+    }
+    if (goal.progressTrend) {
+      const trendIcon = goal.progressTrend === "accelerating" ? "\u{1F680}" : goal.progressTrend === "stalling" ? "\u26A0\uFE0F" : "\u27A1\uFE0F";
+      lines.push("  Trend: " + trendIcon + " " + goal.progressTrend);
+    }
+  }
+  if (goal.deliverables && goal.deliverables.length > 0) {
+    lines.push("");
+    lines.push(color.bold("Deliverables:"));
+    for (const d of goal.deliverables) {
+      const done = /^\[[x✓]\]|✅|\(done\)/i.test(d);
+      const marker = done ? color.green("\u2713") : color.dim("\u25CB");
+      lines.push("  " + marker + " " + d);
+    }
+  }
+  lines.push("");
+  lines.push("Set: " + goal.setAt);
+  lines.push("Last activity: " + goal.lastActivityAt);
+  lines.push("Iterations: " + goal.iterations);
   const stateLabel = goal.goalState ?? "active";
-  lines.push(`State: ${stateLabel}${goal.iterations > 0 ? ` (iteration #${goal.iterations})` : ""}`);
-  lines.push(`Engine: ${goal.engineState}`);
+  lines.push("State: " + stateLabel + (goal.iterations > 0 ? " (iteration #" + goal.iterations + ")" : ""));
+  lines.push("Engine: " + goal.engineState);
   const usage = summarizeUsage(goal);
   if (usage.iterationsWithUsage > 0) {
-    lines.push(
-      `Spent: $${usage.totalCostUsd.toFixed(4)}  (in ${usage.totalInputTokens} / out ${usage.totalOutputTokens} tokens across ${usage.iterationsWithUsage} iterations)`
-    );
+    const spent = "Spent: " + DOLLAR + usage.totalCostUsd.toFixed(4) + "  (in " + usage.totalInputTokens + " / out " + usage.totalOutputTokens + " tokens across " + usage.iterationsWithUsage + " iterations)";
+    lines.push(spent);
   }
   if (goal.journal.length > 0) {
     lines.push("");
-    lines.push(`Recent journal (last ${Math.min(journalLimit, goal.journal.length)}):`);
+    lines.push("Recent journal (last " + Math.min(journalLimit, goal.journal.length) + "):");
     const tail = goal.journal.slice(-journalLimit);
     for (const e of tail) {
       const mark = e.status === "success" ? "\u2713" : e.status === "failure" ? "\u2717" : e.status === "aborted" ? "\u2298" : "\xB7";
-      const note = e.note ? ` \u2014 ${e.note}` : "";
-      const cost = typeof e.costUsd === "number" ? ` ($${e.costUsd.toFixed(4)})` : "";
-      lines.push(`  #${e.iteration} ${mark} [${e.source}] ${e.task}${cost}${note}`);
+      const note = e.note ? " \u2014 " + e.note : "";
+      const cost = typeof e.costUsd === "number" ? " (" + DOLLAR + e.costUsd.toFixed(4) + ")" : "";
+      lines.push("  #" + e.iteration + " " + mark + " [" + e.source + "] " + e.task + cost + note);
     }
   }
   return lines.join("\n");
 }
+function parseProgressFromText(text) {
+  const re = /\[progress:\s*(\d{1,3})%\]\s*(?:[—\-]\s*(.+))?/i;
+  const m = text.match(re);
+  if (!m) return null;
+  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1], 10)));
+  const note = m[2]?.trim() || void 0;
+  return { progress, note };
+}
+function recordProgress(goal, progress, note) {
+  const clamped = Math.min(100, Math.max(0, progress));
+  const history = [...goal.progressHistory ?? [], { at: (/* @__PURE__ */ new Date()).toISOString(), progress: clamped, note }];
+  const trimmed = history.length > 200 ? history.slice(-200) : history;
+  return {
+    ...goal,
+    progress: clamped,
+    progressNote: note ?? `${clamped}% complete`,
+    progressHistory: trimmed,
+    progressTrend: computeTrend(trimmed)
+  };
+}
+var MAX_PROGRESS_HISTORY = 200;
+function computeTrend(history) {
+  if (history.length < 3) return void 0;
+  const recent = history.slice(-5);
+  const deltas = [];
+  for (let i = 1; i < recent.length; i++) {
+    deltas.push(recent[i].progress - recent[i - 1].progress);
+  }
+  if (deltas.length < 2) return void 0;
+  const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+  if (avgDelta > 2) return "accelerating";
+  if (avgDelta < -1) return "stalling";
+  return "steady";
+}
+
+// src/execution/autonomy-brain.ts
+function formatDecisionSummary(decision, request) {
+  const question = request.question.length > 80 ? request.question.slice(0, 77) + "\u2026" : request.question;
+  if (decision.type === "deny") {
+    return `\u{1F9E0} Brain: DENIED \u2014 "${question}" \u2192 ${decision.reason}`;
+  }
+  if (decision.type === "answer") {
+    const action = decision.optionId ? `chose [${decision.optionId}]` : decision.text.length > 60 ? decision.text.slice(0, 57) + "\u2026" : decision.text;
+    return `\u{1F9E0} Brain: DECIDED \u2014 "${question}" \u2192 ${action}`;
+  }
+  return `\u{1F9E0} Brain: ASKED HUMAN \u2014 "${question}"`;
+}
 
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
@@ -9531,7 +9998,7 @@ var EternalAutonomyEngine = class {
           this.consecutiveFailures = 0;
         }
         if (this.stopRequested) break;
-        await sleep(this.opts.cycleGapMs ?? 1e3);
+        await sleep(this.opts.cycleGapMs ?? 0);
       }
     } finally {
       this.state = "stopped";
@@ -9701,6 +10168,18 @@ var EternalAutonomyEngine = class {
       this.stopRequested = true;
       return true;
     }
+    const parsed = parseProgressFromText(finalText);
+    if (parsed) {
+      await this.updateProgress(parsed.progress, parsed.note);
+      if (parsed.progress >= 100) {
+        await this.markGoalCompleted(
+          { source: action.source, task: action.task, directive: action.directive },
+          `progress reached 100%: ${parsed.note ?? "goal complete"}`
+        );
+        this.stopRequested = true;
+        return true;
+      }
+    }
     this.iterationsSinceCompact++;
     await this.maybeCompact().catch((err) => {
       this.opts.onError?.(
@@ -9787,11 +10266,16 @@ var EternalAutonomyEngine = class {
       this.consecutiveBrainstormDone++;
       const threshold = this.opts.brainstormDoneStopThreshold ?? 3;
       if (this.consecutiveBrainstormDone >= threshold) {
-        await this.markGoalCompleted(
-          { source: "brainstorm", task: "no further work", directive: "" },
-          `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row`
-        );
-        this.stopRequested = true;
+        const shouldStop = await this.consultBrainForDone(goal);
+        if (shouldStop) {
+          await this.markGoalCompleted(
+            { source: "brainstorm", task: "no further work", directive: "" },
+            `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row${this.opts.brain ? ", brain confirmed" : ""}`
+          );
+          this.stopRequested = true;
+        } else {
+          this.consecutiveBrainstormDone = 0;
+        }
       }
       return null;
     }
@@ -10010,8 +10494,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?.();
@@ -10025,6 +10509,69 @@ ${recentJournal}` : "No prior iterations.",
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
+  /**
+   * Consult the brain on whether the goal is truly complete.
+   * Without a brain, always returns true (use heuristic: DONE threshold met = done).
+   */
+  async consultBrainForDone(goal) {
+    if (!this.opts.brain) return true;
+    const deliverablesStatus = goal.deliverables?.length ? `
+Deliverables: ${goal.deliverables.length} total, progress ${goal.progress ?? "unknown"}%` : "";
+    const recentJournal = goal.journal.slice(-5).map(
+      (e) => `  #${e.iteration} [${e.status}] ${e.task}`
+    ).join("\n");
+    try {
+      const decision = await this.opts.brain.decide({
+        id: `goal-done-${goal.iterations}`,
+        source: "system",
+        question: `Brainstorm returned DONE ${this.consecutiveBrainstormDone}x. Is the goal truly complete?`,
+        context: [
+          `Goal: ${goal.goal}`,
+          `Iterations: ${goal.iterations}`,
+          `Progress: ${goal.progress ?? "unknown"}%`,
+          deliverablesStatus,
+          recentJournal ? `
+Recent work:
+${recentJournal}` : ""
+        ].join("\n"),
+        risk: "high",
+        fallback: "continue"
+      });
+      const summary = formatDecisionSummary(decision, {
+        id: `goal-done-${goal.iterations}`,
+        source: "system",
+        question: "Is the goal complete?",
+        risk: "high",
+        fallback: "continue"
+      });
+      const rationale = "rationale" in decision ? decision.rationale : void 0;
+      await this.appendIterationEntry({
+        source: "brainstorm",
+        task: summary,
+        status: "success",
+        note: rationale
+      });
+      if (decision.type === "deny") {
+        return false;
+      }
+      if (decision.type === "answer") {
+        const text = decision.text.toLowerCase();
+        return text.includes("complete") || text.includes("done") || text.includes("yes");
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Persist a progress update from the agent's [PROGRESS: N%] output.
+   */
+  async updateProgress(progress, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const updated = recordProgress(current, progress, note);
+    await saveGoal(this.goalPath, updated);
+  }
   async persistEngineState(state) {
     const current = await loadGoal(this.goalPath);
     if (!current) return;
@@ -10390,15 +10937,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 +11045,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;
@@ -12665,17 +13212,120 @@ Working rules:
       phase: "meta",
       summary: "Token/cloud cost optimization: finds spend waste, recommends model routing and trimming with $ estimates.",
       keywords: [
-        "cost",
-        "token cost",
-        "optimize cost",
-        "spend",
-        "cheaper",
-        "model routing",
-        "budget",
-        "expensive",
-        "reduce tokens",
-        "pricing",
-        "cloud cost"
+        "cost",
+        "token cost",
+        "optimize cost",
+        "spend",
+        "cheaper",
+        "model routing",
+        "budget",
+        "expensive",
+        "reduce tokens",
+        "pricing",
+        "cloud cost"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "tech-stack",
+      name: "Tech Stack Validator",
+      role: "tech-stack",
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json"],
+      prompt: `You are the Tech Stack Validator \u2014 a single-shot validation agent that fires
+before any package, library, or framework choice is committed.
+
+Your ONLY job: verify that a technology choice is current, real, and not obsolete.
+You are the "this isn't code, this is 10-year-old technology" agent. Intervene
+hard when the LLM hallucinates a version number or suggests dead tech.
+
+## Critical rules
+
+1. **Verify existence.** Search npm registry (fetch https://registry.npmjs.org/<pkg>/latest)
+   or web search. A package that doesn't exist = hallucination.
+
+2. **Check latest version.** Never trust any version number from the model. Always
+   fetch the actual latest stable version from npm or the project's release page.
+
+3. **Reject dead packages.** No release in >2 years + unresolved critical issues =
+   dead. Suggest a maintained replacement.
+
+4. **Reject prehistoric tech.** Any package/pattern superseded \u22655 years ago is
+   REJECTED. Key blocklist:
+   - axios / node-fetch / got / request \u2192 native fetch (Node 18+)
+   - moment \u2192 date-fns / luxon / Temporal
+   - jQuery (new projects) \u2192 vanilla DOM / React
+   - Gulp / Grunt \u2192 tsup / esbuild / vite
+   - CoffeeScript / Flow \u2192 TypeScript
+   - Bluebird \u2192 native Promises
+   - crypto-js \u2192 node:crypto / Web Crypto
+   - Bower \u2192 npm/pnpm
+   - underscore \u2192 lodash or native ES2020+
+
+5. **The intervention phrase.** When rejecting on age grounds, you MUST output
+   exactly: "This isn't code, this is X-year-old technology." where X =
+   current year \u2212 the year the technology was made obsolete. Follow with
+   what replaced it and a one-step migration path.
+
+6. **Prefer built-in over third-party.** Check Node 22+ native APIs first:
+   node:test, node:sqlite, fetch, WebSocket, Web Crypto \u2014 all built-in.
+
+## Workflow (single-shot \u2014 do NOT loop)
+
+1. Receive the proposed package + version
+2. Search npm registry or web for the latest version
+3. Check age, maintenance status, deprecation
+4. Output verdict: APPROVED (with exact version) or REJECTED (with replacement)
+
+## Output format
+
+### Tech Stack Validation \u2014 <package>
+
+**Status**: APPROVED | REJECTED
+
+**Package**: <name>@<version>
+**Source**: <URL you checked \u2014 npm registry, GitHub, web search>
+**Age**: <first release> \u2014 <last release date>
+**Verdict**: 1\u20132 sentence explanation.
+
+When REJECTED on age:
+**"This isn't code, this is X-year-old technology."**
+**Replaced by**: <modern alternative>
+**Migration**: <one concrete step>
+
+When APPROVED:
+**Install**: pnpm add <name>@^<major>.<minor>.0`
+    },
+    budget: {
+      timeoutMs: 6e4,
+      maxIterations: 5,
+      maxToolCalls: 20,
+      maxTokens: 4e4,
+      maxCostUsd: 0.1
+    },
+    capability: {
+      phase: "meta",
+      summary: "Single-shot tech stack validator: checks npm for latest versions, rejects dead/obsolete packages, enforces modern alternatives.",
+      keywords: [
+        "tech stack",
+        "version",
+        "package",
+        "library",
+        "framework",
+        "dependency",
+        "install",
+        "upgrade",
+        "latest",
+        "npm",
+        "pnpm add",
+        "outdated",
+        "obsolete",
+        "deprecated",
+        "what version",
+        "which package",
+        "check version",
+        "verify version",
+        "is this current"
       ]
     }
   }
@@ -14010,12 +14660,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 +14815,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 +14847,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();
@@ -14476,7 +15120,17 @@ ${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first ite
 }
 
 // src/execution/goal-preamble.ts
-function buildGoalPreamble(goal) {
+function buildGoalPreamble(goal, deliverables) {
+  const deliverableBlock = deliverables && deliverables.length > 0 ? [
+    "",
+    "CONCRETE DELIVERABLES (check these off as you go):",
+    ...deliverables.map((d, i) => `  ${i + 1}. ${d}`),
+    "",
+    "After EACH iteration, estimate your completion percentage (0\u2013100)",
+    "against this deliverable list. Output it as:",
+    "  [PROGRESS: N%] \u2014 <1-sentence status>",
+    "The eternal engine reads this to update the progress bar."
+  ].join("\n") : "";
   return [
     "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
     "The user granted you full autonomy. Read these constraints once, then act.",
@@ -14485,6 +15139,7 @@ function buildGoalPreamble(goal) {
     "---",
     goal,
     "---",
+    deliverableBlock,
     "",
     "AUTHORITY YOU HAVE:",
     "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
@@ -14506,6 +15161,7 @@ function buildGoalPreamble(goal) {
     "- You can tell the user HOW to verify it themselves in 10 seconds.",
     '- You have NOT hedged. None of: "looks like it should work", "I',
     '  believe this fixes it", "the changes appear correct".',
+    `- Progress bar shows 100%. All deliverables checked off.`,
     "",
     "WHAT IS NOT DONE \u2014 never report any of these as completion:",
     "- An error message you didn't recover from.",
@@ -14520,6 +15176,13 @@ function buildGoalPreamble(goal) {
     "  respond to with a fresh attempt (different role, different model,",
     "  tighter prompt).",
     "",
+    "PROGRESS REPORTING \u2014 MANDATORY every iteration:",
+    "- End every response with exactly: [PROGRESS: N%] \u2014 <status note>",
+    "  where N is your honest estimate (0-100) of how much of the goal",
+    "  is done. The engine tracks this and shows a live progress bar.",
+    "- Example: [PROGRESS: 45%] \u2014 Auth module refactored, 3/5 tests pass,",
+    "  remaining: test coverage + docs update.",
+    "",
     "PERSISTENCE PROTOCOL:",
     "- If blocked, try at least 3 different angles before reporting the",
     "  problem to the user. Different tool inputs, different subagent",
@@ -14562,6 +15225,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 +15322,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 +15360,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 +15376,7 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      this._raceResolved = true;
       if (this._timeoutTimer) {
         clearTimeout(this._timeoutTimer);
         this._timeoutTimer = void 0;
@@ -14725,6 +15391,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;
@@ -18307,7 +18974,7 @@ var TaskTracker = class {
     const blockers = this.getBlockers(taskId);
     return blockers.every((id) => {
       const node = this.graph?.nodes.get(id);
-      return node?.status === "completed";
+      return node?.status === "completed" || node?.status === "failed";
     });
   }
   getProgress() {
@@ -18339,7 +19006,7 @@ var TaskTracker = class {
         const remainingBlockers = this.getBlockers(depId);
         const allUnblocked = remainingBlockers.every((id) => {
           const blocker = this.graph?.nodes.get(id);
-          return blocker?.status === "completed";
+          return blocker?.status === "completed" || blocker?.status === "failed";
         });
         if (allUnblocked) {
           dep.status = "pending";
@@ -18353,7 +19020,7 @@ var TaskTracker = class {
     const blockers = this.getBlockers(taskId);
     const someBlocked = blockers.some((id) => {
       const blocker = this.graph?.nodes.get(id);
-      return blocker?.status !== "completed";
+      return blocker?.status !== "completed" && blocker?.status !== "failed";
     });
     if (someBlocked) {
       const node = this.graph.nodes.get(taskId);
@@ -18790,12 +19457,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 +19502,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}`);
     }
   }
@@ -18999,10 +19660,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp20 = await import('fs/promises');
+      const fsp21 = await import('fs/promises');
       const path37 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp20.mkdir(path37.dirname(this.sessionPath), { recursive: true });
+      await fsp21.mkdir(path37.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -19011,8 +19672,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp20 = await import('fs/promises');
-      const raw = await fsp20.readFile(this.sessionPath, "utf8");
+      const fsp21 = await import('fs/promises');
+      const raw = await fsp21.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -19026,8 +19687,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp20 = await import('fs/promises');
-      await fsp20.unlink(this.sessionPath);
+      const fsp21 = await import('fs/promises');
+      await fsp21.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -19428,7 +20089,7 @@ function templateToMarkdown(template, title) {
 }
 
 // src/sdd/task-visualizer.ts
-var STATUS_ICON = {
+var STATUS_ICON2 = {
   pending: "\u25CB",
   in_progress: "\u25D0",
   blocked: "\u2298",
@@ -19436,13 +20097,13 @@ var STATUS_ICON = {
   review: "\u25D1",
   completed: "\u25CF"
 };
-var PRIORITY_ICON = {
+var PRIORITY_ICON2 = {
   critical: "\u{1F534}",
   high: "\u{1F7E0}",
   medium: "\u{1F7E1}",
   low: "\u{1F7E2}"
 };
-var TYPE_ICON = {
+var TYPE_ICON2 = {
   feature: "\u26A1",
   bugfix: "\u{1F41B}",
   refactor: "\u267B\uFE0F",
@@ -19491,9 +20152,9 @@ function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix
   rendered.add(nodeId);
   const node = graph.nodes.get(nodeId);
   if (!node) return;
-  const icon = STATUS_ICON[node.status];
-  const prioIcon = PRIORITY_ICON[node.priority];
-  const typeIcon = TYPE_ICON[node.type];
+  const icon = STATUS_ICON2[node.status];
+  const prioIcon = PRIORITY_ICON2[node.priority];
+  const typeIcon = TYPE_ICON2[node.type];
   const title = compact ? truncate2(node.title, 40) : node.title;
   const blockedBy = childrenMap.get(nodeId) ?? [];
   const depsStr = blockedBy.length > 0 ? ` \u2190 [${blockedBy.map((d) => graph.nodes.get(d)?.title?.slice(0, 12) ?? "?").join(", ")}]` : "";
@@ -19535,11 +20196,11 @@ function renderTaskList(graph) {
   }
   for (const [status, group] of Object.entries(groups)) {
     if (group.length === 0) continue;
-    const icon = STATUS_ICON[status];
+    const icon = STATUS_ICON2[status];
     lines.push(`${icon} ${status.toUpperCase()} (${group.length})`);
     for (const node of group) {
-      const prio = PRIORITY_ICON[node.priority];
-      const type = TYPE_ICON[node.type];
+      const prio = PRIORITY_ICON2[node.priority];
+      const type = TYPE_ICON2[node.type];
       lines.push(`  ${type} ${prio} ${node.title}`);
     }
     lines.push("");
@@ -19583,12 +20244,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 +20319,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 +20365,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,25 +20834,22 @@ 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;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.taskTimeoutMs ?? 3e5;
+    this.maxRetries = Math.max(0, opts.maxRetries ?? 2);
     this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
   }
   opts;
   slots;
   timeoutMs;
+  maxRetries;
   decomposer;
   coordinator = null;
   stopRequested = false;
+  retryMap = /* @__PURE__ */ new Map();
   // -------------------------------------------------------------------
   // Public API
   // -------------------------------------------------------------------
@@ -20209,6 +20861,7 @@ var SddParallelRun = class {
   /** Execute all waves until completion or deadlock. Returns final summary. */
   async run() {
     this.stopRequested = false;
+    this.retryMap.clear();
     const startTime = Date.now();
     let totalCompleted = 0;
     let totalFailed = 0;
@@ -20333,13 +20986,24 @@ 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");
+        this.retryMap.delete(taskId);
       } else {
         const errMsg = result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error";
-        this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+        const currentRetries = this.retryMap.get(taskId) ?? 0;
+        if (currentRetries < this.maxRetries) {
+          this.retryMap.set(taskId, currentRetries + 1);
+          this.opts.tracker.updateNodeStatus(
+            taskId,
+            "pending",
+            `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
+          );
+        } else {
+          this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+        }
       }
     }
     return {
@@ -20354,6 +21018,7 @@ var SddParallelRun = class {
   }
   buildProgress() {
     const gp = this.opts.tracker.getProgress();
+    const isDeadlocked = !this.decomposer.isDone() && this.decomposer.nextBatch().deadlocked;
     return {
       wave: this.decomposer.getWaveCount(),
       total: gp.total,
@@ -20363,7 +21028,7 @@ var SddParallelRun = class {
       blocked: gp.blocked,
       pending: gp.pending,
       percent: gp.percentComplete,
-      deadlocked: false
+      deadlocked: isDeadlocked
     };
   }
 };
@@ -21441,12 +22106,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 +22122,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 +22291,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 +22415,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 +22582,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 +23055,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 +23293,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 +23333,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 +23386,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 +23437,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 +23517,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 +23637,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 +23675,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 +23689,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;
       }
@@ -22792,6 +23799,43 @@ async function revertSnapshots(snapshots, projectRoot) {
   return { revertedFiles, errors };
 }
 
+// src/storage/task-store.ts
+init_atomic_write();
+function emptyTaskFile(sessionId) {
+  return {
+    version: 1,
+    sessionId,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tasks: []
+  };
+}
+async function loadTasks(filePath) {
+  let raw;
+  try {
+    raw = await fsp3.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || !Array.isArray(parsed.tasks)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveTasks(filePath, tasks) {
+  try {
+    tasks.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await atomicWrite(filePath, JSON.stringify(tasks, null, 2), { mode: 384 });
+  } catch (err) {
+    console.warn(
+      "[task-store] save failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+
 // src/storage/prompt-store.ts
 init_atomic_write();
 var DefaultPromptStore = class {
@@ -22864,12 +23908,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 +23950,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 +24003,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 +25102,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 +25350,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 +25399,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 +25480,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 +25600,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 +25840,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 +26029,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: readFile40 } = await import('fs/promises');
+      const content = await readFile40(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: readFile40 } = await import('fs/promises');
+      const content = await readFile40(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -25416,12 +26448,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 +26599,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 +26670,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 +26835,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 +27852,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 +27928,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 +28381,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 +28688,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 {
       }
     }
@@ -28103,8 +29164,13 @@ var SlashCommandRegistry = class {
     if (!entry) {
       return { message: `Unknown command "/${name}". Type /help for a list.` };
     }
-    const res = await entry.cmd.run(args, ctx);
-    return res ?? {};
+    try {
+      const res = await entry.cmd.run(args, ctx);
+      return res ?? {};
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { message: `Command "/${name}" failed: ${msg}` };
+    }
   }
 };
 
@@ -28538,20 +29604,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 +29672,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 +29791,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;
@@ -28779,14 +29864,14 @@ var PhaseOrchestrator = class {
       maxVerifyAttempts: opts.maxVerifyAttempts ?? 2,
       autonomous: opts.autonomous ?? true,
       phaseDelayMs: opts.phaseDelayMs ?? 0,
-      stopOnFailure: opts.stopOnFailure ?? true,
+      stopOnFailure: opts.stopOnFailure ?? false,
       events: this.events
     };
   }
   // ─── 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 +29898,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 +29918,7 @@ var PhaseOrchestrator = class {
       );
     });
   }
-  /** Tamamen durdur — aktif fazlar da durdurulur */
+  /** Stop completely, including active phases. */
   stop() {
     this.stopped = true;
     if (this.tickInterval) {
@@ -29031,7 +30116,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);
@@ -29223,7 +30311,7 @@ var PhaseOrchestrator = class {
       if (phase.status !== "pending") continue;
       const depsDone = phase.dependsOn.every((depId) => {
         const dep = this.graph.phases.get(depId);
-        return dep?.status === "completed" || dep?.status === "skipped";
+        return dep?.status === "completed" || dep?.status === "skipped" || dep?.status === "failed";
       });
       if (depsDone || phase.parallelizable) {
         ready.push(phase);
@@ -29434,7 +30522,9 @@ var AutoPhaseRunner = class {
       if (failedPhase) {
         this.opts.onFail?.(this.graph, failedPhase, new Error(p.error));
       }
-      this.cleanup();
+      if (this.opts.stopOnFailure) {
+        this.cleanup();
+      }
     }
   };
   /** Stores the unsubscribe function returned by EventBus.on() */
@@ -29488,10 +30578,32 @@ var AutoPhaseRunner = class {
       }, 2e3);
     }
     this.maxRunTimer = setTimeout(
-      () => this.stop(),
-      this.opts.maxRunDurationMs ?? 24 * 60 * 6e4
+      () => {
+        this.opts.onProgress?.({
+          totalPhases: 0,
+          pending: 0,
+          ready: 0,
+          running: 0,
+          paused: 0,
+          completed: 0,
+          failed: 0,
+          skipped: 0,
+          percentComplete: 0,
+          totalTasks: 0,
+          completedTasks: 0,
+          failedTasks: 0,
+          estimatedHours: 0,
+          actualHours: 0
+        });
+        this.stop();
+      },
+      this.opts.maxRunDurationMs ?? 7 * 24 * 60 * 6e4
     );
-    this.maxRunTimer.unref?.();
+    if (this.opts.maxRunDurationMs !== void 0 && this.opts.maxRunDurationMs <= 0) {
+      clearTimeout(this.maxRunTimer);
+      this.maxRunTimer = null;
+    }
+    this.maxRunTimer?.unref?.();
     if (this.opts.events) {
       const events = this.opts.events;
       const onUntyped = events.on;
@@ -29583,14 +30695,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 +30750,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 +31490,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 +31859,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 +31912,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 +31935,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 +31945,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 +31957,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 +31992,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 +32005,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 +32078,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 +32219,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 +32944,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, MAX_PROGRESS_HISTORY, 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, computeTaskItemProgress, 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, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined, extractRunEnv, filesystemServer, findCriticalPath, flagsToConfigPatch, formatContextWindowModeList, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, 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, loadTasks, 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, parseProgressFromText, parseSkillRef, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveContextWindowPolicy, resolveModelMatrix, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, 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