@remnic/core 9.69.56 → 9.69.58

package/dist/access-service.d.ts

@@ -1,145 +1,1825 @@
-import './types-Du6VdoAg.js';
-import './orchestrator-iexgVLow.js';
-import './scope-profiles-BN1Dgfha.js';
-import './storage-CMm-3aD3.js';
-import './semantic-BalR6EXU.js';
-import './local-llm-BkkEK9rn.js';
-import './fallback-llm.js';
-export { A as AccessProfilingReportRequest, a as AccessProfilingReportResponse, C as CodingScopedWriteInput, ct as ENGRAM_ACCESS_WRITE_SCHEMA_VERSION, cu as EngramAccessActionConfidenceRequest, cv as EngramAccessActionConfidenceResponse, p as EngramAccessBriefingRequest, q as EngramAccessBriefingResponse, b as EngramAccessCapsuleListResponse, cw as EngramAccessDaySummaryRequest, cx as EngramAccessEntityListResponse, cy as EngramAccessEntityResponse, cz as EngramAccessEntitySummary, d as EngramAccessExtractionForceFlushRequest, e as EngramAccessExtractionForceFlushResponse, cb as EngramAccessLcmCompactionFlushRequest, g as EngramAccessLcmCompactionFlushResponse, cA as EngramAccessLcmCompactionRecordRequest, h as EngramAccessLcmCompactionRecordResponse, j as EngramAccessLcmSearchRequest, k as EngramAccessLcmSearchResponse, cB as EngramAccessLcmStatusResponse, cC as EngramAccessMaintenanceResponse, cD as EngramAccessMemoryBrowseRequest, cE as EngramAccessMemoryBrowseResponse, cF as EngramAccessMemoryRecord, z as EngramAccessMemoryResponse, n as EngramAccessMemoryStoreRequest, J as EngramAccessMemorySummary, cG as EngramAccessObserveMessage, s as EngramAccessObserveRequest, t as EngramAccessObserveResponse, cH as EngramAccessOfflineSyncApplyFileContentRequest, cI as EngramAccessOfflineSyncApplyFileContentResponse, cJ as EngramAccessOfflineSyncApplyRequest, cK as EngramAccessOfflineSyncApplyResponse, cL as EngramAccessOfflineSyncFileContentRequest, cM as EngramAccessOfflineSyncFileContentResponse, cN as EngramAccessOfflineSyncFilesRequest, cO as EngramAccessOfflineSyncFilesResponse, cP as EngramAccessOfflineSyncFinalizeConvergenceRequest, cQ as EngramAccessOfflineSyncFinalizeConvergenceResponse, cR as EngramAccessOfflineSyncManifestRequest, cS as EngramAccessOfflineSyncSnapshotRequest, cT as EngramAccessOfflineSyncSnapshotResponse, i as EngramAccessOfflineSyncSnapshotStreamResponse, cU as EngramAccessQualityResponse, cV as EngramAccessRecallExplainRequest, cW as EngramAccessRecallExplainResponse, I as EngramAccessRecallRequest, H as EngramAccessRecallResponse, cX as EngramAccessReviewDispositionRequest, cY as EngramAccessReviewDispositionResponse, E as EngramAccessReviewQueueResponse, cZ as EngramAccessScopeDebug, f as EngramAccessService, K as EngramAccessSetCodingContextRequest, o as EngramAccessSuggestionSubmitRequest, c_ as EngramAccessTimelineResponse, c$ as EngramAccessTrustZoneBrowseRequest, d0 as EngramAccessTrustZoneBrowseResponse, d1 as EngramAccessTrustZoneDemoSeedRequest, d2 as EngramAccessTrustZoneDemoSeedResponse, d3 as EngramAccessTrustZonePromoteRequest, d4 as EngramAccessTrustZonePromoteResponse, d5 as EngramAccessTrustZoneRecordSummary, d6 as EngramAccessTrustZoneStatusResponse, d7 as EngramAccessWriteEnvelope, r as EngramAccessWriteResponse, m as MemoryScopePlan, d8 as RetainedCategorySpelling, d9 as buildProjectedGovernanceProposedActions, da as hasGroupedGovernanceActions, db as shapeMemorySummary } from './access-service-CUNM5RfA.js';
-import './trust-zones.js';
-import './message-parts/index.js';
-import './access-schema.js';
-import './resolve-auth-token.js';
-import './recall-context-composition.js';
-import './recall-xray.js';
-import './action-confidence.js';
-import './offline-sync.js';
-import './live-connectors-runner.js';
-import './maintenance/memory-governance.js';
-import './recall-state.js';
-import './service-VealHeqO.js';
-import './memory-worth-outcomes.js';
-import './cross-namespace-budget.js';
-import './recall-audit-anomaly.js';
-import './types-B1VHaf2w.js';
-import './transfer/capsule-import.js';
-import './recall-navigation.js';
-import './recall-explain-renderer.js';
-import './access-citation.js';
-export { EngramAccessHealthResponse, EngramAccessQmdCollectionState, EngramAccessQmdHealthResponse } from './access-health-types.js';
-import './tagging-BjsNFKWz.js';
-import './explicit-capture.js';
-export { WearablesMeetingsScope } from './access-wearables-meetings-surface.js';
-export { E as EngramAccessNamespaceWritableRequest } from './access-namespace-preflight-U9RAdxqZ.js';
-import './deep-recall.js';
-import './memory-browse.js';
-import './graph-snapshot.js';
-import './access-offline-manifest.js';
-import './capsule-cli.js';
-import './transfer/capsule-export.js';
-export { EngramAccessInputError, NamespaceNotWritableError } from './access-errors.js';
-import './bounded-jsonl-state.js';
-import './operator-doctor-types.js';
-import './external-wiki-config.js';
-import './recall-state-view.js';
-import './contradiction-config.js';
-import './graph-path-scoring-config.js';
-import './background-generation-config.js';
-import './deep-recall-config.js';
-import './recall-navigation-config.js';
-import './recall-recognition-tier.js';
-import './causal-trajectory.js';
-import './objective-state.js';
-import './active-context-config.js';
-import './local-llm-config.js';
-import './semantic-merge-config.js';
-import './types-continuity.js';
-import './briefing.js';
-import './corpus-read-cancellation.js';
-import './artifact-search.js';
-import './active-context-transform.js';
-import './context-summary.js';
-import './entity-id-normalization.js';
-import './page-versioning.js';
-import './consolidation-operator.js';
-import './utils/serialize-mutations.js';
-import './memory-projection-store.js';
-import './runtime/better-sqlite.js';
-import 'better-sqlite3';
-import './write-envelope.js';
-import './structured-attributes.js';
-import './buffer.js';
-import './extraction-faithfulness.js';
-import './model-registry.js';
-import './fallback-llm-codex-subscription.js';
-import './cli-fallback.js';
-import './resolve-provider-secret.js';
-import './search/port.js';
-import './transcript.js';
-import './session-integrity.js';
-import './summarizer.js';
-import './maintenance-CLBIvVxg.js';
-import './catalog-BuMyYPUn.js';
-import './namespaces/search.js';
-import './compounding/engine.js';
-import './shared-context/manager.js';
-import 'zod';
-import './capabilities.js';
-import './utility-runtime.js';
-import './tier-routing.js';
-import './lifecycle.js';
-import './orchestration/compression-guideline-coordinator.js';
-import './semantic-consolidation-D--qe0eE.js';
-import './connectors/codex-materialize.js';
-import './logger.js';
-import './embedding-fallback.js';
-import './extraction.js';
-import './schemas.js';
-import './profiling.js';
-import './extraction-error-classification.js';
-import './harmonic-retrieval.js';
-import './abstraction-nodes.js';
-import './cue-anchors.js';
-import './verified-recall.js';
-import './boxes.js';
-import './semantic-rule-verifier.js';
-import './work-product-ledger.js';
-import './trust-score-stage.js';
-import './trust-score.js';
-import './conversation-index/chunker.js';
-import './conversation-index/backend.js';
-import './faiss-adapter-BHecI1fF.js';
-import './runtime/child-process.js';
-import './included-memories.js';
-import './dependency-propagation-delivery-BrhPjAHQ.js';
-import './namespaces/storage.js';
-import './threading.js';
-import './graph-DRkl22KE.js';
-import './graph-write-lock.js';
-import './generic-recall-paths-C0J1Oxb7.js';
-import './relevance.js';
-import './negative.js';
-import './session-observer-state.js';
-import './replay/types.js';
-import './lcm/engine.js';
-import './lcm/archive.js';
-import './token-estimate.js';
-import './lcm/recall.js';
-import './lcm/dag.js';
-import './lcm/queue.js';
-import './policy-runtime.js';
-import 'node:stream';
-import './memory-provenance.js';
-import './user-model.js';
-import './offline-sync-file-io.js';
-import './framework-CNDn2164.js';
-import './extraction-judge.js';
-import './recall-audit.js';
-import './transfer/types.js';
-import './corpus-watermark.js';
-import './access-token-capabilities.js';
-import 'node:async_hooks';
-import './replica-divergence.js';
-import 'node:fs/promises';
-import './reconcile/manifest.js';
-import './reconcile/plan.js';
+import { type CitationUsageRequest, type CitationUsageResult } from "./access-citation.js";
+import type { EngramAccessHealthResponse, EngramAccessQmdCollectionState, EngramAccessQmdHealthResponse } from "./access-health-types.js";
+import type { ResolveSecretRefFn } from "./resolve-auth-token.js";
+import { type LocationContextRequestOptions } from "./location/tagging.js";
+export type { EngramAccessHealthResponse, EngramAccessQmdCollectionState, EngramAccessQmdHealthResponse };
+import { type ArchitectureSurfaceRequest, type ArchitectureSurfaceResponse } from "./coding/architecture-surfaces.js";
+import { type CodegraphSurfaceRequest, type CodegraphSurfaceResponse } from "./coding/codegraph-surfaces.js";
+import { type DecisionSurfaceRequest, type DecisionSurfaceResponse } from "./coding/decision-surfaces.js";
+import { type DeltaSurfaceRequest, type DeltaSurfaceResponse } from "./coding/session-delta-surfaces.js";
+import { type CorrectionOutcome, type CorrectionPlan, type CorrectionRequest } from "./correction/index.js";
+import { type BudgetWarning } from "./cross-namespace-budget.js";
+import { type ExplicitCaptureInput } from "./explicit-capture.js";
+import type { LiveConnectorsRunSummary } from "./live-connectors-runner.js";
+import { type readMemoryGovernanceRunArtifact } from "./maintenance/memory-governance.js";
+import type { PatternReinforcementResult } from "./maintenance/pattern-reinforcement.js";
+import type { MeetingsDayBuildSummary } from "./meetings/build.js";
+import type { MeetingsGetResult, MeetingsListResult } from "./meetings/service.js";
+import type { AnomalyDetectorResult } from "./recall-audit-anomaly.js";
+import type { WearablesService } from "./wearables/service.js";
+import type { WearablesMeetingsScope } from "./access-wearables-meetings-surface.js";
+export type { WearablesMeetingsScope };
+import { type EngramAccessNamespaceWritableRequest } from "./access-namespace-preflight.js";
+import { type EngramAccessExtractionForceFlushRequest, type EngramAccessExtractionForceFlushResponse, type EngramAccessLcmCompactionFlushRequest, type EngramAccessLcmCompactionFlushResponse } from "./access-service-helpers.js";
+import { type AdminNamespaceFilter, type InspectScopeOptions, type MemoryPromotionTargetKind, type ScopeInspection } from "./admin/admin-surfaces.js";
+import { type DeepRecallResult } from "./deep-recall.js";
+import { type RecallNavigationRequest, type RecallNavigationResult } from "./recall-navigation.js";
+import { type MemoryStoreBrowseRequest, type MemoryStoreBrowseResult } from "./memory-browse.js";
+import { type GraphSnapshotRequest, type GraphSnapshotResponse } from "./graph-snapshot.js";
+import { type ResolvedScopeProfilePlan, type ScopeProfileLayerResolution, type ScopeProfilePromotionResolution } from "./namespaces/scope-profiles.js";
+import type { GraphRecallSnapshot, IntentDebugSnapshot, Orchestrator } from "./orchestrator.js";
+import { type ProcedureStatsReport } from "./procedural/procedure-stats.js";
+import { type ProcedureLibraryMaintenanceReport } from "./procedural/library-maintenance.js";
+import type { RecallContextComposition } from "./recall-context-composition.js";
+import type { LastRecallSnapshot } from "./recall-state.js";
+import { type WritableNamespaceResult } from "./scopes/scope-plan.js";
+import { type StorageManager } from "./storage.js";
+import { type TrustZoneDemoSeedResult, type TrustZoneName, type TrustZonePromotionResult, type TrustZoneProvenanceScore, type TrustZoneRecordKind, type TrustZoneSourceClass, type TrustZoneStoreStatus } from "./trust-zones.js";
+import type { EntityFile, MemoryFile, MemoryLifecycleEvent, MemoryStatus, PluginConfig, RecallDisclosure, RecallPlanMode, SourceConnectorProvenance } from "./types.js";
+import type { SupportPassportModelRoute } from "./support-passport/model-adapter.js";
+export type { EngramAccessExtractionForceFlushRequest, EngramAccessExtractionForceFlushResponse, EngramAccessLcmCompactionFlushRequest, EngramAccessLcmCompactionFlushResponse, };
+import { type OfflineSyncManifestStreamResponse } from "./access-offline-manifest.js";
+import { type ActionConfidenceInput, type ActionConfidenceResult } from "./action-confidence.js";
+import { type CapsuleListEntry } from "./capsule-cli.js";
+import type { SemanticDedupLookup } from "./dedup/semantic.js";
+import type { FallbackLlmClient } from "./fallback-llm.js";
+import type { LocalLlmClient } from "./local-llm.js";
+import { type MemoryOutcomeKind, type RecordMemoryOutcomeResult } from "./memory-worth-outcomes.js";
+import type { LcmMessagePartInput, MessagePartSourceFormat } from "./message-parts/index.js";
+import type { CategoryAliasCoercion, ObserveRequest, RecallRequest } from "./access-schema.js";
+import { type OfflineSyncApplyChangesetResult, type OfflineSyncApplyFileContentChunkResult, type OfflineSyncFileContentChunk, type OfflineSyncFileRecord, type OfflineSyncFileState, type OfflineSyncSnapshot } from "./offline-sync.js";
+import { ReviewDeckSurface } from "./review/review-deck-surface.js";
+import { type RecallXraySnapshot } from "./recall-xray.js";
+import { type RecallWhyRequest, type RecallWhyResponse } from "./recall-why-service.js";
+import { type WhoKnowsResult } from "./who-knows.js";
+import { type PromotionCandidatesResult } from "./memory-subject.js";
+import { SupportPassportAccessServiceBase } from "./support-passport/access-service-base.js";
+import { type ExportCapsuleOptions, type ExportCapsuleResult } from "./transfer/capsule-export.js";
+import { type ImportCapsuleOptions, type ImportCapsuleResult } from "./transfer/capsule-import.js";
+export { EngramAccessInputError, NamespaceNotWritableError } from "./access-errors.js";
+export type AccessProfilingReportRequest = {
+    format?: string;
+    limit?: number;
+};
+export type AccessProfilingReportResponse = {
+    enabled: boolean;
+    format?: "ascii" | "json";
+    report?: string;
+    traces?: unknown[];
+    stats?: unknown;
+    bottleneck?: string | null;
+    reason?: string;
+    message?: string;
+};
+export declare const ENGRAM_ACCESS_WRITE_SCHEMA_VERSION = 1;
+/**
+ * Recall request. Wire fields derive from the canonical zod schema
+ * (`recallRequestSchema`, access-schema.ts — issue #2482) so the HTTP body,
+ * the MCP args, and the service share ONE model. The overlay below carries
+ * server-resolved transport fields no client may set.
+ */
+export interface EngramAccessRecallRequest extends RecallRequest {
+    authenticatedPrincipal?: string;
+    /** Trusted connector identity resolved at the transport boundary. */
+    sourceConnector?: string;
+    abortSignal?: AbortSignal;
+    /**
+     * Internal, server-set field (issue #1906): wall-clock ms the caller
+     * waited for a per-principal recall slot / single-flight leader before
+     * execution. Set by `recall()`, forwarded into `RecallInvocationOptions`,
+     * and folded additively into recall-timings. Not part of the zod schema
+     * (same pattern as `abortSignal`).
+     */
+    queueWaitMs?: number;
+}
+/**
+ * Standalone request to attach / clear the coding context for a session
+ * without performing a recall. Used by the Claude Code / Codex connectors
+ * at session start, and by the `remnic.set_coding_context` MCP tool (PR 7).
+ */
+export interface EngramAccessSetCodingContextRequest {
+    sessionKey: string;
+    codingContext: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
+}
+export interface EngramAccessRecallResponse {
+    query: string;
+    sessionKey?: string;
+    namespace: string;
+    context: string;
+    /** Request-local split used by adapters that must re-render a tighter prompt budget. */
+    contextComposition?: RecallContextComposition;
+    count: number;
+    memoryIds: string[];
+    results: EngramAccessMemorySummary[];
+    recordedAt?: string;
+    traceId?: string;
+    plannerMode?: RecallPlanMode;
+    fallbackUsed: boolean;
+    sourcesUsed: string[];
+    /**
+     * Disclosure depth applied to this recall (issue #677).  Reflects the
+     * caller-requested level after defaulting; useful for surfaces that want
+     * to render a "served at depth X" hint without re-deriving it.  PR 1 of
+     * #677 wires this end-to-end for plumbing only — section/raw payload
+     * shaping ships in later PRs.
+     */
+    disclosure: RecallDisclosure;
+    budgetsApplied?: LastRecallSnapshot["budgetsApplied"];
+    auditAnomalies?: AnomalyDetectorResult;
+    budgetWarning?: BudgetWarning;
+    latencyMs?: number;
+    debug?: {
+        snapshot?: LastRecallSnapshot;
+        intent?: IntentDebugSnapshot | null;
+        graph?: GraphRecallSnapshot | null;
+    };
+}
+export interface EngramAccessRecallExplainRequest {
+    sessionKey?: string;
+    namespace?: string;
+    /** Caller principal for namespace access checks. Transport-bound; never from untrusted payloads. */
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessRecallExplainResponse {
+    found: boolean;
+    snapshot?: LastRecallSnapshot;
+    intent?: IntentDebugSnapshot | null;
+    graph?: GraphRecallSnapshot | null;
+}
+export interface EngramAccessDaySummaryRequest extends LocationContextRequestOptions {
+    memories?: string;
+    sessionKey?: string;
+    namespace?: string;
+    timeZone?: string;
+}
+/** Inputs accepted by the `remnic_briefing` MCP tool. */
+export interface EngramAccessBriefingRequest extends LocationContextRequestOptions {
+    since?: string;
+    focus?: string;
+    namespace?: string;
+    format?: "markdown" | "json";
+    maxFollowups?: number;
+    /** Caller principal for namespace access checks. Transport-bound — never from untrusted payloads. */
+    principal?: string;
+}
+/** Response for `remnic_briefing`. */
+export interface EngramAccessBriefingResponse {
+    format: "markdown" | "json";
+    window: {
+        from: string;
+        to: string;
+    };
+    namespace: string;
+    markdown: string;
+    json: Record<string, unknown>;
+    followupsUnavailableReason?: string;
+}
+export interface EngramAccessMemoryRecord {
+    id: string;
+    path: string;
+    category: string;
+    status?: string;
+    created?: string;
+    updated?: string;
+    content: string;
+    frontmatter: MemoryFile["frontmatter"];
+}
+export interface EngramAccessMemorySummary {
+    id: string;
+    path: string;
+    category: string;
+    status: string;
+    created?: string;
+    updated?: string;
+    tags: string[];
+    entityRef?: string;
+    preview: string;
+    /**
+     * Disclosure depth at which this result was served (issue #677).  Set by
+     * recall paths; omitted on non-recall surfaces (e.g. memory browse) where
+     * the concept does not apply.  PR 1 of #677 always reports the
+     * request-level disclosure on recall results; per-result divergence is
+     * reserved for the auto-escalation policy that ships in PR 4/4.
+     */
+    disclosure?: RecallDisclosure;
+    /**
+     * Full memory content (markdown body) — populated when `disclosure` is
+     * `"section"` or `"raw"` (issue #677 PR 2/4).  At `"chunk"` depth callers
+     * only receive the short `preview`, preserving the cheap-by-default
+     * recall payload.  Browse/non-recall paths leave `content` undefined.
+     */
+    content?: string;
+    /**
+     * Raw transcript excerpts surfaced from the LCM archive when `disclosure`
+     * is `"raw"` and the LCM engine is enabled (issue #677 PR 2/4).  Each
+     * entry is a per-message excerpt sized by the LCM archive's
+     * configured excerpt window.  Empty array when LCM is disabled or has
+     * no matching transcript content.  Always omitted at chunk/section.
+     */
+    rawExcerpts?: Array<{
+        turnIndex: number;
+        role: string;
+        content: string;
+        sessionId: string;
+    }>;
+}
+export interface EngramAccessMemoryBrowseRequest {
+    query?: string;
+    status?: string;
+    category?: string;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+    sort?: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
+    limit?: number;
+    offset?: number;
+}
+export interface EngramAccessMemoryBrowseResponse {
+    namespace: string;
+    sort: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    memories: EngramAccessMemorySummary[];
+}
+export interface EngramAccessMemoryResponse {
+    found: boolean;
+    namespace: string;
+    memory?: EngramAccessMemoryRecord;
+}
+export interface EngramAccessTimelineResponse {
+    found: boolean;
+    namespace: string;
+    count: number;
+    timeline: MemoryLifecycleEvent[];
+}
+export interface EngramAccessEntitySummary {
+    name: string;
+    type: string;
+    updated: string;
+    summary?: string;
+    aliases: string[];
+}
+export interface EngramAccessEntityListResponse {
+    namespace: string;
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    entities: EngramAccessEntitySummary[];
+}
+export interface EngramAccessEntityResponse {
+    found: boolean;
+    namespace: string;
+    entity?: EntityFile;
+}
+export interface EngramAccessReviewQueueResponse {
+    found: boolean;
+    namespace?: string;
+    runId?: string;
+    summary?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["summary"];
+    metrics?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["metrics"];
+    qualityScore?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["qualityScore"];
+    reviewQueue?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["reviewQueue"];
+    appliedActions?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["appliedActions"];
+    transitionReport?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["transitionReport"];
+    report?: string;
+}
+export interface EngramAccessMaintenanceResponse {
+    namespace: string;
+    health: EngramAccessHealthResponse;
+    latestGovernanceRun: EngramAccessReviewQueueResponse;
+}
+export interface EngramAccessTrustZoneStatusResponse {
+    namespace: string;
+    status: TrustZoneStoreStatus;
+}
+export interface EngramAccessTrustZoneRecordSummary {
+    recordId: string;
+    filePath: string;
+    zone: TrustZoneName;
+    recordedAt: string;
+    kind: TrustZoneRecordKind;
+    summary: string;
+    sourceClass: TrustZoneSourceClass;
+    sessionKey?: string;
+    sourceId?: string;
+    evidenceHashPresent: boolean;
+    anchored: boolean;
+    entityRefs: string[];
+    tags: string[];
+    metadata?: Record<string, string>;
+    trustScore?: TrustZoneProvenanceScore;
+    nextPromotionTarget?: TrustZoneName;
+    nextPromotionAllowed: boolean;
+    nextPromotionReasons: string[];
+    corroborationCount?: number;
+    corroborationSourceClasses?: TrustZoneSourceClass[];
+}
+export interface EngramAccessTrustZoneBrowseRequest {
+    query?: string;
+    zone?: TrustZoneName;
+    kind?: TrustZoneRecordKind;
+    sourceClass?: TrustZoneSourceClass;
+    namespace?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface EngramAccessTrustZoneBrowseResponse {
+    namespace: string;
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    records: EngramAccessTrustZoneRecordSummary[];
+}
+export interface EngramAccessTrustZonePromoteRequest {
+    recordId: string;
+    targetZone: TrustZoneName;
+    promotionReason: string;
+    recordedAt?: string;
+    summary?: string;
+    dryRun?: boolean;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessTrustZonePromoteResponse extends TrustZonePromotionResult {
+    namespace: string;
+    dryRun: boolean;
+}
+export interface EngramAccessTrustZoneDemoSeedRequest {
+    scenario?: string;
+    recordedAt?: string;
+    dryRun?: boolean;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessTrustZoneDemoSeedResponse extends TrustZoneDemoSeedResult {
+    namespace: string;
+}
+export interface EngramAccessQualityResponse {
+    namespace: string;
+    totalMemories: number;
+    statusCounts: Record<string, number>;
+    categoryCounts: Record<string, number>;
+    confidenceTierCounts: Record<string, number>;
+    ageBucketCounts: Record<string, number>;
+    archivePressure: {
+        pendingReview: number;
+        quarantined: number;
+        archived: number;
+        staleActive: number;
+        lowConfidenceActive: number;
+    };
+    latestGovernanceRun: {
+        found: boolean;
+        runId?: string;
+        qualityScore?: EngramAccessReviewQueueResponse["qualityScore"];
+        reviewQueueCount: number;
+    };
+}
+export interface EngramAccessCapsuleListResponse {
+    namespace: string;
+    capsulesDir: string;
+    capsules: CapsuleListEntry[];
+}
+export interface EngramAccessOfflineSyncSnapshotRequest {
+    namespace?: string;
+    principal?: string;
+    includeTranscripts?: boolean;
+    includeContent?: boolean;
+    baseCapturedAt?: Date;
+    baseFiles?: OfflineSyncFileState[];
+}
+export interface EngramAccessOfflineSyncManifestRequest {
+    namespace?: string;
+    principal?: string;
+    includeTranscripts?: boolean;
+}
+export interface EngramAccessOfflineSyncFilesRequest {
+    namespace?: string;
+    principal?: string;
+    includeTranscripts?: boolean;
+    paths: string[];
+}
+export interface EngramAccessOfflineSyncFileContentRequest {
+    namespace?: string;
+    principal?: string;
+    includeTranscripts?: boolean;
+    path: string;
+    offset?: number;
+    length?: number;
+}
+export interface EngramAccessOfflineSyncApplyFileContentRequest {
+    namespace?: string;
+    principal?: string;
+    includeTranscripts?: boolean;
+    sourceId: string;
+    path: string;
+    sha256: string;
+    bytes: number;
+    mtimeMs: number;
+    offset?: number;
+    baseSha256?: string;
+    content: Buffer;
+}
+export interface EngramAccessOfflineSyncApplyRequest {
+    namespace?: string;
+    principal?: string;
+    changeset: unknown;
+    returnCurrentFiles?: boolean;
+}
+export interface EngramAccessOfflineSyncFinalizeConvergenceRequest {
+    namespaces?: string[];
+    principal?: string;
+    sourceId: string;
+}
+export interface EngramAccessOfflineSyncSnapshotResponse extends OfflineSyncSnapshot {
+    namespace: string;
+}
+export interface EngramAccessOfflineSyncSnapshotStreamResponse extends Omit<OfflineSyncSnapshot, "files"> {
+    namespace: string;
+    files: AsyncIterable<OfflineSyncFileRecord>;
+}
+export interface EngramAccessOfflineSyncFilesResponse extends OfflineSyncSnapshot {
+    namespace: string;
+}
+export interface EngramAccessOfflineSyncFileContentResponse extends OfflineSyncFileContentChunk {
+    namespace: string;
+}
+export interface EngramAccessOfflineSyncApplyFileContentResponse extends OfflineSyncApplyFileContentChunkResult {
+    namespace: string;
+}
+export interface EngramAccessOfflineSyncApplyResponse extends OfflineSyncApplyChangesetResult {
+    namespace: string;
+}
+export interface EngramAccessOfflineSyncFinalizeConvergenceResponse {
+    namespaces: string[];
+    refreshed: true;
+}
+export type EngramAccessActionConfidenceRequest = ActionConfidenceInput;
+export type EngramAccessActionConfidenceResponse = ActionConfidenceResult;
+export declare function buildProjectedGovernanceProposedActions(storage: Awaited<ReturnType<Orchestrator["getStorage"]>>, projected: NonNullable<Awaited<ReturnType<Awaited<ReturnType<Orchestrator["getStorage"]>>["getProjectedGovernanceRecord"]>>>): Promise<Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["appliedActions"]>;
+export declare function hasGroupedGovernanceActions(grouped?: Awaited<ReturnType<typeof readMemoryGovernanceRunArtifact>>["transitionReport"]["proposed"]): boolean;
+export interface EngramAccessReviewDispositionRequest {
+    memoryId: string;
+    status: MemoryStatus | "archived";
+    reasonCode: string;
+    namespace?: string;
+    /**
+     * Trusted transport-bound principal. This must never come from untrusted client payloads.
+     * When present, write authorization is evaluated against this principal instead of sessionKey.
+     */
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessReviewDispositionResponse {
+    ok: boolean;
+    namespace: string;
+    memoryId: string;
+    status: MemoryStatus | "archived";
+    previousStatus: MemoryStatus;
+    currentPath?: string;
+}
+export interface EngramAccessWriteEnvelope {
+    schemaVersion?: number;
+    idempotencyKey?: string;
+    dryRun?: boolean;
+    sessionKey?: string;
+    /** Trusted transport-bound principal (never from client payloads); authorizes writes instead of sessionKey. */
+    authenticatedPrincipal?: string;
+    /** When set, an ACL rejection is NOT dead-lettered (#1888) so `remnic quarantine replay` can re-submit through this same surface without re-quarantining and duplicating the parked record. */
+    readonly suppressQuarantine?: boolean;
+}
+/**
+ * Optional git/project context for project-scoped writes (#1434). When no
+ * explicit `namespace` is supplied, these route the write to the same project
+ * namespace recall/observe resolve from `cwd`/`projectTag` (rule 42 symmetry).
+ */
+export interface CodingScopedWriteInput {
+    cwd?: string;
+    projectTag?: string;
+}
+export type { EngramAccessNamespaceWritableRequest } from "./access-namespace-preflight.js";
+/**
+ * Internal, single-resolution plan describing the effective memory scope for a
+ * write-producing access request (#1495, seed for epic #1494). One plan is
+ * resolved per request and EVERY side effect (LCM archival, extraction replay,
+ * objective-state snapshot, response) consumes the same `writeNamespace`, so an
+ * observed turn and its extracted memories never drift away from the namespace a
+ * same-session project-scoped recall searches (rule 39 / 42).
+ *
+ * The resolver that produces this is READ-ONLY with respect to namespace
+ * authorization: an explicit namespace is authorized through the existing
+ * `canWriteNamespace` policy path, and a coding overlay is always REBUILT from
+ * the authenticated principal's base — never accepted as a caller string — so a
+ * caller can never reach another principal's overlay by forging an
+ * overlay-shaped namespace (rule 42 / 47 / 48).
+ */
+export interface MemoryScopePlan {
+    /** Resolved request principal (auth precedence applied), or undefined. */
+    principal?: string;
+    /** Explicit `namespace` supplied by the caller, if any (already authorized). */
+    explicitNamespace?: string;
+    /** Principal self base namespace before any coding overlay. */
+    baseNamespace: string;
+    /** Effective write namespace — what every side effect must use. */
+    writeNamespace: string;
+    /**
+     * Effective namespace the objective-state snapshot writer must target.
+     *
+     * Objective-state has a STRICTER, pre-#1495 contract than the LCM/extraction
+     * write path (#928): an IMPLICIT (no explicit `namespace`) snapshot is based
+     * on the PRINCIPAL SELF namespace (`defaultNamespaceForPrincipal`) and is
+     * authorized against THAT base (rule 48, least-privilege) — never silently
+     * routed to `config.defaultNamespace`. Only the LCM/extraction/response path
+     * collapses an unqualified write to `config.defaultNamespace` (memory_store
+     * parity, rule 39). With an explicit namespace, or once a coding overlay
+     * applies, both targets converge: `objectiveStateNamespace === writeNamespace`.
+     *
+     * Keeping the two as separate fields of ONE plan preserves rule 22 (single
+     * resolution point) while honoring each consumer's historical contract.
+     */
+    objectiveStateNamespace: string;
+    /** Namespaces a same-session recall would read (cheap subset). */
+    readNamespaces: string[];
+    /** Active scope profile id, when `defaultScopeProfile` is configured. */
+    scopeProfile?: string;
+    /** Internal resolved profile used to keep scoped extraction persistence aligned with access resolution. */
+    scopeProfilePlan?: ResolvedScopeProfilePlan | null;
+    /** Resolved profile layer that supplied `writeNamespace`. */
+    writeLayer?: string;
+    /** Resolved profile layers in the active profile contract. */
+    layers?: ScopeProfileLayerResolution[];
+    /** Authorized promotion targets from the active profile contract. */
+    promotionTargets?: ScopeProfilePromotionResolution[];
+    /** Whether the coding overlay changed the base namespace. */
+    codingOverlayApplied: boolean;
+    /** Non-fatal diagnostics surfaced during resolution. */
+    warnings: string[];
+}
+/**
+ * Raw `category` spelling retained at the request boundary when the wire
+ * schema's canonicalizing transform mapped a compat alias to "fact"
+ * (issue #2829). Diagnostic only: drives the response's `categoryCoercion`
+ * note and survives quarantine parking for replay. Never reaches the write
+ * candidate or the idempotency fingerprint, and never parses from client
+ * input (the wire schema strips it).
+ */
+export interface RetainedCategorySpelling {
+    rawCategory?: string;
+}
+export interface EngramAccessMemoryStoreRequest extends EngramAccessWriteEnvelope, ExplicitCaptureInput, CodingScopedWriteInput, RetainedCategorySpelling {
+}
+export interface EngramAccessSuggestionSubmitRequest extends EngramAccessWriteEnvelope, ExplicitCaptureInput, CodingScopedWriteInput, RetainedCategorySpelling {
+}
+export interface EngramAccessWriteResponse {
+    schemaVersion: 1;
+    operation: "memory_store" | "suggestion_submit";
+    namespace: string;
+    dryRun: boolean;
+    accepted: boolean;
+    queued: boolean;
+    status: "validated" | "stored" | "duplicate" | "queued_for_review";
+    memoryId?: string;
+    duplicateOf?: string;
+    idempotencyKey?: string;
+    idempotencyReplay?: boolean;
+    /** Present when a project-shaped category alias was coerced to "fact" (#2780/#2829). */
+    categoryCoercion?: CategoryAliasCoercion;
+}
+export interface EngramAccessObserveMessage {
+    role: "user" | "assistant";
+    content: string;
+    parts?: LcmMessagePartInput[];
+    rawContent?: unknown;
+    sourceFormat?: MessagePartSourceFormat;
+}
+/**
+ * Observe request. Wire fields derive from the canonical zod schema
+ * (`observeRequestSchema`, access-schema.ts — issue #2482); the service
+ * consumes the transport-cleaned message form (the wire schema tolerates
+ * nullable `parts`/`sourceFormat`, the service maps them to `undefined`).
+ */
+export interface EngramAccessObserveRequest extends Omit<ObserveRequest, "messages">, SourceConnectorProvenance {
+    messages: EngramAccessObserveMessage[];
+    authenticatedPrincipal?: string;
+    readonly suppressQuarantine?: boolean;
+}
+/**
+ * Additive diagnostic view of the effective {@link MemoryScopePlan} resolved for
+ * an `observe` request (#1495 / epic #1494). Lets callers and tests inspect
+ * which namespace the operation actually wrote to without changing the
+ * backward-compatible `namespace` field. Purely informational — never gates
+ * authorization.
+ */
+export interface EngramAccessScopeDebug {
+    /** Resolved principal, or `undefined` when none could be derived. */
+    principal?: string;
+    /** Explicit `namespace` from the request, if one was supplied. */
+    explicitNamespace?: string;
+    /** Principal self base before any coding overlay. */
+    baseNamespace: string;
+    /** Effective write namespace every side effect of the request uses. */
+    writeNamespace: string;
+    /** Whether the coding (project/branch) overlay changed the base namespace. */
+    codingOverlayApplied: boolean;
+    /** Namespaces a same-session recall would read, when cheap to compute. */
+    readNamespaces?: string[];
+    scopeProfile?: string;
+    writeLayer?: string;
+    layers?: ScopeProfileLayerResolution[];
+    promotionTargets?: ScopeProfilePromotionResolution[];
+}
+export interface EngramAccessObserveResponse {
+    accepted: number;
+    sessionKey: string;
+    /**
+     * Backward-compatible base writable namespace (pre-#1495 semantics). Kept
+     * unchanged so existing callers/tests are not broken. The namespace the
+     * operation ACTUALLY wrote to is {@link EngramAccessObserveResponse.effectiveNamespace}.
+     */
+    namespace: string;
+    /**
+     * Effective write namespace every memory-producing side effect of this
+     * request used (LCM archival, extraction replay, objective-state snapshot).
+     * Equals the namespace a same-session project-scoped recall searches (#1495).
+     */
+    effectiveNamespace: string;
+    /** Additive diagnostic view of the resolved scope plan (#1495). */
+    scopeDebug?: EngramAccessScopeDebug;
+    lcmArchived: boolean;
+    extractionQueued: boolean;
+    /** True when at least one observe-derived turn was appended to the transcript store (issue #2783). False when the transcript capability is off, every message was filtered/deduped, or every append failed. */
+    transcriptPersisted: boolean;
+    /** True when replayed from the idempotency cache (issue #1649); lets the HTTP surface skip the write-quota slot, matching memory_store replay semantics. */
+    idempotencyReplay?: boolean;
+}
+export interface EngramAccessLcmSearchRequest {
+    query: string;
+    sessionKey?: string;
+    sessionPrefix?: string;
+    namespace?: string;
+    limit?: number;
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessLcmSearchResponse {
+    query: string;
+    namespace: string;
+    results: Array<{
+        sessionId: string;
+        content: string;
+        turnIndex?: number;
+    }>;
+    count: number;
+    lcmEnabled: boolean;
+}
+export interface EngramAccessLcmStatusResponse {
+    enabled: boolean;
+    archiveAvailable: boolean;
+    stats?: {
+        totalTurns?: number;
+    };
+}
+export interface EngramAccessLcmCompactionRecordRequest {
+    sessionKey: string;
+    namespace?: string;
+    tokensBefore: number;
+    tokensAfter: number;
+    authenticatedPrincipal?: string;
+}
+export interface EngramAccessLcmCompactionRecordResponse {
+    enabled: boolean;
+    recorded: boolean;
+    sessionKey: string;
+    namespace: string;
+    reason?: string;
+}
+type EngramAccessIdempotencyStatus = "miss" | "replay" | "conflict";
+/**
+ * Pure helper that shapes a {@link EngramAccessMemorySummary} from a
+ * {@link MemoryFile} based on the requested disclosure depth (issue #677
+ * PR 2/4).  Extracted so the shaping invariants — chunk emits preview
+ * only, section attaches `content`, raw also surfaces `rawExcerpts` when
+ * the caller passes them — can be unit-tested without booting an
+ * orchestrator.
+ *
+ * Browse / non-recall paths pass `disclosure === undefined` so the
+ * `disclosure`, `content`, and `rawExcerpts` fields are all omitted —
+ * preserving the cheap-by-default browse projection.
+ */
+export declare function shapeMemorySummary(memory: MemoryFile, baseDir: string, disclosure?: RecallDisclosure, rawExcerpts?: EngramAccessMemorySummary["rawExcerpts"]): EngramAccessMemorySummary;
+export declare class EngramAccessService extends SupportPassportAccessServiceBase {
+    private readonly orchestrator;
+    private readonly idempotency;
+    private readonly idempotencyLocks;
+    private readonly recallSemaphores;
+    private readonly recallInFlight;
+    private readonly budget;
+    private readonly auditAdapter;
+    private readonly corpusWatermarkCache;
+    private readonly replicaDivergenceMonitor;
+    private readonly injectedSupportPassportGatewayRoute;
+    readonly reviewDeckEnabled: boolean;
+    readonly recallNavigationEnabled: boolean;
+    /** AccessObserveWriteSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+    private _accessObserveWriteSurface;
+    private get accessObserveWriteSurface();
+    /** AccessLcmSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+    private _accessLcmSurface;
+    private get accessLcmSurface();
+    /** AccessAdminOpsSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+    private _accessAdminOpsSurface;
+    private get accessAdminOpsSurface();
+    private _reviewDeckSurface;
+    private get reviewDeckSurface();
+    /** AccessRecallSurface (access-service decomposition). Lazy; selfDeps live wiring. */
+    private _accessRecallSurface;
+    private get accessRecallSurface();
+    /** AccessIdentityContinuitySurface (access-service decomposition). Lazy; selfDeps live wiring. */
+    private _accessIdentityContinuitySurface;
+    private get accessIdentityContinuitySurface();
+    private readonly extractionLivenessWarn;
+    constructor(orchestrator: Orchestrator, options?: {
+        resolveSecretRef?: ResolveSecretRefFn | null;
+        supportPassportGatewayRoute?: SupportPassportModelRoute | null;
+        reviewDeckEnabled?: boolean;
+    });
+    get supportPassportGatewayRouteRef(): SupportPassportModelRoute | null;
+    get briefingEnabled(): boolean;
+    private resolveNamespace;
+    private normalizeRecallMode;
+    private resolveRecallNamespace;
+    private resolveRequestPrincipal;
+    private writableNamespaceFor;
+    /** Shared coding-scope derivation for the read/write resolvers below —
+     *  coding context, overlay, principal, scope-profile plan for an IMPLICIT
+     *  request, IDENTICAL to recall precedence (session-first, per-call fallback)
+     *  so a scoped store is discoverable by scoped recall (#1434). Single source
+     *  of truth for the namespacesEnabled/projectScope gates (rule 22; keeps the
+     *  scattered-config-read ratchet flat). READ-ONLY: never mutates session. */
+    private resolveCodingScopeInputs;
+    private assertTokenCanWriteNamespace;
+    /**
+     * Resolve the write namespace for explicit-write tools (memory_store /
+     * suggestion_submit), project-scoping the write the same way recall does so a
+     * memory stored with a client-injected `cwd`/`projectTag` is discoverable by
+     * project-scoped recall (#1434, rule 42). Shared derivation lives in
+     * {@link resolveCodingScopeInputs}; this method enforces the WRITE acl
+     * (`canWriteNamespace` / profile-layer writability). Read-only: never mutates
+     * session coding context.
+     */
+    private resolveCodingScopedWriteNamespace;
+    namespaceWritablePreflight(request: EngramAccessNamespaceWritableRequest): Promise<WritableNamespaceResult>;
+    /**
+     *  `list`/`get` use this so a record written by a project-scoped session is
+     *  listable/fetchable by the SAME session without manually supplying the
+     *  overlaid namespace (review P2). Derivation is IDENTICAL to the write path
+     *  (shared via {@link resolveCodingScopeInputs}); the only difference is the
+     *  ACL — reads enforce {@link canReadNamespace}, so a read-but-not-write
+     *  principal can still list/fetch (rule 42). */
+    private resolveCodingScopedReadableNamespace;
+    /**
+     * Resolve ONE effective memory scope plan for a write-producing request
+     * (#1495 / seed for epic #1494). The returned {@link MemoryScopePlan} is the
+     * single source of truth `observe` (and, later, other write surfaces) consume
+     * so every side effect lands in `plan.writeNamespace`.
+     *
+     * Authorization mirrors {@link resolveCodingScopedWriteNamespace} EXACTLY so
+     * `observe`'s scoping is identical to `memory_store`/`suggestion_submit`
+     * (rule 39 — feature gates identical across code paths):
+     *  - an explicit `namespace` always wins and is authorized strictly through
+     *    `resolveWritableNamespace` → `canWriteNamespace`; an overlay-shaped string
+     *    is never a writable target (rule 42 / 47 / 48);
+     *  - with NO overlay, the base stays on `config.defaultNamespace` (pre-#1434
+     *    behavior), auth-checked;
+     *  - WITH an overlay, the base is the principal self namespace and the overlay
+     *    is REBUILT from that authorized base — never accepted as a caller string.
+     *
+     * READ-ONLY: this never mutates session coding context. Callers that need the
+     * `cwd`/`projectTag` bound to the session (so a later bare recall is scoped)
+     * must attach it via `maybeAttachCodingContext` BEFORE calling this, which
+     * also preserves the no-orphan-context guard (attach only after auth passes).
+     * The overlay here reads the session's attached context first (matching recall
+     * precedence), falling back to the per-call `cwd`/`projectTag`.
+     */
+    private resolveMemoryScopePlan;
+    private legacyResponseNamespaceForScope;
+    private objectiveStateStoreLocationForNamespace;
+    private resolveReadableNamespace;
+    private resolveReadableNamespacesForSearch;
+    private resolveAllReadableConfiguredNamespaces;
+    private resolveMemorySearchNamespacesForCollection;
+    private buildRecallDebug;
+    private buildRecallResponseFromXraySnapshot;
+    private serializeRecallResults;
+    private storageForAbsoluteRecallPath;
+    private fetchRawExcerpts;
+    private handleIdempotentWrite;
+    private handleIdempotentRead;
+    private peekIdempotentWrite;
+    private withIdempotencyLock;
+    health(namespace?: string): Promise<EngramAccessHealthResponse>;
+    private qmdCollectionForHealth;
+    private qmdHealth;
+    private namespaceQmdHealth;
+    private qmdCollectionState;
+    private qmdProbeAvailable;
+    actionConfidence(request?: EngramAccessActionConfidenceRequest): Promise<EngramAccessActionConfidenceResponse>;
+    daySummary(request: EngramAccessDaySummaryRequest): Promise<import("./types.js").DaySummaryResult | null>;
+    briefing(request: EngramAccessBriefingRequest): Promise<EngramAccessBriefingResponse>;
+    /**
+     * Attach a coding context to a session (issue #569). Used by the Claude
+     * Code / Codex / generic-MCP connectors at session start so that recall +
+     * write paths can route to a project- / branch-scoped namespace.
+     *
+     * Validates the input shape and rejects malformed payloads rather than
+     * silently accepting them (CLAUDE.md #51). Pass `codingContext: null` to
+     * clear.
+     */
+    setCodingContext(request: EngramAccessSetCodingContextRequest): void;
+    /**
+     * Auto-resolve and attach a coding context for a session when one is not
+     * already present. Resolves from `projectTag` (highest priority after
+     * explicit `codingContext`), then from `cwd` via git detection.
+     *
+     * This is a no-op when:
+     *   - `sessionKey` is missing
+     *   - the session already has a coding context attached
+     *   - codingMode.projectScope is disabled (CLAUDE.md #30)
+     *   - neither `cwd` nor `projectTag` is provided
+     *
+     * Never throws — git resolution failures are silently ignored because not
+     * being in a repo is a normal runtime state.
+     */
+    private maybeAttachCodingContext;
+    /**
+     * Seed the session's coding binding AFTER a committed, project-scoped explicit
+     * write (memory_store / suggestion_submit), mirroring the recall path's
+     * `maybeAttachCodingContext` so a later bare recall/write on the same session
+     * is scoped to the same project. Called only from the post-persist path, so it
+     * never fires on dryRun, replay/conflict, or quota-rejected requests. Skips
+     * when an explicit `namespace` was supplied — that write bypassed the coding
+     * overlay, so binding the session to a project it never wrote to would make
+     * later bare recalls miss (Codex review).
+     */
+    private attachCodingContextAfterScopedWrite;
+    recall(request: EngramAccessRecallRequest): Promise<EngramAccessRecallResponse>;
+    private executeRecall;
+    recallExplain(request?: EngramAccessRecallExplainRequest): Promise<EngramAccessRecallExplainResponse>;
+    recallTierExplain(sessionKey?: string, namespace?: string, authenticatedPrincipal?: string): Promise<import("./recall-explain-renderer.js").RecallExplainJsonPayload>;
+    /**
+     * Budgeted REFINE/EXPAND/STOP deep recall (issue #2332). Deep surface
+     * only — never called from the recall hot path. Single implementation
+     * for MCP, HTTP, and CLI (rule 22: one renderer, one service method).
+     */
+    deepRecall(request: {
+        query: string;
+        namespace?: string;
+        sessionKey?: string;
+        authenticatedPrincipal?: string;
+        maxSteps?: number;
+        /** Transport cancellation (issue #2915): MCP tools/call cancelled, HTTP disconnect. */
+        abortSignal?: AbortSignal;
+    }): Promise<DeepRecallResult & {
+        rendered: string;
+    }>;
+    recallNavigate(request: RecallNavigationRequest): Promise<RecallNavigationResult>;
+    /** Memory-store browse verbs (issue #2978): ls/tree/find over ONE resolved namespace. */
+    memoryStoreBrowse(request: MemoryStoreBrowseRequest): Promise<MemoryStoreBrowseResult>;
+    /** Recall-miss diagnosis (issue #3033). Read-only; see recall-why.ts. */
+    recallWhy(request: RecallWhyRequest): Promise<RecallWhyResponse>;
+    recallXray(request: {
+        query: string;
+        sessionKey?: string;
+        namespace?: string;
+        budget?: number;
+        authenticatedPrincipal?: string;
+        sourceConnector?: string;
+        /**
+         * Disclosure depth used to shape per-result payload (issue #677
+         * PR 3/4).  When set, each X-ray result is decorated with the
+         * matching `disclosure` field and `estimatedTokens` computed from
+         * the actual rendered content at that depth, so the renderer's
+         * "Token spend by disclosure" summary reflects real spend rather
+         * than staying empty when no caller wires the depth knob through.
+         */
+        disclosure?: RecallDisclosure;
+        /**
+         * Free-form recall tag filter (issue #689). Mirrors the field on
+         * `EngramAccessRecallRequest`. When non-empty, the captured X-ray
+         * snapshot's `results` are filtered down to memories whose
+         * frontmatter tags satisfy `tagMatch` ("any" by default), and a
+         * `tag-filter` entry is appended to `filters`.
+         */
+        tags?: string[];
+        /** Match mode for `tags`. See `EngramAccessRecallRequest.tagMatch`. */
+        tagMatch?: "any" | "all";
+        /** Recall planner mode override. Mirrors `EngramAccessRecallRequest.mode`. */
+        mode?: RecallPlanMode | "auto";
+        /**
+         * User-aware context scopes active for this recall. Forwarded into
+         * provenance construction so boundary scopes are evaluated against
+         * the caller's real context instead of an empty-context default.
+         */
+        currentContextScopes?: readonly unknown[];
+        /**
+         * Internal inspector affordance: include a recall-shaped response
+         * derived from the same X-ray snapshot. Left off by default so the
+         * regular X-ray API/CLI/MCP surfaces keep their existing payload shape.
+         */
+        includeRecall?: boolean;
+        /** Cancel the capture before it starts and propagate cancellation to recall. */
+        abortSignal?: AbortSignal;
+    }): Promise<{
+        snapshotFound: boolean;
+        snapshot?: RecallXraySnapshot;
+        recall?: EngramAccessRecallResponse;
+    }>;
+    /**
+     * Rank entities by demonstrated expertise for a topic (issue #2057).
+     * Deterministic — no LLM, no QMD. Reads the namespace-scoped corpus and
+     * entity files only; namespace resolution + ACL mirror recall semantics
+     * (`resolveReadableNamespace`), so a principal cannot rank outside a
+     * namespace it cannot read.
+     */
+    whoKnows(request: {
+        topic: string;
+        limit?: number;
+        namespace?: string;
+        authenticatedPrincipal?: string;
+    }): Promise<WhoKnowsResult>;
+    /**
+     * Read-only promotion-candidate surfacing (issue #2372): agent-subject,
+     * active, reuse-signaled memories in the caller's namespace with no
+     * equivalent in the target layer. No auto-promotion — callers use the
+     * existing promotion commands.
+     */
+    promotionCandidates(request: {
+        namespace?: string;
+        targetNamespace?: string;
+        limit?: number;
+        authenticatedPrincipal?: string;
+    }): Promise<PromotionCandidatesResult>;
+    memoryStore(request: EngramAccessMemoryStoreRequest, hooks?: {
+        enforceWriteQuota?: () => void | Promise<void>;
+    }): Promise<EngramAccessWriteResponse>;
+    peekMemoryStoreIdempotency(rawRequest: EngramAccessMemoryStoreRequest): Promise<EngramAccessIdempotencyStatus>;
+    suggestionSubmit(request: EngramAccessSuggestionSubmitRequest, hooks?: {
+        enforceWriteQuota?: () => void | Promise<void>;
+    }): Promise<EngramAccessWriteResponse>;
+    peekSuggestionSubmitIdempotency(rawRequest: EngramAccessSuggestionSubmitRequest): Promise<EngramAccessIdempotencyStatus>;
+    private validateWriteCandidate;
+    memoryGet(memoryId: string, namespace?: string, principal?: string, sessionKey?: string): Promise<EngramAccessMemoryResponse>;
+    /**
+     * Codegraph parity tool delegate (issue #1554). All three surfaces (MCP,
+     * HTTP, CLI) arrive here via the codegraph_* boundary operations. The
+     * handler lives in coding/codegraph-surfaces.ts; this method just wires
+     * the context. Memory dir + principal + coding-context lookup come from
+     * the orchestrator/access-service fabric -- no handler-side state.
+     */
+    codegraphTool(request: CodegraphSurfaceRequest, authenticatedPrincipal?: string, sourceConnector?: string): Promise<CodegraphSurfaceResponse>;
+    /** Whether the coding_decision tool should appear in tools/list (rule 39). */
+    get decisionRecordSurfaceVisible(): boolean;
+    /**
+     * Thin delegate — handler logic in coding/decision-surfaces.ts (#1548 PR2).
+     * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+     * Namespace resolution uses the SAME path as memory_store (principal ACL +
+     * coding overlay + default fallback) so decision records land in the same
+     * storage root.
+     */
+    codingDecision(request: DecisionSurfaceRequest, authenticatedPrincipal?: string, sourceConnector?: string): Promise<DecisionSurfaceResponse>;
+    /** Whether the coding_architecture tool should appear in tools/list (rule 39). */
+    get architectureCardSurfaceVisible(): boolean;
+    /**
+     * Whether the 14 codegraph parity tools should appear in tools/list
+     * (rule 39). Config-only -- runtime availability is checked at call time.
+     * When false the tools array is byte-identical to pre-feature.
+     */
+    get codegraphSurfaceVisible(): boolean;
+    /**
+     * Thin delegate — handler logic in coding/architecture-surfaces.ts (#1548 PR3).
+     * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+     * Namespace resolution uses the SAME coding-scoped path as decision records.
+     */
+    codingArchitecture(request: ArchitectureSurfaceRequest, authenticatedPrincipal?: string, sourceConnector?: string): Promise<ArchitectureSurfaceResponse>;
+    /** Whether the coding_delta tool should appear in tools/list (rule 39). */
+    get sessionDeltaSurfaceVisible(): boolean;
+    /**
+     * Thin delegate — handler logic in coding/session-delta-surfaces.ts (#1548 PR4).
+     * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+     * Namespace resolution uses the SAME coding-scoped read path as the other
+     * coding surfaces; the delta state file lives under
+     * `<memoryDir>/state/coding-knowledge/<namespace>.json`.
+     */
+    codingDelta(request: DeltaSurfaceRequest, authenticatedPrincipal?: string): Promise<DeltaSurfaceResponse>;
+    /** Whether the memory_correct_plan / memory_correct_apply tools should appear in tools/list (rule 39). Same reader as the runtime gate so visibility + enforcement stay in sync. */
+    get correctionSurfaceVisible(): boolean;
+    private _correctionService;
+    /** Lazily construct + cache the CorrectionService with deps wired from the orchestrator. */
+    private correctionService;
+    /**
+     * Issue #1582 — resolve a single memoryId-or-handle reference to a concrete
+     * memory id. Handles resolve against the session's recall history via the
+     * orchestrator's shared helper (rule 22); raw ids pass through unchanged. A
+     * handle that misses or is ambiguous becomes an EngramAccessInputError so the
+     * boundary maps it to a 400 (rule 34/51 — list candidates, never guess).
+     */
+    private resolveMemoryIdOrHandleInput;
+    correctionPlan(request: CorrectionRequest, opts?: {
+        abortSignal?: AbortSignal;
+    }): Promise<CorrectionPlan>;
+    correctionApply(planId: string, opts: {
+        confirm?: boolean;
+        namespace?: string;
+        sessionKey?: string;
+        principal?: string;
+        abortSignal?: AbortSignal;
+    }): Promise<CorrectionOutcome>;
+    correctionListPending(opts: {
+        namespace?: string;
+        sessionKey?: string;
+        principal?: string;
+    }): Promise<CorrectionPlan[]>;
+    correctionDiscard(planId: string, opts: {
+        namespace?: string;
+        sessionKey?: string;
+        principal?: string;
+    }): Promise<void>;
+    memoryBrowse(request?: EngramAccessMemoryBrowseRequest): Promise<EngramAccessMemoryBrowseResponse>;
+    memoryTimeline(memoryId: string, namespace?: string, limit?: number, principal?: string): Promise<EngramAccessTimelineResponse>;
+    entityList(options?: {
+        namespace?: string;
+        query?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<EngramAccessEntityListResponse>;
+    entityGet(name: string, namespace?: string): Promise<EngramAccessEntityResponse>;
+    reviewQueue(runId?: string, namespace?: string, principal?: string): Promise<EngramAccessReviewQueueResponse>;
+    maintenance(namespace?: string, principal?: string): Promise<EngramAccessMaintenanceResponse>;
+    quality(namespace?: string, principal?: string): Promise<EngramAccessQualityResponse>;
+    governanceRun(request: {
+        namespace?: string;
+        mode?: "shadow" | "apply";
+        recentDays?: number;
+        maxMemories?: number;
+        batchSize?: number;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        namespace: string;
+        runId: string;
+        traceId: string;
+        mode: "shadow" | "apply";
+        reviewQueueCount: number;
+        proposedActionCount: number;
+        appliedActionCount: number;
+        summaryPath: string;
+        reportPath: string;
+    }>;
+    entitySynthesisRun(request: {
+        namespace?: string;
+        maxEntities?: number;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        namespace: string;
+        requested: number;
+        processed: number;
+        remaining: number;
+    }>;
+    procedureMiningRun(request: {
+        namespace?: string;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        namespace: string;
+        clustersProcessed: number;
+        proceduresWritten: number;
+        skippedReason?: string;
+    }>;
+    liveConnectorsRun(request?: {
+        authenticatedPrincipal?: string;
+        force?: boolean;
+    }, principal?: string): Promise<LiveConnectorsRunSummary>;
+    /**
+     * Run the pattern-reinforcement maintenance job (issue #687 PR 2/4).
+     *
+     * Cluster duplicate non-procedural memories and reinforce the
+     * canonical (most-recent) member.  Gated on
+     * `patternReinforcementEnabled` — when disabled, returns
+     * `{ ran: false, skippedReason: "disabled" }` so the cron payload
+     * surface in CI logs cleanly.
+     *
+     * Resolves the namespace via the same writable path used by
+     * `procedureMiningRun` so cross-tenant writes are impossible
+     * (CLAUDE.md rule 42).
+     *
+     * Delegates the run to `orchestrator.runPatternReinforcement` so
+     * the cadence floor (`patternReinforcementCadenceMs`) is enforced
+     * uniformly across cron + MCP paths (PR #730 review feedback,
+     * Codex P2).  Accepts `force: true` for ad-hoc operator runs that
+     * must bypass the cadence floor — mirrors the pattern used by
+     * other maintenance MCP tools.
+     */
+    patternReinforcementRun(request?: {
+        namespace?: string;
+        authenticatedPrincipal?: string;
+        force?: boolean;
+    }, principal?: string): Promise<{
+        namespace: string;
+        ran: boolean;
+        skippedReason?: "disabled" | "cadence";
+        clustersFound: number;
+        canonicalsUpdated: number;
+        duplicatesSuperseded: number;
+        result?: PatternReinforcementResult;
+    }>;
+    /**
+     * Procedural memory stats (issue #567 PR 5/5). Read-only — resolves the
+     * namespace via the same path used by `recallExplain` / `trustZoneStatus`
+     * so cross-tenant reads are impossible (CLAUDE.md rule 42).
+     */
+    procedureStats(request?: {
+        namespace?: string;
+    }, principal?: string): Promise<ProcedureStatsReport & {
+        namespace: string;
+    }>;
+    /**
+     * Procedure library health maintenance (issue #2370). Shadow-first: the
+     * gate is checked BEFORE any storage read, so `maintenance.enabled=false`
+     * returns `{ enabled: false }` having touched nothing but config. Apply
+     * mode additionally requires `apply: true`; `dryRun: true` forces shadow.
+     *
+     * The authenticated principal (never a client-supplied actor) drives the
+     * namespace via the same writable resolver `procedureMiningRun` uses, so
+     * cross-tenant writes are impossible.
+     */
+    procedureLibraryMaintenance(request: {
+        namespace?: string;
+        apply?: boolean;
+        dryRun?: boolean;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        enabled: false;
+    } | {
+        enabled: true;
+        namespace: string;
+        report: ProcedureLibraryMaintenanceReport;
+    }>;
+    memorySummarizeHourly(): Promise<{
+        ok: true;
+        message: string;
+        sessionsConsidered: number;
+        sessionsWithEntries: number;
+        summariesWritten: number;
+        staleStore: boolean;
+        newestEntryTimestamp: string | null;
+        scanFailed: boolean;
+        warning?: string;
+    }>;
+    conversationIndexUpdate(request?: {
+        sessionKey?: string;
+        hours?: number;
+        embed?: boolean;
+    }): Promise<{
+        enabled: boolean;
+        sessionKey?: string;
+        sessions: number;
+        chunks: number;
+        skipped: number;
+        skippedSessionKeys: string[];
+        embeddedRuns: number;
+        reason?: string;
+        retryAfterMs?: number;
+    }>;
+    profilingReport(request?: AccessProfilingReportRequest): Promise<AccessProfilingReportResponse>;
+    trustZoneStatus(namespace?: string, principal?: string): Promise<EngramAccessTrustZoneStatusResponse>;
+    trustZoneBrowse(request: EngramAccessTrustZoneBrowseRequest, principal?: string): Promise<EngramAccessTrustZoneBrowseResponse>;
+    trustZonePromote(request: EngramAccessTrustZonePromoteRequest): Promise<EngramAccessTrustZonePromoteResponse>;
+    trustZoneDemoSeed(request: EngramAccessTrustZoneDemoSeedRequest): Promise<EngramAccessTrustZoneDemoSeedResponse>;
+    reviewDisposition(request: EngramAccessReviewDispositionRequest): Promise<EngramAccessReviewDispositionResponse>;
+    private serializeMemory;
+    private serializeMemorySummary;
+    observe(request: EngramAccessObserveRequest, hooks?: {
+        enforceWriteQuota?: () => void | Promise<void>;
+    }): Promise<EngramAccessObserveResponse>;
+    private runObserve;
+    lcmSearch(request: EngramAccessLcmSearchRequest): Promise<EngramAccessLcmSearchResponse>;
+    /**
+     * Resolve the LCM `session_id` a same-session READER (compaction flush/record,
+     * `lcmSearch`, raw-excerpt lookup) must target so it matches the key `observe`
+     * archived under (#1495 thread 2 + #1505 round 3, rule 42). One helper for
+     * EVERY access-surface LCM read so the read key cannot drift from the write key
+     * (rule 22).
+     *
+     * Precedence mirrors `observe`'s effective write namespace:
+     *  - With an explicit `request.namespace`, use the already-authorized
+     *    `resolvedNamespace` (the overlay never applies to an explicit write).
+     *  - With NO explicit namespace, an auto-scoped session was archived under
+     *    its coding-overlay namespace, so overlay the session's bound coding
+     *    context onto the principal self base — the SAME resolution
+     *    `resolveMemoryScopePlan`/recall use. `applyCodingNamespaceOverlay`
+     *    returns the base unchanged when projectScope/namespaces are off or no
+     *    context is bound, so single-store / no-overlay flows collapse to the raw
+     *    sessionKey exactly as before.
+     *
+     * Then encode the `${namespace}:${sessionKey}` prefix via the shared helper
+     * so the read key is byte-for-byte what the LCM write and the recall readers
+     * use.
+     */
+    private resolveLcmReadNamespace;
+    private resolveRawExcerptReadNamespace;
+    /**
+     * The base `resolvedNamespace` an IMPLICIT (no explicit `namespace`)
+     * same-session LCM READER (`resolveRawExcerptReadNamespace`, `lcmSearch`)
+     * passes into {@link resolveLcmReadNamespace} — WITHOUT pre-authorizing
+     * `default` (#1505 thread NBHWz). It decides PROCEED vs SUPPRESS only; the
+     * actual LCM prefix is then resolved by `resolveLcmReadNamespace`, which
+     * mirrors the orchestrator's `lcmReadNamespaceForSession` EXACTLY (rule 39 /
+     * 42): the coding overlay when the principal SELF base is in the readable
+     * recall set, else `config.defaultNamespace` (the raw key).
+     *
+     * Returns `config.defaultNamespace` (PROCEED) whenever the principal has ANY
+     * readable LCM access — either `default` itself is readable, OR a coding
+     * overlay / self base is in the readable recall set. The returned value is
+     * ALWAYS `config.defaultNamespace`, NEVER an arbitrary readable recall
+     * namespace (e.g. `shared`): `resolveLcmReadNamespace` returns this fallback
+     * verbatim only on the overlay-applies-but-self-unreadable branch, where the
+     * orchestrator collapses to the default store — so returning anything but the
+     * default store there would prefix LCM reads with `shared:sessionKey` while
+     * in-prompt recall uses the raw `sessionKey`, diverging the two (cursor
+     * "LCM read gate wrong fallback").
+     *
+     * Returns `undefined` (SUPPRESS) only when NO readable LCM namespace exists —
+     * a restrictive `default` READ policy AND no readable overlay/self — so the
+     * caller emits NO rows instead of throwing `namespace is not readable:
+     * default`. Normal recall still succeeds through the readable self namespace.
+     *
+     * Single-store / namespaces-disabled deployments resolve to
+     * `config.defaultNamespace`, keeping single-user recall byte-for-byte
+     * unchanged.
+     */
+    private resolveImplicitLcmReadFallbackNamespace;
+    private resolveLcmReadSessionKey;
+    /**
+     * Resolve the ORDERED, read-authorized set of LCM `session_id`s a same-session
+     * READER (`lcmSearch`, raw-excerpt disclosure) must query so it matches every
+     * key `observe` archived under across the coding scope (#1505 thread "Include
+     * coding fallback namespaces in LCM reads").
+     *
+     * Mirrors the orchestrator recall path exactly (rule 39): `observe` archives
+     * each turn under `${effectiveNamespace}:${sessionKey}` for whichever namespace
+     * was effective at write time, and normal QMD/file recall searches the primary
+     * coding-overlay namespace AND `codingOverlay.readFallbacks` (project → root).
+     * A single overlay key therefore MISSES rows a branch-scoped session archived at
+     * project/root scope. This returns the primary overlay LCM key first, then one
+     * per read fallback, deduped + ordered so the caller can short-circuit on the
+     * first hit.
+     *
+     * READ-AUTHORIZATION (preserved from the round-3..5 `resolveLcmReadNamespace`
+     * "read" gate; rule 42 / 48): the overlay + fallbacks are `<principal>-project-*`
+     * sub-namespaces authorized transitively by the principal SELF base. They are
+     * included ONLY when the self base is in the readable recall set
+     * (`recallNamespacesForPrincipal`). When the self base is NOT readable (write-
+     * only / self-omitted principal), or when an explicit namespace was supplied,
+     * or no overlay applies, this collapses to the single key
+     * {@link resolveLcmReadSessionKey} returns — byte-for-byte the prior behavior
+     * (single-store / no-overlay flows stay the raw `sessionKey`). No
+     * `<principal>-project-*` key is ever searched for an unauthorized reader (no
+     * cross-tenant read leak).
+     */
+    private resolveScopeProfileLcmReadNamespaces;
+    private lcmSessionIdsForNamespaces;
+    private resolveLcmReadSessionIds;
+    lcmCompactionFlush(request: EngramAccessLcmCompactionFlushRequest): Promise<EngramAccessLcmCompactionFlushResponse>;
+    extractionForceFlush(request: EngramAccessExtractionForceFlushRequest): Promise<EngramAccessExtractionForceFlushResponse>;
+    cancelPendingObservePreparations(sessionKey: string, scopeHint?: string): void;
+    cancelPendingObserveExtractions(sessionKey: string, principal?: string, namespace?: string, scopeHint?: string): void;
+    lcmCompactionRecord(request: EngramAccessLcmCompactionRecordRequest): Promise<EngramAccessLcmCompactionRecordResponse>;
+    continuityAuditGenerate(request: {
+        period?: "weekly" | "monthly";
+        key?: string;
+    }): Promise<{
+        enabled: boolean;
+        reason?: string;
+        period?: string;
+        key?: string;
+        reportPath?: string;
+    }>;
+    continuityIncidentOpen(request: {
+        symptom: string;
+        namespace?: string;
+        principal?: string;
+        triggerWindow?: string;
+        suspectedCause?: string;
+    }): Promise<unknown>;
+    continuityIncidentClose(request: {
+        id: string;
+        namespace?: string;
+        principal?: string;
+        fixApplied: string;
+        verificationResult: string;
+        preventiveRule?: string;
+    }): Promise<unknown>;
+    continuityIncidentList(request: {
+        state?: "open" | "closed" | "all";
+        namespace?: string;
+        principal?: string;
+        limit?: number;
+    }): Promise<unknown>;
+    continuityLoopAddOrUpdate(request: {
+        id: string;
+        cadence: "daily" | "weekly" | "monthly" | "quarterly";
+        purpose: string;
+        status: "active" | "paused" | "retired";
+        killCondition: string;
+        namespace?: string;
+        principal?: string;
+        lastReviewed?: string;
+        notes?: string;
+    }): Promise<unknown>;
+    continuityLoopReview(request: {
+        id: string;
+        namespace?: string;
+        principal?: string;
+        status?: "active" | "paused" | "retired";
+        notes?: string;
+        reviewedAt?: string;
+    }): Promise<unknown>;
+    identityAnchorGet(request: {
+        namespace?: string;
+        principal?: string;
+    }): Promise<unknown>;
+    /**
+     * @deprecated since issue #679 PR 5/5 — the identity-anchor model is
+     * superseded by the peer registry. Use `peerSet({ id: "self", ... })` or
+     * `remnic peer set self` to update the self peer's identity kernel, and
+     * `remnic peer migrate` to seed `peers/self/identity.md` from existing
+     * legacy anchor data. This method continues to function for backward
+     * compatibility but will be removed in a future major version.
+     */
+    identityAnchorUpdate(request: {
+        namespace?: string;
+        principal?: string;
+        identityTraits?: string;
+        communicationPreferences?: string;
+        operatingPrinciples?: string;
+        continuityNotes?: string;
+    }): Promise<unknown>;
+    memoryIdentity(request: {
+        namespace?: string;
+        principal?: string;
+    }): Promise<unknown>;
+    workTask(request: {
+        action: "create" | "get" | "list" | "update" | "transition" | "delete";
+        id?: string;
+        title?: string;
+        description?: string;
+        status?: string;
+        priority?: string;
+        owner?: string;
+        assignee?: string;
+        projectId?: string;
+        tags?: string[];
+        dueAt?: string;
+    }): Promise<unknown>;
+    workProject(request: {
+        action: "create" | "get" | "list" | "update" | "delete" | "link_task";
+        id?: string;
+        name?: string;
+        description?: string;
+        status?: string;
+        owner?: string;
+        tags?: string[];
+        taskId?: string;
+        projectId?: string;
+    }): Promise<unknown>;
+    workBoard(request: {
+        action: "export_markdown" | "export_snapshot" | "import_snapshot";
+        projectId?: string;
+        snapshotJson?: string;
+        linkToMemory?: boolean;
+    }): Promise<unknown>;
+    sharedContextWriteOutput(request: {
+        agentId: string;
+        title: string;
+        content: string;
+        authority?: string;
+        expiresAt?: string;
+        supersedes?: string;
+        /** Authenticated principal resolved by the surface, never client-supplied. */
+        principal?: string;
+    }): Promise<unknown>;
+    sharedFeedbackRecord(request: {
+        agent: string;
+        decision: "approved" | "approved_with_feedback" | "rejected";
+        reason: string;
+        date?: string;
+        learning?: string;
+        outcome?: string;
+        severity?: "low" | "medium" | "high";
+        confidence?: number;
+        workflow?: string;
+        tags?: string[];
+        evidenceWindowStart?: string;
+        evidenceWindowEnd?: string;
+        refs?: string[];
+    }): Promise<unknown>;
+    sharedPrioritiesAppend(request: {
+        agentId: string;
+        text: string;
+    }): Promise<unknown>;
+    sharedContextCrossSignalsRun(request: {
+        date?: string;
+    }): Promise<unknown>;
+    sharedContextCurateDaily(request: {
+        date?: string;
+    }): Promise<unknown>;
+    compoundingWeeklySynthesize(request: {
+        weekId?: string;
+    }): Promise<unknown>;
+    compoundingPromoteCandidate(request: {
+        weekId: string;
+        candidateId: string;
+        dryRun?: boolean;
+    }): Promise<unknown>;
+    compressionGuidelinesOptimize(request: {
+        dryRun?: boolean;
+        eventLimit?: number;
+    }): Promise<unknown>;
+    compressionGuidelinesActivate(request: {
+        expectedContentHash?: string;
+        expectedGuidelineVersion?: number;
+    }): Promise<unknown>;
+    memorySearch(request: {
+        query: string;
+        namespace?: string;
+        maxResults?: number;
+        collection?: string;
+        mode?: "search" | "hybrid" | "bm25" | "vector";
+        principal?: string;
+    }): Promise<{
+        query: string;
+        results: Array<{
+            path: string;
+            score: number;
+            snippet: string;
+        }>;
+        count: number;
+    }>;
+    memoryProfile(namespace?: string, principal?: string): Promise<Record<string, unknown>>;
+    memoryEntitiesList(namespace?: string, principal?: string): Promise<{
+        entities: string[];
+        count: number;
+    }>;
+    memoryQuestions(namespace?: string, principal?: string): Promise<{
+        questions: Array<{
+            id: string;
+            question: string;
+            resolved: boolean;
+        }>;
+        count: number;
+    }>;
+    lastRecallSnapshot(sessionKey?: string): Promise<unknown>;
+    intentDebug(namespace?: string): Promise<unknown>;
+    qmdDebug(namespace?: string): Promise<unknown>;
+    graphExplainLastRecall(namespace?: string): Promise<unknown>;
+    graphSnapshot(request: GraphSnapshotRequest & {
+        namespace?: string;
+    }, authenticatedPrincipal?: string): Promise<GraphSnapshotResponse>;
+    memoryFeedback(request: {
+        memoryId: string;
+        vote: "up" | "down";
+        note?: string;
+    }): Promise<{
+        recorded: boolean;
+        enabled?: boolean;
+        reason?: string;
+    }>;
+    /**
+     * Record a Memory Worth outcome observation (issue #560 PR 3).
+     *
+     * This is distinct from `memoryFeedback` — feedback is a human thumbs
+     * up/down on whether a recalled memory was relevant; outcome is an
+     * automated signal about whether the session that consumed the memory
+     * ultimately succeeded or failed. Outcomes feed the Laplace-smoothed
+     * worth score (`computeMemoryWorth`, PR 2) that PR 4 will use to
+     * downweight memories correlated with bad sessions.
+     *
+     * The underlying writer only touches fact-category memories. Corrections,
+     * procedures, and other kinds return `{ ok: false, reason:
+     * "ineligible_category" }` so a ledger drainer doesn't need to pre-filter.
+     */
+    memoryOutcome(request: {
+        memoryId: string;
+        outcome: MemoryOutcomeKind;
+        namespace?: string;
+        principal?: string;
+        sessionKey?: string;
+        timestamp?: string;
+    }): Promise<RecordMemoryOutcomeResult>;
+    memoryPromote(request: {
+        memoryId: string;
+        namespace?: string;
+        principal?: string;
+        sessionKey?: string;
+    }): Promise<unknown>;
+    memoryActionApply(request: {
+        action: string;
+        outcome?: string;
+        reason?: string;
+        memoryId?: string;
+        namespace?: string;
+        principal?: string;
+        sessionKey?: string;
+        content?: string;
+        category?: string;
+        linkTargetId?: string;
+        linkType?: string;
+        linkStrength?: number;
+        artifactType?: string;
+        execute?: boolean;
+        sourcePrompt?: string;
+        dryRun?: boolean;
+    }): Promise<unknown>;
+    contextCheckpoint(request: {
+        sessionKey: string;
+        context: string;
+        namespace?: string;
+        principal?: string;
+    }): Promise<{
+        saved: boolean;
+    }>;
+    lcmStatus(): Promise<EngramAccessLcmStatusResponse>;
+    recordCitationUsage(request: CitationUsageRequest): Promise<CitationUsageResult>;
+    /**
+     * Gather a point-in-time `ConsoleStateSnapshot` from the orchestrator.
+     *
+     * Principal-aware: `resolveReadableNamespace` enforces ACL before the
+     * snapshot is gathered, so callers cannot read a namespace they don't
+     * have read access to (CLAUDE.md rule 42).  The resolved namespace's
+     * storage directory is forwarded as `config.memoryDir` so the ledger-
+     * tail reader in `gatherConsoleState` scans the correct namespace root
+     * rather than the global root.  Read-only — never mutates orchestrator state.
+     */
+    consoleState(namespace?: string, principal?: string): Promise<import("./console/state.js").ConsoleStateSnapshot>;
+    /**
+     * List all registered peers. Returns the array of `Peer` objects in
+     * deterministic alphabetical order (mirroring `listPeers` storage semantics).
+     */
+    peerList(): Promise<{
+        peers: import("./peers/types.js").Peer[];
+    }>;
+    /**
+     * Get a single peer by id. Returns `{ found: false }` when the peer does
+     * not exist rather than throwing, matching the `memoryGet` / `entityGet`
+     * pattern used throughout the service.
+     */
+    peerGet(peerId: string): Promise<{
+        found: true;
+        peer: import("./peers/types.js").Peer;
+    } | {
+        found: false;
+    }>;
+    /**
+     * Upsert a peer. Writes `peers/{id}/identity.md`. On first write the
+     * `createdAt` timestamp is set to now; on subsequent writes only
+     * `displayName` and `notes` are mutated (kind and createdAt are immutable
+     * once set, per the storage contract).
+     *
+     * Returns `{ created: true }` on first write, `{ created: false }` on update.
+     */
+    peerSet(input: {
+        id: string;
+        kind?: string;
+        displayName?: string;
+        notes?: string;
+    }): Promise<{
+        ok: true;
+        created: boolean;
+        peer: import("./peers/types.js").Peer;
+    }>;
+    /**
+     * Delete a peer by removing `peers/{id}/identity.md`. If the file does not
+     * exist the call is a no-op (idempotent). The peer directory itself
+     * (`peers/{id}/`) is intentionally left in place — profile and interaction
+     * log data are not destroyed.
+     */
+    peerDelete(peerId: string): Promise<{
+        ok: true;
+        deleted: boolean;
+    }>;
+    /**
+     * Destructively purge the entire peer directory for a given peerId —
+     * `identity.md`, `profile.md`, `interactions.log.md`, and any other
+     * files in `peers/{id}/`. Requires `confirm: "yes"` to prevent
+     * accidental invocation.
+     *
+     * This is the DESTRUCTIVE counterpart to `peerDelete`, which only
+     * removes `identity.md`. All companion files are permanently removed.
+     *
+     * Returns `{ ok: true, purged: true }` when the directory existed and
+     * was removed; `{ ok: true, purged: false }` when the directory did
+     * not exist (idempotent no-op).
+     */
+    peerForget(peerId: string, opts: {
+        confirm: string;
+    }): Promise<{
+        ok: true;
+        purged: boolean;
+    }>;
+    /**
+     * Get the evolving cognitive profile for a peer. Returns `{ found: false }`
+     * when no profile file exists yet (profile is written by the async reasoner,
+     * PR 2/5). The peer identity itself need not exist for a profile to exist,
+     * but in practice the reasoner only writes profiles for registered peers.
+     */
+    peerProfileGet(peerId: string): Promise<{
+        found: true;
+        profile: import("./peers/types.js").PeerProfile;
+    } | {
+        found: false;
+    }>;
+    get memoryDir(): string;
+    /**
+     * Resolve the storage directory for a given namespace.  Used by the SSE
+     * graph-event handler to subscribe to the correct per-namespace bus rather
+     * than the global root (CLAUDE.md rule 42 — read/write paths must resolve
+     * through the same namespace layer).
+     *
+     * `principal` must be the transport-bound request principal (from
+     * `resolveRequestPrincipal`).  When namespaces are enabled, an absent
+     * principal causes `resolveReadableNamespace` to throw an auth error,
+     * matching the behaviour of every other authenticated read path.
+     *
+     * Falls back to `this.memoryDir` when namespaces are disabled or the
+     * namespace is absent, matching the behaviour of every other read path.
+     */
+    getMemoryDirForNamespace(namespace?: string, principal?: string): Promise<string>;
+    getReadableStorageForNamespace(namespace?: string, principal?: string): Promise<{
+        namespace: string;
+        storage: StorageManager;
+    }>;
+    getWritableStorageForNamespace(namespace?: string, principal?: string): Promise<{
+        principal: string;
+        namespace: string;
+        storage: StorageManager;
+    }>;
+    get storageRef(): StorageManager;
+    get configRef(): PluginConfig;
+    getStorageForResolvedNamespace(namespace: string): Promise<StorageManager>;
+    get localLlmRef(): LocalLlmClient | null;
+    get fallbackLlmRef(): FallbackLlmClient | null;
+    get embeddingLookupFactoryRef(): (storage: import("./storage.js").StorageManager) => SemanticDedupLookup | undefined;
+    /**
+     * Import a capsule archive into the orchestrator's memory directory.
+     *
+     * Delegates directly to the standalone {@link importCapsuleFn} function.
+     * The `root` parameter defaults to the orchestrator's `memoryDir` when
+     * omitted, so callers that only have access to the service do not need to
+     * thread the config value through.
+     *
+     * `versioning` defaults to the orchestrator's page-versioning config so
+     * `mode: "overwrite"` automatically snapshots prior content without the
+     * caller having to construct the config object.
+     */
+    capsuleImport(opts: Omit<ImportCapsuleOptions, "root" | "memoryDir"> & {
+        root?: string;
+        memoryDir?: string;
+        namespace?: string;
+        principal?: string;
+    }): Promise<ImportCapsuleResult>;
+    private validateCapsuleImportArchivePath;
+    private isCapsuleImportPathInputFsError;
+    private isCapsuleImportArchiveInputError;
+    /**
+     * Export a capsule archive from the orchestrator's memory directory.
+     *
+     * HTTP and future MCP surfaces use this rather than calling the transfer
+     * helper directly so namespace ACL checks stay consistent with the archive
+     * write side effect. The exporter still owns archive construction and
+     * validation.
+     */
+    capsuleExport(opts: Omit<ExportCapsuleOptions, "root" | "memoryDir"> & {
+        root?: string;
+        memoryDir?: string;
+        namespace?: string;
+        principal?: string;
+    }): Promise<ExportCapsuleResult>;
+    capsuleList(options?: {
+        namespace?: string;
+        principal?: string;
+    }): Promise<EngramAccessCapsuleListResponse>;
+    /**
+     * Operator-configured offline-sync excludes (#1786), compiled once per
+     * service instance. Applied to push-side (snapshot/read) enumeration
+     * only — apply-side stays permissive so remote-authoritative runtime
+     * files keep flowing in.
+     */
+    private _offlineSyncUserExcludes;
+    private get offlineSyncUserExcludes();
+    offlineSyncSnapshot(options?: EngramAccessOfflineSyncSnapshotRequest & {
+        signal?: AbortSignal;
+    }): Promise<EngramAccessOfflineSyncSnapshotResponse>;
+    offlineSyncSnapshotStream(options?: Omit<EngramAccessOfflineSyncSnapshotRequest, "baseCapturedAt" | "baseFiles"> & {
+        signal?: AbortSignal;
+    }): Promise<EngramAccessOfflineSyncSnapshotStreamResponse>;
+    offlineSyncManifestStream(options?: EngramAccessOfflineSyncManifestRequest & {
+        signal?: AbortSignal;
+    }): Promise<OfflineSyncManifestStreamResponse>;
+    offlineSyncFiles(options: EngramAccessOfflineSyncFilesRequest): Promise<EngramAccessOfflineSyncFilesResponse>;
+    offlineSyncFileContent(options: EngramAccessOfflineSyncFileContentRequest): Promise<EngramAccessOfflineSyncFileContentResponse>;
+    offlineSyncApplyFileContent(options: EngramAccessOfflineSyncApplyFileContentRequest): Promise<EngramAccessOfflineSyncApplyFileContentResponse>;
+    offlineSyncFinalizeConvergence(options: EngramAccessOfflineSyncFinalizeConvergenceRequest): Promise<EngramAccessOfflineSyncFinalizeConvergenceResponse>;
+    offlineSyncApply(options: EngramAccessOfflineSyncApplyRequest): Promise<EngramAccessOfflineSyncApplyResponse>;
+    /**
+     * Return per-phase Dreams telemetry for the last N hours (default 24).
+     */
+    dreamsStatus(options?: {
+        windowHours?: number;
+        namespace?: string;
+        principal?: string;
+    }): Promise<import("./types.js").DreamsStatusResult>;
+    dreamsRun(options: {
+        phase: import("./types.js").DreamsPhase;
+        dryRun?: boolean;
+        namespace?: string;
+        authenticatedPrincipal?: string;
+    }): Promise<import("./types.js").DreamsRunResult>;
+    /**
+     * Structural host bound per call so the wearables + meetings ops (issue
+     * #2123) delegate to the pure surface module while the namespace/principal
+     * resolvers stay private.
+     */
+    private get wmHost();
+    wearablesStatus(scope?: WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["status"]>>>;
+    wearablesSync(request: {
+        source?: string;
+        date?: string;
+        days?: number;
+        forceMemories?: boolean;
+    } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["sync"]>>>;
+    wearablesTranscriptDay(request: {
+        date: string;
+        source?: string;
+    } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["dayTranscript"]>>>;
+    wearablesTranscriptSearch(request: {
+        query: string;
+        source?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["searchTranscripts"]>>>;
+    wearablesTranscriptMemories(request: {
+        source?: string;
+        date?: string;
+        limit?: number;
+    } & WearablesMeetingsScope): Promise<Awaited<ReturnType<WearablesService["transcriptMemories"]>>>;
+    meetingsList(date?: string, scope?: WearablesMeetingsScope): Promise<MeetingsListResult>;
+    meetingsGet(id: string, scope?: WearablesMeetingsScope): Promise<MeetingsGetResult>;
+    meetingsBuild(date: string, scope?: WearablesMeetingsScope): Promise<MeetingsDayBuildSummary>;
+    /**
+     * Resolve an effective scope inspection for the console. Inputs are
+     * redacted before return so an operator-supplied principal preview /
+     * namespace override never echoes a pasted credential back.
+     */
+    adminInspectScope(options: {
+        sessionKey?: string;
+        namespace?: string;
+        principalOverride?: string;
+        operation?: InspectScopeOptions["operation"];
+    }): Promise<ScopeInspection>;
+    /**
+     * List configured + discovered namespaces from the catalog with the
+     * admin filters the console exposes.
+     */
+    adminListNamespaces(filter?: AdminNamespaceFilter): Promise<import("./admin/admin-surfaces.js").AdminNamespaceList>;
+    /**
+     * Per-namespace maintenance + QMD health. QMD diagnostics are probed via
+     * the orchestrator's search health accessor (one probe per namespace).
+     */
+    adminMaintenanceHealth(): Promise<import("./admin/admin-surfaces.js").MaintenanceHealthReport>;
+    /**
+     * Dry-run transcript/session audit. Detects mixed `other/default` data
+     * and legacy stranded directories. Never applies a migration.
+     */
+    adminTranscriptAudit(): Promise<import("./admin/admin-surfaces.js").TranscriptAuditReport>;
+    adminPromoteMemory(request: {
+        sourceMemoryId: string;
+        namespace?: string;
+        principal?: string;
+        sessionKey?: string;
+        targets: ReadonlyArray<{
+            kind: MemoryPromotionTargetKind;
+            namespace?: string;
+        }>;
+        reason: string;
+        actor?: never;
+    }): Promise<import("./admin/admin-surfaces.js").MemoryPromotionResult>;
+    reviewDeckList(opts: Parameters<ReviewDeckSurface["list"]>[0]): Promise<import("./index.js").ReviewDeckPage>;
+    reviewDeckAction(...args: Parameters<ReviewDeckSurface["action"]>): Promise<import("./index.js").ReviewDeckActionReceipt>;
+    reviewDeckUndo(...args: Parameters<ReviewDeckSurface["undo"]>): Promise<import("./index.js").ReviewDeckActionReceipt>;
+}
+//# sourceMappingURL=access-service.d.ts.map