@joshuaswarren/openclaw-engram 8.3.18 → 8.3.20

package/dist/index.js

@@ -13831,6 +13831,105 @@ import { Type } from "@sinclair/typebox";
 function toolResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
+var IDENTITY_ANCHOR_TITLE = "# Identity Continuity Anchor";
+var IDENTITY_ANCHOR_SECTION_ORDER = [
+  "Identity Traits",
+  "Communication Preferences",
+  "Operating Principles",
+  "Continuity Notes"
+];
+function parseMarkdownSections(raw) {
+  const lines = raw.replace(/\r/g, "").split("\n");
+  const headerLines = [];
+  const sectionLines = /* @__PURE__ */ new Map();
+  const order = [];
+  let currentSection = null;
+  for (const line of lines) {
+    const sectionMatch = line.match(/^##\s+(.+?)\s*$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1].trim();
+      if (!sectionLines.has(currentSection)) {
+        sectionLines.set(currentSection, []);
+        order.push(currentSection);
+      }
+      continue;
+    }
+    if (!currentSection) {
+      headerLines.push(line);
+      continue;
+    }
+    sectionLines.get(currentSection)?.push(line);
+  }
+  const sections = /* @__PURE__ */ new Map();
+  for (const [name, contentLines] of sectionLines.entries()) {
+    sections.set(name, contentLines.join("\n").trim());
+  }
+  return {
+    header: headerLines.join("\n").trim(),
+    sections,
+    order
+  };
+}
+function mergeAnchorSection(existing, incoming) {
+  const next = incoming?.trim();
+  const prev = existing?.trim() === "- (empty)" ? "" : existing?.trim();
+  if (!next) return prev ?? "";
+  if (!prev) return next;
+  if (prev.includes(next)) return prev;
+  if (next.includes(prev)) return next;
+  return `${prev}
+
+${next}`;
+}
+function mergeIdentityAnchor(existingRaw, updates) {
+  const parsed = parseMarkdownSections(existingRaw ?? "");
+  const header = parsed.header.length > 0 ? parsed.header : IDENTITY_ANCHOR_TITLE;
+  const sections = new Map(parsed.sections);
+  for (const sectionName of IDENTITY_ANCHOR_SECTION_ORDER) {
+    const merged = mergeAnchorSection(sections.get(sectionName), updates[sectionName]);
+    if (merged) {
+      sections.set(sectionName, merged);
+    } else if (!sections.has(sectionName)) {
+      sections.set(sectionName, "");
+    }
+  }
+  const finalOrder = [];
+  for (const sectionName of IDENTITY_ANCHOR_SECTION_ORDER) {
+    if (sections.has(sectionName)) finalOrder.push(sectionName);
+  }
+  for (const sectionName of parsed.order) {
+    if (!finalOrder.includes(sectionName) && sections.has(sectionName)) {
+      finalOrder.push(sectionName);
+    }
+  }
+  const lines = [header.trim(), ""];
+  for (const sectionName of finalOrder) {
+    lines.push(`## ${sectionName}`, "");
+    const body = sections.get(sectionName)?.trim();
+    if (body && body.length > 0) {
+      lines.push(body, "");
+    } else {
+      lines.push("");
+    }
+  }
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+function formatContinuityIncidentSummary(incident, index) {
+  const prefix = typeof index === "number" ? `### [${index + 1}] ` : "### ";
+  const lines = [
+    `${prefix}${incident.id} (${incident.state})`,
+    `Opened: ${incident.openedAt}`
+  ];
+  if (incident.closedAt) lines.push(`Closed: ${incident.closedAt}`);
+  if (incident.triggerWindow) lines.push(`Window: ${incident.triggerWindow}`);
+  lines.push("", `Symptom: ${incident.symptom}`);
+  if (incident.suspectedCause) lines.push(`Suspected Cause: ${incident.suspectedCause}`);
+  if (incident.fixApplied) lines.push(`Fix Applied: ${incident.fixApplied}`);
+  if (incident.verificationResult) lines.push(`Verification: ${incident.verificationResult}`);
+  if (incident.preventiveRule) lines.push(`Preventive Rule: ${incident.preventiveRule}`);
+  if (incident.filePath) lines.push(`Path: ${incident.filePath}`);
+  return lines.join("\n");
+}
 function registerTools(api, orchestrator) {
   const actionTypes = [
     "store_episode",
@@ -13912,6 +14011,237 @@ ${formatted}`
     },
     { name: "memory_search" }
   );
+  api.registerTool(
+    {
+      name: "continuity_incident_open",
+      label: "Open Continuity Incident",
+      description: "Create a new continuity incident record in append-only storage.",
+      parameters: Type.Object({
+        symptom: Type.String({
+          description: "Observed continuity failure symptom."
+        }),
+        triggerWindow: Type.Optional(
+          Type.String({
+            description: "Optional time window when incident occurred."
+          })
+        ),
+        suspectedCause: Type.Optional(
+          Type.String({
+            description: "Optional suspected root cause."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to open incidents."
+          );
+        }
+        if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          return toolResult(
+            "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true` to open incidents."
+          );
+        }
+        const symptom = typeof params.symptom === "string" ? params.symptom.trim() : "";
+        if (!symptom) {
+          return toolResult("Missing required field: symptom");
+        }
+        const created = await orchestrator.storage.appendContinuityIncident({
+          symptom,
+          triggerWindow: typeof params.triggerWindow === "string" ? params.triggerWindow : void 0,
+          suspectedCause: typeof params.suspectedCause === "string" ? params.suspectedCause : void 0
+        });
+        log.info(`continuity-incident open id=${created.id}`);
+        return toolResult(`Continuity incident opened.
+
+${formatContinuityIncidentSummary(created)}`);
+      }
+    },
+    { name: "continuity_incident_open" }
+  );
+  api.registerTool(
+    {
+      name: "continuity_incident_close",
+      label: "Close Continuity Incident",
+      description: "Close an open continuity incident with required verification details.",
+      parameters: Type.Object({
+        id: Type.String({
+          description: "Incident ID to close."
+        }),
+        fixApplied: Type.String({
+          description: "What fix was applied."
+        }),
+        verificationResult: Type.String({
+          description: "How closure was verified."
+        }),
+        preventiveRule: Type.Optional(
+          Type.String({
+            description: "Optional preventive follow-up rule."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to close incidents."
+          );
+        }
+        if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          return toolResult(
+            "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true` to close incidents."
+          );
+        }
+        const id = typeof params.id === "string" ? params.id.trim() : "";
+        const fixApplied = typeof params.fixApplied === "string" ? params.fixApplied.trim() : "";
+        const verificationResult = typeof params.verificationResult === "string" ? params.verificationResult.trim() : "";
+        const preventiveRule = typeof params.preventiveRule === "string" ? params.preventiveRule.trim() : void 0;
+        if (!id) return toolResult("Missing required field: id");
+        if (!fixApplied) return toolResult("Missing required field: fixApplied");
+        if (!verificationResult) return toolResult("Missing required field: verificationResult");
+        const closed = await orchestrator.storage.closeContinuityIncident(id, {
+          fixApplied,
+          verificationResult,
+          preventiveRule
+        });
+        if (!closed) return toolResult(`Incident not found: ${id}`);
+        log.info(`continuity-incident close id=${id}`);
+        return toolResult(`Continuity incident closed.
+
+${formatContinuityIncidentSummary(closed)}`);
+      }
+    },
+    { name: "continuity_incident_close" }
+  );
+  api.registerTool(
+    {
+      name: "continuity_incident_list",
+      label: "List Continuity Incidents",
+      description: "List continuity incidents and optionally filter by state.",
+      parameters: Type.Object({
+        state: Type.Optional(
+          Type.String({
+            enum: ["open", "closed", "all"],
+            description: "Incident state filter (default: open)."
+          })
+        ),
+        limit: Type.Optional(
+          Type.Number({
+            description: "Max incidents to return (default: 25, max: 200).",
+            minimum: 1,
+            maximum: 200
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to list incidents."
+          );
+        }
+        const state = params.state === "closed" || params.state === "all" ? params.state : "open";
+        const limitRaw = typeof params.limit === "number" ? params.limit : 25;
+        const limit = Math.max(1, Math.min(200, Math.floor(limitRaw)));
+        const incidents = await orchestrator.storage.readContinuityIncidents(limit);
+        const filtered = state === "all" ? incidents : incidents.filter((incident) => incident.state === state);
+        if (filtered.length === 0) {
+          return toolResult(`No continuity incidents found for state=${state}.`);
+        }
+        const body = filtered.map((incident, index) => formatContinuityIncidentSummary(incident, index)).join("\n\n");
+        return toolResult(`## Continuity Incidents (${filtered.length}, state=${state})
+
+${body}`);
+      }
+    },
+    { name: "continuity_incident_list" }
+  );
+  api.registerTool(
+    {
+      name: "identity_anchor_get",
+      label: "Get Identity Anchor",
+      description: "Read the identity continuity anchor document used for recovery-safe identity context.",
+      parameters: Type.Object({}),
+      async execute() {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to use identity anchor tools."
+          );
+        }
+        const anchor = await orchestrator.storage.readIdentityAnchor();
+        if (!anchor) {
+          return toolResult(
+            "No identity anchor found yet. Use `identity_anchor_update` to create one."
+          );
+        }
+        return toolResult(`## Identity Anchor
+
+${anchor}`);
+      }
+    },
+    { name: "identity_anchor_get" }
+  );
+  api.registerTool(
+    {
+      name: "identity_anchor_update",
+      label: "Update Identity Anchor",
+      description: "Conservatively update identity anchor sections without overwriting existing material.",
+      parameters: Type.Object({
+        identityTraits: Type.Optional(
+          Type.String({
+            description: "Updates for the 'Identity Traits' section."
+          })
+        ),
+        communicationPreferences: Type.Optional(
+          Type.String({
+            description: "Updates for the 'Communication Preferences' section."
+          })
+        ),
+        operatingPrinciples: Type.Optional(
+          Type.String({
+            description: "Updates for the 'Operating Principles' section."
+          })
+        ),
+        continuityNotes: Type.Optional(
+          Type.String({
+            description: "Updates for the 'Continuity Notes' section."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          return toolResult(
+            "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to use identity anchor tools."
+          );
+        }
+        const updates = {
+          "Identity Traits": typeof params.identityTraits === "string" ? params.identityTraits : void 0,
+          "Communication Preferences": typeof params.communicationPreferences === "string" ? params.communicationPreferences : void 0,
+          "Operating Principles": typeof params.operatingPrinciples === "string" ? params.operatingPrinciples : void 0,
+          "Continuity Notes": typeof params.continuityNotes === "string" ? params.continuityNotes : void 0
+        };
+        const hasUpdate = Object.values(updates).some(
+          (value) => typeof value === "string" && value.trim().length > 0
+        );
+        if (!hasUpdate) {
+          return toolResult(
+            "No updates provided. Supply at least one section field to update the identity anchor."
+          );
+        }
+        const existing = await orchestrator.storage.readIdentityAnchor();
+        const merged = mergeIdentityAnchor(existing, updates);
+        await orchestrator.storage.writeIdentityAnchor(merged);
+        const updatedSections = Object.entries(updates).filter(([, value]) => typeof value === "string" && value.trim().length > 0).map(([name]) => name);
+        log.info(
+          `identity-anchor update sections=${updatedSections.join(",")} chars=${merged.length}`
+        );
+        return toolResult(
+          `Identity anchor updated (${updatedSections.length} section${updatedSections.length === 1 ? "" : "s"}).
+
+${merged}`
+        );
+      }
+    },
+    { name: "identity_anchor_update" }
+  );
   api.registerTool(
     {
       name: "memory_feedback",
@@ -15311,6 +15641,21 @@ async function readAllMemoryFiles(memoryDir) {
   }
   return out;
 }
+function formatContinuityIncidentCli(incident) {
+  const lines = [
+    `${incident.id} [${incident.state}]`,
+    `  opened: ${incident.openedAt}`
+  ];
+  if (incident.closedAt) lines.push(`  closed: ${incident.closedAt}`);
+  if (incident.triggerWindow) lines.push(`  window: ${incident.triggerWindow}`);
+  lines.push(`  symptom: ${incident.symptom}`);
+  if (incident.suspectedCause) lines.push(`  suspected-cause: ${incident.suspectedCause}`);
+  if (incident.fixApplied) lines.push(`  fix-applied: ${incident.fixApplied}`);
+  if (incident.verificationResult) lines.push(`  verification: ${incident.verificationResult}`);
+  if (incident.preventiveRule) lines.push(`  preventive-rule: ${incident.preventiveRule}`);
+  if (incident.filePath) lines.push(`  path: ${incident.filePath}`);
+  return lines.join("\n");
+}
 function registerCli(api, orchestrator) {
   api.registerCli(
     ({ program }) => {
@@ -15697,6 +16042,90 @@ function registerCli(api, orchestrator) {
         }
         console.log(identity);
       });
+      const continuityCmd = cmd.command("continuity").description("Identity continuity incident workflow commands");
+      continuityCmd.command("incidents").description("List continuity incidents").option("--state <state>", "Filter by state: open|closed|all", "open").option("--limit <number>", "Maximum incidents to list", "25").action(async (...args) => {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          console.log("Identity continuity is disabled.");
+          return;
+        }
+        const options = args[0] ?? {};
+        const stateRaw = String(options.state ?? "open").toLowerCase();
+        const state = stateRaw === "closed" || stateRaw === "all" ? stateRaw : "open";
+        const limit = Math.max(1, Math.min(200, parseInt(String(options.limit ?? "25"), 10) || 25));
+        const incidents = await orchestrator.storage.readContinuityIncidents(limit);
+        const filtered = state === "all" ? incidents : incidents.filter((incident) => incident.state === state);
+        if (filtered.length === 0) {
+          console.log(`No continuity incidents found for state=${state}.`);
+          return;
+        }
+        console.log(`=== Continuity Incidents (${filtered.length}, state=${state}) ===
+`);
+        for (const incident of filtered) {
+          console.log(formatContinuityIncidentCli(incident));
+          console.log();
+        }
+      });
+      continuityCmd.command("incident-open").description("Open a continuity incident").option("--symptom <text>", "Required symptom description").option("--trigger-window <window>", "Optional incident trigger window").option("--suspected-cause <text>", "Optional suspected cause").action(async (...args) => {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          console.log("Identity continuity is disabled.");
+          return;
+        }
+        if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          console.log("Continuity incident logging is disabled.");
+          return;
+        }
+        const options = args[0] ?? {};
+        const symptom = String(options.symptom ?? "").trim();
+        if (!symptom) {
+          console.log("Missing required --symptom.");
+          return;
+        }
+        const created = await orchestrator.storage.appendContinuityIncident({
+          symptom,
+          triggerWindow: options.triggerWindow ? String(options.triggerWindow) : void 0,
+          suspectedCause: options.suspectedCause ? String(options.suspectedCause) : void 0
+        });
+        console.log("Opened continuity incident:\n");
+        console.log(formatContinuityIncidentCli(created));
+      });
+      continuityCmd.command("incident-close").description("Close a continuity incident").option("--id <id>", "Required incident ID").option("--fix-applied <text>", "Required fix description").option("--verification-result <text>", "Required verification result").option("--preventive-rule <text>", "Optional preventive rule").action(async (...args) => {
+        if (!orchestrator.config.identityContinuityEnabled) {
+          console.log("Identity continuity is disabled.");
+          return;
+        }
+        if (!orchestrator.config.continuityIncidentLoggingEnabled) {
+          console.log("Continuity incident logging is disabled.");
+          return;
+        }
+        const options = args[0] ?? {};
+        const id = String(options.id ?? "").trim();
+        const fixApplied = String(options.fixApplied ?? "").trim();
+        const verificationResult = String(options.verificationResult ?? "").trim();
+        const preventiveRule = options.preventiveRule ? String(options.preventiveRule).trim() : void 0;
+        if (!id) {
+          console.log("Missing required --id.");
+          return;
+        }
+        if (!fixApplied) {
+          console.log("Missing required --fix-applied.");
+          return;
+        }
+        if (!verificationResult) {
+          console.log("Missing required --verification-result.");
+          return;
+        }
+        const closed = await orchestrator.storage.closeContinuityIncident(id, {
+          fixApplied,
+          verificationResult,
+          preventiveRule
+        });
+        if (!closed) {
+          console.log(`Incident not found: ${id}`);
+          return;
+        }
+        console.log("Closed continuity incident:\n");
+        console.log(formatContinuityIncidentCli(closed));
+      });
       cmd.command("access").description("Show memory access statistics").option("-n, --top <number>", "Show top N most accessed", "20").action(async (...args) => {
         const options = args[0] ?? {};
         const top = parseInt(options.top ?? "20", 10);