@remnic/core 9.3.735 → 9.3.737

package/dist/{chunk-FLCYY5JX.js → chunk-PB5YON2G.js}

@@ -508,7 +508,7 @@ import {
 // src/orchestrator.ts
 import path4 from "path";
 import os2 from "os";
-import { createHash, randomBytes } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   lstat,
@@ -1436,6 +1436,509 @@ var LifecyclePolicyCoordinator = class {
   }
 };
 
+// src/orchestration/entity-synthesis-coordinator.ts
+import { createHash } from "crypto";
+function dedupeEntitySynthesisEvidenceEntries(entries) {
+  const dedupedEvidenceEntries = [];
+  const evidenceByFact = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const normalizedFact = entry.text.trim();
+    if (!normalizedFact) continue;
+    const existing = evidenceByFact.get(normalizedFact);
+    if (!existing) {
+      evidenceByFact.set(normalizedFact, { newest: entry, oldest: entry });
+      continue;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.newest.timestamp) > 0) {
+      existing.newest = entry;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.oldest.timestamp) < 0) {
+      existing.oldest = entry;
+    }
+  }
+  for (const { newest, oldest } of evidenceByFact.values()) {
+    dedupedEvidenceEntries.push(newest);
+    const newestKey = [
+      newest.timestamp,
+      newest.source ?? "",
+      newest.sessionKey ?? "",
+      newest.principal ?? "",
+      newest.text
+    ].join("\0");
+    const oldestKey = [
+      oldest.timestamp,
+      oldest.source ?? "",
+      oldest.sessionKey ?? "",
+      oldest.principal ?? "",
+      oldest.text
+    ].join("\0");
+    if (oldestKey !== newestKey) {
+      dedupedEvidenceEntries.push(oldest);
+    }
+  }
+  return dedupedEvidenceEntries;
+}
+function flattenStructuredSectionEvidence(sections) {
+  return (sections ?? []).flatMap(
+    (section) => section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0).map((fact) => ({
+      timestamp: "",
+      text: fact,
+      source: `section:${section.title}`
+    }))
+  );
+}
+function fingerprintEntitySynthesisEvidence(entity) {
+  const fingerprint = createHash("sha256");
+  const timelineEntries = entity.timeline.map((entry) => [
+    entry.timestamp,
+    entry.source ?? "",
+    entry.sessionKey ?? "",
+    entry.principal ?? "",
+    entry.text
+  ].join("\0")).sort();
+  const timelineEntrySeparator = String.fromCharCode(1);
+  const structuredFactsSeparator = String.fromCharCode(2);
+  fingerprint.update(timelineEntries.join(timelineEntrySeparator));
+  fingerprint.update(structuredFactsSeparator);
+  fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
+  return fingerprint.digest("hex");
+}
+var EntitySynthesisCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /**
+   * Process up to `maxEntities` entities from the synthesis queue for the
+   * given namespace. Returns the number of entities whose synthesis was
+   * successfully refreshed.
+   */
+  async processQueue(namespace, maxEntities = 5) {
+    const { config } = this.deps;
+    if (!config.entitySummaryEnabled || maxEntities <= 0 || config.entitySynthesisMaxTokens <= 0) return 0;
+    const storage = await this.deps.getStorage(namespace);
+    const queued = await storage.refreshEntitySynthesisQueue();
+    let processed = 0;
+    let attempted = 0;
+    for (const entityName of queued) {
+      if (attempted >= maxEntities) break;
+      attempted += 1;
+      try {
+        const raw = await storage.readEntity(entityName);
+        if (!raw) continue;
+        const entity = parseEntityFile(raw, config.entitySchemas);
+        const previousSynthesis = entity.synthesis || entity.summary || "";
+        const sortedTimelineEntries = entity.timeline.slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const newerTimelineEntries = sortedTimelineEntries.filter(
+          (entry) => !entity.synthesisUpdatedAt || compareEntityTimestamps(entry.timestamp, entity.synthesisUpdatedAt) > 0
+        );
+        const appendedTimelineEntries = entity.synthesisTimelineCount === void 0 ? [] : entity.timeline.slice(Math.max(0, entity.synthesisTimelineCount));
+        const structuredEvidenceEntries = flattenStructuredSectionEvidence(entity.structuredSections);
+        const structuredEvidenceCount = structuredEvidenceEntries.length;
+        const structuredEvidenceDigest = fingerprintEntityStructuredFacts(entity);
+        const structuredEvidenceDrifted = structuredEvidenceDigest !== (entity.synthesisStructuredFactDigest?.trim() || void 0);
+        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === void 0 || structuredEvidenceDrifted ? structuredEvidenceEntries : structuredEvidenceEntries.slice(Math.max(0, entity.synthesisStructuredFactCount));
+        const candidateEvidenceEntries = [
+          ...newerTimelineEntries,
+          ...appendedTimelineEntries,
+          ...appendedStructuredEvidenceEntries
+        ].slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const dedupedEvidenceEntries = dedupeEntitySynthesisEvidenceEntries(
+          candidateEvidenceEntries.length > 0 ? candidateEvidenceEntries : [...sortedTimelineEntries, ...structuredEvidenceEntries]
+        );
+        const chronologicalEvidenceEntries = dedupedEvidenceEntries.slice().sort((left, right) => compareEntityTimestamps(left.timestamp, right.timestamp));
+        if (chronologicalEvidenceEntries.length === 0) continue;
+        const latestEvidenceTimestamp = chronologicalEvidenceEntries.slice().reverse().map((entry) => entry.timestamp?.trim() || void 0).find((timestamp) => Boolean(timestamp));
+        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || void 0;
+        const nextSynthesisUpdatedAt = compareEntityTimestamps(
+          latestEvidenceTimestamp,
+          previousSynthesisUpdatedAt
+        ) >= 0 ? latestEvidenceTimestamp : previousSynthesisUpdatedAt;
+        const evidenceBatches = [];
+        for (let index = 0; index < chronologicalEvidenceEntries.length; index += 8) {
+          evidenceBatches.push(chronologicalEvidenceEntries.slice(index, index + 8));
+        }
+        let nextSynthesis = previousSynthesis;
+        let batchFailed = false;
+        for (const evidenceEntries of evidenceBatches) {
+          const evidenceText = evidenceEntries.map((entry) => {
+            const sectionTitle = entry.source?.startsWith("section:") ? entry.source.slice("section:".length) : "";
+            const metadata = [
+              `timestamp=${entry.timestamp}`,
+              sectionTitle ? `section=${sectionTitle}` : entry.source ? `source=${entry.source}` : "",
+              entry.sessionKey ? `session=${entry.sessionKey}` : "",
+              entry.principal ? `principal=${entry.principal}` : ""
+            ].filter(Boolean).join(", ");
+            return `- ${metadata}: ${entry.text}`;
+          }).join("\n");
+          const response = await this.deps.fastChatCompletion(
+            [
+              {
+                role: "system",
+                content: "Rewrite the entity synthesis as compact current truth. Preserve uncertainty when evidence conflicts. Return plain text only."
+              },
+              {
+                role: "user",
+                content: [
+                  `Entity: ${entity.name} (${entity.type})`,
+                  nextSynthesis ? `Previous synthesis:
+${nextSynthesis}` : "Previous synthesis: none",
+                  `New evidence:
+${evidenceText}`
+                ].join("\n\n")
+              }
+            ],
+            {
+              temperature: 0.2,
+              maxTokens: config.entitySynthesisMaxTokens,
+              operation: "entity_summary",
+              priority: "background"
+            }
+          );
+          const synthesis = response?.content?.trim().replace(/^["']|["']$/g, "");
+          const maxSynthesisChars = Math.max(2e3, config.entitySynthesisMaxTokens * 8);
+          if (!synthesis || synthesis.length < 10 || synthesis.length > maxSynthesisChars) {
+            batchFailed = true;
+            break;
+          }
+          nextSynthesis = synthesis;
+        }
+        if (batchFailed || nextSynthesis.length === 0) continue;
+        const latestRaw = await storage.readEntity(entityName);
+        if (!latestRaw) continue;
+        const latestEntity = parseEntityFile(latestRaw, config.entitySchemas);
+        if (fingerprintEntitySynthesisEvidence(latestEntity) !== fingerprintEntitySynthesisEvidence(entity)) {
+          continue;
+        }
+        await storage.updateEntitySynthesis(entityName, nextSynthesis, {
+          entityUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          synthesisStructuredFactDigest: structuredEvidenceDigest,
+          synthesisStructuredFactCount: structuredEvidenceCount,
+          synthesisTimelineCount: entity.timeline.length,
+          updatedAt: nextSynthesisUpdatedAt
+        });
+        processed += 1;
+      } catch (err) {
+        log.debug(`entity synthesis refresh failed for ${entityName}: ${err}`);
+      }
+    }
+    return processed;
+  }
+};
+
+// src/orchestration/recall-result-formatter.ts
+function hasIdentityRecoveryIntent(prompt) {
+  const text = typeof prompt === "string" ? prompt.toLowerCase() : "";
+  if (!text) return false;
+  return /\b(identity|continuity|recover(?:y|ing|ed)?|incident|drift|restore|regress(?:ion|ed|ing)?)\b/i.test(
+    text
+  );
+}
+function resolveEffectiveIdentityInjectionMode(options) {
+  if (options.configuredMode === "recovery_only" && !hasIdentityRecoveryIntent(options.prompt)) {
+    return { mode: "recovery_only", shouldInject: false };
+  }
+  if (options.recallMode === "minimal" && options.configuredMode === "full") {
+    return { mode: "minimal", shouldInject: true };
+  }
+  return { mode: options.configuredMode, shouldInject: true };
+}
+var RecallResultFormatter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  // ── QMD results (memory handles + epistemic hedge) ──────────────────────
+  formatQmdResults(title, results, sessionKey, trustByPath) {
+    const handleByIndex = buildHandleIndexForResults(
+      results,
+      this.config.recallMemoryHandles === true && sessionKey != null
+    );
+    const renderHedge = this.config.trustScoreEpistemicRendering && trustByPath !== null && trustByPath !== void 0;
+    const hedgeMap = renderHedge ? trustByPath : null;
+    const lines = results.map((r, i) => {
+      const snippet = r.snippet ? r.snippet.slice(0, 500).replace(/\n/g, " ") : "(no preview)";
+      const source = typeof r.line === "number" ? `${r.path}:${r.line}` : r.path;
+      const head = `[${i + 1}] ${source} (score: ${r.score.toFixed(3)})
+${snippet}`;
+      const handle = handleByIndex.get(i);
+      const hedged = head.replace(/\s+$/, "");
+      const withHandle = handle ? `${hedged} ${handle}` : hedged;
+      if (hedgeMap) {
+        const item = hedgeMap.get(r.path);
+        if (item) {
+          const hedge = renderEpistemicHedge(item.trust);
+          if (hedge.length > 0) return `${withHandle} ${hedge}`;
+        }
+      }
+      return withHandle;
+    });
+    return `## ${title}
+
+${lines.join("\n\n")}`;
+  }
+  // ── Specialized recall result formatters ────────────────────────────────
+  formatObjectiveStateResults(results) {
+    const lines = results.map(({ snapshot }, index) => {
+      const parts = [
+        snapshot.recordedAt.replace("T", " ").slice(0, 16),
+        `${snapshot.kind}/${snapshot.changeKind}`
+      ];
+      if (snapshot.outcome) parts.push(snapshot.outcome);
+      const header = `[${index + 1}] ${parts.join(" | ")} | ${snapshot.scope}`;
+      const detailParts = [snapshot.summary];
+      if (snapshot.command) detailParts.push(`command: ${snapshot.command}`);
+      else if (snapshot.toolName)
+        detailParts.push(`tool: ${snapshot.toolName}`);
+      return `${header}
+${detailParts.join(" | ")}`;
+    });
+    return `## Objective State
+
+${lines.join("\n\n")}`;
+  }
+  formatCausalTrajectoryResults(results) {
+    const lines = results.map(({ record, matchedFields }, index) => {
+      const header = [
+        `[${index + 1}] ${record.recordedAt.replace("T", " ").slice(0, 16)}`,
+        record.outcomeKind
+      ].join(" | ");
+      const details = [
+        `goal: ${record.goal}`,
+        `action: ${record.actionSummary}`,
+        `observation: ${record.observationSummary}`,
+        `outcome: ${record.outcomeSummary}`
+      ];
+      if (record.followUpSummary)
+        details.push(`follow-up: ${record.followUpSummary}`);
+      if (matchedFields.length > 0)
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Causal Trajectories
+
+${lines.join("\n\n")}`;
+  }
+  formatTrustZoneResults(results) {
+    const lines = results.map(({ record, matchedFields }, index) => {
+      const header = [
+        `[${index + 1}] ${record.recordedAt.replace("T", " ").slice(0, 16)}`,
+        record.zone,
+        record.kind
+      ].join(" | ");
+      const details = [
+        record.summary,
+        `provenance: ${record.provenance.sourceClass}`
+      ];
+      if (record.entityRefs && record.entityRefs.length > 0) {
+        details.push(`entities: ${record.entityRefs.join(", ")}`);
+      }
+      if (record.tags && record.tags.length > 0) {
+        details.push(`tags: ${record.tags.join(", ")}`);
+      }
+      if (matchedFields.length > 0) {
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      }
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Trust Zones
+
+${lines.join("\n\n")}`;
+  }
+  formatHarmonicRetrievalResults(results) {
+    const lines = results.map(
+      ({ node, matchedAnchors, matchedFields, nodeScore, anchorScore }, index) => {
+        const header = [
+          `[${index + 1}] ${node.recordedAt.replace("T", " ").slice(0, 16)}`,
+          `${node.kind}/${node.abstractionLevel}`,
+          node.sessionKey
+        ].join(" | ");
+        const details = [
+          node.title,
+          node.summary,
+          `scores: node=${nodeScore.toFixed(1)} anchor=${anchorScore.toFixed(1)}`
+        ];
+        if (matchedAnchors.length > 0) {
+          details.push(
+            `anchors: ${matchedAnchors.map((anchor) => `${anchor.anchorType}:${anchor.anchorValue}`).join("; ")}`
+          );
+        }
+        if (matchedFields.length > 0) {
+          details.push(`matched: ${matchedFields.join(", ")}`);
+        }
+        return `${header}
+${details.join("\n")}`;
+      }
+    );
+    return `## Harmonic Retrieval
+
+${lines.join("\n\n")}`;
+  }
+  formatWorkProductResults(results) {
+    const lines = results.map(({ entry, matchedFields }, index) => {
+      const header = [
+        `[${index + 1}] ${entry.recordedAt.replace("T", " ").slice(0, 16)}`,
+        `${entry.kind}/${entry.action}`,
+        entry.sessionKey
+      ].join(" | ");
+      const details = [entry.summary, `scope: ${entry.scope}`];
+      if (entry.artifactPath) details.push(`artifact: ${entry.artifactPath}`);
+      if (entry.tags && entry.tags.length > 0)
+        details.push(`tags: ${entry.tags.join(", ")}`);
+      if (matchedFields.length > 0)
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Work Products
+
+${lines.join("\n\n")}`;
+  }
+  formatVerifiedEpisodeResults(results) {
+    const lines = results.map(
+      ({ box, verifiedEpisodeCount, matchedFields }, index) => {
+        const header = [
+          `[${index + 1}] ${box.sealedAt.replace("T", " ").slice(0, 16)}`,
+          box.traceId ? `trace:${box.traceId.slice(0, 12)}` : "trace:none"
+        ].join(" | ");
+        const details = [
+          box.goal ?? `topics: ${box.topics.join(", ")}`,
+          `verified episodes: ${verifiedEpisodeCount}`
+        ];
+        if (box.toolsUsed && box.toolsUsed.length > 0) {
+          details.push(`tools: ${box.toolsUsed.join(", ")}`);
+        }
+        if (matchedFields.length > 0) {
+          details.push(`matched: ${matchedFields.join(", ")}`);
+        }
+        return `${header}
+${details.join("\n")}`;
+      }
+    );
+    return `## Verified Episodes
+
+${lines.join("\n\n")}`;
+  }
+  formatVerifiedSemanticRuleResults(results) {
+    const lines = results.map(
+      ({
+        rule,
+        sourceMemoryId,
+        verificationStatus,
+        effectiveConfidence,
+        matchedFields
+      }, index) => {
+        const header = [
+          `[${index + 1}] ${rule.frontmatter.updated.replace("T", " ").slice(0, 16)}`,
+          verificationStatus,
+          `confidence:${effectiveConfidence.toFixed(2)}`
+        ].join(" | ");
+        const details = [rule.content, `source memory: ${sourceMemoryId}`];
+        if (matchedFields.length > 0) {
+          details.push(`matched: ${matchedFields.join(", ")}`);
+        }
+        return `${header}
+${details.join("\n")}`;
+      }
+    );
+    return `## Verified Rules
+
+${lines.join("\n\n")}`;
+  }
+  // ── Identity continuity helpers ─────────────────────────────────────────
+  summarizeIdentityText(raw, maxLines, maxChars) {
+    const lines = raw.replace(/\r/g, "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+    const compact = lines.slice(0, Math.max(1, maxLines)).join(" ");
+    if (compact.length <= maxChars) return compact;
+    return `${compact.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+  }
+  formatOpenIncidentLine(incident, includeDetails) {
+    const base = `[${incident.id}] ${incident.symptom.trim()}`;
+    if (!includeDetails) return `- ${base}`;
+    const parts = [base];
+    if (incident.suspectedCause)
+      parts.push(`cause: ${incident.suspectedCause.trim()}`);
+    if (incident.triggerWindow)
+      parts.push(`window: ${incident.triggerWindow.trim()}`);
+    return `- ${parts.join(" | ")}`;
+  }
+  trimIdentitySection(content, maxChars) {
+    if (maxChars <= 0) return { text: "", truncated: false };
+    if (content.length <= maxChars) return { text: content, truncated: false };
+    const suffix = "\n\n...(identity continuity trimmed)";
+    if (maxChars <= suffix.length) {
+      return { text: content.slice(0, maxChars), truncated: true };
+    }
+    const headroom = Math.max(0, maxChars - suffix.length);
+    return { text: `${content.slice(0, headroom)}${suffix}`, truncated: true };
+  }
+  async buildIdentityContinuitySection(options) {
+    if (!resolveIdentityContinuityCapabilities(this.config).identityContinuity) return null;
+    if (this.config.identityMaxInjectChars <= 0) return null;
+    const resolved = resolveEffectiveIdentityInjectionMode({
+      configuredMode: this.config.identityInjectionMode,
+      recallMode: options.recallMode,
+      prompt: options.prompt
+    });
+    if (!resolved.shouldInject) return null;
+    const [anchorRaw, loopsRaw, incidents] = await Promise.all([
+      options.storage.readIdentityAnchor(),
+      options.storage.readIdentityImprovementLoops(),
+      options.storage.readContinuityIncidents(200)
+    ]);
+    const openIncidents = incidents.filter(
+      (incident) => incident.state === "open"
+    );
+    const lines = [];
+    if (resolved.mode === "full") {
+      lines.push("## Identity Continuity");
+      if (anchorRaw && anchorRaw.trim().length > 0) {
+        lines.push("", "### Anchor", "", anchorRaw.trim());
+      }
+      if (loopsRaw && loopsRaw.trim().length > 0) {
+        lines.push("", "### Improvement Loops", "", loopsRaw.trim());
+      }
+      lines.push("", "### Open Incidents", "");
+      if (openIncidents.length === 0) {
+        lines.push("- none");
+      } else {
+        lines.push(
+          ...openIncidents.slice(0, 5).map((incident) => this.formatOpenIncidentLine(incident, true))
+        );
+      }
+    } else {
+      const anchorSummary = anchorRaw ? this.summarizeIdentityText(anchorRaw, 3, 320) : "";
+      const loopsSummary = loopsRaw ? this.summarizeIdentityText(loopsRaw, 2, 240) : "";
+      lines.push("## Identity Continuity Signals", "");
+      if (anchorSummary) lines.push(`- anchor: ${anchorSummary}`);
+      if (loopsSummary) lines.push(`- loops: ${loopsSummary}`);
+      if (openIncidents.length === 0) {
+        lines.push("- incidents: 0 open");
+      } else {
+        lines.push(`- incidents: ${openIncidents.length} open`);
+        lines.push(
+          ...openIncidents.slice(0, 2).map((incident) => this.formatOpenIncidentLine(incident, false))
+        );
+      }
+    }
+    const body = lines.join("\n").trim();
+    if (!body) return null;
+    const { text, truncated } = this.trimIdentitySection(
+      body,
+      this.config.identityMaxInjectChars
+    );
+    if (!text) return null;
+    return {
+      section: text,
+      mode: resolved.mode,
+      injectedChars: text.length,
+      truncated
+    };
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -2792,71 +3295,6 @@ var BulkImportBatchPartialFailureError = class extends Error {
     this.originalError = originalError;
   }
 };
-function dedupeEntitySynthesisEvidenceEntries(entries) {
-  const dedupedEvidenceEntries = [];
-  const evidenceByFact = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const normalizedFact = entry.text.trim();
-    if (!normalizedFact) continue;
-    const existing = evidenceByFact.get(normalizedFact);
-    if (!existing) {
-      evidenceByFact.set(normalizedFact, { newest: entry, oldest: entry });
-      continue;
-    }
-    if (compareEntityTimestamps(entry.timestamp, existing.newest.timestamp) > 0) {
-      existing.newest = entry;
-    }
-    if (compareEntityTimestamps(entry.timestamp, existing.oldest.timestamp) < 0) {
-      existing.oldest = entry;
-    }
-  }
-  for (const { newest, oldest } of evidenceByFact.values()) {
-    dedupedEvidenceEntries.push(newest);
-    const newestKey = [
-      newest.timestamp,
-      newest.source ?? "",
-      newest.sessionKey ?? "",
-      newest.principal ?? "",
-      newest.text
-    ].join("\0");
-    const oldestKey = [
-      oldest.timestamp,
-      oldest.source ?? "",
-      oldest.sessionKey ?? "",
-      oldest.principal ?? "",
-      oldest.text
-    ].join("\0");
-    if (oldestKey !== newestKey) {
-      dedupedEvidenceEntries.push(oldest);
-    }
-  }
-  return dedupedEvidenceEntries;
-}
-function flattenStructuredSectionEvidence(sections) {
-  return (sections ?? []).flatMap(
-    (section) => section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0).map((fact) => ({
-      timestamp: "",
-      text: fact,
-      source: `section:${section.title}`
-    }))
-  );
-}
-function fingerprintEntitySynthesisEvidence(entity) {
-  const fingerprint = createHash("sha256");
-  const timelineEntries = entity.timeline.map((entry) => [
-    entry.timestamp,
-    entry.source ?? "",
-    entry.sessionKey ?? "",
-    entry.principal ?? "",
-    entry.text
-  ].join("\0")).sort();
-  const timelineEntrySeparator = String.fromCharCode(1);
-  const structuredFactsSeparator = String.fromCharCode(2);
-  fingerprint.update(timelineEntries.join(timelineEntrySeparator));
-  fingerprint.update(structuredFactsSeparator);
-  fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
-  return fingerprint.digest("hex");
-}
 function mapRecallSourceToXrayServedBy(source) {
   switch (source) {
     case "recent_scan":
@@ -3041,7 +3479,7 @@ function defaultWorkspaceDir() {
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const hash = createHash("sha256").update(sessionKey).digest("hex").slice(0, 12);
+  const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
   return `${readable}-${hash}`;
 }
 function latestSourceValidAtFromTurns(turns) {
@@ -3286,22 +3724,6 @@ async function resolveRecallModeDecisionAsync(options) {
     plannerHeuristicMode: planned.heuristicMode
   };
 }
-function hasIdentityRecoveryIntent(prompt) {
-  const text = typeof prompt === "string" ? prompt.toLowerCase() : "";
-  if (!text) return false;
-  return /\b(identity|continuity|recover(?:y|ing|ed)?|incident|drift|restore|regress(?:ion|ed|ing)?)\b/i.test(
-    text
-  );
-}
-function resolveEffectiveIdentityInjectionMode(options) {
-  if (options.configuredMode === "recovery_only" && !hasIdentityRecoveryIntent(options.prompt)) {
-    return { mode: "recovery_only", shouldInject: false };
-  }
-  if (options.recallMode === "minimal" && options.configuredMode === "full") {
-    return { mode: "minimal", shouldInject: true };
-  }
-  return { mode: options.configuredMode, shouldInject: true };
-}
 function computeArtifactCandidateFetchLimit(targetCount) {
   const cappedTarget = Math.max(0, targetCount);
   if (cappedTarget === 0) return 0;
@@ -3597,6 +4019,7 @@ var Orchestrator = class _Orchestrator {
   compressionGuidelineCoordinator;
   semanticConsolidationCoordinator;
   lifecyclePolicyCoordinator;
+  entitySynthesisCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -3685,6 +4108,11 @@ var Orchestrator = class _Orchestrator {
    * hands it to `enqueue`.
    */
   extractionQueueCoordinator;
+  /**
+   * Issue #1526: recall result formatting + identity continuity section moved
+   * to RecallResultFormatter.
+   */
+  recallResultFormatter;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -4390,6 +4818,7 @@ var Orchestrator = class _Orchestrator {
       namespaceCatalog: this.namespaceCatalog
     });
     this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+    this.recallResultFormatter = new RecallResultFormatter(this.config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
       getFaiss: () => this.conversationFaiss
@@ -4427,6 +4856,11 @@ var Orchestrator = class _Orchestrator {
       getStorage: () => this.storage,
       fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
     });
+    this.entitySynthesisCoordinator = new EntitySynthesisCoordinator({
+      config,
+      getStorage: (namespace) => this.getStorage(namespace),
+      fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -4571,7 +5005,7 @@ var Orchestrator = class _Orchestrator {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash2("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -5440,114 +5874,7 @@ ${doc.content}` : doc.content,
     return this.storageRouter.storageFor(ns);
   }
   async processEntitySynthesisQueue(namespace, maxEntities = 5) {
-    if (!this.config.entitySummaryEnabled || maxEntities <= 0 || this.config.entitySynthesisMaxTokens <= 0) return 0;
-    const storage = await this.getStorage(namespace);
-    const queued = await storage.refreshEntitySynthesisQueue();
-    let processed = 0;
-    let attempted = 0;
-    for (const entityName of queued) {
-      if (attempted >= maxEntities) break;
-      attempted += 1;
-      try {
-        const raw = await storage.readEntity(entityName);
-        if (!raw) continue;
-        const entity = parseEntityFile(raw, this.config.entitySchemas);
-        const previousSynthesis = entity.synthesis || entity.summary || "";
-        const sortedTimelineEntries = entity.timeline.slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
-        const newerTimelineEntries = sortedTimelineEntries.filter(
-          (entry) => !entity.synthesisUpdatedAt || compareEntityTimestamps(entry.timestamp, entity.synthesisUpdatedAt) > 0
-        );
-        const appendedTimelineEntries = entity.synthesisTimelineCount === void 0 ? [] : entity.timeline.slice(Math.max(0, entity.synthesisTimelineCount));
-        const structuredEvidenceEntries = flattenStructuredSectionEvidence(entity.structuredSections);
-        const structuredEvidenceCount = structuredEvidenceEntries.length;
-        const structuredEvidenceDigest = fingerprintEntityStructuredFacts(entity);
-        const structuredEvidenceDrifted = structuredEvidenceDigest !== (entity.synthesisStructuredFactDigest?.trim() || void 0);
-        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === void 0 || structuredEvidenceDrifted ? structuredEvidenceEntries : structuredEvidenceEntries.slice(Math.max(0, entity.synthesisStructuredFactCount));
-        const candidateEvidenceEntries = [
-          ...newerTimelineEntries,
-          ...appendedTimelineEntries,
-          ...appendedStructuredEvidenceEntries
-        ].slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
-        const dedupedEvidenceEntries = dedupeEntitySynthesisEvidenceEntries(
-          candidateEvidenceEntries.length > 0 ? candidateEvidenceEntries : [...sortedTimelineEntries, ...structuredEvidenceEntries]
-        );
-        const chronologicalEvidenceEntries = dedupedEvidenceEntries.slice().sort((left, right) => compareEntityTimestamps(left.timestamp, right.timestamp));
-        if (chronologicalEvidenceEntries.length === 0) continue;
-        const latestEvidenceTimestamp = chronologicalEvidenceEntries.slice().reverse().map((entry) => entry.timestamp?.trim() || void 0).find((timestamp) => Boolean(timestamp));
-        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || void 0;
-        const nextSynthesisUpdatedAt = compareEntityTimestamps(
-          latestEvidenceTimestamp,
-          previousSynthesisUpdatedAt
-        ) >= 0 ? latestEvidenceTimestamp : previousSynthesisUpdatedAt;
-        const evidenceBatches = [];
-        for (let index = 0; index < chronologicalEvidenceEntries.length; index += 8) {
-          evidenceBatches.push(chronologicalEvidenceEntries.slice(index, index + 8));
-        }
-        let nextSynthesis = previousSynthesis;
-        let batchFailed = false;
-        for (const evidenceEntries of evidenceBatches) {
-          const evidenceText = evidenceEntries.map((entry) => {
-            const sectionTitle = entry.source?.startsWith("section:") ? entry.source.slice("section:".length) : "";
-            const metadata = [
-              `timestamp=${entry.timestamp}`,
-              sectionTitle ? `section=${sectionTitle}` : entry.source ? `source=${entry.source}` : "",
-              entry.sessionKey ? `session=${entry.sessionKey}` : "",
-              entry.principal ? `principal=${entry.principal}` : ""
-            ].filter(Boolean).join(", ");
-            return `- ${metadata}: ${entry.text}`;
-          }).join("\n");
-          const response = await this.fastChatCompletion(
-            [
-              {
-                role: "system",
-                content: "Rewrite the entity synthesis as compact current truth. Preserve uncertainty when evidence conflicts. Return plain text only."
-              },
-              {
-                role: "user",
-                content: [
-                  `Entity: ${entity.name} (${entity.type})`,
-                  nextSynthesis ? `Previous synthesis:
-${nextSynthesis}` : "Previous synthesis: none",
-                  `New evidence:
-${evidenceText}`
-                ].join("\n\n")
-              }
-            ],
-            {
-              temperature: 0.2,
-              maxTokens: this.config.entitySynthesisMaxTokens,
-              operation: "entity_summary",
-              priority: "background"
-            }
-          );
-          const synthesis = response?.content?.trim().replace(/^["']|["']$/g, "");
-          const maxSynthesisChars = Math.max(2e3, this.config.entitySynthesisMaxTokens * 8);
-          if (!synthesis || synthesis.length < 10 || synthesis.length > maxSynthesisChars) {
-            batchFailed = true;
-            break;
-          }
-          nextSynthesis = synthesis;
-        }
-        if (batchFailed || nextSynthesis.length === 0) continue;
-        const latestRaw = await storage.readEntity(entityName);
-        if (!latestRaw) continue;
-        const latestEntity = parseEntityFile(latestRaw, this.config.entitySchemas);
-        if (fingerprintEntitySynthesisEvidence(latestEntity) !== fingerprintEntitySynthesisEvidence(entity)) {
-          continue;
-        }
-        await storage.updateEntitySynthesis(entityName, nextSynthesis, {
-          entityUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          synthesisStructuredFactDigest: structuredEvidenceDigest,
-          synthesisStructuredFactCount: structuredEvidenceCount,
-          synthesisTimelineCount: entity.timeline.length,
-          updatedAt: nextSynthesisUpdatedAt
-        });
-        processed += 1;
-      } catch (err) {
-        log.debug(`entity synthesis refresh failed for ${entityName}: ${err}`);
-      }
-    }
-    return processed;
+    return this.entitySynthesisCoordinator.processQueue(namespace, maxEntities);
   }
   async generateDaySummary(memories) {
     if (this.initPromise) {
@@ -6716,7 +7043,7 @@ ${r.snippet.trim()}
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash("sha256").update(prompt).digest("hex"),
+        queryHash: createHash2("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -7045,7 +7372,7 @@ ${r.snippet.trim()}
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
-        queryHash: createHash("sha256").update(options.prompt).digest("hex"),
+        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
         queryLength: options.prompt.length,
         namespaces: options.recallNamespaces,
         seedCount: totalSeedCount,
@@ -7387,8 +7714,8 @@ ${r.snippet.trim()}
         timings,
         logger: log
       });
-      const promptHash = createHash("sha256").update(prompt).digest("hex");
-      const traceId = createHash("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash2("sha256").update(prompt).digest("hex");
+      const traceId = createHash2("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
@@ -7397,7 +7724,7 @@ ${r.snippet.trim()}
         cronConversationRecallMode: this.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash2("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.currentPolicyVersion();
       let impressionRecorded = false;
       let recallSource = "none";
@@ -11437,7 +11764,7 @@ _Context: ${topQuestion.context}_`
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash2("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -11687,7 +12014,7 @@ _Context: ${topQuestion.context}_`
   buildExtractionFingerprint(turns, bufferKey) {
     const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
     if (!normalized) return null;
-    return createHash("sha256").update(`${bufferKey}
+    return createHash2("sha256").update(`${bufferKey}
 ${normalized}`).digest("hex");
   }
   shouldQueueExtraction(turns, options = {}) {
@@ -14337,306 +14664,58 @@ ${reflectionsContent.trim()}
       const patternsSection = [
         "## Learned Patterns (consolidated from reflections, " + (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ")",
         "",
-        ...result.learnedPatterns.map((p) => `- ${p}`),
-        ""
-      ].join("\n");
-      const newContent = staticHeader + "\n\n" + patternsSection + "\n";
-      await storage.writeIdentity(
-        this.config.workspaceDir,
-        newContent,
-        identityNamespace
-      );
-      await storage.writeIdentityReflections("");
-      log.info(
-        `IDENTITY(${namespace}) consolidated: ${identityContent.length} \u2192 ${newContent.length} chars, ${result.learnedPatterns.length} patterns`
-      );
-    }
-  }
-  formatQmdResults(title, results, sessionKey, trustByPath) {
-    const handleByIndex = buildHandleIndexForResults(
-      results,
-      this.config.recallMemoryHandles === true && sessionKey != null
-    );
-    const renderHedge = this.config.trustScoreEpistemicRendering && trustByPath !== null && trustByPath !== void 0;
-    const hedgeMap = renderHedge ? trustByPath : null;
-    const lines = results.map((r, i) => {
-      const snippet = r.snippet ? r.snippet.slice(0, 500).replace(/\n/g, " ") : "(no preview)";
-      const source = typeof r.line === "number" ? `${r.path}:${r.line}` : r.path;
-      const head = `[${i + 1}] ${source} (score: ${r.score.toFixed(3)})
-${snippet}`;
-      const handle = handleByIndex.get(i);
-      const hedged = head.replace(/\s+$/, "");
-      const withHandle = handle ? `${hedged} ${handle}` : hedged;
-      if (hedgeMap) {
-        const item = hedgeMap.get(r.path);
-        if (item) {
-          const hedge = renderEpistemicHedge(item.trust);
-          if (hedge.length > 0) return `${withHandle} ${hedge}`;
-        }
-      }
-      return withHandle;
-    });
-    return `## ${title}
-
-${lines.join("\n\n")}`;
+        ...result.learnedPatterns.map((p) => `- ${p}`),
+        ""
+      ].join("\n");
+      const newContent = staticHeader + "\n\n" + patternsSection + "\n";
+      await storage.writeIdentity(
+        this.config.workspaceDir,
+        newContent,
+        identityNamespace
+      );
+      await storage.writeIdentityReflections("");
+      log.info(
+        `IDENTITY(${namespace}) consolidated: ${identityContent.length} \u2192 ${newContent.length} chars, ${result.learnedPatterns.length} patterns`
+      );
+    }
+  }
+  // Issue #1526: recall result formatting moved to RecallResultFormatter. Thin
+  // delegation keeps the private API stable for callers + tests.
+  formatQmdResults(title, results, sessionKey, trustByPath) {
+    return this.recallResultFormatter.formatQmdResults(title, results, sessionKey, trustByPath);
   }
   formatObjectiveStateResults(results) {
-    const lines = results.map(({ snapshot }, index) => {
-      const parts = [
-        snapshot.recordedAt.replace("T", " ").slice(0, 16),
-        `${snapshot.kind}/${snapshot.changeKind}`
-      ];
-      if (snapshot.outcome) parts.push(snapshot.outcome);
-      const header = `[${index + 1}] ${parts.join(" | ")} | ${snapshot.scope}`;
-      const detailParts = [snapshot.summary];
-      if (snapshot.command) detailParts.push(`command: ${snapshot.command}`);
-      else if (snapshot.toolName)
-        detailParts.push(`tool: ${snapshot.toolName}`);
-      return `${header}
-${detailParts.join(" | ")}`;
-    });
-    return `## Objective State
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatObjectiveStateResults(results);
   }
   formatCausalTrajectoryResults(results) {
-    const lines = results.map(({ record, matchedFields }, index) => {
-      const header = [
-        `[${index + 1}] ${record.recordedAt.replace("T", " ").slice(0, 16)}`,
-        record.outcomeKind
-      ].join(" | ");
-      const details = [
-        `goal: ${record.goal}`,
-        `action: ${record.actionSummary}`,
-        `observation: ${record.observationSummary}`,
-        `outcome: ${record.outcomeSummary}`
-      ];
-      if (record.followUpSummary)
-        details.push(`follow-up: ${record.followUpSummary}`);
-      if (matchedFields.length > 0)
-        details.push(`matched: ${matchedFields.join(", ")}`);
-      return `${header}
-${details.join("\n")}`;
-    });
-    return `## Causal Trajectories
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatCausalTrajectoryResults(results);
   }
   formatTrustZoneResults(results) {
-    const lines = results.map(({ record, matchedFields }, index) => {
-      const header = [
-        `[${index + 1}] ${record.recordedAt.replace("T", " ").slice(0, 16)}`,
-        record.zone,
-        record.kind
-      ].join(" | ");
-      const details = [
-        record.summary,
-        `provenance: ${record.provenance.sourceClass}`
-      ];
-      if (record.entityRefs && record.entityRefs.length > 0) {
-        details.push(`entities: ${record.entityRefs.join(", ")}`);
-      }
-      if (record.tags && record.tags.length > 0) {
-        details.push(`tags: ${record.tags.join(", ")}`);
-      }
-      if (matchedFields.length > 0) {
-        details.push(`matched: ${matchedFields.join(", ")}`);
-      }
-      return `${header}
-${details.join("\n")}`;
-    });
-    return `## Trust Zones
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatTrustZoneResults(results);
   }
   formatHarmonicRetrievalResults(results) {
-    const lines = results.map(
-      ({ node, matchedAnchors, matchedFields, nodeScore, anchorScore }, index) => {
-        const header = [
-          `[${index + 1}] ${node.recordedAt.replace("T", " ").slice(0, 16)}`,
-          `${node.kind}/${node.abstractionLevel}`,
-          node.sessionKey
-        ].join(" | ");
-        const details = [
-          node.title,
-          node.summary,
-          `scores: node=${nodeScore.toFixed(1)} anchor=${anchorScore.toFixed(1)}`
-        ];
-        if (matchedAnchors.length > 0) {
-          details.push(
-            `anchors: ${matchedAnchors.map((anchor) => `${anchor.anchorType}:${anchor.anchorValue}`).join("; ")}`
-          );
-        }
-        if (matchedFields.length > 0) {
-          details.push(`matched: ${matchedFields.join(", ")}`);
-        }
-        return `${header}
-${details.join("\n")}`;
-      }
-    );
-    return `## Harmonic Retrieval
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatHarmonicRetrievalResults(results);
   }
   formatWorkProductResults(results) {
-    const lines = results.map(({ entry, matchedFields }, index) => {
-      const header = [
-        `[${index + 1}] ${entry.recordedAt.replace("T", " ").slice(0, 16)}`,
-        `${entry.kind}/${entry.action}`,
-        entry.sessionKey
-      ].join(" | ");
-      const details = [entry.summary, `scope: ${entry.scope}`];
-      if (entry.artifactPath) details.push(`artifact: ${entry.artifactPath}`);
-      if (entry.tags && entry.tags.length > 0)
-        details.push(`tags: ${entry.tags.join(", ")}`);
-      if (matchedFields.length > 0)
-        details.push(`matched: ${matchedFields.join(", ")}`);
-      return `${header}
-${details.join("\n")}`;
-    });
-    return `## Work Products
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatWorkProductResults(results);
   }
   formatVerifiedEpisodeResults(results) {
-    const lines = results.map(
-      ({ box, verifiedEpisodeCount, matchedFields }, index) => {
-        const header = [
-          `[${index + 1}] ${box.sealedAt.replace("T", " ").slice(0, 16)}`,
-          box.traceId ? `trace:${box.traceId.slice(0, 12)}` : "trace:none"
-        ].join(" | ");
-        const details = [
-          box.goal ?? `topics: ${box.topics.join(", ")}`,
-          `verified episodes: ${verifiedEpisodeCount}`
-        ];
-        if (box.toolsUsed && box.toolsUsed.length > 0) {
-          details.push(`tools: ${box.toolsUsed.join(", ")}`);
-        }
-        if (matchedFields.length > 0) {
-          details.push(`matched: ${matchedFields.join(", ")}`);
-        }
-        return `${header}
-${details.join("\n")}`;
-      }
-    );
-    return `## Verified Episodes
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatVerifiedEpisodeResults(results);
   }
   formatVerifiedSemanticRuleResults(results) {
-    const lines = results.map(
-      ({
-        rule,
-        sourceMemoryId,
-        verificationStatus,
-        effectiveConfidence,
-        matchedFields
-      }, index) => {
-        const header = [
-          `[${index + 1}] ${rule.frontmatter.updated.replace("T", " ").slice(0, 16)}`,
-          verificationStatus,
-          `confidence:${effectiveConfidence.toFixed(2)}`
-        ].join(" | ");
-        const details = [rule.content, `source memory: ${sourceMemoryId}`];
-        if (matchedFields.length > 0) {
-          details.push(`matched: ${matchedFields.join(", ")}`);
-        }
-        return `${header}
-${details.join("\n")}`;
-      }
-    );
-    return `## Verified Rules
-
-${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatVerifiedSemanticRuleResults(results);
   }
   summarizeIdentityText(raw, maxLines, maxChars) {
-    const lines = raw.replace(/\r/g, "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
-    const compact = lines.slice(0, Math.max(1, maxLines)).join(" ");
-    if (compact.length <= maxChars) return compact;
-    return `${compact.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+    return this.recallResultFormatter.summarizeIdentityText(raw, maxLines, maxChars);
   }
   formatOpenIncidentLine(incident, includeDetails) {
-    const base = `[${incident.id}] ${incident.symptom.trim()}`;
-    if (!includeDetails) return `- ${base}`;
-    const parts = [base];
-    if (incident.suspectedCause)
-      parts.push(`cause: ${incident.suspectedCause.trim()}`);
-    if (incident.triggerWindow)
-      parts.push(`window: ${incident.triggerWindow.trim()}`);
-    return `- ${parts.join(" | ")}`;
+    return this.recallResultFormatter.formatOpenIncidentLine(incident, includeDetails);
   }
   trimIdentitySection(content, maxChars) {
-    if (maxChars <= 0) return { text: "", truncated: false };
-    if (content.length <= maxChars) return { text: content, truncated: false };
-    const suffix = "\n\n...(identity continuity trimmed)";
-    if (maxChars <= suffix.length) {
-      return { text: content.slice(0, maxChars), truncated: true };
-    }
-    const headroom = Math.max(0, maxChars - suffix.length);
-    return { text: `${content.slice(0, headroom)}${suffix}`, truncated: true };
+    return this.recallResultFormatter.trimIdentitySection(content, maxChars);
   }
   async buildIdentityContinuitySection(options) {
-    if (!resolveIdentityContinuityCapabilities(this.config).identityContinuity) return null;
-    if (this.config.identityMaxInjectChars <= 0) return null;
-    const resolved = resolveEffectiveIdentityInjectionMode({
-      configuredMode: this.config.identityInjectionMode,
-      recallMode: options.recallMode,
-      prompt: options.prompt
-    });
-    if (!resolved.shouldInject) return null;
-    const [anchorRaw, loopsRaw, incidents] = await Promise.all([
-      options.storage.readIdentityAnchor(),
-      options.storage.readIdentityImprovementLoops(),
-      options.storage.readContinuityIncidents(200)
-    ]);
-    const openIncidents = incidents.filter(
-      (incident) => incident.state === "open"
-    );
-    const lines = [];
-    if (resolved.mode === "full") {
-      lines.push("## Identity Continuity");
-      if (anchorRaw && anchorRaw.trim().length > 0) {
-        lines.push("", "### Anchor", "", anchorRaw.trim());
-      }
-      if (loopsRaw && loopsRaw.trim().length > 0) {
-        lines.push("", "### Improvement Loops", "", loopsRaw.trim());
-      }
-      lines.push("", "### Open Incidents", "");
-      if (openIncidents.length === 0) {
-        lines.push("- none");
-      } else {
-        lines.push(
-          ...openIncidents.slice(0, 5).map((incident) => this.formatOpenIncidentLine(incident, true))
-        );
-      }
-    } else {
-      const anchorSummary = anchorRaw ? this.summarizeIdentityText(anchorRaw, 3, 320) : "";
-      const loopsSummary = loopsRaw ? this.summarizeIdentityText(loopsRaw, 2, 240) : "";
-      lines.push("## Identity Continuity Signals", "");
-      if (anchorSummary) lines.push(`- anchor: ${anchorSummary}`);
-      if (loopsSummary) lines.push(`- loops: ${loopsSummary}`);
-      if (openIncidents.length === 0) {
-        lines.push("- incidents: 0 open");
-      } else {
-        lines.push(`- incidents: ${openIncidents.length} open`);
-        lines.push(
-          ...openIncidents.slice(0, 2).map((incident) => this.formatOpenIncidentLine(incident, false))
-        );
-      }
-    }
-    const body = lines.join("\n").trim();
-    if (!body) return null;
-    const { text, truncated } = this.trimIdentitySection(
-      body,
-      this.config.identityMaxInjectChars
-    );
-    if (!text) return null;
-    return {
-      section: text,
-      mode: resolved.mode,
-      injectedChars: text.length,
-      truncated
-    };
+    return this.recallResultFormatter.buildIdentityContinuitySection(options);
   }
   emitTrace(event) {
     try {
@@ -16315,6 +16394,8 @@ ${lines.join("\n\n")}`;
 
 export {
   buildProcedureRecallSection,
+  hasIdentityRecoveryIntent,
+  resolveEffectiveIdentityInjectionMode,
   decideSemanticDedup,
   DEFAULT_TAXONOMY,
   generateResolverDocument,
@@ -16332,7 +16413,6 @@ export {
   WearablesService,
   locateTranscriptPath,
   BulkImportBatchPartialFailureError,
-  dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
   isArtifactMemoryPath,
@@ -16345,8 +16425,6 @@ export {
   resolveEffectiveRecallMode,
   resolveRecallModeDecision,
   resolveRecallModeDecisionAsync,
-  hasIdentityRecoveryIntent,
-  resolveEffectiveIdentityInjectionMode,
   computeArtifactCandidateFetchLimit,
   computeQmdHybridFetchLimit,
   mergeGraphExpandedResults,
@@ -16360,4 +16438,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-FLCYY5JX.js.map
+//# sourceMappingURL=chunk-PB5YON2G.js.map