@remnic/core 9.3.756 → 9.3.758

package/dist/{chunk-DWDDQLSZ.js → chunk-6C6BBBCI.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-3I2IASNK.js";
+} from "./chunk-M5QKGHCR.js";
 import {
   getTrustZoneStoreStatus,
   isTrustZoneName,
@@ -38,9 +38,6 @@ import {
 import {
   estimateRecallTokens
 } from "./chunk-6MMONPHM.js";
-import {
-  namespaceCollectionName
-} from "./chunk-PS572XYO.js";
 import {
   combineNamespaces,
   defaultGitInvoker,
@@ -54,6 +51,9 @@ import {
   resolveWritableNamespaceValue,
   sanitizeFragment
 } from "./chunk-W3M34XT4.js";
+import {
+  namespaceCollectionName
+} from "./chunk-XQT5GSWU.js";
 import {
   namespaceIdentityFromToken
 } from "./chunk-ZFXCQPNO.js";
@@ -64,30 +64,30 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-PRX77NPC.js";
+} from "./chunk-CQCCVJZO.js";
+import {
+  recordMemoryOutcome
+} from "./chunk-EIR5VLIH.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-ICP53SKG.js";
 import {
   objectiveStateStoreOverrideForNamespace
 } from "./chunk-6HMYUWXR.js";
-import {
-  recordMemoryOutcome
-} from "./chunk-EIR5VLIH.js";
 import {
   buildGraphSnapshot
 } from "./chunk-TQT3USCG.js";
-import {
-  persistExplicitCapture,
-  queueExplicitCaptureForReview,
-  validateExplicitCaptureInput
-} from "./chunk-K5LLP4CY.js";
 import {
   wrapWorkLayerContext
 } from "./chunk-EI6V5UXY.js";
 import {
   formatProfileTraceAscii
 } from "./chunk-PNLCEFE4.js";
+import {
+  persistExplicitCapture,
+  queueExplicitCaptureForReview,
+  validateExplicitCaptureInput
+} from "./chunk-K5LLP4CY.js";
 import {
   buildProcedurePersistBody,
   normalizeProcedureSteps
@@ -95,17 +95,21 @@ import {
 import {
   CrossNamespaceBudget
 } from "./chunk-ODPLEWB6.js";
+import {
+  filterTrajectoriesByLookbackDays,
+  readCausalTrajectoryRecords
+} from "./chunk-SQNED75R.js";
 import {
   FileCalendarSource,
   buildBriefing,
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-YMGQXBPS.js";
+} from "./chunk-RF6BZHOD.js";
 import {
   parseEntityFile,
   selfDeps
-} from "./chunk-7APVFQ34.js";
+} from "./chunk-DUQHQ3TL.js";
 import {
   supersessionKeysForFact
 } from "./chunk-TKZ3AL5V.js";
@@ -133,19 +137,15 @@ import {
 import {
   displayErrorDetail
 } from "./chunk-6KYMPV2O.js";
-import {
-  computeContentHash
-} from "./chunk-W5H6ZRPT.js";
 import {
   createVersion
 } from "./chunk-VF4XKTX3.js";
+import {
+  computeContentHash
+} from "./chunk-W5H6ZRPT.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
-import {
-  filterTrajectoriesByLookbackDays,
-  readCausalTrajectoryRecords
-} from "./chunk-SQNED75R.js";
 import {
   canReadNamespace,
   canWriteNamespace,
@@ -182,7 +182,7 @@ import {
 } from "./chunk-NU3CSQ4H.js";
 import {
   exportCapsule
-} from "./chunk-TCKP4EHY.js";
+} from "./chunk-FLVL4L3L.js";
 import {
   evaluateActionConfidence
 } from "./chunk-Z2YFLXHU.js";
@@ -6682,6 +6682,238 @@ var AccessRecallSurface = class {
   }
 };
 
+// src/access-identity-continuity-surface.ts
+var AccessIdentityContinuitySurface = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async continuityAuditGenerate(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return {
+        enabled: false,
+        reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`."
+      };
+    }
+    if (!resolveConsolidationCapabilities(this.deps.orchestrator.config).continuityAudit) {
+      return {
+        enabled: false,
+        reason: "Continuity audits are disabled. Enable `continuityAuditEnabled: true`."
+      };
+    }
+    if (!this.deps.orchestrator.compounding) {
+      return {
+        enabled: false,
+        reason: "Compounding engine is disabled. Enable `compoundingEnabled: true`."
+      };
+    }
+    const period = request.period === "monthly" ? "monthly" : "weekly";
+    const key = request.key?.trim() || void 0;
+    const audit = await this.deps.orchestrator.compounding.synthesizeContinuityAudit({ period, key });
+    return { enabled: true, period: audit.period, key: audit.key, reportPath: audit.reportPath };
+  }
+  async continuityIncidentOpen(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return {
+        enabled: false,
+        reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`."
+      };
+    }
+    if (!resolveRecallAuxiliaryCapabilities(this.deps.orchestrator.config).continuityIncidentLogging) {
+      return {
+        enabled: false,
+        reason: "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true`."
+      };
+    }
+    const symptom = request.symptom?.trim();
+    if (!symptom) throw new EngramAccessInputError("symptom is required");
+    const resolvedNs = this.deps.writableNamespaceFor(request.namespace, void 0, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const created = await storage.appendContinuityIncident({
+      symptom,
+      triggerWindow: request.triggerWindow?.trim() || void 0,
+      suspectedCause: request.suspectedCause?.trim() || void 0
+    });
+    return { created: true, incident: created };
+  }
+  async continuityIncidentClose(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    if (!resolveRecallAuxiliaryCapabilities(this.deps.orchestrator.config).continuityIncidentLogging) {
+      return { enabled: false, reason: "Continuity incident logging is disabled." };
+    }
+    const id = request.id?.trim();
+    if (!id) throw new EngramAccessInputError("id is required");
+    const fixApplied = request.fixApplied?.trim();
+    if (!fixApplied) throw new EngramAccessInputError("fixApplied is required");
+    const verificationResult = request.verificationResult?.trim();
+    if (!verificationResult) throw new EngramAccessInputError("verificationResult is required");
+    const resolvedNs = this.deps.writableNamespaceFor(request.namespace, void 0, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const closed = await storage.closeContinuityIncident(id, {
+      fixApplied,
+      verificationResult,
+      preventiveRule: request.preventiveRule?.trim() || void 0
+    });
+    if (!closed) return { closed: false, reason: `Incident not found: ${id}` };
+    return { closed: true, incident: closed };
+  }
+  async continuityIncidentList(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const state = request.state === "closed" || request.state === "all" ? request.state : "open";
+    const limit = Math.max(1, Math.min(200, Math.floor(request.limit ?? 25)));
+    const resolvedNs = this.deps.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const incidents = await storage.readContinuityIncidents(limit, state);
+    return { state, incidents, count: incidents.length };
+  }
+  async continuityLoopAddOrUpdate(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const resolvedNs = this.deps.writableNamespaceFor(request.namespace, void 0, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const loop = await storage.upsertIdentityImprovementLoop({
+      id: request.id?.trim() || "",
+      cadence: request.cadence,
+      purpose: request.purpose?.trim() || "",
+      status: request.status,
+      killCondition: request.killCondition?.trim() || "",
+      lastReviewed: request.lastReviewed?.trim() || void 0,
+      notes: request.notes?.trim() || void 0
+    });
+    return { saved: true, loop };
+  }
+  async continuityLoopReview(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const id = request.id?.trim();
+    if (!id) throw new EngramAccessInputError("id is required");
+    const resolvedNs = this.deps.writableNamespaceFor(request.namespace, void 0, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const reviewed = await storage.reviewIdentityImprovementLoop(id, {
+      status: request.status,
+      notes: request.notes?.trim() || void 0,
+      reviewedAt: request.reviewedAt?.trim() || void 0
+    });
+    if (!reviewed) return { reviewed: false, reason: `Continuity loop not found: ${id}` };
+    return { reviewed: true, loop: reviewed };
+  }
+  async identityAnchorGet(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const resolvedNs = this.deps.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const anchor = await storage.readIdentityAnchor();
+    if (!anchor) {
+      return {
+        found: false,
+        message: "No identity anchor found yet. Use identity_anchor_update to create one."
+      };
+    }
+    return { found: true, anchor };
+  }
+  async identityAnchorUpdate(request) {
+    if (!resolveIdentityContinuityCapabilities(this.deps.orchestrator.config).identityContinuity) {
+      return { enabled: false, reason: "Identity continuity is disabled." };
+    }
+    const updates = {
+      "Identity Traits": request.identityTraits?.trim() || void 0,
+      "Communication Preferences": request.communicationPreferences?.trim() || void 0,
+      "Operating Principles": request.operatingPrinciples?.trim() || void 0,
+      "Continuity Notes": request.continuityNotes?.trim() || void 0
+    };
+    const hasUpdate = Object.values(updates).some((value) => typeof value === "string" && value.length > 0);
+    if (!hasUpdate) {
+      throw new EngramAccessInputError("At least one section field is required.");
+    }
+    const resolvedNs = this.deps.writableNamespaceFor(request.namespace, void 0, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const existing = await storage.readIdentityAnchor();
+    const merged = this.mergeIdentityAnchorSections(existing, updates);
+    await storage.writeIdentityAnchor(merged);
+    const updatedSections = Object.entries(updates).filter(([, value]) => typeof value === "string" && value.length > 0).map(([name]) => name);
+    return { updated: true, sections: updatedSections, anchor: merged };
+  }
+  async memoryIdentity(request) {
+    const resolvedNs = this.deps.resolveReadableNamespace(request.namespace, request.principal);
+    const storage = await this.deps.orchestrator.getStorage(resolvedNs);
+    const identity = await storage.readIdentityReflections();
+    if (!identity) return { found: false, message: "No identity reflections found." };
+    return { found: true, identity };
+  }
+  /** Conservative identity anchor section merge (matches tools.ts mergeIdentityAnchor logic). */
+  mergeIdentityAnchorSections(existingRaw, updates) {
+    const title = "# Identity Continuity Anchor";
+    const sectionOrder = ["Identity Traits", "Communication Preferences", "Operating Principles", "Continuity Notes"];
+    const lines = (existingRaw ?? "").replace(/\r/g, "").split("\n");
+    const headerLines = [];
+    const sectionContent = /* @__PURE__ */ new Map();
+    const order = [];
+    let current = null;
+    for (const line of lines) {
+      const match = line.match(/^##\s+(.+?)\s*$/);
+      if (match) {
+        current = match[1].trim();
+        if (!sectionContent.has(current)) {
+          sectionContent.set(current, []);
+          order.push(current);
+        }
+        continue;
+      }
+      if (!current) {
+        headerLines.push(line);
+      } else {
+        sectionContent.get(current)?.push(line);
+      }
+    }
+    const sections = /* @__PURE__ */ new Map();
+    for (const [name, contentLines] of sectionContent) {
+      sections.set(name, contentLines.join("\n").trim());
+    }
+    const header = headerLines.join("\n").trim() || title;
+    for (const sectionName of sectionOrder) {
+      const previous = sections.get(sectionName)?.trim();
+      const next = updates[sectionName]?.trim();
+      const existing = previous === "- (empty)" ? "" : previous;
+      if (!next) {
+        if (!sections.has(sectionName)) sections.set(sectionName, "");
+        continue;
+      }
+      if (!existing) {
+        sections.set(sectionName, next);
+        continue;
+      }
+      if (existing.includes(next)) continue;
+      if (next.includes(existing)) {
+        sections.set(sectionName, next);
+        continue;
+      }
+      sections.set(sectionName, `${existing}
+
+${next}`);
+    }
+    const finalOrder = [
+      ...sectionOrder.filter((section) => sections.has(section)),
+      ...order.filter((section) => !sectionOrder.includes(section) && sections.has(section))
+    ];
+    const output = [header, ""];
+    for (const name of finalOrder) {
+      output.push(`## ${name}`, "");
+      const body = sections.get(name)?.trim();
+      if (body) output.push(body, "");
+      else output.push("");
+    }
+    return `${output.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}
+`;
+  }
+};
+
 // src/access-service.ts
 var EngramAccessInputError = class extends Error {
 };
@@ -6905,6 +7137,16 @@ var EngramAccessService = class {
     }
     return this._accessRecallSurface;
   }
+  /** AccessIdentityContinuitySurface (access-service decomposition). Lazy; selfDeps live wiring. */
+  _accessIdentityContinuitySurface;
+  get accessIdentityContinuitySurface() {
+    if (!this._accessIdentityContinuitySurface) {
+      this._accessIdentityContinuitySurface = new AccessIdentityContinuitySurface(
+        selfDeps(this)
+      );
+    }
+    return this._accessIdentityContinuitySurface;
+  }
   get briefingEnabled() {
     return this.orchestrator.config.briefing?.enabled === true;
   }
@@ -9037,114 +9279,25 @@ var EngramAccessService = class {
   // ── Parity tools (match OpenClaw plugin feature set) ──────────────────
   // ── Continuity / Identity ──────────────────────────────────────────────
   async continuityAuditGenerate(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
-    }
-    if (!resolveConsolidationCapabilities(this.orchestrator.config).continuityAudit) {
-      return { enabled: false, reason: "Continuity audits are disabled. Enable `continuityAuditEnabled: true`." };
-    }
-    if (!this.orchestrator.compounding) {
-      return { enabled: false, reason: "Compounding engine is disabled. Enable `compoundingEnabled: true`." };
-    }
-    const period = request.period === "monthly" ? "monthly" : "weekly";
-    const key = request.key?.trim() || void 0;
-    const audit = await this.orchestrator.compounding.synthesizeContinuityAudit({ period, key });
-    return { enabled: true, period: audit.period, key: audit.key, reportPath: audit.reportPath };
+    return this.accessIdentityContinuitySurface.continuityAuditGenerate(request);
   }
   async continuityIncidentOpen(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled. Enable `identityContinuityEnabled: true`." };
-    }
-    if (!resolveRecallAuxiliaryCapabilities(this.orchestrator.config).continuityIncidentLogging) {
-      return { enabled: false, reason: "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true`." };
-    }
-    const symptom = request.symptom?.trim();
-    if (!symptom) throw new EngramAccessInputError("symptom is required");
-    const resolvedNs = this.writableNamespaceFor(request.namespace, void 0, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const created = await storage.appendContinuityIncident({
-      symptom,
-      triggerWindow: request.triggerWindow?.trim() || void 0,
-      suspectedCause: request.suspectedCause?.trim() || void 0
-    });
-    return { created: true, incident: created };
+    return this.accessIdentityContinuitySurface.continuityIncidentOpen(request);
   }
   async continuityIncidentClose(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    if (!resolveRecallAuxiliaryCapabilities(this.orchestrator.config).continuityIncidentLogging) {
-      return { enabled: false, reason: "Continuity incident logging is disabled." };
-    }
-    const id = request.id?.trim();
-    if (!id) throw new EngramAccessInputError("id is required");
-    const fixApplied = request.fixApplied?.trim();
-    if (!fixApplied) throw new EngramAccessInputError("fixApplied is required");
-    const verificationResult = request.verificationResult?.trim();
-    if (!verificationResult) throw new EngramAccessInputError("verificationResult is required");
-    const resolvedNs = this.writableNamespaceFor(request.namespace, void 0, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const closed = await storage.closeContinuityIncident(id, {
-      fixApplied,
-      verificationResult,
-      preventiveRule: request.preventiveRule?.trim() || void 0
-    });
-    if (!closed) return { closed: false, reason: `Incident not found: ${id}` };
-    return { closed: true, incident: closed };
+    return this.accessIdentityContinuitySurface.continuityIncidentClose(request);
   }
   async continuityIncidentList(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    const state = request.state === "closed" || request.state === "all" ? request.state : "open";
-    const limit = Math.max(1, Math.min(200, Math.floor(request.limit ?? 25)));
-    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const incidents = await storage.readContinuityIncidents(limit, state);
-    return { state, incidents, count: incidents.length };
+    return this.accessIdentityContinuitySurface.continuityIncidentList(request);
   }
   async continuityLoopAddOrUpdate(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    const resolvedNs = this.writableNamespaceFor(request.namespace, void 0, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const loop = await storage.upsertIdentityImprovementLoop({
-      id: request.id?.trim() || "",
-      cadence: request.cadence,
-      purpose: request.purpose?.trim() || "",
-      status: request.status,
-      killCondition: request.killCondition?.trim() || "",
-      lastReviewed: request.lastReviewed?.trim() || void 0,
-      notes: request.notes?.trim() || void 0
-    });
-    return { saved: true, loop };
+    return this.accessIdentityContinuitySurface.continuityLoopAddOrUpdate(request);
   }
   async continuityLoopReview(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    const id = request.id?.trim();
-    if (!id) throw new EngramAccessInputError("id is required");
-    const resolvedNs = this.writableNamespaceFor(request.namespace, void 0, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const reviewed = await storage.reviewIdentityImprovementLoop(id, {
-      status: request.status,
-      notes: request.notes?.trim() || void 0,
-      reviewedAt: request.reviewedAt?.trim() || void 0
-    });
-    if (!reviewed) return { reviewed: false, reason: `Continuity loop not found: ${id}` };
-    return { reviewed: true, loop: reviewed };
+    return this.accessIdentityContinuitySurface.continuityLoopReview(request);
   }
   async identityAnchorGet(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const anchor = await storage.readIdentityAnchor();
-    if (!anchor) return { found: false, message: "No identity anchor found yet. Use identity_anchor_update to create one." };
-    return { found: true, anchor };
+    return this.accessIdentityContinuitySurface.identityAnchorGet(request);
   }
   /**
    * @deprecated since issue #679 PR 5/5 — the identity-anchor model is
@@ -9155,31 +9308,10 @@ var EngramAccessService = class {
    * compatibility but will be removed in a future major version.
    */
   async identityAnchorUpdate(request) {
-    if (!resolveIdentityContinuityCapabilities(this.orchestrator.config).identityContinuity) {
-      return { enabled: false, reason: "Identity continuity is disabled." };
-    }
-    const updates = {
-      "Identity Traits": request.identityTraits?.trim() || void 0,
-      "Communication Preferences": request.communicationPreferences?.trim() || void 0,
-      "Operating Principles": request.operatingPrinciples?.trim() || void 0,
-      "Continuity Notes": request.continuityNotes?.trim() || void 0
-    };
-    const hasUpdate = Object.values(updates).some((v) => typeof v === "string" && v.length > 0);
-    if (!hasUpdate) throw new EngramAccessInputError("At least one section field is required.");
-    const resolvedNs = this.writableNamespaceFor(request.namespace, void 0, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const existing = await storage.readIdentityAnchor();
-    const merged = this.mergeIdentityAnchorSections(existing, updates);
-    await storage.writeIdentityAnchor(merged);
-    const updatedSections = Object.entries(updates).filter(([, v]) => typeof v === "string" && v.length > 0).map(([name]) => name);
-    return { updated: true, sections: updatedSections, anchor: merged };
+    return this.accessIdentityContinuitySurface.identityAnchorUpdate(request);
   }
   async memoryIdentity(request) {
-    const resolvedNs = this.resolveReadableNamespace(request.namespace, request.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNs);
-    const identity = await storage.readIdentityReflections();
-    if (!identity) return { found: false, message: "No identity reflections found." };
-    return { found: true, identity };
+    return this.accessIdentityContinuitySurface.memoryIdentity(request);
   }
   // ── Work Layer ──────────────────────────────────────────────────────────
   async workTask(request) {
@@ -9309,65 +9441,6 @@ var EngramAccessService = class {
       expectedGuidelineVersion: request.expectedGuidelineVersion
     });
   }
-  /** Conservative identity anchor section merge (matches tools.ts mergeIdentityAnchor logic). */
-  mergeIdentityAnchorSections(existingRaw, updates) {
-    const TITLE = "# Identity Continuity Anchor";
-    const SECTION_ORDER = ["Identity Traits", "Communication Preferences", "Operating Principles", "Continuity Notes"];
-    const lines = (existingRaw ?? "").replace(/\r/g, "").split("\n");
-    const headerLines = [];
-    const sectionContent = /* @__PURE__ */ new Map();
-    const order = [];
-    let current = null;
-    for (const line of lines) {
-      const m = line.match(/^##\s+(.+?)\s*$/);
-      if (m) {
-        current = m[1].trim();
-        if (!sectionContent.has(current)) {
-          sectionContent.set(current, []);
-          order.push(current);
-        }
-        continue;
-      }
-      if (!current) {
-        headerLines.push(line);
-      } else {
-        sectionContent.get(current)?.push(line);
-      }
-    }
-    const sections = /* @__PURE__ */ new Map();
-    for (const [name, cLines] of sectionContent) sections.set(name, cLines.join("\n").trim());
-    const header = headerLines.join("\n").trim() || TITLE;
-    for (const sectionName of SECTION_ORDER) {
-      const prev = sections.get(sectionName)?.trim();
-      const next = updates[sectionName]?.trim();
-      const existing = prev === "- (empty)" ? "" : prev;
-      if (!next) {
-        if (!sections.has(sectionName)) sections.set(sectionName, "");
-        continue;
-      }
-      if (!existing) {
-        sections.set(sectionName, next);
-        continue;
-      }
-      if (existing.includes(next)) continue;
-      if (next.includes(existing)) {
-        sections.set(sectionName, next);
-        continue;
-      }
-      sections.set(sectionName, `${existing}
-
-${next}`);
-    }
-    const finalOrder = [...SECTION_ORDER.filter((s) => sections.has(s)), ...order.filter((s) => !SECTION_ORDER.includes(s) && sections.has(s))];
-    const out = [header, ""];
-    for (const name of finalOrder) {
-      out.push(`## ${name}`, "");
-      const body = sections.get(name)?.trim();
-      if (body) out.push(body, "");
-      else out.push("");
-    }
-    return out.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-  }
   // ── Memory search & debug ─────────────────────────────────────────────
   async memorySearch(request) {
     const { query, namespace, maxResults, principal } = request;
@@ -10836,6 +10909,7 @@ export {
   qmdCollectionPathParts,
   QmdResultResolver,
   AccessRecallSurface,
+  AccessIdentityContinuitySurface,
   EngramAccessInputError,
   ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
   buildProjectedGovernanceProposedActions,
@@ -10844,4 +10918,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-DWDDQLSZ.js.map
+//# sourceMappingURL=chunk-6C6BBBCI.js.map