@theokit/sdk-memory 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-store.d.ts","sourceRoot":"","sources":["../../src/internal/markdown-store.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAiB,MAAM,mBAAmB,CAAC;AAqCtF,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,mFAAmF;AACnF,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAQ9E;AAED,kGAAkG;AAClG,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAcjF;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAUhE;AAsCD,iFAAiF;AACjF,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAGxF;AAED,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,IAAI,CAAC,CAGf"}

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

@@ -0,0 +1,68 @@
+/**
+ * Common `MemoryIndex` interface shared between the SQLite-backed
+ * `IndexManager` (default) and the Lance-backed adapter (ADR D43, shipped
+ * v1.4.0 via lancedb-backend-ship-v1-1 plan).
+ *
+ * Consumers (`local-agent-memory.ts`, `active-memory.ts`, `tools.ts`,
+ * `runActiveMemory`) only ever call `sync()`, `search()`, `status()`,
+ * `close()` — the union of those four methods is the portable surface.
+ *
+ * Why a separate file (vs declaring inline in `index-manager.ts`)? D43
+ * promised "extrair interface abstrata `MemoryIndex` em
+ * `internal/memory/index-interface.ts`". Keeping the contract physically
+ * separated from one of its implementations preserves OCP — future
+ * backends (Qdrant, PGVector) can land without touching IndexManager.
+ *
+ * Iter 50 (Stage 3 source-move #7): hybrid copy from sdk-core's
+ * `internal/memory/memory-index.ts`. sdk-core retains its copy for v1.x
+ * back-compat; sdk-memory ships the canonical copy that future
+ * `index-manager`, `lance-memory-adapter`, and `active-memory` moves
+ * will target as siblings.
+ *
+ * **Iter 50 side-effect:** by publicly re-exporting `MemorySearchHit`
+ * via the sdk-memory barrel, this file creates the FIRST reachable
+ * downstream consumer for `MemorySearchHit` inside sdk-memory's
+ * graph. That unblocks the rollup-plugin-dts treeshake limitation
+ * the iter 48 inline-duplicate workaround was guarding against —
+ * `internal/active-memory-types.ts` can now re-import the canonical
+ * `MemorySearchHit` from `./index-manager-contract.js` and drop its
+ * inline mirror. Deletion of that workaround lands in this same iter.
+ *
+ * @internal
+ */
+import type { IndexStatus, MemorySearchHit, SearchOptions } from "./index-manager-contract.js";
+export interface SyncResult {
+    filesScanned: number;
+    filesUpdated: number;
+    chunksWritten: number;
+    chunksEmbedded: number;
+}
+/**
+ * Common search-options parser used by both `IndexManager.search` and
+ * `LanceMemoryAdapter.search`. Returns the normalized cap + minimum-score
+ * floor — eliminates jscpd duplication while keeping per-backend search
+ * logic distinct.
+ */
+export declare function parseSearchOptions(options?: SearchOptions): {
+    maxResults: number;
+    minScore: number;
+};
+export interface MemoryIndex {
+    /**
+     * Walk the memory corpus + reindex changed files. Lance backend has no
+     * markdown corpus to walk — its adapter returns zero counts (no-op) and
+     * relies on explicit `addFact` calls instead.
+     */
+    sync(): Promise<SyncResult>;
+    /**
+     * Semantic + textual search over the indexed corpus. Both backends
+     * return the same `MemorySearchHit[]` shape; Lance leaves `textScore`
+     * undefined (vector-only — no FTS5 layer).
+     */
+    search(query: string, options?: SearchOptions): Promise<MemorySearchHit[]>;
+    /** Snapshot of the index health (backend type + counts). */
+    status(): IndexStatus;
+    /** Release native handles. Idempotent. */
+    close(): Promise<void> | void;
+}
+//# sourceMappingURL=memory-index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-index.d.ts","sourceRoot":"","sources":["../../src/internal/memory-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAW/F,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,aAAkB,GAAG;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAKA;AAED,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAE5B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAE3E,4DAA4D;IAC5D,MAAM,IAAI,WAAW,CAAC;IAEtB,0CAA0C;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC/B"}

package/dist/internal/memory-scope.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hierarchical memory scopes — path-based isolation for multi-agent setups.
+ *
+ * Inspired by CrewAI's `MemoryScope` with path hierarchy.
+ * Per ADR D4: scope stored as TEXT column, prefix-matched via LIKE.
+ *
+ * @internal
+ */
+export declare function normalizeScopePath(path: string): string;
+interface ScopeSearchOptions {
+    scopePrefix?: string;
+}
+export declare class MemoryScope {
+    private readonly rootPath;
+    constructor(rootPath: string);
+    get path(): string;
+    child(subPath: string): MemoryScope;
+    toSearchOptions(): ScopeSearchOptions;
+}
+export {};
+//# sourceMappingURL=memory-scope.d.ts.map

package/dist/internal/memory-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-scope.d.ts","sourceRoot":"","sources":["../../src/internal/memory-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,UAAU,kBAAkB;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,EAAE,MAAM;IAI5B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW;IAKnC,eAAe,IAAI,kBAAkB;CAGtC"}

package/dist/internal/memory-types.d.ts

@@ -0,0 +1,95 @@
+export interface MemoryConfig {
+    enabled: boolean;
+    namespace?: string;
+    userId?: string;
+    scope?: "agent" | "user" | "team";
+    storePath?: string;
+}
+export interface MemoryFact {
+    text: string;
+}
+/**
+ * Canonical credential-redaction primitive (ADR D68).
+ *
+ * sdk-core's copy re-exports `redactSecrets` directly from
+ * `../security/index.js` (internal path). sdk-core's PUBLIC surface
+ * (`@theokit/sdk`) doesn't expose a bare `redactSecrets` symbol —
+ * it ships `Security.redact()` instead (T2.1, by design — the
+ * namespace also carries `Security.addPattern()`). sdk-memory's
+ * canonical `redactSecrets` re-export wraps `Security.redact` 1-to-1
+ * so consumers continue to see the same symbol name without sdk-memory
+ * having to import sdk-core's internal subpath. Same 12-pattern
+ * list, same two-bucket mask shape, same disable-via-env behavior.
+ */
+export declare function redactSecrets(text: unknown, opts?: {
+    codeFile?: boolean;
+}): string;
+/**
+ * Resolve the legacy JSON memory path used pre-ADR-D8 (kept for migration
+ * helpers + tests). Centralized here so `migration.ts` and the legacy-aware
+ * `runtime/memory-store.ts` don't duplicate the path logic (jscpd cleanup).
+ */
+export declare function legacyMemoryJsonPath(cwd: string, config: MemoryConfig): string;
+/**
+ * A semantically meaningful slice of a markdown memory file, produced by
+ * `chunkMarkdown`. Each chunk carries stable line numbers + a content hash
+ * used downstream by the embedding cache.
+ *
+ * Mirrors OpenClaw's `MemoryChunk` shape
+ * (`referencia/openclaw/packages/memory-host-sdk/src/host/engine-storage.ts`).
+ *
+ * @internal
+ */
+export interface MemoryChunk {
+    /** 1-indexed starting line in the source file. */
+    startLine: number;
+    /** 1-indexed ending line (inclusive). */
+    endLine: number;
+    /** Slice of markdown source text. */
+    text: string;
+    /** sha256 of `text`; stable across runs for identical inputs. */
+    hash: string;
+    /** Optional nearest heading text (without the `#` markers). */
+    heading?: string;
+}
+/**
+ * Result of `reader.readFile`. Contains the bounded slice plus truncation
+ * + provenance info.
+ *
+ * Mirrors OpenClaw's `MemoryReadResult` shape.
+ *
+ * @internal
+ */
+export interface MemoryReadResult {
+    path: string;
+    /** Requested starting line (1-indexed, defaults to 1). */
+    from: number;
+    /** Number of lines actually returned (may be less than `lines` near EOF). */
+    linesReturned: number;
+    /** Total lines in the file (after the read). */
+    totalLines: number;
+    /** True when fewer lines were returned than the requested `lines` AND EOF was hit. */
+    truncated: boolean;
+    /** Lines past the returned slice that remain in the file. */
+    remainingLines: number;
+    /** Slice text (joined with `\n`). */
+    text: string;
+}
+/**
+ * Lightweight reference to a markdown file in the memory corpus.
+ *
+ * Mirrors OpenClaw's `MemoryFileEntry`.
+ *
+ * @internal
+ */
+export interface MemoryFileEntry {
+    /** Absolute path on disk. */
+    path: string;
+    /** Path relative to the memory root (e.g. "MEMORY.md", "notes/foo.md"). */
+    relPath: string;
+    /** ms-since-epoch mtime. */
+    mtime: number;
+    /** sha256 of the file content; recomputed on each read. */
+    hash: string;
+}
+//# sourceMappingURL=memory-types.d.ts.map

package/dist/internal/memory-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-types.d.ts","sourceRoot":"","sources":["../../src/internal/memory-types.ts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAElF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAY9E;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,SAAS,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/internal/migrate-sqlite-to-lance.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Migrate Memory.index from SQLite to LanceDB (ADR D44).
+ *
+ * EC-3 MUST FIX: validation uses NFC unicode normalization on both sides.
+ *
+ * Iter 71 (Stage 3 source-move #28): hybrid copy from sdk-core's
+ * `internal/memory/migrate-sqlite-to-lance.ts`. sdk-core retains its
+ * copy for v1.x migration back-compat; sdk-memory ships the canonical
+ * copy.
+ *
+ * Dependency chain (all resolved):
+ * - `@theokit/sdk/errors` for `ConfigurationError` (public)
+ * - sibling `./memory-types.js` for `redactSecrets` (moved iter 52)
+ * - sibling `./index-db.js` for `defaultIndexPath` + `openMemoryDb` (moved iter 65)
+ * - sibling `./lance-index.js` for `LanceIndex` + `lanceStoragePath` (moved iter 68)
+ *
+ * @internal
+ */
+export interface MigrateOptions {
+    cwd: string;
+    dryRun?: boolean;
+    batchSize?: number;
+    /** Inject for tests; defaults to console.log. */
+    logger?: (msg: string) => void;
+}
+export interface MigrateResult {
+    countSqlite: number;
+    countLance: number;
+    /** Set when validation succeeded (or dryRun); false on validation failure. */
+    validated: boolean;
+    /** Per-fact compare results (size = sample count, up to 10). */
+    sampleComparisons: ReadonlyArray<{
+        id: string;
+        match: boolean;
+    }>;
+    /** Lance storage location (final, after migration). */
+    lancePath: string;
+    /** Was the migration committed (false for dry-run). */
+    committed: boolean;
+}
+/**
+ * Run the migration. Writes Lance to `<cwd>/.theokit/memory/lance-new/`
+ * first, validates round-trip, then renames to `lance/` on success.
+ * SQLite db is preserved (CLI prompts user to delete).
+ *
+ * @internal
+ */
+export declare function migrateSqliteToLance(opts: MigrateOptions): Promise<MigrateResult>;
+//# sourceMappingURL=migrate-sqlite-to-lance.d.ts.map

package/dist/internal/migrate-sqlite-to-lance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-sqlite-to-lance.d.ts","sourceRoot":"","sources":["../../src/internal/migrate-sqlite-to-lance.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;IACnB,gEAAgE;IAChE,iBAAiB,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACjE,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;CACpB;AA0DD;;;;;;GAMG;AAEH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAmJvF"}

package/dist/internal/migration.d.ts

@@ -0,0 +1,10 @@
+import { type MemoryConfig } from "./memory-types.js";
+export interface MigrationResult {
+    migrated: boolean;
+    factCount: number;
+    reason?: "already-migrated" | "no-legacy-json" | "markdown-exists" | "readonly-fs";
+}
+export declare function migrateLegacyJson(cwd: string, config: MemoryConfig): Promise<MigrationResult>;
+/** Test-only — reset the in-process migration flag map. */
+export declare function resetMigrationStateForTests(): void;
+//# sourceMappingURL=migration.d.ts.map

package/dist/internal/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../src/internal/migration.ts"],"names":[],"mappings":"AAGA,OAAO,EAAwB,KAAK,YAAY,EAAmB,MAAM,mBAAmB,CAAC;AAoE7F,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,aAAa,CAAC;CACpF;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,eAAe,CAAC,CAmB1B;AAED,2DAA2D;AAC3D,wBAAgB,2BAA2B,IAAI,IAAI,CAElD"}

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

@@ -0,0 +1,23 @@
+import { createOpenAiCompatibleRuntime } from "./openai-compatible.js";
+/**
+ * Mistral embedding adapter — OpenAI-compatible REST surface
+ * (`POST /v1/embeddings` against `https://api.mistral.ai`). Default model
+ * `mistral-embed` (1024 dims).
+ *
+ * Mirrors `referencia/openclaw/extensions/mistral/memory-embedding-adapter.ts`.
+ *
+ * Iter 74 (Stage 3 source-move #32): hybrid copy from sdk-core's
+ * `internal/memory/adapters/mistral-embedding.ts`.
+ *
+ * @internal
+ */
+export declare const DEFAULT_MISTRAL_EMBEDDING_MODEL = "mistral-embed";
+export declare const mistralMemoryEmbeddingProviderAdapter: {
+    id: string;
+    defaultModel: string;
+    transport: "remote";
+    authProviderId: string;
+    autoSelectPriority: number;
+    create: (options: Parameters<typeof createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+};
+//# sourceMappingURL=mistral-embedding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mistral-embedding.d.ts","sourceRoot":"","sources":["../../src/internal/mistral-embedding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAIvE;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,+BAA+B,kBAAkB,CAAC;AAM/D,eAAO,MAAM,qCAAqC;;;;;;sBAM9B,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;CAYtE,CAAC"}

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

@@ -0,0 +1,48 @@
+/**
+ * Ollama embedding adapter (T3.1, ADR D183).
+ *
+ * Targets Ollama's OpenAI-compatible `/v1/embeddings` endpoint and reuses
+ * the shared `createOpenAiCompatibleRuntime` factory. The differentiating
+ * bits:
+ *
+ *  - `authType: "none"` — Ollama local ignores `Authorization`. Sentinel
+ *    `"ollama-local"` is passed as apiKey to satisfy the factory contract
+ *    (mirrors OpenClaw `OLLAMA_DEFAULT_API_KEY = "ollama-local"`).
+ *  - `OLLAMA_HOST` overrides the default `http://localhost:11434`.
+ *  - `OLLAMA_API_KEY` (optional) overrides the sentinel for Ollama Cloud
+ *    or reverse-proxy auth setups.
+ *  - Default model: `nomic-embed-text` (768 dim, ~274MB). User can opt
+ *    into `all-minilm` (384 dim, ~45MB) or any other locally-installed
+ *    embedding model.
+ *
+ * EC-B MUST FIX (edge-case review 2026-05-21): empty text is rejected
+ * upstream in the shared factory (`classifyEntry` short-circuits to a
+ * zero vector). That behavior is acceptable here because the zero
+ * vector is identical for any empty input — downstream similarity
+ * calcs ignore zero-norm vectors via the existing `cosineSimilarity`
+ * guard. No additional fail-fast needed.
+ *
+ * EC-A MUST FIX (edge-case review 2026-05-21): dimension is locked
+ * by the `DIMENSION_BY_MODEL` table; an unknown model id throws
+ * `ConfigurationError(code: "embedding_unknown_model")` per the
+ * factory's EC-4 contract. Future model versions with different
+ * dimensions are added to the table here without breaking changes.
+ *
+ * Iter 74 (Stage 3 source-move #36): hybrid copy from sdk-core's
+ * `internal/memory/adapters/ollama-embedding.ts`. The only
+ * `transport: "local"` adapter in the cluster — enables 100%-local
+ * RAG with no remote API key.
+ *
+ * @internal
+ */
+import { createOpenAiCompatibleRuntime } from "./openai-compatible.js";
+export declare const DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
+export declare const ollamaMemoryEmbeddingProviderAdapter: {
+    id: string;
+    defaultModel: string;
+    transport: "local";
+    authProviderId: string;
+    autoSelectPriority: number;
+    create: (options: Parameters<typeof createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+};
+//# sourceMappingURL=ollama-embedding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-embedding.d.ts","sourceRoot":"","sources":["../../src/internal/ollama-embedding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAIvE,eAAO,MAAM,8BAA8B,qBAAqB,CAAC;AAsBjE,eAAO,MAAM,oCAAoC;;;;;;sBAQ7B,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;CAiBtE,CAAC"}

package/dist/internal/openai-compatible.d.ts

@@ -0,0 +1,24 @@
+import type { CreateAdapterOptions, EmbeddingRuntime } from "./embedding-adapter.js";
+export interface OpenAiCompatibleConfig {
+    id: string;
+    defaultBaseUrl: string;
+    apiKeyEnv: string;
+    baseUrlEnv?: string;
+    defaultModel: string;
+    /**
+     * Dimension hint by model id. The chosen model MUST be in this table —
+     * unknown models throw `ConfigurationError(code: "embedding_unknown_model")`
+     * (EC-4 fix). This prevents vec0 virtual-table dimension mismatches that
+     * surface as cryptic errors downstream.
+     */
+    dimensionByModel: Record<string, number>;
+    /**
+     * Path component appended to `baseUrl` for the embeddings endpoint.
+     * Default `"/v1/embeddings"` (OpenAI canonical). REPLACES the default —
+     * does NOT concatenate. Used by DeepInfra (`"/v1/openai/embeddings"`),
+     * etc. (EC-2 fix).
+     */
+    embeddingsPath?: string;
+}
+export declare function createOpenAiCompatibleRuntime(cfg: OpenAiCompatibleConfig, options: CreateAdapterOptions): Promise<EmbeddingRuntime>;
+//# sourceMappingURL=openai-compatible.d.ts.map

package/dist/internal/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../src/internal/openai-compatible.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAmChC,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAgD3B"}

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

@@ -0,0 +1,34 @@
+import { createOpenAiCompatibleRuntime } from "./openai-compatible.js";
+/**
+ * **Iter 74 rollup-plugin-dts workaround:** importing
+ * `MemoryEmbeddingProviderAdapter` from sibling `./embedding-adapter.js`
+ * fails dts emit because no public type reaches it transitively yet
+ * (same iter 48/53/55/66/67/69/72 class). Fix: drop the explicit
+ * type annotation on the exported adapter; TS infers the structural
+ * shape from the literal, and the catalog (iter 37 / this same iter)
+ * pin assignability against the canonical interface via its own
+ * `Record<string, MemoryEmbeddingProviderAdapter>` constraint.
+ *
+ * @internal
+ */
+/**
+ * OpenAI embedding adapter (ADR D3) — built on the shared OpenAI-compatible
+ * factory. Native fetch only.
+ *
+ * Iter 74 (Stage 3 source-move #31): hybrid copy from sdk-core's
+ * `internal/memory/adapters/openai-embedding.ts`. Composes iter 45's
+ * `MemoryEmbeddingProviderAdapter` + iter 73's
+ * `createOpenAiCompatibleRuntime`.
+ *
+ * @internal
+ */
+export declare const DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
+export declare const openAiMemoryEmbeddingProviderAdapter: {
+    id: string;
+    defaultModel: string;
+    transport: "remote";
+    authProviderId: string;
+    autoSelectPriority: number;
+    create: (options: Parameters<typeof createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+};
+//# sourceMappingURL=openai-embedding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai-embedding.d.ts","sourceRoot":"","sources":["../../src/internal/openai-embedding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAEvE;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,8BAA8B,2BAA2B,CAAC;AAQvE,eAAO,MAAM,oCAAoC;;;;;;sBAM7B,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;CAYtE,CAAC"}

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

@@ -0,0 +1,25 @@
+import { createOpenAiCompatibleRuntime } from "./openai-compatible.js";
+/**
+ * OpenRouter embedding adapter — routes through OpenRouter's
+ * `POST /api/v1/embeddings` endpoint (OpenAI-compatible request/response
+ * shape). The provider id strings follow OpenRouter's catalog
+ * (e.g. `"openai/text-embedding-3-small"`, `"mistralai/mistral-embed"`).
+ *
+ * Honors `OPENROUTER_API_KEY` and `OPENROUTER_API_BASE_URL`. Default base
+ * URL is `https://openrouter.ai/api`.
+ *
+ * Iter 74 (Stage 3 source-move #35): hybrid copy from sdk-core's
+ * `internal/memory/adapters/openrouter-embedding.ts`.
+ *
+ * @internal
+ */
+export declare const DEFAULT_OPENROUTER_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+export declare const openRouterMemoryEmbeddingProviderAdapter: {
+    id: string;
+    defaultModel: string;
+    transport: "remote";
+    authProviderId: string;
+    autoSelectPriority: number;
+    create: (options: Parameters<typeof createOpenAiCompatibleRuntime>[1]) => Promise<import("./embedding-adapter.js").EmbeddingRuntime>;
+};
+//# sourceMappingURL=openrouter-embedding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter-embedding.d.ts","sourceRoot":"","sources":["../../src/internal/openrouter-embedding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAIvE;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,kCAAkC,kCAAkC,CAAC;AASlF,eAAO,MAAM,wCAAwC;;;;;;sBAMjC,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;CAYtE,CAAC"}

package/dist/internal/query-analyzer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Query analyzer — LLM-driven sub-query distillation for complex queries.
+ *
+ * Inspired by CrewAI's `recall_flow.py`. Opt-in: short queries (≤250 chars)
+ * pass through unchanged. Per ADR D3.
+ *
+ * @internal
+ */
+interface QueryAnalysisResult {
+    subQueries: string[];
+    timeFilter?: number;
+    scopeHint?: string;
+}
+export declare function analyzeQuery(query: string, callLlm: (system: string, user: string) => Promise<string>): Promise<QueryAnalysisResult>;
+export {};
+//# sourceMappingURL=query-analyzer.d.ts.map

package/dist/internal/query-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-analyzer.d.ts","sourceRoot":"","sources":["../../src/internal/query-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,UAAU,mBAAmB;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GACzD,OAAO,CAAC,mBAAmB,CAAC,CAmB9B"}

package/dist/internal/reader.d.ts

@@ -0,0 +1,64 @@
+/**
+ * **Iter 55 rollup-plugin-dts workaround** (mirrors iter 48/53 pattern).
+ * The canonical sdk-core copy imports `MemoryReadResult` from
+ * `../types.js`. In sdk-memory the same type lives in sibling
+ * `./memory-types.js` (moved iter 52) but rollup-dts treeshakes it
+ * out of the dist .d.ts because no PUBLIC type reaches it
+ * transitively yet — `readMemoryFileBounded`'s return type would be
+ * the consumer BUT rollup-dts processes the import resolution before
+ * reader.ts itself becomes bundled into the public emit. Same class
+ * of bug as iter 48 (MemorySearchHit) + iter 53 (MemoryChunk).
+ *
+ * Fix: declare a byte-identical mirror of MemoryReadResult inline.
+ * When a future move (e.g. tools.ts wrapping readMemoryFileBounded
+ * as a public LLM tool, or IndexManager surface emitting these)
+ * gives MemoryReadResult a different publicly-reachable path, this
+ * mirror MUST be deleted + the canonical import restored to maintain
+ * single source of truth.
+ *
+ * @internal
+ */
+interface MemoryReadResult {
+    path: string;
+    /** Requested starting line (1-indexed, defaults to 1). */
+    from: number;
+    /** Number of lines actually returned (may be less than `lines` near EOF). */
+    linesReturned: number;
+    /** Total lines in the file (after the read). */
+    totalLines: number;
+    /** True when fewer lines were returned than the requested `lines` AND EOF was hit. */
+    truncated: boolean;
+    /** Lines past the returned slice that remain in the file. */
+    remainingLines: number;
+    /** Slice text (joined with `\n`). */
+    text: string;
+}
+/**
+ * Bounded read with truncation info (ADR D5 — `memory_get` foundation).
+ *
+ * Mirrors OpenClaw's `buildMemoryReadResult` semantics:
+ * - `from` is 1-indexed.
+ * - `lines` defaults to 200 (`DEFAULT_MEMORY_READ_LINES`).
+ * - Returns up to EOF when the requested slice extends past file end.
+ * - Sets `truncated: true` when fewer lines were returned than requested AND
+ *   there's still content past the slice. (At EOF, `truncated: false`.)
+ *
+ * Iter 55 (Stage 3 source-move #12): hybrid copy from sdk-core's
+ * `internal/memory/storage/reader.ts`. sdk-core retains its copy for
+ * v1.x `memory_get` back-compat; sdk-memory ships the canonical copy
+ * that future `tools.ts` move (memory_get LLM tool wraps this) will
+ * target as a sibling. `MemoryReadResult` comes from sibling
+ * `./memory-types.js` (moved iter 52).
+ *
+ * @internal
+ */
+export declare const DEFAULT_MEMORY_READ_LINES = 200;
+export interface ReadFileOptions {
+    cwd: string;
+    relPath: string;
+    from?: number;
+    lines?: number;
+}
+export declare function readMemoryFileBounded(opts: ReadFileOptions): Promise<MemoryReadResult>;
+export {};
+//# sourceMappingURL=reader.d.ts.map

package/dist/internal/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../src/internal/reader.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,SAAS,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6B5F"}

package/dist/internal/session-loader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Session summary discovery (ADR D20).
+ *
+ * Mirrors `wiki-loader.ts:discoverWikiFiles`: scans
+ * `.theokit/memory/sessions/*.md` and returns `MemoryFileEntry`-shaped
+ * records. IndexManager tags each chunk with `source="sessions"` so
+ * `memory_search({ corpus: "sessions" })` filters them in.
+ *
+ * Iter 62 (Stage 3 source-move #19): hybrid copy from sdk-core's
+ * `internal/memory/storage/session-loader.ts`. sdk-core retains its
+ * copy for v1.x sessions back-compat; sdk-memory ships the canonical
+ * copy. **Closes the sessions/ cluster in sdk-memory** — session
+ * summary writer (iter 61) + session-loader (this iter) are both
+ * canonical. Dependencies (sibling, both moved):
+ * - `memoryDir` from `./markdown-store.js` (moved iter 56)
+ * - `sessionsDir` from `./session-summary-writer.js` (moved iter 61)
+ *
+ * @internal
+ */
+export interface SessionFile {
+    absolutePath: string;
+    relPath: string;
+}
+export declare function discoverSessionFiles(cwd: string): Promise<SessionFile[]>;
+//# sourceMappingURL=session-loader.d.ts.map

package/dist/internal/session-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-loader.d.ts","sourceRoot":"","sources":["../../src/internal/session-loader.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAiB9E"}

package/dist/internal/session-summary-writer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Per-run session summary writer (ADR D20).
+ *
+ * After every finished run, write a markdown summary to
+ * `.theokit/memory/sessions/<runId>.md`. IndexManager picks these up with
+ * `source="sessions"` so `memory_search({ corpus: "sessions" })` can recall
+ * past conversations.
+ *
+ * EC-9: only `status === "finished"` runs trigger a write. Cancelled/errored
+ * runs would otherwise pollute the recall corpus with partial transcripts.
+ *
+ * Iter 61 (Stage 3 source-move #18): hybrid copy from sdk-core's
+ * `internal/memory/storage/session-summary-writer.ts`. sdk-core
+ * retains its copy for v1.x sessions back-compat; sdk-memory ships
+ * the canonical copy that the future `session-loader.ts` move will
+ * compose with as a sibling (loader reads back the markdown files
+ * this writer emits). Dependency chain (all resolved):
+ * - `@theokit/sdk/internal/persistence` for `replaceFileAtomic`
+ * - sibling `./markdown-store.js` for `memoryDir` (moved iter 56)
+ * - sibling `./memory-types.js` for `redactSecrets` (moved iter 52)
+ *
+ * @internal
+ */
+export interface SessionSummaryInput {
+    cwd: string;
+    runId: string;
+    agentId: string;
+    userText: string;
+    assistantText: string;
+    status: "finished" | "running" | "error" | "cancelled";
+    at: number;
+}
+export declare function sessionsDir(cwd: string): string;
+export declare function sessionSummaryPath(cwd: string, runId: string): string;
+/**
+ * Write a session summary file. EC-9: a non-finished status returns early
+ * without touching disk. Secrets in both user and assistant text are
+ * redacted via the shared `redactSecrets` pattern.
+ *
+ * @internal
+ */
+export declare function writeSessionSummary(input: SessionSummaryInput): Promise<void>;
+//# sourceMappingURL=session-summary-writer.d.ts.map

package/dist/internal/session-summary-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-summary-writer.d.ts","sourceRoot":"","sources":["../../src/internal/session-summary-writer.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAAC;IACvD,EAAE,EAAE,MAAM,CAAC;CACZ;AAID,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErE;AAaD;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4BnF"}