@joshuaswarren/openclaw-engram 8.3.20 → 8.3.21

package/dist/index.js

@@ -10562,7 +10562,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 +10574,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 +10602,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 +10625,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 +10740,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 +10779,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
@@ -14011,6 +14154,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",
@@ -15045,7 +15239,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 +15251,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 +15274,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 +15402,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 +15423,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 +15792,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;
     }