@remnic/core 1.0.3 → 1.1.1

package/dist/access-service-Br8ZydTK.d.ts

@@ -0,0 +1,827 @@
+import { StorageManager } from './storage.js';
+import { RecallXraySnapshot } from './recall-xray.js';
+import { RecallExplainJsonPayload } from './recall-explain-renderer.js';
+import { PluginConfig, DaySummaryResult, RecallPlanMode, MemoryFile, MemoryLifecycleEvent, EntityFile, MemoryStatus } from './types.js';
+import { AnomalyDetectorResult } from './recall-audit-anomaly.js';
+import { ExplicitCaptureInput } from './explicit-capture.js';
+import { BudgetDecision } from './cross-namespace-budget.js';
+import { r as readMemoryGovernanceRunArtifact } from './memory-projection-store-DeSXPh1j.js';
+import { LastRecallSnapshot } from './recall-state.js';
+import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot, S as SemanticDedupLookup } from './orchestrator-CmJ-NTdJ.js';
+import { TrustZoneStoreStatus, TrustZoneName, TrustZoneRecordKind, TrustZoneSourceClass, TrustZoneProvenanceScore, TrustZonePromotionResult, TrustZoneDemoSeedResult } from './trust-zones.js';
+import { LocalLlmClient } from './local-llm.js';
+import { FallbackLlmClient } from './fallback-llm.js';
+import { MemoryOutcomeKind, RecordMemoryOutcomeResult } from './memory-worth-outcomes.js';
+
+/**
+ * Procedural memory stats surface (issue #567 PR 5/5).
+ *
+ * Pure helper that tallies procedure memories by status and summarizes the
+ * current `procedural.*` config so operators (and the dashboard) can see,
+ * in one call, how procedural memory is behaving in a namespace.
+ *
+ * Consumed by:
+ *   - CLI `remnic procedural stats`
+ *   - HTTP `GET /engram/v1/procedural/stats`
+ *   - MCP `remnic.procedural_stats` (+ `engram.procedural_stats` alias)
+ */
+
+interface ProcedureStatusCounts {
+    total: number;
+    active: number;
+    pending_review: number;
+    rejected: number;
+    quarantined: number;
+    superseded: number;
+    archived: number;
+    /** Any status the enum doesn't yet cover. */
+    other: number;
+}
+interface ProcedureStatsConfigSnapshot {
+    enabled: boolean;
+    minOccurrences: number;
+    successFloor: number;
+    autoPromoteOccurrences: number;
+    autoPromoteEnabled: boolean;
+    lookbackDays: number;
+    recallMaxProcedures: number;
+}
+interface ProcedureStatsRecent {
+    /** ISO 8601 timestamp of the most recent procedure write, or null. */
+    lastWriteAt: string | null;
+    /** Count of procedure files with `created` (or `updated`) in the last 7 days. */
+    writesLast7Days: number;
+    /** Count of procedures whose `source` is the procedure miner. */
+    minerSourced: number;
+}
+interface ProcedureStatsReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    counts: ProcedureStatusCounts;
+    recent: ProcedureStatsRecent;
+    config: ProcedureStatsConfigSnapshot;
+}
+/**
+ * Read all memories from storage and tally procedures by status + recency.
+ * `nowMs` is injectable so tests can pin the "last 7 days" window.
+ */
+declare function computeProcedureStats(options: {
+    storage: StorageManager;
+    config: PluginConfig;
+    nowMs?: number;
+}): Promise<ProcedureStatsReport>;
+/**
+ * Render `ProcedureStatsReport` as a human-friendly plain-text block for CLI
+ * operators. Keep it deterministic — no colors, no ANSI. Used by `--format text`.
+ */
+declare function formatProcedureStatsText(report: ProcedureStatsReport): string;
+
+declare class EngramAccessInputError extends Error {
+}
+declare const ENGRAM_ACCESS_WRITE_SCHEMA_VERSION = 1;
+interface EngramAccessHealthResponse {
+    ok: true;
+    memoryDir: string;
+    namespacesEnabled: boolean;
+    defaultNamespace: string;
+    searchBackend: string;
+    qmdEnabled: boolean;
+    nativeKnowledgeEnabled: boolean;
+    projectionAvailable: boolean;
+}
+interface EngramAccessRecallRequest {
+    query: string;
+    sessionKey?: string;
+    namespace?: string;
+    topK?: number;
+    mode?: RecallPlanMode | "auto";
+    includeDebug?: boolean;
+    /**
+     * Coding-agent context (issue #569). When a connector resolves a git
+     * context for the session's cwd, it passes it here and the access service
+     * attaches it to the orchestrator before recall so project- / branch-
+     * scoped namespace overlays apply.
+     *
+     * Keyed by `sessionKey`; ignored when `sessionKey` is absent.
+     */
+    codingContext?: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
+}
+/**
+ * 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).
+ */
+interface EngramAccessSetCodingContextRequest {
+    sessionKey: string;
+    codingContext: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
+}
+interface EngramAccessRecallResponse {
+    query: string;
+    sessionKey?: string;
+    namespace: string;
+    context: string;
+    count: number;
+    memoryIds: string[];
+    results: EngramAccessMemorySummary[];
+    recordedAt?: string;
+    traceId?: string;
+    plannerMode?: RecallPlanMode;
+    fallbackUsed: boolean;
+    sourcesUsed: string[];
+    budgetsApplied?: LastRecallSnapshot["budgetsApplied"];
+    auditAnomalies?: AnomalyDetectorResult;
+    budgetWarning?: BudgetDecision;
+    latencyMs?: number;
+    debug?: {
+        snapshot?: LastRecallSnapshot;
+        intent?: IntentDebugSnapshot | null;
+        graph?: GraphRecallSnapshot | null;
+    };
+}
+interface EngramAccessRecallExplainRequest {
+    sessionKey?: string;
+    namespace?: string;
+}
+interface EngramAccessRecallExplainResponse {
+    found: boolean;
+    snapshot?: LastRecallSnapshot;
+    intent?: IntentDebugSnapshot | null;
+    graph?: GraphRecallSnapshot | null;
+}
+interface EngramAccessDaySummaryRequest {
+    memories?: string;
+    sessionKey?: string;
+    namespace?: string;
+}
+/** Inputs accepted by the `remnic_briefing` MCP tool. */
+interface EngramAccessBriefingRequest {
+    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`. */
+interface EngramAccessBriefingResponse {
+    format: "markdown" | "json";
+    window: {
+        from: string;
+        to: string;
+    };
+    namespace: string;
+    markdown: string;
+    json: Record<string, unknown>;
+    followupsUnavailableReason?: string;
+}
+interface EngramAccessMemoryRecord {
+    id: string;
+    path: string;
+    category: string;
+    status?: string;
+    created?: string;
+    updated?: string;
+    content: string;
+    frontmatter: MemoryFile["frontmatter"];
+}
+interface EngramAccessMemorySummary {
+    id: string;
+    path: string;
+    category: string;
+    status: string;
+    created?: string;
+    updated?: string;
+    tags: string[];
+    entityRef?: string;
+    preview: string;
+}
+interface EngramAccessMemoryBrowseRequest {
+    query?: string;
+    status?: string;
+    category?: string;
+    namespace?: string;
+    sort?: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
+    limit?: number;
+    offset?: number;
+}
+interface EngramAccessMemoryBrowseResponse {
+    namespace: string;
+    sort: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    memories: EngramAccessMemorySummary[];
+}
+interface EngramAccessMemoryResponse {
+    found: boolean;
+    namespace: string;
+    memory?: EngramAccessMemoryRecord;
+}
+interface EngramAccessTimelineResponse {
+    found: boolean;
+    namespace: string;
+    count: number;
+    timeline: MemoryLifecycleEvent[];
+}
+interface EngramAccessEntitySummary {
+    name: string;
+    type: string;
+    updated: string;
+    summary?: string;
+    aliases: string[];
+}
+interface EngramAccessEntityListResponse {
+    namespace: string;
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    entities: EngramAccessEntitySummary[];
+}
+interface EngramAccessEntityResponse {
+    found: boolean;
+    namespace: string;
+    entity?: EntityFile;
+}
+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;
+}
+interface EngramAccessMaintenanceResponse {
+    namespace: string;
+    health: EngramAccessHealthResponse;
+    latestGovernanceRun: EngramAccessReviewQueueResponse;
+}
+interface EngramAccessTrustZoneStatusResponse {
+    namespace: string;
+    status: TrustZoneStoreStatus;
+}
+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[];
+}
+interface EngramAccessTrustZoneBrowseRequest {
+    query?: string;
+    zone?: TrustZoneName;
+    kind?: TrustZoneRecordKind;
+    sourceClass?: TrustZoneSourceClass;
+    namespace?: string;
+    limit?: number;
+    offset?: number;
+}
+interface EngramAccessTrustZoneBrowseResponse {
+    namespace: string;
+    total: number;
+    count: number;
+    limit: number;
+    offset: number;
+    records: EngramAccessTrustZoneRecordSummary[];
+}
+interface EngramAccessTrustZonePromoteRequest {
+    recordId: string;
+    targetZone: TrustZoneName;
+    promotionReason: string;
+    recordedAt?: string;
+    summary?: string;
+    dryRun?: boolean;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+}
+interface EngramAccessTrustZonePromoteResponse extends TrustZonePromotionResult {
+    namespace: string;
+    dryRun: boolean;
+}
+interface EngramAccessTrustZoneDemoSeedRequest {
+    scenario?: string;
+    recordedAt?: string;
+    dryRun?: boolean;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+}
+interface EngramAccessTrustZoneDemoSeedResponse extends TrustZoneDemoSeedResult {
+    namespace: string;
+}
+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;
+    };
+}
+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;
+}
+interface EngramAccessReviewDispositionResponse {
+    ok: boolean;
+    namespace: string;
+    memoryId: string;
+    status: MemoryStatus | "archived";
+    previousStatus: MemoryStatus;
+    currentPath?: string;
+}
+interface EngramAccessWriteEnvelope {
+    schemaVersion?: number;
+    idempotencyKey?: string;
+    dryRun?: boolean;
+    sessionKey?: 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;
+}
+interface EngramAccessMemoryStoreRequest extends EngramAccessWriteEnvelope, ExplicitCaptureInput {
+}
+interface EngramAccessSuggestionSubmitRequest extends EngramAccessWriteEnvelope, ExplicitCaptureInput {
+}
+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;
+}
+interface EngramAccessObserveRequest {
+    sessionKey: string;
+    messages: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    namespace?: string;
+    authenticatedPrincipal?: string;
+    skipExtraction?: boolean;
+}
+interface EngramAccessObserveResponse {
+    accepted: number;
+    sessionKey: string;
+    namespace: string;
+    lcmArchived: boolean;
+    extractionQueued: boolean;
+}
+interface EngramAccessLcmSearchRequest {
+    query: string;
+    sessionKey?: string;
+    namespace?: string;
+    limit?: number;
+    authenticatedPrincipal?: string;
+}
+interface EngramAccessLcmSearchResponse {
+    query: string;
+    namespace: string;
+    results: Array<{
+        sessionId: string;
+        content: string;
+        turnIndex?: number;
+    }>;
+    count: number;
+    lcmEnabled: boolean;
+}
+interface EngramAccessLcmStatusResponse {
+    enabled: boolean;
+    archiveAvailable: boolean;
+    stats?: {
+        totalTurns?: number;
+    };
+}
+type EngramAccessIdempotencyStatus = "miss" | "replay" | "conflict";
+declare class EngramAccessService {
+    private readonly orchestrator;
+    private readonly idempotency;
+    private readonly idempotencyLocks;
+    private readonly budget;
+    private readonly auditAdapter;
+    constructor(orchestrator: Orchestrator);
+    get briefingEnabled(): boolean;
+    private resolveNamespace;
+    private normalizeRecallMode;
+    private resolveRecallNamespace;
+    private resolveWritePrincipal;
+    private resolveWritableNamespace;
+    private resolveReadableNamespace;
+    private buildRecallDebug;
+    private serializeRecallResults;
+    private handleIdempotentWrite;
+    private peekIdempotentWrite;
+    private withIdempotencyLock;
+    health(namespace?: string): Promise<EngramAccessHealthResponse>;
+    daySummary(request: EngramAccessDaySummaryRequest): Promise<DaySummaryResult | null>;
+    /**
+     * Build a daily context briefing. Gracefully degrades when the OpenAI key
+     * or Responses API is unavailable — never throws for LLM-related problems.
+     */
+    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;
+    recall(request: EngramAccessRecallRequest): Promise<EngramAccessRecallResponse>;
+    recallExplain(request?: EngramAccessRecallExplainRequest): Promise<EngramAccessRecallExplainResponse>;
+    recallTierExplain(sessionKey?: string, namespace?: string, authenticatedPrincipal?: string): Promise<RecallExplainJsonPayload>;
+    /**
+     * Recall X-ray (issue #570).  Runs a recall with `xrayCapture: true`
+     * and returns the resulting snapshot as structured JSON so every
+     * surface (CLI / HTTP / MCP) gets the same payload.  Namespace scope
+     * is enforced before the recall fires (CLAUDE.md rule 42 — read and
+     * write paths must resolve through the same namespace layer) so an
+     * unauthorized principal cannot capture an x-ray for a namespace it
+     * cannot read.
+     */
+    recallXray(request: {
+        query: string;
+        sessionKey?: string;
+        namespace?: string;
+        budget?: number;
+        authenticatedPrincipal?: string;
+    }): Promise<{
+        snapshotFound: boolean;
+        snapshot?: RecallXraySnapshot;
+    }>;
+    private xrayQueue;
+    memoryStore(request: EngramAccessMemoryStoreRequest): Promise<EngramAccessWriteResponse>;
+    peekMemoryStoreIdempotency(request: EngramAccessMemoryStoreRequest): Promise<EngramAccessIdempotencyStatus>;
+    suggestionSubmit(request: EngramAccessSuggestionSubmitRequest): Promise<EngramAccessWriteResponse>;
+    peekSuggestionSubmitIdempotency(request: EngramAccessSuggestionSubmitRequest): Promise<EngramAccessIdempotencyStatus>;
+    private validateWriteCandidate;
+    memoryGet(memoryId: string, namespace?: string, principal?: string): Promise<EngramAccessMemoryResponse>;
+    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;
+    }>;
+    procedureMiningRun(request: {
+        namespace?: string;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        namespace: string;
+        clustersProcessed: number;
+        proceduresWritten: number;
+        skippedReason?: string;
+    }>;
+    /**
+     * 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;
+    }>;
+    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): Promise<EngramAccessObserveResponse>;
+    lcmSearch(request: EngramAccessLcmSearchRequest): Promise<EngramAccessLcmSearchResponse>;
+    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>;
+    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;
+    }): 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>;
+    /** Conservative identity anchor section merge (matches tools.ts mergeIdentityAnchor logic). */
+    private mergeIdentityAnchorSections;
+    memorySearch(request: {
+        query: string;
+        namespace?: string;
+        maxResults?: number;
+        collection?: string;
+        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>;
+    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>;
+    contextCheckpoint(request: {
+        sessionKey: string;
+        context: string;
+        namespace?: string;
+        principal?: string;
+    }): Promise<{
+        saved: boolean;
+    }>;
+    lcmStatus(): Promise<EngramAccessLcmStatusResponse>;
+    /**
+     * Record citation usage from an observed oai-mem-citation block.
+     * For each citation entry, extract the memory ID from the path and
+     * increment its access tracking via the orchestrator. Returns the
+     * count of submitted IDs and the count of IDs that matched real memories.
+     */
+    recordCitationUsage(request: {
+        sessionId?: string;
+        namespace?: string;
+        authenticatedPrincipal?: string;
+        entries: Array<{
+            path: string;
+            lineStart: number;
+            lineEnd: number;
+            note: string;
+        }>;
+        rolloutIds: string[];
+    }): Promise<{
+        submitted: number;
+        matched: number;
+    }>;
+    get memoryDir(): string;
+    get storageRef(): StorageManager;
+    get configRef(): PluginConfig;
+    get localLlmRef(): LocalLlmClient | null;
+    get fallbackLlmRef(): FallbackLlmClient | null;
+    get embeddingLookupFactoryRef(): (storage: StorageManager) => SemanticDedupLookup | undefined;
+}
+
+export { type EngramAccessQualityResponse as A, type EngramAccessRecallExplainRequest as B, type EngramAccessRecallExplainResponse as C, type EngramAccessRecallRequest as D, EngramAccessService as E, type EngramAccessRecallResponse as F, type EngramAccessReviewDispositionRequest as G, type EngramAccessReviewDispositionResponse as H, type EngramAccessReviewQueueResponse as I, type EngramAccessSetCodingContextRequest as J, type EngramAccessSuggestionSubmitRequest as K, type EngramAccessTimelineResponse as L, type EngramAccessTrustZoneBrowseRequest as M, type EngramAccessTrustZoneBrowseResponse as N, type EngramAccessTrustZoneDemoSeedRequest as O, type ProcedureStatsConfigSnapshot as P, type EngramAccessTrustZoneDemoSeedResponse as Q, type EngramAccessTrustZonePromoteRequest as R, type EngramAccessTrustZonePromoteResponse as S, type EngramAccessTrustZoneRecordSummary as T, type EngramAccessTrustZoneStatusResponse as U, type EngramAccessWriteEnvelope as V, type EngramAccessWriteResponse as W, EngramAccessInputError as a, type ProcedureStatsRecent as b, type ProcedureStatsReport as c, type ProcedureStatusCounts as d, computeProcedureStats as e, formatProcedureStatsText as f, ENGRAM_ACCESS_WRITE_SCHEMA_VERSION as g, type EngramAccessBriefingRequest as h, type EngramAccessBriefingResponse as i, type EngramAccessDaySummaryRequest as j, type EngramAccessEntityListResponse as k, type EngramAccessEntityResponse as l, type EngramAccessEntitySummary as m, type EngramAccessHealthResponse as n, type EngramAccessLcmSearchRequest as o, type EngramAccessLcmSearchResponse as p, type EngramAccessLcmStatusResponse as q, type EngramAccessMaintenanceResponse as r, type EngramAccessMemoryBrowseRequest as s, type EngramAccessMemoryBrowseResponse as t, type EngramAccessMemoryRecord as u, type EngramAccessMemoryResponse as v, type EngramAccessMemoryStoreRequest as w, type EngramAccessMemorySummary as x, type EngramAccessObserveRequest as y, type EngramAccessObserveResponse as z };