@remnic/core 1.0.0

package/dist/access-service.d.ts

@@ -0,0 +1,614 @@
+import { DaySummaryResult, RecallPlanMode, MemoryFile, MemoryLifecycleEvent, EntityFile, MemoryStatus } from './types.js';
+import { ExplicitCaptureInput } from './explicit-capture.js';
+import { r as readMemoryGovernanceRunArtifact } from './memory-projection-store-NxMkbocT.js';
+import { LastRecallSnapshot } from './recall-state.js';
+import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot } from './orchestrator-zTa-Qo-1.js';
+import { TrustZoneStoreStatus, TrustZoneName, TrustZoneRecordKind, TrustZoneSourceClass, TrustZoneProvenanceScore, TrustZonePromotionResult, TrustZoneDemoSeedResult } from './trust-zones.js';
+import 'better-sqlite3';
+import './buffer.js';
+import './storage.js';
+import './port-C1GZFv8h.js';
+import './transcript.js';
+import './session-integrity.js';
+import './summarizer.js';
+import './model-registry.js';
+import './local-llm.js';
+import './relevance.js';
+import './negative.js';
+import './session-observer-state.js';
+import './embedding-fallback.js';
+import './semantic-consolidation.js';
+import 'zod';
+import './policy-runtime.js';
+import './profiling.js';
+
+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;
+}
+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"];
+    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;
+}
+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;
+    constructor(orchestrator: Orchestrator);
+    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>;
+    recall(request: EngramAccessRecallRequest): Promise<EngramAccessRecallResponse>;
+    recallExplain(request?: EngramAccessRecallExplainRequest): Promise<EngramAccessRecallExplainResponse>;
+    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;
+    }>;
+    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;
+    }>;
+    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>;
+}
+
+export { ENGRAM_ACCESS_WRITE_SCHEMA_VERSION, type EngramAccessDaySummaryRequest, type EngramAccessEntityListResponse, type EngramAccessEntityResponse, type EngramAccessEntitySummary, type EngramAccessHealthResponse, EngramAccessInputError, type EngramAccessLcmSearchRequest, type EngramAccessLcmSearchResponse, type EngramAccessLcmStatusResponse, type EngramAccessMaintenanceResponse, type EngramAccessMemoryBrowseRequest, type EngramAccessMemoryBrowseResponse, type EngramAccessMemoryRecord, type EngramAccessMemoryResponse, type EngramAccessMemoryStoreRequest, type EngramAccessMemorySummary, type EngramAccessObserveRequest, type EngramAccessObserveResponse, type EngramAccessQualityResponse, type EngramAccessRecallExplainRequest, type EngramAccessRecallExplainResponse, type EngramAccessRecallRequest, type EngramAccessRecallResponse, type EngramAccessReviewDispositionRequest, type EngramAccessReviewDispositionResponse, type EngramAccessReviewQueueResponse, EngramAccessService, type EngramAccessSuggestionSubmitRequest, type EngramAccessTimelineResponse, type EngramAccessTrustZoneBrowseRequest, type EngramAccessTrustZoneBrowseResponse, type EngramAccessTrustZoneDemoSeedRequest, type EngramAccessTrustZoneDemoSeedResponse, type EngramAccessTrustZonePromoteRequest, type EngramAccessTrustZonePromoteResponse, type EngramAccessTrustZoneRecordSummary, type EngramAccessTrustZoneStatusResponse, type EngramAccessWriteEnvelope, type EngramAccessWriteResponse };

package/dist/access-service.js

@@ -0,0 +1,32 @@
+import {
+  ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+  EngramAccessInputError,
+  EngramAccessService
+} from "./chunk-QY2BHY5O.js";
+import "./chunk-N5AKDXAI.js";
+import "./chunk-EQINRHYR.js";
+import "./chunk-J3BT33K7.js";
+import "./chunk-EEQLFRUM.js";
+import "./chunk-QWUUMMIK.js";
+import "./chunk-U4PV25RD.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-TP4FZJIZ.js";
+import "./chunk-SCU65EZI.js";
+import "./chunk-BOUYNNYD.js";
+import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
+import "./chunk-YNCQ7E4M.js";
+import "./chunk-HLXVTBF3.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-KWBU5S5U.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+import "./chunk-XKECPATV.js";
+import "./chunk-QCCCQT3O.js";
+export {
+  ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
+  EngramAccessInputError,
+  EngramAccessService
+};
+//# sourceMappingURL=access-service.js.map

package/dist/access-service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/behavior-learner.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSignalEvent, PluginConfig, BehaviorLoopPolicyState } from './types.js';
+
+declare const TUNABLE_BEHAVIOR_PARAMETERS: readonly ["recencyWeight", "lifecyclePromoteHeatThreshold", "lifecycleStaleDecayThreshold", "cronRecallInstructionHeavyTokenCap"];
+type TunableBehaviorParameter = (typeof TUNABLE_BEHAVIOR_PARAMETERS)[number];
+interface BehaviorLearnerInput {
+    signals: BehaviorSignalEvent[];
+    now?: Date;
+    learningWindowDays: number;
+    minSignalCount: number;
+    maxDeltaPerCycle: number;
+    protectedParams: string[];
+    currentPolicy: Pick<PluginConfig, "recencyWeight" | "lifecyclePromoteHeatThreshold" | "lifecycleStaleDecayThreshold" | "cronRecallInstructionHeavyTokenCap">;
+}
+declare function learnBehaviorPolicyAdjustments(input: BehaviorLearnerInput): BehaviorLoopPolicyState;
+
+export { type BehaviorLearnerInput, TUNABLE_BEHAVIOR_PARAMETERS, type TunableBehaviorParameter, learnBehaviorPolicyAdjustments };