@joshuaswarren/openclaw-engram 8.3.25 → 8.3.26

package/dist/index.js

@@ -6,6 +6,18 @@ import {
 
 // src/config.ts
 import path from "path";
+
+// src/session-observer-bands.ts
+var DEFAULT_SESSION_OBSERVER_BANDS = [
+  { maxBytes: 5e4, triggerDeltaBytes: 4800, triggerDeltaTokens: 1200 },
+  { maxBytes: 2e5, triggerDeltaBytes: 9600, triggerDeltaTokens: 2400 },
+  { maxBytes: 1e9, triggerDeltaBytes: 19200, triggerDeltaTokens: 4800 }
+];
+function cloneDefaultSessionObserverBands() {
+  return DEFAULT_SESSION_OBSERVER_BANDS.map((band) => ({ ...band }));
+}
+
+// src/config.ts
 var DEFAULT_MEMORY_DIR = path.join(
   process.env.HOME ?? "~",
   ".openclaw",
@@ -81,6 +93,11 @@ function parseConfig(raw) {
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
   const identityContinuityEnabled = cfg.identityContinuityEnabled === true;
+  const sessionObserverBands = Array.isArray(cfg.sessionObserverBands) ? cfg.sessionObserverBands.map((band) => ({
+    maxBytes: typeof band?.maxBytes === "number" ? Math.max(0, Math.floor(band.maxBytes)) : 0,
+    triggerDeltaBytes: typeof band?.triggerDeltaBytes === "number" ? Math.max(0, Math.floor(band.triggerDeltaBytes)) : 0,
+    triggerDeltaTokens: typeof band?.triggerDeltaTokens === "number" ? Math.max(0, Math.floor(band.triggerDeltaTokens)) : 0
+  })).filter((band) => band.maxBytes > 0) : cloneDefaultSessionObserverBands();
   const principalRules = Array.isArray(cfg.principalFromSessionKeyRules) ? cfg.principalFromSessionKeyRules.map((r) => ({
     match: typeof r?.match === "string" ? r.match : "",
     principal: typeof r?.principal === "string" ? r.principal : ""
@@ -138,6 +155,9 @@ function parseConfig(raw) {
     identityMaxInjectChars: typeof cfg.identityMaxInjectChars === "number" ? Math.max(0, Math.floor(cfg.identityMaxInjectChars)) : 1200,
     continuityIncidentLoggingEnabled: typeof cfg.continuityIncidentLoggingEnabled === "boolean" ? cfg.continuityIncidentLoggingEnabled : identityContinuityEnabled,
     continuityAuditEnabled: cfg.continuityAuditEnabled === true,
+    sessionObserverEnabled: cfg.sessionObserverEnabled === true,
+    sessionObserverDebounceMs: typeof cfg.sessionObserverDebounceMs === "number" ? Math.max(0, Math.floor(cfg.sessionObserverDebounceMs)) : 12e4,
+    sessionObserverBands,
     injectQuestions: cfg.injectQuestions === true,
     commitmentDecayDays: typeof cfg.commitmentDecayDays === "number" ? cfg.commitmentDecayDays : 90,
     workspaceDir: typeof cfg.workspaceDir === "string" && cfg.workspaceDir.length > 0 ? cfg.workspaceDir : DEFAULT_WORKSPACE_DIR,
@@ -394,9 +414,9 @@ function parseConfig(raw) {
 }
 
 // src/orchestrator.ts
-import path22 from "path";
+import path23 from "path";
 import { createHash as createHash4 } from "crypto";
-import { mkdir as mkdir16, readFile as readFile16, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile16 } from "fs/promises";
 
 // src/signal.ts
 var BUILTIN_HIGH_PATTERNS = [
@@ -7054,7 +7074,7 @@ function extractTopics(memories, topN = 50) {
 }
 
 // src/transcript.ts
-import { appendFile as appendFile2, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+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 path6 from "path";
 var TranscriptManager = class _TranscriptManager {
   transcriptsDir;
@@ -7062,6 +7082,7 @@ var TranscriptManager = class _TranscriptManager {
   stateDir;
   toolUsageDir;
   config;
+  sessionFootprintCache = /* @__PURE__ */ new Map();
   /** Default checkpoint TTL in hours */
   static DEFAULT_CHECKPOINT_TTL_HOURS = 24;
   /** Approximate characters per token for rough estimation */
@@ -7077,10 +7098,10 @@ var TranscriptManager = class _TranscriptManager {
    * Parse a sessionKey to extract channel type and ID.
    *
    * SessionKey patterns:
-   *   - agent:generalist:main → type="main", id="default"
-   *   - agent:generalist:discord:channel:1468425700242620516 → type="discord", id="1468425700242620516"
-   *   - agent:generalist:cron:db61e2ac-... → type="cron", id="db61e2ac-..."
-   *   - agent:generalist:slack:channel:C123456 → type="slack", id="C123456"
+   *   - agent:<agent-id>:main → type="main", id="default"
+   *   - agent:<agent-id>:discord:channel:<channel-id> → type="discord", id="<channel-id>"
+   *   - agent:<agent-id>:cron:<job-id> → type="cron", id="<job-id>"
+   *   - agent:<agent-id>:slack:channel:<channel-id> → type="slack", id="<channel-id>"
    *
    * @returns Object with dir (channel type/channel id) and file (YYYY-MM-DD.jsonl)
    */
@@ -7195,6 +7216,101 @@ var TranscriptManager = class _TranscriptManager {
       return [];
     }
   }
+  async estimateSessionFootprint(sessionKey) {
+    const { dir } = this.getTranscriptPath(sessionKey);
+    const channelDir = path6.join(this.transcriptsDir, dir);
+    let bytes = 0;
+    try {
+      const files = (await readdir3(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 fileInfo = await stat2(fullPath);
+            const sessionBytes = await this.estimateSessionBytesInFile(
+              fullPath,
+              sessionKey
+            );
+            fileBytes.set(file, sessionBytes);
+            fileSizes.set(file, Math.max(0, fileInfo.size));
+            bytes += sessionBytes;
+          } catch {
+          }
+        }
+        this.sessionFootprintCache.set(sessionKey, { totalBytes: bytes, fileBytes, fileSizes });
+      } else {
+        bytes = cached.totalBytes;
+        const seen = new Set(files);
+        for (const [cachedFile, cachedSessionBytes] of cached.fileBytes.entries()) {
+          if (!seen.has(cachedFile)) {
+            bytes -= cachedSessionBytes;
+            cached.fileBytes.delete(cachedFile);
+            cached.fileSizes.delete(cachedFile);
+          }
+        }
+        for (const file of files) {
+          if (cached.fileBytes.has(file)) continue;
+          try {
+            const fullPath = path6.join(channelDir, file);
+            const fileInfo = await stat2(fullPath);
+            const sessionBytes = await this.estimateSessionBytesInFile(fullPath, sessionKey);
+            cached.fileBytes.set(file, sessionBytes);
+            cached.fileSizes.set(file, Math.max(0, fileInfo.size));
+            bytes += sessionBytes;
+          } catch {
+          }
+        }
+        const newestFile = files[files.length - 1];
+        if (newestFile) {
+          try {
+            const newestPath = path6.join(channelDir, newestFile);
+            const fileInfo = await stat2(newestPath);
+            const size = Math.max(0, fileInfo.size);
+            const previousSessionBytes = cached.fileBytes.get(newestFile) ?? 0;
+            const previousSize = cached.fileSizes.get(newestFile) ?? -1;
+            if (size !== previousSize) {
+              const sessionBytes = await this.estimateSessionBytesInFile(newestPath, sessionKey);
+              cached.fileBytes.set(newestFile, sessionBytes);
+              cached.fileSizes.set(newestFile, size);
+              bytes += sessionBytes - previousSessionBytes;
+            }
+          } catch {
+          }
+        }
+        if (bytes < 0) bytes = 0;
+        cached.totalBytes = bytes;
+      }
+    } catch {
+      this.sessionFootprintCache.delete(sessionKey);
+    }
+    return {
+      bytes,
+      tokens: Math.floor(bytes / _TranscriptManager.CHARS_PER_TOKEN)
+    };
+  }
+  async estimateSessionBytesInFile(filePath, sessionKey) {
+    try {
+      const raw = await readFile4(filePath, "utf-8");
+      let total = 0;
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.sessionKey === sessionKey) {
+            total += Buffer.byteLength(`${line}
+`, "utf-8");
+          }
+        } catch {
+        }
+      }
+      return total;
+    } catch {
+      return 0;
+    }
+  }
   /**
    * Check if a file is a legacy flat transcript file (YYYY-MM-DD.jsonl format).
    */
@@ -8452,14 +8568,278 @@ var LastRecallStore = class {
   }
 };
 
-// src/embedding-fallback.ts
+// src/session-observer-state.ts
 import path11 from "path";
-import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir9, open, readFile as readFile9, stat as stat3, unlink as unlink3, writeFile as writeFile9 } from "fs/promises";
+function sanitizeNonNegativeInt(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+function parseIsoMs(value) {
+  if (!value) return 0;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : 0;
+}
+function mergeSessionCursor(existing, incoming) {
+  const existingObservedMs = parseIsoMs(existing.lastObservedAt);
+  const incomingObservedMs = parseIsoMs(incoming.lastObservedAt);
+  const existingTriggeredMs = parseIsoMs(existing.lastTriggeredAt);
+  const incomingTriggeredMs = parseIsoMs(incoming.lastTriggeredAt);
+  const existingResetMs = parseIsoMs(existing.lastResetAt);
+  const incomingResetMs = parseIsoMs(incoming.lastResetAt);
+  const observedAt = incomingObservedMs >= existingObservedMs ? incoming.lastObservedAt : existing.lastObservedAt;
+  const triggeredAt = incomingTriggeredMs >= existingTriggeredMs ? incoming.lastTriggeredAt : existing.lastTriggeredAt;
+  const incomingIsNewer = incomingObservedMs >= existingObservedMs;
+  const incomingHasNewerReset = incomingResetMs > existingResetMs;
+  const allowIncomingReset = incomingIsNewer && incomingHasNewerReset;
+  const keepExistingReset = existingResetMs > incomingResetMs && existingObservedMs >= incomingObservedMs;
+  let cursorBytes = Math.max(
+    sanitizeNonNegativeInt(existing.cursorBytes),
+    sanitizeNonNegativeInt(incoming.cursorBytes)
+  );
+  let cursorTokens = Math.max(
+    sanitizeNonNegativeInt(existing.cursorTokens),
+    sanitizeNonNegativeInt(incoming.cursorTokens)
+  );
+  if (keepExistingReset) {
+    cursorBytes = sanitizeNonNegativeInt(existing.cursorBytes);
+    cursorTokens = sanitizeNonNegativeInt(existing.cursorTokens);
+  } else if (allowIncomingReset) {
+    cursorBytes = sanitizeNonNegativeInt(incoming.cursorBytes);
+    cursorTokens = sanitizeNonNegativeInt(incoming.cursorTokens);
+  }
+  return {
+    sessionKey: existing.sessionKey,
+    cursorBytes,
+    cursorTokens,
+    lastObservedAt: observedAt,
+    lastTriggeredAt: triggeredAt,
+    lastResetAt: incomingResetMs >= existingResetMs ? incoming.lastResetAt : existing.lastResetAt
+  };
+}
+function normalizeObserverBands(bands) {
+  const normalized = bands.map((band) => ({
+    maxBytes: sanitizeNonNegativeInt(band.maxBytes),
+    triggerDeltaBytes: sanitizeNonNegativeInt(band.triggerDeltaBytes),
+    triggerDeltaTokens: sanitizeNonNegativeInt(band.triggerDeltaTokens)
+  })).filter((band) => band.maxBytes > 0).sort((a, b) => a.maxBytes - b.maxBytes);
+  if (normalized.length === 0) {
+    return cloneDefaultSessionObserverBands();
+  }
+  const last = normalized[normalized.length - 1];
+  if (last && last.maxBytes < 1e9) {
+    normalized.push({
+      maxBytes: 1e9,
+      triggerDeltaBytes: last.triggerDeltaBytes,
+      triggerDeltaTokens: last.triggerDeltaTokens
+    });
+  }
+  return normalized;
+}
+var SessionObserverState = class {
+  statePath;
+  lockPath;
+  lockStaleMs = 12e4;
+  debounceMs;
+  bands;
+  sessions = /* @__PURE__ */ new Map();
+  saveQueue = Promise.resolve();
+  async readPersistedState() {
+    try {
+      const raw = await readFile9(this.statePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object") {
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  normalizePersistedSessions(sessions) {
+    const next = /* @__PURE__ */ new Map();
+    for (const [sessionKey, value] of Object.entries(sessions)) {
+      if (!value || typeof value !== "object") continue;
+      next.set(sessionKey, {
+        sessionKey,
+        cursorBytes: sanitizeNonNegativeInt(value.cursorBytes),
+        cursorTokens: sanitizeNonNegativeInt(value.cursorTokens),
+        lastObservedAt: typeof value.lastObservedAt === "string" ? value.lastObservedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+        lastTriggeredAt: typeof value.lastTriggeredAt === "string" ? value.lastTriggeredAt : void 0,
+        lastResetAt: typeof value.lastResetAt === "string" ? value.lastResetAt : void 0
+      });
+    }
+    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.debounceMs = Math.max(0, Math.floor(opts.debounceMs));
+    this.bands = normalizeObserverBands(opts.bands);
+  }
+  async withSaveLock(fn) {
+    await mkdir9(path11.dirname(this.lockPath), { recursive: true });
+    for (let attempt = 0; attempt < 80; attempt++) {
+      try {
+        const handle = await open(this.lockPath, "wx");
+        try {
+          await fn();
+        } finally {
+          await handle.close();
+          await unlink3(this.lockPath).catch(() => {
+          });
+        }
+        return;
+      } catch (err) {
+        if (err?.code !== "EEXIST") throw err;
+        try {
+          const lockInfo = await stat3(this.lockPath);
+          if (Date.now() - lockInfo.mtimeMs > this.lockStaleMs) {
+            await unlink3(this.lockPath).catch(() => {
+            });
+            continue;
+          }
+        } catch {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    const error = new Error("session observer save lock timeout");
+    log.debug(error.message);
+    throw error;
+  }
+  async load() {
+    const parsed = await this.readPersistedState();
+    if (!parsed) {
+      this.sessions.clear();
+      return;
+    }
+    this.sessions = this.normalizePersistedSessions(parsed.sessions);
+  }
+  async save() {
+    await this.withSaveLock(async () => {
+      const merged = /* @__PURE__ */ new Map();
+      const persisted = await this.readPersistedState();
+      if (persisted) {
+        for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {
+          merged.set(key, value);
+        }
+      }
+      for (const [key, current] of this.sessions.entries()) {
+        const existing = merged.get(key);
+        if (!existing) {
+          merged.set(key, current);
+          continue;
+        }
+        merged.set(key, mergeSessionCursor(existing, current));
+      }
+      this.sessions = merged;
+      const sessions = {};
+      for (const [key, value] of merged.entries()) {
+        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");
+    });
+  }
+  enqueueSave() {
+    this.saveQueue = this.saveQueue.catch(() => void 0).then(() => this.save());
+    return this.saveQueue;
+  }
+  bandForTotalBytes(totalBytes) {
+    const bytes = sanitizeNonNegativeInt(totalBytes);
+    for (const band of this.bands) {
+      if (bytes <= band.maxBytes) return band;
+    }
+    return this.bands[this.bands.length - 1];
+  }
+  async observe(input) {
+    const nowIso = input.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const totalBytes = sanitizeNonNegativeInt(input.totalBytes);
+    const totalTokens = sanitizeNonNegativeInt(input.totalTokens);
+    const band = this.bandForTotalBytes(totalBytes);
+    const existing = this.sessions.get(input.sessionKey);
+    if (!existing) {
+      this.sessions.set(input.sessionKey, {
+        sessionKey: input.sessionKey,
+        cursorBytes: totalBytes,
+        cursorTokens: totalTokens,
+        lastObservedAt: nowIso
+      });
+      await this.enqueueSave();
+      return {
+        triggered: false,
+        deltaBytes: 0,
+        deltaTokens: 0,
+        band,
+        reason: "baseline"
+      };
+    }
+    const session = { ...existing };
+    if (totalBytes < session.cursorBytes || totalTokens < session.cursorTokens) {
+      session.cursorBytes = totalBytes;
+      session.cursorTokens = totalTokens;
+      session.lastObservedAt = nowIso;
+      session.lastResetAt = nowIso;
+      this.sessions.set(input.sessionKey, session);
+      await this.enqueueSave();
+      return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: "baseline" };
+    }
+    const deltaBytes = totalBytes - session.cursorBytes;
+    const deltaTokens = totalTokens - session.cursorTokens;
+    const crossedThreshold = band.triggerDeltaBytes > 0 && deltaBytes >= band.triggerDeltaBytes || band.triggerDeltaTokens > 0 && deltaTokens >= band.triggerDeltaTokens;
+    session.lastObservedAt = nowIso;
+    if (!crossedThreshold) {
+      const unchanged = deltaBytes === 0 && deltaTokens === 0;
+      if (!unchanged) {
+        this.sessions.set(input.sessionKey, session);
+        await this.enqueueSave();
+      }
+      return {
+        triggered: false,
+        deltaBytes,
+        deltaTokens,
+        band
+      };
+    }
+    const nowMs = Date.parse(nowIso);
+    const lastTriggeredMs = session.lastTriggeredAt ? Date.parse(session.lastTriggeredAt) : NaN;
+    const withinDebounce = Number.isFinite(lastTriggeredMs) && nowMs - lastTriggeredMs < this.debounceMs;
+    if (withinDebounce) {
+      this.sessions.set(input.sessionKey, session);
+      await this.enqueueSave();
+      return {
+        triggered: false,
+        deltaBytes,
+        deltaTokens,
+        band,
+        reason: "debounced"
+      };
+    }
+    session.lastTriggeredAt = nowIso;
+    session.cursorBytes = totalBytes;
+    session.cursorTokens = totalTokens;
+    this.sessions.set(input.sessionKey, session);
+    await this.enqueueSave();
+    return {
+      triggered: true,
+      deltaBytes,
+      deltaTokens,
+      band,
+      reason: "threshold"
+    };
+  }
+};
+
+// src/embedding-fallback.ts
+import path12 from "path";
+import { mkdir as mkdir10, readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
 var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
 var EmbeddingFallback = class {
   constructor(config) {
     this.config = config;
-    this.indexPath = path11.join(config.memoryDir, "state", "embeddings.json");
+    this.indexPath = path12.join(config.memoryDir, "state", "embeddings.json");
   }
   indexPath;
   loaded = null;
@@ -8569,7 +8949,7 @@ var EmbeddingFallback = class {
       return this.loaded;
     }
     try {
-      const raw = await readFile9(this.indexPath, "utf-8");
+      const raw = await readFile10(this.indexPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.version === 1 && parsed.entries && typeof parsed.entries === "object") {
         this.loaded = {
@@ -8591,14 +8971,14 @@ var EmbeddingFallback = class {
     return this.loaded;
   }
   async saveIndex(index) {
-    await mkdir9(path11.dirname(this.indexPath), { recursive: true });
-    await writeFile9(this.indexPath, JSON.stringify(index), "utf-8");
+    await mkdir10(path12.dirname(this.indexPath), { recursive: true });
+    await writeFile10(this.indexPath, JSON.stringify(index), "utf-8");
     this.loaded = index;
   }
 };
 function toMemoryRelativePath(memoryDir, filePath) {
-  if (!path11.isAbsolute(filePath)) return filePath;
-  const rel = path11.relative(memoryDir, filePath);
+  if (!path12.isAbsolute(filePath)) return filePath;
+  const rel = path12.relative(memoryDir, filePath);
   return rel.startsWith("..") ? filePath : rel;
 }
 function cosineSimilarity(a, b) {
@@ -8620,8 +9000,8 @@ function cosineSimilarity(a, b) {
 }
 
 // src/bootstrap.ts
-import path12 from "path";
-import { readdir as readdir5, readFile as readFile10 } from "fs/promises";
+import path13 from "path";
+import { readdir as readdir5, readFile as readFile11 } from "fs/promises";
 var BootstrapEngine = class {
   constructor(config, orchestrator) {
     this.config = config;
@@ -8700,7 +9080,7 @@ var BootstrapEngine = class {
     for (const filePath of files) {
       let raw = "";
       try {
-        raw = await readFile10(filePath, "utf-8");
+        raw = await readFile11(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -8718,7 +9098,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 : path12.relative(baseDir, filePath);
+        const sessionKey = typeof parsed?.sessionKey === "string" && parsed.sessionKey.length > 0 ? parsed.sessionKey : path13.relative(baseDir, filePath);
         const list = bySession.get(sessionKey) ?? [];
         list.push({
           role,
@@ -8738,7 +9118,7 @@ var BootstrapEngine = class {
     const out = [];
     const entries = await readdir5(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
-      const full = path12.join(dir, entry.name);
+      const full = path13.join(dir, entry.name);
       if (entry.isDirectory()) {
         out.push(...await this.listJsonlFiles(full));
       } else if (entry.isFile() && full.endsWith(".jsonl")) {
@@ -8995,8 +9375,8 @@ function buildRecallQueryPolicy(prompt, sessionKey, cfg) {
 }
 
 // src/boxes.ts
-import { mkdir as mkdir10, writeFile as writeFile10, readFile as readFile11, readdir as readdir6 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir11, writeFile as writeFile11, readFile as readFile12, readdir as readdir6 } from "fs/promises";
+import path14 from "path";
 import { createHash as createHash3 } from "crypto";
 var BOX_DIR = "boxes";
 var STATE_DIR = "state";
@@ -9071,42 +9451,42 @@ var BoxBuilder = class {
     this.cfg = cfg;
   }
   get boxBaseDir() {
-    return path13.join(this.baseDir, BOX_DIR);
+    return path14.join(this.baseDir, BOX_DIR);
   }
   get stateDir() {
-    return path13.join(this.baseDir, STATE_DIR);
+    return path14.join(this.baseDir, STATE_DIR);
   }
   get openBoxStatePath() {
-    return path13.join(this.stateDir, OPEN_BOX_STATE_FILE);
+    return path14.join(this.stateDir, OPEN_BOX_STATE_FILE);
   }
   get tracesPath() {
-    return path13.join(this.stateDir, TRACES_FILE);
+    return path14.join(this.stateDir, TRACES_FILE);
   }
   // ── State persistence ────────────────────────────────────────────────────
   async loadOpenBox() {
     if (this.stateLoaded) return;
     this.stateLoaded = true;
     try {
-      const raw = await readFile11(this.openBoxStatePath, "utf-8");
+      const raw = await readFile12(this.openBoxStatePath, "utf-8");
       this.openBox = JSON.parse(raw);
     } catch {
       this.openBox = null;
     }
   }
   async saveOpenBox() {
-    await mkdir10(this.stateDir, { recursive: true });
+    await mkdir11(this.stateDir, { recursive: true });
     if (this.openBox) {
-      await writeFile10(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
+      await writeFile11(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
     } else {
       try {
-        await writeFile10(this.openBoxStatePath, "null", "utf-8");
+        await writeFile11(this.openBoxStatePath, "null", "utf-8");
       } catch {
       }
     }
   }
   async loadTraceIndex() {
     try {
-      const raw = await readFile11(this.tracesPath, "utf-8");
+      const raw = await readFile12(this.tracesPath, "utf-8");
       const parsed = JSON.parse(raw);
       parsed.traceLastSeen ??= {};
       return parsed;
@@ -9116,8 +9496,8 @@ var BoxBuilder = class {
   }
   async saveTraceIndex(idx) {
     try {
-      await mkdir10(this.stateDir, { recursive: true });
-      await writeFile10(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
+      await mkdir11(this.stateDir, { recursive: true });
+      await writeFile11(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
     } catch (err) {
       log.warn(`[engram/boxes] Failed to save trace index: ${err.message}`);
     }
@@ -9193,8 +9573,8 @@ var BoxBuilder = class {
     }
     const sealedAt = (/* @__PURE__ */ new Date()).toISOString();
     const day = sealedAt.slice(0, 10);
-    const dir = path13.join(this.boxBaseDir, day);
-    await mkdir10(dir, { recursive: true });
+    const dir = path14.join(this.boxBaseDir, day);
+    await mkdir11(dir, { recursive: true });
     let traceId;
     if (this.cfg.traceWeaverEnabled && box.topics.length > 0) {
       traceId = await this.resolveTrace(box.id, box.topics);
@@ -9213,8 +9593,8 @@ var BoxBuilder = class {
 
 <!-- Topics: ${box.topics.join(", ")} | Memories: ${box.memoryIds.length} -->
 `;
-    const filePath = path13.join(dir, `${box.id}.md`);
-    await writeFile10(filePath, content, "utf-8");
+    const filePath = path14.join(dir, `${box.id}.md`);
+    await writeFile11(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;
@@ -9265,12 +9645,12 @@ var BoxBuilder = class {
       try {
         const entries = await readdir6(dir, { withFileTypes: true });
         for (const e of entries) {
-          const full = path13.join(dir, e.name);
+          const full = path14.join(dir, e.name);
           if (e.isDirectory()) {
             await walkDir(full);
           } else if (e.name.endsWith(".md")) {
             try {
-              const raw = await readFile11(full, "utf-8");
+              const raw = await readFile12(full, "utf-8");
               const parsed = parseBoxFrontmatter(raw);
               if (parsed && new Date(parsed.sealedAt) >= cutoff) {
                 boxes.push(parsed);
@@ -9378,8 +9758,8 @@ function classifyMemoryKind(content, tags, category) {
 
 // src/tmt.ts
 import * as fs from "fs";
-import * as path14 from "path";
-import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile11, readdir as readdir7 } from "fs/promises";
+import * as path15 from "path";
+import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile12, readdir as readdir7 } from "fs/promises";
 var TMT_DIR = "tmt";
 var TMT_LEVEL_INPUT_LIMITS = {
   hour: { totalChars: 48e3, itemChars: 2e3, maxItems: 64 },
@@ -9408,19 +9788,19 @@ function capTmtSummaryInputs(inputs, level) {
   return [fallback.length > itemChars ? `${fallback.slice(0, itemChars - 1)}\u2026` : fallback];
 }
 function tmtDir(baseDir) {
-  return path14.join(baseDir, TMT_DIR);
+  return path15.join(baseDir, TMT_DIR);
 }
 function hourNodePath(baseDir, date, hour) {
-  return path14.join(tmtDir(baseDir), date, `hour-${hour}.md`);
+  return path15.join(tmtDir(baseDir), date, `hour-${hour}.md`);
 }
 function dayNodePath(baseDir, date) {
-  return path14.join(tmtDir(baseDir), date, "day.md");
+  return path15.join(tmtDir(baseDir), date, "day.md");
 }
 function weekNodePath(baseDir, weekKey) {
-  return path14.join(tmtDir(baseDir), `week-${weekKey}.md`);
+  return path15.join(tmtDir(baseDir), `week-${weekKey}.md`);
 }
 function personaNodePath(baseDir) {
-  return path14.join(tmtDir(baseDir), "persona.md");
+  return path15.join(tmtDir(baseDir), "persona.md");
 }
 function serialiseTmtNode(fm, summary) {
   const yaml = [
@@ -9466,7 +9846,7 @@ var TmtBuilder = class {
   async maybeRebuildNodes(memories, summarize) {
     if (!this.cfg.temporalMemoryTreeEnabled || memories.length === 0) return;
     try {
-      await mkdir11(tmtDir(this.baseDir), { recursive: true });
+      await mkdir12(tmtDir(this.baseDir), { recursive: true });
       await this.buildHourNodes(memories, summarize);
       await this.buildDayNodes(memories, summarize);
       await this.buildWeekNodes(memories, summarize);
@@ -9491,7 +9871,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile12(nodePath, "utf8");
+          const existing = await readFile13(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -9517,8 +9897,8 @@ var TmtBuilder = class {
         sourceIds: entries.map((e) => e.id),
         builtAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await mkdir11(path14.dirname(nodePath), { recursive: true });
-      await writeFile11(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await mkdir12(path15.dirname(nodePath), { recursive: true });
+      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
     }
   }
   async buildDayNodes(memories, summarize) {
@@ -9533,7 +9913,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile12(nodePath, "utf8");
+          const existing = await readFile13(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -9554,7 +9934,7 @@ var TmtBuilder = class {
         const hPath = hourNodePath(this.baseDir, date, h);
         if (fs.existsSync(hPath)) {
           try {
-            const hContent = await readFile12(hPath, "utf8");
+            const hContent = await readFile13(hPath, "utf8");
             const hSummary = hContent.replace(/^---[\s\S]*?---\n\n?/, "").trim();
             if (hSummary) {
               inputs.push(hSummary);
@@ -9582,8 +9962,8 @@ var TmtBuilder = class {
         sourceIds: entries.map((e) => e.id),
         builtAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await mkdir11(path14.dirname(nodePath), { recursive: true });
-      await writeFile11(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await mkdir12(path15.dirname(nodePath), { recursive: true });
+      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
     }
   }
   /**
@@ -9604,7 +9984,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile12(nodePath, "utf8");
+          const existing = await readFile13(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
             shouldBuild = true;
@@ -9630,7 +10010,7 @@ var TmtBuilder = class {
           const dayPath = dayNodePath(this.baseDir, dateDir);
           if (fs.existsSync(dayPath)) {
             try {
-              const content = await readFile12(dayPath, "utf8");
+              const content = await readFile13(dayPath, "utf8");
               const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
               if (summary2) daySummaries.push(summary2);
             } catch {
@@ -9648,8 +10028,8 @@ var TmtBuilder = class {
           sourceIds: entries.map((e) => e.id),
           builtAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await mkdir11(path14.dirname(nodePath), { recursive: true });
-        await writeFile11(nodePath, serialiseTmtNode(fm, summary), "utf8");
+        await mkdir12(path15.dirname(nodePath), { recursive: true });
+        await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
       } catch (err) {
         console.warn(`[engram] tmt: week node build failed for ${week} (ignored): ${err}`);
       }
@@ -9677,7 +10057,7 @@ var TmtBuilder = class {
       let latestEnd;
       for (const f of weekFiles) {
         try {
-          const content = await readFile12(path14.join(dir, f), "utf8");
+          const content = await readFile13(path15.join(dir, f), "utf8");
           const summary2 = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
           if (summary2) weekSummaries.push(summary2);
           const countMatch = content.match(/memoryCount: (\d+)/);
@@ -9698,7 +10078,7 @@ var TmtBuilder = class {
       let shouldBuild = !fs.existsSync(nodePath);
       if (!shouldBuild) {
         try {
-          const existing = await readFile12(nodePath, "utf8");
+          const existing = await readFile13(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
           if (!countMatch || parseInt(countMatch[1], 10) !== totalCount) {
             shouldBuild = true;
@@ -9718,7 +10098,7 @@ var TmtBuilder = class {
         sourceIds: [],
         builtAt: now
       };
-      await writeFile11(nodePath, serialiseTmtNode(fm, summary), "utf8");
+      await writeFile12(nodePath, serialiseTmtNode(fm, summary), "utf8");
     } catch (err) {
       console.warn(`[engram] tmt: persona node build failed (ignored): ${err}`);
     }
@@ -9736,7 +10116,7 @@ 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 readFile12(todayDay, "utf8");
+        const content = await readFile13(todayDay, "utf8");
         const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
         if (summary) return { level: "day", summary };
       }
@@ -9750,7 +10130,7 @@ var TmtBuilder = class {
       for (const dateDir of dateDirs) {
         const dayPath = dayNodePath(this.baseDir, dateDir);
         if (fs.existsSync(dayPath)) {
-          const content = await readFile12(dayPath, "utf8");
+          const content = await readFile13(dayPath, "utf8");
           const summary = content.replace(/^---[\s\S]*?---\n\n?/, "").trim();
           if (summary) return { level: "day", summary };
         }
@@ -9775,13 +10155,13 @@ function clamp01(value) {
   if (value > 1) return 1;
   return value;
 }
-function parseIsoMs(value) {
+function parseIsoMs2(value) {
   if (!value) return null;
   const ms = Date.parse(value);
   return Number.isFinite(ms) ? ms : null;
 }
 function daysSince(value, nowMs) {
-  const ts = parseIsoMs(value);
+  const ts = parseIsoMs2(value);
   if (ts === null) return 365;
   return Math.max(0, (nowMs - ts) / 864e5);
 }
@@ -9925,18 +10305,18 @@ function decideLifecycleTransition(memory, policy, now, signals) {
 
 // src/temporal-index.ts
 import * as fs2 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 var INDEX_VERSION = 1;
 var TEMPORAL_INDEX_FILE = "index_time.json";
 var TAG_INDEX_FILE = "index_tags.json";
 function stateDir(memoryDir) {
-  return path15.join(memoryDir, "state");
+  return path16.join(memoryDir, "state");
 }
 function temporalIndexPath(memoryDir) {
-  return path15.join(stateDir(memoryDir), TEMPORAL_INDEX_FILE);
+  return path16.join(stateDir(memoryDir), TEMPORAL_INDEX_FILE);
 }
 function tagIndexPath(memoryDir) {
-  return path15.join(stateDir(memoryDir), TAG_INDEX_FILE);
+  return path16.join(stateDir(memoryDir), TAG_INDEX_FILE);
 }
 function ensureStateDir(memoryDir) {
   const dir = stateDir(memoryDir);
@@ -10170,8 +10550,8 @@ function recencyWindowFromPrompt(prompt, nowMs = Date.now()) {
 }
 
 // src/graph.ts
-import { mkdir as mkdir12, appendFile as appendFile4, readFile as readFile13 } from "fs/promises";
-import * as path16 from "path";
+import { mkdir as mkdir13, appendFile as appendFile4, readFile as readFile14 } from "fs/promises";
+import * as path17 from "path";
 var CAUSAL_PHRASES = [
   "as a result",
   "led to",
@@ -10181,13 +10561,13 @@ var CAUSAL_PHRASES = [
   "because"
 ];
 function graphsDir(memoryDir) {
-  return path16.join(memoryDir, "state", "graphs");
+  return path17.join(memoryDir, "state", "graphs");
 }
 function graphFilePath(memoryDir, type) {
-  return path16.join(graphsDir(memoryDir), `${type}.jsonl`);
+  return path17.join(graphsDir(memoryDir), `${type}.jsonl`);
 }
 async function ensureGraphsDir(memoryDir) {
-  await mkdir12(graphsDir(memoryDir), { recursive: true });
+  await mkdir13(graphsDir(memoryDir), { recursive: true });
 }
 async function appendEdge(memoryDir, edge) {
   await ensureGraphsDir(memoryDir);
@@ -10197,7 +10577,7 @@ async function appendEdge(memoryDir, edge) {
 async function readEdges(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
   try {
-    const raw = await readFile13(filePath, "utf8");
+    const raw = await readFile14(filePath, "utf8");
     const edges = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -10386,8 +10766,8 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 }
 
 // src/conversation-index/indexer.ts
-import { mkdir as mkdir13, writeFile as writeFile12 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir14, writeFile as writeFile13 } from "fs/promises";
+import path18 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);
@@ -10397,9 +10777,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 = path17.join(rootDir, safe, date);
-    await mkdir13(dir, { recursive: true });
-    const fp = path17.join(dir, `${c.id}.md`);
+    const dir = path18.join(rootDir, safe, date);
+    await mkdir14(dir, { recursive: true });
+    const fp = path18.join(dir, `${c.id}.md`);
     const content = `---
 kind: conversation_chunk
 sessionKey: ${c.sessionKey}
@@ -10408,7 +10788,7 @@ endTs: ${c.endTs}
 ---
 
 ` + c.text + "\n";
-    await writeFile12(fp, content, "utf-8");
+    await writeFile13(fp, content, "utf-8");
     written.push(fp);
   }
   return written;
@@ -10416,7 +10796,7 @@ endTs: ${c.endTs}
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir8, rm } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
@@ -10424,7 +10804,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
     const sessions = await readdir8(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path18.join(rootDir, s.name);
+      const sessionDir = path19.join(rootDir, s.name);
       const dayDirs = await readdir8(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
@@ -10432,7 +10812,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
         const dayMs = (/* @__PURE__ */ new Date(d.name + "T00:00:00.000Z")).getTime();
         if (!Number.isFinite(dayMs)) continue;
         if (dayMs < cutoffMs) {
-          await rm(path18.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm(path19.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
@@ -10449,7 +10829,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 }
 
 // src/namespaces/storage.ts
-import path19 from "path";
+import path20 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -10471,7 +10851,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path19.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path20.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -10480,7 +10860,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path19.join(this.config.memoryDir, "namespaces", namespace);
+    return path20.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -10556,8 +10936,8 @@ function recallNamespacesForPrincipal(principal, config) {
 }
 
 // src/shared-context/manager.ts
-import { mkdir as mkdir14, readFile as readFile14, readdir as readdir9, appendFile as appendFile5, writeFile as writeFile13, stat as stat2 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir15, readFile as readFile15, readdir as readdir9, appendFile as appendFile5, writeFile as writeFile14, stat as stat4 } from "fs/promises";
+import path21 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -10579,15 +10959,15 @@ function ymd(d) {
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path20.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path21.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path20.join(base, "priorities.md");
-    this.prioritiesInboxPath = path20.join(base, "priorities.inbox.md");
-    this.outputsDir = path20.join(base, "agent-outputs");
-    this.roundtableDir = path20.join(base, "roundtable");
-    this.feedbackDir = path20.join(base, "feedback");
-    this.feedbackInboxPath = path20.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path20.join(base, "cross-signals");
+    this.prioritiesPath = path21.join(base, "priorities.md");
+    this.prioritiesInboxPath = path21.join(base, "priorities.inbox.md");
+    this.outputsDir = path21.join(base, "agent-outputs");
+    this.roundtableDir = path21.join(base, "roundtable");
+    this.feedbackDir = path21.join(base, "feedback");
+    this.feedbackInboxPath = path21.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path21.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -10598,15 +10978,15 @@ var SharedContextManager = class {
   feedbackInboxPath;
   crossSignalsDir;
   async ensureStructure() {
-    await mkdir14(this.dir, { recursive: true });
-    await mkdir14(this.outputsDir, { recursive: true });
-    await mkdir14(this.roundtableDir, { recursive: true });
-    await mkdir14(this.feedbackDir, { recursive: true });
-    await mkdir14(this.crossSignalsDir, { recursive: true });
-    await mkdir14(path20.join(this.dir, "staging"), { recursive: true });
-    await mkdir14(path20.join(this.dir, "kpis"), { recursive: true });
-    await mkdir14(path20.join(this.dir, "calendar"), { recursive: true });
-    await mkdir14(path20.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir15(this.dir, { recursive: true });
+    await mkdir15(this.outputsDir, { recursive: true });
+    await mkdir15(this.roundtableDir, { recursive: true });
+    await mkdir15(this.feedbackDir, { recursive: true });
+    await mkdir15(this.crossSignalsDir, { recursive: true });
+    await mkdir15(path21.join(this.dir, "staging"), { recursive: true });
+    await mkdir15(path21.join(this.dir, "kpis"), { recursive: true });
+    await mkdir15(path21.join(this.dir, "calendar"), { recursive: true });
+    await mkdir15(path21.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -10635,14 +11015,14 @@ var SharedContextManager = class {
   }
   async ensureFile(fp, content) {
     try {
-      await stat2(fp);
+      await stat4(fp);
     } catch {
-      await writeFile13(fp, content, "utf-8");
+      await writeFile14(fp, content, "utf-8");
     }
   }
   async readPriorities() {
     try {
-      return await readFile14(this.prioritiesPath, "utf-8");
+      return await readFile15(this.prioritiesPath, "utf-8");
     } catch {
       return "";
     }
@@ -10650,9 +11030,9 @@ var SharedContextManager = class {
   async readLatestRoundtable() {
     try {
       const files = (await readdir9(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path20.join(this.roundtableDir, files[0]) : null;
+      const fp = files[0] ? path21.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
-      return await readFile14(fp, "utf-8");
+      return await readFile15(fp, "utf-8");
     } catch {
       return "";
     }
@@ -10662,9 +11042,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path20.join(this.outputsDir, opts.agentId, date);
-    await mkdir14(dir, { recursive: true });
-    const fp = path20.join(dir, `${time}-${slug}.md`);
+    const dir = path21.join(this.outputsDir, opts.agentId, date);
+    await mkdir15(dir, { recursive: true });
+    const fp = path21.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -10673,7 +11053,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 ---
 
 ` + opts.content.trimEnd() + "\n";
-    await writeFile13(fp, body, "utf-8");
+    await writeFile14(fp, body, "utf-8");
     return fp;
   }
   async appendFeedback(entry) {
@@ -10699,12 +11079,12 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       const agents = await readdir9(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path20.join(this.outputsDir, a.name, date);
+        const dayDir = path21.join(this.outputsDir, a.name, date);
         try {
           const files = (await readdir9(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path20.join(dayDir, f);
-            const raw = await readFile14(p, "utf-8");
+            const p = path21.join(dayDir, f);
+            const raw = await readFile15(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ path: p, title });
           }
@@ -10715,7 +11095,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
     }
     const feedback = [];
     try {
-      const raw = await readFile14(this.feedbackInboxPath, "utf-8");
+      const raw = await readFile15(this.feedbackInboxPath, "utf-8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         try {
@@ -10743,16 +11123,16 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
     ];
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const fp = path20.join(this.roundtableDir, `${date}.md`);
-    await writeFile13(fp, trimmed, "utf-8");
+    const fp = path21.join(this.roundtableDir, `${date}.md`);
+    await writeFile14(fp, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${fp}`);
     return fp;
   }
 };
 
 // src/compounding/engine.ts
-import { mkdir as mkdir15, readFile as readFile15, readdir as readdir10, writeFile as writeFile14 } from "fs/promises";
-import path21 from "path";
+import { mkdir as mkdir16, readFile as readFile16, readdir as readdir10, writeFile as writeFile15 } from "fs/promises";
+import path22 from "path";
 import os4 from "os";
 function isoWeekId(d) {
   const dt = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
@@ -10783,7 +11163,7 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path21.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path22.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
@@ -10802,14 +11182,14 @@ function cadenceStaleWindowMs(cadence) {
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path21.join(config.memoryDir, "compounding", "weekly");
-    this.mistakesPath = path21.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path21.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path21.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path21.join(config.memoryDir, "identity", "incidents");
-    this.identityAuditWeeklyDir = path21.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path21.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path21.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.weeklyDir = path22.join(config.memoryDir, "compounding", "weekly");
+    this.mistakesPath = path22.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path22.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.identityAnchorPath = path22.join(config.memoryDir, "identity", "identity-anchor.md");
+    this.identityIncidentsDir = path22.join(config.memoryDir, "identity", "incidents");
+    this.identityAuditWeeklyDir = path22.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path22.join(config.memoryDir, "identity", "audits", "monthly");
+    this.identityImprovementLoopsPath = path22.join(config.memoryDir, "identity", "improvement-loops.md");
   }
   weeklyDir;
   mistakesPath;
@@ -10820,8 +11200,8 @@ var CompoundingEngine = class {
   identityAuditMonthlyDir;
   identityImprovementLoopsPath;
   async ensureDirs() {
-    await mkdir15(this.weeklyDir, { recursive: true });
-    await mkdir15(path21.dirname(this.mistakesPath), { recursive: true });
+    await mkdir16(this.weeklyDir, { recursive: true });
+    await mkdir16(path22.dirname(this.mistakesPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
@@ -10829,10 +11209,10 @@ var CompoundingEngine = class {
     const entries = await this.readFeedbackEntriesForWeek(weekId);
     const mistakes = this.buildMistakes(entries);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path21.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path22.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, continuity);
-    await writeFile14(reportPath, md, "utf-8");
-    await writeFile14(this.mistakesPath, JSON.stringify(mistakes, null, 2) + "\n", "utf-8");
+    await writeFile15(reportPath, md, "utf-8");
+    await writeFile15(this.mistakesPath, JSON.stringify(mistakes, null, 2) + "\n", "utf-8");
     log.info(`compounding: wrote weekly=${reportPath} mistakes=${this.mistakesPath}`);
     return { weekId, reportPath, mistakesCount: mistakes.patterns.length };
   }
@@ -10908,14 +11288,14 @@ var CompoundingEngine = class {
       ""
     ];
     const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
-    await mkdir15(dir, { recursive: true });
-    const reportPath = path21.join(dir, `${key}.md`);
-    await writeFile14(reportPath, lines.join("\n"), "utf-8");
+    await mkdir16(dir, { recursive: true });
+    const reportPath = path22.join(dir, `${key}.md`);
+    await writeFile15(reportPath, lines.join("\n"), "utf-8");
     return { period, key, reportPath };
   }
   async readMistakes() {
     try {
-      const raw = await readFile15(this.mistakesPath, "utf-8");
+      const raw = await readFile16(this.mistakesPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || !Array.isArray(parsed.patterns)) return null;
       return parsed;
@@ -10926,7 +11306,7 @@ var CompoundingEngine = class {
   async readFeedbackEntriesForWeek(weekId) {
     const out = [];
     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 {
@@ -11014,7 +11394,7 @@ var CompoundingEngine = class {
   }
   async readNonEmptyFile(filePath) {
     try {
-      const raw = await readFile15(filePath, "utf-8");
+      const raw = await readFile16(filePath, "utf-8");
       return raw.trim().length > 0;
     } catch {
       return false;
@@ -11022,7 +11402,7 @@ var CompoundingEngine = class {
   }
   async readOptionalFile(filePath) {
     try {
-      const raw = await readFile15(filePath, "utf-8");
+      const raw = await readFile16(filePath, "utf-8");
       return raw.trim().length > 0 ? raw : null;
     } catch {
       return null;
@@ -11038,9 +11418,9 @@ var CompoundingEngine = class {
       const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
       for (const file of files) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path21.join(this.identityIncidentsDir, file);
+        const filePath = path22.join(this.identityIncidentsDir, file);
         try {
-          const raw = await readFile15(filePath, "utf-8");
+          const raw = await readFile16(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
           if (!parsed) continue;
           if (state && parsed.state !== state) continue;
@@ -11054,8 +11434,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path21.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path21.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path22.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path22.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const weeklyExists = await this.readNonEmptyFile(weeklyPath);
     const monthlyExists = await this.readNonEmptyFile(monthlyPath);
     return {
@@ -11246,11 +11626,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path22.isAbsolute(candidatePath) ? candidatePath : path22.resolve(storageDir, candidatePath);
-  const rel = path22.relative(storageDir, absolutePath);
+  const absolutePath = path23.isAbsolute(candidatePath) ? candidatePath : path23.resolve(storageDir, candidatePath);
+  const rel = path23.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path22.sep).join("/");
+  return rel.split(path23.sep).join("/");
 }
 function graphActivationScoreToRecallScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -11292,7 +11672,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path22.relative(storageDir, mem.path));
+    pathById.set(id, path23.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -11300,7 +11680,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path22.join(options.storageDir, options.memoryRelPath),
+    path: path23.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -11320,15 +11700,15 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path22.join("corrections", `${options.memoryId}.md`);
+    return path23.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 path22.join("facts", day, `${options.memoryId}.md`);
+    return path23.join("facts", day, `${options.memoryId}.md`);
   }
-  return path22.join("facts", `${options.memoryId}.md`);
+  return path23.join("facts", `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -11339,6 +11719,7 @@ var Orchestrator = class _Orchestrator {
   compounding;
   buffer;
   transcript;
+  sessionObserver;
   summarizer;
   localLlm;
   modelRegistry;
@@ -11367,6 +11748,7 @@ var Orchestrator = class _Orchestrator {
   // Queue stores promises that resolve when extraction should run
   extractionQueue = [];
   queueProcessing = false;
+  heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   nonZeroExtractionsSinceConsolidation = 0;
   lastConsolidationRunAtMs = 0;
@@ -11417,17 +11799,22 @@ 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 = path22.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path23.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
     this.lastRecall = new LastRecallStore(config.memoryDir);
+    this.sessionObserver = new SessionObserverState({
+      memoryDir: config.memoryDir,
+      debounceMs: config.sessionObserverDebounceMs ?? 12e4,
+      bands: config.sessionObserverBands ?? []
+    });
     this.embeddingFallback = new EmbeddingFallback(config);
     this.summarizer = new HourlySummarizer(config, config.gatewayConfig, this.modelRegistry, this.transcript);
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path22.join(config.memoryDir, "threads"),
+      path23.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -11533,8 +11920,9 @@ var Orchestrator = class _Orchestrator {
     await this.relevance.load();
     await this.negatives.load();
     await this.lastRecall.load();
+    await this.sessionObserver.load();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path22.join(this.config.memoryDir, "state");
+      const stateDir2 = path23.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -11572,7 +11960,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path22.join(this.config.memoryDir, "conversation-index")
+          path23.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -11608,12 +11996,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path22.isAbsolute(rel) ? rel : path22.join(this.config.workspaceDir, rel);
+        const abs = path23.isAbsolute(rel) ? rel : path23.join(this.config.workspaceDir, rel);
         try {
-          const raw = await readFile16(abs, "utf-8");
+          const raw = await readFile17(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path22.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path22.basename(abs);
+            const archiveDir = path23.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path23.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -11621,7 +12009,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile15(abs, newContent, "utf-8");
+            await writeFile16(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -11638,8 +12026,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path22.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir16(path22.dirname(fp), { recursive: true });
+        const fp = path23.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir17(path23.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -11648,11 +12036,11 @@ var Orchestrator = class _Orchestrator {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile16(fp, "utf-8");
+          existing = await readFile17(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile15(fp, existing + block, "utf-8");
+        await writeFile16(fp, existing + block, "utf-8");
       }
     }
   }
@@ -11695,9 +12083,9 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path22.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path23.join(storage.dir, "state", "last_graph_recall.json");
     try {
-      const raw = await readFile16(snapshotPath, "utf-8");
+      const raw = await readFile17(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -11997,7 +12385,7 @@ var Orchestrator = class _Orchestrator {
       const storage = await this.storageRouter.storageFor(namespace);
       const seedRelativePaths = nsResults.slice(0, perNamespaceSeedCap).map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
-      seedPaths.push(...seedRelativePaths.map((rel) => path22.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path23.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -12006,7 +12394,7 @@ var Orchestrator = class _Orchestrator {
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path22.resolve(storage.dir, candidate.path);
+        const memoryPath = path23.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -12034,8 +12422,8 @@ var Orchestrator = class _Orchestrator {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path22.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir16(path22.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path23.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir17(path23.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const payload = {
         recordedAt: now,
@@ -12048,7 +12436,7 @@ var Orchestrator = class _Orchestrator {
         seeds: options.seedPaths,
         expanded: options.expandedPaths
       };
-      await writeFile15(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile16(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
@@ -12730,9 +13118,48 @@ _Context: ${topQuestion.context}_`);
     };
     const decision = await this.buffer.addTurn(turn);
     if (decision === "keep_buffering") return;
-    const turnsToExtract = this.buffer.getTurns();
-    if (!this.shouldQueueExtraction(turnsToExtract)) {
-      await this.buffer.clearAfterExtraction();
+    await this.queueBufferedExtraction(this.buffer.getTurns(), "trigger_mode");
+  }
+  async observeSessionHeartbeat(sessionKey) {
+    if (this.config.sessionObserverEnabled !== true) return;
+    if (!sessionKey || sessionKey.length === 0) return;
+    const previous = this.heartbeatObserverChains.get(sessionKey) ?? Promise.resolve();
+    const next = previous.catch(() => void 0).then(async () => {
+      const turns = this.buffer.getTurns();
+      if (turns.length === 0) return;
+      const mixedSessionTurns = turns.some((turn) => turn.sessionKey !== sessionKey);
+      if (mixedSessionTurns) {
+        log.debug(`heartbeat observer skipped: mixed session buffer for ${sessionKey}`);
+        return;
+      }
+      if (!this.shouldQueueExtraction(turns, { commit: false })) {
+        log.debug(`heartbeat observer skipped: extraction dedupe for ${sessionKey}`);
+        return;
+      }
+      const footprint = await this.transcript.estimateSessionFootprint(sessionKey);
+      const decision = await this.sessionObserver.observe({
+        sessionKey,
+        totalBytes: footprint.bytes,
+        totalTokens: footprint.tokens
+      });
+      if (!decision.triggered) return;
+      log.debug(
+        `heartbeat observer trigger: session=${sessionKey} deltaBytes=${decision.deltaBytes} deltaTokens=${decision.deltaTokens}`
+      );
+      await this.queueBufferedExtraction(turns, "heartbeat_observer");
+    });
+    this.heartbeatObserverChains.set(sessionKey, next);
+    try {
+      await next;
+    } finally {
+      if (this.heartbeatObserverChains.get(sessionKey) === next) {
+        this.heartbeatObserverChains.delete(sessionKey);
+      }
+    }
+  }
+  async queueBufferedExtraction(turnsToExtract, reason, options = {}) {
+    if (!options.skipDedupeCheck && !this.shouldQueueExtraction(turnsToExtract)) {
+      log.debug(`extraction dedupe skip: preserving buffer (${reason})`);
       return;
     }
     this.extractionQueue.push(async () => {
@@ -12745,8 +13172,9 @@ _Context: ${topQuestion.context}_`);
         this.queueProcessing = false;
       });
     }
+    log.debug(`queued extraction from ${reason}`);
   }
-  shouldQueueExtraction(turns) {
+  shouldQueueExtraction(turns, options = {}) {
     if (!this.config.extractionDedupeEnabled) return true;
     if (!Array.isArray(turns) || turns.length === 0) return false;
     const normalized = turns.filter((t) => t.role === "user" || t.role === "assistant").map((t) => `${t.role}:${(t.content ?? "").trim().slice(0, this.config.extractionMaxTurnChars)}`).join("\n");
@@ -12758,8 +13186,10 @@ _Context: ${topQuestion.context}_`);
       log.debug("extraction dedupe: skipped duplicate buffered turn set");
       return false;
     }
-    this.recentExtractionFingerprints.set(fingerprint, now);
-    if (this.recentExtractionFingerprints.size > 200) {
+    if (options.commit !== false) {
+      this.recentExtractionFingerprints.set(fingerprint, now);
+    }
+    if (options.commit !== false && this.recentExtractionFingerprints.size > 200) {
       const entries = Array.from(this.recentExtractionFingerprints.entries()).sort(
         (a, b) => a[1] - b[1]
       );
@@ -13271,7 +13701,7 @@ _Context: ${topQuestion.context}_`);
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path22.relative(storage.dir, m.path);
+            const rel = path23.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13648,9 +14078,9 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path22.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir16(path22.dirname(metricsPath), { recursive: true });
-    await writeFile15(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    const metricsPath = path23.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir17(path23.dirname(metricsPath), { recursive: true });
+    await writeFile16(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -13916,7 +14346,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path22.isAbsolute(hit.path) ? hit.path : path22.join(this.config.memoryDir, hit.path);
+      const fullPath = path23.isAbsolute(hit.path) ? hit.path : path23.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -14370,7 +14800,7 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path23 from "path";
+import path24 from "path";
 import { createHash as createHash5 } from "crypto";
 import { Type } from "@sinclair/typebox";
 function toolResult(text) {
@@ -15516,7 +15946,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path23.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path24.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.");
@@ -15765,12 +16195,12 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path33 from "path";
-import { access as access2, readFile as readFile22, readdir as readdir13, unlink as unlink3 } from "fs/promises";
+import path34 from "path";
+import { access as access2, readFile as readFile23, readdir as readdir13, unlink as unlink4 } from "fs/promises";
 
 // src/transfer/export-json.ts
-import path25 from "path";
-import { mkdir as mkdir18, readFile as readFile18 } from "fs/promises";
+import path26 from "path";
+import { mkdir as mkdir19, readFile as readFile19 } from "fs/promises";
 
 // src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
@@ -15778,10 +16208,10 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir17, readdir as readdir11, readFile as readFile17, stat as stat3, writeFile as writeFile16 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir18, readdir as readdir11, readFile as readFile18, stat as stat5, writeFile as writeFile17 } from "fs/promises";
+import path25 from "path";
 async function sha256File(filePath) {
-  const buf = await readFile17(filePath);
+  const buf = await readFile18(filePath);
   const sha256 = createHash6("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
@@ -15791,11 +16221,11 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir17(path24.dirname(filePath), { recursive: true });
-  await writeFile16(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  await mkdir18(path25.dirname(filePath), { recursive: true });
+  await writeFile17(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile(filePath) {
-  const raw = await readFile17(filePath, "utf-8");
+  const raw = await readFile18(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function listFilesRecursive(rootDir) {
@@ -15803,7 +16233,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir11(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path24.join(dir, ent.name);
+      const fp = path25.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -15816,18 +16246,18 @@ async function listFilesRecursive(rootDir) {
 }
 async function fileExists(filePath) {
   try {
-    await stat3(filePath);
+    await stat5(filePath);
     return true;
   } catch {
     return false;
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path24.relative(rootDir, absPath);
-  return rel.split(path24.sep).join("/");
+  const rel = path25.relative(rootDir, absPath);
+  return rel.split(path25.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path24.sep);
+  return relPath.split("/").join(path25.sep);
 }
 
 // src/transfer/export-json.ts
@@ -15843,24 +16273,24 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path25.resolve(opts.outDir);
-  await mkdir18(outDirAbs, { recursive: true });
-  const memoryDirAbs = path25.resolve(opts.memoryDir);
+  const outDirAbs = path26.resolve(opts.outDir);
+  await mkdir19(outDirAbs, { recursive: true });
+  const memoryDirAbs = path26.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 readFile18(abs, "utf-8");
+    const content = await readFile19(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 = path25.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path26.join(opts.workspaceDir, "IDENTITY.md");
     try {
-      const content = await readFile18(identityPath, "utf-8");
+      const content = await readFile19(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
       records.push({ path: relPath, content });
       const { sha256, bytes } = sha256String(content);
@@ -15877,13 +16307,13 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path25.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path25.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path26.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path26.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path26 from "path";
-import { mkdir as mkdir19, readFile as readFile19, writeFile as writeFile17 } from "fs/promises";
+import path27 from "path";
+import { mkdir as mkdir20, readFile as readFile20, writeFile as writeFile18 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
   if (!includeTranscripts && parts[0] === "transcripts") return true;
@@ -15891,18 +16321,18 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path26.resolve(opts.outDir);
-  await mkdir19(outDirAbs, { recursive: true });
-  const memDirAbs = path26.resolve(opts.memoryDir);
+  const outDirAbs = path27.resolve(opts.outDir);
+  await mkdir20(outDirAbs, { recursive: true });
+  const memDirAbs = path27.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 = path26.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir19(path26.dirname(dstAbs), { recursive: true });
-    const content = await readFile19(abs);
-    await writeFile17(dstAbs, content);
+    const dstAbs = path27.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir20(path27.dirname(dstAbs), { recursive: true });
+    const content = await readFile20(abs);
+    await writeFile18(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
@@ -15914,12 +16344,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path26.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path27.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path26.resolve(fromDir);
+  const dirAbs = path27.resolve(fromDir);
   try {
-    const raw = await readFile19(path26.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile20(path27.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -15928,16 +16358,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path27 from "path";
-import { mkdir as mkdir20, readdir as readdir12, rm as rm2 } from "fs/promises";
+import path28 from "path";
+import { mkdir as mkdir21, readdir as readdir12, rm as rm2 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path27.resolve(opts.outDir);
-  await mkdir20(outDirAbs, { recursive: true });
+  const outDirAbs = path28.resolve(opts.outDir);
+  await mkdir21(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path27.join(outDirAbs, ts);
+  const backupDir = path28.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -15962,15 +16392,15 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm2(path27.join(outDirAbs, name), { recursive: true, force: true });
+      await rm2(path28.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path28 from "path";
+import path29 from "path";
 import Database from "better-sqlite3";
-import { readFile as readFile20 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 
 // src/transfer/sqlite-schema.ts
 var SQLITE_SCHEMA_VERSION = 1;
@@ -15996,8 +16426,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path28.resolve(opts.memoryDir);
-  const outAbs = path28.resolve(opts.outFile);
+  const memDirAbs = path29.resolve(opts.memoryDir);
+  const outAbs = path29.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -16018,7 +16448,7 @@ async function exportSqlite(opts) {
     for (const abs of filesAbs) {
       const relPosix = toPosixRelPath(abs, memDirAbs);
       if (shouldExclude3(relPosix, includeTranscripts)) continue;
-      const content = await readFile20(abs, "utf-8");
+      const content = await readFile21(abs, "utf-8");
       const { sha256, bytes } = await sha256File(abs);
       rows.push({ rel: relPosix, bytes, sha256, content });
     }
@@ -16029,8 +16459,8 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path29 from "path";
-import { mkdir as mkdir21, writeFile as writeFile18 } from "fs/promises";
+import path30 from "path";
+import { mkdir as mkdir22, writeFile as writeFile19 } from "fs/promises";
 
 // src/transfer/types.ts
 import { z as z4 } from "zod";
@@ -16063,21 +16493,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path29.resolve(opts.fromDir);
-  const bundlePath = path29.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path30.resolve(opts.fromDir);
+  const bundlePath = path30.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile(bundlePath));
-  const memDirAbs = path29.resolve(opts.targetMemoryDir);
+  const memDirAbs = path30.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 ? path29.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path30.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path29.join(targetBase, relFs);
+    const absTarget = path30.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -16101,30 +16531,30 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir21(path29.dirname(w.abs), { recursive: true });
-    await writeFile18(w.abs, w.content, "utf-8");
+    await mkdir22(path30.dirname(w.abs), { recursive: true });
+    await writeFile19(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path29.resolve(fromDir);
+  const dir = path30.resolve(fromDir);
   return Promise.all([
-    fileExists(path29.join(dir, "manifest.json")),
-    fileExists(path29.join(dir, "bundle.json"))
+    fileExists(path30.join(dir, "manifest.json")),
+    fileExists(path30.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path30 from "path";
+import path31 from "path";
 import Database2 from "better-sqlite3";
-import { mkdir as mkdir22, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir23, writeFile as writeFile20 } from "fs/promises";
 function normalizeForDedupe2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path30.resolve(opts.targetMemoryDir);
-  const fromAbs = path30.resolve(opts.fromFile);
+  const memDirAbs = path31.resolve(opts.targetMemoryDir);
+  const fromAbs = path31.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -16137,7 +16567,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 = path30.join(memDirAbs, relFs);
+      const absTarget = path31.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -16162,30 +16592,30 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir22(path30.dirname(w.abs), { recursive: true });
-    await writeFile19(w.abs, w.content, "utf-8");
+    await mkdir23(path31.dirname(w.abs), { recursive: true });
+    await writeFile20(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path31 from "path";
-import { mkdir as mkdir23, readFile as readFile21, writeFile as writeFile20 } from "fs/promises";
+import path32 from "path";
+import { mkdir as mkdir24, readFile as readFile22, writeFile as writeFile21 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path31.resolve(opts.fromDir);
-  const targetAbs = path31.resolve(opts.targetMemoryDir);
+  const fromAbs = path32.resolve(opts.fromDir);
+  const targetAbs = path32.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 = path31.join(targetAbs, fromPosixRelPath(relPosix));
-    const content = await readFile21(abs, "utf-8");
+    const dstAbs = path32.join(targetAbs, fromPosixRelPath(relPosix));
+    const content = await readFile22(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
       if (conflict === "skip") {
@@ -16207,20 +16637,20 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir23(path31.dirname(w.abs), { recursive: true });
-    await writeFile20(w.abs, w.content, "utf-8");
+    await mkdir24(path32.dirname(w.abs), { recursive: true });
+    await writeFile21(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path32 from "path";
-import { stat as stat4 } from "fs/promises";
+import path33 from "path";
+import { stat as stat6 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path32.resolve(fromPath);
+  const abs = path33.resolve(fromPath);
   let st;
   try {
-    st = await stat4(abs);
+    st = await stat6(abs);
   } catch {
     return null;
   }
@@ -16288,7 +16718,7 @@ function planAggressiveDuplicateDeletions(memories) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile22(pkgPath, "utf-8");
+    const raw = await readFile23(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -16307,14 +16737,14 @@ 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 = path33.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path34.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 = [path33.join(memoryDir, "facts"), path33.join(memoryDir, "corrections")];
+  const roots = [path34.join(memoryDir, "facts"), path34.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -16325,14 +16755,14 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path33.join(dir, entryName);
+      const fullPath = path34.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile22(fullPath, "utf-8");
+        const raw = await readFile23(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -16543,7 +16973,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink3(filePath);
+            await unlink4(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -16591,7 +17021,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink3(filePath);
+            await unlink4(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -16755,7 +17185,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path33.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path34.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -16978,8 +17408,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path33.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path33.join(memoryDir, "threads"));
+        const memoryDir = path34.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path34.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -17152,16 +17582,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile23, writeFile as writeFile21 } from "fs/promises";
+import { readFile as readFile24, writeFile as writeFile22 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path34 from "path";
+import path35 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 : path34.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path35.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -17322,6 +17752,16 @@ Use this context naturally when relevant. Never quote or expose this memory cont
         }
       }
     );
+    api.on(
+      "agent_heartbeat",
+      (_event, ctx) => {
+        if (orchestrator.config.sessionObserverEnabled !== true) return;
+        const sessionKey = ctx?.sessionKey ?? "default";
+        void orchestrator.observeSessionHeartbeat(sessionKey).catch((err) => {
+          log.debug(`agent_heartbeat observer failed: ${err}`);
+        });
+      }
+    );
     api.on(
       "before_compaction",
       async (event, ctx) => {
@@ -17359,11 +17799,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 = path34.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path35.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile23(cronFilePath, "utf-8");
+          const content = await readFile24(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -17400,7 +17840,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile21(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile22(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);