@remnic/core 9.3.752 → 9.3.754

package/src/access-service.ts

@@ -251,6 +251,8 @@ import {
 import { formatProfileTraceAscii } from "./profiling.js";
 import { resolveAccessSetupCapabilities, resolveGraphConstructionCapabilities, resolveIndexingCapabilities } from "./capabilities.js";
 import { resolveRecallEnhancementCapabilities } from "./capabilities.js";
+import { AccessLcmSurface } from "./access-lcm-surface.js";
+import { AccessAdminOpsSurface } from "./access-admin-ops-surface.js";
 import { AccessRecallSurface } from "./access-recall-surface.js";
 import { selfDeps } from "./orchestration/self-deps.js";
 
@@ -302,12 +304,12 @@ function qmdResultPathCandidates(
   return [...candidates];
 }
 
-type AccessProfilingReportRequest = {
+export type AccessProfilingReportRequest = {
   format?: string;
   limit?: number;
 };
 
-type AccessProfilingReportResponse = {
+export type AccessProfilingReportResponse = {
   enabled: boolean;
   format?: "ascii" | "json";
   report?: string;
@@ -860,7 +862,7 @@ export interface EngramAccessOfflineSyncApplyResponse extends OfflineSyncApplyCh
 export type EngramAccessActionConfidenceRequest = ActionConfidenceInput;
 export type EngramAccessActionConfidenceResponse = ActionConfidenceResult;
 
-async function buildProjectedGovernanceProposedActions(
+export async function buildProjectedGovernanceProposedActions(
   storage: Awaited<ReturnType<Orchestrator["getStorage"]>>,
   projected: NonNullable<Awaited<ReturnType<Awaited<ReturnType<Orchestrator["getStorage"]>>["getProjectedGovernanceRecord"]>>>,
 ): Promise<Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["appliedActions"]> {
@@ -879,7 +881,7 @@ async function buildProjectedGovernanceProposedActions(
   return buildProposedActions(reviewQueue, memories);
 }
 
-function hasGroupedGovernanceActions(
+export function hasGroupedGovernanceActions(
   grouped?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["transitionReport"]["proposed"],
 ): boolean {
   if (!grouped) return false;
@@ -1307,6 +1309,30 @@ export class EngramAccessService {
   private readonly budget: CrossNamespaceBudget;
   private readonly auditAdapter: AccessAuditAdapter | null;
 
+  /** AccessLcmSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+  private _accessLcmSurface: AccessLcmSurface | undefined;
+
+  private get accessLcmSurface(): AccessLcmSurface {
+    if (!this._accessLcmSurface) {
+      this._accessLcmSurface = new AccessLcmSurface(
+        selfDeps<ConstructorParameters<typeof AccessLcmSurface>[0]>(this),
+      );
+    }
+    return this._accessLcmSurface;
+  }
+
+  /** AccessAdminOpsSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+  private _accessAdminOpsSurface: AccessAdminOpsSurface | undefined;
+
+  private get accessAdminOpsSurface(): AccessAdminOpsSurface {
+    if (!this._accessAdminOpsSurface) {
+      this._accessAdminOpsSurface = new AccessAdminOpsSurface(
+        selfDeps<ConstructorParameters<typeof AccessAdminOpsSurface>[0]>(this),
+      );
+    }
+    return this._accessAdminOpsSurface;
+  }
+
   /** AccessRecallSurface (access-service decomposition). Lazy; selfDeps live wiring. */
   private _accessRecallSurface: AccessRecallSurface | undefined;
 
@@ -3835,97 +3861,11 @@ export class EngramAccessService {
   }
 
   async reviewQueue(runId?: string, namespace?: string, principal?: string): Promise<EngramAccessReviewQueueResponse> {
-    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const projected = await storage.getProjectedGovernanceRecord();
-    if (projected && (!runId || projected.runId === runId.trim())) {
-      const projectedAppliedActions = projected.appliedActionRows.map((row) => ({
-        action: row.action,
-        memoryId: row.memoryId,
-        reasonCode: row.reasonCode,
-        beforeStatus: row.beforeStatus,
-        afterStatus: row.afterStatus,
-        originalPath: row.originalPath,
-        currentPath: row.currentPath,
-      })) as Awaited<
-        ReturnType<typeof readMemoryGovernanceRunArtifact>
-      >["appliedActions"];
-      const projectedProposedActions = await buildProjectedGovernanceProposedActions(storage, projected);
-      const projectedArtifact = await (async () => {
-        try {
-          return await readMemoryGovernanceRunArtifact(storage.dir, projected.runId);
-        } catch {
-          return null;
-        }
-      })();
-      const metrics = projected.metrics as Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["metrics"];
-      const fallbackTransitionReport = {
-        proposed: groupActionsByStatus(projectedProposedActions),
-        applied: groupActionsByStatus(projectedAppliedActions),
-      };
-      const transitionReport = projectedArtifact?.transitionReport
-        ? {
-            proposed:
-              hasGroupedGovernanceActions(projectedArtifact.transitionReport.proposed) || projectedProposedActions.length === 0
-                ? projectedArtifact.transitionReport.proposed
-                : fallbackTransitionReport.proposed,
-            applied:
-              hasGroupedGovernanceActions(projectedArtifact.transitionReport.applied) || projectedAppliedActions.length === 0
-                ? projectedArtifact.transitionReport.applied
-                : fallbackTransitionReport.applied,
-          }
-        : fallbackTransitionReport;
-      const qualityScore = projectedArtifact?.qualityScore ?? metrics?.qualityScore ?? buildQualityScore(metrics?.reviewReasons ?? {
-        exact_duplicate: 0,
-        semantic_duplicate_candidate: 0,
-        disputed_memory: 0,
-        speculative_low_confidence: 0,
-        archive_candidate: 0,
-        explicit_capture_review: 0,
-        malformed_import: 0,
-      });
-      const effectiveMetrics = metrics ? { ...metrics, qualityScore: metrics.qualityScore ?? qualityScore } : metrics;
-
-      return {
-        found: true,
-        namespace: resolvedNamespace,
-        runId: projected.runId,
-        summary: projected.summary as Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["summary"],
-        metrics: effectiveMetrics,
-        qualityScore,
-        reviewQueue: projected.reviewQueueRows.map((row) => ({
-          entryId: row.entryId,
-          memoryId: row.memoryId,
-          path: row.path,
-          reasonCode: row.reasonCode,
-          severity: row.severity,
-          suggestedAction: row.suggestedAction,
-          suggestedStatus: row.suggestedStatus,
-          relatedMemoryIds: row.relatedMemoryIds,
-        })) as Awaited<
-          ReturnType<typeof readMemoryGovernanceRunArtifact>
-        >["reviewQueue"],
-        appliedActions: projectedAppliedActions,
-        transitionReport,
-        report: projected.report,
-      };
-    }
-
-    const resolvedRunId = runId?.trim() || (await listMemoryGovernanceRuns(storage.dir))[0];
-    if (!resolvedRunId) return { found: false, namespace: resolvedNamespace };
-    const artifact = await readMemoryGovernanceRunArtifact(storage.dir, resolvedRunId);
-    return {
-      found: true,
-      namespace: resolvedNamespace,
-      runId: resolvedRunId,
-      summary: artifact.summary,
-      metrics: artifact.metrics,
-      qualityScore: artifact.qualityScore,
-      reviewQueue: artifact.reviewQueue,
-      appliedActions: artifact.appliedActions,
-      transitionReport: artifact.transitionReport,
-      report: artifact.report,
-    };
+    return this.accessAdminOpsSurface.reviewQueue(
+      runId,
+      namespace,
+      principal,
+    );
   }
 
   async maintenance(namespace?: string, principal?: string): Promise<EngramAccessMaintenanceResponse> {
@@ -4010,56 +3950,10 @@ export class EngramAccessService {
     summaryPath: string;
     reportPath: string;
   }> {
-    const deepSleep = this.orchestrator.config.dreamsPhases.deepSleep;
-    if (deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
-      throw new Error("memory governance is disabled by dreams.phases.deepSleep.enabled=false");
-    }
-    const resolvedNamespace = this.writableNamespaceFor(
-      request.namespace,
-      undefined,
-      request.authenticatedPrincipal ?? principal,
+    return this.accessAdminOpsSurface.governanceRun(
+      request,
+      principal,
     );
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const mode = request.mode === "apply" ? "apply" : "shadow";
-    const boundedBatchSize =
-      typeof request.batchSize === "number" && Number.isFinite(request.batchSize)
-        ? Math.max(1, Math.floor(request.batchSize))
-        : undefined;
-    const result = await runMemoryGovernance({
-      memoryDir: storage.dir,
-      mode,
-      recentDays:
-        typeof request.recentDays === "number" && Number.isFinite(request.recentDays)
-          ? Math.max(1, Math.floor(request.recentDays))
-          : undefined,
-      maxMemories:
-        typeof request.maxMemories === "number" && Number.isFinite(request.maxMemories)
-          ? Math.max(1, Math.floor(request.maxMemories))
-          : undefined,
-      batchSize: boundedBatchSize,
-    });
-    if (mode === "apply") {
-      try {
-        await this.orchestrator.processEntitySynthesisQueue(
-          resolvedNamespace,
-          Math.min(boundedBatchSize ?? 5, 5),
-        );
-      } catch (error) {
-        log.debug(`governanceRun: entity synthesis refresh failed after governance apply: ${error}`);
-      }
-    }
-
-    return {
-      namespace: resolvedNamespace,
-      runId: result.runId,
-      traceId: result.traceId,
-      mode: result.mode,
-      reviewQueueCount: result.reviewQueue.length,
-      proposedActionCount: result.proposedActions.length,
-      appliedActionCount: result.appliedActions.length,
-      summaryPath: result.summaryPath,
-      reportPath: result.reportPath,
-    };
   }
 
   async procedureMiningRun(
@@ -4225,160 +4119,17 @@ export class EngramAccessService {
     reason?: string;
     retryAfterMs?: number;
   }> {
-    if (!resolveIndexingCapabilities(this.orchestrator.config).conversationIndex) {
-      return {
-        enabled: false,
-        sessions: 0,
-        chunks: 0,
-        skipped: 0,
-        skippedSessionKeys: [],
-        embeddedRuns: 0,
-        reason: "disabled",
-      };
-    }
-
-    const hours =
-      typeof request.hours === "number" && Number.isFinite(request.hours)
-        ? Math.max(1, Math.floor(request.hours))
-        : 24;
-
-    let sessionKey: string | undefined;
-    if (request.sessionKey !== undefined) {
-      if (typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
-        throw new EngramAccessInputError("sessionKey must be a non-empty string when provided");
-      }
-      sessionKey = request.sessionKey.trim();
-    }
-
-    if (sessionKey) {
-      const result = await this.orchestrator.updateConversationIndex(
-        sessionKey,
-        hours,
-        { embed: request.embed },
-      );
-      return {
-        enabled: true,
-        sessionKey,
-        sessions: 1,
-        chunks: result.chunks,
-        skipped: result.skipped ? 1 : 0,
-        skippedSessionKeys: result.skipped ? [sessionKey] : [],
-        embeddedRuns: result.embedded ? 1 : 0,
-        reason: result.reason,
-        retryAfterMs: result.retryAfterMs,
-      };
-    }
-
-    const sessionKeys = await this.orchestrator.transcript.listSessionKeys();
-    let chunks = 0;
-    let skipped = 0;
-    const skippedSessionKeys: string[] = [];
-    let embeddedRuns = 0;
-
-    for (const sessionKey of sessionKeys) {
-      const result = await this.orchestrator.updateConversationIndex(
-        sessionKey,
-        hours,
-        { embed: request.embed },
-      );
-      chunks += result.chunks;
-      if (result.skipped) {
-        skipped += 1;
-        skippedSessionKeys.push(sessionKey);
-      }
-      if (result.embedded) {
-        embeddedRuns += 1;
-      }
-    }
-
-    return {
-      enabled: true,
-      sessions: sessionKeys.length,
-      chunks,
-      skipped,
-      skippedSessionKeys,
-      embeddedRuns,
-    };
+    return this.accessAdminOpsSurface.conversationIndexUpdate(
+      request,
+    );
   }
 
   async profilingReport(
     request: AccessProfilingReportRequest = {},
   ): Promise<AccessProfilingReportResponse> {
-    const profiler = this.orchestrator.profiler;
-    if (!profiler.isEnabled) {
-      return {
-        enabled: false,
-        reason: "disabled",
-        message: "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable.",
-      };
-    }
-
-    const format = request.format ?? "ascii";
-    if (format !== "ascii" && format !== "json") {
-      throw new EngramAccessInputError("format must be one of: ascii, json");
-    }
-
-    const limit = request.limit ?? 5;
-    if (!Number.isInteger(limit) || limit < 1 || limit > 20) {
-      throw new EngramAccessInputError("limit must be an integer between 1 and 20");
-    }
-
-    const traces = profiler.getRecentTraces(limit);
-    const stats = profiler.getStats();
-    const bottleneck = profiler.identifyBottleneck();
-
-    if (format === "json") {
-      return {
-        enabled: true,
-        format,
-        traces,
-        stats,
-        bottleneck,
-      };
-    }
-
-    const lines: string[] = [];
-    lines.push("Engram Profiling Report");
-    lines.push("=".repeat(60));
-    lines.push("");
-
-    type BucketEntry = { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number };
-    const allBuckets: Array<[string, Record<string, BucketEntry>]> = [
-      ["byKind", stats.byKind],
-      ["bySpan", stats.bySpan],
-    ];
-    const hasStats = allBuckets.some(([, entries]) => Object.keys(entries).length > 0);
-    if (hasStats) {
-      lines.push("Aggregate Stats (all retained traces):");
-      for (const [bucket, entries] of allBuckets) {
-        for (const [key, summary] of Object.entries(entries)) {
-          lines.push(
-            `  ${bucket}/${key}: avg=${summary.avgMs}ms p50=${summary.p50Ms}ms p95=${summary.p95Ms}ms max=${summary.maxMs}ms (n=${summary.count})`,
-          );
-        }
-      }
-      lines.push("");
-    }
-
-    if (bottleneck) {
-      lines.push(`Bottleneck: ${bottleneck}`);
-      lines.push("");
-    }
-
-    if (traces.length === 0) {
-      lines.push("No traces recorded yet. Trigger a recall or extraction to see timing data.");
-    } else {
-      for (const trace of traces) {
-        lines.push(formatProfileTraceAscii(trace));
-        lines.push("");
-      }
-    }
-
-    return {
-      enabled: true,
-      format,
-      report: lines.join("\n"),
-    };
+    return this.accessAdminOpsSurface.profilingReport(
+      request,
+    );
   }
 
   async trustZoneStatus(namespace?: string, principal?: string): Promise<EngramAccessTrustZoneStatusResponse> {
@@ -4865,212 +4616,9 @@ export class EngramAccessService {
   }
 
   async lcmSearch(request: EngramAccessLcmSearchRequest): Promise<EngramAccessLcmSearchResponse> {
-    if (!request.query || typeof request.query !== "string" || request.query.trim().length === 0) {
-      throw new EngramAccessInputError("query is required and must be a non-empty string");
-    }
-
-    const principal = this.resolveRequestPrincipal(request.sessionKey, request.authenticatedPrincipal);
-    const hasExplicitNamespace =
-      typeof request.namespace === "string" &&
-      request.namespace.trim().length > 0;
-    // Resolve the readable base namespace WITHOUT pre-authorizing `default`
-    // (#1505 thread NBHWz). An EXPLICIT namespace is still authorized strictly
-    // via `resolveReadableNamespace` (explicit reads must pass the ACL — throws
-    // on an unreadable explicit namespace). For an IMPLICIT read, derive the
-    // fallback from the ALREADY read-authorized recall namespace set instead of
-    // read-authorizing `config.defaultNamespace`: under a restrictive `default`
-    // READ policy where the principal's self namespace is readable, normal recall
-    // still succeeds via `recallNamespacesForPrincipal`, so `lcmSearch` must too
-    // (the same defect class the raw-excerpt path fixes). `undefined` ⇒ no
-    // readable LCM namespace exists, so return NO rows rather than throwing.
-    const profileLcmReadNamespaces = hasExplicitNamespace
-      ? null
-      : this.resolveScopeProfileLcmReadNamespaces(
-          request.sessionKey,
-          request.authenticatedPrincipal,
-        );
-    const namespace = hasExplicitNamespace
-      ? this.resolveReadableNamespace(request.namespace, principal)
-      : profileLcmReadNamespaces !== null
-        ? profileLcmReadNamespaces[0]
-        : this.resolveImplicitLcmReadFallbackNamespace(principal);
-
-    if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
-      return {
-        query: request.query,
-        namespace: namespace ?? this.orchestrator.config.defaultNamespace,
-        results: [],
-        count: 0,
-        lcmEnabled: false,
-      };
-    }
-
-    // An active scope profile with no readable layers is authoritative: search
-    // no legacy/default LCM keys instead of falling back around the profile.
-    if (profileLcmReadNamespaces !== null && profileLcmReadNamespaces.length === 0) {
-      return {
-        query: request.query,
-        namespace: this.orchestrator.config.defaultNamespace,
-        results: [],
-        count: 0,
-        lcmEnabled: true,
-      };
-    }
-
-    // No readable LCM namespace for an IMPLICIT read (restrictive `default` READ
-    // policy, no readable overlay/self) ⇒ return NO rows instead of pre-
-    // authorizing the denied default (#1505 thread NBHWz). Normal recall still
-    // succeeds through the readable self namespace; LCM search degrades to empty.
-    if (namespace === undefined) {
-      return {
-        query: request.query,
-        namespace: this.orchestrator.config.defaultNamespace,
-        results: [],
-        count: 0,
-        lcmEnabled: true,
-      };
-    }
-
-    const limit = Math.max(1, Math.min(request.limit ?? 10, 100));
-    // Route the LCM read session_id AND prefix through the SAME overlay-aware
-    // namespace `observe`'s write key and compaction use (#1505 round 3). A
-    // project-scoped `observe` with no explicit namespace archived under the
-    // coding-overlay namespace; deriving the prefix only from the readable
-    // `namespace` (as before) would search the raw key and miss those turns.
-    // The effective namespace is resolved ONCE from the real session
-    // (`request.sessionKey`) — the prefix is a search fragment with no bound
-    // coding context, so it inherits the same namespace. Collapses to the raw key
-    // for single-store / no-overlay / explicit-default flows (existing behavior).
-    const lcmReadNamespace = profileLcmReadNamespaces !== null
-      ? profileLcmReadNamespaces[0] ?? this.orchestrator.config.defaultNamespace
-      : this.resolveLcmReadNamespace(
-          request.namespace,
-          namespace,
-          request.sessionKey,
-          request.authenticatedPrincipal,
-        );
-    // Ordered, read-authorized LCM read key SET for a concrete `sessionKey`
-    // (#1505 fallback unification + #1501 scope profiles). A branch-scoped
-    // session whose rows were archived at project/root scope is found by querying
-    // the primary overlay key first, then each fallback. When a scope profile is
-    // active, the profile's expanded read namespace set is authoritative,
-    // including the empty set.
-    const lcmSessionKeyIds = request.sessionKey
-      ? profileLcmReadNamespaces !== null
-        ? this.lcmSessionIdsForNamespaces(
-            profileLcmReadNamespaces,
-            request.sessionKey,
-          )
-        : this.resolveLcmReadSessionIds(
-            request.namespace,
-            namespace,
-            request.sessionKey,
-            request.authenticatedPrincipal,
-          )
-      : [undefined];
-    const lcmSessionPrefixes = request.sessionPrefix
-      ? profileLcmReadNamespaces !== null && !request.sessionKey
-        ? this.lcmSessionIdsForNamespaces(
-            profileLcmReadNamespaces,
-            request.sessionPrefix,
-          )
-        : [
-            lcmSessionKeyForNamespace(
-              lcmReadNamespace,
-              request.sessionPrefix,
-              this.orchestrator.config.defaultNamespace,
-            ) ?? request.sessionPrefix,
-          ]
-      : [undefined];
-    // SECURITY (#1495 P1 + codex P1 r2 "Require a scoped LCM filter before
-    // archive searches"): a sessionless, prefixless `lcmSearch` issues
-    // `searchContextFull(query, limit, undefined, undefined)`, an archive-wide
-    // FTS scan over EVERY `session_id`, including the sentinel-framed
-    // `<ns>`-scoped overlay/tenant rows. The LCM archive is keyed by the
-    // `session_id` STRING and is NOT partitioned by namespace, so an unscoped
-    // scan CANNOT be constrained to the caller's authorized namespace — neither
-    // an explicit `namespace` nor a readable `default` confines its results to
-    // rows the caller may read. The scan is therefore safe ONLY in single-store
-    // mode (namespaces disabled, one shared archive owned by the caller). When
-    // namespaces are ENABLED, an unscoped `lcmSearch` (no `sessionKey` AND no
-    // `sessionPrefix`) must be SUPPRESSED — return EMPTY — regardless of an
-    // explicit namespace or default-readability, so a caller authorized for
-    // `default` (or for one explicit namespace) cannot read other namespaces'
-    // transcript rows via the archive-wide scan (cross-tenant read leak). A
-    // SCOPED call (sessionKey or sessionPrefix present) is unaffected: it carries
-    // a namespace-framed `session_id` / prefix filter that already constrains the
-    // search to the caller's authorized, read-gated namespace.
-    const hasScopedSession =
-      (typeof request.sessionKey === "string" &&
-        request.sessionKey.length > 0) ||
-      lcmSessionPrefixes.some((prefix) => typeof prefix === "string" && prefix.length > 0);
-    if (!hasScopedSession && resolveNamespaceCapabilities(this.orchestrator.config).namespaces === true) {
-      return {
-        query: request.query,
-        namespace,
-        results: [],
-        count: 0,
-        lcmEnabled: true,
-      };
-    }
-    // Query each LCM read key in order, merging + deduping rows (by
-    // sessionId+turnIndex) and preserving first-seen order, capped at `limit`.
-    // Use allSettled so one corrupt/failed namespace key cannot discard sibling
-    // results from other authorized profile namespaces.
-    const seenRows = new Set<string>();
-    const results: Array<{ sessionId: string; content: string; turnIndex: number }> = [];
-    const lcmSearches: Array<{
-      key: string | undefined;
-      prefix: string | undefined;
-      promise: Promise<Array<{ session_id: string; content: string; turn_index: number }>>;
-    }> = [];
-    for (const lcmSessionKey of lcmSessionKeyIds) {
-      for (const lcmSessionPrefix of lcmSessionPrefixes) {
-        lcmSearches.push({
-          key: lcmSessionKey,
-          prefix: lcmSessionPrefix,
-          promise: this.orchestrator.lcmEngine.searchContextFull(
-            request.query,
-            limit,
-            lcmSessionKey,
-            lcmSessionPrefix,
-          ) as Promise<Array<{ session_id: string; content: string; turn_index: number }>>,
-        });
-      }
-    }
-    const settledSearches = await Promise.allSettled(
-      lcmSearches.map((search) => search.promise),
+    return this.accessLcmSurface.lcmSearch(
+      request,
     );
-    for (let i = 0; i < settledSearches.length; i += 1) {
-      if (results.length >= limit) break;
-      const settled = settledSearches[i];
-      if (!settled || settled.status === "rejected") {
-        const failed = lcmSearches[i];
-        log.warn(
-          `lcmSearch: failed for key=${failed?.key ?? "<none>"} prefix=${failed?.prefix ?? "<none>"}: ${settled?.status === "rejected" ? settled.reason : "missing result"}`,
-        );
-        continue;
-      }
-      for (const r of settled.value) {
-        const dedupeKey = `${r.session_id}\0${r.turn_index}`;
-        if (seenRows.has(dedupeKey)) continue;
-        seenRows.add(dedupeKey);
-        results.push({
-          sessionId: r.session_id,
-          content: r.content,
-          turnIndex: r.turn_index,
-        });
-        if (results.length >= limit) break;
-      }
-    }
-
-    return {
-      query: request.query,
-      namespace,
-      results,
-      count: results.length,
-      lcmEnabled: true,
-    };
   }
 
   /**
@@ -5095,38 +4643,6 @@ export class EngramAccessService {
    * so the read key is byte-for-byte what the LCM write and the recall readers
    * use.
    */
-  /**
-   * Resolve the effective LCM NAMESPACE a same-session operation must prefix
-   * with (the namespace half of {@link resolveLcmReadSessionKey}). Split out so
-   * `lcmSearch` can apply ONE namespace to BOTH its `sessionKey` and its
-   * `sessionPrefix` — the prefix is a search fragment, not a real session, so its
-   * own coding context can't be looked up; it must inherit the namespace resolved
-   * from the real session (`sessionKeyForOverlay`).
-   *
-   * `purpose` selects the AUTHORIZATION gate applied before honouring the
-   * coding overlay (#1505 round 3 + round 4, codex P2):
-   *
-   *  - `"read"` (`lcmSearch` / raw-excerpt recall): the overlay rows are only
-   *    visible when the principal SELF base is in the READABLE RECALL SET — the
-   *    same gate the orchestrator's `lcmReadNamespaceForSession` and the recall
-   *    namespace set use (`recallNamespacesForPrincipal`, gated by both
-   *    `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). A
-   *    caller that passed the default read check must NOT receive
-   *    `<principal>-project-*` rows the policy never granted (cross-tenant read
-   *    leak). When the self base is not readable, keep the just-authorized
-   *    namespace (collapses to the raw key on the default store).
-   *
-   *  - `"write"` (`lcmCompactionFlush` / `lcmCompactionRecord`): these are
-   *    write/maintenance operations on the SAME queue `observe` just wrote, so
-   *    the gate must mirror observe's WRITE authorization (`canWriteNamespace`
-   *    on the self base), NOT readability. A principal that can WRITE but not
-   *    READ its self namespace (or whose `defaultRecallNamespaces` omits `self`)
-   *    archived under the overlay key via `observe`; gating compaction by
-   *    readability would fall back to the default/raw key and leave that queue
-   *    never flushed/recorded (round-4 codex P2). Write-authorized ⇒ overlay
-   *    key, matching the observe write key (rule 42 read/write parity; rule 39
-   *    identical gates across paths).
-   */
   private resolveLcmReadNamespace(
     explicitNamespace: string | undefined,
     resolvedNamespace: string,
@@ -5134,134 +4650,24 @@ export class EngramAccessService {
     authenticatedPrincipal: string | undefined,
     purpose: "read" | "write" = "read",
   ): string {
-    const hasExplicitNamespace =
-      typeof explicitNamespace === "string" && explicitNamespace.trim().length > 0;
-    if (hasExplicitNamespace) return resolvedNamespace;
-    // Mirror observe's write resolution: use the coding-overlay namespace when
-    // one applies, else the default store. NOT the principal self base — an
-    // unqualified observe archives under the default store, so a self-base prefix
-    // here would target a queue observe never wrote to (#1495).
-    const principal = this.resolveRequestPrincipal(
+    return this.accessLcmSurface.resolveLcmReadNamespace(
+      explicitNamespace,
+      resolvedNamespace,
       sessionKeyForOverlay,
       authenticatedPrincipal,
+      purpose,
     );
-    const base = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
-    const overlaid = this.orchestrator.applyCodingNamespaceOverlay(
-      sessionKeyForOverlay,
-      base,
-    );
-    // No overlay → the default store (raw sessionKey), as before.
-    if (overlaid === base) return this.orchestrator.config.defaultNamespace;
-    // Overlay applied. Authorize access to the principal's `<principal>-project-*`
-    // overlay base before switching the LCM key to it. The gate differs by
-    // operation purpose (see the doc comment): reads use the readable-recall-set
-    // gate (no cross-tenant read leak), writes use observe's write authorization
-    // (so compaction targets the same overlay queue observe wrote to).
-    const authorized =
-      purpose === "write"
-        ? canWriteNamespace(principal, base, this.orchestrator.config)
-        : recallNamespacesForPrincipal(
-            principal,
-            this.orchestrator.config,
-          ).includes(base);
-    if (authorized) return overlaid;
-    // Unauthorized overlay base. For READS, collapse to the DEFAULT STORE (the
-    // raw sessionKey) EXACTLY like the orchestrator's `lcmReadNamespaceForSession`
-    // (rule 39 / 42) — NOT the caller's `resolvedNamespace`, which for an implicit
-    // read can be a readable recall namespace (e.g. `shared`). Returning that
-    // would prefix LCM reads with `shared:sessionKey` while in-prompt recall uses
-    // the raw `sessionKey`, diverging `lcmSearch`/raw disclosure from orchestrator
-    // LCM reads (cursor "LCM read gate wrong fallback"). For an explicit read the
-    // method already returned at the top, so this only affects implicit reads.
-    // The (currently unused) write purpose preserves its prior `resolvedNamespace`
-    // fallback for backward compatibility.
-    if (purpose === "read") return this.orchestrator.config.defaultNamespace;
-    return resolvedNamespace;
   }
 
-  /**
-   * Resolve the namespace the raw-disclosure excerpt lookup
-   * ({@link fetchRawExcerpts}) must prefix its LCM `session_id` with (#1505
-   * thread 2f7). Raw disclosure reads the SAME LCM archive `lcmSearch` and the
-   * in-prompt LCM sections read, so it MUST pass through the identical
-   * read-authorization gate — NOT `snapshot.namespace`, which records the
-   * effective WRITE/overlay namespace (`<principal>-project-*`) even when the
-   * principal can WRITE but not READ its self base (or `defaultRecallNamespaces`
-   * omits `self`). Routing through `resolveLcmReadNamespace(..., "read")` makes
-   * raw disclosure fall back to the default store exactly like normal recall +
-   * `lcmSearch`, so it never attaches overlay transcript rows the read gate
-   * excludes (cross-tenant read leak). Collapses to the default store / raw
-   * sessionKey for single-store / no-overlay / explicit-default flows, so
-   * single-user recall is byte-for-byte unchanged.
-   *
-   * Returns `undefined` when NO readable LCM namespace exists for an IMPLICIT
-   * (no explicit `namespace`) raw recall — i.e. a restrictive `default` READ
-   * policy denies the principal `default` AND no overlay/self namespace is
-   * readable. In that case the caller emits NO excerpts rather than throwing
-   * `namespace is not readable: default` (#1505 thread NBHWz): normal recall
-   * still succeeds via `recallNamespacesForPrincipal`, so `disclosure: "raw"`
-   * must degrade gracefully (empty excerpts), never pre-authorize `default`.
-   *
-   * IMPLICIT-namespace fallback selection derives from the ALREADY
-   * read-authorized recall namespace set (`recallNamespacesForPrincipal` +
-   * `canReadNamespace`) — the principal's self base when it is in the readable
-   * recall set, else `config.defaultNamespace` ONLY when the principal may read
-   * it. It NEVER pre-authorizes `default`. An EXPLICIT `namespace` is still
-   * authorized strictly via `resolveReadableNamespace` (explicit reads must pass
-   * the ACL — no behavior change).
-   */
   private resolveRawExcerptReadNamespace(
     explicitNamespace: string | undefined,
     sessionKey: string | undefined,
     authenticatedPrincipal: string | undefined,
   ): string | undefined {
-    const principal = this.resolveRequestPrincipal(
-      sessionKey,
-      authenticatedPrincipal,
-    );
-    const hasExplicitNamespace =
-      typeof explicitNamespace === "string" &&
-      explicitNamespace.trim().length > 0;
-    if (hasExplicitNamespace) {
-      // Explicit reads must pass the ACL — authorize strictly, exactly as
-      // `lcmSearch` does (throws on an unreadable explicit namespace).
-      const resolvedNamespace = this.resolveReadableNamespace(
-        explicitNamespace,
-        principal,
-      );
-      return this.resolveLcmReadNamespace(
-        explicitNamespace,
-        resolvedNamespace,
-        sessionKey,
-        authenticatedPrincipal,
-        "read",
-      );
-    }
-    // IMPLICIT raw recall: an active scope profile owns the same LCM read
-    // namespace set used by recall and lcmSearch. Return the first profile
-    // namespace as the legacy raw-excerpt namespace hint; the concrete ordered
-    // key set is still produced by resolveLcmReadSessionIds(), which also treats
-    // an empty profile read set as authoritative.
-    const profileReadNamespaces = this.resolveScopeProfileLcmReadNamespaces(
-      sessionKey,
-      authenticatedPrincipal,
-    );
-    if (profileReadNamespaces !== null) return profileReadNamespaces[0];
-
-    // Otherwise derive the read fallback from the ALREADY read-authorized recall
-    // namespace set — NEVER pre-authorize `default` (#1505 thread NBHWz). When
-    // namespaces are disabled the default store is the only namespace and is
-    // always readable (byte-for-byte single-user path).
-    const fallbackNamespace =
-      this.resolveImplicitLcmReadFallbackNamespace(principal);
-    // No readable LCM namespace at all ⇒ no excerpts (caller short-circuits).
-    if (fallbackNamespace === undefined) return undefined;
-    return this.resolveLcmReadNamespace(
+    return this.accessLcmSurface.resolveRawExcerptReadNamespace(
       explicitNamespace,
-      fallbackNamespace,
       sessionKey,
       authenticatedPrincipal,
-      "read",
     );
   }
 
@@ -5437,76 +4843,12 @@ export class EngramAccessService {
     sessionKey: string,
     authenticatedPrincipal: string | undefined,
   ): string[] {
-    const primary = this.resolveLcmReadSessionKey(
+    return this.accessLcmSurface.resolveLcmReadSessionIds(
       explicitNamespace,
       resolvedNamespace,
       sessionKey,
       authenticatedPrincipal,
-      "read",
     );
-    const hasExplicitNamespace =
-      typeof explicitNamespace === "string" &&
-      explicitNamespace.trim().length > 0;
-    // Explicit namespace → no overlay fallbacks (the overlay never applies to an
-    // explicit read). Single key, unchanged.
-    if (hasExplicitNamespace) return [primary];
-
-    const profileReadNamespaces = this.resolveScopeProfileLcmReadNamespaces(
-      sessionKey,
-      authenticatedPrincipal,
-    );
-    if (profileReadNamespaces !== null) {
-      return this.lcmSessionIdsForNamespaces(profileReadNamespaces, sessionKey);
-    }
-
-    const principal = this.resolveRequestPrincipal(
-      sessionKey,
-      authenticatedPrincipal,
-    );
-    const base = defaultNamespaceForPrincipal(
-      principal,
-      this.orchestrator.config,
-    );
-    const overlaid = this.orchestrator.applyCodingNamespaceOverlay(
-      sessionKey,
-      base,
-    );
-    // No overlay → single default-store key, unchanged.
-    if (overlaid === base) return [primary];
-    // Overlay present but self base unreadable → the "read" gate already
-    // collapsed `primary` to the default store; do NOT add overlay fallbacks
-    // (they would be unauthorized `<principal>-project-*` keys). Single key.
-    const selfReadableInRecall = recallNamespacesForPrincipal(
-      principal,
-      this.orchestrator.config,
-    ).includes(base);
-    if (!selfReadableInRecall) return [primary];
-    // Self base readable → overlay rows authorized. Append one LCM key per coding
-    // read fallback (project → root), combined with the principal base for
-    // isolation — the SAME ordered set the orchestrator recall path searches.
-    const overlay = resolveCodingNamespaceOverlay(
-      this.orchestrator.getCodingContextForSession(sessionKey),
-      this.orchestrator.config.codingMode,
-      this.orchestrator.config.defaultNamespace,
-    );
-    const fallbackNamespaces = (overlay?.readFallbacks ?? []).map((fallback) =>
-      combineNamespaces(base, fallback),
-    );
-    const out = [primary];
-    const seen = new Set<string>([primary]);
-    for (const ns of fallbackNamespaces) {
-      const key =
-        lcmSessionKeyForNamespace(
-          ns,
-          sessionKey,
-          this.orchestrator.config.defaultNamespace,
-        ) ?? sessionKey;
-      if (!seen.has(key)) {
-        seen.add(key);
-        out.push(key);
-      }
-    }
-    return out;
   }
 
   async lcmCompactionFlush(
@@ -6316,134 +5658,14 @@ export class EngramAccessService {
     return { explanation };
   }
 
-  /**
-   * Read-only graph snapshot for the admin pane (issue #691 PR 2/5).
-   *
-   * Reads adjacency from the JSONL edge store written by `GraphIndex` and
-   * resolves node metadata via the namespaced storage manager.  Namespace
-   * resolution mirrors the read-side path used by `recall` /
-   * `procedureStats`, so multi-principal deployments can't leak edges from
-   * a peer namespace (CLAUDE.md rule 42).
-   */
   async graphSnapshot(
     request: GraphSnapshotRequest & { namespace?: string },
     authenticatedPrincipal?: string,
   ): Promise<GraphSnapshotResponse> {
-    const namespace = this.resolveReadableNamespace(
-      request.namespace,
+    return this.accessAdminOpsSurface.graphSnapshot(
+      request,
       authenticatedPrincipal,
     );
-    const storage = await this.orchestrator.getStorage(namespace);
-    const cfg = this.orchestrator.config;
-    const graphCaps = resolveGraphConstructionCapabilities(cfg);
-    // Canonicalize the storage root once — through `realpath` so that any
-    // symlink in the namespace root path itself is resolved before we
-    // compare children against it.  This is required because
-    // `GraphEdge.from` / `to` are JSONL-parsed strings — a malformed edge
-    // with an absolute path, a `..` segment, OR a symlink that resolves
-    // to a file outside the namespace would otherwise read a memory file
-    // from a peer namespace, leaking metadata across tenants
-    // (codex P1 + follow-up on PR #734; CLAUDE.md rule 42).
-    let namespaceRootReal: string;
-    try {
-      namespaceRootReal = await nodeFs.realpath(storage.dir);
-    } catch {
-      // If the namespace root itself doesn't exist on disk yet (fresh
-      // install with no memories), fall back to the lexical resolve so
-      // the snapshot can still return an empty result rather than
-      // throwing.  No symlink can resolve through a missing path, so
-      // this fallback is safe — every candidate we see will fail the
-      // realpath step below and surface as `null`.
-      namespaceRootReal = nodePath.resolve(storage.dir);
-    }
-    const namespaceRootWithSep = namespaceRootReal.endsWith(nodePath.sep)
-      ? namespaceRootReal
-      : namespaceRootReal + nodePath.sep;
-    const loadNode = async (relPath: string): Promise<GraphSnapshotNodeMetadata | null> => {
-      // `GraphEdge.from` / `to` are storage-relative paths; resolve against
-      // the namespaced storage root so the metadata read honors namespace
-      // boundaries even when the same memory id exists in multiple
-      // namespaces.
-      //
-      // Three-stage guard:
-      //   1. Reject absolute paths up front — only relative endpoints are
-      //      ever produced by the writer, so anything else is malformed.
-      //   2. Lexical containment check on the resolved path.  This catches
-      //      `..` traversals before we touch the filesystem.
-      //   3. `fs.realpath` containment check — resolves symlinks so an
-      //      in-namespace path that *points* at an out-of-namespace file
-      //      is still rejected.  Without this step a symlinked endpoint
-      //      could leak a peer namespace's frontmatter.
-      // Bad paths surface a length-only warning (never echo the offending
-      // segments — those would themselves cross namespace boundaries
-      // through the log surface) and fall through to a `null` metadata
-      // result.
-      if (nodePath.isAbsolute(relPath)) {
-        log.warn(
-          `graphSnapshot: rejected absolute edge endpoint (len=${relPath.length}) `
-          + `outside namespace root`,
-        );
-        return null;
-      }
-      const candidate = nodePath.resolve(namespaceRootReal, relPath);
-      if (candidate !== namespaceRootReal && !candidate.startsWith(namespaceRootWithSep)) {
-        log.warn(
-          `graphSnapshot: rejected traversing edge endpoint (len=${relPath.length}) `
-          + `outside namespace root`,
-        );
-        return null;
-      }
-      let canonical: string;
-      try {
-        canonical = await nodeFs.realpath(candidate);
-      } catch {
-        // Missing file — `readMemoryByPath` will return null too.  We
-        // intentionally still call it so callers see a consistent
-        // "unknown" result rather than special-casing missing edges.
-        canonical = candidate;
-      }
-      if (canonical !== namespaceRootReal && !canonical.startsWith(namespaceRootWithSep)) {
-        log.warn(
-          `graphSnapshot: rejected symlinked edge endpoint (len=${relPath.length}) `
-          + `that resolved outside namespace root`,
-        );
-        return null;
-      }
-      // Both `canonical` (realpath of candidate) and `namespaceRootReal`
-      // (realpath of storage.dir) are fully resolved here, so the
-      // containment check above is comparing apples-to-apples even when
-      // storage.dir (= storage.baseDir) is itself a symlink to the real
-      // directory.  Pass `canonical` — not the pre-realpath `candidate` —
-      // so the storage read also uses the stable real path.
-      const memory = await storage.readMemoryByPath(canonical);
-      if (!memory) return null;
-      const fm = memory.frontmatter;
-      return {
-        category: fm.category ?? "unknown",
-        label: fm.id ?? nodePath.basename(canonical, nodePath.extname(canonical)),
-        updated: fm.updated,
-      };
-    };
-    // Use the realpath-resolved namespace root for the edge-file read so
-    // the JSONL location is stable whether storage.dir is a direct path
-    // or a symlink.  namespaceRootReal was computed via `fs.realpath`
-    // above; using it here keeps both the graph-file I/O and the loadNode
-    // containment check on the same resolved base path.
-    return buildGraphSnapshot({
-      memoryDir: namespaceRootReal,
-      graphConfig: {
-        entityGraph: graphCaps.entityGraph,
-        timeGraph: graphCaps.timeGraph,
-        causalGraph: graphCaps.causalGraph,
-      },
-      request: {
-        limit: request.limit,
-        since: request.since,
-        focusNodeId: request.focusNodeId,
-        categories: request.categories,
-      },
-      loadNode,
-    });
   }
 
   async memoryFeedback(request: {
@@ -7140,108 +6362,13 @@ export class EngramAccessService {
     });
   }
 
-  /**
-   * List capsule archives in the namespace-scoped capsule store.
-   *
-   * MCP uses this access-layer method instead of reading arbitrary paths so
-   * capsule discovery remains bound to the same namespace ACLs as export and
-   * import.
-   */
   async capsuleList(options?: {
     namespace?: string;
     principal?: string;
   }): Promise<EngramAccessCapsuleListResponse> {
-    const resolvedNamespace = this.resolveReadableNamespace(options?.namespace, options?.principal);
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const capsulesDir = defaultCapsulesDir(storage.dir);
-    let dirEntries: import("node:fs").Dirent[];
-    try {
-      const capsulesDirStat = await nodeFs.lstat(capsulesDir);
-      if (capsulesDirStat.isSymbolicLink()) {
-        throw new EngramAccessInputError("capsule list failed: capsule store directory must not be a symlink");
-      }
-      if (!capsulesDirStat.isDirectory()) {
-        throw new EngramAccessInputError("capsule list failed: capsule store path must be a directory");
-      }
-      dirEntries = await nodeFs.readdir(capsulesDir, { withFileTypes: true });
-    } catch (err) {
-      const code = typeof err === "object" && err !== null && "code" in err
-        ? (err as { code?: unknown }).code
-        : undefined;
-      if (code === "ENOENT") {
-        return { namespace: resolvedNamespace, capsulesDir, capsules: [] };
-      }
-      throw err;
-    }
-
-    const archiveNames = dirEntries
-      .filter(
-        (entry) =>
-          entry.isFile() &&
-          (entry.name.endsWith(".capsule.json.gz") ||
-            entry.name.endsWith(".capsule.json.gz.enc")),
-      )
-      .map((entry) => entry.name)
-      .sort();
-
-    const capsules: CapsuleListEntry[] = [];
-    for (const archiveName of archiveNames) {
-      const archivePath = nodePath.join(capsulesDir, archiveName);
-      const id = archiveName
-        .replace(/\.capsule\.json\.gz\.enc$/, "")
-        .replace(/\.capsule\.json\.gz$/, "");
-      const manifestPath = nodePath.join(capsulesDir, `${id}.manifest.json`);
-
-      let createdAt: string | null = null;
-      let pluginVersion: string | null = null;
-      let fileCount: number | null = null;
-      let description: string | null = null;
-      let manifestPathOrNull: string | null = manifestPath;
-
-      try {
-        const manifestStat = await nodeFs.lstat(manifestPath);
-        if (manifestStat.isSymbolicLink() || !manifestStat.isFile()) {
-          capsules.push({
-            id,
-            archivePath,
-            manifestPath: manifestPathOrNull,
-            createdAt,
-            pluginVersion,
-            fileCount,
-            description,
-          });
-          continue;
-        }
-        const raw = await nodeFs.readFile(manifestPath, "utf-8");
-        const sidecar = JSON.parse(raw) as Record<string, unknown>;
-        createdAt = typeof sidecar.createdAt === "string" ? sidecar.createdAt : null;
-        pluginVersion = typeof sidecar.pluginVersion === "string" ? sidecar.pluginVersion : null;
-        fileCount = Array.isArray(sidecar.files) ? sidecar.files.length : null;
-        const capsule = sidecar.capsule as Record<string, unknown> | undefined;
-        description = capsule && typeof capsule.description === "string"
-          ? capsule.description
-          : null;
-      } catch (err) {
-        const code = typeof err === "object" && err !== null && "code" in err
-          ? (err as { code?: unknown }).code
-          : undefined;
-        if (code === "ENOENT") {
-          manifestPathOrNull = null;
-        }
-      }
-
-      capsules.push({
-        id,
-        archivePath,
-        manifestPath: manifestPathOrNull,
-        createdAt,
-        pluginVersion,
-        fileCount,
-        description,
-      });
-    }
-
-    return { namespace: resolvedNamespace, capsulesDir, capsules };
+    return this.accessAdminOpsSurface.capsuleList(
+      options,
+    );
   }
 
   /**
@@ -7484,87 +6611,15 @@ export class EngramAccessService {
     return getDreamsStatus(storage.dir, windowHours);
   }
 
-  /**
-   * Manually invoke a single Dreams phase pass (PR 4/4).
-   *
-   * Deep-sleep delegates to memory governance (shadow → dry-run, apply → live).
-   * Light-sleep and REM scan the observation ledger and memory corpus
-   * respectively, returning the same telemetry shape as a scheduled run.
-   */
   async dreamsRun(options: {
     phase: import("./types.js").DreamsPhase;
     dryRun?: boolean;
     namespace?: string;
     authenticatedPrincipal?: string;
   }): Promise<import("./types.js").DreamsRunResult> {
-    const { runDreamsPhase } = await import("./maintenance/dreams-ledger.js");
-    const validPhases = ["lightSleep", "rem", "deepSleep"];
-    if (!validPhases.includes(options.phase)) {
-      throw new EngramAccessInputError(
-        `Invalid phase: ${String(options.phase)}. Must be one of: ${validPhases.join(", ")}`,
-      );
-    }
-    const deepSleep = this.orchestrator.config.dreamsPhases.deepSleep;
-    if (
-      options.phase === "deepSleep" &&
-      deepSleep.enabled === false &&
-      deepSleep.enabledExplicitlySet === true
-    ) {
-      throw new EngramAccessInputError(
-        "memory governance is disabled by dreams.phases.deepSleep.enabled=false",
-      );
-    }
-    const dryRun = options.dryRun === true;
-    const resolvedNamespace = this.writableNamespaceFor(
-      options.namespace,
-      undefined,
-      options.authenticatedPrincipal,
-    );
-    const storage = await this.orchestrator.getStorage(resolvedNamespace);
-    const memoryDir = storage.dir;
-    const phaseRunner = dryRun || options.phase === "deepSleep"
-      ? undefined
-      : async (_opts: { memoryDir: string; phase: "lightSleep" | "rem" }) => {
-          if (_opts.phase === "lightSleep") {
-            const result = await this.orchestrator.runLifecyclePolicyNow(storage);
-            return {
-              itemsProcessed: result.memoriesAssessed,
-              notes: `scored ${result.memoriesAssessed} memories`,
-            };
-          }
-          const result = await this.orchestrator.runSemanticConsolidationNow({
-            dryRun: false,
-            storage,
-          });
-          const itemsProcessed = result.clusters.reduce(
-            (sum, cluster) => sum + cluster.memories.length,
-            0,
-          );
-          return {
-            itemsProcessed,
-            notes: `REM consolidation found ${result.clustersFound} clusters`,
-          };
-        };
-    const governanceRunner = options.phase === "deepSleep"
-      ? async (_opts: { memoryDir: string; dryRun: boolean }) => {
-          return this.orchestrator.runDeepSleepGovernanceNow({
-            storage,
-            dryRun: _opts.dryRun,
-          });
-        }
-      : undefined;
-    const result = await runDreamsPhase(
-      { memoryDir, phase: options.phase, dryRun },
-      governanceRunner,
-      phaseRunner,
+    return this.accessAdminOpsSurface.dreamsRun(
+      options,
     );
-    return {
-      phase: result.phase,
-      dryRun: result.dryRun,
-      durationMs: result.durationMs,
-      itemsProcessed: result.itemsProcessed,
-      notes: result.notes,
-    };
   }
 
   // ---------------------------------------------------------------------------
@@ -7723,12 +6778,6 @@ export class EngramAccessService {
     return redactSensitive(result);
   }
 
-  /**
-   * Manually promote a memory into one or more authorized targets. Requires
-   * a non-empty reason (audit-logged). Reuses the scope-profile promotion
-   * resolution and `canWriteNamespace` gate — there is no dashboard-only
-   * write path.
-   */
   async adminPromoteMemory(request: {
     sourceMemoryId: string;
     namespace?: string;
@@ -7738,111 +6787,9 @@ export class EngramAccessService {
     reason: string;
     actor?: never; // ignored — actor is derived from the authenticated principal
   }) {
-    const config = this.orchestrator.config;
-    const namespacesEnabled = resolveNamespaceCapabilities(config).namespaces === true;
-    // Fix OdCl3: when no namespace is supplied, resolve the source via the
-    // scope plan (principal self / scope-profile write layer / coding overlay)
-    // instead of falling through to config.defaultNamespace. This matches the
-    // runtime observe/write path.
-    let sourceNamespace: string;
-    if (request.namespace) {
-      sourceNamespace = this.resolveReadableNamespace(
-        request.namespace,
-        request.principal,
-      );
-    } else {
-      const codingContext = request.sessionKey
-        ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null
-        : null;
-      const plan = resolveScopePlan({
-        config,
-        sessionKey: request.sessionKey,
-        principalOverride: request.principal,
-        codingContext,
-        namespacesEnabled,
-      });
-      sourceNamespace = this.resolveReadableNamespace(
-        plan.baseNamespace,
-        request.principal,
-      );
-    }
-    // Fix OdB0c: thread coding context into the scope-profile plan so
-    // userProject/teamProject promotion targets resolve for project-scoped
-    // sessions (previously hard-coded to null).
-    const codingContext = request.sessionKey
-      ? this.orchestrator.getCodingContextForSession(request.sessionKey) ?? null
-      : null;
-    const codingOverlay = codingContext
-      ? resolveCodingNamespaceOverlay(
-          codingContext,
-          config.codingMode,
-          config.defaultNamespace,
-        )
-      : null;
-    const scopeProfilePlan = resolveScopeProfilePlan({
-      config,
-      principal: request.principal,
-      codingContext,
-      codingOverlay,
-    });
-    const storage: PromotionStorageProvider = {
-      readMemory: async (namespace, memoryId) => {
-        const resolved = await this.orchestrator.getStorage(namespace);
-        const memory = await resolved.getMemoryById(memoryId);
-        if (!memory) return null;
-        return {
-          category: memory.frontmatter.category,
-          content: memory.content,
-          frontmatter: memory.frontmatter,
-        };
-      },
-      writePromotedMemory: async (namespace, memory) => {
-        const resolved = await this.orchestrator.getStorage(namespace);
-        const { id, tombstoneBlocked } = await resolved.writeMemory(
-          memory.category,
-          memory.content,
-          {
-            confidence: memory.confidence,
-            tags: memory.tags,
-            entityRef: memory.entityRef,
-            source: `admin-promotion:${memory.sourceNamespace}:${memory.reason.slice(0, 120)}`,
-            lineage: memory.lineage,
-            sourceMemoryId: memory.sourceMemoryId,
-            actor: memory.actor,
-            validAt: memory.validAt,
-          },
-        );
-        // #1645: a tombstone-blocked promotion lands pending_review (no active
-        // copy in the target). Report it as a failed promotion so the admin
-        // sees an honest result — the content is queued for review, not
-        // actively promoted. promoteMemory's catch block sanitizes this into
-        // a generic "promotion write failed" audit entry.
-        if (tombstoneBlocked) {
-          throw new Error(
-            "target namespace tombstone-blocked the promoted content (pending_review)",
-          );
-        }
-        return id;
-      },
-    };
-    try {
-      return await promoteMemory({
-        config,
-        sourceMemoryId: request.sourceMemoryId,
-        sourceNamespace,
-        principal: request.principal,
-        targets: request.targets,
-        reason: request.reason,
-        actor: request.principal ?? "admin-console",
-        storage,
-        scopeProfilePlan,
-      });
-    } catch (err) {
-      if (err instanceof AdminPromotionError) {
-        throw new EngramAccessInputError(err.message);
-      }
-      throw err;
-    }
+    return this.accessAdminOpsSurface.adminPromoteMemory(
+      request,
+    );
   }
 }