@wrongstack/core 0.89.1 → 0.89.3

package/dist/storage/index.js

@@ -2,13 +2,15 @@ import { randomBytes, randomUUID, createHash } from 'crypto';
 import * as fsp from 'fs/promises';
 import * as path2 from 'path';
 import * as os from 'os';
+import { hostname } from 'os';
 
-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');
-});
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path2.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
@@ -118,12 +120,6 @@ async function renameWithRetry(from, to) {
 }
 
 // src/utils/message-invariants.ts
-function expectDefined(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -216,12 +212,6 @@ function isEmptyMessage(msg) {
 }
 
 // src/storage/session-store.ts
-function expectDefined2(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);
 }
@@ -932,7 +922,7 @@ var FileSessionWriter = class {
     let targetCheckpointLine = -1;
     let afterTarget = false;
     for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined2(lines[i]);
+      const line = expectDefined(lines[i]);
       if (!line.trim()) continue;
       let event;
       try {
@@ -1221,9 +1211,235 @@ function mergeAdjacentText(blocks) {
   }
   return out;
 }
+
+// src/types/memory.ts
+var MEMORY_TYPE_LABELS = {
+  fact: "Fact",
+  decision: "Decision",
+  convention: "Convention",
+  preference: "Preference",
+  reference: "Reference",
+  anti_pattern: "Anti-pattern"
+};
+
+// src/storage/memory-backend.ts
+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((t) => `#${t}`).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(path2.dirname(file));
+    let existing = "";
+    try {
+      existing = await fsp.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 fsp.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 fsp.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((t) => t.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 fsp.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 fsp.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
 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,
@@ -1240,12 +1456,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();
@@ -1272,7 +1505,7 @@ var DefaultMemoryStore = class {
       if (writeErr) {
         parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr.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()}`);
@@ -1280,117 +1513,214 @@ ${body.trim()}`);
     return parts.join("\n\n");
   }
   async read(scope) {
-    try {
-      return await fsp.readFile(this.files[scope], "utf8");
-    } catch {
-      return "";
+    return this.backend.readAll(scope, this.files[scope]);
+  }
+  /**
+   * List entries from a scope, newest first. Delegates to the backend
+   * so graph/semantic backends can return enriched or filtered results.
+   */
+  async list(scope = "project-memory", limit) {
+    return this.backend.list(scope, this.files[scope], limit);
+  }
+  /**
+   * Find memories related to the given text via graph traversal.
+   * Falls back to content search when no graph backend is available.
+   */
+  async findRelated(text, scope = "project-memory", limit = 5) {
+    if (this.backend.findRelated) {
+      return this.backend.findRelated(scope, this.files[scope], text, limit);
     }
+    return this.search(text, scope, limit);
+  }
+  async search(query, scope = "project-memory", limit) {
+    return this.backend.search(scope, query, this.files[scope], limit);
   }
-  async remember(text, scope = "project-memory") {
+  async remember(text, scope = "project-memory", metadata) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
     return this.runSerialized(scope, async () => {
-      const file = this.files[scope];
-      await ensureDir(path2.dirname(file));
-      let existing = "";
-      try {
-        existing = await fsp.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 fsp.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((t) => t.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((t) => t.toLowerCase());
+      let taskHits = 0;
+      for (const w of taskWords) {
+        if (textLower.includes(w)) {
+          taskHits++;
+          score += 2;
+        }
+        if (tagsLower.some((t) => t.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((t) => t.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((t) => t.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 fsp.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 fsp.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: writeFile6, mkdir: mkdir5 } = await import('fs/promises');
+      await mkdir5(this.backupDir, { recursive: true });
+      await writeFile6(`${this.backupDir}/${scope}.md`, content, "utf8");
+    } catch {
+    }
+  }
 };
 function labelOf(scope) {
   switch (scope) {
@@ -1402,6 +1732,384 @@ function labelOf(scope) {
       return "User memory";
   }
 }
+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((t) => t.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 fsp.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 fsp.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 fsp.mkdir(
+        this.graphFile.substring(0, this.graphFile.lastIndexOf("/")),
+        { recursive: true }
+      );
+      const tmp = `${this.graphFile}.tmp`;
+      await fsp.writeFile(tmp, JSON.stringify(data));
+      await fsp.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 t of a) if (setB.has(t)) 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/config-store.ts
 function stripEphemeralFields(cfg) {
@@ -2097,12 +2805,6 @@ function compileUserRegex(pattern, flags) {
 }
 
 // src/storage/session-reader.ts
-function expectDefined3(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DefaultSessionReader = class {
   store;
   constructor(opts) {
@@ -2164,7 +2866,7 @@ var DefaultSessionReader = class {
         continue;
       }
       for (let i = 0; i < data.events.length; i++) {
-        const ev = expectDefined3(data.events[i]);
+        const ev = expectDefined(data.events[i]);
         if (allowedTypes && !allowedTypes.has(ev.type)) continue;
         const text = eventText(ev);
         if (text === null) continue;
@@ -2377,12 +3079,6 @@ function renderPlainText(meta, events) {
   }
   return lines.join("\n");
 }
-function expectDefined4(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;
@@ -2475,7 +3171,7 @@ var AnnotationsStore = class {
           return;
         }
         const next = {
-          ...expectDefined4(all[idx]),
+          ...expectDefined(all[idx]),
           resolved: true,
           resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
           resolvedBy: input.resolvedBy
@@ -2710,12 +3406,6 @@ var ReplayLogStore = class {
     return next;
   }
 };
-function expectDefined5(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;
@@ -2756,7 +3446,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(expectDefined5(lines[i]));
+          const ev = JSON.parse(expectDefined(lines[i]));
           if (ev.type === "in_flight_start") {
             return {
               sessionId,
@@ -2809,12 +3499,12 @@ var SessionRecovery = class {
     let lastCheckpointIdx = -1;
     for (let i = 0; i < events.length; i++) {
       if (events[i]?.type === "checkpoint") {
-        lastCheckpoint = expectDefined5(events[i]);
+        lastCheckpoint = expectDefined(events[i]);
         lastCheckpointIdx = i;
       }
     }
     const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
-    const lastEv = expectDefined5(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 {
@@ -2857,12 +3547,6 @@ var SessionRecovery = class {
     return path2.join(this.dir, `${sessionId}.jsonl`);
   }
 };
-function expectDefined6(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 {
@@ -2943,7 +3627,7 @@ var ToolAuditLog = class {
     }
     let prevHash = GENESIS_PREV;
     for (let i = 0; i < entries.length; i++) {
-      const e = expectDefined6(entries[i]);
+      const e = expectDefined(entries[i]);
       if (e.prevHash !== prevHash) {
         return {
           ok: false,
@@ -3160,12 +3844,6 @@ var SessionAnalyzer = class {
     return last - first;
   }
 };
-function expectDefined7(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;
@@ -3204,7 +3882,7 @@ var DefaultSessionRewinder = class {
     const events = parseEvents(raw);
     let targetIdx = -1;
     for (let i = 0; i < events.length; i++) {
-      const event = expectDefined7(events[i]);
+      const event = expectDefined(events[i]);
       if (event.type === "checkpoint") {
         const checkpointEvent = event;
         if (checkpointEvent.promptIndex === checkpointIndex) {
@@ -3218,7 +3896,7 @@ var DefaultSessionRewinder = class {
     }
     const snapshotsToRevert = [];
     for (let i = targetIdx + 1; i < events.length; i++) {
-      const event = expectDefined7(events[i]);
+      const event = expectDefined(events[i]);
       if (event.type === "checkpoint") {
         break;
       }
@@ -3365,7 +4043,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 = () => {
@@ -3663,7 +4344,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 });
@@ -4033,12 +4714,6 @@ var DefaultPromptStore = class {
     };
   }
 };
-function expectDefined8(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) {
@@ -4081,8 +4756,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 = expectDefined8(parts[0]);
-    const repoName = expectDefined8(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);
@@ -4134,8 +4809,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 = expectDefined8(pullParts[0]);
-    const repoName = expectDefined8(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);
@@ -4452,6 +5127,6 @@ function resolveSessionLoggingConfig(cfg) {
   };
 }
 
-export { ALL_SYNC_CATEGORIES, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, MAX_JOURNAL_ENTRIES, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionRecovery, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, formatGoal, formatPlan, formatPlanTemplates, getPlanTemplate, goalFilePath, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTodosCheckpoint, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, saveGoal, savePlan, saveTodosCheckpoint, setPlanItemStatus, summarizeUsage };
+export { ALL_SYNC_CATEGORIES, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, FileMemoryBackend, GraphMemoryBackend, MAX_JOURNAL_ENTRIES, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionMemoryConsolidator, SessionRecovery, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, formatGoal, formatPlan, formatPlanTemplates, getPlanTemplate, goalFilePath, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTodosCheckpoint, parseEntries, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, saveGoal, savePlan, saveTodosCheckpoint, setPlanItemStatus, summarizeUsage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map