@remnic/core 1.1.12 → 1.1.14

package/dist/lcm/archive.d.ts

@@ -0,0 +1,89 @@
+import BetterSqlite3 from 'better-sqlite3';
+import { L as LcmMessagePartInput, M as MessagePartSourceFormat } from '../index-DJ9QWMw-.js';
+
+interface LcmMessage {
+    id: number;
+    session_id: string;
+    turn_index: number;
+    role: string;
+    content: string;
+    token_count: number;
+    created_at: string;
+    metadata: string | null;
+}
+interface LcmSearchResult {
+    turn_index: number;
+    role: string;
+    snippet: string;
+    session_id: string;
+    score: number;
+}
+interface LcmSearchWithContentResult {
+    id: number;
+    turn_index: number;
+    role: string;
+    content: string;
+    session_id: string;
+    score: number;
+}
+interface LcmStructuredRecallMatch {
+    part_id: number;
+    message_id: number;
+    turn_index: number;
+    role: string;
+    content: string;
+    session_id: string;
+    kind: string;
+    tool_name: string | null;
+    file_path: string | null;
+    payload: string;
+    score: number;
+}
+/** Rough token count: ~4 chars per token. */
+declare function estimateTokens(text: string): number;
+declare class LcmArchive {
+    private readonly db;
+    constructor(db: BetterSqlite3.Database);
+    /** Append a message to the archive. Returns the row id. */
+    appendMessage(sessionId: string, turnIndex: number, role: string, content: string, metadata?: Record<string, unknown>, parts?: LcmMessagePartInput[]): number;
+    /** Append multiple messages in a single transaction. */
+    appendMessages(sessionId: string, messages: Array<{
+        turnIndex: number;
+        role: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+        parts?: LcmMessagePartInput[];
+        rawContent?: unknown;
+        sourceFormat?: MessagePartSourceFormat;
+    }>, options?: {
+        messagePartsEnabled?: boolean;
+    }): void;
+    insertMessageParts(messageId: number, parts: LcmMessagePartInput[], fallbackCreatedAt: string): void;
+    /** Get the highest turn_index for a session, or -1 if none. */
+    getMaxTurnIndex(sessionId: string): number;
+    /** Retrieve messages in a turn range (inclusive). */
+    getMessages(sessionId: string, fromTurn: number, toTurn: number): LcmMessage[];
+    /** Retrieve unsummarized messages (after last leaf summary). */
+    getUnsummarizedMessages(sessionId: string): LcmMessage[];
+    /** Full-text search across all messages. */
+    search(query: string, limit: number, sessionId?: string): LcmSearchResult[];
+    /**
+     * Full-text search returning focused excerpts around matching terms.
+     * Returns ~1000-char windows centered on query term matches.
+     * Deduplicates by message id and returns results sorted by FTS rank.
+     */
+    searchWithContent(query: string, limit: number, sessionId?: string, excerptChars?: number): LcmSearchWithContentResult[];
+    searchStructuredParts(query: string, limit: number, sessionId?: string): LcmStructuredRecallMatch[];
+    /** Get total message count for a session. */
+    getMessageCount(sessionId: string): number;
+    /** Get total message count across all sessions. */
+    getTotalMessageCount(): number;
+    /** Delete all archived messages for one session. */
+    deleteSession(sessionId: string): number;
+    /** Delete all archived messages. */
+    deleteAll(): number;
+    /** Prune messages older than retentionDays. */
+    pruneOldMessages(retentionDays: number): number;
+}
+
+export { LcmArchive, type LcmMessage, type LcmSearchResult, type LcmSearchWithContentResult, type LcmStructuredRecallMatch, estimateTokens };

package/dist/lcm/archive.js

@@ -0,0 +1,12 @@
+import {
+  LcmArchive,
+  estimateTokens
+} from "../chunk-56K5QLHX.js";
+import "../chunk-3APJ5EVB.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmArchive,
+  estimateTokens
+};
+//# sourceMappingURL=archive.js.map

package/dist/lcm/archive.js.map

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

package/dist/lcm/dag.d.ts

@@ -0,0 +1,48 @@
+import BetterSqlite3 from 'better-sqlite3';
+
+interface SummaryNode {
+    id: string;
+    session_id: string;
+    depth: number;
+    parent_id: string | null;
+    summary_text: string;
+    token_count: number;
+    msg_start: number;
+    msg_end: number;
+    escalation: number;
+    created_at: string;
+}
+declare class LcmDag {
+    private readonly db;
+    constructor(db: BetterSqlite3.Database);
+    /** Insert a new summary node. */
+    insertNode(node: Omit<SummaryNode, "created_at">): void;
+    /** Get leaf nodes (depth=0) for a session without a parent yet, ordered by msg_start. */
+    getOrphanNodesAtDepth(sessionId: string, depth: number): SummaryNode[];
+    /** Get all nodes at a given depth for a session. */
+    getNodesAtDepth(sessionId: string, depth: number): SummaryNode[];
+    /** Get child nodes of a parent. */
+    getChildren(parentId: string): SummaryNode[];
+    /** Get the deepest summary nodes covering a session (highest depth, broadest coverage). */
+    getDeepestNodes(sessionId: string): SummaryNode[];
+    /** Get the maximum depth for a session. */
+    getMaxDepth(sessionId: string): number;
+    /** Get summary nodes that best cover a turn range, preferring higher depth. */
+    getCoveringNodes(sessionId: string, fromTurn: number, toTurn: number): SummaryNode[];
+    /** Get all nodes for a session, ordered by depth then range. */
+    getAllNodes(sessionId: string): SummaryNode[];
+    /** Get total node count for a session. */
+    getNodeCount(sessionId: string): number;
+    /** Delete all summary and compaction state for one session. */
+    deleteSession(sessionId: string): number;
+    /** Delete all summary and compaction state. */
+    deleteAll(): number;
+    /** Set parent_id for a list of child node IDs. */
+    setParent(childIds: string[], parentId: string): void;
+    /** Record a compaction event. */
+    recordCompaction(sessionId: string, msgBefore: number, tokensBefore: number, tokensAfter: number): void;
+    /** Prune summary nodes for old sessions. */
+    pruneOldNodes(retentionDays: number): number;
+}
+
+export { LcmDag, type SummaryNode };

package/dist/lcm/dag.js

@@ -0,0 +1,8 @@
+import {
+  LcmDag
+} from "../chunk-7N4KAIGN.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmDag
+};
+//# sourceMappingURL=dag.js.map

package/dist/lcm/dag.js.map

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

package/dist/lcm/engine.d.ts

@@ -0,0 +1,116 @@
+import { LcmStructuredRecallMatch } from './archive.js';
+import { SummarizeFn } from './summarizer.js';
+import { LcmObserveMessage } from './queue.js';
+import { PluginConfig } from '../types.js';
+import 'better-sqlite3';
+import '../index-DJ9QWMw-.js';
+import './dag.js';
+
+interface LcmEngineConfig {
+    enabled: boolean;
+    leafBatchSize: number;
+    rollupFanIn: number;
+    freshTailTurns: number;
+    maxDepth: number;
+    deterministicMaxTokens: number;
+    archiveRetentionDays: number;
+    recallBudgetShare: number;
+    observeConcurrency: number;
+    telemetryPrefilterEnabled: boolean;
+    messagePartsEnabled: boolean;
+    messagePartsRecallMaxResults: number;
+}
+declare function extractLcmConfig(cfg: PluginConfig): LcmEngineConfig;
+declare class LcmEngine {
+    private readonly summarizeFn;
+    private db;
+    private archive;
+    private dag;
+    private summarizer;
+    private observeQueue;
+    private closed;
+    private readonly config;
+    private readonly memoryDir;
+    private initPromise;
+    private readonly pendingObserveInitCounts;
+    private readonly pendingObserveInitWaiters;
+    private readonly pendingObserveInitIdleWaiters;
+    constructor(pluginConfig: PluginConfig, summarizeFn: SummarizeFn);
+    get enabled(): boolean;
+    /** Lazy init — open database on first use. */
+    ensureInitialized(): Promise<void>;
+    private doInit;
+    /**
+     * Enqueue messages from agent_end hook.
+     * The queue worker performs the archive append and incremental summarization.
+     */
+    observeMessages(sessionId: string, messages: LcmObserveMessage[]): Promise<void>;
+    /** Enqueue an observe job without waiting for worker completion. */
+    enqueueObserveMessages(sessionId: string, messages: LcmObserveMessage[]): void;
+    private processObserveMessages;
+    get observeQueueDepth(): number;
+    get observeQueueInFlightCount(): number;
+    waitForObserveQueueIdle(): Promise<void>;
+    waitForSessionObserveIdle(sessionId: string): Promise<void>;
+    private reservePendingObserveInit;
+    private releasePendingObserveInit;
+    private waitForPendingObserveInitIdle;
+    /** Build the compressed history recall section for a session. */
+    assembleRecall(sessionId: string, budgetChars: number): Promise<string>;
+    searchStructuredParts(sessionId: string, query: string, limit?: number): Promise<LcmStructuredRecallMatch[]>;
+    formatStructuredRecall(matches: LcmStructuredRecallMatch[], budgetChars: number): string;
+    /** Flush pending summaries before compaction (called from before_compaction hook). */
+    preCompactionFlush(sessionId: string): Promise<void>;
+    /** Record a compaction event with real token counts (called from after_compaction hook). */
+    recordCompaction(sessionId: string, tokensBefore: number, tokensAfter: number): Promise<void>;
+    /** Verify archive coverage after compaction. */
+    verifyPostCompaction(sessionId: string): Promise<void>;
+    /** Search across all conversation history via FTS (snippet mode). */
+    searchContext(query: string, limit: number, sessionId?: string): Promise<Array<{
+        turn_index: number;
+        role: string;
+        snippet: string;
+        session_id: string;
+    }>>;
+    /** Search via FTS returning full message content (not snippets). */
+    searchContextFull(query: string, limit: number, sessionId?: string): Promise<Array<{
+        id: number;
+        turn_index: number;
+        role: string;
+        content: string;
+        session_id: string;
+        score: number;
+    }>>;
+    /** Get a compressed summary of a turn range. */
+    describeContext(sessionId: string, fromTurn: number, toTurn: number): Promise<{
+        summary: string;
+        turn_count: number;
+        depth: number;
+    } | null>;
+    /** Retrieve raw messages for a turn range (lossless expansion). */
+    expandContext(sessionId: string, fromTurn: number, toTurn: number, maxTokens: number): Promise<Array<{
+        turn_index: number;
+        role: string;
+        content: string;
+    }>>;
+    /** Get statistics about the LCM archive. */
+    getStats(sessionId?: string): Promise<{
+        totalMessages: number;
+        totalSummaryNodes: number;
+        maxDepth: number;
+        maxTurnIndex?: number;
+    }>;
+    /** Clear all LCM archive and summary state for one session. */
+    clearSession(sessionId: string): Promise<void>;
+    /** Clear all LCM archive and summary state without closing the engine. */
+    clearAll(): Promise<void>;
+    /** Prune old data beyond retention period. */
+    prune(): Promise<{
+        messagesPruned: number;
+        nodesPruned: number;
+    }>;
+    /** Close the database connection. */
+    close(): void;
+}
+
+export { LcmEngine, type LcmEngineConfig, extractLcmConfig };

package/dist/lcm/engine.js

@@ -0,0 +1,20 @@
+import {
+  LcmEngine,
+  extractLcmConfig
+} from "../chunk-VNO6ZJ35.js";
+import "../chunk-34DQE4KF.js";
+import "../chunk-56K5QLHX.js";
+import "../chunk-7N4KAIGN.js";
+import "../chunk-TPDBFYEG.js";
+import "../chunk-ZTFCYYEZ.js";
+import "../chunk-7XYTQGCC.js";
+import "../chunk-4RA3C3EV.js";
+import "../chunk-3APJ5EVB.js";
+import "../chunk-3HPAPHUK.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmEngine,
+  extractLcmConfig
+};
+//# sourceMappingURL=engine.js.map

package/dist/lcm/engine.js.map

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

package/dist/lcm/index.d.ts

@@ -0,0 +1,12 @@
+export { LcmEngine, LcmEngineConfig, extractLcmConfig } from './engine.js';
+export { LcmArchive, estimateTokens } from './archive.js';
+export { LcmDag, SummaryNode } from './dag.js';
+export { LcmSummarizer, SummarizeFn } from './summarizer.js';
+export { assembleCompressedHistory } from './recall.js';
+export { registerLcmTools } from './tools.js';
+export { ensureLcmStateDir, openLcmDatabase } from './schema.js';
+import './queue.js';
+import '../index-DJ9QWMw-.js';
+import '../types.js';
+import 'better-sqlite3';
+import '../runtime/better-sqlite.js';

package/dist/lcm/index.js

@@ -0,0 +1,44 @@
+import "../chunk-HHLLAQGZ.js";
+import {
+  registerLcmTools
+} from "../chunk-UWK5OXUJ.js";
+import {
+  LcmEngine,
+  extractLcmConfig
+} from "../chunk-VNO6ZJ35.js";
+import {
+  LcmSummarizer
+} from "../chunk-34DQE4KF.js";
+import {
+  LcmArchive,
+  estimateTokens
+} from "../chunk-56K5QLHX.js";
+import {
+  LcmDag
+} from "../chunk-7N4KAIGN.js";
+import "../chunk-TPDBFYEG.js";
+import {
+  assembleCompressedHistory
+} from "../chunk-ZTFCYYEZ.js";
+import {
+  ensureLcmStateDir,
+  openLcmDatabase
+} from "../chunk-7XYTQGCC.js";
+import "../chunk-4RA3C3EV.js";
+import "../chunk-3APJ5EVB.js";
+import "../chunk-3HPAPHUK.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmArchive,
+  LcmDag,
+  LcmEngine,
+  LcmSummarizer,
+  assembleCompressedHistory,
+  ensureLcmStateDir,
+  estimateTokens,
+  extractLcmConfig,
+  openLcmDatabase,
+  registerLcmTools
+};
+//# sourceMappingURL=index.js.map

package/dist/lcm/index.js.map

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

package/dist/lcm/queue.d.ts

@@ -0,0 +1,62 @@
+import { L as LcmMessagePartInput, M as MessagePartSourceFormat } from '../index-DJ9QWMw-.js';
+
+interface LcmObserveMessage {
+    role: string;
+    content: string;
+    parts?: LcmMessagePartInput[];
+    rawContent?: unknown;
+    sourceFormat?: MessagePartSourceFormat;
+}
+interface LcmWorkQueueHooks {
+    onJobStart?: (input: {
+        sessionId: string;
+        depth: number;
+        inFlight: number;
+        waitMs: number;
+    }) => void;
+    onJobFinish?: (input: {
+        sessionId: string;
+        depth: number;
+        inFlight: number;
+        waitMs: number;
+        runMs: number;
+        totalMs: number;
+        error?: unknown;
+    }) => void;
+}
+interface LcmWorkQueueOptions {
+    concurrency?: number;
+    worker: (sessionId: string, messages: LcmObserveMessage[]) => Promise<void>;
+    hooks?: LcmWorkQueueHooks;
+}
+/**
+ * Small keyed work queue for LCM observe processing.
+ *
+ * Jobs are coalesced per session while they are pending. A session can have
+ * at most one in-flight job at a time, and the queue processes jobs FIFO up to
+ * the configured concurrency limit.
+ */
+declare class LcmWorkQueue {
+    private readonly concurrency;
+    private readonly worker;
+    private readonly hooks;
+    private readonly pending;
+    private readonly inFlightSessions;
+    private inFlight;
+    private readonly idleWaiters;
+    private readonly sessionIdleWaiters;
+    private drainScheduled;
+    constructor(options: LcmWorkQueueOptions);
+    enqueue(sessionId: string, messages: LcmObserveMessage[]): void;
+    get depth(): number;
+    get inFlightCount(): number;
+    whenIdle(): Promise<void>;
+    whenSessionIdle(sessionId: string): Promise<void>;
+    private startAvailableJobs;
+    private scheduleDrain;
+    private runJob;
+    private resolveIdleWaitersIfNeeded;
+    private resolveSessionIdleWaitersIfNeeded;
+}
+
+export { type LcmObserveMessage, LcmWorkQueue, type LcmWorkQueueHooks, type LcmWorkQueueOptions };

package/dist/lcm/queue.js

@@ -0,0 +1,8 @@
+import {
+  LcmWorkQueue
+} from "../chunk-TPDBFYEG.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmWorkQueue
+};
+//# sourceMappingURL=queue.js.map

package/dist/lcm/queue.js.map

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

package/dist/lcm/recall.d.ts

@@ -0,0 +1,20 @@
+import { LcmDag } from './dag.js';
+import { LcmArchive } from './archive.js';
+import 'better-sqlite3';
+import '../index-DJ9QWMw-.js';
+
+interface LcmRecallConfig {
+    freshTailTurns: number;
+    budgetChars: number;
+}
+/**
+ * Assemble a compressed session history section from the summary DAG.
+ *
+ * Strategy:
+ * 1. For the "fresh tail" (most recent N turns), use leaf-level summaries for maximum detail.
+ * 2. For older portions, use the deepest available summary nodes (most compressed).
+ * 3. Fill within budget, prioritizing recent content.
+ */
+declare function assembleCompressedHistory(dag: LcmDag, archive: LcmArchive, sessionId: string, config: LcmRecallConfig): string;
+
+export { type LcmRecallConfig, assembleCompressedHistory };

package/dist/lcm/recall.js

@@ -0,0 +1,8 @@
+import {
+  assembleCompressedHistory
+} from "../chunk-ZTFCYYEZ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  assembleCompressedHistory
+};
+//# sourceMappingURL=recall.js.map

package/dist/lcm/recall.js.map

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

package/dist/lcm/schema.d.ts

@@ -0,0 +1,16 @@
+import { BetterSqlite3Database } from '../runtime/better-sqlite.js';
+import 'better-sqlite3';
+
+declare function openLcmDatabase(memoryDir: string): BetterSqlite3Database;
+declare function ensureLcmStateDir(memoryDir: string): Promise<void>;
+/**
+ * Apply (or upgrade) the LCM schema on an already-open SQLite handle.
+ *
+ * Exposed so optional host packages — e.g. importers using an in-memory
+ * destination database for true read-only `--dry-run` execution — can
+ * bootstrap the schema without going through `openLcmDatabase()` (which
+ * always touches the filesystem).
+ */
+declare function applyLcmSchema(db: BetterSqlite3Database): void;
+
+export { applyLcmSchema, ensureLcmStateDir, openLcmDatabase };

package/dist/lcm/schema.js

@@ -0,0 +1,14 @@
+import {
+  applyLcmSchema,
+  ensureLcmStateDir,
+  openLcmDatabase
+} from "../chunk-7XYTQGCC.js";
+import "../chunk-3HPAPHUK.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  applyLcmSchema,
+  ensureLcmStateDir,
+  openLcmDatabase
+};
+//# sourceMappingURL=schema.js.map

package/dist/lcm/schema.js.map

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

package/dist/lcm/summarizer.d.ts

@@ -0,0 +1,38 @@
+import { LcmArchive } from './archive.js';
+import { LcmDag } from './dag.js';
+import 'better-sqlite3';
+import '../index-DJ9QWMw-.js';
+
+type SummarizeFn = (text: string, targetTokens: number, aggressive: boolean) => Promise<string | null>;
+interface LcmSummarizerConfig {
+    leafBatchSize: number;
+    rollupFanIn: number;
+    maxDepth: number;
+    deterministicMaxTokens: number;
+    telemetryPrefilterEnabled: boolean;
+}
+declare class LcmSummarizer {
+    private readonly archive;
+    private readonly dag;
+    private readonly summarizeFn;
+    private readonly config;
+    constructor(archive: LcmArchive, dag: LcmDag, summarizeFn: SummarizeFn, config: LcmSummarizerConfig);
+    /**
+     * Run incremental summarization for a session.
+     * Creates leaf nodes from unsummarized messages, then rolls up as needed.
+     */
+    summarizeIncremental(sessionId: string): Promise<number>;
+    /** Create a leaf summary node (depth 0) from a batch of messages. */
+    private createLeafNode;
+    /** Roll up orphan nodes at each depth level up to maxDepth. */
+    private rollupAll;
+    /**
+     * Three-level escalation:
+     * 0 = Normal LLM summary
+     * 1 = Aggressive bullet compression
+     * 2 = Deterministic truncation (no LLM)
+     */
+    private summarizeWithEscalation;
+}
+
+export { LcmSummarizer, type LcmSummarizerConfig, type SummarizeFn };

package/dist/lcm/summarizer.js

@@ -0,0 +1,12 @@
+import {
+  LcmSummarizer
+} from "../chunk-34DQE4KF.js";
+import "../chunk-56K5QLHX.js";
+import "../chunk-4RA3C3EV.js";
+import "../chunk-3APJ5EVB.js";
+import "../chunk-2ODBA7MQ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  LcmSummarizer
+};
+//# sourceMappingURL=summarizer.js.map

package/dist/lcm/summarizer.js.map

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

package/dist/lcm/tools.d.ts

@@ -0,0 +1,29 @@
+import { LcmEngine } from './engine.js';
+import './archive.js';
+import 'better-sqlite3';
+import '../index-DJ9QWMw-.js';
+import './summarizer.js';
+import './dag.js';
+import './queue.js';
+import '../types.js';
+
+interface ToolApi {
+    registerTool(spec: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: unknown;
+        execute: (toolCallId: string, params: Record<string, unknown>, signal?: AbortSignal) => Promise<{
+            content: Array<{
+                type: string;
+                text: string;
+            }>;
+            details: undefined;
+        }>;
+    }, options: {
+        name: string;
+    }): void;
+}
+declare function registerLcmTools(api: ToolApi, engine: LcmEngine): void;
+
+export { registerLcmTools };

package/dist/lcm/tools.js

@@ -0,0 +1,8 @@
+import {
+  registerLcmTools
+} from "../chunk-UWK5OXUJ.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  registerLcmTools
+};
+//# sourceMappingURL=tools.js.map

package/dist/lcm/tools.js.map

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

package/dist/live-connectors-runner.js

@@ -2,12 +2,12 @@ import {
   builtInLiveConnectorDefinitions,
   hasEnabledLiveConnector,
   runLiveConnectorsOnce
-} from "./chunk-XMVFHBHT.js";
-import "./chunk-4IS4SXIQ.js";
-import "./chunk-6TBWYBJ3.js";
+} from "./chunk-U3WSW6PZ.js";
+import "./chunk-HXXBL2KD.js";
+import "./chunk-LPMVBPA3.js";
 import "./chunk-OZHRDTDX.js";
-import "./chunk-IXEJRKCZ.js";
-import "./chunk-MARWOCVP.js";
+import "./chunk-QRNI5JBH.js";
+import "./chunk-XIG5PDM7.js";
 import "./chunk-PZ5AY32C.js";
 export {
   builtInLiveConnectorDefinitions,

package/dist/local-llm.js

@@ -1,8 +1,8 @@
 import {
   LocalLlmClient
-} from "./chunk-HELQZFZO.js";
-import "./chunk-OR64ZGRZ.js";
-import "./chunk-MARWOCVP.js";
+} from "./chunk-EDTHC6UD.js";
+import "./chunk-NNVTUXEB.js";
+import "./chunk-XIG5PDM7.js";
 import "./chunk-2ODBA7MQ.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/maintenance/archive-observations.d.ts

@@ -0,0 +1,18 @@
+interface ArchiveObservationsOptions {
+    memoryDir: string;
+    retentionDays?: number;
+    dryRun?: boolean;
+    now?: Date;
+}
+interface ArchiveObservationsResult {
+    dryRun: boolean;
+    retentionDays: number;
+    scannedFiles: number;
+    archivedFiles: number;
+    archivedBytes: number;
+    archiveRoot: string;
+    archivedRelativePaths: string[];
+}
+declare function archiveObservations(options: ArchiveObservationsOptions): Promise<ArchiveObservationsResult>;
+
+export { type ArchiveObservationsOptions, type ArchiveObservationsResult, archiveObservations };