@tekmidian/pai 0.1.0

package/dist/detector-DKA83aTZ.mjs

@@ -0,0 +1,74 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as populateSlugs, r as searchMemory } from "./search-PjftDxxs.mjs";
+
+//#region src/topics/detector.ts
+var detector_exports = /* @__PURE__ */ __exportAll({ detectTopicShift: () => detectTopicShift });
+/**
+* Detect whether the provided context text best matches a different project
+* than the session's current routing.
+*
+* Works with either a raw SQLite Database or a StorageBackend.
+* For the StorageBackend path, keyword search is used.
+* For the raw Database path (legacy/direct), searchMemory() is called.
+*/
+async function detectTopicShift(registryDb, federation, params) {
+	const threshold = params.threshold ?? .6;
+	const candidates = params.candidates ?? 20;
+	const currentProject = params.currentProject?.trim() || null;
+	if (!params.context || params.context.trim().length === 0) return {
+		shifted: false,
+		currentProject,
+		suggestedProject: null,
+		confidence: 0,
+		chunkCount: 0,
+		topProjects: []
+	};
+	let results;
+	const isBackend = (x) => "backendType" in x;
+	if (isBackend(federation)) results = await federation.searchKeyword(params.context, { maxResults: candidates });
+	else results = searchMemory(federation, params.context, { maxResults: candidates });
+	if (results.length === 0) return {
+		shifted: false,
+		currentProject,
+		suggestedProject: null,
+		confidence: 0,
+		chunkCount: 0,
+		topProjects: []
+	};
+	const withSlugs = populateSlugs(results, registryDb);
+	const projectScores = /* @__PURE__ */ new Map();
+	for (const r of withSlugs) {
+		const slug = r.projectSlug;
+		if (!slug) continue;
+		projectScores.set(slug, (projectScores.get(slug) ?? 0) + r.score);
+	}
+	if (projectScores.size === 0) return {
+		shifted: false,
+		currentProject,
+		suggestedProject: null,
+		confidence: 0,
+		chunkCount: withSlugs.length,
+		topProjects: []
+	};
+	const ranked = Array.from(projectScores.entries()).sort((a, b) => b[1] - a[1]);
+	const totalScore = ranked.reduce((sum, [, s]) => sum + s, 0);
+	const topProjects = ranked.slice(0, 3).map(([slug, score]) => ({
+		slug,
+		score: totalScore > 0 ? score / totalScore : 0
+	}));
+	const topSlug = ranked[0][0];
+	const topRawScore = ranked[0][1];
+	const confidence = totalScore > 0 ? topRawScore / totalScore : 0;
+	return {
+		shifted: currentProject !== null && topSlug !== currentProject && confidence >= threshold,
+		currentProject,
+		suggestedProject: topSlug,
+		confidence,
+		chunkCount: withSlugs.length,
+		topProjects
+	};
+}
+
+//#endregion
+export { detector_exports as n, detectTopicShift as t };
+//# sourceMappingURL=detector-DKA83aTZ.mjs.map

package/dist/detector-DKA83aTZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-DKA83aTZ.mjs","names":[],"sources":["../src/topics/detector.ts"],"sourcesContent":["/**\n * Topic shift detection engine.\n *\n * Accepts a context summary (recent conversation text) and determines whether\n * the conversation has drifted away from the currently-routed project.\n *\n * Algorithm:\n *   1. Run keyword memory_search against the context text (no project filter)\n *   2. Score results by project — sum of BM25 scores per project\n *   3. Compare the top-scoring project against the current project\n *   4. If a different project dominates by more than the confidence threshold,\n *      report a topic shift.\n *\n * Design decisions:\n *   - Keyword search only (no semantic) — fast, no embedding requirement\n *   - Works with or without an active daemon (direct DB access path)\n *   - Stateless: callers supply currentProject; detector has no session memory\n *   - Minimal: returns a plain result object, not MCP content arrays\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend } from \"../storage/interface.js\";\nimport { searchMemory, populateSlugs } from \"../memory/search.js\";\nimport type { SearchResult } from \"../memory/search.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface TopicCheckParams {\n  /** Recent conversation context (a few sentences or tool call summaries) */\n  context: string;\n  /** The project slug the session is currently routed to. May be null/empty. */\n  currentProject?: string;\n  /**\n   * Minimum confidence [0,1] to declare a shift. Default: 0.6.\n   * Higher = less sensitive, fewer false positives.\n   */\n  threshold?: number;\n  /**\n   * Maximum results to draw from memory search (candidates). Default: 20.\n   * More candidates = more accurate scoring, slightly slower.\n   */\n  candidates?: number;\n}\n\nexport interface TopicCheckResult {\n  /** Whether a significant topic shift was detected. */\n  shifted: boolean;\n  /** The project slug the session is currently routed to (echoed from input). */\n  currentProject: string | null;\n  /** The project slug that best matches the context, or null if no clear match. */\n  suggestedProject: string | null;\n  /**\n   * Confidence score for the suggested project [0,1].\n   * Represents the fraction of total score mass held by the top project.\n   * 1.0 = all matching chunks belong to one project.\n   * 0.5 = two projects are equally matched.\n   */\n  confidence: number;\n  /** Number of memory chunks that contributed to scoring. */\n  chunkCount: number;\n  /** Top-3 scoring projects with their normalised scores (for debugging). */\n  topProjects: Array<{ slug: string; score: number }>;\n}\n\n// ---------------------------------------------------------------------------\n// Core algorithm\n// ---------------------------------------------------------------------------\n\n/**\n * Detect whether the provided context text best matches a different project\n * than the session's current routing.\n *\n * Works with either a raw SQLite Database or a StorageBackend.\n * For the StorageBackend path, keyword search is used.\n * For the raw Database path (legacy/direct), searchMemory() is called.\n */\nexport async function detectTopicShift(\n  registryDb: Database,\n  federation: Database | StorageBackend,\n  params: TopicCheckParams\n): Promise<TopicCheckResult> {\n  const threshold = params.threshold ?? 0.6;\n  const candidates = params.candidates ?? 20;\n  const currentProject = params.currentProject?.trim() || null;\n\n  if (!params.context || params.context.trim().length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // -------------------------------------------------------------------------\n  // Run memory search across ALL projects (no project filter)\n  // -------------------------------------------------------------------------\n\n  let results: SearchResult[];\n\n  const isBackend = (x: Database | StorageBackend): x is StorageBackend =>\n    \"backendType\" in x;\n\n  if (isBackend(federation)) {\n    results = await federation.searchKeyword(params.context, {\n      maxResults: candidates,\n    });\n  } else {\n    results = searchMemory(federation, params.context, {\n      maxResults: candidates,\n    });\n  }\n\n  if (results.length === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: 0,\n      topProjects: [],\n    };\n  }\n\n  // Populate project slugs from the registry\n  const withSlugs = populateSlugs(results, registryDb);\n\n  // -------------------------------------------------------------------------\n  // Score projects by summing BM25 scores of matching chunks\n  // -------------------------------------------------------------------------\n\n  const projectScores = new Map<string, number>();\n\n  for (const r of withSlugs) {\n    const slug = r.projectSlug;\n    if (!slug) continue;\n    projectScores.set(slug, (projectScores.get(slug) ?? 0) + r.score);\n  }\n\n  if (projectScores.size === 0) {\n    return {\n      shifted: false,\n      currentProject,\n      suggestedProject: null,\n      confidence: 0,\n      chunkCount: withSlugs.length,\n      topProjects: [],\n    };\n  }\n\n  // Sort by total score descending\n  const ranked = Array.from(projectScores.entries())\n    .sort((a, b) => b[1] - a[1]);\n\n  const totalScore = ranked.reduce((sum, [, s]) => sum + s, 0);\n\n  // Top-3 for reporting (normalised to [0,1] fraction of total mass)\n  const topProjects = ranked.slice(0, 3).map(([slug, score]) => ({\n    slug,\n    score: totalScore > 0 ? score / totalScore : 0,\n  }));\n\n  const topSlug = ranked[0][0];\n  const topRawScore = ranked[0][1];\n  const confidence = totalScore > 0 ? topRawScore / totalScore : 0;\n\n  // -------------------------------------------------------------------------\n  // Determine if a shift occurred\n  // -------------------------------------------------------------------------\n\n  // A shift is detected when:\n  //   1. confidence >= threshold (the top project dominates)\n  //   2. The top project is different from currentProject\n  //   3. There is a currentProject to compare against\n  //      (if no current project, we still return the best match but no \"shift\")\n\n  const isDifferent =\n    currentProject !== null &&\n    topSlug !== currentProject;\n\n  const shifted = isDifferent && confidence >= threshold;\n\n  return {\n    shifted,\n    currentProject,\n    suggestedProject: topSlug,\n    confidence,\n    chunkCount: withSlugs.length,\n    topProjects,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AA8EA,eAAsB,iBACpB,YACA,YACA,QAC2B;CAC3B,MAAM,YAAY,OAAO,aAAa;CACtC,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,iBAAiB,OAAO,gBAAgB,MAAM,IAAI;AAExD,KAAI,CAAC,OAAO,WAAW,OAAO,QAAQ,MAAM,CAAC,WAAW,EACtD,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAOH,IAAI;CAEJ,MAAM,aAAa,MACjB,iBAAiB;AAEnB,KAAI,UAAU,WAAW,CACvB,WAAU,MAAM,WAAW,cAAc,OAAO,SAAS,EACvD,YAAY,YACb,CAAC;KAEF,WAAU,aAAa,YAAY,OAAO,SAAS,EACjD,YAAY,YACb,CAAC;AAGJ,KAAI,QAAQ,WAAW,EACrB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY;EACZ,aAAa,EAAE;EAChB;CAIH,MAAM,YAAY,cAAc,SAAS,WAAW;CAMpD,MAAM,gCAAgB,IAAI,KAAqB;AAE/C,MAAK,MAAM,KAAK,WAAW;EACzB,MAAM,OAAO,EAAE;AACf,MAAI,CAAC,KAAM;AACX,gBAAc,IAAI,OAAO,cAAc,IAAI,KAAK,IAAI,KAAK,EAAE,MAAM;;AAGnE,KAAI,cAAc,SAAS,EACzB,QAAO;EACL,SAAS;EACT;EACA,kBAAkB;EAClB,YAAY;EACZ,YAAY,UAAU;EACtB,aAAa,EAAE;EAChB;CAIH,MAAM,SAAS,MAAM,KAAK,cAAc,SAAS,CAAC,CAC/C,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG;CAE9B,MAAM,aAAa,OAAO,QAAQ,KAAK,GAAG,OAAO,MAAM,GAAG,EAAE;CAG5D,MAAM,cAAc,OAAO,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,YAAY;EAC7D;EACA,OAAO,aAAa,IAAI,QAAQ,aAAa;EAC9C,EAAE;CAEH,MAAM,UAAU,OAAO,GAAG;CAC1B,MAAM,cAAc,OAAO,GAAG;CAC9B,MAAM,aAAa,aAAa,IAAI,cAAc,aAAa;AAkB/D,QAAO;EACL,SANA,mBAAmB,QACnB,YAAY,kBAEiB,cAAc;EAI3C;EACA,kBAAkB;EAClB;EACA,YAAY,UAAU;EACtB;EACD"}

package/dist/embeddings-mfqv-jFu.mjs

@@ -0,0 +1,91 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/memory/embeddings.ts
+var embeddings_exports = /* @__PURE__ */ __exportAll({
+	configureEmbeddingModel: () => configureEmbeddingModel,
+	cosineSimilarity: () => cosineSimilarity,
+	deserializeEmbedding: () => deserializeEmbedding,
+	generateEmbedding: () => generateEmbedding,
+	serializeEmbedding: () => serializeEmbedding
+});
+const DEFAULT_EMBEDDING_MODEL = "Snowflake/snowflake-arctic-embed-m-v1.5";
+/** Query prefix required by Snowflake Arctic Embed for retrieval tasks. */
+const QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
+let _embeddingPipeline = null;
+let _currentModel = null;
+/**
+* Configure the embedding model to use.
+* Must be called before the first generateEmbedding() call.
+* If the pipeline is already loaded with a different model, it will be reloaded.
+*
+* @param model  HuggingFace model ID (e.g. "Snowflake/snowflake-arctic-embed-m-v1.5").
+*               Pass undefined or empty string to use the default model.
+*/
+function configureEmbeddingModel(model) {
+	const resolved = model?.trim() || DEFAULT_EMBEDDING_MODEL;
+	if (_currentModel !== null && _currentModel !== resolved) _embeddingPipeline = null;
+	_currentModel = resolved;
+}
+async function getEmbedder() {
+	const model = _currentModel ?? DEFAULT_EMBEDDING_MODEL;
+	if (!_embeddingPipeline) {
+		const { pipeline } = await import("@huggingface/transformers");
+		_embeddingPipeline = await pipeline("feature-extraction", model, { dtype: "q8" });
+	}
+	return _embeddingPipeline;
+}
+/**
+* Generate a normalized 768-dim embedding for the given text.
+*
+* Uses CLS pooling (first token) and L2 normalization (cosine similarity ready).
+*
+* @param text     The text to embed.
+* @param isQuery  If true, prepend the Snowflake query prefix. Use for search queries.
+*                 Documents should be embedded without the prefix (default: false).
+*/
+async function generateEmbedding(text, isQuery = false) {
+	const input = (isQuery ? QUERY_PREFIX : "") + text;
+	const output = await (await getEmbedder())(input, {
+		pooling: "cls",
+		normalize: true
+	});
+	return new Float32Array(output.data);
+}
+/**
+* Serialize a Float32Array to a Buffer for storage in a SQLite BLOB column.
+*/
+function serializeEmbedding(vec) {
+	return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+/**
+* Deserialize a Buffer (from a SQLite BLOB column) back into a Float32Array.
+*/
+function deserializeEmbedding(blob) {
+	return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+}
+/**
+* Compute cosine similarity between two normalized embedding vectors.
+*
+* Since both vectors are already L2-normalized by the embedding model,
+* cosine similarity reduces to a dot product — but we compute the full
+* formula for correctness when embeddings may not be pre-normalized.
+*
+* Returns a value in [-1, 1] where 1 = identical.
+*/
+function cosineSimilarity(a, b) {
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let i = 0; i < a.length; i++) {
+		dot += a[i] * b[i];
+		normA += a[i] * a[i];
+		normB += b[i] * b[i];
+	}
+	const denom = Math.sqrt(normA) * Math.sqrt(normB);
+	if (denom === 0) return 0;
+	return dot / denom;
+}
+
+//#endregion
+export { embeddings_exports as i, cosineSimilarity as n, deserializeEmbedding as r, configureEmbeddingModel as t };
+//# sourceMappingURL=embeddings-mfqv-jFu.mjs.map

package/dist/embeddings-mfqv-jFu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings-mfqv-jFu.mjs","names":[],"sources":["../src/memory/embeddings.ts"],"sourcesContent":["/**\n * Embedding generation for the PAI federation memory engine (Phase 2.5).\n *\n * Uses @huggingface/transformers with the Snowflake/snowflake-arctic-embed-m-v1.5 model\n * (768 dims, q8 quantization, MTEB strong retrieval quality).\n *\n * The model uses CLS pooling (first token) — NOT mean pooling.\n * For retrieval, queries require a prefix: \"Represent this sentence for searching relevant passages: \"\n * Documents should be embedded WITHOUT a prefix.\n *\n * The pipeline is a lazy singleton — loaded on first call, reused thereafter.\n * This avoids loading the heavy ML model on every CLI invocation.\n */\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\nexport const EMBEDDING_DIM = 768;\nconst DEFAULT_EMBEDDING_MODEL = \"Snowflake/snowflake-arctic-embed-m-v1.5\";\n\n/** Query prefix required by Snowflake Arctic Embed for retrieval tasks. */\nconst QUERY_PREFIX = \"Represent this sentence for searching relevant passages: \";\n\n// ---------------------------------------------------------------------------\n// Lazy pipeline singleton\n// ---------------------------------------------------------------------------\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nlet _embeddingPipeline: any = null;\nlet _currentModel: string | null = null;\n\n/**\n * Configure the embedding model to use.\n * Must be called before the first generateEmbedding() call.\n * If the pipeline is already loaded with a different model, it will be reloaded.\n *\n * @param model  HuggingFace model ID (e.g. \"Snowflake/snowflake-arctic-embed-m-v1.5\").\n *               Pass undefined or empty string to use the default model.\n */\nexport function configureEmbeddingModel(model?: string): void {\n  const resolved = model?.trim() || DEFAULT_EMBEDDING_MODEL;\n  if (_currentModel !== null && _currentModel !== resolved) {\n    // Model changed — force reload on next call\n    _embeddingPipeline = null;\n  }\n  _currentModel = resolved;\n}\n\nasync function getEmbedder() {\n  const model = _currentModel ?? DEFAULT_EMBEDDING_MODEL;\n  if (!_embeddingPipeline) {\n    // Dynamic import to avoid loading the ML runtime on startup\n    const { pipeline } = await import(\"@huggingface/transformers\");\n    _embeddingPipeline = await pipeline(\n      \"feature-extraction\",\n      model,\n      { dtype: \"q8\" },\n    );\n  }\n  return _embeddingPipeline;\n}\n\n// ---------------------------------------------------------------------------\n// Embedding generation\n// ---------------------------------------------------------------------------\n\n/**\n * Generate a normalized 768-dim embedding for the given text.\n *\n * Uses CLS pooling (first token) and L2 normalization (cosine similarity ready).\n *\n * @param text     The text to embed.\n * @param isQuery  If true, prepend the Snowflake query prefix. Use for search queries.\n *                 Documents should be embedded without the prefix (default: false).\n */\nexport async function generateEmbedding(text: string, isQuery: boolean = false): Promise<Float32Array> {\n  const prefix = isQuery ? QUERY_PREFIX : \"\";\n  const input = prefix + text;\n  const extractor = await getEmbedder();\n  // Snowflake Arctic Embed uses CLS pooling (first token), not mean pooling\n  const output = await extractor(input, { pooling: \"cls\", normalize: true });\n  return new Float32Array(output.data);\n}\n\n// ---------------------------------------------------------------------------\n// Serialization helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Serialize a Float32Array to a Buffer for storage in a SQLite BLOB column.\n */\nexport function serializeEmbedding(vec: Float32Array): Buffer {\n  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);\n}\n\n/**\n * Deserialize a Buffer (from a SQLite BLOB column) back into a Float32Array.\n */\nexport function deserializeEmbedding(blob: Buffer): Float32Array {\n  return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);\n}\n\n// ---------------------------------------------------------------------------\n// Similarity computation\n// ---------------------------------------------------------------------------\n\n/**\n * Compute cosine similarity between two normalized embedding vectors.\n *\n * Since both vectors are already L2-normalized by the embedding model,\n * cosine similarity reduces to a dot product — but we compute the full\n * formula for correctness when embeddings may not be pre-normalized.\n *\n * Returns a value in [-1, 1] where 1 = identical.\n */\nexport function cosineSimilarity(a: Float32Array, b: Float32Array): number {\n  let dot = 0;\n  let normA = 0;\n  let normB = 0;\n  for (let i = 0; i < a.length; i++) {\n    dot += a[i] * b[i];\n    normA += a[i] * a[i];\n    normB += b[i] * b[i];\n  }\n  const denom = Math.sqrt(normA) * Math.sqrt(normB);\n  if (denom === 0) return 0;\n  return dot / denom;\n}\n"],"mappings":";;;;;;;;;;AAmBA,MAAM,0BAA0B;;AAGhC,MAAM,eAAe;AAOrB,IAAI,qBAA0B;AAC9B,IAAI,gBAA+B;;;;;;;;;AAUnC,SAAgB,wBAAwB,OAAsB;CAC5D,MAAM,WAAW,OAAO,MAAM,IAAI;AAClC,KAAI,kBAAkB,QAAQ,kBAAkB,SAE9C,sBAAqB;AAEvB,iBAAgB;;AAGlB,eAAe,cAAc;CAC3B,MAAM,QAAQ,iBAAiB;AAC/B,KAAI,CAAC,oBAAoB;EAEvB,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,uBAAqB,MAAM,SACzB,sBACA,OACA,EAAE,OAAO,MAAM,CAChB;;AAEH,QAAO;;;;;;;;;;;AAgBT,eAAsB,kBAAkB,MAAc,UAAmB,OAA8B;CAErG,MAAM,SADS,UAAU,eAAe,MACjB;CAGvB,MAAM,SAAS,OAFG,MAAM,aAAa,EAEN,OAAO;EAAE,SAAS;EAAO,WAAW;EAAM,CAAC;AAC1E,QAAO,IAAI,aAAa,OAAO,KAAK;;;;;AAUtC,SAAgB,mBAAmB,KAA2B;AAC5D,QAAO,OAAO,KAAK,IAAI,QAAQ,IAAI,YAAY,IAAI,WAAW;;;;;AAMhE,SAAgB,qBAAqB,MAA4B;AAC/D,QAAO,IAAI,aAAa,KAAK,QAAQ,KAAK,YAAY,KAAK,aAAa,EAAE;;;;;;;;;;;AAgB5E,SAAgB,iBAAiB,GAAiB,GAAyB;CACzE,IAAI,MAAM;CACV,IAAI,QAAQ;CACZ,IAAI,QAAQ;AACZ,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,SAAO,EAAE,KAAK,EAAE;AAChB,WAAS,EAAE,KAAK,EAAE;AAClB,WAAS,EAAE,KAAK,EAAE;;CAEpB,MAAM,QAAQ,KAAK,KAAK,MAAM,GAAG,KAAK,KAAK,MAAM;AACjD,KAAI,UAAU,EAAG,QAAO;AACxB,QAAO,MAAM"}

package/dist/factory-BDAiKtYR.mjs

@@ -0,0 +1,42 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/storage/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({ createStorageBackend: () => createStorageBackend });
+/**
+* Create and return the configured StorageBackend.
+*
+* Auto-fallback behaviour:
+*  - storageBackend = "sqlite"   → SQLiteBackend always
+*  - storageBackend = "postgres" → PostgresBackend if reachable, else SQLiteBackend
+*/
+async function createStorageBackend(config) {
+	if (config.storageBackend === "postgres") return await tryPostgres(config);
+	return createSQLiteBackend();
+}
+async function tryPostgres(config) {
+	try {
+		const { PostgresBackend } = await import("./postgres-Ccvpc6fC.mjs");
+		const backend = new PostgresBackend(config.postgres ?? {});
+		const err = await backend.testConnection();
+		if (err) {
+			process.stderr.write(`[pai-daemon] Postgres unavailable (${err}). Falling back to SQLite.\n`);
+			await backend.close();
+			return createSQLiteBackend();
+		}
+		process.stderr.write("[pai-daemon] Connected to PostgreSQL backend.\n");
+		return backend;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Postgres init error (${msg}). Falling back to SQLite.\n`);
+		return createSQLiteBackend();
+	}
+}
+async function createSQLiteBackend() {
+	const { openFederation } = await import("./db-BcDxXVBu.mjs").then((n) => n.t);
+	const { SQLiteBackend } = await import("./sqlite-CHUrNtbI.mjs");
+	return new SQLiteBackend(openFederation());
+}
+
+//#endregion
+export { factory_exports as n, createStorageBackend as t };
+//# sourceMappingURL=factory-BDAiKtYR.mjs.map

package/dist/factory-BDAiKtYR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-BDAiKtYR.mjs","names":[],"sources":["../src/storage/factory.ts"],"sourcesContent":["/**\n * Storage backend factory.\n *\n * Reads the daemon config and returns the appropriate StorageBackend.\n * If Postgres is configured but unavailable, falls back to SQLite with\n * a warning log — the daemon never crashes due to a missing Postgres.\n */\n\nimport type { PaiDaemonConfig } from \"../daemon/config.js\";\nimport type { StorageBackend } from \"./interface.js\";\n\n/**\n * Create and return the configured StorageBackend.\n *\n * Auto-fallback behaviour:\n *  - storageBackend = \"sqlite\"   → SQLiteBackend always\n *  - storageBackend = \"postgres\" → PostgresBackend if reachable, else SQLiteBackend\n */\nexport async function createStorageBackend(\n  config: PaiDaemonConfig\n): Promise<StorageBackend> {\n  if (config.storageBackend === \"postgres\") {\n    return await tryPostgres(config);\n  }\n\n  // Default: SQLite\n  return createSQLiteBackend();\n}\n\nasync function tryPostgres(config: PaiDaemonConfig): Promise<StorageBackend> {\n  try {\n    const { PostgresBackend } = await import(\"./postgres.js\");\n    const pgConfig = config.postgres ?? {};\n    const backend = new PostgresBackend(pgConfig);\n\n    const err = await backend.testConnection();\n    if (err) {\n      process.stderr.write(\n        `[pai-daemon] Postgres unavailable (${err}). Falling back to SQLite.\\n`\n      );\n      await backend.close();\n      return createSQLiteBackend();\n    }\n\n    process.stderr.write(\"[pai-daemon] Connected to PostgreSQL backend.\\n\");\n    return backend;\n  } catch (e) {\n    const msg = e instanceof Error ? e.message : String(e);\n    process.stderr.write(\n      `[pai-daemon] Postgres init error (${msg}). Falling back to SQLite.\\n`\n    );\n    return createSQLiteBackend();\n  }\n}\n\nasync function createSQLiteBackend(): Promise<StorageBackend> {\n  const { openFederation } = await import(\"../memory/db.js\");\n  const { SQLiteBackend } = await import(\"./sqlite.js\");\n  const db = openFederation();\n  return new SQLiteBackend(db);\n}\n"],"mappings":";;;;;;;;;;;AAkBA,eAAsB,qBACpB,QACyB;AACzB,KAAI,OAAO,mBAAmB,WAC5B,QAAO,MAAM,YAAY,OAAO;AAIlC,QAAO,qBAAqB;;AAG9B,eAAe,YAAY,QAAkD;AAC3E,KAAI;EACF,MAAM,EAAE,oBAAoB,MAAM,OAAO;EAEzC,MAAM,UAAU,IAAI,gBADH,OAAO,YAAY,EAAE,CACO;EAE7C,MAAM,MAAM,MAAM,QAAQ,gBAAgB;AAC1C,MAAI,KAAK;AACP,WAAQ,OAAO,MACb,sCAAsC,IAAI,8BAC3C;AACD,SAAM,QAAQ,OAAO;AACrB,UAAO,qBAAqB;;AAG9B,UAAQ,OAAO,MAAM,kDAAkD;AACvE,SAAO;UACA,GAAG;EACV,MAAM,MAAM,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE;AACtD,UAAQ,OAAO,MACb,qCAAqC,IAAI,8BAC1C;AACD,SAAO,qBAAqB;;;AAIhC,eAAe,sBAA+C;CAC5D,MAAM,EAAE,mBAAmB,MAAM,OAAO;CACxC,MAAM,EAAE,kBAAkB,MAAM,OAAO;AAEvC,QAAO,IAAI,cADA,gBAAgB,CACC"}

package/dist/index.d.mts

@@ -0,0 +1,307 @@
+import { Database, Database as Database$1, Database as Database$2 } from "better-sqlite3";
+
+//#region src/registry/schema.d.ts
+declare const SCHEMA_VERSION = 3;
+declare const CREATE_TABLES_SQL = "\nPRAGMA journal_mode = WAL;\nPRAGMA foreign_keys = ON;\n\nCREATE TABLE IF NOT EXISTS projects (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  slug          TEXT    NOT NULL UNIQUE,\n  display_name  TEXT    NOT NULL,\n  root_path     TEXT    NOT NULL UNIQUE,\n  encoded_dir   TEXT    NOT NULL UNIQUE,\n  type          TEXT    NOT NULL DEFAULT 'local'\n                        CHECK(type IN ('local','central','obsidian-linked','external')),\n  status        TEXT    NOT NULL DEFAULT 'active'\n                        CHECK(status IN ('active','archived','migrating')),\n  parent_id       INTEGER,\n  obsidian_link   TEXT,\n  claude_notes_dir TEXT,\n  created_at      INTEGER NOT NULL,\n  updated_at      INTEGER NOT NULL,\n  archived_at     INTEGER,\n  FOREIGN KEY (parent_id) REFERENCES projects(id)\n);\n\nCREATE TABLE IF NOT EXISTS sessions (\n  id                INTEGER PRIMARY KEY AUTOINCREMENT,\n  project_id        INTEGER NOT NULL,\n  number            INTEGER NOT NULL,\n  date              TEXT    NOT NULL,\n  slug              TEXT    NOT NULL,\n  title             TEXT    NOT NULL,\n  filename          TEXT    NOT NULL,\n  status            TEXT    NOT NULL DEFAULT 'open'\n                            CHECK(status IN ('open','completed','compacted')),\n  claude_session_id TEXT,\n  token_count       INTEGER,\n  created_at        INTEGER NOT NULL,\n  closed_at         INTEGER,\n  UNIQUE (project_id, number),\n  FOREIGN KEY (project_id) REFERENCES projects(id)\n);\n\nCREATE TABLE IF NOT EXISTS tags (\n  id   INTEGER PRIMARY KEY AUTOINCREMENT,\n  name TEXT    NOT NULL UNIQUE\n);\n\nCREATE TABLE IF NOT EXISTS project_tags (\n  project_id INTEGER NOT NULL,\n  tag_id     INTEGER NOT NULL,\n  PRIMARY KEY (project_id, tag_id),\n  FOREIGN KEY (project_id) REFERENCES projects(id),\n  FOREIGN KEY (tag_id)     REFERENCES tags(id)\n);\n\nCREATE TABLE IF NOT EXISTS session_tags (\n  session_id INTEGER NOT NULL,\n  tag_id     INTEGER NOT NULL,\n  PRIMARY KEY (session_id, tag_id),\n  FOREIGN KEY (session_id) REFERENCES sessions(id),\n  FOREIGN KEY (tag_id)     REFERENCES tags(id)\n);\n\nCREATE TABLE IF NOT EXISTS aliases (\n  alias      TEXT    PRIMARY KEY,\n  project_id INTEGER NOT NULL,\n  FOREIGN KEY (project_id) REFERENCES projects(id)\n);\n\nCREATE TABLE IF NOT EXISTS compaction_log (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  project_id    INTEGER NOT NULL,\n  session_id    INTEGER,\n  trigger       TEXT    NOT NULL\n                        CHECK(trigger IN ('precompact','manual','end-session')),\n  files_written TEXT    NOT NULL,\n  token_count   INTEGER,\n  created_at    INTEGER NOT NULL,\n  FOREIGN KEY (project_id) REFERENCES projects(id),\n  FOREIGN KEY (session_id) REFERENCES sessions(id)\n);\n\nCREATE TABLE IF NOT EXISTS links (\n  id               INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id       INTEGER NOT NULL,\n  target_project_id INTEGER NOT NULL,\n  link_type        TEXT    NOT NULL DEFAULT 'related'\n                           CHECK(link_type IN ('related','follow-up','reference')),\n  created_at       INTEGER NOT NULL,\n  UNIQUE (session_id, target_project_id),\n  FOREIGN KEY (session_id)        REFERENCES sessions(id),\n  FOREIGN KEY (target_project_id) REFERENCES projects(id)\n);\n\nCREATE TABLE IF NOT EXISTS schema_version (\n  version    INTEGER PRIMARY KEY,\n  applied_at INTEGER NOT NULL\n);\n\n-- Indexes\nCREATE INDEX IF NOT EXISTS idx_projects_slug    ON projects(slug);\nCREATE INDEX IF NOT EXISTS idx_projects_status  ON projects(status);\nCREATE INDEX IF NOT EXISTS idx_projects_type    ON projects(type);\nCREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);\nCREATE INDEX IF NOT EXISTS idx_sessions_date    ON sessions(date);\nCREATE INDEX IF NOT EXISTS idx_sessions_status  ON sessions(status);\nCREATE INDEX IF NOT EXISTS idx_sessions_claude  ON sessions(claude_session_id);\nCREATE INDEX IF NOT EXISTS idx_pc_project       ON project_tags(project_id);\n";
+/**
+ * Run the full DDL against an open database connection.
+ *
+ * The function is idempotent — every statement uses IF NOT EXISTS so it is
+ * safe to call on an already-initialised database.  After creating the tables
+ * it inserts the current SCHEMA_VERSION into schema_version if no row exists
+ * yet.
+ */
+declare function initializeSchema(db: Database): void;
+//#endregion
+//#region src/registry/db.d.ts
+/**
+ * Open (or create) the PAI registry database.
+ *
+ * @param path  Absolute path to registry.db.  Defaults to ~/.pai/registry.db.
+ * @returns     An open better-sqlite3 Database instance.
+ *
+ * Side effects on first call:
+ *  - Creates the parent directory if it does not exist.
+ *  - Enables WAL journal mode.
+ *  - Runs initializeSchema() if schema_version is empty.
+ */
+declare function openRegistry(path?: string): Database$2;
+//#endregion
+//#region src/registry/migrate.d.ts
+/**
+ * Reverse Claude Code's directory encoding.
+ *
+ * Claude Code's actual encoding rules:
+ *   - `/` (path separator) → `-`
+ *   - ` ` (space)          → `--`  (escaped)
+ *   - `.` (dot)            → `--`  (escaped)
+ *   - `-` (literal hyphen) → `--`  (escaped)
+ *
+ * Because space, dot, and hyphen all encode to `--`, the encoding is
+ * **lossy** — you cannot unambiguously reverse it.  This function therefore
+ * provides a *best-effort* heuristic decode (treating `--` as a literal `-`
+ * which gives wrong results for paths with spaces or dots).
+ *
+ * PREFER using {@link buildEncodedDirMap} to get the authoritative mapping
+ * from session-registry.json instead of calling this function directly.
+ *
+ * Examples (best-effort, may be wrong for paths with spaces/dots):
+ *   `-Users-alice-dev-apps-MyProject` → `/Users/alice/dev/apps/MyProject`
+ *   `-Users-alice--ssh`               → `/Users/alice/-ssh` ← WRONG (actually .ssh)
+ *
+ * @param encoded   The Claude-encoded directory name.
+ * @param lookupMap Optional authoritative map from {@link buildEncodedDirMap}.
+ *                  If provided and the key is found, that value is returned
+ *                  instead of the heuristic result.
+ */
+declare function decodeEncodedDir(encoded: string, lookupMap?: Map<string, string>): string;
+/**
+ * Derive a URL-safe kebab-case slug from an arbitrary string.
+ *
+ * Uses the last path component so that `/Users/alice/dev/my-app` → `my-app`.
+ */
+declare function slugify(value: string): string;
+interface ParsedSession {
+  number: number;
+  date: string;
+  slug: string;
+  title: string;
+  filename: string;
+}
+/**
+ * Attempt to parse a session note filename into its structured parts.
+ *
+ * Returns `null` if the filename does not match either known format.
+ */
+declare function parseSessionFilename(filename: string): ParsedSession | null;
+interface MigrationResult {
+  projectsInserted: number;
+  projectsSkipped: number;
+  sessionsInserted: number;
+  errors: string[];
+}
+/**
+ * Migrate the existing JSON session-registry into the SQLite registry.
+ *
+ * @param db            Open better-sqlite3 Database (target).
+ * @param registryPath  Path to session-registry.json.
+ *                      Defaults to ~/.claude/session-registry.json.
+ *
+ * The migration is idempotent: projects and sessions that already exist
+ * (matched by slug / project_id+number) are silently skipped.
+ */
+declare function migrateFromJson(db: Database, registryPath?: string): MigrationResult;
+//#endregion
+//#region src/registry/pai-marker.d.ts
+/**
+ * PAI.md marker file management.
+ *
+ * Each registered project gets a `Notes/PAI.md` file with a YAML frontmatter
+ * `pai:` block that PAI manages.  The rest of the file (body content, other
+ * frontmatter keys) is user-owned and never modified by PAI.
+ *
+ * YAML parsing/updating is done with simple regex — no external dependency.
+ */
+interface PaiMarker {
+  /** Absolute path to the PAI.md file */
+  path: string;
+  /** The `slug` value from the `pai:` frontmatter block */
+  slug: string;
+  /** Absolute path to the project root (parent of Notes/) */
+  projectRoot: string;
+}
+/**
+ * Create or update `<projectRoot>/Notes/PAI.md`.
+ *
+ * - File absent: creates `Notes/` if needed, writes from template.
+ * - File present: updates only the `pai:` frontmatter block; body and all
+ *   other frontmatter keys are preserved verbatim.
+ *
+ * @param projectRoot  Absolute path to the project root directory.
+ * @param slug         PAI slug for this project.
+ * @param displayName  Human-readable name (defaults to slug if omitted).
+ */
+declare function ensurePaiMarker(projectRoot: string, slug: string, displayName?: string): void;
+/**
+ * Read PAI marker data from `<projectRoot>/Notes/PAI.md`.
+ * Returns null if the file does not exist or contains no `pai:` block.
+ */
+declare function readPaiMarker(projectRoot: string): {
+  slug: string;
+  registered: string;
+  status: string;
+} | null;
+/**
+ * Scan a list of parent directories for `<child>/Notes/PAI.md` marker files.
+ * Each directory in `searchDirs` is scanned one level deep — its immediate
+ * child directories are checked for a `Notes/PAI.md` file.
+ *
+ * Returns an array of PaiMarker objects for every valid marker found.
+ * Invalid or malformed markers are silently skipped.
+ *
+ * @param searchDirs  Absolute paths to parent directories.
+ */
+declare function discoverPaiMarkers(searchDirs: string[]): PaiMarker[];
+//#endregion
+//#region src/memory/schema.d.ts
+declare const FEDERATION_SCHEMA_SQL = "\nPRAGMA journal_mode = WAL;\nPRAGMA foreign_keys = ON;\n\nCREATE TABLE IF NOT EXISTS memory_files (\n  project_id   INTEGER NOT NULL,\n  path         TEXT    NOT NULL,\n  source       TEXT    NOT NULL DEFAULT 'memory',\n  tier         TEXT    NOT NULL DEFAULT 'topic',\n  hash         TEXT    NOT NULL,\n  mtime        INTEGER NOT NULL,\n  size         INTEGER NOT NULL,\n  PRIMARY KEY (project_id, path)\n);\n\nCREATE TABLE IF NOT EXISTS memory_chunks (\n  id           TEXT    PRIMARY KEY,\n  project_id   INTEGER NOT NULL,\n  source       TEXT    NOT NULL DEFAULT 'memory',\n  tier         TEXT    NOT NULL DEFAULT 'topic',\n  path         TEXT    NOT NULL,\n  start_line   INTEGER NOT NULL,\n  end_line     INTEGER NOT NULL,\n  hash         TEXT    NOT NULL,\n  text         TEXT    NOT NULL,\n  updated_at   INTEGER NOT NULL,\n  embedding    BLOB\n);\n\nCREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(\n  text,\n  id UNINDEXED,\n  project_id UNINDEXED,\n  path UNINDEXED,\n  source UNINDEXED,\n  tier UNINDEXED,\n  start_line UNINDEXED,\n  end_line UNINDEXED\n);\n\nCREATE INDEX IF NOT EXISTS idx_mc_project ON memory_chunks(project_id);\nCREATE INDEX IF NOT EXISTS idx_mc_source  ON memory_chunks(project_id, source);\nCREATE INDEX IF NOT EXISTS idx_mc_tier    ON memory_chunks(tier);\nCREATE INDEX IF NOT EXISTS idx_mf_project ON memory_files(project_id);\n";
+/**
+ * Apply the full federation schema to an open database.
+ *
+ * Idempotent — all statements use IF NOT EXISTS so calling this on an
+ * already-initialised database is safe.
+ *
+ * Also runs any necessary migrations for existing databases (e.g. adding the
+ * embedding column to an older schema that was created without it).
+ */
+declare function initializeFederationSchema(db: Database): void;
+//#endregion
+//#region src/memory/db.d.ts
+/**
+ * Open (or create) the PAI federation database.
+ *
+ * @param path  Absolute path to federation.db.  Defaults to ~/.pai/federation.db.
+ * @returns     An open better-sqlite3 Database instance.
+ *
+ * Side effects on first call:
+ *  - Creates the parent directory if it does not exist.
+ *  - Enables WAL journal mode.
+ *  - Runs initializeFederationSchema() to ensure tables exist.
+ */
+declare function openFederation(path?: string): Database$1;
+//#endregion
+//#region src/memory/chunker.d.ts
+/**
+ * Markdown text chunker for the PAI memory engine.
+ *
+ * Splits markdown files into overlapping text segments suitable for BM25
+ * full-text indexing.  Respects heading boundaries where possible, falling
+ * back to paragraph and sentence splitting when sections are large.
+ */
+interface Chunk {
+  text: string;
+  startLine: number;
+  endLine: number;
+  hash: string;
+}
+interface ChunkOptions {
+  /** Approximate maximum tokens per chunk. Default 400. */
+  maxTokens?: number;
+  /** Overlap in tokens from the previous chunk. Default 80. */
+  overlap?: number;
+}
+/**
+ * Approximate token count using a words * 1.3 heuristic.
+ * Matches the OpenClaw estimate approach.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Chunk a markdown file into overlapping segments for BM25 indexing.
+ *
+ * Strategy:
+ *  1. Split by headings (##, ###) as natural boundaries.
+ *  2. If a section exceeds maxTokens, split by paragraphs.
+ *  3. If a paragraph still exceeds maxTokens, split by sentences.
+ *  4. Apply overlap: each chunk includes the last `overlap` tokens from the
+ *     previous chunk.
+ */
+declare function chunkMarkdown(content: string, opts?: ChunkOptions): Chunk[];
+//#endregion
+//#region src/memory/indexer.d.ts
+interface IndexResult {
+  filesProcessed: number;
+  chunksCreated: number;
+  filesSkipped: number;
+}
+/**
+ * Classify a relative file path into one of the four memory tiers.
+ *
+ * Rules (in priority order):
+ *  - MEMORY.md anywhere in memory/  → 'evergreen'
+ *  - YYYY-MM-DD.md in memory/       → 'daily'
+ *  - anything else in memory/       → 'topic'
+ *  - anything in Notes/             → 'session'
+ */
+declare function detectTier(relativePath: string): "evergreen" | "daily" | "topic" | "session";
+/**
+ * Index a single file into the federation database.
+ *
+ * @returns true if the file was re-indexed (changed or new), false if skipped.
+ */
+declare function indexFile(db: Database, projectId: number, rootPath: string, relativePath: string, source: string, tier: string): boolean;
+declare function indexProject(db: Database, projectId: number, rootPath: string, claudeNotesDir?: string | null): Promise<IndexResult>;
+/**
+ * Index all active projects registered in the registry DB.
+ *
+ * Async: yields to the event loop between each project so that the daemon's
+ * Unix socket server can process IPC requests (e.g. status) while indexing.
+ */
+declare function indexAll(db: Database, registryDb: Database): Promise<{
+  projects: number;
+  result: IndexResult;
+}>;
+//#endregion
+//#region src/memory/search.d.ts
+interface SearchResult {
+  projectId: number;
+  projectSlug?: string;
+  path: string;
+  startLine: number;
+  endLine: number;
+  snippet: string;
+  score: number;
+  tier: string;
+  source: string;
+}
+interface SearchOptions {
+  /** Restrict search to these project IDs. */
+  projectIds?: number[];
+  /** Restrict to 'memory' or 'notes' sources. */
+  sources?: string[];
+  /** Restrict to specific tier(s): 'evergreen' | 'daily' | 'topic' | 'session' */
+  tiers?: string[];
+  /** Maximum number of results to return. Default 10. */
+  maxResults?: number;
+  /** Minimum BM25 score threshold (FTS5 scores are negative; 0.0 means no filter). */
+  minScore?: number;
+}
+/**
+ * Convert a free-text query into an FTS5 query string.
+ *
+ * Strategy:
+ *  1. Tokenise by whitespace and punctuation
+ *  2. Remove stop words and tokens shorter than 2 characters
+ *  3. Double-quote each remaining token (exact word form)
+ *  4. Join with OR so that any matching token returns a result
+ *
+ * Using OR instead of AND is critical for multi-word queries: the words rarely
+ * all appear in the same chunk, so AND would return zero results.  FTS5 BM25
+ * scoring naturally ranks chunks where more terms match higher, so the most
+ * relevant chunks still surface at the top.
+ *
+ * Example: "Synchrotech interview follow-up Gilles"
+ *   → `"synchrotech" OR "interview" OR "follow" OR "gilles"`
+ *   → chunks matching any term, ranked by how many terms match
+ */
+declare function buildFtsQuery(query: string): string;
+/**
+ * Search across all indexed memory using FTS5 BM25 ranking.
+ *
+ * Results are ordered by BM25 score (most relevant first).
+ * FTS5 bm25() returns negative values; closer to 0 = more relevant.
+ * We negate the score so callers get positive values where higher = better.
+ *
+ * Multilingual note: SQLite FTS5 uses the `unicode61` tokenizer by default,
+ * which handles Unicode correctly (German umlauts, French accents, etc.) without
+ * language-specific stemming. No changes needed here — it is already
+ * multilingual-safe.
+ */
+declare function searchMemory(db: Database, query: string, opts?: SearchOptions): SearchResult[];
+/**
+ * Populate the projectSlug field on search results by looking up project IDs
+ * in the registry database.
+ */
+declare function populateSlugs(results: SearchResult[], registryDb: Database): SearchResult[];
+//#endregion
+export { CREATE_TABLES_SQL, type Chunk, type ChunkOptions, FEDERATION_SCHEMA_SQL, type IndexResult, type MigrationResult, type PaiMarker, SCHEMA_VERSION, type SearchOptions, type SearchResult, buildFtsQuery, chunkMarkdown, decodeEncodedDir, detectTier, discoverPaiMarkers, ensurePaiMarker, estimateTokens, indexAll, indexFile, indexProject, initializeFederationSchema, initializeSchema, migrateFromJson, openFederation, openRegistry, parseSessionFilename, populateSlugs, readPaiMarker, searchMemory, slugify };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/registry/schema.ts","../src/registry/db.ts","../src/registry/migrate.ts","../src/registry/pai-marker.ts","../src/memory/schema.ts","../src/memory/db.ts","../src/memory/chunker.ts","../src/memory/indexer.ts","../src/memory/search.ts"],"mappings":";;;cAgBa,cAAA;AAAA,cAEA,iBAAA;;;;;;ACYb;;;iBDyGgB,gBAAA,CAAiB,EAAA,EAAI,QAAA;;;AArHrC;;;;;AAqHA;;;;;;AArHA,iBCYgB,YAAA,CAAa,IAAA,YAAuC,UAAA;;;;;;;AC0HpE;;;;;AAUC;;;;;;;;;;;AAyBD;;;;;AAmCA;iBArGgB,gBAAA,CACd,OAAA,UACA,SAAA,GAAY,GAAA;;;;;;iBA6BE,OAAA,CAAQ,KAAA;AAAA,UAgBd,aAAA;EACR,MAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;EACA,QAAA;AAAA;;;;;;iBAcc,oBAAA,CACd,QAAA,WACC,aAAA;AAAA,UAiCc,eAAA;EACf,gBAAA;EACA,eAAA;EACA,gBAAA;EACA,MAAA;AAAA;;;;;;AClDF;;;;;iBD+DgB,eAAA,CACd,EAAA,EAAI,QAAA,EACJ,YAAA,YACC,eAAA;;;;;;AFlOH;;;;;AAEA;UGMiB,SAAA;;EAEf,IAAA;EHR4B;EGU5B,IAAA;EH2G8B;EGzG9B,WAAA;AAAA;;;;;AFAF;;;;;;;iBEkJgB,eAAA,CACd,WAAA,UACA,IAAA,UACA,WAAA;AD1DF;;;;AAAA,iBC2HgB,aAAA,CACd,WAAA;EACG,IAAA;EAAc,UAAA;EAAoB,MAAA;AAAA;AD9FvC;;;;;AAUC;;;;;AAVD,iBC2HgB,kBAAA,CAAmB,UAAA,aAAuB,SAAA;;;cC7P7C,qBAAA;;AHQb;;;;;;;;iBG+CgB,0BAAA,CAA2B,EAAA,EAAI,QAAA;;;AJ3D/C;;;;;AAqHA;;;;;;AArHA,iBKYgB,cAAA,CAAe,IAAA,YAAyC,UAAA;;;;;;ALdxE;;;;UMNiB,KAAA;EACf,IAAA;EACA,SAAA;EACA,OAAA;EACA,IAAA;AAAA;AAAA,UAGe,YAAA;ENsHe;EMpH9B,SAAA;ENoHmC;EMlHnC,OAAA;AAAA;;;ALSF;;iBKCgB,cAAA,CAAe,IAAA;;;;;;AJ0F/B;;;;;iBIoFgB,aAAA,CAAc,OAAA,UAAiB,IAAA,GAAO,YAAA,GAAe,KAAA;;;UCrLpD,WAAA;EACf,cAAA;EACA,aAAA;EACA,YAAA;AAAA;;;;ANGF;;;;;;iBMagB,UAAA,CACd,YAAA;;AL6EF;;;;iBKVgB,SAAA,CACd,EAAA,EAAI,QAAA,EACJ,SAAA,UACA,QAAA,UACA,YAAA,UACA,MAAA,UACA,IAAA;AAAA,iBA6UoB,YAAA,CACpB,EAAA,EAAI,QAAA,EACJ,SAAA,UACA,QAAA,UACA,cAAA,mBACC,OAAA,CAAQ,WAAA;;;;AL/SX;;;iBKuesB,QAAA,CACpB,EAAA,EAAI,QAAA,EACJ,UAAA,EAAY,QAAA,GACX,OAAA;EAAU,QAAA;EAAkB,MAAA,EAAQ,WAAA;AAAA;;;UC/mBtB,YAAA;EACf,SAAA;EACA,WAAA;EACA,IAAA;EACA,SAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA;EACA,MAAA;AAAA;AAAA,UAGe,aAAA;EPDY;EOG3B,UAAA;;EAEA,OAAA;;EAEA,KAAA;ENoF8B;EMlF9B,UAAA;ENoFe;EMlFf,QAAA;AAAA;;;;AN+GF;;;;;AAUC;;;;;;;;;;iBMnFe,aAAA,CAAc,KAAA;AN4G9B;;;;;AAmCA;;;;;;;AAnCA,iBM1EgB,YAAA,CACd,EAAA,EAAI,QAAA,EACJ,KAAA,UACA,IAAA,GAAO,aAAA,GACN,YAAA;AL2DH;;;;AAAA,iBKwNgB,aAAA,CACd,OAAA,EAAS,YAAA,IACT,UAAA,EAAY,QAAA,GACX,YAAA"}

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { a as initializeSchema, i as SCHEMA_VERSION, n as openRegistry, r as CREATE_TABLES_SQL } from "./db-4lSqLFb8.mjs";
+import { a as slugify, i as parseSessionFilename, n as decodeEncodedDir, r as migrateFromJson } from "./migrate-Bwj7qPaE.mjs";
+import { n as ensurePaiMarker, r as readPaiMarker, t as discoverPaiMarkers } from "./pai-marker-DX_mFLum.mjs";
+import { i as initializeFederationSchema, n as openFederation, r as FEDERATION_SCHEMA_SQL } from "./db-BcDxXVBu.mjs";
+import { a as indexProject, i as indexFile, o as chunkMarkdown, r as indexAll, s as estimateTokens, t as detectTier } from "./indexer-B20bPHL-.mjs";
+import "./embeddings-mfqv-jFu.mjs";
+import { n as populateSlugs, r as searchMemory, t as buildFtsQuery } from "./search-PjftDxxs.mjs";
+import "./tools-CLK4080-.mjs";
+import "./mcp/index.mjs";
+
+export { CREATE_TABLES_SQL, FEDERATION_SCHEMA_SQL, SCHEMA_VERSION, buildFtsQuery, chunkMarkdown, decodeEncodedDir, detectTier, discoverPaiMarkers, ensurePaiMarker, estimateTokens, indexAll, indexFile, indexProject, initializeFederationSchema, initializeSchema, migrateFromJson, openFederation, openRegistry, parseSessionFilename, populateSlugs, readPaiMarker, searchMemory, slugify };