@joshuaswarren/openclaw-engram 8.3.19 → 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
@@ -13914,6 +14057,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 +14154,200 @@ ${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",
+      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",
@@ -14886,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";
@@ -14898,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);
@@ -14921,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()) {
@@ -15049,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, "-");
 }
@@ -15070,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;
@@ -15439,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;
     }
@@ -15482,6 +15835,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 +16236,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);