@remnic/core 9.3.735 → 9.3.737

package/src/orchestrator.ts

@@ -79,12 +79,9 @@ import {
 } from "./search/factory.js";
 import { NoopSearchBackend } from "./search/noop-backend.js";
 import {
-  compareEntityTimestamps,
   StorageManager,
   ContentHashIndex,
-  fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
-  parseEntityFile,
 } from "./storage.js";
 import { sanitizeMemoryContent } from "./sanitize.js";
 import { ThreadingManager } from "./threading.js";
@@ -103,6 +100,9 @@ import { ExtractionQueueCoordinator } from "./orchestration/extraction-queue-coo
 import { CompressionGuidelineCoordinator } from "./orchestration/compression-guideline-coordinator.js";
 import { SemanticConsolidationCoordinator } from "./orchestration/semantic-consolidation-coordinator.js";
 import { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coordinator.js";
+import { EntitySynthesisCoordinator } from "./orchestration/entity-synthesis-coordinator.js";
+import { RecallResultFormatter } from "./orchestration/recall-result-formatter.js";
+export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
   runLiveConnectorsOnce,
   type LiveConnectorsRunSummary,
@@ -451,8 +451,6 @@ import type {
   RecallPlanMode,
   RecallSectionConfig,
   RecallTierExplain,
-  EntityStructuredSection,
-  EntityTimelineEntry,
 } from "./types.js";
 import { disposeDefaultArchiveScoring, getDefaultArchiveScoring, memoryFileToScoreItem } from "./recall/archive-scoring.js";
 
@@ -492,92 +490,6 @@ interface ExtractionRunResult {
   postPersistMetadataFailed?: boolean;
 }
 
-export function dedupeEntitySynthesisEvidenceEntries(
-  entries: EntityTimelineEntry[],
-): EntityTimelineEntry[] {
-  const dedupedEvidenceEntries: EntityTimelineEntry[] = [];
-  const evidenceByFact = new Map<string, {
-    newest: EntityTimelineEntry;
-    oldest: EntityTimelineEntry;
-  }>();
-
-  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("\u0000");
-    const oldestKey = [
-      oldest.timestamp,
-      oldest.source ?? "",
-      oldest.sessionKey ?? "",
-      oldest.principal ?? "",
-      oldest.text,
-    ].join("\u0000");
-    if (oldestKey !== newestKey) {
-      dedupedEvidenceEntries.push(oldest);
-    }
-  }
-
-  return dedupedEvidenceEntries;
-}
-
-function flattenStructuredSectionEvidence(
-  sections: EntityStructuredSection[] | undefined,
-): EntityTimelineEntry[] {
-  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: {
-  timeline: EntityTimelineEntry[];
-  structuredSections?: EntityStructuredSection[];
-}): string {
-  const fingerprint = createHash("sha256");
-  const timelineEntries = entity.timeline
-    .map((entry) => [
-      entry.timestamp,
-      entry.source ?? "",
-      entry.sessionKey ?? "",
-      entry.principal ?? "",
-      entry.text,
-    ].join("\u0000"))
-    .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");
-}
-
 export interface GraphRecallSnapshot {
   recordedAt: string;
   mode: RecallPlanMode | string;
@@ -1458,31 +1370,6 @@ export async function resolveRecallModeDecisionAsync(
   };
 }
 
-export function hasIdentityRecoveryIntent(prompt: string): boolean {
-  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,
-  );
-}
-
-export function resolveEffectiveIdentityInjectionMode(options: {
-  configuredMode: IdentityInjectionMode;
-  recallMode: RecallPlanMode;
-  prompt: string;
-}): { mode: IdentityInjectionMode; shouldInject: boolean } {
-  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 };
-}
-
 export function computeArtifactCandidateFetchLimit(
   targetCount: number,
 ): number {
@@ -1904,6 +1791,7 @@ export class Orchestrator {
   readonly compressionGuidelineCoordinator: CompressionGuidelineCoordinator;
   readonly semanticConsolidationCoordinator: SemanticConsolidationCoordinator;
   readonly lifecyclePolicyCoordinator: LifecyclePolicyCoordinator;
+  readonly entitySynthesisCoordinator: EntitySynthesisCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -2017,6 +1905,11 @@ export class Orchestrator {
    * hands it to `enqueue`.
    */
   readonly extractionQueueCoordinator: ExtractionQueueCoordinator;
+  /**
+   * Issue #1526: recall result formatting + identity continuity section moved
+   * to RecallResultFormatter.
+   */
+  readonly recallResultFormatter: RecallResultFormatter;
   private heartbeatObserverChains = new Map<string, Promise<void>>();
   private recentExtractionFingerprints = new Map<string, number>();
   private readonly consolidationObservers = new Set<
@@ -2985,6 +2878,7 @@ export class Orchestrator {
     });
     // Issue #1526: background extraction queue lives on its own coordinator.
     this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+    this.recallResultFormatter = new RecallResultFormatter(this.config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
       getFaiss: () => this.conversationFaiss,
@@ -3027,6 +2921,12 @@ export class Orchestrator {
       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,
@@ -4444,150 +4344,10 @@ export class Orchestrator {
     namespace?: string,
     maxEntities: number = 5,
   ): Promise<number> {
-    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 === undefined
-          ? []
-          : 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() || undefined);
-        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === undefined
-          || 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() || undefined)
-          .find((timestamp) => Boolean(timestamp));
-        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || undefined;
-        const nextSynthesisUpdatedAt = compareEntityTimestamps(
-          latestEvidenceTimestamp,
-          previousSynthesisUpdatedAt,
-        ) >= 0
-          ? latestEvidenceTimestamp
-          : previousSynthesisUpdatedAt;
-        const evidenceBatches: typeof chronologicalEvidenceEntries[] = [];
-        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:\n${nextSynthesis}` : "Previous synthesis: none",
-                  `New evidence:\n${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(2_000, 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: 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;
+    // Issue #1526: entity synthesis lifecycle moved to EntitySynthesisCoordinator.
+    // Thin delegation keeps all call sites (consolidation pass, access-service)
+    // and tests that exercise the public API working unchanged.
+    return this.entitySynthesisCoordinator.processQueue(namespace, maxEntities);
   }
 
   async generateDaySummary(
@@ -17169,226 +16929,55 @@ export class Orchestrator {
     }
   }
 
+  // Issue #1526: recall result formatting moved to RecallResultFormatter. Thin
+  // delegation keeps the private API stable for callers + tests.
   private formatQmdResults(
     title: string,
     results: QmdSearchResult[],
     sessionKey?: string,
     trustByPath?: Map<string, TrustStageResultItem> | null,
   ): string {
-    // Issue #1582 — handles are only rendered when a session key is available:
-    // resolution requires the handle history to have been recorded for this
-    // session, which only happens when sessionKey is present. Rendering handles
-    // without recording would show tokens a user can never resolve (cursor
-    // review). The rendering logic itself lives in the pure handles module.
-    const handleByIndex = buildHandleIndexForResults(
-      results,
-      this.config.recallMemoryHandles === true && sessionKey != null,
-    );
-    // Issue #1577 — epistemic hedge. Append a deterministic, component-derived
-    // suffix so the downstream model knows each memory's trust status (the
-    // cheap lever against confident-stale-answer failures). Gated separately
-    // from scoring so rendering can ship after the stage is stable. High-band
-    // and neutral items get no suffix (don't waste tokens on the common case).
-    const renderHedge = this.config.trustScoreEpistemicRendering && trustByPath !== null && trustByPath !== undefined;
-    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)})\n${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}\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatQmdResults(title, results, sessionKey, trustByPath);
   }
 
   private formatObjectiveStateResults(
     results: ObjectiveStateSearchResult[],
   ): string {
-    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}\n${detailParts.join(" | ")}`;
-    });
-    return `## Objective State\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatObjectiveStateResults(results);
   }
 
   private formatCausalTrajectoryResults(
     results: CausalTrajectorySearchResult[],
   ): string {
-    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}\n${details.join("\n")}`;
-    });
-
-    return `## Causal Trajectories\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatCausalTrajectoryResults(results);
   }
 
   private formatTrustZoneResults(results: TrustZoneSearchResult[]): string {
-    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}\n${details.join("\n")}`;
-    });
-
-    return `## Trust Zones\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatTrustZoneResults(results);
   }
 
   private formatHarmonicRetrievalResults(
     results: HarmonicRetrievalResult[],
   ): string {
-    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}\n${details.join("\n")}`;
-      },
-    );
-
-    return `## Harmonic Retrieval\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatHarmonicRetrievalResults(results);
   }
 
   private formatWorkProductResults(
     results: WorkProductLedgerSearchResult[],
   ): string {
-    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}\n${details.join("\n")}`;
-    });
-
-    return `## Work Products\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatWorkProductResults(results);
   }
 
   private formatVerifiedEpisodeResults(
     results: VerifiedEpisodeResult[],
   ): string {
-    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}\n${details.join("\n")}`;
-      },
-    );
-
-    return `## Verified Episodes\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatVerifiedEpisodeResults(results);
   }
 
   private formatVerifiedSemanticRuleResults(
     results: VerifiedSemanticRuleResult[],
   ): string {
-    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}\n${details.join("\n")}`;
-      },
-    );
-
-    return `## Verified Rules\n\n${lines.join("\n\n")}`;
+    return this.recallResultFormatter.formatVerifiedSemanticRuleResults(results);
   }
 
   private summarizeIdentityText(
@@ -17396,42 +16985,21 @@ export class Orchestrator {
     maxLines: number,
     maxChars: number,
   ): string {
-    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))}…`;
+    return this.recallResultFormatter.summarizeIdentityText(raw, maxLines, maxChars);
   }
 
   private formatOpenIncidentLine(
     incident: ContinuityIncidentRecord,
     includeDetails: boolean,
   ): string {
-    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);
   }
 
   private trimIdentitySection(
     content: string,
     maxChars: number,
   ): { text: string; truncated: boolean } {
-    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);
   }
 
   private async buildIdentityContinuitySection(options: {
@@ -17444,81 +17012,7 @@ export class Orchestrator {
     injectedChars: number;
     truncated: boolean;
   } | null> {
-    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: string[] = [];
-    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);
   }
 
   private emitTrace(event: EngramTraceEvent): void {