@joshuaswarren/openclaw-engram 8.3.19 → 8.3.20

package/dist/index.js

@@ -13914,6 +13914,22 @@ function mergeIdentityAnchor(existingRaw, updates) {
   }
   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",
@@ -13995,6 +14011,149 @@ ${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",
@@ -15482,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 }) => {
@@ -15868,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);