@theokit/sdk 1.5.0

package/dist/internal/task/telemetry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OTel telemetry for the Task registry (ADR D371).
+ *
+ * Spans:
+ *   - `task.submit` — short-lived span around the submit + insert.
+ *   - `task.transition` — per state transition (attrs: from / to).
+ *   - `task.cancel` — invoked from `Task.cancel` or via cancelRequested honor.
+ *
+ * Uses the existing tracer seam (D34); when OTel is absent, every helper
+ * returns the shared no-op span. No new peer deps.
+ *
+ * @internal
+ */
+export declare function startTaskSubmitSpan(info: {
+    taskId: string;
+    kind: string;
+}): SpanLike;
+export declare function startTaskTransitionSpan(info: {
+    taskId: string;
+    from: string;
+    to: string;
+}): SpanLike;
+export declare function startTaskCancelSpan(info: {
+    taskId: string;
+    reason?: string;
+    via: "api" | "cancelRequested";
+}): SpanLike;

package/dist/internal/telemetry/adapter-registry.d.ts

@@ -0,0 +1,2 @@
+import type { TelemetryAdapter } from "./safe-require.js";
+export type { TelemetryAdapter };

package/dist/internal/telemetry/adapters/langfuse.d.ts

@@ -0,0 +1,2 @@
+import { type TelemetryAdapter } from "../safe-require.js";
+export declare const langfuseAdapter: TelemetryAdapter;

package/dist/internal/telemetry/adapters/posthog.d.ts

@@ -0,0 +1,2 @@
+import { type TelemetryAdapter } from "../safe-require.js";
+export declare const posthogAdapter: TelemetryAdapter;

package/dist/internal/telemetry/adapters/sentry.d.ts

@@ -0,0 +1,2 @@
+import { type TelemetryAdapter } from "../safe-require.js";
+export declare const sentryAdapter: TelemetryAdapter;

package/dist/internal/telemetry/safe-require.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/telemetry/tracer.d.ts

@@ -0,0 +1,18 @@
+export interface OTelSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setAttributes(attrs: Record<string, string | number | boolean | undefined>): void;
+    addEvent(name: string, attrs?: Record<string, string | number | boolean>): void;
+    setStatus(status: {
+        code: number;
+        message?: string;
+    }): void;
+    recordException(err: unknown): void;
+    end(endTime?: number): void;
+    spanContext(): {
+        traceId: string;
+        spanId: string;
+    };
+    isRecording(): boolean;
+}
+/** Exported for tests — resets the OTel cache and the warning-once latch. */
+export declare function _resetTelemetryCacheForTests(): void;

package/dist/internal/tool-dispatch/repair-middleware.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tool-call repair middleware (T1.1, ADR D87).
+ *
+ * Applies 3 idempotent repairs sequentially before tool dispatch:
+ *   1. Case-insensitive name match (ADR D88 — no fuzzy match)
+ *   2. JSON-string args → object parse
+ *   3. Type coercion against JSON Schema (string → number/integer/boolean/object)
+ *
+ * Fixes 10+ provider-specific failure modes catalogued in
+ * `.claude/knowledge-base/sdk-references/tool-call-failure-recovery.md`:
+ * Hermes v0.2 #444 (DeepSeek JSON), v0.3 #1300 (parallel calls),
+ * v0.8 #5265 (type coerce), and similar.
+ *
+ * NOTE on coerce limits (EC-9): regex `^-?\d+(\.\d+)?$` accepts decimal
+ * notation only — scientific (`1e5`), hex (`0xFF`), and `Infinity` are
+ * preserved as strings and rejected by downstream schema validation. KISS:
+ * 99% of provider-emitted tool args use plain decimal.
+ *
+ * @internal
+ */
+export interface RepairableTool {
+    name: string;
+    /** JSON Schema for the tool's input. `properties` map drives coercion. */
+    inputSchema: Record<string, unknown>;
+}
+export interface RepairResult {
+    call: ToolCall;
+    /** Human-readable log of repairs applied (empty when no-op). */
+    repairs: string[];
+}
+export interface CoerceResult {
+    value: Record<string, unknown>;
+    changed: string[];
+}

package/dist/internal/tool-dispatch/strip-think.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Strip `<think>...</think>` chain-of-thought blocks (T1.2, ADR D96).
+ *
+ * DeepSeek-R1, Qwen-QwQ, and similar reasoning models emit visible
+ * `<think>` blocks in the `content` field. Without stripping, they enter
+ * the message history; each turn accumulates 5k+ thinking tokens, and
+ * prompt caching invalidates every turn (Hermes v0.2 #174, ~10x cost
+ * regression).
+ *
+ * NOTE on `<think>` in legitimate prose (EC-10): a user/assistant message
+ * that deliberately contains the `<think>` token will lose it. This is
+ * provider-convention scope — `<think>` is reserved for CoT, never plain
+ * content.
+ *
+ * @internal
+ */
+export interface ThinkStripResult {
+    /** Content with `<think>` blocks removed. */
+    visible: string;
+    /** Combined thinking text (without `<think>` tags), or null if none. */
+    thinking: string | null;
+}

package/dist/internal/tool-registry/personality-filter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * applyPersonalityFilter — additive narrowing of exposed tools by an
+ * active personality preset's `tools` whitelist (T4.1, ADRs D102+D167).
+ *
+ * Contract:
+ *
+ * - `whitelist === undefined` → return `exposedTools` unchanged (no
+ *   active personality OR personality has no tool restriction).
+ * - `whitelist === []` → return empty array (explicit "no tools for
+ *   this persona").
+ * - Otherwise → return the subset of `exposedTools` whose `name` is
+ *   present in `whitelist`. Missing entries emit a one-shot stderr
+ *   warning per `(agentId, personalityName, missingTool)` combo
+ *   (advisory only — D167 says missing tools must NOT crash).
+ *
+ * **EC-I:** MCP-style names like `mcp__server__tool` are matched as
+ * exact strings (no regex semantics) — the registry already produces
+ * the verbatim name.
+ *
+ * **EC-15:** Duplicate entries in `whitelist` are deduped silently.
+ *
+ * **EC-17:** Missing names within Levenshtein distance ≤2 of an exposed
+ * tool emit a "did you mean: X" hint inside the warning.
+ *
+ * The function is **pure**: it never mutates the input array.
+ *
+ * @internal
+ */
+export interface ToolNamed {
+    readonly name: string;
+}
+export interface ApplyPersonalityFilterOptions {
+    /** Used in the dedup key + warning prefix so logs are traceable. */
+    agentId?: string;
+    /** Active personality slug — used in the dedup key + warning. */
+    personalityName?: string;
+}

package/dist/internal/workflow/ctx.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Build the `StepContext` passed to every step.fn. The `suspend` method
+ * throws a `WorkflowSuspendedSentinel` (defined here) that the executor
+ * catches to persist a snapshot (D236).
+ *
+ * @internal
+ */
+/** Sentinel thrown by `ctx.suspend()`; only the executor catches it. */
+export declare class WorkflowSuspendedSentinel extends Error {
+    readonly payload?: unknown | undefined;
+    readonly name = "WorkflowSuspendedSentinel";
+    constructor(payload?: unknown | undefined);
+}
+export declare function makeStepContext(runId: string, signal: AbortSignal): StepContext;
+/**
+ * Combine the caller-supplied signal with the flight signal so abort on
+ * either side cancels the workflow run.
+ */
+export declare function combineSignals(...signals: ReadonlyArray<AbortSignal | undefined>): AbortSignal;

package/dist/internal/workflow/error-shape.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper to normalize unknown thrown values to `{ name, message }` shape
+ * for use in `StepResult.error` / `WorkflowRun.error`.
+ *
+ * @internal
+ */
+export {};

package/dist/internal/workflow/executor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Workflow executor (ADRs D230-D248).
+ *
+ * Walks `steps[]` sequentially, dispatching to per-kind handlers. Handles
+ * suspend (sentinel pattern; D236), single-flight (D242), abort signal
+ * boundaries (D245), and snapshot persistence opt-in (D235).
+ *
+ * @internal
+ */
+export declare function executeWorkflow<TInput, TOutput>(options: WorkflowOptions, steps: ReadonlyArray<Step>, input: TInput, runOpts?: WorkflowRunOptions): Promise<WorkflowRun<TOutput>>;
+/**
+ * Dispatch single step to the right handler. Exhaustive over `step.kind`.
+ */
+export declare function dispatchStep(step: Step, input: unknown, ctx: StepContext, options: WorkflowOptions, prevStepResults: ReadonlyArray<StepResult>): Promise<StepResult>;
+export declare function resumeWorkflow<TO>(opts: WorkflowResumeOptions): Promise<WorkflowRun<TO>>;

package/dist/internal/workflow/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal barrel for the workflow executor + helpers. Public API lives
+ * in `../../workflow.ts`.
+ *
+ * @internal
+ */
+export { dispatchStep, executeWorkflow, resumeWorkflow } from "./executor.js";
+export { mintRunId } from "./run-id.js";
+export { acquireSingleFlight } from "./single-flight.js";
+export type { WorkflowSnapshotStore } from "./snapshot-store.js";
+export { __resetSnapshotStoresForTests, getSnapshotStoreFor } from "./snapshot-store.js";
+export { __resetTelemetryCacheForTests, startWorkflowRunSpan, startWorkflowStepSpan, } from "./telemetry.js";

package/dist/internal/workflow/retry-policy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Retry wrapper with exponential backoff (ADR D237).
+ *
+ * `withRetry(fn, policy, signal)` retries on throw until success or
+ * `maxAttempts` reached. Aborts mid-backoff when signal fires.
+ * Non-retryable errors (by name) propagate immediately.
+ *
+ * @internal
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, policy: RetryPolicy, signal: AbortSignal): Promise<{
+    value: T;
+    attempts: number;
+}>;
+export declare function abortableSleep(ms: number, signal: AbortSignal): Promise<void>;

package/dist/internal/workflow/run-id.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate a short, deterministic workflow run identifier.
+ *
+ * Format: `wfr-<8 hex chars>`. Used for span keys, snapshot filenames, and
+ * single-flight registry keys.
+ *
+ * @internal
+ */
+export {};

package/dist/internal/workflow/single-flight.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Single-flight registry for in-flight workflow runs (ADR D242).
+ *
+ * Key = `${workflowId}:${runId}`. Throws `WorkflowAlreadyRunningError` on
+ * duplicate. Process crash auto-releases (in-memory map). Pattern mirrors
+ * `internal/eval/single-flight.ts` (D213).
+ *
+ * EC-5 absorbed: lock uses `workflowId` (minted at `.commit()`), not the
+ * user-supplied `name`, so two `Workflow` instances sharing a name don't
+ * collide on each other's locks.
+ *
+ * @internal
+ */
+export interface AcquiredFlight {
+    signal: AbortSignal;
+    release: () => void;
+}
+export declare function acquireSingleFlight(workflowId: string, runId: string, workflowName: string): AcquiredFlight;

package/dist/internal/workflow/snapshot-store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Snapshot store interface + InMemory and JsonFile backends (ADR D235).
+ *
+ * EC-4 absorbed: serialization happens here. `JSON.stringify` failure raises
+ * `WorkflowNotSerializableError` instead of letting the underlying `TypeError`
+ * leak.
+ *
+ * @internal
+ */
+import { type WorkflowOptions, type WorkflowSnapshot } from "../../types/workflow.js";
+export interface WorkflowSnapshotStore {
+    save(snapshot: WorkflowSnapshot): Promise<void>;
+    load(runId: string): Promise<WorkflowSnapshot | undefined>;
+    delete(runId: string): Promise<void>;
+    list(workflowName?: string): Promise<ReadonlyArray<{
+        runId: string;
+        workflowName: string;
+        suspendedAt: number;
+    }>>;
+}
+export declare function getSnapshotStoreFor(options: WorkflowOptions): WorkflowSnapshotStore;
+/** Test seam — clear in-memory store between tests. */
+export declare function __resetSnapshotStoresForTests(): void;

package/dist/internal/workflow/step-agent.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Execute an `AgentStep` — render the prompt template, call `agent.send`,
+ * wait for completion, return the result text as step output (ADR D244,
+ * D245).
+ *
+ * Cloud guard: agents marked as `CloudAgent` throw `UnsupportedRunOperationError`
+ * (workflows are local-only in v1).
+ *
+ * @internal
+ */
+import type { AgentStep, StepContext, StepResult } from "../../types/workflow.js";
+export declare function runAgentStep(step: AgentStep, input: unknown, ctx: StepContext): Promise<StepResult>;

package/dist/internal/workflow/step-branch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Execute a `BranchStep` — first-match-wins predicates + optional fallback.
+ *
+ * EC-2 absorbed: predicates that THROW are treated as "no match" + stderr
+ * warn — user-code bugs in predicates don't take down the whole workflow.
+ *
+ * @internal
+ */
+import type { DispatchFn } from "./step-parallel.js";
+export declare function runBranchStep(step: BranchStep, input: unknown, ctx: StepContext, options: WorkflowOptions, prevStepResults: ReadonlyArray<StepResult>, dispatch: DispatchFn): Promise<StepResult>;

package/dist/internal/workflow/step-dowhile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Execute a `DowhileStep` — loop the inner step until `condFn` returns
+ * false or `maxIterations` is reached (default 100).
+ *
+ * @internal
+ */
+import type { DispatchFn } from "./step-parallel.js";
+export declare function runDowhileStep(step: DowhileStep, input: unknown, ctx: StepContext, options: WorkflowOptions, prevStepResults: ReadonlyArray<StepResult>, dispatch: DispatchFn): Promise<StepResult>;

package/dist/internal/workflow/step-fn.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Execute a `FnStep` — call the user-supplied function with `input` + `ctx`.
+ * Wraps in `withRetry` if a retry policy is set (D237).
+ *
+ * Validates input/output via Zod when schemas are supplied. EC-4 / D229
+ * pattern: empty/undefined input parses as `{}` only when schema is defined.
+ *
+ * @internal
+ */
+export declare function runFnStep(step: FnStep, input: unknown, ctx: StepContext): Promise<StepResult>;

package/dist/internal/workflow/step-foreach.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Execute a `ForeachStep` — map a step over the output of an upstream step.
+ *
+ * EC-7 absorbed: `iterableFrom` MUST reference a top-level step (one of
+ * `prevStepResults`). Inner steps from inside `.parallel` / `.branch` /
+ * `.foreach` are not reachable.
+ *
+ * @internal
+ */
+import type { DispatchFn } from "./step-parallel.js";
+export declare function runForeachStep(step: ForeachStep, _input: unknown, ctx: StepContext, options: WorkflowOptions, prevStepResults: ReadonlyArray<StepResult>, dispatch: DispatchFn): Promise<StepResult>;

package/dist/internal/workflow/step-parallel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Execute a `ParallelStep` — run N branches concurrently.
+ *
+ * - `errorPolicy: "fail-fast"` (default): first branch error aborts the rest
+ *   via a derived AbortSignal; `WorkflowParallelError` aggregates failures.
+ * - `errorPolicy: "collect"`: all branches complete; output is array of
+ *   `{ ok: true, value } | { ok: false, error }`.
+ *
+ * Concurrency: bounded by `step.concurrency ?? branches.length` (D240). All
+ * branches run inside the same `AsyncSemaphore`.
+ *
+ * EC-6 absorbed: empty `branches[]` returns `output: []` without error.
+ *
+ * @internal
+ */
+export type DispatchFn = (step: Step, input: unknown, ctx: StepContext, options: WorkflowOptions, prevStepResults: ReadonlyArray<StepResult>) => Promise<StepResult>;
+export declare function runParallelStep(step: ParallelStep, input: unknown, ctx: StepContext, options: WorkflowOptions, _prevStepResults: ReadonlyArray<StepResult>, dispatch: DispatchFn): Promise<StepResult>;

package/dist/internal/workflow/step-sleep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Execute a `SleepStep` — pause for `durationMs`. Aborts mid-sleep
+ * when the signal fires (D245).
+ *
+ * @internal
+ */
+export declare function runSleepStep(step: SleepStep, input: unknown, ctx: StepContext): Promise<StepResult>;

package/dist/internal/workflow/telemetry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OTel telemetry for workflows (ADR D241).
+ *
+ * Spans:
+ *   - `workflow.run` — root span per `Workflow.run` invocation
+ *   - `workflow.step.<id>` — child span per step (retry attempts share the kind)
+ *
+ * Attributes:
+ *   - `workflow.name`, `workflow.run_id`, `step.kind`, `step.status`, `step.attempts`
+ *
+ * @internal
+ */
+export declare function startWorkflowRunSpan(info: {
+    workflowName: string;
+    runId: string;
+}): SpanLike;
+export declare function startWorkflowStepSpan(info: {
+    stepId: string;
+    kind: string;
+    attempt: number;
+}): SpanLike;
+/** Test seam — reset tracer cache so a fresh require attempt happens. */
+export declare function __resetTelemetryCacheForTests(): void;

package/dist/internal/zod/to-json-schema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Zod → JSON Schema universal adapter (FAANG-grade, supports Zod 3 + Zod 4).
+ *
+ * The SDK declares `zod: "^3.25.0 || ^4.0.0"` as optional peer. Implementation
+ * MUST work on both versions or the peer-range claim is false.
+ *
+ * Strategy:
+ *   1. Feature-detect Zod 4's native `z.toJSONSchema` (preferred — zero extra
+ *      dep, ships with Zod 4 core).
+ *   2. Fall back to the universal `zod-to-json-schema` library (works for both
+ *      v3 and v4; ~5KB gzipped, optional peer dep).
+ *   3. If neither path resolves, throw an actionable error explaining the
+ *      install command for the user's Zod major.
+ *
+ * Output shape is identical across paths: a `Record<string, unknown>` JSON
+ * Schema document with `type: "object"` root that the LLM tool-use spec
+ * accepts unchanged.
+ *
+ * @internal
+ */
+export {};

package/dist/memory-adapter-helpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runtime helpers for `MemoryAdapter` (T1.1, ADR D141).
+ *
+ * Kept separate from `types/memory-adapter.ts` so the types module
+ * stays import-free of runtime code (dep-cruise rule
+ * `types-dont-import-runtime`). Adapter authors call `mkMemoryId` to
+ * construct a branded id and `extractRawId` to unwrap with cross-adapter
+ * safety (EC-B).
+ *
+ * @public
+ */
+import type { MemoryId } from "./types/memory-adapter.js";
+/**
+ * Construct a branded `MemoryId` for an adapter. Embeds the adapter
+ * identifier so `extractRawId` can reject ids minted by other adapters.
+ *
+ * @public
+ */
+export declare function mkMemoryId(adapterId: string, rawId: string): MemoryId;
+/**
+ * Extract the raw provider id from a `MemoryId`, enforcing that the
+ * prefix matches `expectedAdapterId`. Throws `MemoryAdapterError(code:
+ * "invalid_input")` on mismatch — prevents `mem0.delete(supermemoryId)`
+ * from accidentally deleting unrelated data (EC-B).
+ *
+ * @public
+ */
+export declare function extractRawId(id: MemoryId, expectedAdapterId: string): string;

package/dist/memory.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Public handle to an open memory index. Mirrors the internal `MemoryIndex`
+ * contract structurally; defined here (NOT re-exported from internal/) so
+ * the public DTS surface does not pull the internal/runtime cycle that
+ * trips rollup-plugin-dts.
+ *
+ * @public
+ */
+export interface MemoryIndexHandle {
+    sync(): Promise<{
+        filesScanned: number;
+        filesUpdated: number;
+        chunksWritten: number;
+        chunksEmbedded: number;
+    }>;
+    search(query: string, options?: {
+        maxResults?: number;
+        minScore?: number;
+        sources?: ReadonlyArray<"memory" | "sessions" | "wiki">;
+    }): Promise<ReadonlyArray<{
+        path: string;
+        startLine: number;
+        endLine: number;
+        score: number;
+        textScore: number;
+        vectorScore?: number;
+        snippet: string;
+        source: "memory" | "sessions" | "wiki";
+        citation: string;
+    }>>;
+    status(): {
+        backend: "fts-only" | "hybrid";
+        filesIndexed: number;
+        chunksIndexed: number;
+        lastSyncMs?: number;
+    };
+    close(): Promise<void> | void;
+}
+/**
+ * Public `Memory` namespace.
+ *
+ * Exposes operations users can run outside of `agent.send()` — most notably
+ * the dreaming sweep (consolidation of facts via dedup + clustering).
+ *
+ * @public
+ */
+export interface DreamingSweepOptions {
+    /** Workspace cwd holding `.theokit/memory/`. */
+    cwd: string;
+    /**
+     * Embedding provider for semantic dedup + clustering. Required — dreaming
+     * relies on real embeddings to score cosine similarity. Supported providers:
+     * `"openai"`, `"mistral"`, `"openrouter"`, `"voyage"`, `"deepinfra"`,
+     * `"ollama"` (local, ADR D183).
+     */
+    embedding: {
+        provider: "openai" | "mistral" | "openrouter" | "voyage" | "deepinfra" | "ollama";
+        model?: string;
+    };
+    /** Cosine-similarity threshold for the dedup phase. Default `0.95`. */
+    dedupThreshold?: number;
+    /** Cosine-similarity threshold for the clustering phase. Default `0.75`. */
+    clusterThreshold?: number;
+}
+export interface DreamingSweepResult {
+    status: "ok" | "skipped" | "error";
+    factsBefore: number;
+    factsAfter: number;
+    duplicatesRemoved: number;
+    clustersCreated: number;
+    notesWritten: number;
+}
+/**
+ * Options for `Memory.openIndex`. Mirrors the internal `OpenIndexOptions`
+ * but using only public types from the SDK surface.
+ *
+ * @public
+ */
+export interface OpenMemoryIndexOptions {
+    /** Workspace cwd holding `.theokit/memory/`. */
+    cwd: string;
+    /** Override storage file path (SQLite) OR storage directory (Lance). */
+    filePath?: string;
+    /**
+     * Embedding runtime — REQUIRED for `backend: "lance"`, optional for
+     * `"sqlite-vec"` (when omitted, SQLite runs FTS-only without vector
+     * recall).
+     */
+    embedding?: {
+        provider: "openai" | "mistral" | "openrouter" | "voyage" | "deepinfra" | "ollama";
+        model?: string;
+    };
+    /** Default `"sqlite-vec"`. Set to `"lance"` to opt into LanceDB (peer dep). */
+    backend?: "sqlite-vec" | "lance";
+}
+export declare const Memory: {
+    /**
+     * Open a memory index. Dispatches to SQLite-vec (default, zero deps) or
+     * LanceDB (opt-in via `backend: "lance"`, requires `@lancedb/lancedb`
+     * peer dep + an embedding runtime).
+     *
+     * Returns a `MemoryIndex` with `sync()`, `search(query, opts?)`,
+     * `status()`, and `close()`. Use this when you want a direct index
+     * handle outside of `Agent.create({ memory: ... })`.
+     *
+     * @throws ConfigurationError({code:"invalid_memory_backend"}) for typos
+     *   like `"lancedb"`.
+     * @throws ConfigurationError({code:"lance_requires_embedding"}) when
+     *   `backend: "lance"` is requested without `embedding`.
+     * @throws ConfigurationError({code:"lance_backend_unavailable"}) when
+     *   `backend: "lance"` is requested but the peer dep is absent.
+     *
+     * @public
+     */
+    openIndex(opts: OpenMemoryIndexOptions): Promise<MemoryIndexHandle>;
+    /**
+     * Run a dreaming sweep: dedup near-duplicate facts, cluster thematically
+     * related ones, and write a consolidated note + diary entry.
+     *
+     * @public
+     */
+    runDreamingSweep(opts: DreamingSweepOptions): Promise<DreamingSweepResult>;
+};

package/dist/migrate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Options for {@link migrateSqliteToLance}.
+ *
+ * @public
+ */
+export interface MigrateOptions {
+    cwd: string;
+    dryRun?: boolean;
+    batchSize?: number;
+    logger?: (msg: string) => void;
+}
+/**
+ * Outcome of {@link migrateSqliteToLance}.
+ *
+ * @public
+ */
+export interface MigrateResult {
+    countSqlite: number;
+    countLance: number;
+    validated: boolean;
+    sampleComparisons: ReadonlyArray<{
+        id: string;
+        match: boolean;
+    }>;
+    lancePath: string;
+    committed: boolean;
+}
+/**
+ * Migrate the Memory index from SQLite to LanceDB. ADR D44.
+ *
+ * @public
+ */
+export declare function migrateSqliteToLance(options: MigrateOptions): Promise<MigrateResult>;