@remnic/core 9.3.748 → 9.3.750

package/src/orchestrator.ts

@@ -114,6 +114,75 @@ import { RecallSearchPipelineCoordinator } from "./orchestration/recall-search-p
 import { TurnIngestionCoordinator } from "./orchestration/turn-ingestion.js";
 import { RecallIntrospectionCoordinator } from "./orchestration/recall-introspection.js";
 import { OrchestratorInitCoordinator } from "./orchestration/orchestrator-init.js";
+import { PersistenceIndexCoordinator } from "./orchestration/persistence-index.js";
+import { WorkspaceOpsCoordinator } from "./orchestration/workspace-ops.js";
+import { NamespaceReadFanoutCoordinator } from "./orchestration/namespace-read-fanout.js";
+import {
+  abortRecallError,
+  buildCompressionGuidelinesMarkdown,
+  buildQmdIntentHint,
+  isArtifactMemoryPath,
+  mergeArtifactRecallCandidates,
+  tokenizeRecallQuery,
+  type BulkImportBatchIngestResult,
+  type DaySummaryGatherOptions,
+  type GraphRecallSnapshot,
+  type IntentDebugSnapshot,
+  type QmdRecallSnapshot,
+  type QueryAwarePrefilter,
+  type RecallInvocationOptions,
+} from "./orchestration/orchestrator-helpers.js";
+// Issue #1526 seam 25: module-level helpers moved to
+// orchestration/orchestrator-helpers.ts; re-exported here so existing
+// importers (coordinators, tests, root shims) keep working.
+export {
+  BulkImportBatchPartialFailureError,
+  COMPACTION_SIGNAL_MAX_AGE_MS,
+  appendMemoryToGraphContext,
+  applyQueryAwareCandidateFilter,
+  buildCompressionGuidelinesMarkdown,
+  buildMemoryPathById,
+  computeArtifactCandidateFetchLimit,
+  computeArtifactRecallLimit,
+  computeQmdHybridFetchLimit,
+  defaultWorkspaceDir,
+  filterHourlySummaryMarkdownForLocalDay,
+  filterRecallCandidates,
+  formatDateInTimeZone,
+  isArtifactMemoryPath,
+  lifecycleRecallScoreAdjustment,
+  mapRecallSourceToXrayServedBy,
+  mergeArtifactRecallCandidates,
+  normalizeIanaTimeZone,
+  parseFiniteDate,
+  parseGraphRecallRankedResults,
+  parseMemoryIntentSnapshot,
+  parseQmdRecallResults,
+  qmdStartupCollectionCheckWithTimeout,
+  raceRecallAbort,
+  resolveEffectiveRecallMode,
+  resolvePersistedMemoryRelativePath,
+  resolveRecallModeDecision,
+  resolveRecallModeDecisionAsync,
+  resolveRecentThreadMemoryPaths,
+  sanitizeSessionKeyForFilename,
+  shouldFilterLifecycleRecallCandidate,
+  splitTurnsBySourceValidAt,
+  summarizeGraphShadowComparison,
+  targetSourceValidAtSortMs,
+  throwIfRecallAborted,
+  tokenizeRecallQuery,
+  utcDateKeysForLocalDay,
+  type BulkImportBatchIngestResult,
+  type DaySummaryGatherOptions,
+  type GraphRecallSnapshot,
+  type IntentDebugSnapshot,
+  type QmdRecallSnapshot,
+  type QueryAwarePrefilter,
+  type RecallInvocationOptions,
+  type RecallModeDecision,
+} from "./orchestration/orchestrator-helpers.js";
+
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
   GraphRecallCoordinator,
@@ -468,1105 +537,14 @@ import type {
 } from "./types.js";
 import { disposeDefaultArchiveScoring, getDefaultArchiveScoring, memoryFileToScoreItem } from "./recall/archive-scoring.js";
 
-export interface BulkImportBatchIngestResult {
-  attemptedTurnCount: number;
-  extractionCount: number;
-  persistedCount: number;
-  durableOutputCount: number;
-  skippedCount: number;
-  failedCount: number;
-  postPersistMetadataFailureCount: number;
-  processedTurnCount: number;
-}
-
-export class BulkImportBatchPartialFailureError extends Error {
-  readonly partialResult: BulkImportBatchIngestResult;
-
-  readonly originalError: unknown;
-
-  constructor(
-    message: string,
-    partialResult: BulkImportBatchIngestResult,
-    originalError: unknown,
-  ) {
-    super(message);
-    this.name = "BulkImportBatchPartialFailureError";
-    this.partialResult = partialResult;
-    this.originalError = originalError;
-  }
-}
 
 // Issue #1526 seam 15: ExtractionRunResult moved to orchestration/extraction-run.ts.
 export type { ExtractionRunResult } from "./orchestration/extraction-run.js";
 
-export interface GraphRecallSnapshot {
-  recordedAt: string;
-  mode: RecallPlanMode | string;
-  queryHash: string;
-  queryLength: number;
-  namespaces: string[];
-  seedCount: number;
-  expandedCount: number;
-  seeds: string[];
-  expanded: GraphRecallExpandedEntry[];
-  status?: "completed" | "skipped" | "aborted";
-  reason?: string;
-  shadowMode?: boolean;
-  queryIntent?: MemoryIntent;
-  seedResults?: GraphRecallRankedResult[];
-  finalResults?: GraphRecallRankedResult[];
-  shadowComparison?: GraphRecallShadowComparison;
-}
-
-export interface IntentDebugSnapshot {
-  recordedAt: string;
-  promptHash: string;
-  promptLength: number;
-  retrievalQueryHash: string;
-  retrievalQueryLength: number;
-  plannerEnabled: boolean;
-  plannedMode: RecallPlanMode;
-  effectiveMode: RecallPlanMode;
-  recallResultLimit: number;
-  queryIntent: MemoryIntent;
-  graphExpandedIntentDetected: boolean;
-  graphDecision: {
-    status: "not_requested" | "skipped" | "completed" | "aborted";
-    reason?: string;
-    shadowMode: boolean;
-    qmdAvailable: boolean;
-    graphRecallEnabled: boolean;
-    multiGraphMemoryEnabled: boolean;
-  };
-}
-
-export interface QmdRecallSnapshot {
-  recordedAt: string;
-  queryHash: string;
-  queryLength: number;
-  collection?: string;
-  namespaces: string[];
-  fetchLimit: number;
-  primaryResultCount: number;
-  hybridResultCount: number;
-  queryAwareSeedCount: number;
-  resultCount: number;
-  intentHint?: string;
-  explainEnabled: boolean;
-  hybridTopUpUsed: boolean;
-  hybridTopUpSkippedReason?: string;
-  results: QmdSearchResult[];
-}
-
-export interface RecallModeDecision {
-  plannedMode: RecallPlanMode;
-  effectiveMode: RecallPlanMode;
-  graphExpandedIntentDetected: boolean;
-  graphReason?: string;
-  /**
-   * Where `plannedMode` came from (issue #1367 / Option C). `"heuristic"` for
-   * the regex planner; `"llm"` when the LLM planner classified it; and
-   * `"heuristic-fallback"` when the LLM was enabled but errored/timed out and we
-   * fell back. Absent on the synchronous heuristic-only path.
-   */
-  plannerSource?: "heuristic" | "llm" | "heuristic-fallback";
-  /** Short rationale from the planner (for telemetry / x-ray). */
-  plannerReason?: string;
-  /** Wall-clock spent in the LLM planner call, when one was made. */
-  plannerLatencyMs?: number;
-  /** True when the LLM planner was enabled but fell back to the heuristic. */
-  plannerFallbackUsed?: boolean;
-  /** Model that served the LLM classification, when one was used. */
-  plannerModelUsed?: string;
-  /**
-   * The regex-heuristic baseline mode, captured whenever the LLM planner ran
-   * (any source). Lets operators compare planned-vs-heuristic during rollout —
-   * distinct from `plannedMode`, which on the LLM path is the LLM's choice.
-   */
-  plannerHeuristicMode?: RecallPlanMode;
-  /**
-   * In shadow mode, the mode the LLM *would* have chosen (recorded for
-   * comparison) while `effectiveMode` stays on the heuristic decision.
-   */
-  shadowLlmMode?: RecallPlanMode;
-}
-
-/**
- * Map the orchestrator's internal `recallSource` strings to the
- * X-ray `servedBy` vocabulary (issue #570 PR 1).  The X-ray tier
- * ladder intentionally flattens QMD / embedding / cold-fallback to
- * the `hybrid` tier because they all materialize through the same
- * hybrid BM25+vector pipeline from the caller's perspective.  The
- * `recent_scan` path gets its own dedicated tier because it bypasses
- * the hybrid pipeline entirely.  `none` is treated as `hybrid` on the
- * theory that a query that returned nothing still routed through the
- * hybrid pipeline — but callers should normally gate capture on
- * `recalledMemoryIds.length > 0`.
- */
-export function mapRecallSourceToXrayServedBy(
-  source:
-    | "none"
-    | "hot_qmd"
-    | "hot_embedding"
-    | "cold_fallback"
-    | "recent_scan",
-): RecallXrayServedBy {
-  // Exhaustive switch: every current union member is explicitly
-  // listed so TypeScript surfaces a compile error if a new source is
-  // added without a deliberate mapping.  The `never`-typed fallthrough
-  // keeps the function total at runtime — if the caller passes an
-  // unexpected value that slipped past the type system (e.g. a JSON
-  // deserialization), we still fall back to `hybrid`.
-  switch (source) {
-    case "recent_scan":
-      return "recent-scan";
-    case "hot_qmd":
-    case "hot_embedding":
-    case "cold_fallback":
-    case "none":
-      return "hybrid";
-  }
-  const _exhaustive: never = source;
-  void _exhaustive;
-  return "hybrid";
-}
-
-export interface RecallInvocationOptions {
-  namespace?: string;
-  topK?: number;
-  mode?: RecallPlanMode;
-  abortSignal?: AbortSignal;
-  /**
-   * Capture a `RecallXraySnapshot` for this recall (issue #570).  When
-   * `true`, the orchestrator builds a snapshot from the data it has
-   * already gathered and stashes it in memory, accessible via
-   * `getLastXraySnapshot()`.  When `false` or absent, nothing is
-   * captured and recall behavior is unchanged (schema-only slice).
-   */
-  xrayCapture?: boolean;
-  /**
-   * Per-invocation override for `recallBudgetChars` (issue #570 PR 3/4).
-   * Flows through `getRecallBudgetChars()` for this recall only — no
-   * shared config mutation, so concurrent recalls on the same
-   * orchestrator are not affected (CLAUDE.md rule 47: no shared
-   * mutable state across async boundaries).  Must be a non-negative
-   * finite integer; non-conforming values are ignored and the
-   * configured budget is used.
-   */
-  budgetCharsOverride?: number;
-  /**
-   * Per-invocation principal override (issue #570 PR 4).  When set,
-   * the orchestrator uses this principal for ACL / namespace checks
-   * instead of `resolvePrincipal(sessionKey, config)`.  This is the
-   * escape hatch for access surfaces (HTTP / MCP) that have already
-   * authenticated the caller upstream — threading an unmapped
-   * principal through the session-key-based resolver would otherwise
-   * collapse it to `"default"` and produce false denials in
-   * namespace-enabled deployments (CLAUDE.md rule 42).
-   */
-  principalOverride?: string;
-  /**
-   * Historical recall point (issue #680).  When set, the orchestrator
-   * filters out memories whose `valid_at` is after this timestamp OR
-   * whose `invalid_at` is at-or-before this timestamp, so callers see
-   * the corpus as it existed at `asOf`.  ISO 8601 string; comparisons
-   * use `Date.parse()` so timezone-aware values round-trip correctly
-   * (CLAUDE.md gotcha — never compare ISO strings lexicographically).
-   * Invalid values must be rejected at input boundaries (CLAUDE.md
-   * rule 51); the orchestrator does NOT silently fall back here.
-   */
-  asOf?: string;
-  /**
-   * Issue #681 — when `true`, bypasses `graphTraversalConfidenceFloor`
-   * and includes edges below the floor in graph traversal.  Useful for
-   * diagnostic recall queries that need to surface results that would
-   * normally be pruned by confidence decay.  Default `false`.
-   */
-  includeLowConfidence?: boolean;
-  /**
-   * User-aware context scopes active for this recall. Used by X-ray
-   * provenance safety checks so boundary-scoped memories are evaluated
-   * against the caller's real context.
-   */
-  currentContextScopes?: readonly unknown[];
-}
-
-export type QueryAwarePrefilter = {
-  candidatePaths: Set<string> | null;
-  temporalFromDate: string | null;
-  matchedTags: string[];
-  expandedTags: string[];
-  combination: "none" | "temporal" | "tag" | "intersection" | "union";
-  filteredToFullSearch: boolean;
-};
-
-// Recall-specific abort helpers.  Thin wrappers over the shared
-// `abort-error.ts` module so every abort in the codebase shares the
-// same `name === "AbortError"` classification contract (`isAbortError`
-// works uniformly).  We keep the "recall aborted" default message for
-// back-compat with call-site logs; callers that pass an explicit
-// message (e.g. "extraction aborted (before_extract)") are unaffected.
-const abortRecallError = sharedAbortError;
-
-export function throwIfRecallAborted(
-  signal?: AbortSignal,
-  message = "recall aborted",
-): void {
-  sharedThrowIfAborted(signal, message);
-}
-
-export async function raceRecallAbort<T>(
-  promise: Promise<T>,
-  signal?: AbortSignal,
-  message = "recall aborted",
-): Promise<T> {
-  throwIfRecallAborted(signal, message);
-  if (!signal) return promise;
-
-  let onAbort: (() => void) | null = null;
-  const abortPromise = new Promise<T>((_resolve, reject) => {
-    onAbort = () => reject(abortRecallError(message));
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-
-  try {
-    return await Promise.race([promise, abortPromise]);
-  } finally {
-    if (onAbort) {
-      signal.removeEventListener("abort", onAbort);
-    }
-  }
-}
-
-/** Maximum age (ms) before a compaction-reset signal file is considered stale and removed. */
-export const COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
-const DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 10_000;
-
-type DaySummaryGatherOptions = {
-  timeZone?: string;
-  now?: Date;
-};
-
-function normalizeIanaTimeZone(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  if (!trimmed) return undefined;
-  try {
-    Intl.DateTimeFormat(undefined, { timeZone: trimmed });
-    return trimmed;
-  } catch {
-    return undefined;
-  }
-}
-
-function formatDateInTimeZone(date: Date, timeZone: string): string {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-  }).formatToParts(date);
-  const get = (type: string): string => parts.find((part) => part.type === type)?.value ?? "";
-  return `${get("year")}-${get("month")}-${get("day")}`;
-}
-
-function utcDateKey(date: Date): string {
-  return date.toISOString().slice(0, 10);
-}
-
-function utcDateKeysAround(date: Date): string[] {
-  const dayMs = 86_400_000;
-  const keys = [
-    utcDateKey(new Date(date.getTime() - dayMs)),
-    utcDateKey(date),
-    utcDateKey(new Date(date.getTime() + dayMs)),
-  ];
-  return keys.filter((value, index, array) => array.indexOf(value) === index);
-}
-
-function utcDateKeysForLocalDay(date: Date, timeZone: string): string[] {
-  const targetLocalDate = formatDateInTimeZone(date, timeZone);
-  const keys = new Set<string>();
-  const hourMs = 3_600_000;
-  const scanStart = date.getTime() - 48 * hourMs;
-  const scanEnd = date.getTime() + 48 * hourMs;
-  for (let ms = scanStart; ms <= scanEnd; ms += hourMs) {
-    const candidate = new Date(ms);
-    if (formatDateInTimeZone(candidate, timeZone) === targetLocalDate) {
-      keys.add(utcDateKey(candidate));
-    }
-  }
-  return keys.size > 0 ? [...keys].sort() : utcDateKeysAround(date);
-}
-
-function parseFiniteDate(value: unknown): Date | null {
-  if (typeof value !== "string" || value.trim().length === 0) return null;
-  const parsed = new Date(value);
-  return Number.isFinite(parsed.getTime()) ? parsed : null;
-}
-
-function filterHourlySummaryMarkdownForLocalDay(
-  raw: string,
-  utcDate: string,
-  timeZone: string,
-  targetLocalDate: string,
-): string | null {
-  const hourHeaderPattern = /^## ([01]\d|2[0-3]):00[ \t]*$/gm;
-  const matches = Array.from(raw.matchAll(hourHeaderPattern));
-  if (matches.length === 0) return null;
-
-  const firstSectionStart = matches[0]?.index ?? 0;
-  const preamble = raw.slice(0, firstSectionStart).trim();
-  const sections: string[] = [];
-  for (let index = 0; index < matches.length; index += 1) {
-    const match = matches[index];
-    const hour = match[1];
-    if (!hour) continue;
-    const sectionTimestamp = parseFiniteDate(`${utcDate}T${hour}:00:00.000Z`);
-    if (
-      !sectionTimestamp ||
-      formatDateInTimeZone(sectionTimestamp, timeZone) !== targetLocalDate
-    ) {
-      continue;
-    }
-    const sectionStart = match.index ?? 0;
-    const sectionEnd = matches[index + 1]?.index ?? raw.length;
-    const section = raw.slice(sectionStart, sectionEnd).trim();
-    if (section.length > 0) sections.push(section);
-  }
-
-  if (sections.length === 0) return null;
-  return [preamble, ...sections]
-    .filter((section) => section.length > 0)
-    .join("\n\n");
-}
-
-type SearchCollectionState = "present" | "missing" | "unknown" | "skipped";
-
-function qmdStartupCollectionCheckTimeoutMs(): number {
-  const raw =
-    process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS ??
-    process.env.ENGRAM_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-  if (raw === undefined) return DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-  const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed >= 1_000
-    ? Math.floor(parsed)
-    : DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-}
 
-export async function qmdStartupCollectionCheckWithTimeout(
-  promise: Promise<SearchCollectionState>,
-  controller: AbortController,
-  label: string,
-): Promise<SearchCollectionState> {
-  const timeoutMs = qmdStartupCollectionCheckTimeoutMs();
-  let timer: NodeJS.Timeout | undefined;
-  let settled = false;
-
-  const timeoutPromise = new Promise<SearchCollectionState>((resolve) => {
-    timer = setTimeout(() => {
-      if (settled) return;
-      controller.abort();
-      log.warn(
-        `QMD startup collection check for ${label} timed out after ${timeoutMs}ms; keeping search enabled fail-open`,
-      );
-      resolve("unknown");
-    }, timeoutMs);
-    timer.unref?.();
-  });
-
-  const checkedPromise = promise
-    .catch((err): SearchCollectionState => {
-      log.warn(
-        `QMD startup collection check for ${label} failed; keeping search enabled fail-open: ${err}`,
-      );
-      return "unknown";
-    })
-    .finally(() => {
-      settled = true;
-      if (timer) clearTimeout(timer);
-    });
-
-  return await Promise.race([checkedPromise, timeoutPromise]);
-}
-
-/** Default workspace directory when no per-agent or config workspace is available. */
-export function defaultWorkspaceDir(): string {
-  return path.join(os.homedir(), ".openclaw", "workspace");
-}
-
-/**
- * Produce a collision-resistant, filesystem-safe identifier from a session key.
- *
- * Session keys follow colon-delimited forms (e.g., `agent:gpucodebot:main`).
- * A naive replace (`:` → `_`) is lossy: different keys like `agent:alpha` and
- * `agent/alpha` would collide. Instead we append a short SHA-256 hash of the
- * original key to the human-readable sanitized prefix, guaranteeing uniqueness
- * while keeping filenames debuggable.
- *
- * Format: `<sanitized>-<12-char-hex-hash>`
- * Example: `agent:gpucodebot:main` → `agent_gpucodebot_main-a1b2c3d4e5f6`
- */
-export function sanitizeSessionKeyForFilename(sessionKey: string): string {
-  const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const hash = createHash("sha256")
-    .update(sessionKey)
-    .digest("hex")
-    .slice(0, 12);
-  return `${readable}-${hash}`;
-}
-
-function sourceValidAtMs(turn: BufferTurn): number | null {
-  if (typeof turn.sourceValidAt !== "string") return null;
-  return parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
-}
-
-const SOURCE_VALID_AT_CONTEXT_TURNS = 2;
-
-function sourceValidAtSliceKey(turn: BufferTurn, index: number): string {
-  const validAtMs = sourceValidAtMs(turn);
-  return validAtMs === null ? `unknown:${index}` : String(validAtMs);
-}
-
-function asExtractionContextTurn(turn: BufferTurn): BufferTurn {
-  return { ...turn, extractionContextOnly: true };
-}
-
-function asExtractionTargetTurn(turn: BufferTurn): BufferTurn {
-  const { extractionContextOnly: _contextOnly, ...targetTurn } = turn;
-  return targetTurn;
-}
-
-function sourceValidAtContextTurns(
-  turns: readonly BufferTurn[],
-  targetStart: number,
-  targetEnd: number,
-  targetValidAtMs: number | null,
-): BufferTurn[] {
-  if (targetValidAtMs === null) return [];
-  return turns
-    .flatMap((turn, index) => {
-      if (index >= targetStart && index < targetEnd) return [];
-      const contextValidAtMs = sourceValidAtMs(turn);
-      if (contextValidAtMs === null || contextValidAtMs > targetValidAtMs) {
-        return [];
-      }
-      return [{ turn, index, validAtMs: contextValidAtMs }];
-    })
-    .sort((a, b) => {
-      if (a.validAtMs < b.validAtMs) return -1;
-      if (a.validAtMs > b.validAtMs) return 1;
-      if (a.index === b.index) return 0;
-      return a.index < b.index ? -1 : 1;
-    })
-    .slice(-SOURCE_VALID_AT_CONTEXT_TURNS)
-    .map(({ turn }) => asExtractionContextTurn(turn));
-}
-
-export function targetSourceValidAtSortMs(turns: readonly BufferTurn[]): number {
-  let latestMs: number | null = null;
-  for (const turn of turns) {
-    if (turn.extractionContextOnly === true) continue;
-    const validAtMs = sourceValidAtMs(turn);
-    if (validAtMs === null) continue;
-    if (latestMs === null || validAtMs > latestMs) {
-      latestMs = validAtMs;
-    }
-  }
-  return latestMs ?? Number.POSITIVE_INFINITY;
-}
-
-function sortSourceValidAtSlicesChronologically(
-  slices: BufferTurn[][],
-): BufferTurn[][] {
-  return slices
-    .map((turns, order) => ({
-      turns,
-      order,
-      targetValidAtMs: targetSourceValidAtSortMs(turns),
-    }))
-    .sort((a, b) => {
-      if (a.targetValidAtMs < b.targetValidAtMs) return -1;
-      if (a.targetValidAtMs > b.targetValidAtMs) return 1;
-      if (a.order === b.order) return 0;
-      return a.order < b.order ? -1 : 1;
-    })
-    .map((slice) => slice.turns);
-}
-
-export function splitTurnsBySourceValidAt(
-  turns: readonly BufferTurn[],
-  options: { includeContext?: boolean } = {},
-): BufferTurn[][] {
-  if (turns.length === 0) return [];
-  if (!turns.some((turn) => sourceValidAtMs(turn) !== null)) {
-    return [[...turns]];
-  }
-
-  const slices: BufferTurn[][] = [];
-  let start = 0;
-  while (start < turns.length) {
-    const targetValidAtMs = sourceValidAtMs(turns[start]);
-    const activeKey = sourceValidAtSliceKey(turns[start], start);
-    let end = start + 1;
-    while (
-      end < turns.length &&
-      sourceValidAtSliceKey(turns[end], end) === activeKey
-    ) {
-      end += 1;
-    }
-
-    const contextTurns =
-      options.includeContext === false
-        ? []
-        : sourceValidAtContextTurns(turns, start, end, targetValidAtMs);
-    slices.push([
-      ...contextTurns,
-      ...turns.slice(start, end).map(asExtractionTargetTurn),
-    ]);
-    start = end;
-  }
-  return sortSourceValidAtSlicesChronologically(slices);
-}
-
-export function isArtifactMemoryPath(filePath: string): boolean {
-  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
-}
 // Issue #1526 seam 15: deriveTopicsFromExtraction moved to orchestration/extraction-run.ts.
 export { deriveTopicsFromExtraction } from "./orchestration/extraction-run.js";
-export function buildCompressionGuidelinesMarkdown(
-  events: MemoryActionEvent[],
-  generatedAtIso: string = new Date().toISOString(),
-): string {
-  return buildCompressionGuidelinesMarkdownV2(events, generatedAtIso);
-}
-
-export function filterRecallCandidates(
-  candidates: QmdSearchResult[],
-  options: {
-    namespacesEnabled: boolean;
-    recallNamespaces: string[];
-    resolveNamespace: (path: string) => string;
-    limit: number;
-  },
-): QmdSearchResult[] {
-  const scopedByNamespace = options.namespacesEnabled
-    ? candidates.filter((r) =>
-        options.recallNamespaces.includes(options.resolveNamespace(r.path)),
-      )
-    : candidates;
-  return scopedByNamespace
-    .filter((r) => !isArtifactMemoryPath(r.path))
-    .slice(0, Math.max(0, options.limit));
-}
-
-export function applyQueryAwareCandidateFilter(
-  candidates: QmdSearchResult[],
-  candidatePaths: Set<string> | null,
-): QmdSearchResult[] {
-  if (!candidatePaths) return candidates;
-  if (candidatePaths.size === 0) return [];
-  const filtered = candidates.filter((candidate) =>
-    candidatePaths.has(candidate.path),
-  );
-  return filtered.length > 0 ? filtered : candidates;
-}
-
-export function tokenizeRecallQuery(prompt: string): string[] {
-  return prompt
-    .toLowerCase()
-    .split(/[^a-z0-9]+/i)
-    .map((t) => t.trim())
-    .filter((t) => t.length >= 3);
-}
-
-function hasLifecycleMetadata(frontmatter: MemoryFrontmatter): boolean {
-  return (
-    frontmatter.lifecycleState !== undefined ||
-    frontmatter.verificationState !== undefined ||
-    frontmatter.policyClass !== undefined ||
-    frontmatter.lastValidatedAt !== undefined ||
-    frontmatter.decayScore !== undefined ||
-    frontmatter.heatScore !== undefined
-  );
-}
-
-export function shouldFilterLifecycleRecallCandidate(
-  frontmatter: MemoryFrontmatter,
-  options: {
-    lifecyclePolicyEnabled: boolean;
-    lifecycleFilterStaleEnabled: boolean;
-  },
-): boolean {
-  if (!options.lifecyclePolicyEnabled || !options.lifecycleFilterStaleEnabled)
-    return false;
-  if (!hasLifecycleMetadata(frontmatter)) return false;
-  const lifecycleState = resolveLifecycleState(frontmatter);
-  return lifecycleState === "stale" || lifecycleState === "archived";
-}
-
-export function lifecycleRecallScoreAdjustment(
-  frontmatter: MemoryFrontmatter,
-  options: {
-    lifecyclePolicyEnabled: boolean;
-  },
-): number {
-  if (!options.lifecyclePolicyEnabled) return 0;
-  if (!hasLifecycleMetadata(frontmatter)) return 0;
-
-  let delta = 0;
-  const lifecycleState = resolveLifecycleState(frontmatter);
-  switch (lifecycleState) {
-    case "active":
-      delta += 0.05;
-      break;
-    case "validated":
-      delta += 0.03;
-      break;
-    case "candidate":
-      delta -= 0.01;
-      break;
-    case "stale":
-      delta -= 0.06;
-      break;
-    case "archived":
-      delta -= 0.08;
-      break;
-  }
-  if (frontmatter.verificationState === "disputed") {
-    delta -= 0.12;
-  }
-  return delta;
-}
-
-export function computeArtifactRecallLimit(
-  recallMode: RecallPlanMode,
-  recallResultLimit: number,
-  verbatimArtifactsMaxRecall: number,
-): number {
-  if (recallMode === "no_recall") return 0;
-  if (Math.max(0, recallResultLimit) === 0) return 0;
-  const base = Math.max(0, verbatimArtifactsMaxRecall);
-  if (recallMode === "minimal") {
-    return Math.min(base, Math.max(0, recallResultLimit));
-  }
-  return base;
-}
-
-export function resolveEffectiveRecallMode(options: {
-  plannerEnabled: boolean;
-  graphRecallEnabled: boolean;
-  multiGraphMemoryEnabled: boolean;
-  graphExpandedIntentEnabled?: boolean;
-  prompt: string;
-}): RecallPlanMode {
-  return resolveRecallModeDecision(options).effectiveMode;
-}
-
-interface RecallModeGraphOptions {
-  plannerEnabled: boolean;
-  graphRecallEnabled: boolean;
-  multiGraphMemoryEnabled: boolean;
-  graphExpandedIntentEnabled?: boolean;
-  prompt: string;
-}
-
-/**
- * Apply the graph-mode overlay + gating to a planner-produced mode.
- *
- * Shared by the heuristic ({@link resolveRecallModeDecision}) and LLM
- * ({@link resolveRecallModeDecisionAsync}) paths so graph promotion and the
- * "graph disabled → fall back to full" gating behave identically regardless of
- * which planner produced `plannedModeRaw` (gotcha #39).
- */
-function finalizeRecallModeDecision(
-  plannedModeRaw: RecallPlanMode,
-  options: RecallModeGraphOptions,
-): RecallModeDecision {
-  let plannedMode: RecallPlanMode = plannedModeRaw;
-  const graphExpandedIntentDetected =
-    options.plannerEnabled &&
-    options.graphExpandedIntentEnabled === true &&
-    hasBroadGraphIntent(options.prompt);
-  if (plannedMode !== "graph_mode" && graphExpandedIntentDetected) {
-    plannedMode = "graph_mode";
-  }
-  if (
-    plannedMode === "graph_mode" &&
-    (!options.graphRecallEnabled || !options.multiGraphMemoryEnabled)
-  ) {
-    return {
-      plannedMode,
-      effectiveMode: "full",
-      graphExpandedIntentDetected,
-      graphReason: !options.graphRecallEnabled
-        ? "graph recall disabled by config"
-        : "multi-graph memory disabled by config",
-    };
-  }
-  return {
-    plannedMode,
-    effectiveMode: plannedMode,
-    graphExpandedIntentDetected,
-  };
-}
-
-export function resolveRecallModeDecision(options: RecallModeGraphOptions): RecallModeDecision {
-  const plannedMode: RecallPlanMode = options.plannerEnabled
-    ? planRecallMode(options.prompt)
-    : "full";
-  return finalizeRecallModeDecision(plannedMode, options);
-}
-
-/**
- * Async recall-mode decision with optional LLM-based planning (issue #1367 /
- * Option C). Falls back to the heuristic decision when the LLM planner is
- * disabled, in shadow mode, or unavailable/failed — so this is always safe to
- * await on the recall hot path. Provider-agnostic: the LLM call routes through
- * the gateway/fallback chain.
- *
- * `recallPlannerEnabled === false` keeps the legacy "always full" behavior and
- * skips the LLM entirely (the planner as a whole is off).
- */
-export async function resolveRecallModeDecisionAsync(
-  options: RecallModeGraphOptions & {
-    config: PluginConfig;
-    /**
-     * Recall-operation capability gates (issue #1523). REQUIRED: the recall
-     * orchestrator always passes a resolved set — the LLM planner gate reads
-     * `caps.recallPlannerLlm`, never re-derives from config.
-     */
-    caps: CapabilitySet;
-    hints?: string[];
-    llm?: FallbackLlmClient;
-    signal?: AbortSignal;
-  },
-): Promise<RecallModeDecision> {
-  const heuristicDecision = resolveRecallModeDecision(options);
-
-  // Planner globally off, or LLM planning not opted into → heuristic only.
-  // Read the resolved capability (issue #1523) — never re-derive from config.
-  const plannerLlmEnabled = options.caps.recallPlannerLlm;
-  if (!options.plannerEnabled || !plannerLlmEnabled) {
-    return heuristicDecision;
-  }
-
-  const { planRecallModeLLM } = await import("./recall-planner-llm.js");
-  const planned = await planRecallModeLLM(
-    options.prompt,
-    options.hints,
-    options.config,
-    options.caps,
-    options.llm,
-    options.signal,
-  );
-
-  // Shadow mode: record what the LLM would have chosen but keep the heuristic
-  // effective decision (safe rollout / comparison — gotcha #30).
-  if (options.config.recallPlannerShadowMode) {
-    return {
-      ...heuristicDecision,
-      plannerSource: planned.source,
-      plannerReason: `shadow:${planned.reason}`,
-      plannerLatencyMs: planned.latencyMs,
-      plannerFallbackUsed: planned.fallbackUsed,
-      plannerModelUsed: planned.modelUsed,
-      plannerHeuristicMode: planned.heuristicMode,
-      shadowLlmMode: planned.mode,
-    };
-  }
-
-  const llmDecision = finalizeRecallModeDecision(planned.mode, options);
-  return {
-    ...llmDecision,
-    plannerSource: planned.source,
-    plannerReason: planned.reason,
-    plannerLatencyMs: planned.latencyMs,
-    plannerFallbackUsed: planned.fallbackUsed,
-    plannerModelUsed: planned.modelUsed,
-    plannerHeuristicMode: planned.heuristicMode,
-  };
-}
-
-export function computeArtifactCandidateFetchLimit(
-  targetCount: number,
-): number {
-  const cappedTarget = Math.max(0, targetCount);
-  if (cappedTarget === 0) return 0;
-  const headroom = Math.max(8, cappedTarget * 4);
-  return Math.min(200, cappedTarget + headroom);
-}
-
-export function computeQmdHybridFetchLimit(
-  recallFetchLimit: number,
-  artifactsEnabled: boolean,
-  maxArtifactRecall: number,
-): number {
-  const cappedRecallLimit = Math.max(0, recallFetchLimit);
-  if (cappedRecallLimit === 0) return 0;
-  if (!artifactsEnabled) return cappedRecallLimit;
-  // Overscan when artifacts are enabled, then filter artifact paths before
-  // re-applying the recall cap to avoid artifact-dominated top-N starvation.
-  const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
-  return Math.min(400, cappedRecallLimit + artifactHeadroom);
-}
-export function summarizeGraphShadowComparison(
-  baseline: QmdSearchResult[],
-  merged: QmdSearchResult[],
-  topN: number,
-): {
-  baselineCount: number;
-  graphCount: number;
-  overlapCount: number;
-  overlapRatio: number;
-  averageOverlapDelta: number;
-} {
-  const limit = Math.max(0, Math.floor(topN));
-  const baselineTop = limit > 0 ? baseline.slice(0, limit) : [];
-  const graphTop = limit > 0 ? merged.slice(0, limit) : [];
-  const baselineByPath = new Map(
-    baselineTop.map((item) => [item.path, item.score]),
-  );
-  const graphByPath = new Map(graphTop.map((item) => [item.path, item.score]));
-
-  let overlapCount = 0;
-  let overlapDeltaSum = 0;
-  for (const [p, baselineScore] of baselineByPath.entries()) {
-    const graphScore = graphByPath.get(p);
-    if (typeof graphScore !== "number") continue;
-    overlapCount += 1;
-    overlapDeltaSum += graphScore - baselineScore;
-  }
-
-  const baselineCount = baselineTop.length;
-  return {
-    baselineCount,
-    graphCount: graphTop.length,
-    overlapCount,
-    overlapRatio: baselineCount > 0 ? overlapCount / baselineCount : 0,
-    averageOverlapDelta: overlapCount > 0 ? overlapDeltaSum / overlapCount : 0,
-  };
-}
-
-export function parseGraphRecallRankedResults(
-  value: unknown,
-): GraphRecallRankedResult[] {
-  if (!Array.isArray(value)) return [];
-  const parsed: GraphRecallRankedResult[] = [];
-  for (const entry of value) {
-    if (!entry || typeof entry !== "object") continue;
-    const candidate = entry as Partial<GraphRecallRankedResult>;
-    if (
-      typeof candidate.path !== "string" ||
-      typeof candidate.score !== "number"
-    )
-      continue;
-    parsed.push({
-      path: candidate.path,
-      score: candidate.score,
-      docid: typeof candidate.docid === "string" ? candidate.docid : undefined,
-      sourceLabels: Array.isArray(candidate.sourceLabels)
-        ? candidate.sourceLabels.filter(
-            (item): item is string => typeof item === "string",
-          )
-        : [],
-    });
-  }
-  return parsed.slice(0, 64);
-}
-
-export function parseMemoryIntentSnapshot(value: unknown): MemoryIntent {
-  const candidate =
-    value && typeof value === "object" ? (value as Partial<MemoryIntent>) : {};
-  return {
-    goal: typeof candidate.goal === "string" ? candidate.goal : "unknown",
-    actionType:
-      typeof candidate.actionType === "string"
-        ? candidate.actionType
-        : "unknown",
-    entityTypes: Array.isArray(candidate.entityTypes)
-      ? candidate.entityTypes.filter(
-          (item): item is string => typeof item === "string",
-        )
-      : [],
-    taskInitiation: candidate.taskInitiation === true,
-  };
-}
-
-function buildQmdIntentHint(intent: MemoryIntent): string | undefined {
-  const parts: string[] = [];
-  if (intent.goal !== "unknown") {
-    parts.push(`goal:${intent.goal.replace(/_/g, " ")}`);
-  }
-  if (intent.actionType !== "unknown") {
-    parts.push(`action:${intent.actionType.replace(/_/g, " ")}`);
-  }
-  if (intent.entityTypes.length > 0) {
-    parts.push(`entities:${intent.entityTypes.join(",")}`);
-  }
-  if (intent.taskInitiation === true) {
-    parts.push("task_initiation");
-  }
-  return parts.length > 0 ? parts.join(" ") : undefined;
-}
 
-export function parseQmdRecallResults(value: unknown): QmdSearchResult[] {
-  if (!Array.isArray(value)) return [];
-  const parsed: QmdSearchResult[] = [];
-  for (const entry of value) {
-    if (!entry || typeof entry !== "object") continue;
-    const candidate = entry as Partial<QmdSearchResult>;
-    if (
-      typeof candidate.path !== "string" ||
-      typeof candidate.score !== "number"
-    )
-      continue;
-    parsed.push({
-      docid: typeof candidate.docid === "string" ? candidate.docid : "",
-      path: candidate.path,
-      snippet: typeof candidate.snippet === "string" ? candidate.snippet : "",
-      score: candidate.score,
-      explain: parseQmdExplain(candidate.explain),
-      transport:
-        candidate.transport === "daemon" ||
-        candidate.transport === "subprocess" ||
-        candidate.transport === "hybrid" ||
-        candidate.transport === "scoped_prefilter"
-          ? candidate.transport
-          : undefined,
-    });
-  }
-  return parsed.slice(0, 32);
-}
-
-export function mergeArtifactRecallCandidates(
-  candidatesByNamespace: MemoryFile[][],
-  limit: number,
-): MemoryFile[] {
-  const cappedLimit = Math.max(0, limit);
-  if (cappedLimit === 0) return [];
-
-  const out: MemoryFile[] = [];
-  const seen = new Set<string>();
-  let offset = 0;
-  while (out.length < cappedLimit) {
-    let hasAnyCandidateAtOffset = false;
-    for (const list of candidatesByNamespace) {
-      if (offset >= list.length) continue;
-      hasAnyCandidateAtOffset = true;
-      const item = list[offset];
-      const dedupeKey = `${item.frontmatter.id}:${item.frontmatter.sourceMemoryId ?? ""}:${item.content}`;
-      if (seen.has(dedupeKey)) continue;
-      seen.add(dedupeKey);
-      out.push(item);
-      if (out.length >= cappedLimit) break;
-    }
-    if (!hasAnyCandidateAtOffset) break;
-    offset += 1;
-  }
-  return out;
-}
-
-export function resolveRecentThreadMemoryPaths(options: {
-  threadEpisodeIds: string[];
-  currentMemoryId: string;
-  allMemsForGraph: MemoryFile[] | null | undefined;
-  pathById?: Map<string, string>;
-  storageDir: string;
-  maxRecent: number;
-}): string[] {
-  const maxRecent = Math.max(0, options.maxRecent);
-  if (options.threadEpisodeIds.length === 0 || maxRecent === 0) return [];
-  const pathById =
-    options.pathById ??
-    buildMemoryPathById(options.allMemsForGraph, options.storageDir);
-  if (pathById.size === 0) return [];
-
-  // #1635 (defensive): skip pending_review ids from legacy episode sets.
-  const pendingReviewIds = new Set<string>(
-    (options.allMemsForGraph ?? [])
-      .filter((m) => m.frontmatter.status === "pending_review" && m.frontmatter.id)
-      .map((m) => m.frontmatter.id as string),
-  );
-
-  return options.threadEpisodeIds
-    .filter((id) => id !== options.currentMemoryId)
-    .filter((id) => !pendingReviewIds.has(id))
-    .slice(-maxRecent)
-    .map((id) => pathById.get(id))
-    .filter((p): p is string => typeof p === "string" && p.length > 0);
-}
-
-export function buildMemoryPathById(
-  allMemsForGraph: MemoryFile[] | null | undefined,
-  storageDir: string,
-): Map<string, string> {
-  const pathById = new Map<string, string>();
-  for (const mem of allMemsForGraph ?? []) {
-    const id = mem.frontmatter.id;
-    if (!id) continue;
-    pathById.set(id, path.relative(storageDir, mem.path));
-  }
-  return pathById;
-}
-
-export function appendMemoryToGraphContext(options: {
-  allMemsForGraph: MemoryFile[] | null | undefined;
-  storageDir: string;
-  memoryRelPath: string;
-  memoryId: string;
-  category: MemoryFile["frontmatter"]["category"];
-  content: string;
-  entityRef: string | undefined;
-}): void {
-  if (!Array.isArray(options.allMemsForGraph)) return;
-
-  const nowIso = new Date().toISOString();
-  options.allMemsForGraph.push({
-    path: path.join(options.storageDir, options.memoryRelPath),
-    content: options.content,
-    frontmatter: {
-      id: options.memoryId,
-      category: options.category,
-      created: nowIso,
-      updated: nowIso,
-      source: "extraction",
-      confidence: 0.8,
-      confidenceTier: "implied",
-      tags: [],
-      entityRef: options.entityRef,
-      status: "active",
-    },
-  });
-}
-
-export function resolvePersistedMemoryRelativePath(options: {
-  memoryId: string;
-  pathById: Map<string, string>;
-  category: string;
-}): string {
-  const persisted = options.pathById.get(options.memoryId);
-  if (persisted) return persisted;
-  if (options.category === "correction") {
-    return path.join("corrections", `${options.memoryId}.md`);
-  }
-  // Pick the subtree that matches the StorageManager.writeMemory routing
-  // so fallback paths (used before memoryPathById has seen the fresh
-  // write) agree with where the file actually lives. Routing goes through
-  // the shared categoryDirName() chokepoint (utils/category-dir.ts) so
-  // every category — decisions/, preferences/, reasoning-traces/, ... —
-  // resolves to the same dir the writer used; otherwise graph edges point
-  // at the wrong subtree and graph expansion silently drops those nodes
-  // when readMemoryByPath cannot resolve them (issue #564 PR 3 / #1546).
-  const subtree = categoryDirName(options.category);
-  const idParts = options.memoryId.split("-");
-  const maybeTimestamp = Number(idParts[1]);
-  if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
-    const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path.join(subtree, day, `${options.memoryId}.md`);
-  }
-  return path.join(subtree, `${options.memoryId}.md`);
-}
 
 export class Orchestrator {
 
@@ -1705,7 +683,8 @@ export class Orchestrator {
       statuses: Map<string, "active" | "superseded" | "archived" | "missing">;
     }
   >();
-  private static readonly ARTIFACT_STATUS_CACHE_TTL_MS = 60_000;
+  /** Read by NamespaceReadFanoutCoordinator (seam 26), hence not `private`. */
+  static readonly ARTIFACT_STATUS_CACHE_TTL_MS = 60_000;
 
   // Access tracking buffer (Phase 1A)
   // Maps memoryId -> {count, lastAccessed} for batched updates
@@ -2272,98 +1251,17 @@ export class Orchestrator {
     resolvedStorageDir: string,
     configured: Set<string>,
   ): { namespace: string; identityToken: string; storageDir: string } {
-    const currentRank = this.namespaceStorageDirHintOwnershipRank(
+    return this.namespaceReadFanoutCoordinator.preferNamespaceStorageDirHintOwner(
       current,
-      resolvedStorageDir,
-      configured,
-    );
-    const candidateRank = this.namespaceStorageDirHintOwnershipRank(
       candidate,
       resolvedStorageDir,
       configured,
     );
-    if (candidateRank < currentRank) return candidate;
-    if (candidateRank > currentRank) return current;
-
-    const byName = candidate.namespace.localeCompare(current.namespace);
-    if (byName < 0) return candidate;
-    if (byName > 0) return current;
-    return candidate.identityToken.localeCompare(current.identityToken) < 0
-      ? candidate
-      : current;
   }
 
   private loadNamespaceStorageDirHintsFromCatalog(): void {
-    if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
-    this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path.join(this.config.memoryDir, "state", "namespaces.jsonl");
-    if (!existsSync(catalogPath)) return;
-
-    let body: string;
-    try {
-      body = readFileSync(catalogPath, "utf8");
-    } catch {
-      return;
-    }
-
-    const compactedByNamespace = new Map<
-      string,
-      { namespace: string; identityToken: string; storageDir: string }
-    >();
-    for (const line of body.split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const parsed = JSON.parse(trimmed) as unknown;
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-        const record = parsed as Record<string, unknown>;
-        if (
-          typeof record.namespace !== "string" ||
-          typeof record.storageDir !== "string" ||
-          typeof record.identityToken !== "string"
-        ) {
-          continue;
-        }
-        const namespace = normalizeNamespaceIdentity(record.namespace);
-        if (!namespace || record.identityToken !== namespaceIdentityToken(namespace)) continue;
-        compactedByNamespace.set(namespace, {
-          namespace,
-          identityToken: record.identityToken,
-          storageDir: record.storageDir,
-        });
-      } catch {
-        // Catalog hints are best-effort. The catalog reader still owns full recovery.
-      }
-    }
-
-    const configured = new Set(
-      this.configuredNamespaceList().map((namespace) => normalizeNamespaceIdentity(namespace)),
+    return this.namespaceReadFanoutCoordinator.loadNamespaceStorageDirHintsFromCatalog(
     );
-    const preferredByStorageDir = new Map<
-      string,
-      { namespace: string; identityToken: string; storageDir: string }
-    >();
-    for (const record of compactedByNamespace.values()) {
-      if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
-        continue;
-      }
-      const resolvedStorageDir = path.resolve(record.storageDir);
-      const current = preferredByStorageDir.get(resolvedStorageDir);
-      preferredByStorageDir.set(
-        resolvedStorageDir,
-        current
-          ? this.preferNamespaceStorageDirHintOwner(
-              current,
-              record,
-              resolvedStorageDir,
-              configured,
-            )
-          : record,
-      );
-    }
-    for (const record of preferredByStorageDir.values()) {
-      this.rememberNamespaceStorageDirHint(record.namespace, record.storageDir);
-    }
   }
 
   private async maintenanceNamespaces(
@@ -2439,68 +1337,9 @@ export class Orchestrator {
     searchOptions?: SearchQueryOptions;
     execution?: SearchExecutionOptions;
   }): Promise<QmdSearchResult[]> {
-    if (
-      resolveNamespaceCapabilities(this.config).namespaces &&
-      options.namespaces !== undefined &&
-      options.namespaces.length === 0
-    ) {
-      return [];
-    }
-    const namespaces = resolveNamespaceCapabilities(this.config).namespaces
-      ? Array.from(
-          new Set(
-            (options.namespaces?.length
-              ? options.namespaces
-              : this.configuredNamespaceList()
-            )
-              .map((value) => value.trim())
-              .filter(Boolean),
-          ),
-        )
-      : [this.config.defaultNamespace];
-
-    if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      switch (options.mode) {
-        case "hybrid":
-          return await this.qmd.hybridSearch(
-            options.query,
-            undefined,
-            options.maxResults,
-            options.execution,
-          );
-        case "bm25":
-          return await this.qmd.bm25Search(
-            options.query,
-            undefined,
-            options.maxResults,
-            options.execution,
-          );
-        case "vector":
-          return await this.qmd.vectorSearch(
-            options.query,
-            undefined,
-            options.maxResults,
-            options.execution,
-          );
-        default:
-          return await this.qmd.search(
-            options.query,
-            undefined,
-            options.maxResults,
-            options.searchOptions,
-            options.execution,
-          );
-      }
-    }
-
-    return await this.namespaceSearchRouter.searchAcrossNamespaces({
-      query: options.query,
-      namespaces,
-      maxResults: options.maxResults,
-      mode: options.mode,
-      searchOptions: options.searchOptions,
-      execution: options.execution,
-    });
+    return this.namespaceReadFanoutCoordinator.searchAcrossNamespaces(
+      options,
+    );
   }
 
   async searchHealthForNamespace(
@@ -2549,17 +1388,20 @@ export class Orchestrator {
     targetStorage: StorageManager,
     content: string,
   ): Promise<boolean> {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    return index ? index.has(content) : false;
+    return this.persistenceIndexCoordinator.hasContentHashDedup(
+      targetStorage,
+      content,
+    );
   }
 
   private async addContentHashDedup(
     targetStorage: StorageManager,
     content: string,
   ): Promise<void> {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    if (!index) return;
-    index.add(content);
+    return this.persistenceIndexCoordinator.addContentHashDedup(
+      targetStorage,
+      content,
+    );
   }
 
   private async removeContentHashForMemory(
@@ -2567,50 +1409,13 @@ export class Orchestrator {
     memory: MemoryFile,
     context: string,
   ): Promise<void> {
-    const index = await this.contentHashIndexForStorage(targetStorage);
-    if (!index) return;
-
-    if (memory.frontmatter.contentHash) {
-      index.removeByHash(memory.frontmatter.contentHash);
-      return;
-    }
-
-    log.warn(
-      `[${context}] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback - no contentHash in frontmatter`,
+    return this.persistenceIndexCoordinator.removeContentHashForMemory(
+      targetStorage,
+      memory,
+      context,
     );
-    index.remove(memory.content);
   }
 
-  /**
-   * Issue #1671 — backfill bi-temporal bounds onto an existing promoted/deduped
-   * copy that was written BEFORE the source fact carried a resolved
-   * `invalid_at`/`observedAt`/`eventTimeSource`.
-   *
-   * On re-extraction/backfill, a fact may now carry a resolved end bound (e.g.
-   * "until June 2025") that the existing copy lacks because it was promoted
-   * before bi-temporal wiring existed. Without this backfill, recall keeps
-   * surfacing an expired fact even though the source copy now expires correctly.
-   *
-   * Finds the active fact in `targetStorage` matching `dedupContent`, then
-   * patches the temporal frontmatter the existing copy is missing. Best-effort
-   * / fail-open — any I/O error is logged and swallowed so the dedup
-   * short-circuit is never blocked by a backfill failure.
-   *
-   * Matching: the stored `frontmatter.contentHash` is compared against
-   * `ContentHashIndex.computeHash(dedupContent)` first (the exact hash the
-   * content-hash index uses), then falls back to stripping citations and
-   * comparing normalized bodies. This handles inline-attribution deployments
-   * where the persisted body carries a citation marker the dedup key does not.
-   *
-   * I/O gate: only triggers when `invalidAt` is present (the end bound that
-   * actually changes recall behavior by expiring the fact). `observedAt` and
-   * `eventTimeSource` alone don'\''t expire a fact, so backfilling them without
-   * an end bound would cause a full readAllMemories scan on every dedup hit
-   * under biTemporal for no recall benefit.
-   *
-   * Only patches fields the existing copy LACKS — never overwrites a bound the
-   * copy already carries.
-   */
   private async backfillTemporalBoundsOnDedupHit(
     targetStorage: StorageManager,
     dedupContent: string,
@@ -2626,130 +1431,17 @@ export class Orchestrator {
     },
     entityRef?: string,
   ): Promise<void> {
-    // I/O gate: scan when there is a recall-relevant bound to backfill —
-    // either an end bound (invalidAt, which expires the fact) or a corrected
-    // EXTRACTED start bound. A start bound only changes recall when it is
-    // extracted (the as-of filter excludes facts whose valid_at is after the
-    // as-of instant); an "assumed" validFrom is just the ingestion anchor
-    // (resolveFactEventTime sets one for every fact), so scanning on it would
-    // run a full readAllMemories on every bi-temporal dedup hit for no benefit
-    // (review cursor PRRT_OvHk / codex PRRT_OvHxVH). observedAt and
-    // eventTimeSource alone never change recall.
-    const hasExtractedStart =
-      bounds.validFrom !== undefined && bounds.eventTimeSource === "extracted";
-    if (!bounds.invalidAt && !hasExtractedStart) return;
-    try {
-      const incomingHash = ContentHashIndex.computeHash(dedupContent);
-      const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
-      // Normalize the entity for same-entity scoping when provided — two
-      // entities can share identical fact text, and patching a different
-      // entity'\''s fact would corrupt its temporal bounds (cursor review).
-      const incomingEntityNorm = entityRef
-        ? normalizeSupersessionKey(entityRef)
-        : undefined;
-      const all = await targetStorage.readAllMemories();
-      const existing = all.find((m) => {
-        if (m.frontmatter.category !== "fact") return false;
-        if ((m.frontmatter.status ?? "active") !== "active") return false;
-        // Same-entity guard: reject only when the stored fact carries a
-        // DIFFERENT entity (two entities can share identical fact text, so
-        // patching the other entity's copy would corrupt its bounds — codex
-        // P2 PRRT_OvB4A). Legacy facts written before entity linkage (no
-        // entityRef) have no entity to conflict with, so they stay eligible
-        // for backfill (cursor PRRT_OvKnV: the guard must NOT silently
-        // no-op for older promoted copies that predate entity linkage).
-        if (
-          incomingEntityNorm &&
-          m.frontmatter.entityRef &&
-          normalizeSupersessionKey(m.frontmatter.entityRef) !== incomingEntityNorm
-        ) {
-          return false;
-        }
-        // Prefer the stored contentHash (what the hash index actually keys
-        // on) — it is computed from contentHashSource (the raw/enriched
-        // body before citation), matching the dedupContent the caller passes.
-        if (m.frontmatter.contentHash) {
-          return m.frontmatter.contentHash === incomingHash;
-        }
-        // Legacy facts without a stored hash: strip citations then compare
-        // normalized bodies so inline-attribution markers don'\''t prevent
-        // a match.
-        return (
-          ContentHashIndex.normalizeContent(
-            stripCitationForTemplate(m.content ?? "", this.config.inlineSourceAttributionFormat),
-          ) === normalizedIncoming
-        );
-      });
-      if (!existing) return;
-      // Build a patch containing ONLY the fields the existing copy lacks.
-      const patch: Partial<MemoryFrontmatter> = {};
-      const fm = existing.frontmatter;
-      if (bounds.invalidAt && (!fm.invalid_at || fm.invalid_at.length === 0)) {
-        patch.invalid_at = bounds.invalidAt;
-      }
-      if (bounds.observedAt && (!fm.observedAt || fm.observedAt.length === 0)) {
-        patch.observedAt = bounds.observedAt;
-      }
-      if (
-        bounds.eventTimeSource &&
-        (!fm.eventTimeSource || fm.eventTimeSource.length === 0)
-      ) {
-        patch.eventTimeSource = bounds.eventTimeSource;
-      }
-      // #1707 thread 2 — per-fact-anchored start bound. A re-extracted
-      // duplicate whose event time resolves a real start bound must carry
-      // that anchor onto the existing copy so as-of recall uses the corrected
-      // valid_at instead of a stale batch-anchored value. Only an EXTRACTED
-      // bound corrects; an "assumed" bound is just the ingestion anchor.
-      //
-      // No-clobber via equality, not provenance inference: exact-content dedup
-      // re-extracts the SAME event-time expression, which #1670 per-fact
-      // anchoring resolves deterministically to the same validFrom — so for
-      // stable content the incoming validFrom EQUALS the copy's valid_at and
-      // we skip the redundant write (the only no-clobber that holds without a
-      // fragile provenance heuristic — review codex PRRT_Ov7LKC). When they
-      // differ (a prior batch/assumed anchor, end-only assumed start, or a
-      // non-deterministic re-resolution), the extracted validFrom is the
-      // authoritative correction and overwrites. The eventTimeSource upgrade
-      // below records that the start is now extracted-anchored.
-      if (
-        bounds.validFrom &&
-        bounds.eventTimeSource === "extracted" &&
-        fm.valid_at !== bounds.validFrom
-      ) {
-        patch.valid_at = bounds.validFrom;
-        // Mark the copy extracted-anchored in the SAME patch so its provenance
-        // reflects the correction (review cursor PRRT_OvHM / codex PRRT_OvHxVD):
-        // without this, a copy upgraded from "assumed" would keep "assumed"
-        // provenance while carrying an extracted start. (The earlier
-        // eventTimeSource block only fills an EMPTY source.)
-        if (fm.eventTimeSource !== "extracted") {
-          patch.eventTimeSource = "extracted";
-        }
-      }
-      if (Object.keys(patch).length === 0) return;
-      const ok = await targetStorage.writeMemoryFrontmatter(existing, patch);
-      if (ok) {
-        log.debug(
-          `bitemporal-backfill: patched ${Object.keys(patch).join(",")} onto existing fact ${fm.id ?? "(unknown)"} in ${targetStorage.dir}`,
-        );
-      }
-    } catch (err) {
-      log.warn(
-        `bitemporal-backfill: failed open for ${targetStorage.dir}: ${err}`,
-      );
-    }
+    return this.persistenceIndexCoordinator.backfillTemporalBoundsOnDedupHit(
+      targetStorage,
+      dedupContent,
+      bounds,
+      entityRef,
+    );
   }
 
   private async saveContentHashIndexes(): Promise<void> {
-    const indexes = new Set<ContentHashIndex>();
-    if (this.contentHashIndex) indexes.add(this.contentHashIndex);
-    for (const index of this.contentHashIndexesByStorageDir.values()) {
-      indexes.add(index);
-    }
-    for (const index of indexes) {
-      await index.save();
-    }
+    return this.persistenceIndexCoordinator.saveContentHashIndexes(
+    );
   }
 
   constructor(config: PluginConfig) {
@@ -3194,92 +1886,10 @@ export class Orchestrator {
     storage: StorageManager,
     sourceIds: string[],
   ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">> {
-    const currentStatusVersion = storage.getMemoryStatusVersion();
-    const cached = this.artifactSourceStatusCache.get(storage);
-    let snapshot = cached;
-    const isFresh =
-      snapshot !== undefined &&
-      Date.now() - snapshot.loadedAtMs <=
-        Orchestrator.ARTIFACT_STATUS_CACHE_TTL_MS &&
-      snapshot.statusVersion === currentStatusVersion;
-
-    const rebuildSnapshot = async () => {
-      const MAX_STABLE_READ_ATTEMPTS = 3;
-      let latestStatuses = new Map<
-        string,
-        "active" | "superseded" | "archived" | "missing"
-      >();
-      let latestVersionAfter = storage.getMemoryStatusVersion();
-
-      for (let attempt = 0; attempt < MAX_STABLE_READ_ATTEMPTS; attempt += 1) {
-        const versionBefore = storage.getMemoryStatusVersion();
-        const allMemories = await storage.readAllMemories();
-        const versionAfter = storage.getMemoryStatusVersion();
-        latestVersionAfter = versionAfter;
-        latestStatuses = new Map(
-          allMemories.map((m) => [
-            m.frontmatter.id,
-            (m.frontmatter.status ?? "active") as
-              | "active"
-              | "superseded"
-              | "archived"
-              | "missing",
-          ]),
-        );
-
-        if (versionAfter === versionBefore) {
-          const rebuilt = {
-            loadedAtMs: Date.now(),
-            statusVersion: versionAfter,
-            statuses: latestStatuses,
-          };
-          this.artifactSourceStatusCache.set(storage, rebuilt);
-          return rebuilt;
-        }
-      }
-
-      // Sustained write churn: return latest read without caching a potentially torn snapshot.
-      return {
-        loadedAtMs: Date.now(),
-        statusVersion: latestVersionAfter,
-        statuses: latestStatuses,
-      };
-    };
-
-    if (!isFresh) {
-      snapshot = await rebuildSnapshot();
-    } else {
-      // Warm cache may miss brand-new sourceMemoryId values created after snapshot build.
-      // Refresh once on-demand when unseen IDs are requested.
-      const hasUnknownSourceIds = sourceIds.some(
-        (id) => !snapshot?.statuses.has(id),
-      );
-      if (hasUnknownSourceIds) {
-        snapshot = await rebuildSnapshot();
-      }
-    }
-
-    // Persist negative lookups in the cached snapshot so stale source IDs do not
-    // trigger repeated full snapshot rebuilds on every matching recall.
-    for (const id of sourceIds) {
-      if (!snapshot?.statuses.has(id)) {
-        snapshot?.statuses.set(id, "missing");
-      }
-    }
-
-    const statuses = new Map<
-      string,
-      "active" | "superseded" | "archived" | "missing"
-    >();
-    for (const id of sourceIds) {
-      const status = snapshot?.statuses.get(id);
-      if (status) {
-        statuses.set(id, status);
-      } else {
-        statuses.set(id, "missing");
-      }
-    }
-    return statuses;
+    return this.namespaceReadFanoutCoordinator.resolveArtifactSourceStatuses(
+      storage,
+      sourceIds,
+    );
   }
 
   /**
@@ -3370,29 +1980,8 @@ export class Orchestrator {
     return this.orchestratorInitCoordinator.startupSearchSync(
       signal,
     );
-  }
-
-  /**
-   * Run the pattern-reinforcement maintenance job (issue #687 PR 2/4).
-   *
-   * Cadence-gated on `patternReinforcementCadenceMs` so every caller
-   * (orchestrator cron path, MCP tool, CLI) shares a single floor —
-   * none can call this on a hot loop and burn the corpus.  When the
-   * feature is disabled or the cadence has not elapsed, returns a
-   * synthetic "skipped" result rather than throwing.
-   *
-   * Cadence tracking is per-namespace so a tenant-scoped MCP run in
-   * one namespace does not silence a cron run in another (PR #730
-   * review feedback, Codex P2).  Pass `force: true` for ad-hoc
-   * operator runs that must bypass the cadence floor — mirrors the
-   * pattern used by other maintenance MCP tools.
-   *
-   * `force` deliberately does NOT bypass the master
-   * `patternReinforcementEnabled` flag (PR #730 review feedback,
-   * Cursor Medium).  Operators who have explicitly disabled the
-   * feature must not have their corpus mutated by an MCP tool call —
-   * the only way to run the job is to enable the feature in config.
-   */
+  }
+
   async runPatternReinforcement(options: {
     force?: boolean;
     namespace?: string;
@@ -3402,69 +1991,16 @@ export class Orchestrator {
     namespace: string;
     result?: PatternReinforcementResult;
   }> {
-    const cadenceKey = options.namespace ?? "";
-    // Master switch: a disabled feature is never bypassed, even with
-    // force=true.  `force` only relaxes the cadence floor below.
-    if (!resolveConsolidationCapabilities(this.config).patternReinforcement) {
-      return { ran: false, skippedReason: "disabled", namespace: cadenceKey };
-    }
-    const cadence = this.config.patternReinforcementCadenceMs;
-    const lastAt = this.lastPatternReinforcementAtByNs.get(cadenceKey);
-    if (
-      !options.force &&
-      cadence > 0 &&
-      lastAt !== undefined &&
-      Date.now() - lastAt < cadence
-    ) {
-      return { ran: false, skippedReason: "cadence", namespace: cadenceKey };
-    }
-    const storage = options.namespace
-      ? await this.getStorage(options.namespace)
-      : this.storage;
-    const result = await runPatternReinforcement(storage, {
-      categories: this.config.patternReinforcementCategories,
-      minCount: this.config.patternReinforcementMinCount,
-    });
-    this.lastPatternReinforcementAtByNs.set(cadenceKey, Date.now());
-    log.debug(
-      `pattern reinforcement [ns=${cadenceKey || "(default)"}]: clusters=${result.clustersFound} canonicalsUpdated=${result.canonicalsUpdated} duplicatesSuperseded=${result.duplicatesSuperseded}`,
+    return this.workspaceOpsCoordinator.runPatternReinforcement(
+      options,
     );
-    return { ran: true, result, namespace: cadenceKey };
   }
 
-  /**
-   * Fan out pattern reinforcement across all maintained namespaces (issue #1500).
-   * Delegates per-namespace execution to {@link runPatternReinforcement} while
-   * the planner handles discovery, budgeting, locking, and status recording.
-   * When namespaces are disabled, runs once against default storage.
-   */
   async runPatternReinforcementFanout(options: {
     force?: boolean;
   } = {}): Promise<NamespaceMaintenanceSummary> {
-    return this.runNamespaceMaintenanceFanoutForJob(
-      "pattern-reinforcement",
-      async (ctx) => {
-        const result = await this.runPatternReinforcement({
-          namespace: ctx.candidate.namespace,
-          force: options.force,
-        });
-        // runPatternReinforcement has its own per-namespace cadence gate
-        // (lastPatternReinforcementAtByNs). When it throttles (ran:false),
-        // signal skip so the planner records state:"skipped" and does NOT
-        // touch lastMaintenanceAt — otherwise a throttled namespace would
-        // look maintained while pattern reinforcement never ran (#1500
-        // review: cadence-skip accuracy).
-        if (!result.ran) {
-          return {
-            skipped: true,
-            skipReason: result.skippedReason ?? "throttled",
-          };
-        }
-        return result.result
-          ? { itemCount: result.result.clustersFound }
-          : { itemCount: 0 };
-      },
-      { enabled: resolveConsolidationCapabilities(this.config).patternReinforcement },
+    return this.workspaceOpsCoordinator.runPatternReinforcementFanout(
+      options,
     );
   }
 
@@ -3578,75 +2114,8 @@ export class Orchestrator {
   }
 
   async maybeRunFileHygiene(): Promise<void> {
-    const hygiene = this.config.fileHygiene;
-    if (!hygiene?.enabled) return;
-
-    const now = Date.now();
-    if (now - this.lastFileHygieneRunAtMs < hygiene.runMinIntervalMs) return;
-    this.lastFileHygieneRunAtMs = now;
-
-    // Rotation first (keeps bootstrap files small).
-    if (hygiene.rotateEnabled) {
-      for (const rel of hygiene.rotatePaths) {
-        const abs = path.isAbsolute(rel)
-          ? rel
-          : path.join(this.config.workspaceDir, rel);
-        try {
-          const raw = await readFile(abs, "utf-8");
-          if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path.join(
-              this.config.workspaceDir,
-              hygiene.archiveDir,
-            );
-            const base = path.basename(abs);
-            const prefix =
-              base
-                .toUpperCase()
-                .replace(/\.MD$/i, "")
-                .replace(/[^A-Z0-9]+/g, "-") || "FILE";
-            const { newContent } = await rotateMarkdownFileToArchive({
-              filePath: abs,
-              archiveDir,
-              archivePrefix: prefix,
-              keepTailChars: hygiene.rotateKeepTailChars,
-            });
-            await writeFile(abs, newContent, "utf-8");
-          }
-        } catch {
-          // ignore missing/unreadable targets
-        }
-      }
-    }
-
-    // Lint (warn before truncation risk).
-    if (hygiene.lintEnabled) {
-      const warnings = await lintWorkspaceFiles({
-        workspaceDir: this.config.workspaceDir,
-        paths: hygiene.lintPaths,
-        budgetBytes: hygiene.lintBudgetBytes,
-        warnRatio: hygiene.lintWarnRatio,
-      });
-      for (const w of warnings) {
-        log.warn(w.message);
-      }
-
-      if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir(path.dirname(fp), { recursive: true });
-        const stamp = new Date().toISOString();
-        const block =
-          `\n\n## ${stamp}\n\n` +
-          warnings.map((w) => `- ${w.message}`).join("\n") +
-          "\n";
-        let existing = "";
-        try {
-          existing = await readFile(fp, "utf-8");
-        } catch {
-          existing = "# Engram File Hygiene Warnings\n";
-        }
-        await writeFile(fp, existing + block, "utf-8");
-      }
-    }
+    return this.workspaceOpsCoordinator.maybeRunFileHygiene(
+    );
   }
 
   async runBootstrap(options: BootstrapOptions): Promise<BootstrapResult> {
@@ -3797,282 +2266,22 @@ export class Orchestrator {
     return this.generateDaySummary(gathered);
   }
 
-  /**
-   * Read today's facts and hourly summaries from storage, returning them
-   * as a formatted string suitable for generateDaySummary().
-   */
   async gatherTodayFacts(
     namespace?: string,
     options: DaySummaryGatherOptions = {},
   ): Promise<string> {
-    const ns =
-      namespace && namespace.length > 0
-        ? namespace
-        : this.config.defaultNamespace;
-    const storage = await this.storageRouter.storageFor(ns);
-    const configuredTimeZone = normalizeIanaTimeZone(options.timeZone)
-      ?? normalizeIanaTimeZone(this.config.daySummaryTimezone);
-    const timeZone =
-      configuredTimeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const now = options.now instanceof Date && Number.isFinite(options.now.getTime())
-      ? options.now
-      : new Date();
-    const targetLocalDate = formatDateInTimeZone(now, timeZone);
-    // Facts are stored under UTC date directories, while the summary target is
-    // a local calendar day. Scan the UTC-date envelope that overlaps the local
-    // day, then filter parseable fact timestamps to that configured local day.
-    const datesToScan = utcDateKeysForLocalDay(now, timeZone);
-    const MAX_CHARS = 100_000;
-
-    // --- Read memory files from each category dir × date directory ---
-    // Iterate every recall category dir (RECALL_FALLBACK_DIRS — single source
-    // of truth) so the day summary includes decisions/, moments/, ... not just
-    // facts/ (#1546). corrections/ is flat, so corrections/<date>/ never exists
-    // and is skipped by the ENOENT guard — preserving the prior exclusion. The
-    // per-file created→local-day filter below is unchanged.
-    //
-    // Symlink/containment hardening (mirrors scanDir / the CLI walker): the
-    // gathered contents feed the day-summary LLM input, so a symlinked category
-    // dir (decisions/ → outside memoryDir) must not be followed and leak files.
-    // Resolve the store root once; skip symlinked / out-of-root dirs and
-    // entries; skip the scan gracefully if the root can't be resolved.
-    const facts: MemoryFile[] = [];
-    let memoryRootReal: string | null = null;
-    try {
-      memoryRootReal = await realpath(storage.dir);
-    } catch {
-      memoryRootReal = null;
-    }
-    for (const categoryDir of RECALL_FALLBACK_DIRS) {
-      if (memoryRootReal === null) break;
-      for (const date of datesToScan) {
-        const dateDir = path.join(storage.dir, categoryDir, date);
-        try {
-          const dirStat = await lstat(dateDir);
-          if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
-          assertPathInsideRoot(memoryRootReal, await realpath(dateDir), dateDir);
-          const entries = await readdir(dateDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isSymbolicLink()) continue;
-            if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path.join(dateDir, entry.name);
-            try {
-              assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
-              const raw = await readFile(fullPath, "utf-8");
-              const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-              if (!fmMatch) continue;
-              const fmBlock = fmMatch[1];
-              const content = fmMatch[2].trim();
-              const fm: Record<string, string> = {};
-              for (const line of fmBlock.split("\n")) {
-                const colonIdx = line.indexOf(":");
-                if (colonIdx === -1) continue;
-                fm[line.slice(0, colonIdx).trim()] = line
-                  .slice(colonIdx + 1)
-                  .trim();
-              }
-              const created = fm.created || "unknown";
-              const createdAt = parseFiniteDate(created);
-              if (
-                createdAt &&
-                formatDateInTimeZone(createdAt, timeZone) !== targetLocalDate
-              ) {
-                continue;
-              }
-              facts.push({
-                path: fullPath,
-                frontmatter: {
-                  id: fm.id || path.basename(entry.name, ".md"),
-                  category: (fm.category as any) || "fact",
-                  created,
-                  updated: fm.updated || created,
-                  source: fm.source || "unknown",
-                  confidence: parseFloat(fm.confidence || "0.8"),
-                  confidenceTier: (fm.confidenceTier as any) || "implied",
-                  tags: [],
-                },
-                content,
-              });
-            } catch {
-              // Skip unreadable files
-            }
-          }
-        } catch {
-          // Absent dir (ENOENT), symlinked/out-of-root dir, or containment
-          // violation — skip this category/date without aborting the summary.
-        }
-      }
-    }
-
-    // Sort facts by created timestamp (most recent last) so truncation keeps newest
-    facts.sort((a, b) => {
-      if (a.frontmatter.created === b.frontmatter.created) return 0;
-      return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
-    });
-
-    // --- Read hourly summaries for the scanned dates ---
-    const hourlySummaries: string[] = [];
-    const hourlyBaseDir = path.join(storage.dir, "summaries", "hourly");
-    try {
-      const sessionKeys = await readdir(hourlyBaseDir, { withFileTypes: true });
-      for (const sk of sessionKeys) {
-        if (!sk.isDirectory()) continue;
-        for (const date of datesToScan) {
-          const summaryFile = path.join(hourlyBaseDir, sk.name, `${date}.md`);
-          try {
-            const raw = await readFile(summaryFile, "utf-8");
-            const filtered = filterHourlySummaryMarkdownForLocalDay(
-              raw,
-              date,
-              timeZone,
-              targetLocalDate,
-            );
-            if (filtered) {
-              hourlySummaries.push(filtered);
-            }
-          } catch {
-            // No summary file for this session/date
-          }
-        }
-      }
-    } catch {
-      // No hourly summaries directory
-    }
-
-    // --- Format and truncate ---
-    let formatted = formatDaySummaryMemories(facts);
-    if (hourlySummaries.length > 0) {
-      formatted +=
-        "\n\n---\n## Hourly Summaries\n\n" +
-        hourlySummaries.join("\n\n---\n\n");
-    }
-
-    // Truncate intelligently if over budget: drop oldest facts first
-    if (formatted.length > MAX_CHARS) {
-      // Re-build with fewer facts, keeping most recent
-      while (facts.length > 1 && formatted.length > MAX_CHARS) {
-        facts.shift(); // drop oldest
-        formatted = formatDaySummaryMemories(facts);
-        if (hourlySummaries.length > 0) {
-          formatted +=
-            "\n\n---\n## Hourly Summaries\n\n" +
-            hourlySummaries.join("\n\n---\n\n");
-        }
-      }
-      // If still over, hard truncate
-      if (formatted.length > MAX_CHARS) {
-        formatted = formatted.slice(0, MAX_CHARS);
-      }
-    }
-
-    log.info(
-      `gatherTodayFacts: collected ${facts.length} facts, ${hourlySummaries.length} hourly summaries for ${targetLocalDate} (${timeZone}, ${formatted.length} chars)`,
+    return this.workspaceOpsCoordinator.gatherTodayFacts(
+      namespace,
+      options,
     );
-
-    return formatted;
   }
 
   previewMemoryActionEvent(
     event: Omit<MemoryActionEvent, "timestamp"> & { timestamp?: string },
   ): MemoryActionEvent {
-    const namespace =
-      typeof event.namespace === "string" && event.namespace.length > 0
-        ? event.namespace
-        : this.config.defaultNamespace;
-    const eligibility = parseMemoryActionEligibilityContext(
-      event.policyEligibility,
-    );
-    const policy = evaluateMemoryActionPolicy({
-      action: event.action,
-      eligibility,
-      options: {
-        actionsEnabled: resolveCompressionCapabilities(this.config).contextCompressionActions,
-        maxCompressionTokensPerHour: this.config.maxCompressionTokensPerHour,
-      },
-    });
-    const dryRun = event.dryRun === true;
-
-    const normalizedOutcome = dryRun
-      ? event.outcome === "failed"
-        ? "failed"
-        : "skipped"
-      : policy.decision === "allow"
-        ? event.outcome
-        : event.outcome === "failed"
-          ? "failed"
-          : "skipped";
-    const sourceSessionKey =
-      typeof event.sourceSessionKey === "string" &&
-      event.sourceSessionKey.length > 0
-        ? event.sourceSessionKey
-        : typeof event.sessionKey === "string" && event.sessionKey.length > 0
-          ? event.sessionKey
-          : undefined;
-    const outputMemoryIds = Array.isArray(event.outputMemoryIds)
-      ? Array.from(
-          new Set(
-            event.outputMemoryIds.filter(
-              (value): value is string =>
-                typeof value === "string" && value.length > 0,
-            ),
-          ),
-        )
-      : [];
-
-    const reasonParts = [
-      event.reason,
-      `policy:${policy.decision}`,
-      policy.rationale,
-    ].filter(
-      (part): part is string => typeof part === "string" && part.length > 0,
+    return this.workspaceOpsCoordinator.previewMemoryActionEvent(
+      event,
     );
-
-    return {
-      ...event,
-      schemaVersion: event.schemaVersion ?? 1,
-      actionId:
-        typeof event.actionId === "string" && event.actionId.length > 0
-          ? event.actionId
-          : `memact-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      outcome: normalizedOutcome,
-      status:
-        event.status ??
-        (dryRun && policy.decision === "allow" && event.outcome !== "failed"
-          ? "validated"
-          : normalizedOutcome === "applied"
-            ? "applied"
-            : "rejected"),
-      actor:
-        typeof event.actor === "string" && event.actor.length > 0
-          ? event.actor
-          : "engram",
-      subsystem:
-        typeof event.subsystem === "string" && event.subsystem.length > 0
-          ? event.subsystem
-          : "memory_action",
-      reason: reasonParts.join(" | "),
-      namespace,
-      sessionKey: sourceSessionKey ?? event.sessionKey,
-      sourceSessionKey,
-      inputSummary:
-        typeof event.inputSummary === "string" && event.inputSummary.length > 0
-          ? event.inputSummary
-          : undefined,
-      outputMemoryIds,
-      dryRun,
-      policyVersion:
-        typeof event.policyVersion === "string" &&
-        event.policyVersion.length > 0
-          ? event.policyVersion
-          : "memory-action-policy.v1",
-      timestamp:
-        typeof event.timestamp === "string" && event.timestamp.length > 0
-          ? event.timestamp
-          : new Date().toISOString(),
-      policyDecision: policy.decision,
-      policyRationale: policy.rationale,
-      policyEligibility: eligibility,
-    };
   }
 
   async appendMemoryActionEvent(
@@ -4233,63 +2442,9 @@ export class Orchestrator {
     return this.conversationIndexCoordinator.rebuild(sessionKey, hours, opts);
   }
 
-  /**
-   * Validate local LLM model availability and context window compatibility.
-   * Warns the user if there's a mismatch.
-   */
   private async validateLocalLlmModel(): Promise<void> {
-    log.debug("Local LLM: validating model configuration");
-    try {
-      const modelInfo = await this.localLlm.getLoadedModelInfo();
-      if (!modelInfo) {
-        log.warn(
-          "Local LLM validation: Could not query model info from server",
-        );
-        log.warn(
-          "Local LLM validation: Could not query model info. " +
-            "Ensure LM Studio/Ollama is running with the model loaded.",
-        );
-        return;
-      }
-
-      // Check for context window mismatch
-      const configuredMaxContext = this.config.localLlmMaxContext;
-
-      if (modelInfo.contextWindow) {
-        log.debug(
-          `Local LLM: ${modelInfo.id} loaded with ${modelInfo.contextWindow.toLocaleString()} token context window`,
-        );
-
-        if (
-          configuredMaxContext &&
-          configuredMaxContext > modelInfo.contextWindow
-        ) {
-          log.warn(
-            `Local LLM context mismatch: engram configured for ${configuredMaxContext.toLocaleString()} tokens, ` +
-              `but ${modelInfo.id} only supports ${modelInfo.contextWindow.toLocaleString()}. ` +
-              `Reducing to ${modelInfo.contextWindow.toLocaleString()} to avoid errors.`,
-          );
-          // Update the config in-memory to match actual capability
-          // (This is a temporary fix - user should update their config)
-          (this.config as { localLlmMaxContext?: number }).localLlmMaxContext =
-            modelInfo.contextWindow;
-        }
-      } else {
-        log.debug(
-          `Local LLM: ${modelInfo.id} loaded (context window not reported by server)`,
-        );
-
-        if (!configuredMaxContext) {
-          log.warn(
-            "Local LLM: Server did not report context window. " +
-              "If you get 'context length exceeded' errors, set localLlmMaxContext in your config. " +
-              "Common defaults: LM Studio (32K), Ollama (2K-128K depending on model).",
-          );
-        }
-      }
-    } catch (err) {
-      log.warn(`Local LLM validation failed: ${err}`);
-    }
+    return this.workspaceOpsCoordinator.validateLocalLlmModel(
+    );
   }
 
   async recall(
@@ -4556,15 +2711,11 @@ export class Orchestrator {
     recallNamespaces: string[],
     targetCount: number,
   ): Promise<MemoryFile[]> {
-    if (targetCount <= 0) return [];
-    const namespaces = Array.from(new Set(recallNamespaces));
-    const filteredByNamespace = await Promise.all(
-      namespaces.map((namespace) =>
-        this.fetchActiveArtifactsForNamespace(namespace, prompt, targetCount),
-      ),
+    return this.namespaceReadFanoutCoordinator.recallArtifactsAcrossNamespaces(
+      prompt,
+      recallNamespaces,
+      targetCount,
     );
-
-    return mergeArtifactRecallCandidates(filteredByNamespace, targetCount);
   }
 
   private scopeQueryAwarePaths(
@@ -4604,51 +2755,12 @@ export class Orchestrator {
       allowArchived?: boolean;
     },
   ): Promise<QmdSearchResult[]> {
-    const cappedLimit = Math.max(0, limit);
-    if (cappedLimit === 0 || candidatePaths.size === 0) return [];
-
-    const tokens = Array.from(new Set(tokenizeRecallQuery(query)));
-    const memories = (
-      await Promise.all(
-        Array.from(candidatePaths).map(async (memoryPath) => {
-          const namespace = resolveNamespaceCapabilities(this.config).namespaces
-            ? this.namespaceFromPath(memoryPath)
-            : this.config.defaultNamespace;
-          const storage = await this.storageRouter.storageFor(namespace);
-          return await storage.readMemoryByPath(memoryPath);
-        }),
-      )
-    ).filter((memory): memory is MemoryFile => memory !== null);
-
-    const results: QmdSearchResult[] = [];
-    for (const memory of memories) {
-      const status = memory.frontmatter.status ?? "active";
-      if (!options?.allowArchived && status !== "active") continue;
-
-      const haystack = [
-        memory.content,
-        memory.frontmatter.category,
-        ...(memory.frontmatter.tags ?? []),
-      ]
-        .join(" ")
-        .toLowerCase();
-      let hits = 0;
-      for (const token of tokens) {
-        if (haystack.includes(token)) hits += 1;
-      }
-      const score = tokens.length > 0 ? hits / tokens.length : 0.01;
-      if (tokens.length > 0 && hits === 0) continue;
-
-      results.push({
-        docid: memory.frontmatter.id,
-        path: memory.path,
-        score,
-        snippet: memory.content.slice(0, 400).replace(/\n/g, " "),
-        transport: "scoped_prefilter",
-      });
-    }
-
-    return results.sort((a, b) => b.score - a.score).slice(0, cappedLimit);
+    return this.namespaceReadFanoutCoordinator.searchScopedMemoryCandidates(
+      candidatePaths,
+      query,
+      limit,
+      options,
+    );
   }
 
   private async fetchQmdMemoryResultsWithArtifactTopUp(
@@ -4742,26 +2854,9 @@ export class Orchestrator {
   private async resolveStateDirForNamespace(
     namespace: string,
   ): Promise<string> {
-    if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path.join(this.config.memoryDir, "state");
-    }
-    if (namespace !== this.config.defaultNamespace) {
-      return path.join(this.config.memoryDir, "namespaces", namespace, "state");
-    }
-    const candidate = path.join(
-      this.config.memoryDir,
-      "namespaces",
-      this.config.defaultNamespace,
+    return this.namespaceReadFanoutCoordinator.resolveStateDirForNamespace(
+      namespace,
     );
-    try {
-      const candidateStat = await stat(candidate);
-      if (candidateStat.isDirectory()) {
-        return path.join(candidate, "state");
-      }
-    } catch {
-      // Fall back to the legacy root when the migrated default namespace directory is absent.
-    }
-    return path.join(this.config.memoryDir, "state");
   }
 
   private buildGraphRecallRankedResults(
@@ -4862,7 +2957,6 @@ export class Orchestrator {
   }
 
 
-
   /**
    * Clock source for the shared post-retrieval assembly/enrichment budget. The
    * deadline is set from this value and every expiry check reads it back, so a
@@ -5146,6 +3240,105 @@ export class Orchestrator {
     return this._orchestratorInitCoordinator;
   }
 
+  /**
+   * Persistence-index coordinator (issue #1526 seam 23). Owns post-persist
+   * bookkeeping (content-hash dedup, temporal indexes, graph edges,
+   * semantic dedup lookup). Lazy + accessor-wired (late-binding rule).
+   */
+  private _persistenceIndexCoordinator: PersistenceIndexCoordinator | undefined;
+
+  private get persistenceIndexCoordinator(): PersistenceIndexCoordinator {
+    if (!this._persistenceIndexCoordinator) {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const self = this;
+      this._persistenceIndexCoordinator = new PersistenceIndexCoordinator({
+        get config() { return self.config; },
+        get contentHashIndex() { return self.contentHashIndex; },
+        contentHashIndexForStorage: (targetStorage) => self.contentHashIndexForStorage(targetStorage),
+        get contentHashIndexesByStorageDir() { return self.contentHashIndexesByStorageDir; },
+        get embeddingFallback() { return self.embeddingFallback; },
+        graphIndexFor: (storage) => self.graphIndexFor(storage),
+        readAllMemoriesForNamespaces: (namespaces) => self.readAllMemoriesForNamespaces(namespaces),
+        semanticDedupScopeFor: (targetStorage) => self.semanticDedupScopeFor(targetStorage),
+      });
+    }
+    return this._persistenceIndexCoordinator;
+  }
+
+  /**
+   * Workspace-ops coordinator (issue #1526 seam 24). Owns periodic
+   * workspace/operations surfaces. Lazy + accessor-wired (late-binding
+   * rule, seams 18–23).
+   */
+  private _workspaceOpsCoordinator: WorkspaceOpsCoordinator | undefined;
+
+  private get workspaceOpsCoordinator(): WorkspaceOpsCoordinator {
+    if (!this._workspaceOpsCoordinator) {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const self = this;
+      this._workspaceOpsCoordinator = new WorkspaceOpsCoordinator({
+        get accessTrackingBuffer() { return self.accessTrackingBuffer; },
+        bulkImportWriteNamespace: () => self.bulkImportWriteNamespace(),
+        get config() { return self.config; },
+        get extraction() { return self.extraction; },
+        getStorage: (namespace) => self.getStorage(namespace),
+        getStorageForNamespace: (namespace) => self.getStorageForNamespace(namespace),
+        get judgeDeferCounts() { return self.judgeDeferCounts; },
+        get judgeVerdictCache() { return self.judgeVerdictCache; },
+        get lastFileHygieneRunAtMs() { return self.lastFileHygieneRunAtMs; },
+        set lastFileHygieneRunAtMs(value) { self.lastFileHygieneRunAtMs = value; },
+        get lastPatternReinforcementAtByNs() { return self.lastPatternReinforcementAtByNs; },
+        get localLlm() { return self.localLlm; },
+        maintenanceNamespaces: (jobName, budgetMode) => self.maintenanceNamespaces(jobName, budgetMode),
+        namespaceFromPath: (p) => self.namespaceFromPath(p),
+        get qmd() { return self.qmd; },
+        readAllMemoriesForNamespaces: (namespaces) => self.readAllMemoriesForNamespaces(namespaces),
+        runNamespaceMaintenanceFanoutForJob: (jobName, runner, options) => self.runNamespaceMaintenanceFanoutForJob(jobName, runner, options),
+        runPatternReinforcement: (options) => self.runPatternReinforcement(options),
+        get storage() { return self.storage; },
+        get storageRouter() { return self.storageRouter; },
+        get wearablesServiceInstance() { return self.wearablesServiceInstance; },
+        set wearablesServiceInstance(value) { self.wearablesServiceInstance = value; },
+      });
+    }
+    return this._workspaceOpsCoordinator;
+  }
+
+  /**
+   * Namespace read-fanout coordinator (issue #1526 seam 26). Owns
+   * namespace-scoped read fanout (hints, cross-namespace search/reads,
+   * artifact statuses). Lazy + accessor-wired (late-binding rule).
+   */
+  private _namespaceReadFanoutCoordinator: NamespaceReadFanoutCoordinator | undefined;
+
+  private get namespaceReadFanoutCoordinator(): NamespaceReadFanoutCoordinator {
+    if (!this._namespaceReadFanoutCoordinator) {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const self = this;
+      this._namespaceReadFanoutCoordinator = new NamespaceReadFanoutCoordinator({
+        get artifactSourceStatusCache() { return self.artifactSourceStatusCache; },
+        get config() { return self.config; },
+        configuredNamespaceList: () => self.configuredNamespaceList(),
+        fetchActiveArtifactsForNamespace: (namespace, prompt, targetCount) => self.fetchActiveArtifactsForNamespace(namespace, prompt, targetCount),
+        loadNamespaceStorageDirHintsFromCatalog: () => self.loadNamespaceStorageDirHintsFromCatalog(),
+        get namespaceCatalog() { return self.namespaceCatalog; },
+        namespaceFromPath: (p) => self.namespaceFromPath(p),
+        get namespaceSearchRouter() { return self.namespaceSearchRouter; },
+        namespaceStorageDirHintOwnershipRank: (record, resolvedStorageDir, configured) => self.namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured),
+        get namespaceStorageDirHints() { return self.namespaceStorageDirHints; },
+        get namespaceStorageDirHintsLoaded() { return self.namespaceStorageDirHintsLoaded; },
+        set namespaceStorageDirHintsLoaded(value) { self.namespaceStorageDirHintsLoaded = value; },
+        preferNamespaceStorageDirHintOwner: (current, candidate, resolvedStorageDir, configured) => self.preferNamespaceStorageDirHintOwner(current, candidate, resolvedStorageDir, configured),
+        get qmd() { return self.qmd; },
+        qmdCollectionNamespaceFromPrefix: (collectionPrefix) => self.qmdCollectionNamespaceFromPrefix(collectionPrefix),
+        rememberNamespaceStorageDirHint: (namespace, storageDir) => self.rememberNamespaceStorageDirHint(namespace, storageDir),
+        storageDirMatchesNamespaceHint: (namespace, storageDir) => self.storageDirMatchesNamespaceHint(namespace, storageDir),
+        get storageRouter() { return self.storageRouter; },
+      });
+    }
+    return this._namespaceReadFanoutCoordinator;
+  }
+
   private async recallInternal(
     prompt: string,
     sessionKey?: string,
@@ -5280,60 +3473,9 @@ export class Orchestrator {
     return this.config.defaultNamespace;
   }
 
-  /**
-   * Lazily-constructed wearables service (Limitless / Bee / Omi
-   * transcript ingestion). All wearables surfaces — CLI, MCP tools,
-   * HTTP routes — share this one instance so sync state, search, and
-   * memory writes stay consistent. Writes are pinned to the same
-   * deterministic namespace bulk-import uses.
-   */
   getWearablesService(): WearablesService {
-    if (!this.wearablesServiceInstance) {
-      this.wearablesServiceInstance = new WearablesService({
-        config: this.config.wearables,
-        getStorage: async () =>
-          await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
-        extract: (turns) => this.extraction.extract(turns),
-        // Smart memoryMode runs candidates through the SAME extraction
-        // judge (cache + defer counters included) the live extraction
-        // pipeline uses, so wearable facts get identical LLM-as-judge
-        // durability gating.
-        judgeFacts: (candidates) =>
-          judgeFactDurability(
-            candidates,
-            this.config,
-            this.localLlm,
-            new FallbackLlmClient(
-              this.config.gatewayConfig,
-              fallbackLlmRuntimeContextFromConfig(this.config),
-            ),
-            this.judgeVerdictCache,
-            this.judgeDeferCounts,
-          ),
-        searchBackend: {
-          search: async (query, maxResults) => {
-            if (!this.qmd.isAvailable()) return null;
-            try {
-              const results = await this.qmd.search(query, undefined, maxResults);
-              return results.map((result) => ({
-                path: result.path,
-                score: result.score,
-                preview: result.snippet,
-              }));
-            } catch {
-              // Backend hiccup → tell the service "unavailable" so it
-              // runs its bounded scan fallback instead of returning a
-              // silent empty result (CLAUDE.md rule 34).
-              return null;
-            }
-          },
-        },
-        reindexSearch: async () => {
-          await this.qmd.update();
-        },
-      });
-    }
-    return this.wearablesServiceInstance;
+    return this.workspaceOpsCoordinator.getWearablesService(
+    );
   }
 
   async ingestBulkImportBatch(
@@ -5593,22 +3735,12 @@ export class Orchestrator {
     storage: StorageManager,
     memoryId: string,
   ): Promise<void> {
-    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) return;
-    if (!(await this.embeddingFallback.isAvailable())) return;
-    const memory = await storage.getMemoryById(memoryId);
-    if (!memory) return;
-    await this.embeddingFallback.indexFile(
+    return this.persistenceIndexCoordinator.indexPersistedMemory(
+      storage,
       memoryId,
-      memory.content,
-      memory.path,
     );
   }
 
-  /**
-   * Build a graph edge for a persisted memory (v8.2).
-   * Shared helper used by both the chunked and non-chunked write paths to avoid duplication.
-   * Fail-open: caller wraps in try/catch.
-   */
   private async buildGraphEdge(
     storage: StorageManager,
     memoryRelPath: string,
@@ -5622,65 +3754,19 @@ export class Orchestrator {
     fallbackCausalPredecessor: string | undefined,
     graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.config),
   ): Promise<void> {
-    // Entity siblings: other memories sharing the same entityRef
-    const entitySiblings: string[] = [];
-    if (entityRef) {
-      try {
-        const allMems = allMemsForGraph ?? [];
-        for (const m of allMems) {
-          if (m.frontmatter.entityRef === entityRef) {
-            const rel = path.relative(storage.dir, m.path);
-            if (rel !== memoryRelPath) entitySiblings.push(rel);
-          }
-        }
-      } catch {
-        /* fail-open */
-      }
-    }
-    // Recent thread memories for time graph
-    const recentInThread: string[] = [];
-    if (threadIdForEdge && threadEpisodeIdsForGraph?.length) {
-      try {
-        recentInThread.push(
-          ...resolveRecentThreadMemoryPaths({
-            threadEpisodeIds: threadEpisodeIdsForGraph,
-            currentMemoryId: memoryId,
-            allMemsForGraph,
-            pathById: memoryPathById,
-            storageDir: storage.dir,
-            maxRecent: 3,
-          }),
-        );
-      } catch {
-        /* fail-open */
-      }
-    }
-    if (
-      recentInThread.length === 0 &&
-      graphCaps.graphWriteSessionAdjacency &&
-      fallbackCausalPredecessor &&
-      fallbackCausalPredecessor !== memoryRelPath
-    ) {
-      recentInThread.push(fallbackCausalPredecessor);
-    }
-    const causalPredecessor =
-      recentInThread[recentInThread.length - 1] ?? fallbackCausalPredecessor;
-    await this.graphIndexFor(storage).onMemoryWritten({
-      memoryPath: memoryRelPath,
+    return this.persistenceIndexCoordinator.buildGraphEdge(
+      storage,
+      memoryRelPath,
       entityRef,
-      content: factContent,
-      created: new Date().toISOString(),
-      threadId: threadIdForEdge,
-      recentInThread,
-      entitySiblings,
-      causalPredecessor,
-      graphCapsOverride: {
-        entityGraph: graphCaps.entityGraph,
-        timeGraph: graphCaps.timeGraph,
-        causalGraph: graphCaps.causalGraph,
-        multiGraphMemory: graphCaps.multiGraphMemory,
-      },
-    });
+      memoryId,
+      factContent,
+      allMemsForGraph,
+      memoryPathById,
+      threadIdForEdge,
+      threadEpisodeIdsForGraph,
+      fallbackCausalPredecessor,
+      graphCaps,
+    );
   }
 
   private graphIndexFor(storage: StorageManager): GraphIndex {
@@ -5692,89 +3778,14 @@ export class Orchestrator {
     return created;
   }
 
-  /**
-   * Batch-update temporal and tag indexes after extraction (v8.1).
-   * Reads each persisted memory's path + frontmatter and adds them to
-   * state/index_time.json and state/index_tags.json.
-   * Fail-open: any error is logged but does not abort extraction.
-   */
   private async updateTemporalTagIndexes(
     storage: StorageManager,
     persistedIds: string[],
   ): Promise<void> {
-    const caps = resolveCapabilities(this.config); // #1566 Cluster C
-    // Build temporal/tag indexes whenever either consumer is enabled:
-    // - queryAwareIndexingEnabled: uses indexes for query-aware prefiltering in recall
-    // - parallelRetrievalEnabled: temporal agent reads index_time.json for date-range lookup
-    // Enabling only parallelRetrievalEnabled without queryAwareIndexingEnabled would silently
-    // produce an empty temporal index, leaving the temporal agent with no data to work from.
-    if (
-      !resolveIndexingCapabilities(this.config).queryAwareIndexing &&
-      !caps.parallelRetrieval
-    )
-      return;
-    // Check for missing indexes BEFORE the early-return so first-time enablement
-    // can bootstrap the full corpus even when this extraction turn persisted nothing.
-    const needsFullRebuild = !indexesExist(this.config.memoryDir);
-    if (!needsFullRebuild && persistedIds.length === 0) return;
-    try {
-      // Read the corpus once to avoid N separate full-corpus scans.
-      // On full rebuild with namespaces enabled, span all configured namespaces so
-      // memories written to other namespaces before the index existed are also captured.
-      const allMemories =
-        needsFullRebuild && resolveNamespaceCapabilities(this.config).namespaces
-          ? await this.readAllMemoriesForNamespaces(
-              Array.from(
-                new Set<string>([
-                  this.config.defaultNamespace,
-                  this.config.sharedNamespace,
-                  ...this.config.namespacePolicies.map((p) => p.name),
-                ]),
-              ),
-            )
-          : await storage.readAllMemories();
-
-      // Bootstrap: index only active (non-archived, non-superseded) memories.
-      // Incremental: index only the newly persisted IDs.
-      const pool = needsFullRebuild
-        ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status))
-        : (() => {
-            const idSet = new Set(persistedIds);
-            return allMemories.filter((m) => idSet.has(m.frontmatter.id));
-          })();
-
-      const entries: Array<{
-        path: string;
-        createdAt: string;
-        tags: string[];
-      }> = [];
-      for (const mem of pool) {
-        if (mem.path && mem.frontmatter?.created) {
-          entries.push({
-            path: mem.path,
-            createdAt: mem.frontmatter.created,
-            tags: mem.frontmatter.tags ?? [],
-          });
-        }
-      }
-      if (needsFullRebuild) {
-        // Always write empty indexes on full rebuild — even when the active pool
-        // is empty (e.g. store contains only archived/superseded entries).
-        // This marks bootstrap completion so indexesExist() returns true and
-        // subsequent extractions skip the full-corpus scan.
-        clearIndexes(this.config.memoryDir);
-        if (entries.length > 0) {
-          indexMemoriesBatch(this.config.memoryDir, entries);
-        }
-        log.info(
-          `temporal-index: bootstrapped from ${entries.length} active memories`,
-        );
-      } else if (entries.length > 0) {
-        indexMemoriesBatch(this.config.memoryDir, entries);
-      }
-    } catch (err) {
-      log.debug(`temporal-index update failed (non-fatal): ${err}`);
-    }
+    return this.persistenceIndexCoordinator.updateTemporalTagIndexes(
+      storage,
+      persistedIds,
+    );
   }
 
   /** IDs of facts persisted in the last extraction */
@@ -5823,93 +3834,16 @@ export class Orchestrator {
   ): Promise<number> {
     return this.lifecyclePolicyCoordinator.runLifecyclePolicyPass(allMemories, storage);
   }
-  /** Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated */
-  private static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8_000;
+  /**
+   * Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated.
+   * Read by WorkspaceOpsCoordinator (seam 24) via `Orchestrator.…`, hence
+   * not `private`.
+   */
+  static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8_000;
 
   private async autoConsolidateIdentity(): Promise<void> {
-    // Fan out over the catalog-union namespace set (issue #1499 sweep): a dynamic
-    // namespace that accumulated IDENTITY.md reflections must also be eligible for
-    // auto-consolidation, otherwise its identity file grows unbounded and is never
-    // consolidated. Falls back to the configured set on any catalog read failure.
-    const namespaces = resolveNamespaceCapabilities(this.config).namespaces
-      ? await this.maintenanceNamespaces()
-      : [this.config.defaultNamespace];
-
-    for (const namespace of namespaces) {
-      const storage = await this.storageRouter.storageFor(namespace);
-      const identityNamespace =
-        resolveNamespaceCapabilities(this.config).namespaces &&
-        namespace !== this.config.defaultNamespace
-          ? namespace
-          : undefined;
-      const reflectionsContent =
-        (await storage.readIdentityReflections()) ?? "";
-
-      const existingIdentity = await storage.readIdentity(
-        this.config.workspaceDir,
-        identityNamespace,
-      );
-      const headerEnd =
-        existingIdentity.indexOf("## Learned Patterns") !== -1
-          ? existingIdentity.indexOf("## Learned Patterns")
-          : existingIdentity.indexOf("## Reflection");
-      const staticHeader =
-        (headerEnd !== -1
-          ? existingIdentity.slice(0, headerEnd)
-          : existingIdentity
-        ).trimEnd() || "# IDENTITY";
-      const identityContent = `${staticHeader}\n\n${reflectionsContent.trim()}\n`;
-      if (identityContent.length < Orchestrator.IDENTITY_CONSOLIDATE_THRESHOLD)
-        continue;
-
-      log.info(
-        `IDENTITY(${namespace}) is ${identityContent.length} chars — auto-consolidating reflections`,
-      );
-      const result = await this.extraction.consolidateIdentity(
-        identityContent,
-        "## Reflection",
-      );
-
-      if (!result || result.learnedPatterns.length === 0) {
-        log.warn(
-          `identity consolidation produced no patterns for namespace=${namespace}`,
-        );
-        continue;
-      }
-
-      const patternsSection = [
-        "## Learned Patterns (consolidated from reflections, " +
-          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("");
-      // NRcCL (codex P2): record a per-namespace catalog write for THIS namespace
-      // after the identity files are updated. This fan-out can mutate a dynamic
-      // namespace via `writeIdentity`/`writeIdentityReflections`, but the
-      // consolidation pass's only consolidated touch covers `this.storage` (the
-      // default) and only fires when `memoryItemMutated` was set by OTHER work — so
-      // a namespace whose sole mutation in the pass is identity consolidation would
-      // otherwise keep a stale `lastWriteAt`, making `listNamespaces({ writtenSince })`
-      // and catalog-recency consumers miss the write. Best-effort and
-      // failure-tolerant (the storage chokepoint (#1522) swallows errors, never crashing the
-      // consolidation; gotcha #13, rule #40). No double-count with the consolidated
-      // touch above: that one is gated on `memoryItemMutated` (which identity
-      // consolidation does not set), and `markWrite` is idempotent regardless.
-      log.info(
-        `IDENTITY(${namespace}) consolidated: ${identityContent.length} → ${newContent.length} chars, ${result.learnedPatterns.length} patterns`,
-      );
-    }
+    return this.workspaceOpsCoordinator.autoConsolidateIdentity(
+    );
   }
 
   // Issue #1526: recall result formatting moved to RecallResultFormatter. Thin
@@ -6198,60 +4132,16 @@ export class Orchestrator {
     );
   }
 
-  /**
-   * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
-   * guard. Returns the top-K embedding hits against the currently indexed
-   * memories, or an empty array when the embedding backend is unavailable.
-   * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
-   * and "error" outcomes as fail-open (keep the candidate).
-   *
-   * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
-   * to the SAME namespace as the fact being written. Otherwise a
-   * high-similarity memory from another namespace can suppress a write in
-   * the target namespace — cross-tenant data loss. Callers pass the target
-   * storage so we can translate its root directory into the correct index
-   * path prefix (and, for the legacy default-namespace layout at
-   * `memoryDir` root, an exclusion list for `namespaces/*`).
-   */
   async semanticDedupLookup(
     content: string,
     limit: number,
     targetStorage: StorageManager,
   ): Promise<SemanticDedupHit[]> {
-    // Round 6 fix (Finding 3): backend-unavailable conditions must THROW so
-    // that `decideSemanticDedup`'s catch block can return
-    // reason="backend_unavailable".  Previously all error/unavailable paths
-    // returned [] — causing decideSemanticDedup to always report
-    // reason="no_candidates" even when the provider was actually down.
-    //
-    // Contract after this fix:
-    //   • embeddingFallbackEnabled=false  → throw (feature not configured;
-    //     caller treats this as backend_unavailable and fails open).
-    //   • isAvailable() returns false     → throw (provider is reachable but
-    //     reports itself unavailable; distinct from empty index).
-    //   • search() throws                 → re-throw (network/provider error).
-    //   • search() returns []             → return [] (empty index, not a
-    //     backend failure; decideSemanticDedup reports no_candidates).
-    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) {
-      throw new Error("semantic dedup: embedding backend not configured");
-    }
-    if (!(await this.embeddingFallback.isAvailable())) {
-      log.debug("semantic dedup: embedding backend unavailable, skipping");
-      throw new Error("semantic dedup: embedding backend unavailable");
-    }
-    // search() may throw — let it propagate so decideSemanticDedup catches it
-    // and returns reason="backend_unavailable". Pass throwOnTimeout:true so
-    // EmbeddingTimeoutError is re-thrown here (Round 10 fix, Ui1J+Ui1L: the
-    // recall-path caller searchEmbeddingFallback does NOT pass this flag,
-    // keeping its fail-open [] contract on timeout).
-    const scope = this.semanticDedupScopeFor(targetStorage);
-    const hits = await this.embeddingFallback.search(content, limit, { ...scope, throwOnTimeout: true });
-    if (!Array.isArray(hits) || hits.length === 0) return [];
-    return hits.map((hit) => ({
-      id: hit.id,
-      score: hit.score,
-      path: hit.path,
-    }));
+    return this.persistenceIndexCoordinator.semanticDedupLookup(
+      content,
+      limit,
+      targetStorage,
+    );
   }
 
   /**
@@ -6404,52 +4294,9 @@ export class Orchestrator {
     }
   }
 
-  /**
-   * Flush access tracking buffer to disk.
-   * Called during consolidation or when buffer is full.
-   */
   async flushAccessTracking(): Promise<void> {
-    if (this.accessTrackingBuffer.size === 0) return;
-
-    // Build entries from buffer, merging with existing counts
-    const entries: AccessTrackingEntry[] = [];
-    const namespaces = resolveNamespaceCapabilities(this.config).namespaces
-      ? Array.from(
-          new Set<string>([
-            this.config.defaultNamespace,
-            this.config.sharedNamespace,
-            ...this.config.namespacePolicies.map((p) => p.name),
-          ]),
-        )
-      : [this.config.defaultNamespace];
-    const memories = await this.readAllMemoriesForNamespaces(namespaces);
-    const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-
-    for (const [memoryId, update] of this.accessTrackingBuffer) {
-      const memory = memoryMap.get(memoryId);
-      const existingCount = memory?.frontmatter.accessCount ?? 0;
-      entries.push({
-        memoryId,
-        newCount: existingCount + update.count,
-        lastAccessed: update.lastAccessed,
-      });
-    }
-
-    const byNamespace = new Map<string, AccessTrackingEntry[]>();
-    for (const e of entries) {
-      const m = memoryMap.get(e.memoryId);
-      if (!m) continue;
-      const ns = this.namespaceFromPath(m.path);
-      const list = byNamespace.get(ns) ?? [];
-      list.push(e);
-      byNamespace.set(ns, list);
-    }
-    for (const [ns, list] of byNamespace) {
-      const sm = await this.storageRouter.storageFor(ns);
-      await sm.flushAccessTracking(list);
-    }
-    this.accessTrackingBuffer.clear();
-    log.debug(`flushed ${entries.length} access tracking entries`);
+    return this.workspaceOpsCoordinator.flushAccessTracking(
+    );
   }
 
   private async loadSearchResultMemoryMap(
@@ -6698,29 +4545,15 @@ export class Orchestrator {
   }
 
   private namespaceFromPath(p: string): string {
-    if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.defaultNamespace;
-    const parts = qmdCollectionPathParts(p);
-    const collectionNamespace = parts
-      ? this.qmdCollectionNamespaceFromPrefix(parts.collection)
-      : null;
-    if (collectionNamespace) return collectionNamespace;
-    const m = p.match(/[\\/]+namespaces[\\/]+([^\\/]+)(?:[\\/]|$)/);
-    if (!m?.[1]) return this.config.defaultNamespace;
-    return namespaceIdentityFromToken(m[1]) ?? m[1];
+    return this.namespaceReadFanoutCoordinator.namespaceFromPath(
+      p,
+    );
   }
 
   private storageDirNamespace(storageDir: string): string {
-    // #1521: delegates to the scope-module resolver. The inline dir→namespace
-    // derivation (token round-trip guard, catalog hints) is retired so the
-    // adHocNamespaceResolutions ratchet no longer counts this site. Hints are
-    // loaded lazily via the callback (only after early returns, matching the
-    // original behavior — codex P2).
-    return resolveNamespaceFromStorageDir(storageDir, {
-      config: this.config,
-      configuredNamespaces: this.configuredNamespaceList(),
-      hints: this.namespaceStorageDirHints,
-      loadHints: () => this.loadNamespaceStorageDirHintsFromCatalog(),
-    });
+    return this.namespaceReadFanoutCoordinator.storageDirNamespace(
+      storageDir,
+    );
   }
 
   // #1522: catalog touch methods removed — touches now happen at the storage chokepoint.
@@ -6746,26 +4579,16 @@ export class Orchestrator {
   private async readAllMemoriesForNamespaces(
     namespaces: string[],
   ): Promise<MemoryFile[]> {
-    const uniq = Array.from(new Set(namespaces.filter(Boolean)));
-    const lists = await Promise.all(
-      uniq.map(async (ns) => {
-        const sm = await this.storageRouter.storageFor(ns);
-        return sm.readAllMemories();
-      }),
+    return this.namespaceReadFanoutCoordinator.readAllMemoriesForNamespaces(
+      namespaces,
     );
-    return lists.flat();
   }
 
   private async readArchivedMemoriesForNamespaces(
     namespaces: string[],
   ): Promise<MemoryFile[]> {
-    const uniq = Array.from(new Set(namespaces.filter(Boolean)));
-    const lists = await Promise.all(
-      uniq.map(async (ns) => {
-        const sm = await this.storageRouter.storageFor(ns);
-        return sm.readArchivedMemories();
-      }),
+    return this.namespaceReadFanoutCoordinator.readArchivedMemoriesForNamespaces(
+      namespaces,
     );
-    return lists.flat();
   }
 }