@joshuaswarren/openclaw-engram 8.3.20 → 8.3.22

package/dist/index.js

@@ -8238,7 +8238,10 @@ var LastRecallStore = class {
       recordedAt: now,
       queryHash,
       queryLen: opts.query.length,
-      memoryIds: opts.memoryIds
+      memoryIds: opts.memoryIds,
+      identityInjectionMode: opts.identityInjection?.mode,
+      identityInjectedChars: opts.identityInjection?.injectedChars,
+      identityInjectionTruncated: opts.identityInjection?.truncated
     };
     this.state[opts.sessionKey] = snapshot;
     const keys = Object.keys(this.state);
@@ -10562,7 +10565,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 };
 
 // src/compounding/engine.ts
-import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir15, readFile as readFile15, readdir as readdir10, writeFile as writeFile14 } from "fs/promises";
 import path21 from "path";
 import os4 from "os";
 function isoWeekId(d) {
@@ -10574,6 +10577,22 @@ function isoWeekId(d) {
   const yyyy = dt.getUTCFullYear();
   return `${yyyy}-W${String(week).padStart(2, "0")}`;
 }
+function isoMonthId(d) {
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+function monthIdFromIsoWeek(weekId) {
+  const match = weekId.match(/^(\d{4})-W(\d{2})$/);
+  if (!match) return isoMonthId(/* @__PURE__ */ new Date());
+  const year = Number(match[1]);
+  const week = Number(match[2]);
+  const jan4 = new Date(Date.UTC(year, 0, 4));
+  const jan4Day = jan4.getUTCDay() || 7;
+  const isoWeekOneMonday = new Date(jan4);
+  isoWeekOneMonday.setUTCDate(jan4.getUTCDate() - (jan4Day - 1));
+  const monday = new Date(isoWeekOneMonday);
+  monday.setUTCDate(isoWeekOneMonday.getUTCDate() + (week - 1) * 7);
+  return isoMonthId(monday);
+}
 function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
@@ -10586,10 +10605,20 @@ var CompoundingEngine = class {
     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");
   }
   weeklyDir;
   mistakesPath;
   feedbackInboxPath;
+  identityAnchorPath;
+  identityIncidentsDir;
+  identityAuditWeeklyDir;
+  identityAuditMonthlyDir;
+  identityImprovementLoopsPath;
   async ensureDirs() {
     await mkdir15(this.weeklyDir, { recursive: true });
     await mkdir15(path21.dirname(this.mistakesPath), { recursive: true });
@@ -10599,13 +10628,77 @@ var CompoundingEngine = class {
     const weekId = opts?.weekId ?? isoWeekId(/* @__PURE__ */ new Date());
     const entries = await this.readFeedbackEntriesForWeek(weekId);
     const mistakes = this.buildMistakes(entries);
+    const continuity = await this.readContinuityAuditReferences(weekId);
     const reportPath = path21.join(this.weeklyDir, `${weekId}.md`);
-    const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns);
+    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");
     log.info(`compounding: wrote weekly=${reportPath} mistakes=${this.mistakesPath}`);
     return { weekId, reportPath, mistakesCount: mistakes.patterns.length };
   }
+  async synthesizeContinuityAudit(opts) {
+    const period = opts?.period === "monthly" ? "monthly" : "weekly";
+    const key = opts?.key?.trim() || (period === "weekly" ? isoWeekId(/* @__PURE__ */ new Date()) : isoMonthId(/* @__PURE__ */ new Date()));
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const [anchorPresent, improvementLoopPresent, incidents, mistakes] = await Promise.all([
+      this.readNonEmptyFile(this.identityAnchorPath),
+      this.readNonEmptyFile(this.identityImprovementLoopsPath),
+      this.readContinuityIncidents(),
+      this.readMistakes()
+    ]);
+    const openIncidents = incidents.filter((i) => i.state === "open");
+    const closedIncidents = incidents.filter((i) => i.state === "closed");
+    const hardeningCandidates = [];
+    if (!anchorPresent) {
+      hardeningCandidates.push("Create/update identity anchor baseline and verify recovery injection path.");
+    }
+    if (openIncidents.length > 0) {
+      hardeningCandidates.push(
+        `Close or downgrade ${openIncidents.length} open continuity incident${openIncidents.length === 1 ? "" : "s"}.`
+      );
+    }
+    if (!improvementLoopPresent) {
+      hardeningCandidates.push("Initialize continuity improvement-loops register with cadence and kill conditions.");
+    }
+    if ((mistakes?.patterns.length ?? 0) > 0) {
+      hardeningCandidates.push("Review latest compounding mistakes and convert one pattern into preventive continuity rule.");
+    }
+    const nextAction = hardeningCandidates[0] ?? "No critical drift detected; keep weekly/monthly continuity audit cadence.";
+    const lines = [
+      `# Continuity Audit \u2014 ${period} ${key}`,
+      "",
+      `Generated: ${nowIso}`,
+      `Scope: ${period}`,
+      "",
+      "## Signal Summary",
+      `- Identity anchor present: ${anchorPresent ? "yes" : "no"}`,
+      `- Improvement-loop register present: ${improvementLoopPresent ? "yes" : "no"}`,
+      `- Open incidents: ${openIncidents.length}`,
+      `- Closed incidents: ${closedIncidents.length}`,
+      `- Compounding mistake patterns: ${mistakes?.patterns.length ?? 0}`,
+      "",
+      "## Drift Checks",
+      `- Identity anchor drift: ${anchorPresent ? "pass" : "needs attention"}`,
+      `- Incident backlog: ${openIncidents.length === 0 ? "pass" : "needs attention"}`,
+      `- Improvement-loop coverage: ${improvementLoopPresent ? "pass" : "needs attention"}`,
+      "",
+      "## Stale Rule Detection",
+      `- Open incidents older than closure window: ${openIncidents.length > 0 ? "possible" : "none detected"}`,
+      `- Preventive rule coverage on closed incidents: ${closedIncidents.some((i) => (i.preventiveRule ?? "").trim().length > 0) ? "present" : "not detected"}`,
+      "",
+      "## Next Hardening Action",
+      `- ${nextAction}`,
+      "",
+      "## Open Incident IDs",
+      ...openIncidents.length > 0 ? openIncidents.slice(0, 20).map((i) => `- ${i.id}`) : ["- (none)"],
+      ""
+    ];
+    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");
+    return { period, key, reportPath };
+  }
   async readMistakes() {
     try {
       const raw = await readFile15(this.mistakesPath, "utf-8");
@@ -10650,7 +10743,7 @@ var CompoundingEngine = class {
     const uniq = Array.from(new Set(patterns)).slice(0, 500);
     return { updatedAt: (/* @__PURE__ */ new Date()).toISOString(), patterns: uniq };
   }
-  formatWeeklyReport(weekId, entries, patterns) {
+  formatWeeklyReport(weekId, entries, patterns, continuity) {
     const byAgent = /* @__PURE__ */ new Map();
     for (const e of entries) {
       const list = byAgent.get(e.agent) ?? [];
@@ -10689,8 +10782,61 @@ var CompoundingEngine = class {
       for (const p of patterns.slice(0, 100)) lines.push(`- ${p}`);
     }
     lines.push("");
+    if (this.config.continuityAuditEnabled) {
+      lines.push("## Continuity Audits");
+      if (continuity.weeklyPath) {
+        lines.push(`- weekly: ${continuity.weeklyPath}`);
+      } else {
+        lines.push(`- weekly: (missing for ${weekId})`);
+      }
+      if (continuity.monthlyPath) {
+        lines.push(`- monthly: ${continuity.monthlyPath}`);
+      } else {
+        lines.push(`- monthly: (missing for ${continuity.monthId})`);
+      }
+      lines.push("");
+    }
     return lines.join("\n");
   }
+  async readNonEmptyFile(filePath) {
+    try {
+      const raw = await readFile15(filePath, "utf-8");
+      return raw.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async readContinuityIncidents() {
+    const incidents = [];
+    try {
+      const names = await readdir10(this.identityIncidentsDir);
+      const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
+      for (const file of files) {
+        const filePath = path21.join(this.identityIncidentsDir, file);
+        try {
+          const raw = await readFile15(filePath, "utf-8");
+          const parsed = parseContinuityIncident(raw);
+          if (parsed) incidents.push(parsed);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return incidents;
+  }
+  async readContinuityAuditReferences(weekId) {
+    const monthId = monthIdFromIsoWeek(weekId);
+    const weeklyPath = path21.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path21.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyExists = await this.readNonEmptyFile(weeklyPath);
+    const monthlyExists = await this.readNonEmptyFile(monthlyPath);
+    return {
+      weekId,
+      monthId,
+      weeklyPath: weeklyExists ? weeklyPath : null,
+      monthlyPath: monthlyExists ? monthlyPath : null
+    };
+  }
 };
 
 // src/orchestrator.ts
@@ -10828,6 +10974,22 @@ function resolveEffectiveRecallMode(options) {
   }
   return plannedMode;
 }
+function hasIdentityRecoveryIntent(prompt) {
+  const text = typeof prompt === "string" ? prompt.toLowerCase() : "";
+  if (!text) return false;
+  return /\b(identity|continuity|recover(?:y|ing|ed)?|incident|drift|restore|regress(?:ion|ed|ing)?)\b/i.test(
+    text
+  );
+}
+function resolveEffectiveIdentityInjectionMode(options) {
+  if (options.configuredMode === "recovery_only" && !hasIdentityRecoveryIntent(options.prompt)) {
+    return { mode: "recovery_only", shouldInject: false };
+  }
+  if (options.recallMode === "minimal" && options.configuredMode === "full") {
+    return { mode: "minimal", shouldInject: true };
+  }
+  return { mode: options.configuredMode, shouldInject: true };
+}
 function computeArtifactCandidateFetchLimit(targetCount) {
   const cappedTarget = Math.max(0, targetCount);
   if (cappedTarget === 0) return 0;
@@ -11679,6 +11841,9 @@ var Orchestrator = class _Orchestrator {
     let impressionRecorded = false;
     let recallSource = "none";
     let recalledMemoryCount = 0;
+    let identityInjectionModeUsed = "none";
+    let identityInjectedChars = 0;
+    let identityInjectionTruncated = false;
     timings.queryPolicy = `${queryPolicy.promptShape}/${queryPolicy.retrievalBudgetMode}${queryPolicy.skipConversationRecall ? "/skip-conv" : ""}`;
     const recallMode = resolveEffectiveRecallMode({
       plannerEnabled: this.config.recallPlannerEnabled,
@@ -11723,6 +11888,9 @@ var Orchestrator = class _Orchestrator {
         recalledMemoryCount,
         injected: false,
         contextChars: 0,
+        identityInjectionMode: identityInjectionModeUsed,
+        identityInjectedChars,
+        identityInjectionTruncated,
         durationMs: Date.now() - recallStart,
         timings: { ...timings }
       });
@@ -11756,6 +11924,16 @@ var Orchestrator = class _Orchestrator {
       timings.profile = `${Date.now() - t0}ms`;
       return profile2 || null;
     })();
+    const identityContinuityPromise = (async () => {
+      const t0 = Date.now();
+      const section = await this.buildIdentityContinuitySection({
+        storage: profileStorage,
+        recallMode,
+        prompt: retrievalQuery
+      });
+      timings.identityContinuity = `${Date.now() - t0}ms`;
+      return section;
+    })();
     const knowledgeIndexPromise = (async () => {
       if (!this.config.knowledgeIndexEnabled) return null;
       const t0 = Date.now();
@@ -11813,9 +11991,10 @@ var Orchestrator = class _Orchestrator {
       timings.qmd = `${Date.now() - t0}ms`;
       return { memoryResultsLists: [filteredResults], globalResults: [] };
     })();
-    const [sharedCtx, profile, kiResult, artifacts, qmdResult] = await Promise.all([
+    const [sharedCtx, profile, identityContinuity, kiResult, artifacts, qmdResult] = await Promise.all([
       sharedContextPromise,
       profilePromise,
+      identityContinuityPromise,
       knowledgeIndexPromise,
       artifactsPromise,
       qmdPromise
@@ -11824,6 +12003,12 @@ var Orchestrator = class _Orchestrator {
     if (profile) sections.push(`## User Profile
 
 ${profile}`);
+    if (identityContinuity) {
+      sections.push(identityContinuity.section);
+      identityInjectionModeUsed = identityContinuity.mode;
+      identityInjectedChars = identityContinuity.injectedChars;
+      identityInjectionTruncated = identityContinuity.truncated;
+    }
     if (kiResult?.result) {
       sections.push(kiResult.result);
       log.debug(`Knowledge Index: ${kiResult.result.split("\n").length - 4} entities, ${kiResult.result.length} chars${kiResult.cached ? " (cached)" : ""}`);
@@ -11935,7 +12120,12 @@ ${tmtNode.summary}`);
           results: memoryResults,
           sections,
           retrievalQuery,
-          sessionKey
+          sessionKey,
+          identityInjection: {
+            mode: identityInjectionModeUsed,
+            injectedChars: identityInjectedChars,
+            truncated: identityInjectionTruncated
+          }
         });
         impressionRecorded = true;
       } else {
@@ -11958,7 +12148,12 @@ ${tmtNode.summary}`);
             results: scoped,
             sections,
             retrievalQuery,
-            sessionKey
+            sessionKey,
+            identityInjection: {
+              mode: identityInjectionModeUsed,
+              injectedChars: identityInjectedChars,
+              truncated: identityInjectionTruncated
+            }
           });
           impressionRecorded = true;
         } else {
@@ -11975,7 +12170,12 @@ ${tmtNode.summary}`);
               results: longTerm,
               sections,
               retrievalQuery,
-              sessionKey
+              sessionKey,
+              identityInjection: {
+                mode: identityInjectionModeUsed,
+                injectedChars: identityInjectedChars,
+                truncated: identityInjectionTruncated
+              }
             });
             impressionRecorded = true;
           }
@@ -12021,7 +12221,12 @@ ${tmtNode.summary}`);
           results: scoped,
           sections,
           retrievalQuery,
-          sessionKey
+          sessionKey,
+          identityInjection: {
+            mode: identityInjectionModeUsed,
+            injectedChars: identityInjectedChars,
+            truncated: identityInjectionTruncated
+          }
         });
         impressionRecorded = true;
       } else {
@@ -12056,7 +12261,12 @@ ${tmtNode.summary}`);
               results: recent,
               sections,
               retrievalQuery,
-              sessionKey
+              sessionKey,
+              identityInjection: {
+                mode: identityInjectionModeUsed,
+                injectedChars: identityInjectedChars,
+                truncated: identityInjectionTruncated
+              }
             });
             impressionRecorded = true;
           } else {
@@ -12073,7 +12283,12 @@ ${tmtNode.summary}`);
                 results: longTerm,
                 sections,
                 retrievalQuery,
-                sessionKey
+                sessionKey,
+                identityInjection: {
+                  mode: identityInjectionModeUsed,
+                  injectedChars: identityInjectedChars,
+                  truncated: identityInjectionTruncated
+                }
               });
               impressionRecorded = true;
             }
@@ -12092,7 +12307,12 @@ ${tmtNode.summary}`);
               results: longTerm,
               sections,
               retrievalQuery,
-              sessionKey
+              sessionKey,
+              identityInjection: {
+                mode: identityInjectionModeUsed,
+                injectedChars: identityInjectedChars,
+                truncated: identityInjectionTruncated
+              }
             });
             impressionRecorded = true;
           }
@@ -12231,7 +12451,16 @@ _Context: ${topQuestion.context}_`);
     const timingParts = Object.entries(timings).map(([k, v]) => `${k}=${v}`).join(", ");
     log.debug(`recall: ${timingParts}`);
     if (!impressionRecorded && sessionKey && this.config.recordEmptyRecallImpressions) {
-      this.lastRecall.record({ sessionKey, query: retrievalQuery, memoryIds: [] }).catch((err) => log.debug(`last recall record failed: ${err}`));
+      this.lastRecall.record({
+        sessionKey,
+        query: retrievalQuery,
+        memoryIds: [],
+        identityInjection: {
+          mode: identityInjectionModeUsed,
+          injectedChars: identityInjectedChars,
+          truncated: identityInjectionTruncated
+        }
+      }).catch((err) => log.debug(`last recall record failed: ${err}`));
     }
     const context = sections.length === 0 ? "" : sections.join("\n\n---\n\n");
     this.emitTrace({
@@ -12252,6 +12481,9 @@ _Context: ${topQuestion.context}_`);
       recalledMemoryCount,
       injected: context.length > 0,
       contextChars: context.length,
+      identityInjectionMode: identityInjectionModeUsed,
+      identityInjectedChars,
+      identityInjectionTruncated,
       durationMs: Date.now() - recallStart,
       timings: { ...timings }
     });
@@ -13347,6 +13579,86 @@ ${snippet}`;
 
 ${lines.join("\n\n")}`;
   }
+  summarizeIdentityText(raw, maxLines, maxChars) {
+    const lines = raw.replace(/\r/g, "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+    const compact = lines.slice(0, Math.max(1, maxLines)).join(" ");
+    if (compact.length <= maxChars) return compact;
+    return `${compact.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+  }
+  formatOpenIncidentLine(incident, includeDetails) {
+    const base = `[${incident.id}] ${incident.symptom.trim()}`;
+    if (!includeDetails) return `- ${base}`;
+    const parts = [base];
+    if (incident.suspectedCause) parts.push(`cause: ${incident.suspectedCause.trim()}`);
+    if (incident.triggerWindow) parts.push(`window: ${incident.triggerWindow.trim()}`);
+    return `- ${parts.join(" | ")}`;
+  }
+  trimIdentitySection(content, maxChars) {
+    if (maxChars <= 0) return { text: "", truncated: false };
+    if (content.length <= maxChars) return { text: content, truncated: false };
+    const suffix = "\n\n...(identity continuity trimmed)";
+    if (maxChars <= suffix.length) {
+      return { text: content.slice(0, maxChars), truncated: true };
+    }
+    const headroom = Math.max(0, maxChars - suffix.length);
+    return { text: `${content.slice(0, headroom)}${suffix}`, truncated: true };
+  }
+  async buildIdentityContinuitySection(options) {
+    if (!this.config.identityContinuityEnabled) return null;
+    if (this.config.identityMaxInjectChars <= 0) return null;
+    const resolved = resolveEffectiveIdentityInjectionMode({
+      configuredMode: this.config.identityInjectionMode,
+      recallMode: options.recallMode,
+      prompt: options.prompt
+    });
+    if (!resolved.shouldInject) return null;
+    const [anchorRaw, loopsRaw, incidents] = await Promise.all([
+      options.storage.readIdentityAnchor(),
+      options.storage.readIdentityImprovementLoops(),
+      options.storage.readContinuityIncidents(200)
+    ]);
+    const openIncidents = incidents.filter((incident) => incident.state === "open");
+    const lines = [];
+    if (resolved.mode === "full") {
+      lines.push("## Identity Continuity");
+      if (anchorRaw && anchorRaw.trim().length > 0) {
+        lines.push("", "### Anchor", "", anchorRaw.trim());
+      }
+      if (loopsRaw && loopsRaw.trim().length > 0) {
+        lines.push("", "### Improvement Loops", "", loopsRaw.trim());
+      }
+      lines.push("", "### Open Incidents", "");
+      if (openIncidents.length === 0) {
+        lines.push("- none");
+      } else {
+        lines.push(
+          ...openIncidents.slice(0, 5).map((incident) => this.formatOpenIncidentLine(incident, true))
+        );
+      }
+    } else {
+      const anchorSummary = anchorRaw ? this.summarizeIdentityText(anchorRaw, 3, 320) : "";
+      const loopsSummary = loopsRaw ? this.summarizeIdentityText(loopsRaw, 2, 240) : "";
+      lines.push("## Identity Continuity Signals", "");
+      if (anchorSummary) lines.push(`- anchor: ${anchorSummary}`);
+      if (loopsSummary) lines.push(`- loops: ${loopsSummary}`);
+      if (openIncidents.length === 0) {
+        lines.push("- incidents: 0 open");
+      } else {
+        lines.push(`- incidents: ${openIncidents.length} open`);
+        lines.push(...openIncidents.slice(0, 2).map((incident) => this.formatOpenIncidentLine(incident, false)));
+      }
+    }
+    const body = lines.join("\n").trim();
+    if (!body) return null;
+    const { text, truncated } = this.trimIdentitySection(body, this.config.identityMaxInjectChars);
+    if (!text) return null;
+    return {
+      section: text,
+      mode: resolved.mode,
+      injectedChars: text.length,
+      truncated
+    };
+  }
   emitTrace(event) {
     try {
       const cb = globalThis.__openclawEngramTrace;
@@ -13360,7 +13672,12 @@ ${lines.join("\n\n")}`;
     this.trackMemoryAccess(memoryIds);
     if (options.sessionKey) {
       const unique = Array.from(new Set(memoryIds)).slice(0, 40);
-      this.lastRecall.record({ sessionKey: options.sessionKey, query: options.retrievalQuery, memoryIds: unique }).catch((err) => log.debug(`last recall record failed: ${err}`));
+      this.lastRecall.record({
+        sessionKey: options.sessionKey,
+        query: options.retrievalQuery,
+        memoryIds: unique,
+        identityInjection: options.identityInjection
+      }).catch((err) => log.debug(`last recall record failed: ${err}`));
     }
     options.sections.push(this.formatQmdResults(options.title, options.results));
   }
@@ -14011,6 +14328,57 @@ ${formatted}`
     },
     { name: "memory_search" }
   );
+  api.registerTool(
+    {
+      name: "continuity_audit_generate",
+      label: "Generate Continuity Audit",
+      description: "Generate a deterministic identity continuity audit report (weekly/monthly) and persist it under identity/audits.",
+      parameters: Type.Object({
+        period: Type.Optional(
+          Type.String({
+            enum: ["weekly", "monthly"],
+            description: "Audit period. Defaults to weekly."
+          })
+        ),
+        key: Type.Optional(
+          Type.String({
+            description: "Optional period key (weekly: YYYY-Www, monthly: YYYY-MM). Defaults to current period."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to generate continuity audits."
+          );
+        }
+        if (!orchestrator.config.continuityAuditEnabled) {
+          return toolResult(
+            "Continuity audits are disabled. Enable `continuityAuditEnabled: true` to generate continuity audits."
+          );
+        }
+        if (!orchestrator.compounding) {
+          return toolResult(
+            "Compounding engine is disabled. Enable `compoundingEnabled: true` to generate continuity audits."
+          );
+        }
+        const period = params.period === "monthly" ? "monthly" : "weekly";
+        const key = typeof params.key === "string" ? params.key : void 0;
+        const audit = await orchestrator.compounding.synthesizeContinuityAudit({
+          period,
+          key
+        });
+        return toolResult(
+          `OK
+
+period: ${audit.period}
+key: ${audit.key}
+report: ${audit.reportPath}`
+        );
+      }
+    },
+    { name: "continuity_audit_generate" }
+  );
   api.registerTool(
     {
       name: "continuity_incident_open",
@@ -14303,6 +14671,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             "",
             `Recorded at: ${snap.recordedAt}`,
             `Query hash: ${snap.queryHash} (len=${snap.queryLen})`,
+            `Identity injection: mode=${snap.identityInjectionMode ?? "none"}, chars=${snap.identityInjectedChars ?? 0}, truncated=${snap.identityInjectionTruncated === true ? "yes" : "no"}`,
             `Memories (${snap.memoryIds.length}):`,
             ...snap.memoryIds.map((id) => `- ${id}`)
           ].join("\n")
@@ -15045,7 +15414,7 @@ mistakes: ${res.mistakesCount} patterns`
 
 // src/cli.ts
 import path33 from "path";
-import { access as access2, readFile as readFile22, readdir as readdir12, unlink as unlink3 } from "fs/promises";
+import { access as access2, readFile as readFile22, readdir as readdir13, unlink as unlink3 } from "fs/promises";
 
 // src/transfer/export-json.ts
 import path25 from "path";
@@ -15057,7 +15426,7 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir17, readdir as readdir10, readFile as readFile17, stat as stat3, writeFile as writeFile16 } from "fs/promises";
+import { mkdir as mkdir17, readdir as readdir11, readFile as readFile17, stat as stat3, writeFile as writeFile16 } from "fs/promises";
 import path24 from "path";
 async function sha256File(filePath) {
   const buf = await readFile17(filePath);
@@ -15080,7 +15449,7 @@ async function readJsonFile(filePath) {
 async function listFilesRecursive(rootDir) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir10(dir, { withFileTypes: true });
+    const entries = await readdir11(dir, { withFileTypes: true });
     for (const ent of entries) {
       const fp = path24.join(dir, ent.name);
       if (ent.isDirectory()) {
@@ -15208,7 +15577,7 @@ async function looksLikeEngramMdExport(fromDir) {
 
 // src/transfer/backup.ts
 import path27 from "path";
-import { mkdir as mkdir20, readdir as readdir11, rm as rm2 } from "fs/promises";
+import { mkdir as mkdir20, readdir as readdir12, rm as rm2 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
@@ -15229,7 +15598,7 @@ async function backupMemoryDir(opts) {
   return backupDir;
 }
 async function enforceRetention(outDirAbs, retentionDays) {
-  const entries = await readdir11(outDirAbs, { withFileTypes: true });
+  const entries = await readdir12(outDirAbs, { withFileTypes: true });
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
@@ -15598,7 +15967,7 @@ async function readAllMemoryFiles(memoryDir) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir12(dir, { withFileTypes: true });
+      entries = await readdir13(dir, { withFileTypes: true });
     } catch {
       return;
     }