@theokit/sdk-memory 0.1.0

package/dist/internal/dreaming-run.d.ts

@@ -0,0 +1,49 @@
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+/**
+ * Dreaming sweep orchestrator (ADR D7 of memory-system-openclaw-parity).
+ *
+ * Phases:
+ *   1. **light** — drop near-duplicate facts via cosine similarity.
+ *   2. **REM**  — cluster thematically related facts.
+ *   3. **deep** — write a `notes/dreamed-<ts>.md` per sweep with consolidated
+ *                  clusters; append a diary entry.
+ *
+ * All file writes go through `replaceFileAtomic` (EC-3) and the entire sweep
+ * holds the per-cwd mutex so a `Remember:` append can't race it.
+ *
+ * Iter 60 (Stage 3 source-move #17): hybrid copy from sdk-core's
+ * `internal/memory/dreaming/run.ts`. sdk-core retains its copy for
+ * v1.x dreaming back-compat; sdk-memory ships the canonical
+ * orchestrator that composes all four sibling moves from iter 45
+ * (`EmbeddingRuntime`), iter 54 (`lightPhase`+`remPhase`+`deepPhase`),
+ * iter 56 (`memoryDir`+`readFactsFromMarkdown`), and iter 59
+ * (`appendDiaryEntry`). Persistence sub-path provides
+ * `replaceFileAtomic` + `withCwdMutex`. This closes the dreaming/
+ * cluster — 4 files all in sdk-memory now.
+ *
+ * Flat-naming convention (not `dreaming/run.ts`): sdk-memory's
+ * `internal/` directory stays flat. The `dreaming-` prefix preserves
+ * the topical grouping (companion to iter 54's `dreaming-phases` and
+ * iter 59's `dreaming-diary`).
+ *
+ * @internal
+ */
+export interface DreamingOptions {
+    cwd: string;
+    embedding: EmbeddingRuntime;
+    dedupThreshold?: number;
+    clusterThreshold?: number;
+    /** Test hook — fixed timestamp for the run. */
+    now?: () => number;
+}
+export interface DreamingResult {
+    status: "ok" | "skipped" | "error";
+    factsBefore: number;
+    factsAfter: number;
+    duplicatesRemoved: number;
+    clustersCreated: number;
+    notesWritten: number;
+    diaryEntryHash: string | undefined;
+}
+export declare function runDreamingSweep(options: DreamingOptions): Promise<DreamingResult>;
+//# sourceMappingURL=dreaming-run.d.ts.map

package/dist/internal/dreaming-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dreaming-run.d.ts","sourceRoot":"","sources":["../../src/internal/dreaming-run.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,gBAAgB,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,+CAA+C;IAC/C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAElF"}

package/dist/internal/embedding-adapter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Memory embedding provider adapter contract (ADR D3 of memory-system-openclaw-parity).
+ *
+ * Mirrors OpenClaw's `MemoryEmbeddingProviderAdapter` from
+ * `referencia/openclaw/extensions/openai/memory-embedding-adapter.ts` so
+ * adding a new provider becomes one new file under `adapters/`.
+ *
+ * @internal
+ */
+export interface MemoryEmbeddingProviderAdapter {
+    /** Stable provider id (matches OpenClaw's id catalog: "openai", "mistral", …). */
+    readonly id: string;
+    /** Default model the adapter uses unless the caller overrides via `options.model`. */
+    readonly defaultModel: string;
+    /** Transport kind. Remote = network HTTP; local = in-process / on-device. */
+    readonly transport: "local" | "remote";
+    /** Auth provider id used to resolve API keys (mirrors OpenClaw). */
+    readonly authProviderId?: string;
+    /** Higher priority = auto-select this provider first when multiple are available. */
+    readonly autoSelectPriority?: number;
+    /** Factory — instantiate a per-agent runtime. */
+    create(options: CreateAdapterOptions): Promise<EmbeddingRuntime>;
+}
+export interface CreateAdapterOptions {
+    /** Override the adapter's `defaultModel`. */
+    model?: string;
+    /** Override the API key (else resolved from env). */
+    apiKey?: string;
+    /** Override the HTTP base URL (else provider default). */
+    baseUrl?: string;
+    /** Inject a fetch implementation (tests use this to stub HTTP). */
+    fetch?: typeof fetch;
+    /** Optional cache instance (else a default LRU is created). */
+    cache?: EmbeddingCache;
+}
+export interface EmbeddingRuntime {
+    readonly id: string;
+    readonly model: string;
+    readonly dimension: number;
+    /** Embed N texts → N vectors of length `dimension`. Handles batching internally. */
+    embed(texts: ReadonlyArray<string>): Promise<number[][]>;
+    /** Observability — cache hit/miss + call counts. */
+    stats(): EmbeddingRuntimeStats;
+}
+export interface EmbeddingRuntimeStats {
+    cacheHits: number;
+    cacheMisses: number;
+    httpCalls: number;
+    retries: number;
+}
+export interface EmbeddingCache {
+    get(key: string): number[] | undefined;
+    set(key: string, value: number[]): void;
+    /** Total entries currently held. */
+    size(): number;
+}
+//# sourceMappingURL=embedding-adapter.d.ts.map

package/dist/internal/embedding-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-adapter.d.ts","sourceRoot":"","sources":["../../src/internal/embedding-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,8BAA8B;IAC7C,kFAAkF;IAClF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sFAAsF;IACtF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,QAAQ,CAAC;IACvC,oEAAoE;IACpE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,qFAAqF;IACrF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,iDAAiD;IACjD,MAAM,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oFAAoF;IACpF,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACzD,oDAAoD;IACpD,KAAK,IAAI,qBAAqB,CAAC;CAChC;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IACvC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACxC,oCAAoC;IACpC,IAAI,IAAI,MAAM,CAAC;CAChB"}

package/dist/internal/embedding-cache.d.ts

@@ -0,0 +1,16 @@
+import type { EmbeddingCache } from "./embedding-adapter.js";
+/**
+ * Bounded in-memory LRU cache for embeddings, keyed by `sha256(text)` (or any
+ * stable key the caller chooses).
+ *
+ * @internal
+ */
+export declare class LruEmbeddingCache implements EmbeddingCache {
+    private readonly capacity;
+    private readonly map;
+    constructor(capacity?: number);
+    get(key: string): number[] | undefined;
+    set(key: string, value: number[]): void;
+    size(): number;
+}
+//# sourceMappingURL=embedding-cache.d.ts.map

package/dist/internal/embedding-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-cache.d.ts","sourceRoot":"","sources":["../../src/internal/embedding-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IAG1C,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA+B;gBAEtB,QAAQ,GAAE,MAAa;IAEpD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAStC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAUvC,IAAI,IAAI,MAAM;CAGf"}

package/dist/internal/index-db.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Thin wrapper around the SQLite driver. Prefers `node:sqlite` when available
+ * (Node 22.5+) and falls back to `better-sqlite3`. Both expose nearly the
+ * same `prepare/exec/close` surface; we normalize via a minimal adapter.
+ *
+ * Corrupt-DB recovery (EC-7): when opening fails with a "file is encrypted
+ * or is not a database" or "malformed" error, the file is renamed aside to
+ * `<path>.corrupt-<ts>` and the schema is rebuilt from scratch.
+ *
+ * Iter 65 (Stage 3 source-move #22): hybrid copy from sdk-core's
+ * `internal/memory/index-db.ts`. sdk-core retains its copy for v1.x
+ * sqlite-vec back-compat; sdk-memory ships the canonical copy that
+ * future `sqlite-vec-loader`, `vec-index`, `index-manager` moves
+ * will compose with. Dependency chain (all resolved):
+ * - `@theokit/sdk/errors` for `ConfigurationError` (public)
+ * - `@theokit/sdk/internal/persistence` for `applyWalWithFallback`
+ *   (ADR D63 — NFS/SMB/FUSE-safe WAL adoption)
+ * - sibling `./index-schema.js` for SCHEMA + PRAGMA statements (moved iter 49)
+ *
+ * @internal
+ */
+export interface MemoryDb {
+    exec(sql: string): void;
+    prepare(sql: string): {
+        run(...args: unknown[]): {
+            changes: number;
+            lastInsertRowid: number | bigint;
+        };
+        get(...args: unknown[]): Record<string, unknown> | undefined;
+        all(...args: unknown[]): Array<Record<string, unknown>>;
+    };
+    /** SQLite `pragma()` access (used by `applyWalWithFallback`). */
+    pragma(statement: string, options?: {
+        simple?: boolean;
+    }): unknown;
+    close(): void;
+    /** Load a SQLite loadable extension at the given path (used by sqlite-vec). */
+    loadExtension(path: string): void;
+}
+export interface OpenDbOptions {
+    filePath: string;
+    /**
+     * When true and opening fails with a corruption error, rename the file aside
+     * and create a fresh DB. Default true.
+     */
+    recoverCorrupt?: boolean;
+}
+export declare function openMemoryDb(opts: OpenDbOptions): Promise<MemoryDb>;
+export declare function defaultIndexPath(cwd: string): string;
+//# sourceMappingURL=index-db.d.ts.map

package/dist/internal/index-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-db.d.ts","sourceRoot":"","sources":["../../src/internal/index-db.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,QAAQ;IACvB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG;QACpB,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;QAC/E,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;QAC7D,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACzD,CAAC;IACF,iEAAiE;IACjE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;IACnE,KAAK,IAAI,IAAI,CAAC;IACd,+EAA+E;IAC/E,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWzE;AAqDD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/internal/index-manager-contract.d.ts

@@ -0,0 +1,70 @@
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+/**
+ * Memory index manager contract — leaf types shared by `index-manager.ts`
+ * (orchestrator), `index-manager-dispatch.ts` (backend dispatch), `lance-memory-adapter.ts`
+ * (Lance backend), and `memory-index.ts` (common search-options parsing).
+ *
+ * **T2.1 / Cycles #11 + #12 + #13 of plan `arch-review-fixes-2026-06-06`
+ * (ADR D433):** the previous layout had `index-manager.ts` defining the
+ * contract types AND importing runtime from `index-manager-dispatch.ts`;
+ * `index-manager-dispatch.ts` importing the types back from `index-manager.ts`;
+ * `lance-memory-adapter.ts` and `memory-index.ts` both importing types from
+ * `index-manager.ts`. The result was three HIGH-severity cycles
+ * (Phase 5 cartographer):
+ *
+ *   #11: index-manager.ts ↔ index-manager-dispatch.ts (2-node)
+ *   #12: index-manager.ts → index-manager-dispatch.ts → lance-memory-adapter.ts → index-manager.ts (3-node)
+ *   #13: index-manager.ts → index-manager-dispatch.ts → lance-memory-adapter.ts → memory-index.ts → index-manager.ts (4-node)
+ *
+ * Single ~60 LOC extraction breaks all three: every cluster member now
+ * imports types from this contract; only the orchestrator imports runtime
+ * functions from dispatch (one direction, no cycle).
+ *
+ * **Contract scope:** types only. No runtime code. The single non-cycle
+ * import (`EmbeddingRuntime` from `embedding-adapter.ts`) is itself a leaf
+ * dependency outside the cluster — does not re-introduce a cycle.
+ *
+ * @internal — NOT part of the `@theokit/sdk` public API.
+ */
+export interface MemorySearchHit {
+    /** Path relative to the memory root. */
+    path: string;
+    startLine: number;
+    endLine: number;
+    /** Combined score (hybrid when vector backend active, else just textScore). */
+    score: number;
+    /** FTS5 BM25 score normalized to 0..1 (higher = better). */
+    textScore: number;
+    /** sqlite-vec distance normalized to 0..1 (higher = better). Omitted when vector backend disabled. */
+    vectorScore?: number;
+    snippet: string;
+    source: "memory" | "sessions" | "wiki";
+    /** path:startLine-endLine for citations. */
+    citation: string;
+}
+export interface IndexStatus {
+    backend: "fts-only" | "hybrid";
+    filesIndexed: number;
+    chunksIndexed: number;
+    lastSyncMs?: number;
+}
+export interface SearchOptions {
+    maxResults?: number;
+    minScore?: number;
+    sources?: ReadonlyArray<"memory" | "sessions" | "wiki">;
+    /** 0..1 — vector vs text weight in hybrid scoring (D4). Default 0.6. */
+    vectorWeight?: number;
+    /** 0..1 — text weight in hybrid scoring. Default 0.4. */
+    textWeight?: number;
+}
+/** Vector backend selector. SQLite default; Lance opt-in (ADR D43). */
+export type MemoryBackend = "sqlite-vec" | "lance";
+export interface OpenIndexOptions {
+    cwd: string;
+    filePath?: string;
+    /** When provided, vector index is enabled in hybrid mode. */
+    embedding?: EmbeddingRuntime;
+    /** Vector backend. Default and only value today: `"sqlite-vec"`. */
+    backend?: MemoryBackend;
+}
+//# sourceMappingURL=index-manager-contract.d.ts.map

package/dist/internal/index-manager-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-manager-contract.d.ts","sourceRoot":"","sources":["../../src/internal/index-manager-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,sGAAsG;IACtG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IACvC,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;IACxD,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,uEAAuE;AACvE,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,OAAO,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,oEAAoE;IACpE,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB"}

package/dist/internal/index-manager-dispatch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Dispatch helpers for `IndexManager.open`. Extracted to keep
+ * `index-manager.ts` under the G8 400-LoC budget (lancedb-backend-ship-v1-1).
+ *
+ * Iter 70 (Stage 3 source-move #27): hybrid copy from sdk-core's
+ * `internal/memory/index-manager-dispatch.ts`. sdk-core retains
+ * its copy for v1.x back-compat; sdk-memory ships the canonical
+ * copy that the future `index-manager.ts` move will compose with
+ * as a sibling. Dependency chain (all sibling, all moved):
+ * - `@theokit/sdk/errors` for `ConfigurationError` (public)
+ * - `./index-manager-contract.js` for `MemoryBackend` +
+ *   `OpenIndexOptions` (moved iter 47)
+ * - `./lance-index.js` for `LanceIndex` (moved iter 68)
+ * - `./lance-memory-adapter.js` for `LanceMemoryAdapter` (moved iter 69)
+ * - `./memory-index.js` for `MemoryIndex` (moved iter 50)
+ *
+ * @internal
+ */
+import type { MemoryBackend, OpenIndexOptions } from "./index-manager-contract.js";
+import type { MemoryIndex } from "./memory-index.js";
+/** Valid backend identifiers — runtime guard against TS-narrowing escapes (EC-1). */
+export declare const VALID_BACKENDS: readonly MemoryBackend[];
+/**
+ * EC-1: runtime guard for `opts.backend`. TS union is compile-time only;
+ * consumers passing JS `as any` typos must hit a typed error, not silent
+ * SQLite fallback.
+ */
+export declare function assertValidBackend(backend: string): asserts backend is MemoryBackend;
+/**
+ * Lance-path open. Throws `lance_requires_embedding` when no embedding
+ * runtime is provided (Lance is vector-only — no FTS fallback).
+ * Surfaces `lance_backend_unavailable` from LanceIndex.open when peer
+ * dep is absent.
+ */
+export declare function openLanceIndex(opts: OpenIndexOptions): Promise<MemoryIndex>;
+//# sourceMappingURL=index-manager-dispatch.d.ts.map

package/dist/internal/index-manager-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-manager-dispatch.d.ts","sourceRoot":"","sources":["../../src/internal/index-manager-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAGnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,qFAAqF;AACrF,eAAO,MAAM,cAAc,EAAE,SAAS,aAAa,EAA4B,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,IAAI,aAAa,CAOpF;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC,CAajF"}

package/dist/internal/index-manager.d.ts

@@ -0,0 +1,94 @@
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+import { type MemoryIndex } from "./memory-index.js";
+/**
+ * Memory index manager (ADR D2). FTS5-only at Phase 3; vector index lands in
+ * Phase 5.
+ *
+ * Lifecycle:
+ *   const idx = await IndexManager.open({ cwd });
+ *   await idx.sync();
+ *   const hits = await idx.search("query");
+ *   idx.close();
+ *
+ * Iter 72 (Stage 3 source-move #29): hybrid copy from sdk-core's
+ * `internal/memory/index-manager.ts`. sdk-core retains its copy for
+ * v1.x back-compat; sdk-memory ships the canonical orchestrator
+ * composing every prior Stage 3 move (sqlite-vec stack iter 47/49/50/53/55-57/62/65-67,
+ * lance stack iter 68-70, storage iter 56). The biggest move of the
+ * stage at 446 LOC — closes the index/ cluster.
+ *
+ * @internal
+ */
+interface MemorySearchHit {
+    readonly path: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly score: number;
+    readonly textScore: number;
+    readonly vectorScore?: number;
+    readonly snippet: string;
+    readonly source: "memory" | "sessions" | "wiki";
+    readonly citation: string;
+}
+interface IndexStatus {
+    backend: "fts-only" | "hybrid";
+    filesIndexed: number;
+    chunksIndexed: number;
+    lastSyncMs?: number;
+}
+interface SearchOptions {
+    maxResults?: number;
+    minScore?: number;
+    vectorWeight?: number;
+    textWeight?: number;
+    sources?: ReadonlyArray<"memory" | "sessions" | "wiki">;
+}
+interface OpenIndexOptions {
+    cwd: string;
+    filePath?: string;
+    embedding?: EmbeddingRuntime;
+    backend?: "sqlite-vec" | "lance";
+}
+export declare class IndexManager implements MemoryIndex {
+    private readonly cwd;
+    private readonly db;
+    private readonly embedding;
+    private lastSyncMs;
+    private vectorReady;
+    private constructor();
+    /**
+     * Open a memory index. Dispatches to SQLite (default) or Lance (opt-in
+     * via `backend: "lance"`). See `openLanceIndex` for Lance-specific
+     * preconditions + typed errors.
+     */
+    static open(opts: OpenIndexOptions & {
+        backend: "lance";
+    }): Promise<MemoryIndex>;
+    static open(opts: Omit<OpenIndexOptions, "backend"> | (OpenIndexOptions & {
+        backend?: "sqlite-vec";
+    })): Promise<IndexManager>;
+    /** Internal SQLite-path open. Renamed from previous public `open`. */
+    private static openSqliteInternal;
+    private initVectorBackend;
+    /** Walk the memory corpus + (re)index changed files. */
+    sync(): Promise<{
+        filesScanned: number;
+        filesUpdated: number;
+        chunksWritten: number;
+        chunksEmbedded: number;
+    }>;
+    search(query: string, options?: SearchOptions): Promise<MemorySearchHit[]>;
+    status(): IndexStatus;
+    private ftsSearch;
+    private vectorSearchById;
+    private combineHybridScores;
+    private mergeHits;
+    private fetchChunksByIds;
+    private loadFilesIndex;
+    private upsertFile;
+    private deleteChunksForFile;
+    private insertChunk;
+    close(): void;
+}
+export {};
+//# sourceMappingURL=index-manager.d.ts.map

package/dist/internal/index-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-manager.d.ts","sourceRoot":"","sources":["../../src/internal/index-manager.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,OAAO,EAAE,KAAK,WAAW,EAAsB,MAAM,mBAAmB,CAAC;AAczE;;;;;;;;;;;;;;;;;;GAkBG;AAmBH,UAAU,eAAe;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,aAAa;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;CACzD;AAED,UAAU,gBAAgB;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC;CAClC;AAED,qBAAa,YAAa,YAAW,WAAW;IAK5C,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO;IAMP;;;;OAIG;WACU,IAAI,CAAC,IAAI,EAAE,gBAAgB,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC;WACzE,IAAI,CACf,IAAI,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,GAAG,CAAC,gBAAgB,GAAG;QAAE,OAAO,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC,GACxF,OAAO,CAAC,YAAY,CAAC;IAQxB,sEAAsE;mBACjD,kBAAkB;YAQzB,iBAAiB;IAkB/B,wDAAwD;IAClD,IAAI,IAAI,OAAO,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IAkCI,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAYpF,MAAM,IAAI,WAAW;IAcrB,OAAO,CAAC,SAAS;YA4CH,gBAAgB;IAiB9B,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,gBAAgB;IAkCxB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,WAAW;IAcnB,KAAK,IAAI,IAAI;CAGd"}

package/dist/internal/index-schema.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SQLite schema for the memory index.
+ *
+ * Tables:
+ *   - files      — one row per indexed markdown file (path, mtime, hash).
+ *   - chunks     — one row per chunk produced by `chunkMarkdown`.
+ *   - chunks_fts — FTS5 virtual table mirroring chunks.text for BM25 search.
+ *   - meta       — key/value store; persists the active embedding identity
+ *                  (provider id, model, dimension) so we detect when the
+ *                  index was built against a different embedding setup.
+ *   - embeddings — sqlite-vec virtual table holding the chunk vectors
+ *                  (created on demand by `vec-index.ts`).
+ *
+ * Iter 49 (Stage 3 source-move #6): pure SQL-string leaf copied from
+ * sdk-core's `internal/memory/index-schema.ts`. Hybrid dual-copy per
+ * Phase 2 Stage 1 precedent — sdk-core retains its copy for v1.x
+ * back-compat; sdk-memory ships the canonical copy that future
+ * sqlite/lance index moves (`index-db`, `index-manager`, `vec-index`,
+ * `lance-index`) will target as siblings.
+ *
+ * @internal
+ */
+export declare const SCHEMA_STATEMENTS: ReadonlyArray<string>;
+/**
+ * Non-WAL pragmas. WAL is applied separately via
+ * `applyWalWithFallback` (T4.2, ADR D63) so NFS/SMB users get a graceful
+ * DELETE fallback instead of crashing.
+ */
+/**
+ * v2 migration: adds created_at, importance, scope columns to chunks.
+ * All nullable for backward-compat with existing data (EC-2).
+ */
+export declare const MIGRATION_V2_STATEMENTS: ReadonlyArray<string>;
+export declare const PRAGMA_STATEMENTS: ReadonlyArray<string>;
+//# sourceMappingURL=index-schema.d.ts.map

package/dist/internal/index-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-schema.d.ts","sourceRoot":"","sources":["../../src/internal/index-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAkCnD,CAAC;AAEF;;;;GAIG;AACH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAIzD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAGnD,CAAC"}

package/dist/internal/lance-index.d.ts

@@ -0,0 +1,70 @@
+import type { EmbeddingRuntime } from "./embedding-adapter.js";
+export interface LanceFactRecord {
+    id: string;
+    text: string;
+    source: "memory" | "sessions" | "wiki";
+    embedding: ReadonlyArray<number>;
+    namespace: string;
+    scope: string;
+    user_id: string;
+    timestamp: number;
+}
+export interface OpenLanceOptions {
+    cwd: string;
+    embedding: EmbeddingRuntime;
+    /** Override storage location. Default: `<cwd>/.theokit/memory/lance/`. */
+    storagePath?: string;
+}
+export interface LanceSearchOptions {
+    namespace: string;
+    scope?: string;
+    limit?: number;
+    sources?: ReadonlyArray<"memory" | "sessions" | "wiki">;
+}
+export interface LanceSearchHit {
+    id: string;
+    text: string;
+    source: "memory" | "sessions" | "wiki";
+    namespace: string;
+    scope: string;
+    userId: string;
+    score: number;
+}
+/**
+ * Lance-backed memory index. Public API mirrors the SQLite one logically:
+ * `addFacts`, `search`, `countFacts`, `removeFacts`, `close`.
+ *
+ * @internal
+ */
+export declare class LanceIndex {
+    private readonly table;
+    private readonly embedding;
+    private readonly embeddingDim;
+    private constructor();
+    static open(opts: OpenLanceOptions): Promise<LanceIndex>;
+    addFacts(facts: ReadonlyArray<Omit<LanceFactRecord, "embedding">>): Promise<void>;
+    /**
+     * Search facts by semantic similarity. EC-1: filters use Lance's
+     * SQL string predicate with `'` → `''` escape — bind parameters are
+     * not supported by Lance 0.30.
+     */
+    search(query: string, opts: LanceSearchOptions): Promise<LanceSearchHit[]>;
+    countFacts(namespace: string): Promise<number>;
+    removeFacts(ids: ReadonlyArray<string>): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Test helper for {@link LanceIndex}: indicates whether the Lance module
+ * is loadable in the current environment. Allows tests to gracefully skip
+ * when the optional dep is absent.
+ *
+ * @internal
+ */
+export declare function isLanceAvailable(): boolean;
+/**
+ * Test helper: re-export the storage path computation.
+ *
+ * @internal
+ */
+export declare function lanceStoragePath(cwd: string): string;
+//# sourceMappingURL=lance-index.d.ts.map

package/dist/internal/lance-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lance-index.d.ts","sourceRoot":"","sources":["../../src/internal/lance-index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA+D/D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IACvC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,gBAAgB,CAAC;IAC5B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAoBD;;;;;GAKG;AACH,qBAAa,UAAU;IAEnB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAH/B,OAAO;WAMM,IAAI,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IA2CxD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvF;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IA+B1E,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ9C,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAiCD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAQ1C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/internal/lance-memory-adapter.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `LanceMemoryAdapter` — wraps `LanceIndex` to expose the common
+ * `MemoryIndex` interface (sync/search/status/close) so consumers of
+ * `IndexManager.open({ backend: "lance" })` get a drop-in replacement
+ * for the SQLite-backed `IndexManager`.
+ *
+ * Semantic deltas vs SQLite (documented so callers know what to expect):
+ *
+ *  - `sync()` is a NO-OP. Lance is a pure vector store — there is no
+ *    markdown corpus to crawl. Returns zero counts. Consumers writing
+ *    facts use `LanceIndex.addFacts` directly (exposed via the index
+ *    object returned to advanced callers).
+ *  - `search()` performs vector-only retrieval. `MemorySearchHit.textScore`
+ *    is undefined (no FTS5 layer); `vectorScore === score`.
+ *  - `status()` reports `backend: "hybrid"` only when an embedding runtime
+ *    is wired (always the case for Lance — embedding is required at open).
+ *    `chunksIndexed` reflects total Lance row count; `filesIndexed` is 0
+ *    because Lance does not track file provenance per-row.
+ *
+ * Ships with the lancedb-backend-ship-v1-1 plan (close D12, supersede via
+ * D43). v1.4.0 of `@theokit/sdk`.
+ *
+ * Iter 69 (Stage 3 source-move #26): hybrid copy from sdk-core's
+ * `internal/memory/lance-memory-adapter.ts`. sdk-core retains its
+ * copy for v1.x Lance back-compat; sdk-memory ships the canonical
+ * copy that the future `index-manager-dispatch.ts` move will compose
+ * with as a sibling. Dependency chain (all sibling, all moved):
+ * - `IndexStatus`, `MemorySearchHit`, `SearchOptions` from
+ *   `./index-manager-contract.js` (moved iter 47)
+ * - `LanceIndex` from `./lance-index.js` (moved iter 68)
+ * - `MemoryIndex`, `parseSearchOptions`, `SyncResult` from
+ *   `./memory-index.js` (moved iter 50)
+ *
+ * @internal
+ */
+import type { IndexStatus, MemorySearchHit, SearchOptions } from "./index-manager-contract.js";
+import { type MemoryIndex, type SyncResult } from "./memory-index.js";
+/**
+ * **Iter 69 rollup-plugin-dts workaround** (mirrors iter 48/53/55/66/67 pattern).
+ * Importing `LanceIndex` from sibling `./lance-index.js` fails dts
+ * emit with `"LanceIndex" is not exported by "src/internal/lance-index.ts"`
+ * because rollup-dts treeshakes the class when it has no public
+ * type reaching it transitively — even though the barrel `export *`
+ * makes it publicly callable. Same class as iter 66/67's MemoryDb.
+ *
+ * Fix: inline a structural mirror of the minimal LanceIndex surface
+ * the adapter actually uses (search + close + identity for unwrap()
+ * via `inner === actual LanceIndex`). The mirror is purely a TYPE —
+ * the runtime continues to receive the real LanceIndex instance
+ * unchanged. When a future move surfaces LanceIndex through a
+ * different publicly-reachable path, this mirror MUST be deleted +
+ * the canonical type import restored.
+ *
+ * @internal
+ */
+interface LanceIndex {
+    addFacts(facts: ReadonlyArray<{
+        id: string;
+        text: string;
+        source: "memory" | "sessions" | "wiki";
+        namespace: string;
+        scope: string;
+        user_id: string;
+        timestamp: number;
+    }>): Promise<void>;
+    search(query: string, opts: {
+        namespace: string;
+        scope?: string;
+        limit?: number;
+        sources?: ReadonlyArray<"memory" | "sessions" | "wiki">;
+    }): Promise<ReadonlyArray<{
+        id: string;
+        text: string;
+        source: "memory" | "sessions" | "wiki";
+        namespace: string;
+        scope: string;
+        userId: string;
+        score: number;
+    }>>;
+    countFacts(namespace: string): Promise<number>;
+    removeFacts(ids: ReadonlyArray<string>): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class LanceMemoryAdapter implements MemoryIndex {
+    private readonly inner;
+    constructor(inner: LanceIndex);
+    /**
+     * No-op for Lance — see file header. Returns zero counts so callers'
+     * existing logging (`filesScanned: X`) does not break.
+     */
+    sync(): Promise<SyncResult>;
+    search(query: string, options?: SearchOptions): Promise<MemorySearchHit[]>;
+    status(): IndexStatus;
+    close(): Promise<void>;
+    /**
+     * Escape hatch for advanced callers (migration tool, benchmark script)
+     * that need direct access to addFacts/countFacts/removeFacts.
+     */
+    unwrap(): LanceIndex;
+}
+export {};
+//# sourceMappingURL=lance-memory-adapter.d.ts.map

package/dist/internal/lance-memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lance-memory-adapter.d.ts","sourceRoot":"","sources":["../../src/internal/lance-memory-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC/F,OAAO,EAAE,KAAK,WAAW,EAAsB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE1F;;;;;;;;;;;;;;;;;GAiBG;AACH,UAAU,UAAU;IAClB,QAAQ,CACN,KAAK,EAAE,aAAa,CAAC;QACnB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;QACvC,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,GACD,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CACJ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,aAAa,CAAC,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;KACzD,GACA,OAAO,CACR,aAAa,CAAC;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;QACvC,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CACH,CAAC;IACF,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,WAAW,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAqBD,qBAAa,kBAAmB,YAAW,WAAW;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,UAAU;IAE9C;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC;IAO3B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAepF,MAAM,IAAI,WAAW;IAWf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;;OAGG;IACH,MAAM,IAAI,UAAU;CAGrB"}

package/dist/internal/markdown-store.d.ts

@@ -0,0 +1,17 @@
+import { type MemoryConfig, type MemoryFact } from "./memory-types.js";
+export declare function memoryDir(cwd: string): string;
+export declare function memoryMdPath(cwd: string): string;
+export declare function notesDir(cwd: string): string;
+/** Read facts from `MEMORY.md`'s `## Facts` section. Returns `[]` when missing. */
+export declare function readFactsFromMarkdown(cwd: string): Promise<MemoryFact[]>;
+/** Append a fact to `MEMORY.md ## Facts`. Creates the section if missing. Atomic + serialized. */
+export declare function appendFactToMarkdown(cwd: string, fact: MemoryFact): Promise<void>;
+export interface NoteFile {
+    slug: string;
+    path: string;
+}
+export declare function listNotes(cwd: string): Promise<NoteFile[]>;
+/** Configuration-aware accessors honoring the existing MemoryConfig contract. */
+export declare function readFacts(cwd: string, config: MemoryConfig): Promise<MemoryFact[]>;
+export declare function appendFact(cwd: string, config: MemoryConfig, fact: MemoryFact): Promise<void>;
+//# sourceMappingURL=markdown-store.d.ts.map