@joshuaswarren/openclaw-engram 8.3.86 → 8.3.88

package/dist/index.js

@@ -456,9 +456,9 @@ function parseConfig(raw) {
 }
 
 // src/orchestrator.ts
-import path27 from "path";
+import path28 from "path";
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir20, readdir as readdir11, readFile as readFile19, writeFile as writeFile18 } from "fs/promises";
+import { mkdir as mkdir20, readdir as readdir12, readFile as readFile20, writeFile as writeFile19 } from "fs/promises";
 
 // src/signal.ts
 var BUILTIN_HIGH_PATTERNS = [
@@ -7505,8 +7505,410 @@ function extractTopics(memories, topN = 50) {
 }
 
 // src/transcript.ts
-import { appendFile as appendFile2, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, stat as stat2, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir4, readdir as readdir4, readFile as readFile5, stat as stat2, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
+import path7 from "path";
+
+// src/session-integrity.ts
 import path6 from "path";
+import { readFile as readFile4, readdir as readdir3, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+function isObjectRecord(input) {
+  return Boolean(input) && typeof input === "object";
+}
+function isTranscriptEntry(raw) {
+  if (!isObjectRecord(raw)) return false;
+  if (raw.role !== "user" && raw.role !== "assistant") return false;
+  return typeof raw.timestamp === "string" && raw.timestamp.length > 0 && typeof raw.content === "string" && typeof raw.sessionKey === "string" && raw.sessionKey.length > 0 && typeof raw.turnId === "string" && raw.turnId.length > 0;
+}
+async function listTranscriptFiles(memoryDir) {
+  const transcriptsDir = path6.join(memoryDir, "transcripts");
+  const out = [];
+  const stack = [transcriptsDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir) continue;
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        out.push(fullPath);
+      }
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+async function parseTranscriptFile(filePath) {
+  const bySession = /* @__PURE__ */ new Map();
+  const malformed = [];
+  const invalid = [];
+  const invalidBySession = /* @__PURE__ */ new Map();
+  let raw = "";
+  try {
+    raw = await readFile4(filePath, "utf-8");
+  } catch {
+    return { bySession, malformed, invalid, invalidBySession };
+  }
+  const lines = raw.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim() ?? "";
+    if (!line) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      malformed.push({
+        code: "transcript_malformed_line",
+        severity: "warn",
+        message: "Transcript line is not valid JSON.",
+        filePath,
+        line: index + 1
+      });
+      continue;
+    }
+    if (!isTranscriptEntry(parsed)) {
+      const sessionKey = isObjectRecord(parsed) && typeof parsed.sessionKey === "string" && parsed.sessionKey.length > 0 ? parsed.sessionKey : void 0;
+      invalid.push({
+        code: "transcript_invalid_entry",
+        severity: "warn",
+        message: "Transcript entry is missing required fields.",
+        filePath,
+        line: index + 1,
+        sessionKey
+      });
+      if (sessionKey) {
+        invalidBySession.set(sessionKey, (invalidBySession.get(sessionKey) ?? 0) + 1);
+      }
+      continue;
+    }
+    const list = bySession.get(parsed.sessionKey) ?? [];
+    list.push({ filePath, lineNumber: index + 1, entry: parsed });
+    bySession.set(parsed.sessionKey, list);
+  }
+  return { bySession, malformed, invalid, invalidBySession };
+}
+function analyzeSessionEntries(sessionKey, refs) {
+  function parseTimestampForSort(timestamp) {
+    const parsed = Date.parse(timestamp);
+    if (Number.isFinite(parsed)) return parsed;
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const issues = [];
+  const sorted = [...refs].sort((a, b) => {
+    const tsA = parseTimestampForSort(a.entry.timestamp);
+    const tsB = parseTimestampForSort(b.entry.timestamp);
+    if (tsA !== tsB) return tsA - tsB;
+    const rawTimestampCmp = a.entry.timestamp.localeCompare(b.entry.timestamp);
+    if (rawTimestampCmp !== 0) return rawTimestampCmp;
+    return a.entry.turnId.localeCompare(b.entry.turnId);
+  });
+  const turnIdSeen = /* @__PURE__ */ new Set();
+  let duplicateTurnIds = 0;
+  let brokenChains = 0;
+  for (let i = 0; i < sorted.length; i += 1) {
+    const current = sorted[i];
+    if (turnIdSeen.has(current.entry.turnId)) {
+      duplicateTurnIds += 1;
+      issues.push({
+        code: "transcript_duplicate_turn_id",
+        severity: "warn",
+        message: `Duplicate turnId detected: ${current.entry.turnId}`,
+        sessionKey,
+        filePath: current.filePath,
+        line: current.lineNumber
+      });
+    } else {
+      turnIdSeen.add(current.entry.turnId);
+    }
+    if (i > 0) {
+      const previous = sorted[i - 1];
+      if (previous && previous.entry.role === current.entry.role) {
+        brokenChains += 1;
+        issues.push({
+          code: "transcript_broken_chain",
+          severity: "warn",
+          message: `Adjacent turns have the same role (${current.entry.role}).`,
+          sessionKey,
+          filePath: current.filePath,
+          line: current.lineNumber
+        });
+      }
+    }
+  }
+  let incompleteTurns = 0;
+  if (sorted.length > 0 && sorted[sorted.length - 1]?.entry.role === "user") {
+    incompleteTurns = 1;
+    const last = sorted[sorted.length - 1];
+    issues.push({
+      code: "transcript_incomplete_turn",
+      severity: "warn",
+      message: "Session ends on a user turn without assistant response.",
+      sessionKey,
+      filePath: last?.filePath,
+      line: last?.lineNumber
+    });
+  }
+  return {
+    stats: {
+      sessionKey,
+      entries: sorted.length,
+      malformedLines: 0,
+      invalidEntries: 0,
+      duplicateTurnIds,
+      brokenChains,
+      incompleteTurns
+    },
+    issues
+  };
+}
+function validateCheckpointRaw(checkpoint) {
+  if (!isObjectRecord(checkpoint)) return false;
+  return typeof checkpoint.sessionKey === "string" && checkpoint.sessionKey.length > 0 && typeof checkpoint.capturedAt === "string" && typeof checkpoint.ttl === "string" && Array.isArray(checkpoint.turns);
+}
+async function analyzeCheckpoint(memoryDir) {
+  const checkpointPath = path6.join(memoryDir, "state", "checkpoint.json");
+  const issues = [];
+  const checkpoint = {
+    present: false,
+    healthy: true,
+    path: checkpointPath
+  };
+  let raw = "";
+  try {
+    raw = await readFile4(checkpointPath, "utf-8");
+  } catch {
+    issues.push({
+      code: "checkpoint_missing",
+      severity: "info",
+      message: "No checkpoint file present.",
+      filePath: checkpointPath
+    });
+    return { checkpoint, issues };
+  }
+  checkpoint.present = true;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    checkpoint.healthy = false;
+    issues.push({
+      code: "checkpoint_invalid_json",
+      severity: "error",
+      message: "Checkpoint file is invalid JSON.",
+      filePath: checkpointPath
+    });
+    return { checkpoint, issues };
+  }
+  if (!validateCheckpointRaw(parsed)) {
+    checkpoint.healthy = false;
+    issues.push({
+      code: "checkpoint_invalid_metadata",
+      severity: "error",
+      message: "Checkpoint file is missing required metadata fields.",
+      filePath: checkpointPath
+    });
+    return { checkpoint, issues };
+  }
+  checkpoint.sessionKey = parsed.sessionKey;
+  checkpoint.expiresAt = parsed.ttl;
+  const ttlMs = Date.parse(parsed.ttl);
+  const capturedAtMs = Date.parse(parsed.capturedAt);
+  if (!Number.isFinite(ttlMs) || !Number.isFinite(capturedAtMs) || ttlMs <= capturedAtMs) {
+    checkpoint.healthy = false;
+    issues.push({
+      code: "checkpoint_invalid_metadata",
+      severity: "error",
+      message: "Checkpoint timestamps are invalid or inconsistent.",
+      filePath: checkpointPath,
+      sessionKey: parsed.sessionKey
+    });
+    return { checkpoint, issues };
+  }
+  if (ttlMs < Date.now()) {
+    checkpoint.healthy = false;
+    issues.push({
+      code: "checkpoint_expired",
+      severity: "warn",
+      message: "Checkpoint TTL has expired.",
+      filePath: checkpointPath,
+      sessionKey: parsed.sessionKey
+    });
+  }
+  for (const turn of parsed.turns) {
+    if (!isTranscriptEntry(turn)) {
+      checkpoint.healthy = false;
+      issues.push({
+        code: "checkpoint_invalid_metadata",
+        severity: "error",
+        message: "Checkpoint contains invalid turn entries.",
+        filePath: checkpointPath,
+        sessionKey: parsed.sessionKey
+      });
+      break;
+    }
+  }
+  return { checkpoint, issues };
+}
+async function analyzeSessionIntegrity(options) {
+  const memoryDir = options.memoryDir;
+  const reportIssues = [];
+  const allSessionRefs = /* @__PURE__ */ new Map();
+  const invalidBySession = /* @__PURE__ */ new Map();
+  const sessions = /* @__PURE__ */ new Map();
+  const files = await listTranscriptFiles(memoryDir);
+  for (const filePath of files) {
+    const parsed = await parseTranscriptFile(filePath);
+    reportIssues.push(...parsed.malformed, ...parsed.invalid);
+    for (const [sessionKey, count] of parsed.invalidBySession.entries()) {
+      invalidBySession.set(sessionKey, (invalidBySession.get(sessionKey) ?? 0) + count);
+    }
+    for (const [sessionKey, refs] of parsed.bySession.entries()) {
+      const existing = allSessionRefs.get(sessionKey) ?? [];
+      existing.push(...refs);
+      allSessionRefs.set(sessionKey, existing);
+    }
+  }
+  for (const [sessionKey, refs] of allSessionRefs.entries()) {
+    const analyzed = analyzeSessionEntries(sessionKey, refs);
+    reportIssues.push(...analyzed.issues);
+    sessions.set(sessionKey, {
+      ...analyzed.stats,
+      malformedLines: 0,
+      invalidEntries: invalidBySession.get(sessionKey) ?? 0
+    });
+  }
+  const checkpoint = await analyzeCheckpoint(memoryDir);
+  reportIssues.push(...checkpoint.issues);
+  const severeIssueCount = reportIssues.filter((issue) => issue.severity !== "info").length;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    memoryDir,
+    healthy: severeIssueCount === 0,
+    sessions: [...sessions.values()].sort((a, b) => a.sessionKey.localeCompare(b.sessionKey)),
+    checkpoint: checkpoint.checkpoint,
+    issues: reportIssues
+  };
+}
+function collectTranscriptRewriteTargets(report) {
+  const set = /* @__PURE__ */ new Set();
+  for (const issue of report.issues) {
+    if (!issue.filePath) continue;
+    if (issue.code === "transcript_malformed_line" || issue.code === "transcript_invalid_entry") {
+      set.add(issue.filePath);
+    }
+  }
+  return [...set].sort((a, b) => a.localeCompare(b));
+}
+function planSessionRepair(options) {
+  const actions = [];
+  const transcriptTargets = collectTranscriptRewriteTargets(options.report);
+  for (const targetPath of transcriptTargets) {
+    actions.push({
+      kind: "rewrite_transcript",
+      targetPath,
+      description: "Rewrite transcript file with only valid JSON transcript entries."
+    });
+  }
+  const checkpointNeedsRepair = options.report.issues.some(
+    (issue) => issue.code === "checkpoint_invalid_json" || issue.code === "checkpoint_invalid_metadata" || issue.code === "checkpoint_expired"
+  );
+  if (checkpointNeedsRepair && options.report.checkpoint.present) {
+    actions.push({
+      kind: "remove_checkpoint",
+      targetPath: options.report.checkpoint.path,
+      description: "Remove invalid or expired checkpoint file."
+    });
+  }
+  if (options.sessionFilesDir && options.allowSessionFileRepair === true) {
+    actions.push({
+      kind: "repair_session_files",
+      targetPath: options.sessionFilesDir,
+      description: "Session file repair was requested; no automatic rewiring is performed.",
+      details: "No-op by design. OpenClaw session files require explicit manual review."
+    });
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dryRun: options.dryRun,
+    allowSessionFileRepair: options.allowSessionFileRepair === true,
+    actions
+  };
+}
+async function rewriteTranscriptFile(targetPath) {
+  let raw = "";
+  try {
+    raw = await readFile4(targetPath, "utf-8");
+  } catch {
+    return;
+  }
+  const lines = raw.split("\n");
+  const validLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!isTranscriptEntry(parsed)) continue;
+      validLines.push(JSON.stringify(parsed));
+    } catch {
+    }
+  }
+  const body = validLines.length > 0 ? `${validLines.join("\n")}
+` : "";
+  await writeFile4(targetPath, body, "utf-8");
+}
+async function applySessionRepair(options) {
+  const { plan } = options;
+  if (plan.dryRun) {
+    return {
+      applied: false,
+      actionsAttempted: plan.actions.length,
+      actionsApplied: 0,
+      errors: []
+    };
+  }
+  let actionsApplied = 0;
+  const errors = [];
+  for (const action of plan.actions) {
+    try {
+      if (action.kind === "rewrite_transcript") {
+        await rewriteTranscriptFile(action.targetPath);
+        actionsApplied += 1;
+        continue;
+      }
+      if (action.kind === "remove_checkpoint") {
+        try {
+          await unlink2(action.targetPath);
+        } catch (err) {
+          const code = typeof err === "object" && err && "code" in err ? String(err.code ?? "") : "";
+          if (code !== "ENOENT") {
+            throw err;
+          }
+        }
+        actionsApplied += 1;
+        continue;
+      }
+      if (action.kind === "repair_session_files") {
+        actionsApplied += 1;
+      }
+    } catch (err) {
+      errors.push(`Failed ${action.kind} ${action.targetPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return {
+    applied: true,
+    actionsAttempted: plan.actions.length,
+    actionsApplied,
+    errors
+  };
+}
+
+// src/transcript.ts
 var TranscriptManager = class _TranscriptManager {
   transcriptsDir;
   checkpointPath;
@@ -7520,10 +7922,10 @@ var TranscriptManager = class _TranscriptManager {
   static CHARS_PER_TOKEN = 4;
   constructor(config) {
     this.config = config;
-    this.transcriptsDir = path6.join(config.memoryDir, "transcripts");
-    this.stateDir = path6.join(config.memoryDir, "state");
-    this.checkpointPath = path6.join(this.stateDir, "checkpoint.json");
-    this.toolUsageDir = path6.join(this.stateDir, "tool-usage");
+    this.transcriptsDir = path7.join(config.memoryDir, "transcripts");
+    this.stateDir = path7.join(config.memoryDir, "state");
+    this.checkpointPath = path7.join(this.stateDir, "checkpoint.json");
+    this.toolUsageDir = path7.join(this.stateDir, "tool-usage");
   }
   /**
    * Parse a sessionKey to extract channel type and ID.
@@ -7556,7 +7958,7 @@ var TranscriptManager = class _TranscriptManager {
     }
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     return {
-      dir: path6.join(channelType, channelId),
+      dir: path7.join(channelType, channelId),
       file: `${today}.jsonl`
     };
   }
@@ -7578,19 +7980,19 @@ var TranscriptManager = class _TranscriptManager {
     const transcriptDir = this.transcriptsDir;
     const sessionKeys = /* @__PURE__ */ new Set();
     try {
-      const typeEntries = await readdir3(transcriptDir, { withFileTypes: true });
+      const typeEntries = await readdir4(transcriptDir, { withFileTypes: true });
       for (const typeEnt of typeEntries) {
         if (!typeEnt.isDirectory()) continue;
-        const typeDir = path6.join(transcriptDir, typeEnt.name);
-        const idEntries = await readdir3(typeDir, { withFileTypes: true });
+        const typeDir = path7.join(transcriptDir, typeEnt.name);
+        const idEntries = await readdir4(typeDir, { withFileTypes: true });
         for (const idEnt of idEntries) {
           if (!idEnt.isDirectory()) continue;
-          const chanDir = path6.join(typeDir, idEnt.name);
-          const files = (await readdir3(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
+          const chanDir = path7.join(typeDir, idEnt.name);
+          const files = (await readdir4(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
           const last = files[files.length - 1];
           if (!last) continue;
           try {
-            const raw = await readFile4(path6.join(chanDir, last), "utf-8");
+            const raw = await readFile5(path7.join(chanDir, last), "utf-8");
             const firstLine = raw.split("\n").find((l) => l.trim().length > 0);
             if (!firstLine) continue;
             const entry = JSON.parse(firstLine);
@@ -7612,21 +8014,21 @@ var TranscriptManager = class _TranscriptManager {
   }
   async appendToolUse(entry) {
     const { dir, file } = this.getToolUsagePath(entry.sessionKey);
-    const channelDir = path6.join(this.toolUsageDir, dir);
+    const channelDir = path7.join(this.toolUsageDir, dir);
     await mkdir4(channelDir, { recursive: true });
-    const filePath = path6.join(channelDir, file);
+    const filePath = path7.join(channelDir, file);
     await appendFile2(filePath, JSON.stringify(entry) + "\n", "utf-8");
   }
   async readToolUse(sessionKey, startTime, endTime) {
     const { dir } = this.getToolUsagePath(sessionKey);
-    const channelDir = path6.join(this.toolUsageDir, dir);
+    const channelDir = path7.join(this.toolUsageDir, dir);
     try {
-      const files = await readdir3(channelDir);
+      const files = await readdir4(channelDir);
       const out = [];
       for (const file of files) {
         if (!file.endsWith(".jsonl")) continue;
-        const fp = path6.join(channelDir, file);
-        const raw = await readFile4(fp, "utf-8");
+        const fp = path7.join(channelDir, file);
+        const raw = await readFile5(fp, "utf-8");
         for (const line of raw.split("\n")) {
           if (!line.trim()) continue;
           try {
@@ -7649,17 +8051,17 @@ var TranscriptManager = class _TranscriptManager {
   }
   async estimateSessionFootprint(sessionKey) {
     const { dir } = this.getTranscriptPath(sessionKey);
-    const channelDir = path6.join(this.transcriptsDir, dir);
+    const channelDir = path7.join(this.transcriptsDir, dir);
     let bytes = 0;
     try {
-      const files = (await readdir3(channelDir)).filter((file) => file.endsWith(".jsonl")).sort();
+      const files = (await readdir4(channelDir)).filter((file) => file.endsWith(".jsonl")).sort();
       const cached = this.sessionFootprintCache.get(sessionKey);
       if (!cached) {
         const fileBytes = /* @__PURE__ */ new Map();
         const fileSizes = /* @__PURE__ */ new Map();
         for (const file of files) {
           try {
-            const fullPath = path6.join(channelDir, file);
+            const fullPath = path7.join(channelDir, file);
             const fileInfo = await stat2(fullPath);
             const sessionBytes = await this.estimateSessionBytesInFile(
               fullPath,
@@ -7685,7 +8087,7 @@ var TranscriptManager = class _TranscriptManager {
         for (const file of files) {
           if (cached.fileBytes.has(file)) continue;
           try {
-            const fullPath = path6.join(channelDir, file);
+            const fullPath = path7.join(channelDir, file);
             const fileInfo = await stat2(fullPath);
             const sessionBytes = await this.estimateSessionBytesInFile(fullPath, sessionKey);
             cached.fileBytes.set(file, sessionBytes);
@@ -7697,7 +8099,7 @@ var TranscriptManager = class _TranscriptManager {
         const newestFile = files[files.length - 1];
         if (newestFile) {
           try {
-            const newestPath = path6.join(channelDir, newestFile);
+            const newestPath = path7.join(channelDir, newestFile);
             const fileInfo = await stat2(newestPath);
             const size = Math.max(0, fileInfo.size);
             const previousSessionBytes = cached.fileBytes.get(newestFile) ?? 0;
@@ -7724,7 +8126,7 @@ var TranscriptManager = class _TranscriptManager {
   }
   async estimateSessionBytesInFile(filePath, sessionKey) {
     try {
-      const raw = await readFile4(filePath, "utf-8");
+      const raw = await readFile5(filePath, "utf-8");
       let total = 0;
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -7757,12 +8159,12 @@ var TranscriptManager = class _TranscriptManager {
   async append(entry) {
     try {
       const { dir, file } = this.getTranscriptPath(entry.sessionKey);
-      const channelType = dir.split(path6.sep)[0] ?? dir;
+      const channelType = dir.split(path7.sep)[0] ?? dir;
       if (this.config.transcriptSkipChannelTypes.includes(channelType)) {
         return;
       }
-      const channelDir = path6.join(this.transcriptsDir, dir);
-      const filePath = path6.join(channelDir, file);
+      const channelDir = path7.join(this.transcriptsDir, dir);
+      const filePath = path7.join(channelDir, file);
       await mkdir4(channelDir, { recursive: true });
       const line = JSON.stringify(entry) + "\n";
       await appendFile2(filePath, line, "utf-8");
@@ -7779,26 +8181,26 @@ var TranscriptManager = class _TranscriptManager {
   async getAllTranscriptFiles() {
     const files = [];
     try {
-      const entries = await readdir3(this.transcriptsDir, { withFileTypes: true });
+      const entries = await readdir4(this.transcriptsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const channelTypeDir = path6.join(this.transcriptsDir, entry.name);
+          const channelTypeDir = path7.join(this.transcriptsDir, entry.name);
           try {
-            const channelTypeEntries = await readdir3(channelTypeDir, { withFileTypes: true });
+            const channelTypeEntries = await readdir4(channelTypeDir, { withFileTypes: true });
             for (const channelTypeEntry of channelTypeEntries) {
               if (channelTypeEntry.isDirectory()) {
-                const channelDir = path6.join(channelTypeDir, channelTypeEntry.name);
+                const channelDir = path7.join(channelTypeDir, channelTypeEntry.name);
                 try {
-                  const channelFiles = await readdir3(channelDir);
+                  const channelFiles = await readdir4(channelDir);
                   for (const file of channelFiles) {
                     if (file.endsWith(".jsonl")) {
-                      files.push(path6.join(entry.name, channelTypeEntry.name, file));
+                      files.push(path7.join(entry.name, channelTypeEntry.name, file));
                     }
                   }
                 } catch {
                 }
               } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
-                files.push(path6.join(entry.name, channelTypeEntry.name));
+                files.push(path7.join(entry.name, channelTypeEntry.name));
               }
             }
           } catch {
@@ -7823,9 +8225,9 @@ var TranscriptManager = class _TranscriptManager {
     try {
       const transcriptFiles = await this.getAllTranscriptFiles();
       for (const relativePath of transcriptFiles) {
-        const filePath = path6.join(this.transcriptsDir, relativePath);
+        const filePath = path7.join(this.transcriptsDir, relativePath);
         try {
-          const content = await readFile4(filePath, "utf-8");
+          const content = await readFile5(filePath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           for (const line of lines) {
             try {
@@ -7875,26 +8277,26 @@ var TranscriptManager = class _TranscriptManager {
     cutoff.setHours(0, 0, 0, 0);
     let processed = 0;
     try {
-      const entries = await readdir3(this.transcriptsDir, { withFileTypes: true });
+      const entries = await readdir4(this.transcriptsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const channelTypeDir = path6.join(this.transcriptsDir, entry.name);
+          const channelTypeDir = path7.join(this.transcriptsDir, entry.name);
           try {
-            const channelTypeEntries = await readdir3(channelTypeDir, { withFileTypes: true });
+            const channelTypeEntries = await readdir4(channelTypeDir, { withFileTypes: true });
             for (const channelTypeEntry of channelTypeEntries) {
               if (channelTypeEntry.isDirectory()) {
-                const channelDir = path6.join(channelTypeDir, channelTypeEntry.name);
+                const channelDir = path7.join(channelTypeDir, channelTypeEntry.name);
                 try {
-                  const channelFiles = await readdir3(channelDir);
+                  const channelFiles = await readdir4(channelDir);
                   for (const file of channelFiles) {
                     if (!file.endsWith(".jsonl")) continue;
-                    const filePath = path6.join(channelDir, file);
+                    const filePath = path7.join(channelDir, file);
                     if (this.isLegacyTranscriptFile(file)) {
                       const dateStr = file.slice(0, 10);
                       const fileDate = new Date(dateStr);
                       if (!isNaN(fileDate.getTime()) && fileDate < cutoff) {
                         try {
-                          await unlink2(filePath);
+                          await unlink3(filePath);
                           processed++;
                           log.debug(`deleted old daily transcript file: ${entry.name}/${channelTypeEntry.name}/${file}`);
                         } catch (err) {
@@ -7912,7 +8314,7 @@ var TranscriptManager = class _TranscriptManager {
                   log.debug(`failed to process channel directory ${entry.name}/${channelTypeEntry.name}:`, err);
                 }
               } else if (channelTypeEntry.isFile() && channelTypeEntry.name.endsWith(".jsonl")) {
-                const filePath = path6.join(channelTypeDir, channelTypeEntry.name);
+                const filePath = path7.join(channelTypeDir, channelTypeEntry.name);
                 const cleaned = await this.cleanupTranscriptFile(filePath, cutoff);
                 if (cleaned) {
                   processed++;
@@ -7927,9 +8329,9 @@ var TranscriptManager = class _TranscriptManager {
             const dateStr = entry.name.slice(0, 10);
             const fileDate = new Date(dateStr);
             if (!isNaN(fileDate.getTime()) && fileDate < cutoff) {
-              const filePath = path6.join(this.transcriptsDir, entry.name);
+              const filePath = path7.join(this.transcriptsDir, entry.name);
               try {
-                await unlink2(filePath);
+                await unlink3(filePath);
                 processed++;
                 log.debug(`deleted old legacy transcript file: ${entry.name}`);
               } catch (err) {
@@ -7955,7 +8357,7 @@ var TranscriptManager = class _TranscriptManager {
    */
   async cleanupTranscriptFile(filePath, cutoff) {
     try {
-      const content = await readFile4(filePath, "utf-8");
+      const content = await readFile5(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       const validLines = [];
       let hasOldEntries = false;
@@ -7974,7 +8376,7 @@ var TranscriptManager = class _TranscriptManager {
       }
       if (validLines.length === 0) {
         try {
-          await unlink2(filePath);
+          await unlink3(filePath);
           log.debug(`deleted empty transcript file: ${filePath}`);
           return true;
         } catch (err) {
@@ -7983,7 +8385,7 @@ var TranscriptManager = class _TranscriptManager {
         }
       }
       if (hasOldEntries) {
-        await writeFile4(filePath, validLines.join("\n") + "\n", "utf-8");
+        await writeFile5(filePath, validLines.join("\n") + "\n", "utf-8");
         log.debug(`cleaned old entries from transcript file: ${filePath}`);
         return true;
       }
@@ -7998,7 +8400,7 @@ var TranscriptManager = class _TranscriptManager {
    */
   async saveCheckpoint(checkpoint) {
     try {
-      await writeFile4(this.checkpointPath, JSON.stringify(checkpoint, null, 2), "utf-8");
+      await writeFile5(this.checkpointPath, JSON.stringify(checkpoint, null, 2), "utf-8");
       log.info(`saved checkpoint for session ${checkpoint.sessionKey} with ${checkpoint.turns.length} turn(s)`);
     } catch (err) {
       log.error("failed to save checkpoint:", err);
@@ -8011,7 +8413,7 @@ var TranscriptManager = class _TranscriptManager {
    */
   async loadCheckpoint(sessionKey) {
     try {
-      const raw = await readFile4(this.checkpointPath, "utf-8");
+      const raw = await readFile5(this.checkpointPath, "utf-8");
       const checkpoint = JSON.parse(raw);
       if (!checkpoint.sessionKey || !checkpoint.capturedAt || !checkpoint.ttl || !Array.isArray(checkpoint.turns)) {
         log.warn("checkpoint file has invalid structure");
@@ -8043,7 +8445,7 @@ var TranscriptManager = class _TranscriptManager {
    */
   async clearCheckpoint() {
     try {
-      await unlink2(this.checkpointPath);
+      await unlink3(this.checkpointPath);
       log.info("cleared checkpoint");
     } catch (err) {
       log.debug("no checkpoint to clear");
@@ -8139,12 +8541,12 @@ var TranscriptManager = class _TranscriptManager {
       let totalEntries = 0;
       const channelTypes = {};
       for (const relativePath of allFiles) {
-        const filePath = path6.join(this.transcriptsDir, relativePath);
+        const filePath = path7.join(this.transcriptsDir, relativePath);
         try {
-          const content = await readFile4(filePath, "utf-8");
+          const content = await readFile5(filePath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           totalEntries += lines.length;
-          const channelType = relativePath.includes(path6.sep) ? relativePath.split(path6.sep)[0] : "legacy";
+          const channelType = relativePath.includes(path7.sep) ? relativePath.split(path7.sep)[0] : "legacy";
           channelTypes[channelType] = (channelTypes[channelType] || 0) + 1;
         } catch {
         }
@@ -8167,11 +8569,32 @@ var TranscriptManager = class _TranscriptManager {
       };
     }
   }
+  async analyzeIntegrity() {
+    return analyzeSessionIntegrity({ memoryDir: this.config.memoryDir });
+  }
+  async getRecoverySummary(sessionKey) {
+    const report = await this.analyzeIntegrity();
+    const selectedSessions = sessionKey ? report.sessions.filter((session) => session.sessionKey === sessionKey) : report.sessions;
+    const incompleteTurns = selectedSessions.reduce((sum, session) => sum + session.incompleteTurns, 0);
+    const brokenChains = selectedSessions.reduce((sum, session) => sum + session.brokenChains, 0);
+    const filteredIssues = report.issues.filter((issue) => !sessionKey || issue.sessionKey === sessionKey);
+    const issueCount = filteredIssues.length;
+    const severeIssueCount = filteredIssues.filter((issue) => issue.severity !== "info").length;
+    return {
+      generatedAt: report.generatedAt,
+      sessionKey,
+      healthy: sessionKey ? severeIssueCount === 0 && report.checkpoint.healthy : report.healthy,
+      issueCount,
+      incompleteTurns,
+      brokenChains,
+      checkpointHealthy: report.checkpoint.healthy
+    };
+  }
 };
 
 // src/summarizer.ts
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5, readdir as readdir4 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile6, readdir as readdir5 } from "fs/promises";
+import path8 from "path";
 import { z as z2 } from "zod";
 var HourlySummarySchema = z2.object({
   bullets: z2.array(z2.string()).describe("3-5 bullet points summarizing the hour's activity")
@@ -8191,7 +8614,7 @@ var HourlySummarizer = class {
   transcript;
   constructor(config, gatewayConfig, modelRegistry, transcript) {
     this.config = config;
-    this.summariesDir = path7.join(config.memoryDir, "summaries", "hourly");
+    this.summariesDir = path8.join(config.memoryDir, "summaries", "hourly");
     this.modelRegistry = modelRegistry ?? new ModelRegistry(config.memoryDir);
     this.transcript = transcript;
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
@@ -8459,15 +8882,15 @@ ${truncatedConversation}`;
   }
   // Save summary to file
   async saveSummary(summary) {
-    const sessionDir = path7.join(this.summariesDir, summary.sessionKey);
+    const sessionDir = path8.join(this.summariesDir, summary.sessionKey);
     await mkdir5(sessionDir, { recursive: true });
     const dateStr = summary.hour.slice(0, 10);
-    const filePath = path7.join(sessionDir, `${dateStr}.md`);
+    const filePath = path8.join(sessionDir, `${dateStr}.md`);
     const hourStr = summary.hour.slice(11, 13);
     const lines = [];
     let existingContent = "";
     try {
-      existingContent = await readFile5(filePath, "utf-8");
+      existingContent = await readFile6(filePath, "utf-8");
     } catch {
     }
     const hourHeader = `## ${hourStr}:00`;
@@ -8481,18 +8904,18 @@ ${truncatedConversation}`;
       } else {
         existingContent = beforeHour + newSection;
       }
-      await writeFile5(filePath, existingContent, "utf-8");
+      await writeFile6(filePath, existingContent, "utf-8");
       log.debug(`updated hourly summary for ${summary.sessionKey} at ${hourStr}:00`);
     } else {
       const newSection = this.formatHourSection(summary, hourHeader);
       if (existingContent) {
-        await writeFile5(filePath, existingContent.trimEnd() + "\n\n" + newSection, "utf-8");
+        await writeFile6(filePath, existingContent.trimEnd() + "\n\n" + newSection, "utf-8");
       } else {
         const header = `# Hourly Summaries \u2014 ${dateStr}
 
 *Session: ${summary.sessionKey}*
 `;
-        await writeFile5(filePath, header + "\n" + newSection, "utf-8");
+        await writeFile6(filePath, header + "\n" + newSection, "utf-8");
       }
       log.debug(`saved hourly summary for ${summary.sessionKey} at ${hourStr}:00`);
     }
@@ -8537,15 +8960,15 @@ ${truncatedConversation}`;
   }
   // Read recent summaries for recall injection
   async readRecent(sessionKey, hours) {
-    const sessionDir = path7.join(this.summariesDir, sessionKey);
+    const sessionDir = path8.join(this.summariesDir, sessionKey);
     try {
-      const files = await readdir4(sessionDir);
+      const files = await readdir5(sessionDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       const summaries = [];
       const cutoffTime = Date.now() - hours * 60 * 60 * 1e3;
       for (const file of mdFiles) {
-        const filePath = path7.join(sessionDir, file);
-        const content = await readFile5(filePath, "utf-8");
+        const filePath = path8.join(sessionDir, file);
+        const content = await readFile6(filePath, "utf-8");
         const parsed = this.parseSummaryFile(content, sessionKey, file);
         summaries.push(...parsed);
       }
@@ -8633,22 +9056,22 @@ ${truncatedConversation}`;
   }
   // Get list of active sessions from transcript directory
   async getActiveSessions() {
-    const transcriptDir = path7.join(this.config.memoryDir, "transcripts");
+    const transcriptDir = path8.join(this.config.memoryDir, "transcripts");
     try {
       const sessionKeys = /* @__PURE__ */ new Set();
-      const typeEntries = await readdir4(transcriptDir, { withFileTypes: true });
+      const typeEntries = await readdir5(transcriptDir, { withFileTypes: true });
       for (const typeEnt of typeEntries) {
         if (!typeEnt.isDirectory()) continue;
-        const typeDir = path7.join(transcriptDir, typeEnt.name);
-        const idEntries = await readdir4(typeDir, { withFileTypes: true });
+        const typeDir = path8.join(transcriptDir, typeEnt.name);
+        const idEntries = await readdir5(typeDir, { withFileTypes: true });
         for (const idEnt of idEntries) {
           if (!idEnt.isDirectory()) continue;
-          const chanDir = path7.join(typeDir, idEnt.name);
-          const files = (await readdir4(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
+          const chanDir = path8.join(typeDir, idEnt.name);
+          const files = (await readdir5(chanDir)).filter((f) => f.endsWith(".jsonl")).sort();
           const last = files[files.length - 1];
           if (!last) continue;
           try {
-            const raw = await readFile5(path7.join(chanDir, last), "utf-8");
+            const raw = await readFile6(path8.join(chanDir, last), "utf-8");
             const firstLine = raw.split("\n").find((l) => l.trim().length > 0);
             if (!firstLine) continue;
             const entry = JSON.parse(firstLine);
@@ -8683,15 +9106,15 @@ ${truncatedConversation}`;
         channelId = parts[3];
       }
     }
-    const transcriptDir = path7.join(this.config.memoryDir, "transcripts", channelType, channelId);
+    const transcriptDir = path8.join(this.config.memoryDir, "transcripts", channelType, channelId);
     try {
-      const files = await readdir4(transcriptDir);
+      const files = await readdir5(transcriptDir);
       const entries = [];
       for (const file of files) {
         if (!file.endsWith(".jsonl")) continue;
-        const transcriptPath = path7.join(transcriptDir, file);
+        const transcriptPath = path8.join(transcriptDir, file);
         try {
-          const content = await readFile5(transcriptPath, "utf-8");
+          const content = await readFile6(transcriptPath, "utf-8");
           const lines = content.trim().split("\n");
           for (const line of lines) {
             if (!line.trim()) continue;
@@ -9011,17 +9434,17 @@ async function rerankLocalOrNoop(opts) {
 }
 
 // src/relevance.ts
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import path9 from "path";
 var RelevanceStore = class {
   statePath;
   state = {};
   constructor(memoryDir) {
-    this.statePath = path8.join(memoryDir, "state", "relevance.json");
+    this.statePath = path9.join(memoryDir, "state", "relevance.json");
   }
   async load() {
     try {
-      const raw = await readFile6(this.statePath, "utf-8");
+      const raw = await readFile7(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") this.state = parsed;
     } catch {
@@ -9043,8 +9466,8 @@ var RelevanceStore = class {
     };
     this.state[memoryId] = next;
     try {
-      await mkdir6(path8.dirname(this.statePath), { recursive: true });
-      await writeFile6(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await mkdir6(path9.dirname(this.statePath), { recursive: true });
+      await writeFile7(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
     } catch (err) {
       log.debug(`relevance store write failed: ${err}`);
     }
@@ -9063,17 +9486,17 @@ var RelevanceStore = class {
 };
 
 // src/negative.ts
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import path10 from "path";
 var NegativeExampleStore = class {
   statePath;
   state = {};
   constructor(memoryDir) {
-    this.statePath = path9.join(memoryDir, "state", "negative_examples.json");
+    this.statePath = path10.join(memoryDir, "state", "negative_examples.json");
   }
   async load() {
     try {
-      const raw = await readFile7(this.statePath, "utf-8");
+      const raw = await readFile8(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") this.state = parsed;
     } catch {
@@ -9096,8 +9519,8 @@ var NegativeExampleStore = class {
       this.state[memoryId] = next;
     }
     try {
-      await mkdir7(path9.dirname(this.statePath), { recursive: true });
-      await writeFile7(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await mkdir7(path10.dirname(this.statePath), { recursive: true });
+      await writeFile8(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
     } catch (err) {
       log.debug(`negative example store write failed: ${err}`);
     }
@@ -9116,8 +9539,8 @@ var NegativeExampleStore = class {
 };
 
 // src/recall-state.ts
-import { appendFile as appendFile3, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
-import path10 from "path";
+import { appendFile as appendFile3, mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
+import path11 from "path";
 import { createHash as createHash2 } from "crypto";
 function clampGraphRecallExpandedEntries(entries, maxEntries = 64) {
   const limit = Math.max(1, Math.floor(maxEntries));
@@ -9152,12 +9575,12 @@ var LastRecallStore = class {
   impressionsPath;
   state = {};
   constructor(memoryDir) {
-    this.statePath = path10.join(memoryDir, "state", "last_recall.json");
-    this.impressionsPath = path10.join(memoryDir, "state", "recall_impressions.jsonl");
+    this.statePath = path11.join(memoryDir, "state", "last_recall.json");
+    this.impressionsPath = path11.join(memoryDir, "state", "recall_impressions.jsonl");
   }
   async load() {
     try {
-      const raw = await readFile8(this.statePath, "utf-8");
+      const raw = await readFile9(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") this.state = parsed;
     } catch {
@@ -9200,13 +9623,13 @@ var LastRecallStore = class {
       }
     }
     try {
-      await mkdir8(path10.dirname(this.statePath), { recursive: true });
-      await writeFile8(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await mkdir8(path11.dirname(this.statePath), { recursive: true });
+      await writeFile9(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last recall store write failed: ${err}`);
     }
     try {
-      await mkdir8(path10.dirname(this.impressionsPath), { recursive: true });
+      await mkdir8(path11.dirname(this.impressionsPath), { recursive: true });
       await appendFile3(this.impressionsPath, JSON.stringify(snapshot) + "\n", "utf-8");
     } catch (err) {
       log.debug(`recall impressions append failed: ${err}`);
@@ -9217,11 +9640,11 @@ var TierMigrationStatusStore = class {
   statePath;
   state = structuredClone(DEFAULT_TIER_MIGRATION_STATUS);
   constructor(memoryDir) {
-    this.statePath = path10.join(memoryDir, "state", "tier-migration-status.json");
+    this.statePath = path11.join(memoryDir, "state", "tier-migration-status.json");
   }
   async load() {
     try {
-      const raw = await readFile8(this.statePath, "utf-8");
+      const raw = await readFile9(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") {
         this.state = structuredClone(DEFAULT_TIER_MIGRATION_STATUS);
@@ -9270,8 +9693,8 @@ var TierMigrationStatusStore = class {
     };
     this.state = next;
     try {
-      await mkdir8(path10.dirname(this.statePath), { recursive: true });
-      await writeFile8(this.statePath, JSON.stringify(next, null, 2), "utf-8");
+      await mkdir8(path11.dirname(this.statePath), { recursive: true });
+      await writeFile9(this.statePath, JSON.stringify(next, null, 2), "utf-8");
     } catch (err) {
       log.debug(`tier migration status write failed: ${err}`);
     }
@@ -9279,8 +9702,8 @@ var TierMigrationStatusStore = class {
 };
 
 // src/session-observer-state.ts
-import path11 from "path";
-import { mkdir as mkdir9, open, readFile as readFile9, stat as stat3, unlink as unlink3, writeFile as writeFile9 } from "fs/promises";
+import path12 from "path";
+import { mkdir as mkdir9, open, readFile as readFile10, stat as stat3, unlink as unlink4, writeFile as writeFile10 } from "fs/promises";
 function sanitizeNonNegativeInt(value) {
   if (!Number.isFinite(value)) return 0;
   return Math.max(0, Math.floor(value));
@@ -9356,7 +9779,7 @@ var SessionObserverState = class {
   saveQueue = Promise.resolve();
   async readPersistedState() {
     try {
-      const raw = await readFile9(this.statePath, "utf-8");
+      const raw = await readFile10(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed?.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object") {
         return null;
@@ -9382,13 +9805,13 @@ var SessionObserverState = class {
     return next;
   }
   constructor(opts) {
-    this.statePath = path11.join(opts.memoryDir, "state", "session-observer-state.json");
-    this.lockPath = path11.join(opts.memoryDir, "state", "session-observer-state.lock");
+    this.statePath = path12.join(opts.memoryDir, "state", "session-observer-state.json");
+    this.lockPath = path12.join(opts.memoryDir, "state", "session-observer-state.lock");
     this.debounceMs = Math.max(0, Math.floor(opts.debounceMs));
     this.bands = normalizeObserverBands(opts.bands);
   }
   async withSaveLock(fn) {
-    await mkdir9(path11.dirname(this.lockPath), { recursive: true });
+    await mkdir9(path12.dirname(this.lockPath), { recursive: true });
     for (let attempt = 0; attempt < 80; attempt++) {
       try {
         const handle = await open(this.lockPath, "wx");
@@ -9396,7 +9819,7 @@ var SessionObserverState = class {
           await fn();
         } finally {
           await handle.close();
-          await unlink3(this.lockPath).catch(() => {
+          await unlink4(this.lockPath).catch(() => {
           });
         }
         return;
@@ -9405,7 +9828,7 @@ var SessionObserverState = class {
         try {
           const lockInfo = await stat3(this.lockPath);
           if (Date.now() - lockInfo.mtimeMs > this.lockStaleMs) {
-            await unlink3(this.lockPath).catch(() => {
+            await unlink4(this.lockPath).catch(() => {
             });
             continue;
           }
@@ -9449,8 +9872,8 @@ var SessionObserverState = class {
         sessions[key] = value;
       }
       const payload = { version: 1, sessions };
-      await mkdir9(path11.dirname(this.statePath), { recursive: true });
-      await writeFile9(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await mkdir9(path12.dirname(this.statePath), { recursive: true });
+      await writeFile10(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
     });
   }
   enqueueSave() {
@@ -9543,13 +9966,13 @@ var SessionObserverState = class {
 };
 
 // src/embedding-fallback.ts
-import path12 from "path";
-import { mkdir as mkdir10, readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
+import path13 from "path";
+import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile11 } from "fs/promises";
 var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
 var EmbeddingFallback = class {
   constructor(config) {
     this.config = config;
-    this.indexPath = path12.join(config.memoryDir, "state", "embeddings.json");
+    this.indexPath = path13.join(config.memoryDir, "state", "embeddings.json");
   }
   indexPath;
   loaded = null;
@@ -9659,7 +10082,7 @@ var EmbeddingFallback = class {
       return this.loaded;
     }
     try {
-      const raw = await readFile10(this.indexPath, "utf-8");
+      const raw = await readFile11(this.indexPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.version === 1 && parsed.entries && typeof parsed.entries === "object") {
         this.loaded = {
@@ -9681,14 +10104,14 @@ var EmbeddingFallback = class {
     return this.loaded;
   }
   async saveIndex(index) {
-    await mkdir10(path12.dirname(this.indexPath), { recursive: true });
-    await writeFile10(this.indexPath, JSON.stringify(index), "utf-8");
+    await mkdir10(path13.dirname(this.indexPath), { recursive: true });
+    await writeFile11(this.indexPath, JSON.stringify(index), "utf-8");
     this.loaded = index;
   }
 };
 function toMemoryRelativePath(memoryDir, filePath) {
-  if (!path12.isAbsolute(filePath)) return filePath;
-  const rel = path12.relative(memoryDir, filePath);
+  if (!path13.isAbsolute(filePath)) return filePath;
+  const rel = path13.relative(memoryDir, filePath);
   return rel.startsWith("..") ? filePath : rel;
 }
 function cosineSimilarity(a, b) {
@@ -9710,8 +10133,8 @@ function cosineSimilarity(a, b) {
 }
 
 // src/bootstrap.ts
-import path13 from "path";
-import { readdir as readdir5, readFile as readFile11 } from "fs/promises";
+import path14 from "path";
+import { readdir as readdir6, readFile as readFile12 } from "fs/promises";
 var BootstrapEngine = class {
   constructor(config, orchestrator) {
     this.config = config;
@@ -9790,7 +10213,7 @@ var BootstrapEngine = class {
     for (const filePath of files) {
       let raw = "";
       try {
-        raw = await readFile11(filePath, "utf-8");
+        raw = await readFile12(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -9808,7 +10231,7 @@ var BootstrapEngine = class {
         const role = String(parsed?.role ?? "");
         const content = typeof parsed?.content === "string" ? parsed.content : "";
         if (!role || !content) continue;
-        const sessionKey = typeof parsed?.sessionKey === "string" && parsed.sessionKey.length > 0 ? parsed.sessionKey : path13.relative(baseDir, filePath);
+        const sessionKey = typeof parsed?.sessionKey === "string" && parsed.sessionKey.length > 0 ? parsed.sessionKey : path14.relative(baseDir, filePath);
         const list = bySession.get(sessionKey) ?? [];
         list.push({
           role,
@@ -9826,9 +10249,9 @@ var BootstrapEngine = class {
   }
   async listJsonlFiles(dir) {
     const out = [];
-    const entries = await readdir5(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir6(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = path13.join(dir, entry.name);
+      const full = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         out.push(...await this.listJsonlFiles(full));
       } else if (entry.isFile() && full.endsWith(".jsonl")) {
@@ -10343,8 +10766,8 @@ function renderCompressionGuidelinesMarkdown(candidate) {
 }
 
 // src/boxes.ts
-import { mkdir as mkdir11, writeFile as writeFile11, readFile as readFile12, readdir as readdir6 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir11, writeFile as writeFile12, readFile as readFile13, readdir as readdir7 } from "fs/promises";
+import path15 from "path";
 import { createHash as createHash3 } from "crypto";
 var BOX_DIR = "boxes";
 var STATE_DIR = "state";
@@ -10419,23 +10842,23 @@ var BoxBuilder = class {
     this.cfg = cfg;
   }
   get boxBaseDir() {
-    return path14.join(this.baseDir, BOX_DIR);
+    return path15.join(this.baseDir, BOX_DIR);
   }
   get stateDir() {
-    return path14.join(this.baseDir, STATE_DIR);
+    return path15.join(this.baseDir, STATE_DIR);
   }
   get openBoxStatePath() {
-    return path14.join(this.stateDir, OPEN_BOX_STATE_FILE);
+    return path15.join(this.stateDir, OPEN_BOX_STATE_FILE);
   }
   get tracesPath() {
-    return path14.join(this.stateDir, TRACES_FILE);
+    return path15.join(this.stateDir, TRACES_FILE);
   }
   // ── State persistence ────────────────────────────────────────────────────
   async loadOpenBox() {
     if (this.stateLoaded) return;
     this.stateLoaded = true;
     try {
-      const raw = await readFile12(this.openBoxStatePath, "utf-8");
+      const raw = await readFile13(this.openBoxStatePath, "utf-8");
       this.openBox = JSON.parse(raw);
     } catch {
       this.openBox = null;
@@ -10444,17 +10867,17 @@ var BoxBuilder = class {
   async saveOpenBox() {
     await mkdir11(this.stateDir, { recursive: true });
     if (this.openBox) {
-      await writeFile11(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
+      await writeFile12(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
     } else {
       try {
-        await writeFile11(this.openBoxStatePath, "null", "utf-8");
+        await writeFile12(this.openBoxStatePath, "null", "utf-8");
       } catch {
       }
     }
   }
   async loadTraceIndex() {
     try {
-      const raw = await readFile12(this.tracesPath, "utf-8");
+      const raw = await readFile13(this.tracesPath, "utf-8");
       const parsed = JSON.parse(raw);
       parsed.traceLastSeen ??= {};
       return parsed;
@@ -10465,7 +10888,7 @@ var BoxBuilder = class {
   async saveTraceIndex(idx) {
     try {
       await mkdir11(this.stateDir, { recursive: true });
-      await writeFile11(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
+      await writeFile12(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
     } catch (err) {
       log.warn(`[engram/boxes] Failed to save trace index: ${err.message}`);
     }
@@ -10541,7 +10964,7 @@ var BoxBuilder = class {
     }
     const sealedAt = (/* @__PURE__ */ new Date()).toISOString();
     const day = sealedAt.slice(0, 10);
-    const dir = path14.join(this.boxBaseDir, day);
+    const dir = path15.join(this.boxBaseDir, day);
     await mkdir11(dir, { recursive: true });
     let traceId;
     if (this.cfg.traceWeaverEnabled && box.topics.length > 0) {
@@ -10561,8 +10984,8 @@ var BoxBuilder = class {
 
 <!-- Topics: ${box.topics.join(", ")} | Memories: ${box.memoryIds.length} -->
 `;
-    const filePath = path14.join(dir, `${box.id}.md`);
-    await writeFile11(filePath, content, "utf-8");
+    const filePath = path15.join(dir, `${box.id}.md`);
+    await writeFile12(filePath, content, "utf-8");
     log.debug(`[boxes] sealed box ${box.id} (${reason}): ${box.memoryIds.length} memories, topics=[${box.topics.join(",")}]`);
     await this.saveOpenBox();
     return box.id;
@@ -10611,14 +11034,14 @@ var BoxBuilder = class {
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
     const walkDir = async (dir) => {
       try {
-        const entries = await readdir6(dir, { withFileTypes: true });
+        const entries = await readdir7(dir, { withFileTypes: true });
         for (const e of entries) {
-          const full = path14.join(dir, e.name);
+          const full = path15.join(dir, e.name);
           if (e.isDirectory()) {
             await walkDir(full);
           } else if (e.name.endsWith(".md")) {
             try {
-              const raw = await readFile12(full, "utf-8");
+              const raw = await readFile13(full, "utf-8");
               const parsed = parseBoxFrontmatter(raw);
               if (parsed && new Date(parsed.sealedAt) >= cutoff) {
                 boxes.push(parsed);
@@ -10726,8 +11149,8 @@ function classifyMemoryKind(content, tags, category) {
 
 // src/tmt.ts
 import * as fs from "fs";
-import * as path15 from "path";
-import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile12, readdir as readdir7 } from "fs/promises";
+import * as path16 from "path";
+import { mkdir as mkdir12, readFile as readFile14, writeFile as writeFile13, readdir as readdir8 } from "fs/promises";
 var TMT_DIR = "tmt";
 var TMT_LEVEL_INPUT_LIMITS = {
   hour: { totalChars: 48e3, itemChars: 2e3, maxItems: 64 },
@@ -10756,19 +11179,19 @@ function capTmtSummaryInputs(inputs, level) {
   return [fallback.length > itemChars ? `${fallback.slice(0, itemChars - 1)}\u2026` : fallback];
 }
 function tmtDir(baseDir) {
-  return path15.join(baseDir, TMT_DIR);
+  return path16.join(baseDir, TMT_DIR);
 }
 function hourNodePath(baseDir, date, hour) {
-  return path15.join(tmtDir(baseDir), date, `hour-${hour}.md`);
+  return path16.join(tmtDir(baseDir), date, `hour-${hour}.md`);
 }
 function dayNodePath(baseDir, date) {
-  return path15.join(tmtDir(baseDir), date, "day.md");
+  return path16.join(tmtDir(baseDir), date, "day.md");
 }
 function weekNodePath(baseDir, weekKey) {
-  return path15.join(tmtDir(baseDir), `week-${weekKey}.md`);
+  return path16.join(tmtDir(baseDir), `week-${weekKey}.md`);
 }
 function personaNodePath(baseDir) {
-  return path15.join(tmtDir(baseDir), "persona.md");
+  return path16.join(tmtDir(baseDir), "persona.md");
 }
 function serialiseTmtNode(fm, summary) {
   const yaml = [
@@ -10839,7 +11262,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile13(nodePath, "utf8");
+          const existing = await readFile14(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -10865,8 +11288,8 @@ var TmtBuilder = class {
         sourceIds: entries.map((e) => e.id),
         builtAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await mkdir12(path15.dirname(nodePath), { recursive: true });
-      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await mkdir12(path16.dirname(nodePath), { recursive: true });
+      await writeFile13(nodePath, serialiseTmtNode(fm, summary), "utf8");
     }
   }
   async buildDayNodes(memories, summarize2) {
@@ -10881,7 +11304,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile13(nodePath, "utf8");
+          const existing = await readFile14(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -10902,7 +11325,7 @@ var TmtBuilder = class {
         const hPath = hourNodePath(this.baseDir, date, h);
         if (fs.existsSync(hPath)) {
           try {
-            const hContent = await readFile13(hPath, "utf8");
+            const hContent = await readFile14(hPath, "utf8");
             const hSummary = hContent.replace(/^---[\s\S]*?---\n\n?/, "").trim();
             if (hSummary) {
               inputs.push(hSummary);
@@ -10930,8 +11353,8 @@ var TmtBuilder = class {
         sourceIds: entries.map((e) => e.id),
         builtAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await mkdir12(path15.dirname(nodePath), { recursive: true });
-      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await mkdir12(path16.dirname(nodePath), { recursive: true });
+      await writeFile13(nodePath, serialiseTmtNode(fm, summary), "utf8");
     }
   }
   /**
@@ -10952,7 +11375,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile13(nodePath, "utf8");
+          const existing = await readFile14(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -10966,7 +11389,7 @@ var TmtBuilder = class {
         const dir = tmtDir(this.baseDir);
         let allDirs = [];
         try {
-          allDirs = await readdir7(dir);
+          allDirs = await readdir8(dir);
         } catch {
           continue;
         }
@@ -10978,7 +11401,7 @@ var TmtBuilder = class {
           const dayPath = dayNodePath(this.baseDir, dateDir);
           if (fs.existsSync(dayPath)) {
             try {
-              const content = await readFile13(dayPath, "utf8");
+              const content = await readFile14(dayPath, "utf8");
               const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
               if (summary2) daySummaries.push(summary2);
             } catch {
@@ -10996,8 +11419,8 @@ var TmtBuilder = class {
           sourceIds: entries.map((e) => e.id),
           builtAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await mkdir12(path15.dirname(nodePath), { recursive: true });
-        await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
+        await mkdir12(path16.dirname(nodePath), { recursive: true });
+        await writeFile13(nodePath, serialiseTmtNode(fm, summary), "utf8");
       } catch (err) {
         console.warn(`[engram] tmt: week node build failed for ${week} (ignored): ${err}`);
       }
@@ -11013,7 +11436,7 @@ var TmtBuilder = class {
       const dir = tmtDir(this.baseDir);
       let allFiles = [];
       try {
-        allFiles = await readdir7(dir);
+        allFiles = await readdir8(dir);
       } catch {
         return;
       }
@@ -11025,7 +11448,7 @@ var TmtBuilder = class {
       let latestEnd;
       for (const f of weekFiles) {
         try {
-          const content = await readFile13(path15.join(dir, f), "utf8");
+          const content = await readFile14(path16.join(dir, f), "utf8");
           const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
           if (summary2) weekSummaries.push(summary2);
           const countMatch = content.match(/memoryCount: (\d+)/);
@@ -11046,7 +11469,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile13(nodePath, "utf8");
+          const existing = await readFile14(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) !== totalCount) {
             shouldBuild = true;
@@ -11066,7 +11489,7 @@ var TmtBuilder = class {
         sourceIds: [],
         builtAt: now
       };
-      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await writeFile13(nodePath, serialiseTmtNode(fm, summary), "utf8");
     } catch (err) {
       console.warn(`[engram] tmt: persona node build failed (ignored): ${err}`);
     }
@@ -11084,13 +11507,13 @@ var TmtBuilder = class {
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const todayDay = dayNodePath(this.baseDir, today);
       if (fs.existsSync(todayDay)) {
-        const content = await readFile13(todayDay, "utf8");
+        const content = await readFile14(todayDay, "utf8");
         const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
         if (summary) return { level: "day", summary };
       }
       let entries = [];
       try {
-        entries = await readdir7(dir);
+        entries = await readdir8(dir);
       } catch {
         return null;
       }
@@ -11098,7 +11521,7 @@ var TmtBuilder = class {
       for (const dateDir of dateDirs) {
         const dayPath = dayNodePath(this.baseDir, dateDir);
         if (fs.existsSync(dayPath)) {
-          const content = await readFile13(dayPath, "utf8");
+          const content = await readFile14(dayPath, "utf8");
           const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
           if (summary) return { level: "day", summary };
         }
@@ -11112,18 +11535,18 @@ var TmtBuilder = class {
 
 // src/temporal-index.ts
 import * as fs2 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 var INDEX_VERSION = 1;
 var TEMPORAL_INDEX_FILE = "index_time.json";
 var TAG_INDEX_FILE = "index_tags.json";
 function stateDir(memoryDir) {
-  return path16.join(memoryDir, "state");
+  return path17.join(memoryDir, "state");
 }
 function temporalIndexPath(memoryDir) {
-  return path16.join(stateDir(memoryDir), TEMPORAL_INDEX_FILE);
+  return path17.join(stateDir(memoryDir), TEMPORAL_INDEX_FILE);
 }
 function tagIndexPath(memoryDir) {
-  return path16.join(stateDir(memoryDir), TAG_INDEX_FILE);
+  return path17.join(stateDir(memoryDir), TAG_INDEX_FILE);
 }
 function ensureStateDir(memoryDir) {
   const dir = stateDir(memoryDir);
@@ -11357,8 +11780,8 @@ function recencyWindowFromPrompt(prompt, nowMs = Date.now()) {
 }
 
 // src/graph.ts
-import { mkdir as mkdir13, appendFile as appendFile4, readFile as readFile14 } from "fs/promises";
-import * as path17 from "path";
+import { mkdir as mkdir13, appendFile as appendFile4, readFile as readFile15 } from "fs/promises";
+import * as path18 from "path";
 var CAUSAL_PHRASES = [
   "as a result",
   "led to",
@@ -11368,10 +11791,10 @@ var CAUSAL_PHRASES = [
   "because"
 ];
 function graphsDir(memoryDir) {
-  return path17.join(memoryDir, "state", "graphs");
+  return path18.join(memoryDir, "state", "graphs");
 }
 function graphFilePath(memoryDir, type) {
-  return path17.join(graphsDir(memoryDir), `${type}.jsonl`);
+  return path18.join(graphsDir(memoryDir), `${type}.jsonl`);
 }
 async function ensureGraphsDir(memoryDir) {
   await mkdir13(graphsDir(memoryDir), { recursive: true });
@@ -11384,7 +11807,7 @@ async function appendEdge(memoryDir, edge) {
 async function readEdges(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
   try {
-    const raw = await readFile14(filePath, "utf8");
+    const raw = await readFile15(filePath, "utf8");
     const edges = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -11427,7 +11850,7 @@ async function analyzeGraphHealth(memoryDir, options) {
     let corruptLines = 0;
     const nodes = /* @__PURE__ */ new Set();
     try {
-      const raw = await readFile14(filePath, "utf8");
+      const raw = await readFile15(filePath, "utf8");
       for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -11751,8 +12174,8 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 }
 
 // src/conversation-index/indexer.ts
-import { mkdir as mkdir14, writeFile as writeFile13 } from "fs/promises";
-import path18 from "path";
+import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
+import path19 from "path";
 function sanitizeSessionKey(sessionKey) {
   const raw = typeof sessionKey === "string" && sessionKey.trim().length > 0 ? sessionKey : "unknown-session";
   return raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "_").slice(0, 200);
@@ -11762,9 +12185,9 @@ async function writeConversationChunks(rootDir, chunks) {
   for (const c of chunks) {
     const safe = sanitizeSessionKey(c.sessionKey);
     const date = c.startTs.slice(0, 10);
-    const dir = path18.join(rootDir, safe, date);
+    const dir = path19.join(rootDir, safe, date);
     await mkdir14(dir, { recursive: true });
-    const fp = path18.join(dir, `${c.id}.md`);
+    const fp = path19.join(dir, `${c.id}.md`);
     const content = `---
 kind: conversation_chunk
 sessionKey: ${c.sessionKey}
@@ -11773,7 +12196,7 @@ endTs: ${c.endTs}
 ---
 
 ` + c.text + "\n";
-    await writeFile13(fp, content, "utf-8");
+    await writeFile14(fp, content, "utf-8");
     written.push(fp);
   }
   return written;
@@ -11792,28 +12215,28 @@ async function upsertConversationChunksFailOpen(adapter, chunks) {
 }
 
 // src/conversation-index/cleanup.ts
-import { readdir as readdir8, rm } from "fs/promises";
-import path19 from "path";
+import { readdir as readdir9, rm } from "fs/promises";
+import path20 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
   try {
-    const sessions = await readdir8(rootDir, { withFileTypes: true });
+    const sessions = await readdir9(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path19.join(rootDir, s.name);
-      const dayDirs = await readdir8(sessionDir, { withFileTypes: true });
+      const sessionDir = path20.join(rootDir, s.name);
+      const dayDirs = await readdir9(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
         if (!/^\d{4}-\d{2}-\d{2}$/.test(d.name)) continue;
         const dayMs = (/* @__PURE__ */ new Date(d.name + "T00:00:00.000Z")).getTime();
         if (!Number.isFinite(dayMs)) continue;
         if (dayMs < cutoffMs) {
-          await rm(path19.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm(path20.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
-        const remaining = await readdir8(sessionDir);
+        const remaining = await readdir9(sessionDir);
         if (remaining.length === 0) {
           await rm(sessionDir, { recursive: true, force: true });
         }
@@ -11828,7 +12251,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 // src/conversation-index/faiss-adapter.ts
 import * as childProcess from "child_process";
 import { fileURLToPath } from "url";
-import path20 from "path";
+import path21 from "path";
 var FaissAdapterError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -11838,18 +12261,18 @@ var FaissAdapterError = class extends Error {
 };
 function resolveDefaultFaissScriptPath(fromModuleUrl = import.meta.url) {
   const currentFile = fileURLToPath(fromModuleUrl);
-  const moduleDir = path20.dirname(currentFile);
-  if (moduleDir.endsWith(`${path20.sep}conversation-index`)) {
-    return path20.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
+  const moduleDir = path21.dirname(currentFile);
+  if (moduleDir.endsWith(`${path21.sep}conversation-index`)) {
+    return path21.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
   }
-  return path20.resolve(moduleDir, "..", "scripts", "faiss_index.py");
+  return path21.resolve(moduleDir, "..", "scripts", "faiss_index.py");
 }
 var FaissConversationIndexAdapter = class {
   constructor(config) {
     this.config = config;
     this.pythonBin = config.pythonBin && config.pythonBin.trim().length > 0 ? config.pythonBin.trim() : "python3";
     this.scriptPath = config.scriptPath && config.scriptPath.trim().length > 0 ? config.scriptPath.trim() : resolveDefaultFaissScriptPath();
-    this.indexPath = path20.isAbsolute(config.indexDir) ? config.indexDir : path20.join(config.memoryDir, config.indexDir);
+    this.indexPath = path21.isAbsolute(config.indexDir) ? config.indexDir : path21.join(config.memoryDir, config.indexDir);
     this.spawnFn = config.spawnFn ?? childProcess.spawn;
   }
   pythonBin;
@@ -12030,7 +12453,7 @@ async function searchConversationIndexFaissFailOpen(adapter, query, maxResults)
 }
 
 // src/namespaces/storage.ts
-import path21 from "path";
+import path22 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -12052,7 +12475,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path21.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path22.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -12061,7 +12484,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path21.join(this.config.memoryDir, "namespaces", namespace);
+    return path22.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -12137,8 +12560,8 @@ function recallNamespacesForPrincipal(principal, config) {
 }
 
 // src/shared-context/manager.ts
-import { mkdir as mkdir15, readFile as readFile15, readdir as readdir9, appendFile as appendFile5, writeFile as writeFile14, stat as stat4 } from "fs/promises";
-import path22 from "path";
+import { mkdir as mkdir15, readFile as readFile16, readdir as readdir10, appendFile as appendFile5, writeFile as writeFile15, stat as stat4 } from "fs/promises";
+import path23 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -12334,15 +12757,15 @@ async function computeSemanticOverlapsWithTimeout(sources, timeoutMs, maxCandida
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path22.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path23.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path22.join(base, "priorities.md");
-    this.prioritiesInboxPath = path22.join(base, "priorities.inbox.md");
-    this.outputsDir = path22.join(base, "agent-outputs");
-    this.roundtableDir = path22.join(base, "roundtable");
-    this.feedbackDir = path22.join(base, "feedback");
-    this.feedbackInboxPath = path22.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path22.join(base, "cross-signals");
+    this.prioritiesPath = path23.join(base, "priorities.md");
+    this.prioritiesInboxPath = path23.join(base, "priorities.inbox.md");
+    this.outputsDir = path23.join(base, "agent-outputs");
+    this.roundtableDir = path23.join(base, "roundtable");
+    this.feedbackDir = path23.join(base, "feedback");
+    this.feedbackInboxPath = path23.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path23.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -12358,10 +12781,10 @@ var SharedContextManager = class {
     await mkdir15(this.roundtableDir, { recursive: true });
     await mkdir15(this.feedbackDir, { recursive: true });
     await mkdir15(this.crossSignalsDir, { recursive: true });
-    await mkdir15(path22.join(this.dir, "staging"), { recursive: true });
-    await mkdir15(path22.join(this.dir, "kpis"), { recursive: true });
-    await mkdir15(path22.join(this.dir, "calendar"), { recursive: true });
-    await mkdir15(path22.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir15(path23.join(this.dir, "staging"), { recursive: true });
+    await mkdir15(path23.join(this.dir, "kpis"), { recursive: true });
+    await mkdir15(path23.join(this.dir, "calendar"), { recursive: true });
+    await mkdir15(path23.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -12392,22 +12815,22 @@ var SharedContextManager = class {
     try {
       await stat4(fp);
     } catch {
-      await writeFile14(fp, content, "utf-8");
+      await writeFile15(fp, content, "utf-8");
     }
   }
   async readPriorities() {
     try {
-      return await readFile15(this.prioritiesPath, "utf-8");
+      return await readFile16(this.prioritiesPath, "utf-8");
     } catch {
       return "";
     }
   }
   async readLatestRoundtable() {
     try {
-      const files = (await readdir9(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path22.join(this.roundtableDir, files[0]) : null;
+      const files = (await readdir10(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
+      const fp = files[0] ? path23.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
-      return await readFile15(fp, "utf-8");
+      return await readFile16(fp, "utf-8");
     } catch {
       return "";
     }
@@ -12417,9 +12840,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path22.join(this.outputsDir, opts.agentId, date);
+    const dir = path23.join(this.outputsDir, opts.agentId, date);
     await mkdir15(dir, { recursive: true });
-    const fp = path22.join(dir, `${time}-${slug}.md`);
+    const fp = path23.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -12428,7 +12851,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 ---
 
 ` + opts.content.trimEnd() + "\n";
-    await writeFile14(fp, body, "utf-8");
+    await writeFile15(fp, body, "utf-8");
     return fp;
   }
   async appendFeedback(entry) {
@@ -12451,15 +12874,15 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
     const maxChars = Math.max(2e3, opts.maxChars ?? 2e4);
     const outputs = [];
     try {
-      const agents = await readdir9(this.outputsDir, { withFileTypes: true });
+      const agents = await readdir10(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path22.join(this.outputsDir, a.name, date);
+        const dayDir = path23.join(this.outputsDir, a.name, date);
         try {
-          const files = (await readdir9(dayDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await readdir10(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path22.join(dayDir, f);
-            const raw = await readFile15(p, "utf-8");
+            const p = path23.join(dayDir, f);
+            const raw = await readFile16(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ agent: a.name, path: p, title, raw });
           }
@@ -12470,7 +12893,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
     }
     const feedback = [];
     try {
-      const raw = await readFile15(this.feedbackInboxPath, "utf-8");
+      const raw = await readFile16(this.feedbackInboxPath, "utf-8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         try {
@@ -12565,8 +12988,8 @@ ${body}`)
         addedOverlapCount: semanticAddedOverlapCount
       }
     };
-    const crossSignalsPath = path22.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile14(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
+    const crossSignalsPath = path23.join(this.crossSignalsDir, `${date}.json`);
+    await writeFile15(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
 `, "utf-8");
     const overlapBullets = mergedOverlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : mergedOverlaps.slice(0, 8).map((entry) => `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")})`);
     const md = [
@@ -12589,8 +13012,8 @@ ${body}`)
     ];
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const roundtablePath = path22.join(this.roundtableDir, `${date}.md`);
-    await writeFile14(roundtablePath, trimmed, "utf-8");
+    const roundtablePath = path23.join(this.roundtableDir, `${date}.md`);
+    await writeFile15(roundtablePath, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
     return {
       date,
@@ -12602,8 +13025,8 @@ ${body}`)
 };
 
 // src/compounding/engine.ts
-import { mkdir as mkdir16, readFile as readFile16, readdir as readdir10, writeFile as writeFile15 } from "fs/promises";
-import path23 from "path";
+import { mkdir as mkdir16, readFile as readFile17, readdir as readdir11, writeFile as writeFile16 } from "fs/promises";
+import path24 from "path";
 import os4 from "os";
 function defaultTierMigrationCycleBudget(config, trigger) {
   if (trigger === "extraction") {
@@ -12650,7 +13073,7 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path23.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path24.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
@@ -12669,16 +13092,16 @@ function cadenceStaleWindowMs(cadence) {
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path23.join(config.memoryDir, "compounding", "weekly");
-    this.rubricsPath = path23.join(config.memoryDir, "compounding", "rubrics.md");
-    this.mistakesPath = path23.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path23.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path23.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path23.join(config.memoryDir, "identity", "incidents");
-    this.identityAuditWeeklyDir = path23.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path23.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path23.join(config.memoryDir, "identity", "improvement-loops.md");
-    this.memoryActionEventsPath = path23.join(config.memoryDir, "state", "memory-actions.jsonl");
+    this.weeklyDir = path24.join(config.memoryDir, "compounding", "weekly");
+    this.rubricsPath = path24.join(config.memoryDir, "compounding", "rubrics.md");
+    this.mistakesPath = path24.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path24.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.identityAnchorPath = path24.join(config.memoryDir, "identity", "identity-anchor.md");
+    this.identityIncidentsDir = path24.join(config.memoryDir, "identity", "incidents");
+    this.identityAuditWeeklyDir = path24.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path24.join(config.memoryDir, "identity", "audits", "monthly");
+    this.identityImprovementLoopsPath = path24.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.memoryActionEventsPath = path24.join(config.memoryDir, "state", "memory-actions.jsonl");
   }
   weeklyDir;
   rubricsPath;
@@ -12692,8 +13115,8 @@ var CompoundingEngine = class {
   memoryActionEventsPath;
   async ensureDirs() {
     await mkdir16(this.weeklyDir, { recursive: true });
-    await mkdir16(path23.dirname(this.mistakesPath), { recursive: true });
-    await mkdir16(path23.dirname(this.rubricsPath), { recursive: true });
+    await mkdir16(path24.dirname(this.mistakesPath), { recursive: true });
+    await mkdir16(path24.dirname(this.rubricsPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
@@ -12704,12 +13127,12 @@ var CompoundingEngine = class {
     const promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary) : [];
     const mistakes = this.buildMistakes(entries, actionPatterns);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path23.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path24.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, mistakes.details, continuity, outcomeSummary, promotionCandidates);
-    await writeFile15(reportPath, md, "utf-8");
+    await writeFile16(reportPath, md, "utf-8");
     const rubrics = this.formatRubrics(entries, outcomeSummary);
-    await writeFile15(this.rubricsPath, rubrics, "utf-8");
-    await writeFile15(
+    await writeFile16(this.rubricsPath, rubrics, "utf-8");
+    await writeFile16(
       this.mistakesPath,
       JSON.stringify({ updatedAt: mistakes.updatedAt, patterns: mistakes.patterns }, null, 2) + "\n",
       "utf-8"
@@ -12790,13 +13213,13 @@ var CompoundingEngine = class {
     ];
     const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
     await mkdir16(dir, { recursive: true });
-    const reportPath = path23.join(dir, `${key}.md`);
-    await writeFile15(reportPath, lines.join("\n"), "utf-8");
+    const reportPath = path24.join(dir, `${key}.md`);
+    await writeFile16(reportPath, lines.join("\n"), "utf-8");
     return { period, key, reportPath };
   }
   async readMistakes() {
     try {
-      const raw = await readFile16(this.mistakesPath, "utf-8");
+      const raw = await readFile17(this.mistakesPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || !Array.isArray(parsed.patterns)) return null;
       return parsed;
@@ -12810,7 +13233,7 @@ var CompoundingEngine = class {
   async readFeedbackEntriesForWeek(weekId) {
     const out = [];
     try {
-      const raw = await readFile16(this.feedbackInboxPath, "utf-8");
+      const raw = await readFile17(this.feedbackInboxPath, "utf-8");
       const lines = raw.split("\n");
       for (let idx = 0; idx < lines.length; idx += 1) {
         const line = lines[idx];
@@ -12852,7 +13275,7 @@ var CompoundingEngine = class {
   async readActionEventsForWeek(weekId) {
     const out = [];
     try {
-      const raw = await readFile16(this.memoryActionEventsPath, "utf-8");
+      const raw = await readFile17(this.memoryActionEventsPath, "utf-8");
       const lines = raw.split("\n");
       for (let idx = 0; idx < lines.length; idx += 1) {
         const line = lines[idx];
@@ -12890,7 +13313,7 @@ var CompoundingEngine = class {
       else if (event.outcome === "skipped") acc.counts.skipped += 1;
       else if (event.outcome === "failed") acc.counts.failed += 1;
       else acc.counts.unknown += 1;
-      acc.provenance.add(`${path23.basename(this.memoryActionEventsPath)}:L${event.line}`);
+      acc.provenance.add(`${path24.basename(this.memoryActionEventsPath)}:L${event.line}`);
       byAction.set(key, acc);
     }
     const out = [];
@@ -12928,7 +13351,7 @@ var CompoundingEngine = class {
     const patterns = [];
     for (const wrapped of entries) {
       const e = wrapped.entry;
-      const provenance = [`${path23.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
+      const provenance = [`${path24.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
       if (e.learning && e.learning.trim().length > 0) {
         patterns.push({ pattern: `${e.agent}: ${e.learning.trim()}`, provenance });
         continue;
@@ -12938,7 +13361,7 @@ var CompoundingEngine = class {
       }
     }
     for (const p of actionPatterns) {
-      patterns.push({ pattern: p, provenance: [`${path23.basename(this.memoryActionEventsPath)}:*`] });
+      patterns.push({ pattern: p, provenance: [`${path24.basename(this.memoryActionEventsPath)}:*`] });
     }
     const byPattern = /* @__PURE__ */ new Map();
     for (const p of patterns) {
@@ -12978,7 +13401,7 @@ var CompoundingEngine = class {
         lines.push(`- approved: ${approved}`);
         lines.push(`- approved_with_feedback: ${awf}`);
         lines.push(`- rejected: ${rejected}`);
-        const provenance = list.slice(0, 3).map((e) => `${path23.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
+        const provenance = list.slice(0, 3).map((e) => `${path24.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
         if (provenance.length > 0) {
           lines.push(`- provenance: ${provenance.join(", ")}`);
         }
@@ -13069,7 +13492,7 @@ var CompoundingEngine = class {
         } else {
           for (const item of learnings) {
             const note = (item.entry.learning && item.entry.learning.trim().length > 0 ? item.entry.learning : item.entry.reason).trim();
-            lines.push(`- ${note} _(source: ${path23.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
+            lines.push(`- ${note} _(source: ${path24.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
           }
         }
         lines.push("");
@@ -13090,7 +13513,7 @@ var CompoundingEngine = class {
   }
   async readNonEmptyFile(filePath) {
     try {
-      const raw = await readFile16(filePath, "utf-8");
+      const raw = await readFile17(filePath, "utf-8");
       return raw.trim().length > 0;
     } catch {
       return false;
@@ -13098,7 +13521,7 @@ var CompoundingEngine = class {
   }
   async readOptionalFile(filePath) {
     try {
-      const raw = await readFile16(filePath, "utf-8");
+      const raw = await readFile17(filePath, "utf-8");
       return raw.trim().length > 0 ? raw : null;
     } catch {
       return null;
@@ -13110,13 +13533,13 @@ var CompoundingEngine = class {
     if (cappedLimit === 0) return [];
     const incidents = [];
     try {
-      const names = await readdir10(this.identityIncidentsDir);
+      const names = await readdir11(this.identityIncidentsDir);
       const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
       for (const file of files) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path23.join(this.identityIncidentsDir, file);
+        const filePath = path24.join(this.identityIncidentsDir, file);
         try {
-          const raw = await readFile16(filePath, "utf-8");
+          const raw = await readFile17(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
           if (!parsed) continue;
           if (state && parsed.state !== state) continue;
@@ -13130,8 +13553,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path23.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path23.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path24.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path24.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const weeklyExists = await this.readNonEmptyFile(weeklyPath);
     const monthlyExists = await this.readNonEmptyFile(monthlyPath);
     return {
@@ -13145,7 +13568,7 @@ var CompoundingEngine = class {
 
 // src/tier-migration.ts
 import { appendFile as appendFile6, mkdir as mkdir17 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 var TierMigrationExecutor = class {
   storage;
   qmd;
@@ -13159,7 +13582,7 @@ var TierMigrationExecutor = class {
     this.hotCollection = options.hotCollection;
     this.coldCollection = options.coldCollection;
     this.autoEmbed = options.autoEmbed === true;
-    this.journalPath = options.journalPath ?? path24.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
+    this.journalPath = options.journalPath ?? path25.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
   }
   async migrateMemory(request) {
     const { memory, fromTier, toTier, reason } = request;
@@ -13212,7 +13635,7 @@ var TierMigrationExecutor = class {
       reason: result.reason,
       targetPath: result.targetPath
     };
-    await mkdir17(path24.dirname(this.journalPath), { recursive: true });
+    await mkdir17(path25.dirname(this.journalPath), { recursive: true });
     await appendFile6(this.journalPath, `${JSON.stringify(entry)}
 `, "utf-8");
   }
@@ -13378,8 +13801,8 @@ function selectRouteRule(text, rules, options) {
 }
 
 // src/routing/store.ts
-import { lstat, mkdir as mkdir18, readFile as readFile17, realpath, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile16 } from "fs/promises";
-import path25 from "path";
+import { lstat, mkdir as mkdir18, readFile as readFile18, realpath, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile17 } from "fs/promises";
+import path26 from "path";
 import { createHash as createHash4 } from "crypto";
 function defaultState() {
   return {
@@ -13398,14 +13821,14 @@ function stableRuleId(rule) {
   return `route-${createHash4("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path25.resolve(memoryDir);
-  const defaultPath = path25.join(root, "state", "routing-rules.json");
-  if (path25.isAbsolute(stateFile)) {
-    const absolute = path25.resolve(stateFile);
-    return absolute.startsWith(root + path25.sep) ? absolute : defaultPath;
+  const root = path26.resolve(memoryDir);
+  const defaultPath = path26.join(root, "state", "routing-rules.json");
+  if (path26.isAbsolute(stateFile)) {
+    const absolute = path26.resolve(stateFile);
+    return absolute.startsWith(root + path26.sep) ? absolute : defaultPath;
   }
-  const resolved = path25.resolve(root, stateFile);
-  return resolved.startsWith(root + path25.sep) ? resolved : defaultPath;
+  const resolved = path26.resolve(root, stateFile);
+  return resolved.startsWith(root + path26.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -13438,7 +13861,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path25.resolve(memoryDir);
+    this.memoryRoot = path26.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -13476,7 +13899,7 @@ var RoutingRulesStore = class {
     await this.withWriteLock(async () => {
       const payload = defaultState();
       await this.assertStatePathScoped();
-      await writeFile16(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile17(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
     });
   }
   dedupeById(rules) {
@@ -13489,7 +13912,7 @@ var RoutingRulesStore = class {
   async readPersistedRules() {
     try {
       await this.assertStatePathScoped();
-      const raw = await readFile17(this.statePath, "utf-8");
+      const raw = await readFile18(this.statePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.rules)) return [];
       const normalized = parsed.rules.map((rule) => normalizeRule(rule)).filter((rule) => rule !== null);
@@ -13510,7 +13933,7 @@ var RoutingRulesStore = class {
     const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;
     try {
       await this.assertStatePathScoped();
-      await writeFile16(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile17(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
       await rename2(tmpPath, this.statePath);
     } catch (err) {
       log.debug(`routing rules write failed: ${err}`);
@@ -13544,7 +13967,7 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir18(path25.dirname(this.lockPath), { recursive: true });
+    await mkdir18(path26.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
         await mkdir18(this.lockPath);
@@ -13579,12 +14002,12 @@ var RoutingRulesStore = class {
   async assertStatePathScoped() {
     await mkdir18(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path25.dirname(this.statePath));
-    const canonicalStatePath = path25.join(canonicalParent, path25.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path26.dirname(this.statePath));
+    const canonicalStatePath = path26.join(canonicalParent, path26.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir18(path25.dirname(this.statePath), { recursive: true });
+    await mkdir18(path26.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -13601,28 +14024,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path25.resolve(root);
-    const normalizedCandidate = path25.resolve(candidate);
+    const normalizedRoot = path26.resolve(root);
+    const normalizedCandidate = path26.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path25.parse(normalizedRoot).root) {
+    if (normalizedRoot === path26.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path25.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path26.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path25.resolve(targetPath);
+    const absoluteTarget = path26.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path25.relative(probe, absoluteTarget);
-        return path25.resolve(canonicalProbe, remainder);
+        const remainder = path26.relative(probe, absoluteTarget);
+        return path26.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path25.dirname(probe);
+        const parent = path26.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -13633,8 +14056,8 @@ var RoutingRulesStore = class {
 };
 
 // src/policy-runtime.ts
-import path26 from "path";
-import { mkdir as mkdir19, readFile as readFile18, rename as rename3, writeFile as writeFile17 } from "fs/promises";
+import path27 from "path";
+import { mkdir as mkdir19, readFile as readFile19, rename as rename3, writeFile as writeFile18 } from "fs/promises";
 var RUNTIME_POLICY_VERSION = 1;
 var RUNTIME_POLICY_FILE = "policy-runtime.json";
 var RUNTIME_POLICY_PREV_FILE = "policy-runtime.prev.json";
@@ -13663,7 +14086,7 @@ function isRuntimeParameter(parameter) {
 }
 async function readRuntimePolicySnapshot(filePath, options) {
   try {
-    const raw = await readFile18(filePath, "utf-8");
+    const raw = await readFile19(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.version !== "number" || parsed.version < 1 || typeof parsed.updatedAt !== "string" || !parsed.values || typeof parsed.values !== "object" || typeof parsed.sourceAdjustmentCount !== "number" || parsed.sourceAdjustmentCount < 0) {
       return null;
@@ -13682,8 +14105,8 @@ async function readRuntimePolicySnapshot(filePath, options) {
 }
 async function writeSnapshotAtomic(filePath, snapshot) {
   const tempPath = `${filePath}.tmp`;
-  await mkdir19(path26.dirname(filePath), { recursive: true });
-  await writeFile17(tempPath, `${JSON.stringify(snapshot, null, 2)}
+  await mkdir19(path27.dirname(filePath), { recursive: true });
+  await writeFile18(tempPath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf-8");
   await rename3(tempPath, filePath);
 }
@@ -13691,9 +14114,9 @@ var PolicyRuntimeManager = class {
   constructor(memoryDir, config) {
     this.memoryDir = memoryDir;
     this.config = config;
-    const stateDir2 = path26.join(memoryDir, "state");
-    this.runtimePath = path26.join(stateDir2, RUNTIME_POLICY_FILE);
-    this.runtimePrevPath = path26.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
+    const stateDir2 = path27.join(memoryDir, "state");
+    this.runtimePath = path27.join(stateDir2, RUNTIME_POLICY_FILE);
+    this.runtimePrevPath = path27.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
   }
   runtimePath;
   runtimePrevPath;
@@ -13977,11 +14400,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path27.isAbsolute(candidatePath) ? candidatePath : path27.resolve(storageDir, candidatePath);
-  const rel = path27.relative(storageDir, absolutePath);
+  const absolutePath = path28.isAbsolute(candidatePath) ? candidatePath : path28.resolve(storageDir, candidatePath);
+  const rel = path28.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path27.sep).join("/");
+  return rel.split(path28.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -14056,7 +14479,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path27.relative(storageDir, mem.path));
+    pathById.set(id, path28.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -14064,7 +14487,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path27.join(options.storageDir, options.memoryRelPath),
+    path: path28.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -14084,15 +14507,15 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path27.join("corrections", `${options.memoryId}.md`);
+    return path28.join("corrections", `${options.memoryId}.md`);
   }
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path27.join("facts", day, `${options.memoryId}.md`);
+    return path28.join("facts", day, `${options.memoryId}.md`);
   }
-  return path27.join("facts", `${options.memoryId}.md`);
+  return path28.join("facts", `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -14202,7 +14625,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path27.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path28.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -14219,7 +14642,7 @@ var Orchestrator = class _Orchestrator {
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path27.join(config.memoryDir, "threads"),
+      path28.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -14388,7 +14811,7 @@ var Orchestrator = class _Orchestrator {
     await this.sessionObserver.load();
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path27.join(this.config.memoryDir, "state");
+      const stateDir2 = path28.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -14426,7 +14849,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path27.join(this.config.memoryDir, "conversation-index")
+          path28.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -14480,12 +14903,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path27.isAbsolute(rel) ? rel : path27.join(this.config.workspaceDir, rel);
+        const abs = path28.isAbsolute(rel) ? rel : path28.join(this.config.workspaceDir, rel);
         try {
-          const raw = await readFile19(abs, "utf-8");
+          const raw = await readFile20(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path27.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path27.basename(abs);
+            const archiveDir = path28.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path28.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -14493,7 +14916,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile18(abs, newContent, "utf-8");
+            await writeFile19(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -14510,8 +14933,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path27.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir20(path27.dirname(fp), { recursive: true });
+        const fp = path28.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir20(path28.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -14520,11 +14943,11 @@ var Orchestrator = class _Orchestrator {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile19(fp, "utf-8");
+          existing = await readFile20(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile18(fp, existing + block, "utf-8");
+        await writeFile19(fp, existing + block, "utf-8");
       }
     }
   }
@@ -14600,9 +15023,9 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path27.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path28.join(storage.dir, "state", "last_graph_recall.json");
     try {
-      const raw = await readFile19(snapshotPath, "utf-8");
+      const raw = await readFile20(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -14668,10 +15091,10 @@ ${r.snippet.trim()}
   }
   async countConversationChunkDocs(dir) {
     try {
-      const entries = await readdir11(dir, { withFileTypes: true });
+      const entries = await readdir12(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path27.join(dir, entry.name);
+        const fullPath = path28.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -14719,6 +15142,9 @@ ${r.snippet.trim()}
       qmdAvailable
     };
   }
+  async getRecoverySummary(sessionKey) {
+    return this.transcript.getRecoverySummary(sessionKey);
+  }
   async updateConversationIndex(sessionKey, hours = 24, opts) {
     if (!this.config.conversationIndexEnabled) {
       return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
@@ -14987,7 +15413,7 @@ ${r.snippet.trim()}
       const seedRelativePaths = seedCandidates.map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
       const seedRecallScore = seedCandidates.reduce((max, item) => Math.max(max, item.score), 0);
-      seedPaths.push(...seedRelativePaths.map((rel) => path27.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path28.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -14996,7 +15422,7 @@ ${r.snippet.trim()}
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path27.resolve(storage.dir, candidate.path);
+        const memoryPath = path28.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -15019,7 +15445,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path27.resolve(storage.dir, candidate.seed),
+          seed: path28.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType
@@ -15034,8 +15460,8 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path27.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir20(path27.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path28.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir20(path28.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -15052,7 +15478,7 @@ ${r.snippet.trim()}
         seeds,
         expanded
       };
-      await writeFile18(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile19(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
@@ -16063,7 +16489,7 @@ _Context: ${topQuestion.context}_`);
     };
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path27.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path28.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -16657,7 +17083,7 @@ _Context: ${topQuestion.context}_`);
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path27.relative(storage.dir, m.path);
+            const rel = path28.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -17215,9 +17641,9 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path27.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir20(path27.dirname(metricsPath), { recursive: true });
-    await writeFile18(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    const metricsPath = path28.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir20(path28.dirname(metricsPath), { recursive: true });
+    await writeFile19(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -17484,7 +17910,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path27.isAbsolute(hit.path) ? hit.path : path27.join(this.config.memoryDir, hit.path);
+      const fullPath = path28.isAbsolute(hit.path) ? hit.path : path28.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -17942,8 +18368,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path27.resolve(storageDir);
-    const resolvedMemoryDir = path27.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path28.resolve(storageDir);
+    const resolvedMemoryDir = path28.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir) return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
     return m && m[1] ? m[1] : this.config.defaultNamespace;
@@ -17971,14 +18397,14 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path29 from "path";
+import path30 from "path";
 import { createHash as createHash7 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
-import path28 from "path";
+import path29 from "path";
 import { randomUUID } from "crypto";
-import { mkdir as mkdir21, readdir as readdir12, readFile as readFile20, rm as rm3, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir21, readdir as readdir13, readFile as readFile21, rm as rm3, writeFile as writeFile20 } from "fs/promises";
 var TASK_TRANSITIONS = {
   todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
   in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
@@ -18053,8 +18479,8 @@ function ensureProjectStatus(value) {
 var WorkStorage = class {
   constructor(memoryDir) {
     this.memoryDir = memoryDir;
-    this.tasksDir = path28.join(memoryDir, "work", "tasks");
-    this.projectsDir = path28.join(memoryDir, "work", "projects");
+    this.tasksDir = path29.join(memoryDir, "work", "tasks");
+    this.projectsDir = path29.join(memoryDir, "work", "projects");
   }
   tasksDir;
   projectsDir;
@@ -18064,11 +18490,11 @@ var WorkStorage = class {
   }
   taskPath(id) {
     assertValidWorkId(id, "task");
-    return path28.join(this.tasksDir, `${id}.md`);
+    return path29.join(this.tasksDir, `${id}.md`);
   }
   projectPath(id) {
     assertValidWorkId(id, "project");
-    return path28.join(this.projectsDir, `${id}.md`);
+    return path29.join(this.projectsDir, `${id}.md`);
   }
   serializeTask(task) {
     return `${serializeFrontmatter2(task)}
@@ -18140,7 +18566,7 @@ ${project.description}
         throw new Error(`project not found: ${task.projectId}`);
       }
     }
-    await writeFile19(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    await writeFile20(this.taskPath(task.id), this.serializeTask(task), "utf-8");
     if (task.projectId) {
       await this.addTaskIdToProject(task.projectId, task.id, now);
     }
@@ -18148,7 +18574,7 @@ ${project.description}
   }
   async getTask(id) {
     try {
-      const raw = await readFile20(this.taskPath(id), "utf-8");
+      const raw = await readFile21(this.taskPath(id), "utf-8");
       return this.parseTask(raw);
     } catch {
       return null;
@@ -18156,11 +18582,11 @@ ${project.description}
   }
   async listTasks(filter) {
     await this.ensureDirectories();
-    const entries = await readdir12(this.tasksDir, { withFileTypes: true });
+    const entries = await readdir13(this.tasksDir, { withFileTypes: true });
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile20(path28.join(this.tasksDir, entry.name), "utf-8");
+      const raw = await readFile21(path29.join(this.tasksDir, entry.name), "utf-8");
       const task = this.parseTask(raw);
       if (!task) continue;
       if (filter?.status && task.status !== filter.status) continue;
@@ -18202,7 +18628,7 @@ ${project.description}
       tags: patch.tags ?? existing.tags,
       updatedAt: now.toISOString()
     };
-    await writeFile19(this.taskPath(id), this.serializeTask(next), "utf-8");
+    await writeFile20(this.taskPath(id), this.serializeTask(next), "utf-8");
     return next;
   }
   async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
@@ -18242,12 +18668,12 @@ ${project.description}
       createdAt: timestamp,
       updatedAt: timestamp
     };
-    await writeFile19(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    await writeFile20(this.projectPath(project.id), this.serializeProject(project), "utf-8");
     return project;
   }
   async getProject(id) {
     try {
-      const raw = await readFile20(this.projectPath(id), "utf-8");
+      const raw = await readFile21(this.projectPath(id), "utf-8");
       return this.parseProject(raw);
     } catch {
       return null;
@@ -18255,11 +18681,11 @@ ${project.description}
   }
   async listProjects() {
     await this.ensureDirectories();
-    const entries = await readdir12(this.projectsDir, { withFileTypes: true });
+    const entries = await readdir13(this.projectsDir, { withFileTypes: true });
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile20(path28.join(this.projectsDir, entry.name), "utf-8");
+      const raw = await readFile21(path29.join(this.projectsDir, entry.name), "utf-8");
       const project = this.parseProject(raw);
       if (project) out.push(project);
     }
@@ -18276,7 +18702,7 @@ ${project.description}
       taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
       updatedAt: now.toISOString()
     };
-    await writeFile19(this.projectPath(id), this.serializeProject(next), "utf-8");
+    await writeFile20(this.projectPath(id), this.serializeProject(next), "utf-8");
     return next;
   }
   async deleteProject(id) {
@@ -19815,7 +20241,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path29.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path30.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           return toolResult("No identity file found. Identity reflections build automatically through conversations when identityEnabled is true.");
@@ -20332,13 +20758,13 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path45 from "path";
-import { access as access3, readFile as readFile31, readdir as readdir19, unlink as unlink5 } from "fs/promises";
-import { createHash as createHash9 } from "crypto";
+import path48 from "path";
+import { access as access3, readFile as readFile34, readdir as readdir20, unlink as unlink6 } from "fs/promises";
+import { createHash as createHash10 } from "crypto";
 
 // src/transfer/export-json.ts
-import path31 from "path";
-import { mkdir as mkdir23, readFile as readFile22 } from "fs/promises";
+import path32 from "path";
+import { mkdir as mkdir23, readFile as readFile23 } from "fs/promises";
 
 // src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
@@ -20346,10 +20772,10 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir22, readdir as readdir13, readFile as readFile21, stat as stat6, writeFile as writeFile20 } from "fs/promises";
-import path30 from "path";
+import { mkdir as mkdir22, readdir as readdir14, readFile as readFile22, stat as stat6, writeFile as writeFile21 } from "fs/promises";
+import path31 from "path";
 async function sha256File(filePath) {
-  const buf = await readFile21(filePath);
+  const buf = await readFile22(filePath);
   const sha256 = createHash8("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
@@ -20359,19 +20785,19 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir22(path30.dirname(filePath), { recursive: true });
-  await writeFile20(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  await mkdir22(path31.dirname(filePath), { recursive: true });
+  await writeFile21(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile(filePath) {
-  const raw = await readFile21(filePath, "utf-8");
+  const raw = await readFile22(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function listFilesRecursive(rootDir) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir13(dir, { withFileTypes: true });
+    const entries = await readdir14(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path30.join(dir, ent.name);
+      const fp = path31.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -20391,11 +20817,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path30.relative(rootDir, absPath);
-  return rel.split(path30.sep).join("/");
+  const rel = path31.relative(rootDir, absPath);
+  return rel.split(path31.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path30.sep);
+  return relPath.split("/").join(path31.sep);
 }
 
 // src/transfer/export-json.ts
@@ -20411,24 +20837,24 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path31.resolve(opts.outDir);
+  const outDirAbs = path32.resolve(opts.outDir);
   await mkdir23(outDirAbs, { recursive: true });
-  const memoryDirAbs = path31.resolve(opts.memoryDir);
+  const memoryDirAbs = path32.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, memoryDirAbs);
     if (shouldExclude(relPosix, includeTranscripts)) continue;
-    const content = await readFile22(abs, "utf-8");
+    const content = await readFile23(abs, "utf-8");
     records.push({ path: relPosix, content });
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path31.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path32.join(opts.workspaceDir, "IDENTITY.md");
     try {
-      const content = await readFile22(identityPath, "utf-8");
+      const content = await readFile23(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
       records.push({ path: relPath, content });
       const { sha256, bytes } = sha256String(content);
@@ -20445,13 +20871,13 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path31.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path31.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path32.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path32.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path32 from "path";
-import { mkdir as mkdir24, readFile as readFile23, writeFile as writeFile21 } from "fs/promises";
+import path33 from "path";
+import { mkdir as mkdir24, readFile as readFile24, writeFile as writeFile22 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
   if (!includeTranscripts && parts[0] === "transcripts") return true;
@@ -20459,18 +20885,18 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path32.resolve(opts.outDir);
+  const outDirAbs = path33.resolve(opts.outDir);
   await mkdir24(outDirAbs, { recursive: true });
-  const memDirAbs = path32.resolve(opts.memoryDir);
+  const memDirAbs = path33.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const manifestFiles = [];
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, memDirAbs);
     if (shouldExclude2(relPosix, includeTranscripts)) continue;
-    const dstAbs = path32.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir24(path32.dirname(dstAbs), { recursive: true });
-    const content = await readFile23(abs);
-    await writeFile21(dstAbs, content);
+    const dstAbs = path33.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir24(path33.dirname(dstAbs), { recursive: true });
+    const content = await readFile24(abs);
+    await writeFile22(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
@@ -20482,12 +20908,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path32.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path33.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path32.resolve(fromDir);
+  const dirAbs = path33.resolve(fromDir);
   try {
-    const raw = await readFile23(path32.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile24(path33.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -20496,16 +20922,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path33 from "path";
-import { mkdir as mkdir25, readdir as readdir14, rm as rm4 } from "fs/promises";
+import path34 from "path";
+import { mkdir as mkdir25, readdir as readdir15, rm as rm4 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path33.resolve(opts.outDir);
+  const outDirAbs = path34.resolve(opts.outDir);
   await mkdir25(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path33.join(outDirAbs, ts);
+  const backupDir = path34.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -20518,7 +20944,7 @@ async function backupMemoryDir(opts) {
   return backupDir;
 }
 async function enforceRetention(outDirAbs, retentionDays) {
-  const entries = await readdir14(outDirAbs, { withFileTypes: true });
+  const entries = await readdir15(outDirAbs, { withFileTypes: true });
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
@@ -20530,15 +20956,15 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm4(path33.join(outDirAbs, name), { recursive: true, force: true });
+      await rm4(path34.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path34 from "path";
+import path35 from "path";
 import Database from "better-sqlite3";
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 
 // src/transfer/sqlite-schema.ts
 var SQLITE_SCHEMA_VERSION = 1;
@@ -20564,8 +20990,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path34.resolve(opts.memoryDir);
-  const outAbs = path34.resolve(opts.outFile);
+  const memDirAbs = path35.resolve(opts.memoryDir);
+  const outAbs = path35.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -20586,7 +21012,7 @@ async function exportSqlite(opts) {
     for (const abs of filesAbs) {
       const relPosix = toPosixRelPath(abs, memDirAbs);
       if (shouldExclude3(relPosix, includeTranscripts)) continue;
-      const content = await readFile24(abs, "utf-8");
+      const content = await readFile25(abs, "utf-8");
       const { sha256, bytes } = await sha256File(abs);
       rows.push({ rel: relPosix, bytes, sha256, content });
     }
@@ -20597,8 +21023,8 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path35 from "path";
-import { mkdir as mkdir26, writeFile as writeFile22 } from "fs/promises";
+import path36 from "path";
+import { mkdir as mkdir26, writeFile as writeFile23 } from "fs/promises";
 
 // src/transfer/types.ts
 import { z as z4 } from "zod";
@@ -20631,21 +21057,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path35.resolve(opts.fromDir);
-  const bundlePath = path35.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path36.resolve(opts.fromDir);
+  const bundlePath = path36.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile(bundlePath));
-  const memDirAbs = path35.resolve(opts.targetMemoryDir);
+  const memDirAbs = path36.resolve(opts.targetMemoryDir);
   const written = [];
   let skipped = 0;
   for (const rec of bundle.records) {
     const isWorkspace = rec.path.startsWith("workspace/");
-    const targetBase = isWorkspace ? opts.workspaceDir ? path35.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path36.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path35.join(targetBase, relFs);
+    const absTarget = path36.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -20669,30 +21095,30 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir26(path35.dirname(w.abs), { recursive: true });
-    await writeFile22(w.abs, w.content, "utf-8");
+    await mkdir26(path36.dirname(w.abs), { recursive: true });
+    await writeFile23(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path35.resolve(fromDir);
+  const dir = path36.resolve(fromDir);
   return Promise.all([
-    fileExists(path35.join(dir, "manifest.json")),
-    fileExists(path35.join(dir, "bundle.json"))
+    fileExists(path36.join(dir, "manifest.json")),
+    fileExists(path36.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path36 from "path";
+import path37 from "path";
 import Database2 from "better-sqlite3";
-import { mkdir as mkdir27, writeFile as writeFile23 } from "fs/promises";
+import { mkdir as mkdir27, writeFile as writeFile24 } from "fs/promises";
 function normalizeForDedupe2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path36.resolve(opts.targetMemoryDir);
-  const fromAbs = path36.resolve(opts.fromFile);
+  const memDirAbs = path37.resolve(opts.targetMemoryDir);
+  const fromAbs = path37.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -20705,7 +21131,7 @@ async function importSqlite(opts) {
     const rows = db.prepare("SELECT path_rel, content FROM files").all();
     for (const r of rows) {
       const relFs = fromPosixRelPath(r.path_rel);
-      const absTarget = path36.join(memDirAbs, relFs);
+      const absTarget = path37.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -20730,30 +21156,30 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir27(path36.dirname(w.abs), { recursive: true });
-    await writeFile23(w.abs, w.content, "utf-8");
+    await mkdir27(path37.dirname(w.abs), { recursive: true });
+    await writeFile24(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path37 from "path";
-import { mkdir as mkdir28, readFile as readFile25, writeFile as writeFile24 } from "fs/promises";
+import path38 from "path";
+import { mkdir as mkdir28, readFile as readFile26, writeFile as writeFile25 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path37.resolve(opts.fromDir);
-  const targetAbs = path37.resolve(opts.targetMemoryDir);
+  const fromAbs = path38.resolve(opts.fromDir);
+  const targetAbs = path38.resolve(opts.targetMemoryDir);
   const filesAbs = await listFilesRecursive(fromAbs);
   const writes = [];
   let skipped = 0;
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, fromAbs);
     if (relPosix === "manifest.json") continue;
-    const dstAbs = path37.join(targetAbs, fromPosixRelPath(relPosix));
-    const content = await readFile25(abs, "utf-8");
+    const dstAbs = path38.join(targetAbs, fromPosixRelPath(relPosix));
+    const content = await readFile26(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
       if (conflict === "skip") {
@@ -20775,17 +21201,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir28(path37.dirname(w.abs), { recursive: true });
-    await writeFile24(w.abs, w.content, "utf-8");
+    await mkdir28(path38.dirname(w.abs), { recursive: true });
+    await writeFile25(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path38 from "path";
+import path39 from "path";
 import { stat as stat7 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path38.resolve(fromPath);
+  const abs = path39.resolve(fromPath);
   let st;
   try {
     st = await stat7(abs);
@@ -21213,8 +21639,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path47 = typeof record.path === "string" ? record.path : "";
-      if (!path47.startsWith("transcripts/") && !path47.includes("/transcripts/")) continue;
+      const path50 = typeof record.path === "string" ? record.path : "";
+      if (!path50.startsWith("transcripts/") && !path50.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -21270,8 +21696,8 @@ var openclawReplayNormalizer = {
 };
 
 // src/maintenance/archive-observations.ts
-import path39 from "path";
-import { mkdir as mkdir29, readdir as readdir15, readFile as readFile26, unlink as unlink4, writeFile as writeFile25 } from "fs/promises";
+import path40 from "path";
+import { mkdir as mkdir29, readdir as readdir16, readFile as readFile27, unlink as unlink5, writeFile as writeFile26 } from "fs/promises";
 var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 function normalizeRetentionDays(value) {
   if (!Number.isFinite(value)) return 30;
@@ -21292,13 +21718,13 @@ async function listFilesRecursive2(root, relPrefix = "") {
   const out = [];
   let entries;
   try {
-    entries = await readdir15(root, { withFileTypes: true });
+    entries = await readdir16(root, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
-    const rel = relPrefix ? path39.join(relPrefix, entry.name) : entry.name;
-    const full = path39.join(root, entry.name);
+    const rel = relPrefix ? path40.join(relPrefix, entry.name) : entry.name;
+    const full = path40.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive2(full, rel));
       continue;
@@ -21308,19 +21734,19 @@ async function listFilesRecursive2(root, relPrefix = "") {
   return out;
 }
 async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
-  const roots = ["transcripts", path39.join("state", "tool-usage"), path39.join("summaries", "hourly")];
+  const roots = ["transcripts", path40.join("state", "tool-usage"), path40.join("summaries", "hourly")];
   const out = [];
   for (const relRoot of roots) {
-    const absRoot = path39.join(memoryDir, relRoot);
+    const absRoot = path40.join(memoryDir, relRoot);
     const files = await listFilesRecursive2(absRoot);
     for (const fileRel of files) {
-      const filename = path39.basename(fileRel);
+      const filename = path40.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
       out.push({
-        absolutePath: path39.join(absRoot, fileRel),
-        relativePath: path39.join(relRoot, fileRel)
+        absolutePath: path40.join(absRoot, fileRel),
+        relativePath: path40.join(relRoot, fileRel)
       });
     }
   }
@@ -21335,7 +21761,7 @@ async function archiveObservations(options) {
     new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1e3)
   );
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path39.join(options.memoryDir, "archive", "observations", stamp);
+  const archiveRoot = path40.join(options.memoryDir, "archive", "observations", stamp);
   const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
     options.memoryDir,
     cutoffDayStartUtc
@@ -21346,12 +21772,12 @@ async function archiveObservations(options) {
   if (!dryRun && candidates.length > 0) {
     await mkdir29(archiveRoot, { recursive: true });
     for (const candidate of candidates) {
-      const archivePath = path39.join(archiveRoot, candidate.relativePath);
-      const archiveDir = path39.dirname(archivePath);
+      const archivePath = path40.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path40.dirname(archivePath);
       await mkdir29(archiveDir, { recursive: true });
-      const raw = await readFile26(candidate.absolutePath);
-      await writeFile25(archivePath, raw);
-      await unlink4(candidate.absolutePath);
+      const raw = await readFile27(candidate.absolutePath);
+      await writeFile26(archivePath, raw);
+      await unlink5(candidate.absolutePath);
       archivedFiles += 1;
       archivedBytes += raw.byteLength;
       archivedRelativePaths.push(candidate.relativePath);
@@ -21371,12 +21797,12 @@ async function archiveObservations(options) {
 }
 
 // src/maintenance/rebuild-observations.ts
-import path41 from "path";
-import { readdir as readdir16, readFile as readFile28 } from "fs/promises";
+import path42 from "path";
+import { readdir as readdir17, readFile as readFile29 } from "fs/promises";
 
 // src/maintenance/observation-ledger-utils.ts
-import path40 from "path";
-import { mkdir as mkdir30, readFile as readFile27, writeFile as writeFile26 } from "fs/promises";
+import path41 from "path";
+import { mkdir as mkdir30, readFile as readFile28, writeFile as writeFile27 } from "fs/promises";
 function toHourBucketIso(timestamp) {
   const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
   const ms = Date.parse(normalized);
@@ -21387,17 +21813,17 @@ function toHourBucketIso(timestamp) {
 }
 async function backupAndWriteRebuiltObservations(options) {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path40.join(options.memoryDir, "archive", "observations", stamp);
-  let backupPath = path40.join(
+  const archiveRoot = path41.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path41.join(
     archiveRoot,
     "state",
     "observation-ledger",
     "rebuilt-observations.jsonl"
   );
   try {
-    const existing = await readFile27(options.outputPath, "utf-8");
-    await mkdir30(path40.dirname(backupPath), { recursive: true });
-    await writeFile26(backupPath, existing, "utf-8");
+    const existing = await readFile28(options.outputPath, "utf-8");
+    await mkdir30(path41.dirname(backupPath), { recursive: true });
+    await writeFile27(backupPath, existing, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") {
@@ -21413,8 +21839,8 @@ async function backupAndWriteRebuiltObservations(options) {
       rebuiltAt
     })
   );
-  await mkdir30(path40.dirname(options.outputPath), { recursive: true });
-  await writeFile26(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+  await mkdir30(path41.dirname(options.outputPath), { recursive: true });
+  await writeFile27(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf-8");
   return backupPath;
 }
@@ -21423,11 +21849,11 @@ async function backupAndWriteRebuiltObservations(options) {
 function toSortableKey(sessionKey, hour) {
   return `${sessionKey}\0${hour}`;
 }
-async function listTranscriptFiles(root) {
+async function listTranscriptFiles2(root) {
   const out = [];
   let entries;
   try {
-    entries = await readdir16(root, { withFileTypes: true });
+    entries = await readdir17(root, { withFileTypes: true });
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") return out;
@@ -21436,9 +21862,9 @@ async function listTranscriptFiles(root) {
   for (const entry of entries) {
     if (entry.name === "." || entry.name === "..") continue;
     if (entry.isSymbolicLink()) continue;
-    const full = path41.join(root, entry.name);
+    const full = path42.join(root, entry.name);
     if (entry.isDirectory()) {
-      out.push(...await listTranscriptFiles(full));
+      out.push(...await listTranscriptFiles2(full));
       continue;
     }
     if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -21496,18 +21922,18 @@ function buildLedgerRows(linesByFile) {
 async function rebuildObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const transcriptsRoot = path41.join(options.memoryDir, "transcripts");
-  const outputPath = path41.join(
+  const transcriptsRoot = path42.join(options.memoryDir, "transcripts");
+  const outputPath = path42.join(
     options.memoryDir,
     "state",
     "observation-ledger",
     "rebuilt-observations.jsonl"
   );
-  const transcriptFiles = await listTranscriptFiles(transcriptsRoot);
+  const transcriptFiles = await listTranscriptFiles2(transcriptsRoot);
   const contents = [];
   for (const file of transcriptFiles) {
     try {
-      contents.push(await readFile28(file, "utf-8"));
+      contents.push(await readFile29(file, "utf-8"));
     } catch {
     }
   }
@@ -21533,8 +21959,8 @@ async function rebuildObservations(options) {
 }
 
 // src/maintenance/migrate-observations.ts
-import path42 from "path";
-import { readdir as readdir17, readFile as readFile29 } from "fs/promises";
+import path43 from "path";
+import { readdir as readdir18, readFile as readFile30 } from "fs/promises";
 function toNonNegativeInt(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
   const normalized = Math.floor(value);
@@ -21585,7 +22011,7 @@ function toCounts(row) {
 async function listLegacyObservationFiles(root) {
   let entries;
   try {
-    entries = await readdir17(root, { withFileTypes: true });
+    entries = await readdir18(root, { withFileTypes: true });
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") return [];
@@ -21597,16 +22023,16 @@ async function listLegacyObservationFiles(root) {
 async function migrateObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const ledgerRoot = path42.join(options.memoryDir, "state", "observation-ledger");
-  const outputPath = path42.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const ledgerRoot = path43.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path43.join(ledgerRoot, "rebuilt-observations.jsonl");
   const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
-  const sourceRelativePaths = legacyFiles.map((name) => path42.join("state", "observation-ledger", name));
+  const sourceRelativePaths = legacyFiles.map((name) => path43.join("state", "observation-ledger", name));
   const byKey = /* @__PURE__ */ new Map();
   let parsedRows = 0;
   let malformedLines = 0;
   for (const file of legacyFiles) {
-    const full = path42.join(ledgerRoot, file);
-    const raw = await readFile29(full, "utf-8");
+    const full = path43.join(ledgerRoot, file);
+    const raw = await readFile30(full, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
       let parsed;
@@ -21795,10 +22221,10 @@ var defaultCommandRunner = (command, args, options) => {
 
 // src/network/webdav.ts
 import { createReadStream } from "fs";
-import { mkdir as mkdir31, readdir as readdir18, realpath as realpath2, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir31, readdir as readdir19, realpath as realpath2, stat as stat9 } from "fs/promises";
 import { createServer } from "http";
 import { timingSafeEqual } from "crypto";
-import path43 from "path";
+import path44 from "path";
 import { pipeline } from "stream/promises";
 import { URL as URL2 } from "url";
 function hostToUrlAuthority(host) {
@@ -21834,10 +22260,10 @@ var WebDavServer = class _WebDavServer {
     const allowedRoots = [];
     const aliasSet = /* @__PURE__ */ new Set();
     for (const dir of options.allowlistDirs) {
-      const resolved = path43.resolve(dir);
+      const resolved = path44.resolve(dir);
       await mkdir31(resolved, { recursive: true });
       const canonical = await realpath2(resolved);
-      const alias = path43.basename(canonical) || "root";
+      const alias = path44.basename(canonical) || "root";
       if (aliasSet.has(alias)) {
         throw new Error(`duplicate webdav allowlist alias: ${alias}`);
       }
@@ -21993,7 +22419,7 @@ var WebDavServer = class _WebDavServer {
     if (decodedPath.includes("\0")) {
       return { ok: false, code: 400, message: "invalid path" };
     }
-    const normalized = path43.posix.normalize(decodedPath);
+    const normalized = path44.posix.normalize(decodedPath);
     const segments = normalized.split("/").filter((segment) => segment.length > 0);
     if (segments.length === 0) {
       return { ok: false, code: 403, message: "root listing is not allowed" };
@@ -22007,7 +22433,7 @@ var WebDavServer = class _WebDavServer {
     if (relative.some((segment) => segment === ".." || segment.includes("\\"))) {
       return { ok: false, code: 403, message: "path traversal is not allowed" };
     }
-    const candidate = path43.resolve(root.absolute, ...relative);
+    const candidate = path44.resolve(root.absolute, ...relative);
     if (!this.isPathInside(root.absolute, candidate)) {
       return { ok: false, code: 403, message: "path escaped allowlist" };
     }
@@ -22063,7 +22489,7 @@ var WebDavServer = class _WebDavServer {
     }
     const entries = [];
     if (info.isDirectory()) {
-      const children = await readdir18(absolutePath, { withFileTypes: true });
+      const children = await readdir19(absolutePath, { withFileTypes: true });
       for (const child of children) {
         const childHref = toEncodedHref(`${displayPath.replace(/\/$/, "")}/${child.name}`);
         entries.push(`
@@ -22085,10 +22511,10 @@ var WebDavServer = class _WebDavServer {
   }
   isPathInside(root, target) {
     if (target === root) return true;
-    if (root === path43.parse(root).root) {
+    if (root === path44.parse(root).root) {
       return target.startsWith(root);
     }
-    return target.startsWith(`${root}${path43.sep}`);
+    return target.startsWith(`${root}${path44.sep}`);
   }
 };
 function xmlEscape(value) {
@@ -22098,9 +22524,362 @@ function toEncodedHref(pathname) {
   return pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
 
+// src/dashboard-runtime.ts
+import { createHash as createHash9 } from "crypto";
+import { createServer as createServer2 } from "http";
+import { watch } from "fs";
+import { readFile as readFile32 } from "fs/promises";
+import path46 from "path";
+
+// src/graph-dashboard-parser.ts
+import path45 from "path";
+import { readFile as readFile31 } from "fs/promises";
+
+// src/graph-dashboard-key.ts
+function graphEdgeKey(edge) {
+  return `${edge.type}|${edge.from}|${edge.to}|${edge.label}|${edge.ts}`;
+}
+
+// src/graph-dashboard-parser.ts
+var GRAPH_TYPES = ["entity", "time", "causal"];
+function graphFile(memoryDir, type) {
+  return path45.join(memoryDir, "state", "graphs", `${type}.jsonl`);
+}
+function isGraphEdge(raw, expectedType) {
+  if (!raw || typeof raw !== "object") return false;
+  const edge = raw;
+  return edge.type === expectedType && typeof edge.from === "string" && edge.from.length > 0 && typeof edge.to === "string" && edge.to.length > 0 && typeof edge.weight === "number" && Number.isFinite(edge.weight) && typeof edge.label === "string" && typeof edge.ts === "string";
+}
+async function graphSnapshotFromMemoryDir(memoryDir) {
+  const nodes = /* @__PURE__ */ new Set();
+  const edges = [];
+  const filesMissing = [];
+  let malformedLines = 0;
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const type of GRAPH_TYPES) {
+    const filePath = graphFile(memoryDir, type);
+    let raw = "";
+    try {
+      raw = await readFile31(filePath, "utf-8");
+    } catch {
+      filesMissing.push(type);
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        malformedLines += 1;
+        continue;
+      }
+      if (!isGraphEdge(parsed, type)) {
+        malformedLines += 1;
+        continue;
+      }
+      const key = graphEdgeKey(parsed);
+      if (seenEdges.has(key)) continue;
+      seenEdges.add(key);
+      edges.push(parsed);
+      nodes.add(parsed.from);
+      nodes.add(parsed.to);
+    }
+  }
+  const sortedEdges = edges.sort(
+    (a, b) => a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.ts.localeCompare(b.ts)
+  );
+  const sortedNodes = [...nodes].sort((a, b) => a.localeCompare(b)).map((id) => ({ id }));
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: sortedNodes,
+    edges: sortedEdges,
+    stats: {
+      nodes: sortedNodes.length,
+      edges: sortedEdges.length,
+      malformedLines,
+      filesMissing
+    }
+  };
+}
+
+// src/graph-dashboard-diff.ts
+function diffGraphSnapshots(previous, next) {
+  const prevNodeSet = new Set(previous.nodes.map((node) => node.id));
+  const nextNodeSet = new Set(next.nodes.map((node) => node.id));
+  const prevEdges = new Map(previous.edges.map((edge) => [graphEdgeKey(edge), edge]));
+  const nextEdges = new Map(next.edges.map((edge) => [graphEdgeKey(edge), edge]));
+  const addedNodes = [...nextNodeSet].filter((id) => !prevNodeSet.has(id)).sort((a, b) => a.localeCompare(b));
+  const removedNodes = [...prevNodeSet].filter((id) => !nextNodeSet.has(id)).sort((a, b) => a.localeCompare(b));
+  const addedEdges = [...nextEdges.entries()].filter(([key]) => !prevEdges.has(key)).map(([, edge]) => edge).sort((a, b) => a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  const removedEdges = [...prevEdges.entries()].filter(([key]) => !nextEdges.has(key)).map(([, edge]) => edge).sort((a, b) => a.type.localeCompare(b.type) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  return {
+    addedNodes,
+    removedNodes,
+    addedEdges,
+    removedEdges
+  };
+}
+
+// src/dashboard-runtime.ts
+function websocketAcceptKey(clientKey) {
+  return createHash9("sha1").update(`${clientKey}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+}
+function encodeTextFrame(payload) {
+  const payloadBuffer = Buffer.from(payload, "utf-8");
+  const len = payloadBuffer.length;
+  const header = [129];
+  if (len <= 125) {
+    header.push(len);
+  } else if (len <= 65535) {
+    header.push(126, len >> 8 & 255, len & 255);
+  } else {
+    const high = Math.floor(len / 2 ** 32);
+    const low = len >>> 0;
+    header.push(127, high >> 24 & 255, high >> 16 & 255, high >> 8 & 255, high & 255, low >> 24 & 255, low >> 16 & 255, low >> 8 & 255, low & 255);
+  }
+  return Buffer.concat([Buffer.from(header), payloadBuffer]);
+}
+var GraphDashboardServer = class {
+  memoryDir;
+  host;
+  requestedPort;
+  publicDir;
+  watchDebounceMs;
+  server = null;
+  watcher = null;
+  clients = /* @__PURE__ */ new Map();
+  graphSnapshot = {
+    generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    nodes: [],
+    edges: [],
+    stats: { nodes: 0, edges: 0, malformedLines: 0, filesMissing: [] }
+  };
+  debounceTimer = null;
+  lastError = null;
+  boundPort = 0;
+  constructor(options) {
+    this.memoryDir = options.memoryDir;
+    this.host = options.host?.trim() || "127.0.0.1";
+    this.requestedPort = Number.isFinite(options.port) ? Math.max(0, Math.floor(options.port ?? 0)) : 0;
+    this.publicDir = options.publicDir ?? path46.join(process.cwd(), "dashboard", "public");
+    this.watchDebounceMs = Math.max(50, Math.floor(options.watchDebounceMs ?? 300));
+  }
+  async start() {
+    if (this.server) {
+      return this.status();
+    }
+    await this.rebuildSnapshot();
+    const candidate = createServer2((req, res) => {
+      void this.handleHttp(req, res);
+    });
+    candidate.on("upgrade", (req, socket) => {
+      this.handleUpgrade(req, socket);
+    });
+    try {
+      await new Promise((resolve, reject) => {
+        const onError = (err) => {
+          candidate.off("listening", onListening);
+          reject(err);
+        };
+        const onListening = () => {
+          candidate.off("error", onError);
+          resolve();
+        };
+        candidate.once("error", onError);
+        candidate.once("listening", onListening);
+        candidate.listen(this.requestedPort, this.host);
+      });
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      try {
+        candidate.close();
+      } catch {
+      }
+      throw err;
+    }
+    this.server = candidate;
+    const addr = candidate.address();
+    this.boundPort = typeof addr === "object" && addr ? addr.port : this.requestedPort;
+    this.startWatcher();
+    return this.status();
+  }
+  async stop() {
+    const closeServer = this.server;
+    this.server = null;
+    this.boundPort = 0;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const client of this.clients.values()) {
+      try {
+        client.socket.destroy();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    if (closeServer) {
+      await new Promise((resolve, reject) => {
+        closeServer.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  }
+  status() {
+    return {
+      running: this.server !== null,
+      host: this.host,
+      port: this.boundPort,
+      watching: this.watcher !== null,
+      lastUpdatedAt: this.graphSnapshot.generatedAt,
+      graphNodeCount: this.graphSnapshot.stats.nodes,
+      graphEdgeCount: this.graphSnapshot.stats.edges
+    };
+  }
+  async handleHttp(req, res) {
+    const url = req.url ?? "/";
+    if (req.method === "GET" && url === "/api/health") {
+      this.respondJson(res, 200, {
+        ok: true,
+        running: this.server !== null,
+        watching: this.watcher !== null,
+        graph: this.graphSnapshot.stats,
+        clients: this.clients.size,
+        lastError: this.lastError ?? void 0
+      });
+      return;
+    }
+    if (req.method === "GET" && url === "/api/graph") {
+      this.respondJson(res, 200, this.graphSnapshot);
+      return;
+    }
+    if (req.method === "GET" && url === "/app.js") {
+      await this.respondStatic(res, path46.join(this.publicDir, "app.js"), "application/javascript; charset=utf-8");
+      return;
+    }
+    if (req.method === "GET" && (url === "/" || url === "/index.html")) {
+      await this.respondStatic(res, path46.join(this.publicDir, "index.html"), "text/html; charset=utf-8");
+      return;
+    }
+    this.respondJson(res, 404, { error: "Not found" });
+  }
+  respondJson(res, status, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.setHeader("content-length", String(Buffer.byteLength(body)));
+    res.end(body);
+  }
+  async respondStatic(res, filePath, contentType) {
+    try {
+      const body = await readFile32(filePath, "utf-8");
+      res.statusCode = 200;
+      res.setHeader("content-type", contentType);
+      res.setHeader("content-length", String(Buffer.byteLength(body)));
+      res.end(body);
+    } catch {
+      this.respondJson(res, 404, { error: "Not found" });
+    }
+  }
+  handleUpgrade(req, socket) {
+    const upgrade = typeof req.headers.upgrade === "string" ? req.headers.upgrade.toLowerCase() : "";
+    const key = req.headers["sec-websocket-key"];
+    if (upgrade !== "websocket" || typeof key !== "string") {
+      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const accept = websocketAcceptKey(key);
+    socket.write(
+      [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${accept}`,
+        "",
+        ""
+      ].join("\r\n")
+    );
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    this.clients.set(id, { id, socket });
+    socket.on("close", () => {
+      this.clients.delete(id);
+    });
+    socket.on("error", () => {
+      this.clients.delete(id);
+    });
+    const hello = JSON.stringify({
+      type: "hello",
+      graph: this.graphSnapshot
+    });
+    socket.write(encodeTextFrame(hello));
+  }
+  broadcast(payload) {
+    const frame = encodeTextFrame(JSON.stringify(payload));
+    for (const [id, client] of this.clients.entries()) {
+      try {
+        client.socket.write(frame);
+      } catch {
+        this.clients.delete(id);
+      }
+    }
+  }
+  startWatcher() {
+    const graphDir = path46.join(this.memoryDir, "state", "graphs");
+    try {
+      this.watcher = watch(graphDir, { persistent: false }, () => {
+        this.scheduleRebuild();
+      });
+      this.watcher.on("error", (err) => {
+        this.lastError = err instanceof Error ? err.message : String(err);
+      });
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      this.watcher = null;
+    }
+  }
+  scheduleRebuild() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      void this.rebuildAndBroadcast();
+    }, this.watchDebounceMs);
+  }
+  async rebuildAndBroadcast() {
+    const previous = this.graphSnapshot;
+    await this.rebuildSnapshot();
+    const patch = diffGraphSnapshots(previous, this.graphSnapshot);
+    if (patch.addedEdges.length === 0 && patch.removedEdges.length === 0 && patch.addedNodes.length === 0 && patch.removedNodes.length === 0) {
+      return;
+    }
+    this.broadcast({
+      type: "graph_patch",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patch,
+      graph: this.graphSnapshot
+    });
+  }
+  async rebuildSnapshot() {
+    try {
+      this.graphSnapshot = await graphSnapshotFromMemoryDir(this.memoryDir);
+      this.lastError = null;
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+};
+
 // src/compat/checks.ts
-import { access as access2, readFile as readFile30 } from "fs/promises";
-import path44 from "path";
+import { access as access2, readFile as readFile33 } from "fs/promises";
+import path47 from "path";
 import { spawn as spawn4 } from "child_process";
 var REQUIRED_HOOKS = ["before_agent_start", "agent_end"];
 function isSafeCommandToken(command) {
@@ -22282,13 +23061,13 @@ function compareVersions(a, b) {
 async function runCompatChecks(options) {
   const checks = [];
   const runner = options.runner ?? defaultRunner;
-  const pluginJsonPath = path44.join(options.repoRoot, "openclaw.plugin.json");
-  const packageJsonPath = path44.join(options.repoRoot, "package.json");
-  const indexPath = path44.join(options.repoRoot, "src", "index.ts");
+  const pluginJsonPath = path47.join(options.repoRoot, "openclaw.plugin.json");
+  const packageJsonPath = path47.join(options.repoRoot, "package.json");
+  const indexPath = path47.join(options.repoRoot, "src", "index.ts");
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
-    pluginRaw = await readFile30(pluginJsonPath, "utf-8");
+    pluginRaw = await readFile33(pluginJsonPath, "utf-8");
     pluginManifestPresent = true;
     checks.push({
       id: "plugin-manifest-present",
@@ -22337,7 +23116,7 @@ async function runCompatChecks(options) {
   let packageRaw = "";
   let packageJsonPresent = false;
   try {
-    packageRaw = await readFile30(packageJsonPath, "utf-8");
+    packageRaw = await readFile33(packageJsonPath, "utf-8");
     packageJsonPresent = true;
   } catch {
     checks.push({
@@ -22408,7 +23187,7 @@ async function runCompatChecks(options) {
   }
   try {
     await access2(indexPath);
-    const indexRaw = await readFile30(indexPath, "utf-8");
+    const indexRaw = await readFile33(indexPath, "utf-8");
     const structuralSource = stripCommentsAndStrings(indexRaw);
     const hooks = parseHookRegistrations(indexRaw);
     const missingHooks = REQUIRED_HOOKS.filter((hook) => !hooks.has(hook));
@@ -22520,6 +23299,8 @@ function planAggressiveDuplicateDeletions(memories) {
 }
 var activeWebDavServer = null;
 var webDavOperationChain = Promise.resolve();
+var activeDashboardServer = null;
+var dashboardOperationChain = Promise.resolve();
 async function withWebDavLock(operation) {
   const run = webDavOperationChain.then(operation, operation);
   webDavOperationChain = run.then(
@@ -22528,6 +23309,14 @@ async function withWebDavLock(operation) {
   );
   return run;
 }
+async function withDashboardLock(operation) {
+  const run = dashboardOperationChain.then(operation, operation);
+  dashboardOperationChain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
 function isRoutePatternType(value) {
   return value === "keyword" || value === "regex";
 }
@@ -22615,6 +23404,21 @@ async function runGraphHealthCliCommand(options) {
     includeRepairGuidance: options.includeRepairGuidance
   });
 }
+async function runSessionCheckCliCommand(options) {
+  return analyzeSessionIntegrity({ memoryDir: options.memoryDir });
+}
+async function runSessionRepairCliCommand(options) {
+  const report = await analyzeSessionIntegrity({ memoryDir: options.memoryDir });
+  const dryRun = options.apply !== true || options.dryRun === true;
+  const plan = planSessionRepair({
+    report,
+    dryRun,
+    allowSessionFileRepair: options.allowSessionFileRepair === true,
+    sessionFilesDir: options.sessionFilesDir
+  });
+  const applyResult = await applySessionRepair({ plan });
+  return { report, plan, applyResult };
+}
 async function runTierStatusCliCommand(orchestrator) {
   return orchestrator.getTierMigrationStatus();
 }
@@ -22824,10 +23628,10 @@ function effectivePolicyValuesForVersion(values, config) {
 }
 function policyVersionForValues(values, config) {
   const normalized = effectivePolicyValuesForVersion(values, config);
-  return createHash9("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
+  return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path45.join(config.memoryDir, "state", fileName);
+  const filePath = path48.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -23064,8 +23868,8 @@ async function runWebDavServeCliCommand(options) {
       const current = activeWebDavServer.status();
       if (current.running) return current;
     }
-    const createServer2 = options.createServer ?? WebDavServer.create;
-    const server = await createServer2({
+    const createServer3 = options.createServer ?? WebDavServer.create;
+    const server = await createServer3({
       enabled: options.enabled ?? true,
       host: options.host,
       port: options.port ?? 8080,
@@ -23096,6 +23900,47 @@ async function runWebDavStopCliCommand() {
     return { stopped: true };
   });
 }
+async function runDashboardStartCliCommand(options) {
+  return withDashboardLock(async () => {
+    if (activeDashboardServer) {
+      const status = activeDashboardServer.status();
+      if (status.running) return status;
+    }
+    const createServer3 = options.createServer ?? ((opts) => new GraphDashboardServer({
+      memoryDir: opts.memoryDir,
+      host: opts.host,
+      port: opts.port,
+      publicDir: opts.publicDir
+    }));
+    const server = createServer3(options);
+    activeDashboardServer = server;
+    try {
+      return await server.start();
+    } catch (err) {
+      if (activeDashboardServer === server) {
+        activeDashboardServer = null;
+      }
+      throw err;
+    }
+  });
+}
+async function runDashboardStopCliCommand() {
+  return withDashboardLock(async () => {
+    if (!activeDashboardServer) return { stopped: false };
+    const server = activeDashboardServer;
+    await server.stop();
+    if (activeDashboardServer === server) {
+      activeDashboardServer = null;
+    }
+    return { stopped: true };
+  });
+}
+async function runDashboardStatusCliCommand() {
+  return withDashboardLock(async () => {
+    if (!activeDashboardServer) return { running: false };
+    return activeDashboardServer.status();
+  });
+}
 async function runCompatCliCommand(options = {}) {
   const report = await runCompatChecks({
     repoRoot: options.repoRoot ?? process.cwd(),
@@ -23286,7 +24131,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile31(options.inputPath, "utf-8");
+  const inputRaw = await readFile34(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -23351,7 +24196,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile31(pkgPath, "utf-8");
+    const raw = await readFile34(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -23370,32 +24215,32 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   if (!orchestrator.config.namespacesEnabled) return orchestrator.config.memoryDir;
-  const candidate = path45.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path48.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
 async function readAllMemoryFiles(memoryDir) {
-  const roots = [path45.join(memoryDir, "facts"), path45.join(memoryDir, "corrections")];
+  const roots = [path48.join(memoryDir, "facts"), path48.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir19(dir, { withFileTypes: true });
+      entries = await readdir20(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path45.join(dir, entryName);
+      const fullPath = path48.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile31(fullPath, "utf-8");
+        const raw = await readFile34(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -23673,6 +24518,25 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(report, null, 2));
         console.log("OK");
       });
+      cmd.command("session-check").description("Analyze transcript/checkpoint continuity integrity without mutating files").action(async () => {
+        const report = await runSessionCheckCliCommand({
+          memoryDir: orchestrator.config.memoryDir
+        });
+        console.log(JSON.stringify(report, null, 2));
+        console.log("OK");
+      });
+      cmd.command("session-repair").description("Generate/apply bounded Engram session integrity repairs (dry-run by default)").option("--apply", "Apply repairs (default: dry-run)").option("--dry-run", "Force dry-run output").option("--allow-session-file-repair", "Allow explicit OpenClaw session-file repair path (still no automatic rewiring)").option("--session-files-dir <path>", "Optional OpenClaw session files directory for guarded repair workflow").action(async (...args) => {
+        const options = args[0] ?? {};
+        const result = await runSessionRepairCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          apply: options.apply === true,
+          dryRun: options.dryRun === true,
+          allowSessionFileRepair: options.allowSessionFileRepair === true,
+          sessionFilesDir: typeof options.sessionFilesDir === "string" && options.sessionFilesDir.trim().length > 0 ? options.sessionFilesDir.trim() : void 0
+        });
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
       cmd.command("tier-status").description("Show tier migration telemetry and last-cycle summary").action(async () => {
         const status = await runTierStatusCliCommand(orchestrator);
         console.log(JSON.stringify(status, null, 2));
@@ -23811,6 +24675,29 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(result, null, 2));
         console.log("OK");
       });
+      const dashboardCmd = cmd.command("dashboard").description("Manage live graph dashboard service");
+      dashboardCmd.command("start").description("Start dashboard server (localhost by default)").option("--host <host>", "Bind host", "127.0.0.1").option("--port <n>", "Bind port", "4319").option("--public-dir <path>", "Override static dashboard assets path").action(async (...args) => {
+        const options = args[0] ?? {};
+        const portRaw = parseInt(String(options.port ?? "4319"), 10);
+        const status = await runDashboardStartCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          host: typeof options.host === "string" ? options.host : "127.0.0.1",
+          port: Number.isFinite(portRaw) ? portRaw : 4319,
+          publicDir: typeof options.publicDir === "string" ? options.publicDir : void 0
+        });
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
+      dashboardCmd.command("stop").description("Stop dashboard server").action(async () => {
+        const result = await runDashboardStopCliCommand();
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
+      dashboardCmd.command("status").description("Show dashboard server status").action(async () => {
+        const status = await runDashboardStatusCliCommand();
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
       const routeCmd = cmd.command("route").description("Manage custom memory routing rules");
       routeCmd.command("list").description("List configured routing rules").action(async () => {
         const rules = await runRouteCliCommand({
@@ -24051,7 +24938,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink5(filePath);
+            await unlink6(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -24099,7 +24986,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink5(filePath);
+            await unlink6(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -24263,7 +25150,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path45.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path48.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -24486,8 +25373,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path45.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path45.join(memoryDir, "threads"));
+        const memoryDir = path48.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path48.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -24660,16 +25547,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile32, writeFile as writeFile27 } from "fs/promises";
+import { readFile as readFile35, writeFile as writeFile28 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path46 from "path";
+import path49 from "path";
 import os5 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path46.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path49.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -24877,11 +25764,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path46.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path49.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile32(cronFilePath, "utf-8");
+          const content = await readFile35(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -24918,7 +25805,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile27(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile28(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);