@joshuaswarren/openclaw-engram 8.3.17 → 8.3.18

package/dist/index.js

@@ -4317,6 +4317,104 @@ function confidenceTier(score) {
 }
 var SPECULATIVE_TTL_DAYS = 30;
 
+// src/identity-continuity.ts
+function parseFrontmatterValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseFrontmatter(raw) {
+  const parsed = {};
+  for (const line of raw.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    parsed[key] = parseFrontmatterValue(value);
+  }
+  return parsed;
+}
+function emitSection(lines, title, value) {
+  if (!value || value.trim().length === 0) return;
+  lines.push(`## ${title}`, "", value.trim(), "");
+}
+function parseSection(body, title) {
+  const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`## ${escaped}\\n\\n([\\s\\S]*?)(?=\\n## |$)`);
+  const match = body.match(re);
+  if (!match) return void 0;
+  const value = match[1].trim();
+  return value.length > 0 ? value : void 0;
+}
+function serializeContinuityIncident(incident) {
+  const lines = [
+    "---",
+    `id: ${JSON.stringify(incident.id)}`,
+    `state: ${JSON.stringify(incident.state)}`,
+    `openedAt: ${JSON.stringify(incident.openedAt)}`,
+    `updatedAt: ${JSON.stringify(incident.updatedAt)}`
+  ];
+  if (incident.closedAt) lines.push(`closedAt: ${JSON.stringify(incident.closedAt)}`);
+  if (incident.triggerWindow) lines.push(`triggerWindow: ${JSON.stringify(incident.triggerWindow)}`);
+  lines.push("---", "");
+  emitSection(lines, "Symptom", incident.symptom);
+  emitSection(lines, "Suspected Cause", incident.suspectedCause);
+  emitSection(lines, "Fix Applied", incident.fixApplied);
+  emitSection(lines, "Verification Result", incident.verificationResult);
+  emitSection(lines, "Preventive Rule", incident.preventiveRule);
+  return lines.join("\n").trimEnd() + "\n";
+}
+function parseContinuityIncident(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const frontmatter = parseFrontmatter(match[1]);
+  const body = match[2] ?? "";
+  const id = typeof frontmatter.id === "string" ? frontmatter.id : "";
+  const stateRaw = frontmatter.state;
+  const state = stateRaw === "closed" ? "closed" : stateRaw === "open" ? "open" : "open";
+  const openedAt = typeof frontmatter.openedAt === "string" ? frontmatter.openedAt : "";
+  const updatedAt = typeof frontmatter.updatedAt === "string" ? frontmatter.updatedAt : openedAt;
+  const symptom = parseSection(body, "Symptom");
+  if (!id || !openedAt || !updatedAt || !symptom) return null;
+  return {
+    id,
+    state,
+    openedAt,
+    updatedAt,
+    triggerWindow: typeof frontmatter.triggerWindow === "string" ? frontmatter.triggerWindow : void 0,
+    symptom,
+    suspectedCause: parseSection(body, "Suspected Cause"),
+    fixApplied: parseSection(body, "Fix Applied"),
+    verificationResult: parseSection(body, "Verification Result"),
+    preventiveRule: parseSection(body, "Preventive Rule"),
+    closedAt: typeof frontmatter.closedAt === "string" ? frontmatter.closedAt : void 0
+  };
+}
+function createContinuityIncidentRecord(id, input, nowIso) {
+  return {
+    id,
+    state: "open",
+    openedAt: nowIso,
+    updatedAt: nowIso,
+    triggerWindow: input.triggerWindow?.trim() || void 0,
+    symptom: input.symptom.trim(),
+    suspectedCause: input.suspectedCause?.trim() || void 0
+  };
+}
+function closeContinuityIncidentRecord(incident, closure, nowIso) {
+  return {
+    ...incident,
+    state: "closed",
+    updatedAt: nowIso,
+    closedAt: nowIso,
+    fixApplied: closure.fixApplied.trim(),
+    verificationResult: closure.verificationResult.trim(),
+    preventiveRule: closure.preventiveRule?.trim() || incident.preventiveRule
+  };
+}
+
 // src/storage.ts
 var ARTIFACT_SEARCH_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
@@ -4416,7 +4514,7 @@ function serializeFrontmatter(fm) {
   lines.push("---");
   return lines.join("\n");
 }
-function parseFrontmatter(raw) {
+function parseFrontmatter2(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (!match) return null;
   const fmBlock = match[1];
@@ -4804,6 +4902,24 @@ var StorageManager = class _StorageManager {
   get artifactsDir() {
     return path4.join(this.baseDir, "artifacts");
   }
+  get identityDir() {
+    return path4.join(this.baseDir, "identity");
+  }
+  get identityAnchorPath() {
+    return path4.join(this.identityDir, "identity-anchor.md");
+  }
+  get identityIncidentsDir() {
+    return path4.join(this.identityDir, "incidents");
+  }
+  get identityAuditsWeeklyDir() {
+    return path4.join(this.identityDir, "audits", "weekly");
+  }
+  get identityAuditsMonthlyDir() {
+    return path4.join(this.identityDir, "audits", "monthly");
+  }
+  get identityImprovementLoopsPath() {
+    return path4.join(this.identityDir, "improvement-loops.md");
+  }
   get profilePath() {
     return path4.join(this.baseDir, "profile.md");
   }
@@ -4839,6 +4955,10 @@ var StorageManager = class _StorageManager {
     await mkdir2(this.stateDir, { recursive: true });
     await mkdir2(this.questionsDir, { recursive: true });
     await mkdir2(this.artifactsDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
+    await mkdir2(this.identityIncidentsDir, { recursive: true });
+    await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
+    await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
     await mkdir2(path4.join(this.baseDir, "config"), { recursive: true });
   }
   async writeMemory(category, content, options = {}) {
@@ -5114,7 +5234,7 @@ ${sanitized.text}
           } else if (entry.name.endsWith(".md")) {
             try {
               const raw = await readFile2(fullPath, "utf-8");
-              const parsed = parseFrontmatter(raw);
+              const parsed = parseFrontmatter2(raw);
               if (parsed) {
                 memories.push({
                   path: fullPath,
@@ -5150,7 +5270,7 @@ ${sanitized.text}
           } else if (entry.name.endsWith(".md")) {
             try {
               const raw = await readFile2(fullPath, "utf-8");
-              const parsed = parseFrontmatter(raw);
+              const parsed = parseFrontmatter2(raw);
               if (parsed) {
                 memories.push({
                   path: fullPath,
@@ -5172,7 +5292,7 @@ ${sanitized.text}
   async readMemoryByPath(filePath) {
     try {
       const raw = await readFile2(filePath, "utf-8");
-      const parsed = parseFrontmatter(raw);
+      const parsed = parseFrontmatter2(raw);
       if (!parsed) return null;
       return { path: filePath, frontmatter: parsed.frontmatter, content: parsed.content };
     } catch {
@@ -5448,6 +5568,86 @@ ${memory.content}
       return null;
     }
   }
+  async writeIdentityAnchor(content) {
+    await this.ensureDirectories();
+    await writeFile2(this.identityAnchorPath, content, "utf-8");
+  }
+  async readIdentityAnchor() {
+    try {
+      return await readFile2(this.identityAnchorPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async appendContinuityIncident(input) {
+    await this.ensureDirectories();
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const date = nowIso.slice(0, 10);
+    const id = this.generateId("incident");
+    const incident = createContinuityIncidentRecord(id, input, nowIso);
+    const filePath = path4.join(this.identityIncidentsDir, `${date}-${id}.md`);
+    await writeFile2(filePath, serializeContinuityIncident(incident), "utf-8");
+    return { ...incident, filePath };
+  }
+  async readContinuityIncidents(limit = 200) {
+    const cappedLimit = Math.max(0, Math.floor(limit));
+    if (cappedLimit === 0) return [];
+    try {
+      const candidates = await this.readContinuityIncidentFileNames();
+      const incidents = [];
+      for (const file of candidates) {
+        if (incidents.length >= cappedLimit) break;
+        const filePath = path4.join(this.identityIncidentsDir, file);
+        try {
+          const raw = await readFile2(filePath, "utf-8");
+          const parsed = parseContinuityIncident(raw);
+          if (parsed) incidents.push({ ...parsed, filePath });
+        } catch {
+        }
+      }
+      return incidents;
+    } catch {
+      return [];
+    }
+  }
+  async closeContinuityIncident(id, closure) {
+    const directFilePath = await this.findContinuityIncidentFilePathById(id);
+    const target = directFilePath ? await this.readContinuityIncidentFile(directFilePath) : null;
+    if (!target || !directFilePath) return null;
+    if (target.state === "closed") return target;
+    const closed = closeContinuityIncidentRecord(target, closure, (/* @__PURE__ */ new Date()).toISOString());
+    await writeFile2(directFilePath, serializeContinuityIncident(closed), "utf-8");
+    return { ...closed, filePath: directFilePath };
+  }
+  async writeIdentityAudit(period, key, content) {
+    await this.ensureDirectories();
+    const safeKey = this.sanitizeIdentityAuditKey(key);
+    const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
+    const filePath = path4.join(dir, `${safeKey}.md`);
+    await writeFile2(filePath, content, "utf-8");
+    return filePath;
+  }
+  async readIdentityAudit(period, key) {
+    try {
+      const safeKey = this.sanitizeIdentityAuditKey(key);
+      const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
+      return await readFile2(path4.join(dir, `${safeKey}.md`), "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async writeIdentityImprovementLoops(content) {
+    await this.ensureDirectories();
+    await writeFile2(this.identityImprovementLoopsPath, content, "utf-8");
+  }
+  async readIdentityImprovementLoops() {
+    try {
+      return await readFile2(this.identityImprovementLoopsPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
   // ---------------------------------------------------------------------------
   // Question storage
   // ---------------------------------------------------------------------------
@@ -5456,6 +5656,37 @@ ${memory.content}
     const rand = Math.random().toString(36).slice(2, 4);
     return `${prefix}-${ts}-${rand}`;
   }
+  async readContinuityIncidentFileNames() {
+    const files = await readdir(this.identityIncidentsDir);
+    return files.filter((file) => file.endsWith(".md")).sort().reverse();
+  }
+  async readContinuityIncidentFile(filePath) {
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const parsed = parseContinuityIncident(raw);
+      return parsed ? { ...parsed, filePath } : null;
+    } catch {
+      return null;
+    }
+  }
+  async findContinuityIncidentFilePathById(id) {
+    const fileNames = await this.readContinuityIncidentFileNames();
+    const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
+    if (directMatch) return path4.join(this.identityIncidentsDir, directMatch);
+    for (const fileName of fileNames) {
+      const filePath = path4.join(this.identityIncidentsDir, fileName);
+      const parsed = await this.readContinuityIncidentFile(filePath);
+      if (parsed?.id === id) return filePath;
+    }
+    return null;
+  }
+  sanitizeIdentityAuditKey(key) {
+    const trimmed = key.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) || trimmed.includes("..")) {
+      throw new Error("Invalid identity audit key");
+    }
+    return trimmed;
+  }
   async writeQuestion(question, context, priority) {
     await mkdir2(this.questionsDir, { recursive: true });
     const id = this.generateId("q");