@remnic/core 1.0.0

package/dist/lifecycle.js

@@ -0,0 +1,21 @@
+import {
+  clamp01,
+  clampLifecycleThreshold,
+  computeDecay,
+  computeHeat,
+  computeLifecycleValueInputs,
+  daysSince,
+  decideLifecycleTransition,
+  resolveLifecycleState
+} from "./chunk-QCCCQT3O.js";
+export {
+  clamp01,
+  clampLifecycleThreshold,
+  computeDecay,
+  computeHeat,
+  computeLifecycleValueInputs,
+  daysSince,
+  decideLifecycleTransition,
+  resolveLifecycleState
+};
+//# sourceMappingURL=lifecycle.js.map

package/dist/lifecycle.js.map

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

package/dist/local-llm.d.ts

@@ -0,0 +1,154 @@
+import { PluginConfig } from './types.js';
+import { ModelRegistry } from './model-registry.js';
+
+/**
+ * Local LLM client for OpenAI-compatible endpoints (LM Studio, Ollama, MLX, etc.)
+ *
+ * Based on openclaw-tactician's provider detection patterns for consistency.
+ * Provides privacy-preserving, cost-effective LLM operations with
+ * graceful fallback to cloud providers when local LLM is unavailable.
+ */
+type LocalLlmType = "lmstudio" | "ollama" | "mlx" | "vllm" | "generic";
+interface LocalModelInfo {
+    id: string;
+    contextWindow?: number;
+    maxTokens?: number;
+}
+type LocalLlmRequestPriority = "recall-critical" | "background";
+interface LocalLlmChatCompletionOptions {
+    temperature?: number;
+    maxTokens?: number;
+    responseFormat?: {
+        type: string;
+    };
+    timeoutMs?: number;
+    operation?: string;
+    priority?: LocalLlmRequestPriority;
+}
+interface LocalLlmChatCompletionResult {
+    content: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+declare class LocalLlmClient {
+    private config;
+    private isAvailable;
+    private lastHealthCheck;
+    private detectedType;
+    private cachedModelInfo;
+    private cachedLmsContext;
+    private lastLmsCheck;
+    private consecutive400s;
+    private cooldownUntilMs;
+    private modelRegistry?;
+    private _disableThinking;
+    private readonly requestQueues;
+    private readonly queueProcessing;
+    private queueDrainScheduled;
+    private static readonly HEALTH_CHECK_INTERVAL_MS;
+    private static readonly LMS_CACHE_INTERVAL_MS;
+    constructor(config: PluginConfig, modelRegistry?: ModelRegistry);
+    /**
+     * Disable thinking/reasoning mode for models that support it (e.g. Qwen 3.5).
+     * When enabled, adds chat_template_kwargs to suppress chain-of-thought,
+     * reducing latency for fast-tier operations.
+     */
+    set disableThinking(value: boolean);
+    private resolveHomeDir;
+    private buildRequestHeaders;
+    private isAbortError;
+    /**
+     * Set the ModelRegistry for caching detected capabilities
+     */
+    setModelRegistry(registry: ModelRegistry): void;
+    /**
+     * Get the detected server type (null if not detected)
+     */
+    getDetectedType(): LocalLlmType | null;
+    private getBackendKey;
+    private getGlobalBackendState;
+    private getTrippedBackendState;
+    private markBackendUnavailable;
+    private extractNonRecoverableBackendReason;
+    private extractNonRecoverableBackendReasonFromErrorText;
+    private normalizeBackendTripReason;
+    /**
+     * Fetch with timeout for health checks
+     */
+    private fetchWithTimeout;
+    /**
+     * Check if local LLM is available
+     * Uses 127.0.0.1 instead of localhost to avoid DNS issues (consistent with tactician)
+     */
+    checkAvailability(): Promise<boolean>;
+    /**
+     * Try to get context window from LM Studio settings.json as fallback.
+     * This reads the defaultContextLength setting which is what LM Studio uses
+     * when loading models without explicit context configuration.
+     */
+    private getContextFromLmStudioSettings;
+    /**
+     * Try to get context window from LMS CLI (LM Studio specific).
+     * Uses --json flag for reliable parsing.
+     * Returns null if LMS CLI is not available or model not found.
+     */
+    private getContextFromLmsCli;
+    /**
+     * Get full model info from LMS CLI including context length and max context length.
+     * Returns null if LMS CLI is unavailable or model not found.
+     */
+    private getLmsModelInfo;
+    /**
+     * Get context window for the configured model, using cache if available.
+     * This method caches the result to avoid repeated LMS CLI calls.
+     * Order: ModelRegistry (persistent) -> memory cache -> LMS CLI -> settings.json
+     */
+    getCachedContextWindow(modelId: string): number | null;
+    /**
+     * Clear the LMS context cache. Call this when the model changes.
+     */
+    clearContextCache(): void;
+    private remainingCooldownMs;
+    private scheduleQueueDrain;
+    private hasQueuedRequests;
+    private dequeueQueuedRequest;
+    private failOpenQueuedRequestsForCooldown;
+    private startAvailableQueuedRequests;
+    private runQueuedRequest;
+    private runChatCompletionRequest;
+    /**
+     * Query the local LLM server for loaded model information.
+     * Returns null if unavailable or if the model is not found.
+     */
+    getLoadedModelInfo(): Promise<LocalModelInfo | null>;
+    /**
+     * Check if the configured model is available and get its actual context window.
+     * Warns if there's a mismatch between expected and actual context.
+     */
+    validateModelConfig(expectedContextWindow?: number): Promise<{
+        available: boolean;
+        actualContextWindow?: number;
+        warnings: string[];
+    }>;
+    /**
+     * Make a chat completion request to local LLM
+     */
+    chatCompletion(messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: LocalLlmChatCompletionOptions): Promise<LocalLlmChatCompletionResult | null>;
+    /**
+     * Estimate tokens when local LLM doesn't return usage stats
+     * Rough estimate: 1 token ≈ 4 characters
+     */
+    private estimateTokens;
+    /**
+     * Try local LLM first, fallback to cloud provider if configured
+     */
+    withFallback<T>(localOperation: () => Promise<T | null>, fallbackOperation: () => Promise<T>, operationName: string): Promise<T>;
+}
+
+export { LocalLlmClient, type LocalLlmRequestPriority, type LocalLlmType, type LocalModelInfo };

package/dist/local-llm.js

@@ -0,0 +1,10 @@
+import {
+  LocalLlmClient
+} from "./chunk-MDDAA2AO.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  LocalLlmClient
+};
+//# sourceMappingURL=local-llm.js.map

package/dist/local-llm.js.map

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

package/dist/logger.d.ts

@@ -0,0 +1,15 @@
+interface LoggerBackend {
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+    debug?(msg: string, ...args: unknown[]): void;
+}
+declare function initLogger(backend: LoggerBackend, debug: boolean): void;
+declare const log: {
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, err?: unknown): void;
+    debug(msg: string, ...args: unknown[]): void;
+};
+
+export { type LoggerBackend, initLogger, log };

package/dist/logger.js

@@ -0,0 +1,9 @@
+import {
+  initLogger,
+  log
+} from "./chunk-KWBU5S5U.js";
+export {
+  initLogger,
+  log
+};
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

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

package/dist/memory-action-policy.d.ts

@@ -0,0 +1,13 @@
+import { MemoryActionType, MemoryActionEligibilityContext, MemoryActionPolicyResult } from './types.js';
+
+interface MemoryActionPolicyOptions {
+    actionsEnabled: boolean;
+    maxCompressionTokensPerHour: number;
+}
+declare function evaluateMemoryActionPolicy(input: {
+    action: MemoryActionType;
+    eligibility: MemoryActionEligibilityContext;
+    options: MemoryActionPolicyOptions;
+}): MemoryActionPolicyResult;
+
+export { type MemoryActionPolicyOptions, evaluateMemoryActionPolicy };

package/dist/memory-action-policy.js

@@ -0,0 +1,7 @@
+import {
+  evaluateMemoryActionPolicy
+} from "./chunk-H63EDPFJ.js";
+export {
+  evaluateMemoryActionPolicy
+};
+//# sourceMappingURL=memory-action-policy.js.map

package/dist/memory-action-policy.js.map

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

package/dist/memory-cache.d.ts

@@ -0,0 +1,35 @@
+import { MemoryFile, EntityFile } from './types.js';
+
+declare function getCachedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null;
+declare function setCachedMemories(baseDir: string, memories: MemoryFile[], version: number): void;
+declare function updateCacheOnWrite(baseDir: string, memory: MemoryFile): void;
+declare function updateCacheOnDelete(baseDir: string, filePath: string): void;
+declare function getCachedArchivedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null;
+declare function setCachedArchivedMemories(baseDir: string, memories: MemoryFile[], version: number): void;
+declare function getCachedEntities(baseDir: string, currentVersion: number): EntityFile[] | null;
+declare function setCachedEntities(baseDir: string, entities: EntityFile[], version: number): void;
+/** Get a pre-filtered Map of episode memories (keyed by ID). Derived from hot cache. */
+declare function getCachedEpisodeMap(baseDir: string, currentVersion: number): Map<string, MemoryFile> | null;
+/** Build and cache the episode memory map from the full memory list. */
+declare function setCachedEpisodeMap(baseDir: string, memories: MemoryFile[], version: number): Map<string, MemoryFile>;
+/** Get pre-filtered rule memories. Derived from hot cache. */
+declare function getCachedRuleMemories(baseDir: string, currentVersion: number): {
+    all: MemoryFile[];
+    byId: Map<string, MemoryFile>;
+} | null;
+/** Build and cache the rule memories from the full memory list. */
+declare function setCachedRuleMemories(baseDir: string, memories: MemoryFile[], version: number): {
+    all: MemoryFile[];
+    byId: Map<string, MemoryFile>;
+};
+declare function getCachedQmdSearch(cacheKey: string): unknown[] | null;
+declare function setCachedQmdSearch(cacheKey: string, results: unknown[]): void;
+declare function clearMemoryCache(baseDir?: string): void;
+declare function getMemoryCacheStats(baseDir: string): {
+    hotSize: number;
+    archiveSize: number;
+    hotVersion: number | null;
+    archiveVersion: number | null;
+};
+
+export { clearMemoryCache, getCachedArchivedMemories, getCachedEntities, getCachedEpisodeMap, getCachedMemories, getCachedQmdSearch, getCachedRuleMemories, getMemoryCacheStats, setCachedArchivedMemories, setCachedEntities, setCachedEpisodeMap, setCachedMemories, setCachedQmdSearch, setCachedRuleMemories, updateCacheOnDelete, updateCacheOnWrite };

package/dist/memory-cache.js

@@ -0,0 +1,37 @@
+import {
+  clearMemoryCache,
+  getCachedArchivedMemories,
+  getCachedEntities,
+  getCachedEpisodeMap,
+  getCachedMemories,
+  getCachedQmdSearch,
+  getCachedRuleMemories,
+  getMemoryCacheStats,
+  setCachedArchivedMemories,
+  setCachedEntities,
+  setCachedEpisodeMap,
+  setCachedMemories,
+  setCachedQmdSearch,
+  setCachedRuleMemories,
+  updateCacheOnDelete,
+  updateCacheOnWrite
+} from "./chunk-ESSMF2FR.js";
+export {
+  clearMemoryCache,
+  getCachedArchivedMemories,
+  getCachedEntities,
+  getCachedEpisodeMap,
+  getCachedMemories,
+  getCachedQmdSearch,
+  getCachedRuleMemories,
+  getMemoryCacheStats,
+  setCachedArchivedMemories,
+  setCachedEntities,
+  setCachedEpisodeMap,
+  setCachedMemories,
+  setCachedQmdSearch,
+  setCachedRuleMemories,
+  updateCacheOnDelete,
+  updateCacheOnWrite
+};
+//# sourceMappingURL=memory-cache.js.map

package/dist/memory-cache.js.map

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

package/dist/memory-lifecycle-ledger-utils.d.ts

@@ -0,0 +1,13 @@
+import { MemoryLifecycleEventType, MemoryFile, MemoryLifecycleEvent, MemoryFrontmatter, MemoryStatus, MemoryLifecycleStateSummary } from './types.js';
+
+declare const MEMORY_LIFECYCLE_RULE_VERSION = "memory-lifecycle-ledger.v1";
+declare const MEMORY_LIFECYCLE_EVENT_SORT_ORDER: Record<MemoryLifecycleEventType, number>;
+declare function toMemoryPathRel(baseDir: string, filePath: string): string;
+declare function isArchivedMemoryPath(pathRel: string): boolean;
+declare function inferMemoryStatus(frontmatter: MemoryFrontmatter, pathRel: string, fallbackStatus?: MemoryStatus): MemoryStatus;
+declare function summarizeMemoryLifecycleState(memory: MemoryFile): MemoryLifecycleStateSummary;
+declare function makeRebuiltMemoryLifecycleEvent(memory: MemoryFile, eventType: MemoryLifecycleEventType, timestamp: string): MemoryLifecycleEvent;
+declare function buildLifecycleEventsForMemory(memory: MemoryFile): MemoryLifecycleEvent[];
+declare function sortMemoryLifecycleEvents(events: MemoryLifecycleEvent[]): MemoryLifecycleEvent[];
+
+export { MEMORY_LIFECYCLE_EVENT_SORT_ORDER, MEMORY_LIFECYCLE_RULE_VERSION, buildLifecycleEventsForMemory, inferMemoryStatus, isArchivedMemoryPath, makeRebuiltMemoryLifecycleEvent, sortMemoryLifecycleEvents, summarizeMemoryLifecycleState, toMemoryPathRel };

package/dist/memory-lifecycle-ledger-utils.js

@@ -0,0 +1,23 @@
+import {
+  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  MEMORY_LIFECYCLE_RULE_VERSION,
+  buildLifecycleEventsForMemory,
+  inferMemoryStatus,
+  isArchivedMemoryPath,
+  makeRebuiltMemoryLifecycleEvent,
+  sortMemoryLifecycleEvents,
+  summarizeMemoryLifecycleState,
+  toMemoryPathRel
+} from "./chunk-TP4FZJIZ.js";
+export {
+  MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  MEMORY_LIFECYCLE_RULE_VERSION,
+  buildLifecycleEventsForMemory,
+  inferMemoryStatus,
+  isArchivedMemoryPath,
+  makeRebuiltMemoryLifecycleEvent,
+  sortMemoryLifecycleEvents,
+  summarizeMemoryLifecycleState,
+  toMemoryPathRel
+};
+//# sourceMappingURL=memory-lifecycle-ledger-utils.js.map

package/dist/memory-lifecycle-ledger-utils.js.map

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

package/dist/memory-projection-format.d.ts

@@ -0,0 +1,4 @@
+declare function normalizeProjectionPreview(content: string, maxChars?: number): string;
+declare function normalizeProjectionTags(tags: string[] | undefined): string[];
+
+export { normalizeProjectionPreview, normalizeProjectionTags };

package/dist/memory-projection-format.js

@@ -0,0 +1,9 @@
+import {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+} from "./chunk-SCU65EZI.js";
+export {
+  normalizeProjectionPreview,
+  normalizeProjectionTags
+};
+//# sourceMappingURL=memory-projection-format.js.map

package/dist/memory-projection-format.js.map

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

package/dist/memory-projection-store-NxMkbocT.d.ts

@@ -0,0 +1,221 @@
+import { MemoryStatus, MemoryCategory, MemoryProjectionCurrentState, MemoryLifecycleEvent } from './types.js';
+import BetterSqlite3 from 'better-sqlite3';
+
+type MemoryGovernanceMode = "shadow" | "apply";
+type MemoryGovernanceReasonCode = "exact_duplicate" | "semantic_duplicate_candidate" | "disputed_memory" | "speculative_low_confidence" | "archive_candidate" | "explicit_capture_review" | "malformed_import";
+interface MemoryGovernanceReviewQueueEntry {
+    entryId: string;
+    memoryId: string;
+    path: string;
+    reasonCode: MemoryGovernanceReasonCode;
+    severity: "low" | "medium" | "high";
+    suggestedAction: "set_status" | "archive";
+    suggestedStatus?: Extract<MemoryStatus, "pending_review" | "quarantined" | "rejected">;
+    relatedMemoryIds: string[];
+}
+interface MemoryGovernanceAppliedAction {
+    action: "set_status" | "archive";
+    memoryId: string;
+    reasonCode: MemoryGovernanceReviewQueueEntry["reasonCode"];
+    beforeStatus: MemoryStatus;
+    afterStatus?: MemoryStatus;
+    originalPath: string;
+    currentPath: string;
+}
+interface MemoryGovernanceRestoreEntry {
+    action: MemoryGovernanceAppliedAction["action"];
+    memoryId: string;
+    reasonCode: MemoryGovernanceReviewQueueEntry["reasonCode"];
+    originalPath: string;
+    currentPath: string;
+    beforeRaw: string;
+    expectedCurrentRaw?: string;
+    applied: boolean;
+}
+interface MemoryGovernanceRestoreManifest {
+    runId: string;
+    createdAt: string;
+    entries: MemoryGovernanceRestoreEntry[];
+}
+interface MemoryGovernanceSummary {
+    schemaVersion: 1;
+    runId: string;
+    traceId: string;
+    mode: MemoryGovernanceMode;
+    createdAt: string;
+    scannedMemories: number;
+    reviewQueueCount: number;
+    proposedActionCount: number;
+    appliedActionCount: number;
+    ruleVersion: string;
+}
+interface MemoryGovernanceMetrics {
+    reviewReasons: Record<MemoryGovernanceReasonCode, number>;
+    proposedStatuses: Record<string, number>;
+    keptMemoryCount: number;
+    qualityScore: MemoryGovernanceQualityScore;
+}
+interface MemoryGovernanceQualityScore {
+    score: number;
+    maxScore: 100;
+    grade: "excellent" | "good" | "fair" | "poor";
+    deductions: Array<{
+        reasonCode: MemoryGovernanceReasonCode;
+        count: number;
+        pointsLost: number;
+    }>;
+}
+interface MemoryGovernanceTransitionReport {
+    proposed: Record<string, MemoryGovernanceAppliedAction[]>;
+    applied: Record<string, MemoryGovernanceAppliedAction[]>;
+}
+interface MemoryGovernanceManifest {
+    schemaVersion: 1;
+    runId: string;
+    traceId: string;
+    mode: MemoryGovernanceMode;
+    createdAt: string;
+    ruleVersion: string;
+    artifacts: Record<string, string>;
+}
+interface MemoryGovernanceRunResult {
+    runId: string;
+    traceId: string;
+    mode: MemoryGovernanceMode;
+    summaryPath: string;
+    reviewQueuePath: string;
+    qualityScorePath: string;
+    transitionReportPath: string;
+    reportPath: string;
+    keptMemoriesPath: string;
+    appliedActionsPath: string;
+    metricsPath: string;
+    manifestPath: string;
+    restorePath?: string;
+    reviewQueue: MemoryGovernanceReviewQueueEntry[];
+    proposedActions: MemoryGovernanceAppliedAction[];
+    appliedActions: MemoryGovernanceAppliedAction[];
+}
+interface RestoreMemoryGovernanceRunResult {
+    runId: string;
+    restoredActions: number;
+    restorePath: string;
+}
+declare function readMemoryGovernanceRunArtifact(memoryDir: string, runId: string): Promise<{
+    summary: MemoryGovernanceSummary;
+    metrics: MemoryGovernanceMetrics;
+    qualityScore: MemoryGovernanceQualityScore;
+    keptMemoryIds: string[];
+    reviewQueue: MemoryGovernanceReviewQueueEntry[];
+    appliedActions: MemoryGovernanceAppliedAction[];
+    transitionReport: MemoryGovernanceTransitionReport;
+    report: string;
+    manifest: MemoryGovernanceManifest;
+    restore?: MemoryGovernanceRestoreManifest;
+}>;
+
+type BetterSqlite3Database = BetterSqlite3.Database;
+
+declare const MEMORY_PROJECTION_SCHEMA_VERSION = 2;
+interface ProjectedMemoryBrowseOptions {
+    query?: string;
+    status?: string;
+    category?: string;
+    sort?: "updated_desc" | "updated_asc" | "created_desc" | "created_asc";
+    limit: number;
+    offset: number;
+}
+interface ProjectedMemoryBrowseRow {
+    id: string;
+    path: string;
+    category: MemoryCategory;
+    status: MemoryStatus;
+    created?: string;
+    updated?: string;
+    tags: string[];
+    entityRef?: string;
+    preview: string;
+}
+interface ProjectedMemoryBrowsePage {
+    total: number;
+    memories: ProjectedMemoryBrowseRow[];
+}
+interface ProjectedEntityMentionRow {
+    memoryId: string;
+    entityRef: string;
+    mentionSource: string;
+    created: string;
+    updated: string;
+}
+interface ProjectedNativeKnowledgeChunkRow {
+    chunkId: string;
+    sourcePath: string;
+    title: string;
+    sourceKind: string;
+    startLine: number;
+    endLine: number;
+    derivedDate?: string;
+    sessionKey?: string;
+    workflowKey?: string;
+    author?: string;
+    agent?: string;
+    namespace?: string;
+    privacyClass?: string;
+    sourceHash?: string;
+    preview: string;
+}
+interface MemoryProjectionGovernanceReviewQueueRow {
+    runId: string;
+    entryId: string;
+    memoryId: string;
+    path: string;
+    reasonCode: MemoryGovernanceReviewQueueEntry["reasonCode"];
+    severity: MemoryGovernanceReviewQueueEntry["severity"];
+    suggestedAction: MemoryGovernanceReviewQueueEntry["suggestedAction"];
+    suggestedStatus?: MemoryGovernanceReviewQueueEntry["suggestedStatus"];
+    relatedMemoryIds: string[];
+}
+interface MemoryProjectionGovernanceAppliedActionRow {
+    runId: string;
+    rowKey: string;
+    action: MemoryGovernanceAppliedAction["action"];
+    memoryId: string;
+    reasonCode: MemoryGovernanceAppliedAction["reasonCode"];
+    beforeStatus: MemoryGovernanceAppliedAction["beforeStatus"];
+    afterStatus?: MemoryGovernanceAppliedAction["afterStatus"];
+    originalPath: string;
+    currentPath: string;
+}
+interface ProjectedReviewQueueSnapshot {
+    found: boolean;
+    runId?: string;
+    summary?: MemoryGovernanceSummary;
+    metrics?: MemoryGovernanceMetrics;
+    reviewQueue?: MemoryGovernanceReviewQueueEntry[];
+    appliedActions?: MemoryGovernanceAppliedAction[];
+    report?: string;
+}
+declare function getMemoryProjectionPath(memoryDir: string): string;
+declare function memoryCurrentSelectExpressions(db: BetterSqlite3Database): {
+    tagsJson: string;
+    previewText: string;
+};
+declare function initializeMemoryProjectionDb(db: BetterSqlite3Database): void;
+declare function parseCurrentRow(memoryDir: string, row: Record<string, unknown> | undefined): MemoryProjectionCurrentState | null;
+declare function parseTimelineRows(rows: Array<Record<string, unknown>>): MemoryLifecycleEvent[];
+declare function readProjectedMemoryState(memoryDir: string, memoryId: string): MemoryProjectionCurrentState | null;
+declare function readProjectedMemoryTimeline(memoryDir: string, memoryId: string, limit: number): MemoryLifecycleEvent[] | null;
+declare function readProjectedMemoryBrowse(memoryDir: string, options: ProjectedMemoryBrowseOptions): ProjectedMemoryBrowsePage | null;
+declare function readProjectedEntityMentions(memoryDir: string, memoryIds?: Set<string>): ProjectedEntityMentionRow[] | null;
+declare function readProjectedNativeKnowledgeChunks(memoryDir: string): ProjectedNativeKnowledgeChunkRow[] | null;
+declare function readProjectedLatestReviewQueue(memoryDir: string): ProjectedReviewQueueSnapshot | null;
+declare function readProjectedGovernanceRecord(memoryDir: string): {
+    runId: string;
+    summary: unknown;
+    metrics: unknown;
+    reviewQueueRows: MemoryProjectionGovernanceReviewQueueRow[];
+    appliedActionRows: MemoryProjectionGovernanceAppliedActionRow[];
+    report: string;
+} | null;
+
+export { readProjectedMemoryState as A, readProjectedMemoryTimeline as B, readProjectedNativeKnowledgeChunks as C, type MemoryGovernanceRunResult as M, type ProjectedMemoryBrowseOptions as P, type RestoreMemoryGovernanceRunResult as R, type MemoryGovernanceSummary as a, type MemoryGovernanceMetrics as b, type MemoryGovernanceQualityScore as c, type MemoryGovernanceReviewQueueEntry as d, type MemoryGovernanceAppliedAction as e, type MemoryGovernanceTransitionReport as f, type MemoryGovernanceManifest as g, type MemoryGovernanceRestoreManifest as h, type ProjectedMemoryBrowsePage as i, readProjectedGovernanceRecord as j, MEMORY_PROJECTION_SCHEMA_VERSION as k, type MemoryProjectionGovernanceAppliedActionRow as l, type MemoryProjectionGovernanceReviewQueueRow as m, type ProjectedEntityMentionRow as n, type ProjectedMemoryBrowseRow as o, type ProjectedNativeKnowledgeChunkRow as p, type ProjectedReviewQueueSnapshot as q, readMemoryGovernanceRunArtifact as r, getMemoryProjectionPath as s, initializeMemoryProjectionDb as t, memoryCurrentSelectExpressions as u, parseCurrentRow as v, parseTimelineRows as w, readProjectedEntityMentions as x, readProjectedLatestReviewQueue as y, readProjectedMemoryBrowse as z };

package/dist/memory-projection-store.d.ts

@@ -0,0 +1,3 @@
+export { k as MEMORY_PROJECTION_SCHEMA_VERSION, l as MemoryProjectionGovernanceAppliedActionRow, m as MemoryProjectionGovernanceReviewQueueRow, n as ProjectedEntityMentionRow, P as ProjectedMemoryBrowseOptions, i as ProjectedMemoryBrowsePage, o as ProjectedMemoryBrowseRow, p as ProjectedNativeKnowledgeChunkRow, q as ProjectedReviewQueueSnapshot, s as getMemoryProjectionPath, t as initializeMemoryProjectionDb, u as memoryCurrentSelectExpressions, v as parseCurrentRow, w as parseTimelineRows, x as readProjectedEntityMentions, j as readProjectedGovernanceRecord, y as readProjectedLatestReviewQueue, z as readProjectedMemoryBrowse, A as readProjectedMemoryState, B as readProjectedMemoryTimeline, C as readProjectedNativeKnowledgeChunks } from './memory-projection-store-NxMkbocT.js';
+import './types.js';
+import 'better-sqlite3';

package/dist/memory-projection-store.js

@@ -0,0 +1,31 @@
+import {
+  MEMORY_PROJECTION_SCHEMA_VERSION,
+  getMemoryProjectionPath,
+  initializeMemoryProjectionDb,
+  memoryCurrentSelectExpressions,
+  parseCurrentRow,
+  parseTimelineRows,
+  readProjectedEntityMentions,
+  readProjectedGovernanceRecord,
+  readProjectedLatestReviewQueue,
+  readProjectedMemoryBrowse,
+  readProjectedMemoryState,
+  readProjectedMemoryTimeline,
+  readProjectedNativeKnowledgeChunks
+} from "./chunk-BOUYNNYD.js";
+export {
+  MEMORY_PROJECTION_SCHEMA_VERSION,
+  getMemoryProjectionPath,
+  initializeMemoryProjectionDb,
+  memoryCurrentSelectExpressions,
+  parseCurrentRow,
+  parseTimelineRows,
+  readProjectedEntityMentions,
+  readProjectedGovernanceRecord,
+  readProjectedLatestReviewQueue,
+  readProjectedMemoryBrowse,
+  readProjectedMemoryState,
+  readProjectedMemoryTimeline,
+  readProjectedNativeKnowledgeChunks
+};
+//# sourceMappingURL=memory-projection-store.js.map

package/dist/memory-projection-store.js.map

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