@chendpoc/pi-memory 0.2.4 → 0.3.2

package/dist/scheduler/sync.js

@@ -0,0 +1,79 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ENV_KEYS } from "../constants/env.js";
+import { LAUNCHD_LABEL } from "../constants/paths.js";
+import { resolveMemoryAgentDir } from "../config/agentDir.js";
+import { debugMemory } from "../utils/debugLog.js";
+import { isMacOS } from "../utils/platform.js";
+import { defaultConsolidateSchedulerPaths } from "../utils/scheduler.js";
+import { syncLaunchdMaintenanceJob } from "./launchd.js";
+export function isSchedulerSyncDisabled(env = process.env) {
+    const value = env[ENV_KEYS.SKIP_SCHEDULER_SYNC];
+    return value === "1" || value === "true";
+}
+/** Whether this process can attempt a user LaunchAgent sync (macOS + uid + home). */
+export function canSyncLaunchdInProcess(env = process.env) {
+    if (!isMacOS())
+        return { ok: false, reason: "unsupported-platform" };
+    if (process.getuid?.() === undefined)
+        return { ok: false, reason: "no-user-id" };
+    if (!homedir()?.trim())
+        return { ok: false, reason: "no-home-directory" };
+    if (isSchedulerSyncDisabled(env))
+        return { ok: false, reason: "PI_MEMORY_SKIP_SCHEDULER_SYNC" };
+    return { ok: true };
+}
+export function resolvePackageCliPath(moduleUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(moduleUrl)), "..", "cli.js");
+}
+function formatSyncError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Install or refresh the OS maintenance scheduler (macOS launchd today).
+ * Never throws — automatic callers (postinstall, session_start, init) treat failures as best-effort.
+ */
+export async function syncMaintenanceScheduler(opts = {}) {
+    const env = opts.env ?? process.env;
+    const capability = canSyncLaunchdInProcess(env);
+    if (!capability.ok) {
+        return { status: "skipped", reason: capability.reason };
+    }
+    try {
+        const agentDir = opts.agentDir ?? resolveMemoryAgentDir({ env });
+        const paths = defaultConsolidateSchedulerPaths(agentDir);
+        const nodePath = opts.nodePath ?? process.execPath;
+        const cliPath = opts.cliPath ?? resolvePackageCliPath(import.meta.url);
+        const result = await syncLaunchdMaintenanceJob({
+            label: LAUNCHD_LABEL,
+            nodePath,
+            cliPath,
+            envFile: paths.envFile,
+            agentDir: paths.agentDir,
+            logsDir: paths.logsDir,
+            stdoutLog: paths.stdoutLog,
+            stderrLog: paths.stderrLog,
+        });
+        debugMemory("scheduler", "launchd sync complete", {
+            label: result.label,
+            changed: result.changed,
+            bootstrapped: result.bootstrapped,
+            removedLegacy: result.removedLegacy.join(",") || "none",
+        }, env);
+        return {
+            status: "synced",
+            platform: "launchd",
+            label: result.label,
+            plistPath: result.plistPath,
+            changed: result.changed,
+            bootstrapped: result.bootstrapped,
+            removedLegacy: result.removedLegacy,
+        };
+    }
+    catch (error) {
+        const message = formatSyncError(error);
+        debugMemory("scheduler", "launchd sync failed (best-effort)", { message }, env);
+        return { status: "failed", reason: "launchd-sync-error", message };
+    }
+}

package/dist/shutdown/enqueue.d.ts

@@ -1,4 +1,5 @@
 import type { SessionShutdownEvent } from "@earendil-works/pi-coding-agent";
+export { readParentSession } from "../utils/session/index.js";
 export type ShutdownQueueEntry = {
     sessionFile: string;
     parentSession?: string;
@@ -8,4 +9,3 @@ export type ShutdownQueueEntry = {
 };
 export declare function shutdownQueuePath(agentDir: string): string;
 export declare function enqueueShutdownMetadata(agentDir: string, entry: ShutdownQueueEntry): Promise<void>;
-export declare function readParentSession(header: Record<string, unknown> | null): string | undefined;

package/dist/shutdown/enqueue.js

@@ -1,13 +1,10 @@
 import { SHUTDOWN_QUEUE_FILE } from "../constants/memory.js";
-import { serializeJsonlFrame } from "../ipc/jsonlFramer.js";
+import { serializeJsonlFrame } from "../utils/jsonl.js";
 import { appendText, joinPath } from "../utils/fs.js";
+export { readParentSession } from "../utils/session/index.js";
 export function shutdownQueuePath(agentDir) {
     return joinPath(agentDir, SHUTDOWN_QUEUE_FILE);
 }
 export async function enqueueShutdownMetadata(agentDir, entry) {
     await appendText(shutdownQueuePath(agentDir), serializeJsonlFrame(entry));
 }
-export function readParentSession(header) {
-    const parent = header?.parentSession ?? header?.parent_session;
-    return typeof parent === "string" && parent.trim().length > 0 ? parent.trim() : undefined;
-}

package/dist/shutdown/readQueue.js

@@ -1,4 +1,4 @@
-import { parseJsonlLine } from "../ipc/jsonlFramer.js";
+import { parseJsonlLine } from "../utils/jsonl.js";
 import { readText } from "../utils/fs.js";
 import { shutdownQueuePath } from "./enqueue.js";
 /** Latest queue row per session file (deduped). */

package/dist/shutdown/runDrainJob.js

@@ -1,9 +1,5 @@
-import { filterCompactionDelta, shouldSkipSubagentCompactionIngest, } from "../compact/subagentDelta.js";
-import { parseMemoryExport } from "../compact/parseMemoryExport.js";
-import { reindex } from "../sidecar/client.js";
-import { ensureSidecarRunning } from "../sidecar/sidecarManager.js";
-import { resolveSidecarPaths } from "../sidecar/paths.js";
-import { sidecarQueryCache } from "../preflight/queryCache.js";
+import { syncSidecarIndex } from "../sidecar/syncIndex.js";
+import { ingestMemoryExport } from "../store/ingestEntries.js";
 import { canRead, pathExists } from "../utils/fs.js";
 import { buildShutdownMemoryExportPrompt, wrapShutdownExportMarkdown, } from "./extractPrompt.js";
 import { markShutdownProcessed, readShutdownProcessedState, isShutdownProcessed } from "./processed.js";
@@ -104,39 +100,14 @@ async function drainQueueEntry(opts) {
     return { appended };
 }
 async function ingestFromSummary(opts) {
-    const parsed = parseMemoryExport(opts.summary);
-    if (parsed.length === 0) {
-        if (opts.compactionId) {
-            await opts.store.markCompactionProcessed(opts.compactionId);
-        }
-        await markShutdownProcessed(opts.agentDir, opts.sessionFile);
-        return 0;
-    }
-    let entries = parsed;
-    if (opts.subagent) {
-        const existing = await opts.store.listEntries();
-        entries = filterCompactionDelta(parsed, existing);
-        if (shouldSkipSubagentCompactionIngest(parsed, entries)) {
-            if (opts.compactionId) {
-                await opts.store.markCompactionProcessed(opts.compactionId);
-            }
-            await markShutdownProcessed(opts.agentDir, opts.sessionFile);
-            return 0;
-        }
-    }
-    if (entries.length > 0) {
-        await opts.store.appendMany(entries, { mode: "ifAbsent" });
-    }
+    const { appended } = await ingestMemoryExport({
+        store: opts.store,
+        summary: opts.summary,
+        isSubagent: !!opts.subagent,
+    });
     if (opts.compactionId) {
         await opts.store.markCompactionProcessed(opts.compactionId);
     }
     await markShutdownProcessed(opts.agentDir, opts.sessionFile);
-    return entries.length;
-}
-async function syncSidecarIndex(agentDir, store) {
-    const sidecar = resolveSidecarPaths(agentDir);
-    await ensureSidecarRunning(sidecar);
-    const result = await reindex(sidecar.socketPath, await store.exportForIndex());
-    sidecarQueryCache.onReindexComplete(agentDir, result.index_generation);
-    return result.index_generation;
+    return appended;
 }

package/dist/shutdown/sessionReader.js

@@ -1,19 +1,6 @@
 import { buildSessionContext, convertToLlm, getLatestCompactionEntry, parseSessionEntries, serializeConversation, } from "@earendil-works/pi-coding-agent";
-import { stripPrivateMemory } from "../preflight/strip.js";
+import { stripPrivateMemoryFromMessages } from "../utils/memory/index.js";
 import { readTextRequired } from "../utils/fs.js";
-function stripPrivateMemoryFromMessages(messages) {
-    return messages.map((message) => {
-        if (message.role !== "user")
-            return message;
-        if (typeof message.content === "string") {
-            return { ...message, content: stripPrivateMemory(message.content) };
-        }
-        return {
-            ...message,
-            content: message.content.map((block) => block.type === "text" ? { ...block, text: stripPrivateMemory(block.text) } : block),
-        };
-    });
-}
 function toSessionEntries(fileEntries) {
     return fileEntries.filter((entry) => entry.type !== "session");
 }

package/dist/sidecar/client.d.ts

@@ -1,12 +1,16 @@
 import { type IndexDocument, type IndexStats, type SidecarResponse } from "./protocol.js";
-export declare function sidecarRequest<T extends SidecarResponse>(socketPath: string, frame: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+export type SidecarRequestOptions = {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+export declare function sidecarRequest<T extends SidecarResponse>(socketPath: string, frame: Record<string, unknown>, options?: SidecarRequestOptions): Promise<T>;
 export declare function ping(socketPath: string): Promise<boolean>;
 export declare function fetchIndexStats(socketPath: string): Promise<{
     stats: IndexStats;
 } | {
     error: string;
 }>;
-export declare function query(socketPath: string, queryText: string, timeoutMs?: number): Promise<{
+export declare function query(socketPath: string, queryText: string, options?: SidecarRequestOptions): Promise<{
     type: "result";
     request_id: string;
     results: import("./protocol.js").MemoryEntry[];

package/dist/sidecar/client.js

@@ -2,45 +2,80 @@
 import { randomUUID } from "node:crypto";
 import net from "node:net";
 import { SIDECAR_PING_TIMEOUT_MS, SIDECAR_QUERY_TIMEOUT_MS, SIDECAR_REINDEX_TIMEOUT_MS, } from "../constants/timing.js";
-import { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "../ipc/jsonlFramer.js";
+import { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "../utils/jsonl.js";
 import { isErrorResponse } from "./protocol.js";
-export function sidecarRequest(socketPath, frame, timeoutMs = SIDECAR_QUERY_TIMEOUT_MS) {
+export function sidecarRequest(socketPath, frame, options = {}) {
+    const timeoutMs = options.timeoutMs ?? SIDECAR_QUERY_TIMEOUT_MS;
+    const { signal } = options;
     return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError(signal));
+            return;
+        }
         const socket = net.connect(socketPath);
         const framer = new JsonlFramer();
-        const timer = setTimeout(() => {
+        let settled = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
             socket.destroy();
-            reject(new Error("Sidecar request timed out"));
+            reject(error);
+        };
+        const succeed = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        const onAbort = () => {
+            fail(abortError(signal));
+        };
+        const timer = setTimeout(() => {
+            fail(new Error("Sidecar request timed out"));
         }, timeoutMs);
+        if (signal) {
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
         socket.on("connect", () => {
             socket.write(serializeJsonlFrame(frame));
         });
         socket.on("data", (chunk) => {
             for (const line of framer.push(chunk.toString())) {
-                clearTimeout(timer);
                 socket.end();
                 let response;
                 try {
                     response = parseJsonlLine(line);
                 }
                 catch {
-                    reject(new Error("Invalid JSON response from sidecar"));
+                    fail(new Error("Invalid JSON response from sidecar"));
                     return;
                 }
                 if (isErrorResponse(response)) {
-                    reject(new Error(response.error));
+                    fail(new Error(response.error));
                     return;
                 }
-                resolve(response);
+                succeed(response);
                 return;
             }
         });
-        socket.on("error", reject);
+        socket.on("error", (error) => {
+            fail(error instanceof Error ? error : new Error(String(error)));
+        });
     });
 }
+function abortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error("Aborted");
+}
 export async function ping(socketPath) {
     try {
-        const res = await sidecarRequest(socketPath, { type: "ping" }, SIDECAR_PING_TIMEOUT_MS);
+        const res = await sidecarRequest(socketPath, { type: "ping" }, { timeoutMs: SIDECAR_PING_TIMEOUT_MS });
         return res.type === "pong";
     }
     catch {
@@ -49,7 +84,7 @@ export async function ping(socketPath) {
 }
 export async function fetchIndexStats(socketPath) {
     try {
-        const res = await sidecarRequest(socketPath, { type: "stats" }, SIDECAR_PING_TIMEOUT_MS);
+        const res = await sidecarRequest(socketPath, { type: "stats" }, { timeoutMs: SIDECAR_PING_TIMEOUT_MS });
         if (res.type !== "stats_ok")
             return { error: "unexpected sidecar response" };
         const { type: _type, ...stats } = res;
@@ -60,11 +95,11 @@ export async function fetchIndexStats(socketPath) {
         return { error: message };
     }
 }
-export async function query(socketPath, queryText, timeoutMs = SIDECAR_QUERY_TIMEOUT_MS) {
+export async function query(socketPath, queryText, options = {}) {
     const request_id = randomUUID();
-    return sidecarRequest(socketPath, { type: "query", request_id, query: queryText }, timeoutMs);
+    return sidecarRequest(socketPath, { type: "query", request_id, query: queryText }, options);
 }
 export async function reindex(socketPath, documents = []) {
     const request_id = randomUUID();
-    return sidecarRequest(socketPath, { type: "reindex", request_id, documents }, SIDECAR_REINDEX_TIMEOUT_MS);
+    return sidecarRequest(socketPath, { type: "reindex", request_id, documents }, { timeoutMs: SIDECAR_REINDEX_TIMEOUT_MS });
 }

package/dist/{preflight → sidecar}/queryCache.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from "../sidecar/protocol.js";
+import type { MemoryEntry } from "./protocol.js";
 declare class SidecarQueryCache {
     private readonly generationByAgent;
     private readonly lru;

package/dist/sidecar/reindexBridge.js

@@ -1,6 +1,6 @@
-import debounce from "lodash/debounce.js";
+import { debounce } from "es-toolkit";
 import { DEFAULT_REINDEX_DEBOUNCE_MS } from "../constants/timing.js";
-import { sidecarQueryCache } from "../preflight/queryCache.js";
+import { sidecarQueryCache } from "./queryCache.js";
 import { ensureSidecarRunning } from "./sidecarManager.js";
 import { reindex } from "./client.js";
 export function createReindexScheduler(opts) {

package/dist/sidecar/server/server.js

@@ -1,7 +1,7 @@
 import { createServer } from "node:net";
 import { writeFileSync } from "node:fs";
 import { SIDECAR_PID_SUFFIX } from "../../constants/paths.js";
-import { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "../../ipc/jsonlFramer.js";
+import { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "../../utils/jsonl.js";
 import { ensureDirSync, pathDirname } from "../../utils/fs.js";
 import { cleanupSocketFiles, removeSocketFile, secureSocketPath } from "../../utils/socket.js";
 import { handleQuery } from "./query.js";

package/dist/sidecar/server/vec/chunkQuery.d.ts

@@ -0,0 +1,4 @@
+import type { MemoryEntry } from "../../protocol.js";
+type VecDatabase = import("better-sqlite3").Database;
+export declare function queryChunks(db: VecDatabase, queryText: string, topK?: number): Promise<MemoryEntry[]>;
+export {};

package/dist/sidecar/server/vec/chunkQuery.js

@@ -0,0 +1,46 @@
+import { readRetrievalConfig } from "../../../config/retrieval.js";
+import { blobToEmbedding } from "./embeddingCodec.js";
+import { getEmbedder } from "./embedder.js";
+import { cosineSimilarity, distanceToRelevance, mmrSelect } from "./mmr.js";
+import { clearChunksIfEmbeddingMismatch } from "./schema.js";
+export async function queryChunks(db, queryText, topK) {
+    const retrieval = readRetrievalConfig();
+    const limit = topK ?? retrieval.topK;
+    const embedder = getEmbedder();
+    clearChunksIfEmbeddingMismatch(db, embedder);
+    const queryEmbedding = await embedder.embed(queryText);
+    const rows = db
+        .prepare("SELECT chunk_id, content, source, timestamp, embedding FROM memory_chunks")
+        .all();
+    if (rows.length === 0)
+        return [];
+    const candidates = [];
+    for (const row of rows) {
+        const embedding = blobToEmbedding(row.embedding);
+        if (embedding.length !== queryEmbedding.length)
+            continue;
+        const similarity = cosineSimilarity(queryEmbedding, embedding);
+        if (similarity < retrieval.minRelevance)
+            continue;
+        candidates.push({
+            chunkId: row.chunk_id,
+            content: row.content,
+            source: row.source,
+            timestamp: row.timestamp,
+            distance: 1 - similarity,
+            embedding,
+        });
+    }
+    if (candidates.length === 0)
+        return [];
+    candidates.sort((a, b) => a.distance - b.distance);
+    const poolSize = Math.min(limit * retrieval.candidatePoolMultiplier, candidates.length);
+    const pool = candidates.slice(0, poolSize);
+    const selected = mmrSelect(queryEmbedding, pool, limit, retrieval.mmrLambda);
+    return selected.map((item) => ({
+        content: item.content,
+        source: item.source,
+        timestamp: item.timestamp,
+        relevance: distanceToRelevance(item.distance),
+    }));
+}

package/dist/sidecar/server/vec/chunkReindex.d.ts

@@ -0,0 +1,5 @@
+import type { IndexDocument } from "../../protocol.js";
+import { type ReindexOutcome } from "./schema.js";
+type VecDatabase = import("better-sqlite3").Database;
+export declare function reindexChunks(db: VecDatabase, documents: IndexDocument[]): Promise<ReindexOutcome>;
+export {};

package/dist/sidecar/server/vec/chunkReindex.js

@@ -0,0 +1,40 @@
+import { getEmbedder } from "./embedder.js";
+import { embeddingToBlob } from "./embeddingCodec.js";
+import { bumpIndexGeneration, clearChunksIfEmbeddingMismatch, getIndexGeneration, writeEmbeddingMeta, } from "./schema.js";
+export async function reindexChunks(db, documents) {
+    const embedder = getEmbedder();
+    clearChunksIfEmbeddingMismatch(db, embedder);
+    if (documents.length === 0) {
+        const indexGeneration = getIndexGeneration(db);
+        writeEmbeddingMeta(db, embedder);
+        return { indexed: 0, indexGeneration };
+    }
+    const embeddings = await embedder.embedBatch(documents.map((doc) => doc.content));
+    const sync = db.transaction((docs, vectors) => {
+        const incomingIds = new Set(docs.map((doc) => doc.id));
+        const existing = db.prepare("SELECT chunk_id FROM memory_chunks").all();
+        const deleteChunk = db.prepare("DELETE FROM memory_chunks WHERE chunk_id = ?");
+        for (const row of existing) {
+            if (!incomingIds.has(row.chunk_id)) {
+                deleteChunk.run(row.chunk_id);
+            }
+        }
+        const upsert = db.prepare(`
+      INSERT INTO memory_chunks(chunk_id, content, source, timestamp, embedding)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET
+        content = excluded.content,
+        source = excluded.source,
+        timestamp = excluded.timestamp,
+        embedding = excluded.embedding
+    `);
+        for (let i = 0; i < docs.length; i++) {
+            const doc = docs[i];
+            upsert.run(doc.id, doc.content, doc.source, doc.timestamp, embeddingToBlob(vectors[i]));
+        }
+        const indexGeneration = bumpIndexGeneration(db);
+        writeEmbeddingMeta(db, embedder);
+        return { indexed: docs.length, indexGeneration };
+    });
+    return sync(documents, embeddings);
+}

package/dist/sidecar/server/vec/embeddingCodec.d.ts

@@ -0,0 +1,2 @@
+export declare function embeddingToBlob(embedding: Float32Array): Buffer;
+export declare function blobToEmbedding(blob: Buffer): Float32Array;

package/dist/sidecar/server/vec/embeddingCodec.js

@@ -0,0 +1,6 @@
+export function embeddingToBlob(embedding) {
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+}
+export function blobToEmbedding(blob) {
+    return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+}

package/dist/sidecar/server/vec/schema.d.ts

@@ -0,0 +1,20 @@
+import type { Embedder } from "../../../adapters/embed/types.js";
+type VecDatabase = import("better-sqlite3").Database;
+export type StoredEmbeddingMeta = {
+    model: string;
+    provider: string;
+    dim: number;
+};
+export type ReindexOutcome = {
+    indexed: number;
+    indexGeneration: number;
+};
+export declare function initVecSchema(db: VecDatabase): void;
+export declare function getStoredEmbeddingMeta(db: VecDatabase): StoredEmbeddingMeta | null;
+export declare function embeddingMetaMatches(db: VecDatabase, embedder: Embedder): boolean;
+export declare function getIndexGeneration(db: VecDatabase): number;
+export declare function getChunkCount(db: VecDatabase): number;
+export declare function clearChunksIfEmbeddingMismatch(db: VecDatabase, embedder: Embedder): void;
+export declare function bumpIndexGeneration(db: VecDatabase): number;
+export declare function writeEmbeddingMeta(db: VecDatabase, embedder: Embedder): void;
+export {};

package/dist/sidecar/server/vec/schema.js

@@ -0,0 +1,61 @@
+export function initVecSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS memory_chunks (
+      chunk_id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      source TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      embedding BLOB NOT NULL
+    );
+  `);
+}
+export function getStoredEmbeddingMeta(db) {
+    const read = (key) => db.prepare("SELECT value FROM meta WHERE key = ?").pluck().get(key);
+    const model = read("embedding_model");
+    const provider = read("embedding_provider");
+    const dimRaw = read("embedding_dim");
+    if (!model || !provider || !dimRaw)
+        return null;
+    const dim = Number.parseInt(dimRaw, 10);
+    if (!Number.isFinite(dim))
+        return null;
+    return { model, provider, dim };
+}
+export function embeddingMetaMatches(db, embedder) {
+    const stored = getStoredEmbeddingMeta(db);
+    if (!stored)
+        return true;
+    return (stored.model === embedder.model &&
+        stored.provider === embedder.provider &&
+        stored.dim === embedder.dim);
+}
+export function getIndexGeneration(db) {
+    const raw = db.prepare("SELECT value FROM meta WHERE key = 'index_generation'").pluck().get();
+    return Number(raw ?? "0");
+}
+export function getChunkCount(db) {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM memory_chunks").get();
+    return row.count;
+}
+export function clearChunksIfEmbeddingMismatch(db, embedder) {
+    if (embeddingMetaMatches(db, embedder))
+        return;
+    db.prepare("DELETE FROM memory_chunks").run();
+}
+export function bumpIndexGeneration(db) {
+    const generation = getIndexGeneration(db) + 1;
+    db
+        .prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+        .run("index_generation", String(generation));
+    return generation;
+}
+export function writeEmbeddingMeta(db, embedder) {
+    const upsert = db.prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    upsert.run("embedding_model", embedder.model);
+    upsert.run("embedding_provider", embedder.provider);
+    upsert.run("embedding_dim", String(embedder.dim));
+}

package/dist/sidecar/server/vec/store.d.ts

@@ -1,25 +1,14 @@
 import type { Embedder } from "../../../adapters/embed/types.js";
 import type { IndexDocument, MemoryEntry } from "../../protocol.js";
-export type StoredEmbeddingMeta = {
-    model: string;
-    provider: string;
-    dim: number;
-};
-export type ReindexOutcome = {
-    indexed: number;
-    indexGeneration: number;
-};
+import { type ReindexOutcome, type StoredEmbeddingMeta } from "./schema.js";
+export type { ReindexOutcome, StoredEmbeddingMeta };
 export declare class VecStore {
     private db;
     constructor(dbPath: string);
-    private initSchema;
     getStoredEmbeddingMeta(): StoredEmbeddingMeta | null;
     embeddingMetaMatches(embedder: Embedder): boolean;
     getIndexGeneration(): number;
     getChunkCount(): number;
-    private clearChunksIfEmbeddingMismatch;
-    private bumpIndexGeneration;
-    private writeEmbeddingMeta;
     reindex(documents: IndexDocument[]): Promise<ReindexOutcome>;
     query(queryText: string, topK?: number): Promise<MemoryEntry[]>;
     close(): void;