@agenr/agenr-plugin 1.7.4 → 1.8.0

package/dist/chunk-NIQKTINU.js

@@ -1,2545 +0,0 @@
-import {
-  buildLexicalPlan,
-  cosineSimilarity
-} from "./chunk-7WL5EAQZ.js";
-
-// src/adapters/db/client.ts
-import fs from "fs/promises";
-import path from "path";
-import { createClient } from "@libsql/client";
-
-// src/adapters/db/episode-queries.ts
-import { createHash, randomUUID } from "crypto";
-
-// src/adapters/db/row-mapping.ts
-var DEFAULT_QUALITY_SCORE = 0.5;
-var ACTIVE_ENTRY_CLAUSE = "retired = 0 AND superseded_by IS NULL";
-var ACTIVE_EPISODE_CLAUSE = "retired = 0 AND superseded_by IS NULL";
-function buildActiveEntryClause(alias) {
-  if (!alias) {
-    return ACTIVE_ENTRY_CLAUSE;
-  }
-  return `${alias}.retired = 0 AND ${alias}.superseded_by IS NULL`;
-}
-function buildActiveEpisodeClause(alias) {
-  if (!alias) {
-    return ACTIVE_EPISODE_CLAUSE;
-  }
-  return `${alias}.retired = 0 AND ${alias}.superseded_by IS NULL`;
-}
-function serializeEmbeddingForVector(embedding) {
-  if (embedding.length === 0) {
-    return null;
-  }
-  return JSON.stringify(embedding.map((value) => Number.isFinite(value) ? value : 0));
-}
-function serializeTags(tags) {
-  const normalizedTags = tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-  return JSON.stringify(normalizedTags);
-}
-function deserializeTags(value) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    return [];
-  }
-  const normalized = value.trim();
-  if (normalized.startsWith("|") && normalized.endsWith("|")) {
-    return normalized.slice(1, -1).split("|").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-  }
-  try {
-    const parsed = JSON.parse(normalized);
-    if (!Array.isArray(parsed)) {
-      return [];
-    }
-    return parsed.filter((tag) => typeof tag === "string");
-  } catch {
-    return [];
-  }
-}
-function readRequiredString(row, key) {
-  const value = row[key];
-  if (typeof value !== "string") {
-    throw new Error(`Expected string column "${key}" in database row.`);
-  }
-  return value;
-}
-function readOptionalString(row, key) {
-  const value = row[key];
-  return typeof value === "string" ? value : void 0;
-}
-function readNumber(row, key, fallback = 0) {
-  const value = row[key];
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? value : fallback;
-  }
-  if (typeof value === "bigint") {
-    const converted = Number(value);
-    return Number.isFinite(converted) ? converted : fallback;
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    const converted = Number(value);
-    return Number.isFinite(converted) ? converted : fallback;
-  }
-  return fallback;
-}
-function readBoolean(row, key) {
-  return readNumber(row, key, 0) !== 0;
-}
-function readEmbedding(row, key) {
-  const value = row[key];
-  if (value instanceof ArrayBuffer) {
-    return Array.from(new Float32Array(value));
-  }
-  if (ArrayBuffer.isView(value)) {
-    const length = Math.floor(value.byteLength / Float32Array.BYTES_PER_ELEMENT);
-    if (length === 0) {
-      return [];
-    }
-    if (value.byteOffset % Float32Array.BYTES_PER_ELEMENT !== 0) {
-      const copy = new Uint8Array(value.byteLength);
-      copy.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-      return Array.from(new Float32Array(copy.buffer, 0, length));
-    }
-    return Array.from(new Float32Array(value.buffer, value.byteOffset, length));
-  }
-  return [];
-}
-function mapEntryRow(row) {
-  const type = readRequiredString(row, "type");
-  const expiry = readRequiredString(row, "expiry");
-  return {
-    id: readRequiredString(row, "id"),
-    type,
-    subject: readRequiredString(row, "subject"),
-    content: readRequiredString(row, "content"),
-    importance: readNumber(row, "importance", 0),
-    expiry,
-    tags: deserializeTags(row.tags),
-    source_file: readOptionalString(row, "source_file"),
-    source_context: readOptionalString(row, "source_context"),
-    embedding: readEmbedding(row, "embedding"),
-    content_hash: readOptionalString(row, "content_hash"),
-    norm_content_hash: readOptionalString(row, "norm_content_hash"),
-    quality_score: readNumber(row, "quality_score", DEFAULT_QUALITY_SCORE),
-    recall_count: readNumber(row, "recall_count", 0),
-    last_recalled_at: readOptionalString(row, "last_recalled_at"),
-    superseded_by: readOptionalString(row, "superseded_by"),
-    valid_from: readOptionalString(row, "valid_from"),
-    valid_to: readOptionalString(row, "valid_to"),
-    claim_key: readOptionalString(row, "claim_key"),
-    supersession_kind: readOptionalString(row, "supersession_kind"),
-    supersession_reason: readOptionalString(row, "supersession_reason"),
-    cluster_id: readOptionalString(row, "cluster_id"),
-    user_id: readOptionalString(row, "user_id"),
-    project: readOptionalString(row, "project"),
-    retired: readBoolean(row, "retired"),
-    retired_at: readOptionalString(row, "retired_at"),
-    retired_reason: readOptionalString(row, "retired_reason"),
-    created_at: readRequiredString(row, "created_at"),
-    updated_at: readRequiredString(row, "updated_at")
-  };
-}
-function mapEpisodeRow(row) {
-  const source = readRequiredString(row, "source");
-  const activityLevel = readOptionalString(row, "activity_level");
-  return {
-    id: readRequiredString(row, "id"),
-    source,
-    sourceId: readOptionalString(row, "source_id"),
-    sourceRef: readOptionalString(row, "source_ref"),
-    transcriptHash: readOptionalString(row, "transcript_hash"),
-    summaryHash: readOptionalString(row, "summary_hash"),
-    agentId: readOptionalString(row, "agent_id"),
-    surface: readOptionalString(row, "surface"),
-    startedAt: readRequiredString(row, "started_at"),
-    endedAt: readOptionalString(row, "ended_at"),
-    summary: readRequiredString(row, "summary"),
-    tags: deserializeTags(row.tags),
-    activityLevel,
-    userId: readOptionalString(row, "user_id"),
-    project: readOptionalString(row, "project"),
-    genModel: readOptionalString(row, "gen_model"),
-    genVersion: readOptionalString(row, "gen_version"),
-    messageCount: readOptionalNumber(row, "message_count"),
-    embedding: readEmbedding(row, "embedding"),
-    retired: readBoolean(row, "retired"),
-    retiredAt: readOptionalString(row, "retired_at"),
-    retiredReason: readOptionalString(row, "retired_reason"),
-    supersededBy: readOptionalString(row, "superseded_by"),
-    createdAt: readRequiredString(row, "created_at"),
-    updatedAt: readRequiredString(row, "updated_at")
-  };
-}
-function readOptionalNumber(row, key) {
-  if (row[key] === null || row[key] === void 0) {
-    return void 0;
-  }
-  return readNumber(row, key, 0);
-}
-
-// src/adapters/db/episode-queries.ts
-var EPISODE_SELECT_COLUMNS = `
-  id,
-  source,
-  source_id,
-  source_ref,
-  transcript_hash,
-  summary_hash,
-  agent_id,
-  surface,
-  started_at,
-  ended_at,
-  summary,
-  tags,
-  activity_level,
-  user_id,
-  project,
-  gen_model,
-  gen_version,
-  message_count,
-  embedding,
-  retired,
-  retired_at,
-  retired_reason,
-  superseded_by,
-  created_at,
-  updated_at
-`;
-async function getEpisodeBySourceId(executor, source, sourceId) {
-  const normalizedSourceId = normalizeOptionalString(sourceId);
-  if (!normalizedSourceId) {
-    return null;
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT ${EPISODE_SELECT_COLUMNS}
-      FROM episodes
-      WHERE source = ?
-        AND source_id = ?
-      LIMIT 1
-    `,
-    args: [source, normalizedSourceId]
-  });
-  const row = result.rows[0];
-  return row ? mapEpisodeRow(row) : null;
-}
-async function getEpisodeByTranscriptHash(executor, source, transcriptHash) {
-  const normalizedTranscriptHash = normalizeOptionalString(transcriptHash);
-  if (!normalizedTranscriptHash) {
-    return null;
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT ${EPISODE_SELECT_COLUMNS}
-      FROM episodes
-      WHERE source = ?
-        AND transcript_hash = ?
-      LIMIT 1
-    `,
-    args: [source, normalizedTranscriptHash]
-  });
-  const row = result.rows[0];
-  return row ? mapEpisodeRow(row) : null;
-}
-async function upsertEpisode(executor, input) {
-  const payload = normalizeEpisodePayload(input);
-  const summaryHash = createEpisodePayloadHash(payload);
-  const existing = payload.sourceId !== void 0 ? await getEpisodeBySourceId(executor, payload.source, payload.sourceId) : await getEpisodeByTranscriptHash(executor, payload.source, readRequiredIdentityHash(payload));
-  if (!existing) {
-    const id = randomUUID();
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    const vectorJson2 = serializeEmbeddingForVector(payload.embedding ?? []);
-    await executor.execute({
-      sql: `
-        INSERT INTO episodes (
-          id,
-          source,
-          source_id,
-          source_ref,
-          transcript_hash,
-          summary_hash,
-          agent_id,
-          surface,
-          started_at,
-          ended_at,
-          summary,
-          tags,
-          activity_level,
-          user_id,
-          project,
-          gen_model,
-          gen_version,
-          message_count,
-          embedding,
-          retired,
-          retired_at,
-          retired_reason,
-          superseded_by,
-          created_at,
-          updated_at
-        )
-        VALUES (
-          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
-          CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
-          0, NULL, NULL, NULL, ?, ?
-        )
-      `,
-      args: [
-        id,
-        payload.source,
-        toNullableString(payload.sourceId),
-        toNullableString(payload.sourceRef),
-        toNullableString(payload.transcriptHash),
-        summaryHash,
-        toNullableString(payload.agentId),
-        toNullableString(payload.surface),
-        payload.startedAt,
-        toNullableString(payload.endedAt),
-        payload.summary,
-        serializeTags(payload.tags),
-        toNullableString(payload.activityLevel),
-        toNullableString(payload.userId),
-        toNullableString(payload.project),
-        toNullableString(payload.genModel),
-        toNullableString(payload.genVersion),
-        toNullableInteger(payload.messageCount),
-        vectorJson2,
-        vectorJson2,
-        now2,
-        now2
-      ]
-    });
-    return {
-      episode: await getEpisodeById(executor, id),
-      action: "inserted"
-    };
-  }
-  const existingSummaryHash = existing.summaryHash ?? createEpisodePayloadHash(normalizeEpisodePayload(fromStoredEpisode(existing)));
-  if (existingSummaryHash === summaryHash) {
-    return {
-      episode: existing,
-      action: "unchanged"
-    };
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const vectorJson = serializeEmbeddingForVector(payload.embedding ?? []);
-  await executor.execute({
-    sql: `
-      UPDATE episodes
-      SET source_ref = ?,
-          transcript_hash = ?,
-          summary_hash = ?,
-          agent_id = ?,
-          surface = ?,
-          started_at = ?,
-          ended_at = ?,
-          summary = ?,
-          tags = ?,
-          activity_level = ?,
-          user_id = ?,
-          project = ?,
-          gen_model = ?,
-          gen_version = ?,
-          message_count = ?,
-          embedding = CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
-          updated_at = ?
-      WHERE id = ?
-    `,
-    args: [
-      toNullableString(payload.sourceRef),
-      toNullableString(payload.transcriptHash),
-      summaryHash,
-      toNullableString(payload.agentId),
-      toNullableString(payload.surface),
-      payload.startedAt,
-      toNullableString(payload.endedAt),
-      payload.summary,
-      serializeTags(payload.tags),
-      toNullableString(payload.activityLevel),
-      toNullableString(payload.userId),
-      toNullableString(payload.project),
-      toNullableString(payload.genModel),
-      toNullableString(payload.genVersion),
-      toNullableInteger(payload.messageCount),
-      vectorJson,
-      vectorJson,
-      now,
-      existing.id
-    ]
-  });
-  return {
-    episode: await getEpisodeById(executor, existing.id),
-    action: "updated"
-  };
-}
-async function listEpisodesByTimeWindow(executor, window, limit) {
-  const bounds = resolveWindowBounds(window);
-  if (!bounds) {
-    return [];
-  }
-  const whereClauses = [buildActiveEpisodeClause()];
-  const args = [];
-  if (bounds.start && bounds.end) {
-    whereClauses.push("started_at <= ?");
-    whereClauses.push("COALESCE(ended_at, started_at) >= ?");
-    args.push(bounds.end, bounds.start);
-  } else if (bounds.start) {
-    whereClauses.push("COALESCE(ended_at, started_at) >= ?");
-    args.push(bounds.start);
-  } else if (bounds.end) {
-    whereClauses.push("started_at <= ?");
-    args.push(bounds.end);
-  } else {
-    return [];
-  }
-  const normalizedLimit = normalizePositiveInteger(limit);
-  const result = await executor.execute({
-    sql: `
-      SELECT ${EPISODE_SELECT_COLUMNS}
-      FROM episodes
-      WHERE ${whereClauses.join(" AND ")}
-      ORDER BY started_at DESC, id ASC
-      ${normalizedLimit ? "LIMIT ?" : ""}
-    `,
-    args: normalizedLimit ? [...args, normalizedLimit] : args
-  });
-  return result.rows.map((row) => mapEpisodeRow(row));
-}
-async function episodeVectorSearch(executor, params) {
-  if (params.limit <= 0 || params.embedding.length === 0) {
-    return [];
-  }
-  const serializedEmbedding = serializeEmbeddingForVector(params.embedding);
-  if (!serializedEmbedding) {
-    return [];
-  }
-  let result;
-  try {
-    result = await executor.execute({
-      sql: `
-        SELECT ${prefixColumns(EPISODE_SELECT_COLUMNS, "e")}
-        FROM vector_top_k('idx_episodes_embedding', vector32(?), ?) AS v
-        JOIN episodes AS e ON e.rowid = v.id
-        WHERE ${buildActiveEpisodeClause("e")}
-        LIMIT ?
-      `,
-      args: [serializedEmbedding, params.limit, params.limit]
-    });
-  } catch (error) {
-    throw wrapEpisodeVectorError(error);
-  }
-  return result.rows.map((row) => {
-    const episode = mapEpisodeRow(row);
-    return {
-      episode,
-      vectorSim: cosineSimilarity(params.embedding, episode.embedding ?? [])
-    };
-  }).filter((candidate) => candidate.vectorSim > 0).sort((left, right) => right.vectorSim - left.vectorSim).slice(0, params.limit);
-}
-async function listEpisodesWithoutEmbeddings(executor, limit) {
-  const normalizedLimit = normalizePositiveInteger(limit);
-  const result = await executor.execute({
-    sql: `
-      SELECT ${EPISODE_SELECT_COLUMNS}
-      FROM episodes
-      WHERE ${buildActiveEpisodeClause()}
-        AND embedding IS NULL
-      ORDER BY started_at DESC, id ASC
-      ${normalizedLimit ? "LIMIT ?" : ""}
-    `,
-    args: normalizedLimit ? [normalizedLimit] : []
-  });
-  return result.rows.map((row) => mapEpisodeRow(row));
-}
-async function updateEpisodeEmbedding(executor, id, embedding) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const vectorJson = serializeEmbeddingForVector(embedding);
-  await executor.execute({
-    sql: `
-      UPDATE episodes
-      SET embedding = CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
-          updated_at = ?
-      WHERE id = ?
-    `,
-    args: [vectorJson, vectorJson, now, id]
-  });
-}
-function createEpisodePayloadHash(payload) {
-  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
-}
-function fromStoredEpisode(episode) {
-  return {
-    source: episode.source,
-    sourceId: episode.sourceId,
-    sourceRef: episode.sourceRef,
-    transcriptHash: episode.transcriptHash,
-    agentId: episode.agentId,
-    surface: episode.surface,
-    startedAt: episode.startedAt,
-    endedAt: episode.endedAt,
-    summary: episode.summary,
-    tags: episode.tags,
-    activityLevel: episode.activityLevel,
-    userId: episode.userId,
-    project: episode.project,
-    genModel: episode.genModel,
-    genVersion: episode.genVersion,
-    messageCount: episode.messageCount,
-    embedding: episode.embedding
-  };
-}
-async function getEpisodeById(executor, id) {
-  const result = await executor.execute({
-    sql: `
-      SELECT ${EPISODE_SELECT_COLUMNS}
-      FROM episodes
-      WHERE id = ?
-      LIMIT 1
-    `,
-    args: [id]
-  });
-  const row = result.rows[0];
-  if (!row) {
-    throw new Error(`Episode ${id} was not found after persistence.`);
-  }
-  return mapEpisodeRow(row);
-}
-function normalizeEpisodePayload(input) {
-  const sourceId = normalizeOptionalString(input.sourceId);
-  const transcriptHash = normalizeOptionalString(input.transcriptHash);
-  if (!sourceId && !transcriptHash) {
-    throw new Error("Episode writes require either sourceId or transcriptHash.");
-  }
-  const startedAt = normalizeRequiredString(input.startedAt, "startedAt");
-  const endedAt = normalizeOptionalString(input.endedAt);
-  const summary = normalizeSummary(input.summary);
-  return {
-    source: input.source,
-    ...sourceId ? { sourceId } : {},
-    ...normalizeOptionalString(input.sourceRef) ? { sourceRef: normalizeOptionalString(input.sourceRef) ?? void 0 } : {},
-    ...transcriptHash ? { transcriptHash } : {},
-    ...normalizeOptionalString(input.agentId) ? { agentId: normalizeOptionalString(input.agentId) ?? void 0 } : {},
-    ...normalizeOptionalString(input.surface) ? { surface: normalizeOptionalString(input.surface) ?? void 0 } : {},
-    startedAt,
-    ...endedAt ? { endedAt } : {},
-    summary,
-    tags: normalizeTags(input.tags),
-    ...normalizeActivityLevel(input.activityLevel) ? { activityLevel: normalizeActivityLevel(input.activityLevel) } : {},
-    ...normalizeOptionalString(input.userId) ? { userId: normalizeOptionalString(input.userId) ?? void 0 } : {},
-    ...normalizeOptionalText(input.project) ? { project: normalizeOptionalText(input.project) ?? void 0 } : {},
-    ...normalizeOptionalString(input.genModel) ? { genModel: normalizeOptionalString(input.genModel) ?? void 0 } : {},
-    ...normalizeOptionalString(input.genVersion) ? { genVersion: normalizeOptionalString(input.genVersion) ?? void 0 } : {},
-    ...normalizeOptionalInteger(input.messageCount) !== void 0 ? { messageCount: normalizeOptionalInteger(input.messageCount) } : {},
-    ...normalizeEmbedding(input.embedding) ? { embedding: normalizeEmbedding(input.embedding) } : {}
-  };
-}
-function resolveWindowBounds(window) {
-  switch (window.kind) {
-    case "interval": {
-      if (!window.start || !window.end) {
-        return null;
-      }
-      return { start: window.start.toISOString(), end: window.end.toISOString() };
-    }
-    case "anchor": {
-      if (!window.anchor || window.radiusDays === void 0 || window.radiusDays < 0) {
-        return null;
-      }
-      const radiusMs = Math.trunc(window.radiusDays) * 24 * 60 * 60 * 1e3;
-      return {
-        start: new Date(window.anchor.getTime() - radiusMs).toISOString(),
-        end: new Date(window.anchor.getTime() + radiusMs).toISOString()
-      };
-    }
-    case "open_end":
-      return window.start ? { start: window.start.toISOString() } : null;
-    case "open_start":
-      return window.end ? { end: window.end.toISOString() } : null;
-    default:
-      return null;
-  }
-}
-function readRequiredIdentityHash(payload) {
-  if (!payload.transcriptHash) {
-    throw new Error("Episode writes without sourceId require transcriptHash.");
-  }
-  return payload.transcriptHash;
-}
-function normalizeActivityLevel(value) {
-  if (!value) {
-    return void 0;
-  }
-  return value;
-}
-function normalizeOptionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function normalizeOptionalText(value) {
-  const normalized = value?.replace(/\s+/gu, " ").trim();
-  return normalized ? normalized : void 0;
-}
-function normalizeSummary(value) {
-  const normalized = value.replace(/\s+/gu, " ").trim();
-  if (!normalized) {
-    throw new Error("Episode summary must not be empty.");
-  }
-  return normalized;
-}
-function normalizeTags(tags) {
-  if (!tags || tags.length === 0) {
-    return [];
-  }
-  return Array.from(new Set(tags.map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0))).sort((left, right) => left.localeCompare(right)).slice(0, 8);
-}
-function normalizeOptionalInteger(value) {
-  if (value === void 0 || !Number.isFinite(value)) {
-    return void 0;
-  }
-  return Math.trunc(value);
-}
-function normalizeEmbedding(embedding) {
-  if (!embedding || embedding.length === 0) {
-    return void 0;
-  }
-  return embedding.map((value) => Number.isFinite(value) ? value : 0);
-}
-function normalizeRequiredString(value, fieldName) {
-  const normalized = value.trim();
-  if (!normalized) {
-    throw new Error(`Episode field "${fieldName}" must not be empty.`);
-  }
-  return normalized;
-}
-function normalizePositiveInteger(value) {
-  const normalized = normalizeOptionalInteger(value);
-  if (normalized === void 0 || normalized <= 0) {
-    return void 0;
-  }
-  return normalized;
-}
-function prefixColumns(columns, alias) {
-  return columns.split(",").map((col) => {
-    const trimmed = col.trim();
-    return trimmed ? `${alias}.${trimmed}` : "";
-  }).filter(Boolean).join(", ");
-}
-function wrapEpisodeVectorError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return new Error(`Episode vector search is unavailable: ${message}`);
-}
-function toNullableString(value) {
-  return value ?? null;
-}
-function toNullableInteger(value) {
-  return value ?? null;
-}
-
-// src/adapters/db/queries.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var LOOKUP_CHUNK_SIZE = 100;
-var DEFAULT_QUALITY_SCORE2 = 0.5;
-async function insertEntry(executor, entry, embedding, contentHash) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = entry.id.trim().length > 0 ? entry.id.trim() : randomUUID2();
-  const createdAt = normalizeTimestamp(entry.created_at) ?? now;
-  const updatedAt = normalizeTimestamp(entry.updated_at) ?? now;
-  const vectorJson = serializeEmbeddingForVector(embedding);
-  await executor.execute({
-    sql: `
-      INSERT INTO entries (
-        id,
-        type,
-        subject,
-        content,
-        importance,
-        expiry,
-        tags,
-        source_file,
-        source_context,
-        embedding,
-        content_hash,
-        norm_content_hash,
-        minhash_sig,
-        quality_score,
-        recall_count,
-        last_recalled_at,
-        superseded_by,
-        valid_from,
-        valid_to,
-        claim_key,
-        supersession_kind,
-        supersession_reason,
-        cluster_id,
-        user_id,
-        project,
-        retired,
-        retired_at,
-        retired_reason,
-        created_at,
-        updated_at
-      )
-      VALUES (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?,
-        CASE WHEN ? IS NULL THEN NULL ELSE vector32(?) END,
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
-      )
-    `,
-    args: [
-      id,
-      entry.type,
-      entry.subject,
-      entry.content,
-      normalizeInteger(entry.importance, 0),
-      entry.expiry,
-      serializeTags(entry.tags),
-      normalizeOptionalString2(entry.source_file),
-      normalizeOptionalString2(entry.source_context),
-      vectorJson,
-      vectorJson,
-      contentHash.trim(),
-      normalizeOptionalString2(entry.norm_content_hash),
-      null,
-      normalizeNumber(entry.quality_score, DEFAULT_QUALITY_SCORE2),
-      normalizeInteger(entry.recall_count, 0),
-      normalizeOptionalString2(entry.last_recalled_at),
-      normalizeOptionalString2(entry.superseded_by),
-      normalizeOptionalString2(entry.valid_from),
-      normalizeOptionalString2(entry.valid_to),
-      normalizeOptionalString2(entry.claim_key),
-      normalizeOptionalString2(entry.supersession_kind),
-      normalizeOptionalString2(entry.supersession_reason),
-      normalizeOptionalString2(entry.cluster_id),
-      normalizeOptionalString2(entry.user_id),
-      normalizeOptionalString2(entry.project),
-      entry.retired ? 1 : 0,
-      normalizeOptionalString2(entry.retired_at),
-      normalizeOptionalString2(entry.retired_reason),
-      createdAt,
-      updatedAt
-    ]
-  });
-  return id;
-}
-async function getEntries(executor, ids) {
-  const normalizedIds = dedupeStrings(ids);
-  if (normalizedIds.length === 0) {
-    return [];
-  }
-  const byId = /* @__PURE__ */ new Map();
-  for (const chunk of chunkValues(normalizedIds, LOOKUP_CHUNK_SIZE)) {
-    const placeholders = chunk.map(() => "?").join(", ");
-    const result = await executor.execute({
-      sql: `
-        SELECT
-          id,
-          type,
-          subject,
-          content,
-          importance,
-          expiry,
-          tags,
-          source_file,
-          source_context,
-          embedding,
-          content_hash,
-          norm_content_hash,
-          quality_score,
-          recall_count,
-          last_recalled_at,
-          superseded_by,
-          valid_from,
-          valid_to,
-          claim_key,
-          supersession_kind,
-          supersession_reason,
-          cluster_id,
-          user_id,
-          project,
-          retired,
-          retired_at,
-          retired_reason,
-          created_at,
-          updated_at
-        FROM entries
-        WHERE id IN (${placeholders})
-          AND ${ACTIVE_ENTRY_CLAUSE}
-      `,
-      args: chunk
-    });
-    for (const row of result.rows) {
-      const entry = mapEntryRow(row);
-      byId.set(entry.id, entry);
-    }
-  }
-  return ids.map((id) => byId.get(id.trim())).filter((entry) => entry !== void 0);
-}
-async function getEntry(executor, id) {
-  const [entry] = await getEntries(executor, [id]);
-  return entry ?? null;
-}
-async function findExistingHashes(executor, hashes) {
-  const normalizedHashes = dedupeStrings(hashes);
-  if (normalizedHashes.length === 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  const matches = /* @__PURE__ */ new Set();
-  for (const chunk of chunkValues(normalizedHashes, LOOKUP_CHUNK_SIZE)) {
-    const placeholders = chunk.map(() => "?").join(", ");
-    const result = await executor.execute({
-      sql: `
-        SELECT DISTINCT content_hash
-        FROM entries
-        WHERE content_hash IN (${placeholders})
-          AND ${ACTIVE_ENTRY_CLAUSE}
-      `,
-      args: chunk
-    });
-    for (const row of result.rows) {
-      matches.add(readRequiredString(row, "content_hash"));
-    }
-  }
-  return matches;
-}
-async function findExistingNormHashes(executor, hashes) {
-  const normalizedHashes = dedupeStrings(hashes);
-  if (normalizedHashes.length === 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  const matches = /* @__PURE__ */ new Set();
-  for (const chunk of chunkValues(normalizedHashes, LOOKUP_CHUNK_SIZE)) {
-    const placeholders = chunk.map(() => "?").join(", ");
-    const result = await executor.execute({
-      sql: `
-        SELECT DISTINCT norm_content_hash
-        FROM entries
-        WHERE norm_content_hash IN (${placeholders})
-          AND ${ACTIVE_ENTRY_CLAUSE}
-      `,
-      args: chunk
-    });
-    for (const row of result.rows) {
-      matches.add(readRequiredString(row, "norm_content_hash"));
-    }
-  }
-  return matches;
-}
-async function retireEntry(executor, id, reason) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = await executor.execute({
-    sql: `
-      UPDATE entries
-      SET retired = 1,
-          retired_at = ?,
-          retired_reason = ?,
-          updated_at = ?
-      WHERE id = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
-    `,
-    args: [now, normalizeOptionalString2(reason), now, id]
-  });
-  return result.rowsAffected > 0;
-}
-async function supersedeEntry(executor, oldId, newId, kind, reason) {
-  const normalizedOldId = oldId.trim();
-  const normalizedNewId = newId.trim();
-  if (normalizedOldId.length === 0 || normalizedNewId.length === 0 || normalizedOldId === normalizedNewId) {
-    return false;
-  }
-  const existing = await executor.execute({
-    sql: `
-      SELECT id
-      FROM entries
-      WHERE id = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
-      LIMIT 1
-    `,
-    args: [normalizedOldId]
-  });
-  if (existing.rows.length === 0) {
-    return false;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const result = await executor.execute({
-    sql: `
-      UPDATE entries
-      SET superseded_by = ?,
-          supersession_kind = ?,
-          supersession_reason = ?,
-          updated_at = ?
-      WHERE id = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
-    `,
-    args: [normalizedNewId, normalizeOptionalString2(kind) ?? "update", normalizeOptionalString2(reason), now, normalizedOldId]
-  });
-  return result.rowsAffected > 0;
-}
-async function findActiveEntriesByClaimKey(executor, claimKey) {
-  const normalizedClaimKey = claimKey.trim();
-  if (normalizedClaimKey.length === 0) {
-    return [];
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT *
-      FROM entries
-      WHERE claim_key = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
-    `,
-    args: [normalizedClaimKey]
-  });
-  return result.rows.map((row) => mapEntryRow(row));
-}
-async function getDistinctClaimKeyPrefixes(executor) {
-  const result = await executor.execute({
-    sql: `
-      SELECT DISTINCT lower(trim(substr(claim_key, 1, instr(claim_key, '/') - 1))) AS claim_key_prefix
-      FROM entries
-      WHERE claim_key IS NOT NULL
-        AND instr(claim_key, '/') > 1
-        AND ${ACTIVE_ENTRY_CLAUSE}
-      ORDER BY claim_key_prefix ASC
-    `
-  });
-  return result.rows.flatMap((row) => {
-    const prefix = row.claim_key_prefix;
-    return typeof prefix === "string" && prefix.length > 0 ? [prefix] : [];
-  });
-}
-async function getClaimKeyExamples(executor, limit = 8) {
-  const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 8;
-  const result = await executor.execute({
-    sql: `
-      SELECT claim_key
-      FROM entries
-      WHERE claim_key IS NOT NULL
-        AND ${ACTIVE_ENTRY_CLAUSE}
-      GROUP BY claim_key
-      ORDER BY COUNT(*) DESC, MAX(importance) DESC, MAX(created_at) DESC, claim_key ASC
-      LIMIT ?
-    `,
-    args: [normalizedLimit]
-  });
-  return result.rows.flatMap((row) => {
-    const claimKey = row.claim_key;
-    return typeof claimKey === "string" && claimKey.length > 0 ? [claimKey] : [];
-  });
-}
-async function updateEntry(executor, id, fields, options) {
-  const assignments = [];
-  const args = [];
-  if (fields.importance !== void 0) {
-    assignments.push("importance = ?");
-    args.push(normalizeInteger(fields.importance, 0));
-  }
-  if (fields.expiry !== void 0) {
-    assignments.push("expiry = ?");
-    args.push(fields.expiry);
-  }
-  if (fields.claim_key !== void 0) {
-    assignments.push("claim_key = ?");
-    args.push(normalizeOptionalString2(fields.claim_key));
-  }
-  if (fields.valid_from !== void 0) {
-    assignments.push("valid_from = ?");
-    args.push(normalizeOptionalString2(fields.valid_from));
-  }
-  if (fields.valid_to !== void 0) {
-    assignments.push("valid_to = ?");
-    args.push(normalizeOptionalString2(fields.valid_to));
-  }
-  if (assignments.length === 0) {
-    return false;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  assignments.push("updated_at = ?");
-  args.push(now, id);
-  const result = await executor.execute({
-    sql: `
-      UPDATE entries
-      SET ${assignments.join(", ")}
-      WHERE id = ?
-        AND ${options?.includeInactive === true ? "1 = 1" : ACTIVE_ENTRY_CLAUSE}
-    `,
-    args
-  });
-  return result.rowsAffected > 0;
-}
-async function recordRecallEvent(executor, entryId, query, sessionKey) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const updateResult = await executor.execute({
-    sql: `
-      UPDATE entries
-      SET recall_count = COALESCE(recall_count, 0) + 1,
-          last_recalled_at = ?,
-          updated_at = ?
-      WHERE id = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
-    `,
-    args: [now, now, entryId]
-  });
-  if (updateResult.rowsAffected === 0) {
-    return;
-  }
-  await executor.execute({
-    sql: `
-      INSERT INTO recall_events (
-        id,
-        entry_id,
-        query,
-        session_key,
-        recalled_at
-      )
-      VALUES (?, ?, ?, ?, ?)
-    `,
-    args: [randomUUID2(), entryId, query, normalizeOptionalString2(sessionKey), now]
-  });
-}
-async function getIngestLogEntry(executor, filePath) {
-  const result = await executor.execute({
-    sql: `
-      SELECT file_hash, ingested_at
-      FROM ingest_log
-      WHERE file_path = ?
-      LIMIT 1
-    `,
-    args: [filePath]
-  });
-  const row = result.rows[0];
-  if (!row) {
-    return null;
-  }
-  return {
-    fileHash: readRequiredString(row, "file_hash"),
-    ingestedAt: readRequiredString(row, "ingested_at")
-  };
-}
-async function insertIngestLogEntry(executor, filePath, fileHash, entryCount) {
-  await executor.execute({
-    sql: `
-      INSERT INTO ingest_log (
-        file_path,
-        file_hash,
-        ingested_at,
-        entry_count
-      )
-      VALUES (?, ?, ?, ?)
-      ON CONFLICT(file_path) DO UPDATE SET
-        file_hash = excluded.file_hash,
-        ingested_at = excluded.ingested_at,
-        entry_count = excluded.entry_count
-    `,
-    args: [filePath, fileHash, (/* @__PURE__ */ new Date()).toISOString(), normalizeInteger(entryCount, 0)]
-  });
-}
-function dedupeStrings(values) {
-  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
-}
-function chunkValues(values, size) {
-  const chunks = [];
-  for (let index = 0; index < values.length; index += size) {
-    chunks.push(values.slice(index, index + size));
-  }
-  return chunks;
-}
-function normalizeOptionalString2(value) {
-  if (value === void 0) {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeTimestamp(value) {
-  return normalizeOptionalString2(value);
-}
-function normalizeNumber(value, fallback) {
-  return Number.isFinite(value) ? value : fallback;
-}
-function normalizeInteger(value, fallback) {
-  const normalized = Number.isFinite(value) ? Math.trunc(value) : fallback;
-  return Number.isFinite(normalized) ? normalized : fallback;
-}
-
-// src/adapters/db/schema.ts
-var SCHEMA_VERSION = "7";
-var VECTOR_INDEX_NAME = "idx_entries_embedding";
-var EPISODE_VECTOR_INDEX_NAME = "idx_episodes_embedding";
-var BULK_WRITE_STATE_META_KEY = "bulk_write_state";
-var LAST_BULK_INGEST_META_KEY = "last_bulk_ingest_at";
-var CREATE_ENTRIES_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS entries (
-    id TEXT PRIMARY KEY,
-    type TEXT NOT NULL,
-    subject TEXT NOT NULL,
-    content TEXT NOT NULL,
-    importance INTEGER NOT NULL,
-    expiry TEXT NOT NULL,
-    tags TEXT,
-    source_file TEXT,
-    source_context TEXT,
-    embedding F32_BLOB(1024),
-    content_hash TEXT,
-    norm_content_hash TEXT,
-    minhash_sig BLOB,
-    quality_score REAL NOT NULL DEFAULT 0.5,
-    recall_count INTEGER DEFAULT 0,
-    last_recalled_at TEXT,
-    superseded_by TEXT REFERENCES entries(id),
-    valid_from TEXT,
-    valid_to TEXT,
-    claim_key TEXT,
-    supersession_kind TEXT,
-    supersession_reason TEXT,
-    cluster_id TEXT,
-    user_id TEXT,
-    project TEXT,
-    retired INTEGER NOT NULL DEFAULT 0,
-    retired_at TEXT,
-    retired_reason TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )
-`;
-var CREATE_ENTRIES_FTS_TABLE_SQL = `
-  CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
-    content,
-    subject,
-    content=entries,
-    content_rowid=rowid
-  )
-`;
-var CREATE_ENTRIES_FTS_INSERT_TRIGGER_SQL = `
-  CREATE TRIGGER IF NOT EXISTS entries_ai AFTER INSERT ON entries
-  WHEN new.retired = 0 AND new.superseded_by IS NULL BEGIN
-    INSERT INTO entries_fts(rowid, content, subject)
-    VALUES (new.rowid, new.content, new.subject);
-  END
-`;
-var CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL = `
-  CREATE TRIGGER IF NOT EXISTS entries_ad AFTER DELETE ON entries
-  WHEN old.retired = 0 AND old.superseded_by IS NULL BEGIN
-    INSERT INTO entries_fts(entries_fts, rowid, content, subject)
-    VALUES ('delete', old.rowid, old.content, old.subject);
-  END
-`;
-var CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL = `
-  CREATE TRIGGER IF NOT EXISTS entries_au AFTER UPDATE ON entries BEGIN
-    INSERT INTO entries_fts(entries_fts, rowid, content, subject)
-    SELECT 'delete', old.rowid, old.content, old.subject
-    WHERE old.retired = 0 AND old.superseded_by IS NULL;
-
-    INSERT INTO entries_fts(rowid, content, subject)
-    SELECT new.rowid, new.content, new.subject
-    WHERE new.retired = 0 AND new.superseded_by IS NULL;
-  END
-`;
-var CREATE_INGEST_LOG_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS ingest_log (
-    file_path TEXT PRIMARY KEY,
-    file_hash TEXT NOT NULL,
-    ingested_at TEXT NOT NULL,
-    entry_count INTEGER DEFAULT 0
-  )
-`;
-var CREATE_EPISODES_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS episodes (
-    id TEXT PRIMARY KEY,
-    source TEXT NOT NULL,
-    source_id TEXT,
-    source_ref TEXT,
-    transcript_hash TEXT,
-    summary_hash TEXT,
-    agent_id TEXT,
-    surface TEXT,
-    started_at TEXT NOT NULL,
-    ended_at TEXT,
-    summary TEXT NOT NULL,
-    tags TEXT,
-    activity_level TEXT,
-    user_id TEXT,
-    project TEXT,
-    gen_model TEXT,
-    gen_version TEXT,
-    message_count INTEGER,
-    embedding F32_BLOB(1024),
-    retired INTEGER NOT NULL DEFAULT 0,
-    retired_at TEXT,
-    retired_reason TEXT,
-    superseded_by TEXT REFERENCES episodes(id),
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )
-`;
-var CREATE_RECALL_EVENTS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS recall_events (
-    id TEXT PRIMARY KEY,
-    entry_id TEXT NOT NULL REFERENCES entries(id),
-    query TEXT,
-    session_key TEXT,
-    recalled_at TEXT NOT NULL
-  )
-`;
-var CREATE_SURGEON_RUNS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS surgeon_runs (
-    id TEXT PRIMARY KEY,
-    pass_type TEXT NOT NULL DEFAULT 'retirement',
-    project TEXT,
-    started_at TEXT NOT NULL,
-    completed_at TEXT,
-    status TEXT NOT NULL DEFAULT 'running',
-    input_tokens INTEGER DEFAULT 0,
-    output_tokens INTEGER DEFAULT 0,
-    estimated_cost_usd REAL DEFAULT 0,
-    model TEXT,
-    actions_taken INTEGER DEFAULT 0,
-    actions_skipped INTEGER DEFAULT 0,
-    entries_retired INTEGER DEFAULT 0,
-    summary TEXT,
-    summary_json TEXT,
-    error TEXT,
-    dry_run INTEGER NOT NULL DEFAULT 1,
-    config_json TEXT
-  )
-`;
-var CREATE_SURGEON_RUN_ACTIONS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS surgeon_run_actions (
-    id TEXT PRIMARY KEY,
-    run_id TEXT NOT NULL REFERENCES surgeon_runs(id),
-    action_type TEXT NOT NULL,
-    entry_id TEXT,
-    entry_ids TEXT NOT NULL DEFAULT '[]',
-    reasoning TEXT NOT NULL DEFAULT '',
-    recall_delta TEXT,
-    details_json TEXT,
-    created_at TEXT NOT NULL
-  )
-`;
-var CREATE_SURGEON_RUN_ACTIONS_RUN_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_actions_run_id
-  ON surgeon_run_actions(run_id)
-`;
-var CREATE_SURGEON_RUN_ACTIONS_ENTRY_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_actions_entry_id
-  ON surgeon_run_actions(entry_id)
-`;
-var CREATE_SURGEON_RUN_ACTIONS_CREATED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_actions_created_at
-  ON surgeon_run_actions(created_at)
-`;
-var CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS surgeon_run_proposals (
-    id TEXT PRIMARY KEY,
-    run_id TEXT NOT NULL REFERENCES surgeon_runs(id),
-    group_id TEXT NOT NULL,
-    issue_kind TEXT NOT NULL,
-    scope TEXT NOT NULL,
-    entry_ids TEXT NOT NULL DEFAULT '[]',
-    current_claim_keys TEXT NOT NULL DEFAULT '[]',
-    proposed_claim_keys TEXT NOT NULL DEFAULT '[]',
-    rationale TEXT NOT NULL DEFAULT '',
-    confidence REAL NOT NULL DEFAULT 0,
-    source TEXT NOT NULL DEFAULT '',
-    eligible_for_apply INTEGER NOT NULL DEFAULT 0,
-    created_at TEXT NOT NULL
-  )
-`;
-var CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_run_id
-  ON surgeon_run_proposals(run_id)
-`;
-var CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_group_id
-  ON surgeon_run_proposals(group_id)
-`;
-var CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_created_at
-  ON surgeon_run_proposals(created_at)
-`;
-var CREATE_META_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS _meta (
-    key TEXT PRIMARY KEY,
-    value TEXT
-  )
-`;
-var CREATE_ENTRIES_CONTENT_HASH_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_content_hash
-  ON entries(content_hash)
-`;
-var CREATE_ENTRIES_NORM_CONTENT_HASH_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_norm_content_hash
-  ON entries(norm_content_hash)
-`;
-var CREATE_ENTRIES_TYPE_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_type
-  ON entries(type)
-`;
-var CREATE_ENTRIES_EXPIRY_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_expiry
-  ON entries(expiry)
-`;
-var CREATE_ENTRIES_RETIRED_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_retired
-  ON entries(retired)
-`;
-var CREATE_ENTRIES_CREATED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_created_at
-  ON entries(created_at)
-`;
-var CREATE_ENTRIES_CLAIM_KEY_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_claim_key
-  ON entries(claim_key)
-  WHERE claim_key IS NOT NULL
-`;
-var CREATE_ENTRIES_VALID_FROM_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_valid_from
-  ON entries(valid_from)
-  WHERE valid_from IS NOT NULL
-`;
-var CREATE_ENTRIES_VALID_TO_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_valid_to
-  ON entries(valid_to)
-  WHERE valid_to IS NOT NULL
-`;
-var CREATE_EPISODES_STARTED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_started_at
-  ON episodes(started_at)
-`;
-var CREATE_EPISODES_ENDED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_ended_at
-  ON episodes(ended_at)
-`;
-var CREATE_EPISODES_SOURCE_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_source
-  ON episodes(source)
-`;
-var CREATE_EPISODES_SOURCE_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_source_id
-  ON episodes(source_id)
-`;
-var CREATE_EPISODES_RETIRED_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_retired
-  ON episodes(retired)
-`;
-var CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL = `
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_episodes_source_source_id
-  ON episodes(source, source_id)
-  WHERE source_id IS NOT NULL
-`;
-var CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_recall_events_entry_id
-  ON recall_events(entry_id)
-`;
-var CREATE_RECALL_EVENTS_RECALLED_AT_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_recall_events_recalled_at
-  ON recall_events(recalled_at)
-`;
-var CREATE_ENTRIES_EMBEDDING_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_entries_embedding ON entries (
-    libsql_vector_idx(
-      embedding,
-      'metric=cosine',
-      'compress_neighbors=float8',
-      'max_neighbors=50'
-    )
-  )
-  WHERE embedding IS NOT NULL
-    AND retired = 0
-    AND superseded_by IS NULL
-`;
-var CREATE_EPISODES_EMBEDDING_INDEX_SQL = `
-  CREATE INDEX IF NOT EXISTS idx_episodes_embedding ON episodes (
-    libsql_vector_idx(
-      embedding,
-      'metric=cosine',
-      'compress_neighbors=float8',
-      'max_neighbors=50'
-    )
-  )
-  WHERE embedding IS NOT NULL
-    AND retired = 0
-    AND superseded_by IS NULL
-`;
-var SCHEMA_STATEMENTS = [
-  CREATE_ENTRIES_TABLE_SQL,
-  CREATE_ENTRIES_FTS_TABLE_SQL,
-  CREATE_ENTRIES_FTS_INSERT_TRIGGER_SQL,
-  CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL,
-  CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL,
-  CREATE_INGEST_LOG_TABLE_SQL,
-  CREATE_EPISODES_TABLE_SQL,
-  CREATE_RECALL_EVENTS_TABLE_SQL,
-  CREATE_SURGEON_RUNS_TABLE_SQL,
-  CREATE_SURGEON_RUN_ACTIONS_TABLE_SQL,
-  CREATE_SURGEON_RUN_ACTIONS_RUN_ID_INDEX_SQL,
-  CREATE_SURGEON_RUN_ACTIONS_ENTRY_ID_INDEX_SQL,
-  CREATE_SURGEON_RUN_ACTIONS_CREATED_AT_INDEX_SQL,
-  CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL,
-  CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL,
-  CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL,
-  CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL,
-  CREATE_META_TABLE_SQL,
-  CREATE_ENTRIES_CONTENT_HASH_INDEX_SQL,
-  CREATE_ENTRIES_NORM_CONTENT_HASH_INDEX_SQL,
-  CREATE_ENTRIES_TYPE_INDEX_SQL,
-  CREATE_ENTRIES_EXPIRY_INDEX_SQL,
-  CREATE_ENTRIES_RETIRED_INDEX_SQL,
-  CREATE_ENTRIES_CREATED_AT_INDEX_SQL,
-  CREATE_ENTRIES_CLAIM_KEY_INDEX_SQL,
-  CREATE_ENTRIES_VALID_FROM_INDEX_SQL,
-  CREATE_ENTRIES_VALID_TO_INDEX_SQL,
-  CREATE_EPISODES_STARTED_AT_INDEX_SQL,
-  CREATE_EPISODES_ENDED_AT_INDEX_SQL,
-  CREATE_EPISODES_SOURCE_INDEX_SQL,
-  CREATE_EPISODES_SOURCE_ID_INDEX_SQL,
-  CREATE_EPISODES_RETIRED_INDEX_SQL,
-  CREATE_EPISODES_SOURCE_SOURCE_ID_UNIQUE_INDEX_SQL,
-  CREATE_RECALL_EVENTS_ENTRY_ID_INDEX_SQL,
-  CREATE_RECALL_EVENTS_RECALLED_AT_INDEX_SQL
-];
-async function initSchema(db) {
-  await db.execute("PRAGMA foreign_keys = ON");
-  let currentVersion = await getSchemaVersion(db);
-  await assertSupportedSchemaState(db, currentVersion);
-  if (currentVersion === "5") {
-    await migrateV5ToV6(db);
-    currentVersion = "6";
-  }
-  if (currentVersion === "6") {
-    await migrateV6ToV7(db);
-    currentVersion = "7";
-  }
-  const hadEntriesFts = await tableExists(db, "entries_fts");
-  for (const statement of SCHEMA_STATEMENTS) {
-    await db.execute(statement);
-  }
-  await db.execute({
-    sql: `
-      INSERT INTO _meta (key, value)
-      VALUES ('schema_version', ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value
-    `,
-    args: [SCHEMA_VERSION]
-  });
-  if (await hasActiveBulkWriteState(db)) {
-    await finalizeBulkWrites(db);
-    return;
-  }
-  if (currentVersion !== SCHEMA_VERSION || !hadEntriesFts) {
-    await rebuildFts(db);
-  }
-  await ensureVectorIndexes(db);
-}
-async function assertSupportedSchemaState(db, currentVersion) {
-  if (currentVersion && currentVersion !== "5" && currentVersion !== "6" && currentVersion !== SCHEMA_VERSION) {
-    throw new Error(
-      `Unsupported agenr database schema version "${currentVersion}". This build only supports schema version ${SCHEMA_VERSION}. Create a fresh database with \`agenr db reset\` or manually migrate the data into a new database.`
-    );
-  }
-  if (currentVersion !== null) {
-    return;
-  }
-  const existingTables = await listUserTables(db);
-  if (existingTables.length === 0) {
-    return;
-  }
-  throw new Error(
-    `Unsupported agenr database without schema metadata. This build only supports a fresh database or one already initialized at schema version ${SCHEMA_VERSION}. Create a fresh database with \`agenr db reset\` or manually migrate the data into a new database.`
-  );
-}
-async function migrateV5ToV6(db) {
-  const columns = ["valid_from TEXT", "valid_to TEXT", "claim_key TEXT", "supersession_kind TEXT", "supersession_reason TEXT"];
-  for (const column of columns) {
-    try {
-      await db.execute(`ALTER TABLE entries ADD COLUMN ${column}`);
-    } catch (error) {
-      if (!(error instanceof Error && /duplicate column/i.test(error.message))) {
-        throw error;
-      }
-    }
-  }
-}
-async function migrateV6ToV7(db) {
-  if (await tableExists(db, "surgeon_run_actions")) {
-    try {
-      await db.execute("ALTER TABLE surgeon_run_actions ADD COLUMN details_json TEXT");
-    } catch (error) {
-      if (!(error instanceof Error && /duplicate column/i.test(error.message))) {
-        throw error;
-      }
-    }
-  }
-  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL);
-  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL);
-  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL);
-  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL);
-}
-async function rebuildFts(db) {
-  await db.execute("INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')");
-}
-async function prepareBulkWrites(db) {
-  await runImmediateTransaction(db, async () => {
-    await db.execute({
-      sql: `
-        INSERT INTO _meta (key, value)
-        VALUES (?, 'active')
-        ON CONFLICT(key) DO UPDATE SET value = excluded.value
-      `,
-      args: [BULK_WRITE_STATE_META_KEY]
-    });
-    await db.execute("DROP TRIGGER IF EXISTS entries_ai");
-    await db.execute("DROP TRIGGER IF EXISTS entries_ad");
-    await db.execute("DROP TRIGGER IF EXISTS entries_au");
-    await dropVectorIndexes(db);
-  });
-}
-async function finalizeBulkWrites(db) {
-  await runImmediateTransaction(db, async () => {
-    await db.execute(CREATE_ENTRIES_FTS_INSERT_TRIGGER_SQL);
-    await db.execute(CREATE_ENTRIES_FTS_DELETE_TRIGGER_SQL);
-    await db.execute(CREATE_ENTRIES_FTS_UPDATE_TRIGGER_SQL);
-    await rebuildFts(db);
-    await ensureVectorIndexes(db);
-    await db.execute({
-      sql: "DELETE FROM _meta WHERE key = ?",
-      args: [BULK_WRITE_STATE_META_KEY]
-    });
-    await db.execute({
-      sql: `
-        INSERT INTO _meta (key, value)
-        VALUES (?, ?)
-        ON CONFLICT(key) DO UPDATE SET value = excluded.value
-      `,
-      args: [LAST_BULK_INGEST_META_KEY, (/* @__PURE__ */ new Date()).toISOString()]
-    });
-  });
-}
-async function getLastBulkIngestAt(db) {
-  try {
-    const result = await db.execute({
-      sql: "SELECT value FROM _meta WHERE key = ? LIMIT 1",
-      args: [LAST_BULK_INGEST_META_KEY]
-    });
-    const row = result.rows[0];
-    return row?.value ? String(row.value) : null;
-  } catch {
-    return null;
-  }
-}
-async function getSchemaVersion(db) {
-  try {
-    const result = await db.execute("SELECT value FROM _meta WHERE key = 'schema_version' LIMIT 1");
-    const row = result.rows[0];
-    if (!row) {
-      return null;
-    }
-    const value = row.value;
-    return typeof value === "string" ? value : null;
-  } catch {
-    return null;
-  }
-}
-async function tableExists(db, tableName) {
-  const result = await db.execute({
-    sql: `
-      SELECT 1
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND name = ?
-      LIMIT 1
-    `,
-    args: [tableName]
-  });
-  return result.rows.length > 0;
-}
-async function listUserTables(db) {
-  const result = await db.execute({
-    sql: `
-      SELECT name
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND name NOT LIKE 'sqlite_%'
-      ORDER BY name
-    `
-  });
-  return result.rows.flatMap((row) => {
-    const name = row.name;
-    return typeof name === "string" ? [name] : [];
-  });
-}
-async function hasActiveBulkWriteState(db) {
-  try {
-    const result = await db.execute({
-      sql: "SELECT value FROM _meta WHERE key = ? LIMIT 1",
-      args: [BULK_WRITE_STATE_META_KEY]
-    });
-    const row = result.rows[0];
-    return row?.value === "active";
-  } catch {
-    return false;
-  }
-}
-async function ensureVectorIndexes(db) {
-  try {
-    await db.execute(CREATE_ENTRIES_EMBEDDING_INDEX_SQL);
-    await db.execute(CREATE_EPISODES_EMBEDDING_INDEX_SQL);
-  } catch (error) {
-    if (!isVectorUnavailableError(error)) {
-      throw error;
-    }
-  }
-}
-async function dropVectorIndexes(db) {
-  try {
-    await db.execute(`DROP INDEX IF EXISTS ${VECTOR_INDEX_NAME}`);
-    await db.execute(`DROP INDEX IF EXISTS ${EPISODE_VECTOR_INDEX_NAME}`);
-  } catch (error) {
-    if (!isVectorUnavailableError(error)) {
-      throw error;
-    }
-  }
-}
-async function runImmediateTransaction(db, fn) {
-  await db.execute("BEGIN IMMEDIATE");
-  try {
-    await fn();
-    await db.execute("COMMIT");
-  } catch (error) {
-    try {
-      await db.execute("ROLLBACK");
-    } catch {
-    }
-    throw error;
-  }
-}
-function isVectorUnavailableError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return /libsql_vector_idx|vector32|vector_top_k|vector|no such function|unsupported/i.test(message);
-}
-
-// src/adapters/db/client.ts
-var DEFAULT_BUSY_TIMEOUT_MS = 3e3;
-async function createDatabase(dbPath) {
-  const client = await openClient(dbPath);
-  const database = new LibsqlDatabase(client, client);
-  await database.init();
-  return database;
-}
-var LibsqlDatabase = class _LibsqlDatabase {
-  /** Creates a database adapter over a shared client and SQL executor. */
-  constructor(client, executor) {
-    this.client = client;
-    this.executor = executor;
-  }
-  /** Inserts a new entry row and its derived storage fields. */
-  async insertEntry(entry, embedding, contentHash) {
-    return insertEntry(this.executor, entry, embedding, contentHash);
-  }
-  /** Drops indexes and triggers that slow down bulk ingest writes. */
-  async prepareForBulkWrites() {
-    await prepareBulkWrites(this.client);
-  }
-  /** Restores indexes and triggers after bulk ingest writes complete. */
-  async finalizeBulkWrites() {
-    await finalizeBulkWrites(this.client);
-  }
-  /** Loads entries by identifier while preserving caller order when possible. */
-  async getEntries(ids) {
-    return getEntries(this.executor, ids);
-  }
-  /** Loads a single entry by identifier. */
-  async getEntry(id) {
-    return getEntry(this.executor, id);
-  }
-  /** Finds which exact content hashes already exist in storage. */
-  async findExistingHashes(hashes) {
-    return findExistingHashes(this.executor, hashes);
-  }
-  /** Loads one episode by stable `(source, sourceId)` identity. */
-  async getEpisodeBySourceId(source, sourceId) {
-    return getEpisodeBySourceId(this.executor, source, sourceId);
-  }
-  /** Loads one episode by fallback `(source, transcriptHash)` identity. */
-  async getEpisodeByTranscriptHash(source, transcriptHash) {
-    return getEpisodeByTranscriptHash(this.executor, source, transcriptHash);
-  }
-  /** Inserts or updates an episodic-memory row using normalized change detection. */
-  async upsertEpisode(input) {
-    return upsertEpisode(this.executor, input);
-  }
-  /** Lists active episodes whose time range overlaps the requested window. */
-  async listEpisodesByTimeWindow(window, limit) {
-    return listEpisodesByTimeWindow(this.executor, window, limit);
-  }
-  /** Finds active episodes by vector similarity. */
-  async episodeVectorSearch(params) {
-    return episodeVectorSearch(this.executor, params);
-  }
-  /** Lists active episodes that are still missing embeddings. */
-  async listEpisodesWithoutEmbeddings(limit) {
-    return listEpisodesWithoutEmbeddings(this.executor, limit);
-  }
-  /** Updates only the embedding payload for one episode row. */
-  async updateEpisodeEmbedding(id, embedding) {
-    await updateEpisodeEmbedding(this.executor, id, embedding);
-  }
-  /** Finds which normalized content hashes already exist in storage. */
-  async findExistingNormHashes(hashes) {
-    return findExistingNormHashes(this.executor, hashes);
-  }
-  /** Marks an entry as retired with an optional reason. */
-  async retireEntry(id, reason) {
-    return retireEntry(this.executor, id, reason);
-  }
-  /** Marks one active entry as superseded by a newer entry. */
-  async supersedeEntry(oldId, newId, kind, reason) {
-    return supersedeEntry(this.executor, oldId, newId, kind, reason);
-  }
-  /** Finds active entries by exact claim key. */
-  async findActiveEntriesByClaimKey(claimKey) {
-    return findActiveEntriesByClaimKey(this.executor, claimKey);
-  }
-  /** Lists distinct entity prefixes derived from active claim keys. */
-  async getDistinctClaimKeyPrefixes() {
-    return getDistinctClaimKeyPrefixes(this.executor);
-  }
-  /** Lists bounded full claim-key examples ordered for extraction hinting. */
-  async getClaimKeyExamples(limit) {
-    return getClaimKeyExamples(this.executor, limit);
-  }
-  /** Updates mutable entry fields such as importance, expiry, and temporal metadata. */
-  async updateEntry(id, fields) {
-    return updateEntry(this.executor, id, fields);
-  }
-  /** Looks up the ingest log row for a previously processed file. */
-  async getIngestLogEntry(filePath) {
-    return getIngestLogEntry(this.executor, filePath);
-  }
-  /** Upserts ingest metadata for a processed transcript file. */
-  async insertIngestLogEntry(filePath, fileHash, entryCount) {
-    return insertIngestLogEntry(this.executor, filePath, fileHash, entryCount);
-  }
-  /** Ensures the schema exists before the adapter is used. */
-  async init() {
-    await initSchema(this.client);
-  }
-  /** Closes the underlying libSQL client. */
-  async close() {
-    this.client.close();
-  }
-  /** Executes a callback inside a write transaction when supported. */
-  async withTransaction(fn) {
-    if (this.executor !== this.client) {
-      return fn(this);
-    }
-    const transaction = await this.client.transaction("write");
-    const transactionDb = new _LibsqlDatabase(this.client, transaction);
-    try {
-      const result = await fn(transactionDb);
-      await transaction.commit();
-      return result;
-    } catch (error) {
-      await rollbackTransaction(transaction);
-      throw error;
-    } finally {
-      transaction.close();
-    }
-  }
-  /** Executes one statement through the shared libSQL executor. */
-  async execute(statementOrSql, args) {
-    if (typeof statementOrSql === "string") {
-      return this.executor.execute(statementOrSql, args);
-    }
-    return this.executor.execute(statementOrSql);
-  }
-};
-async function openClient(dbPath) {
-  const trimmedPath = dbPath.trim();
-  if (trimmedPath.length === 0) {
-    throw new Error("Database path must not be empty.");
-  }
-  if (trimmedPath !== ":memory:" && !trimmedPath.startsWith("file:")) {
-    const resolvedPath = path.resolve(trimmedPath);
-    await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
-  }
-  const client = createClient({ url: resolveClientUrl(trimmedPath) });
-  await client.execute("PRAGMA foreign_keys = ON");
-  await client.execute(`PRAGMA busy_timeout=${DEFAULT_BUSY_TIMEOUT_MS}`);
-  if (trimmedPath !== ":memory:") {
-    await client.execute("PRAGMA journal_mode=WAL");
-  }
-  return client;
-}
-function resolveClientUrl(dbPath) {
-  if (dbPath === ":memory:") {
-    return dbPath;
-  }
-  if (dbPath.startsWith("file:")) {
-    return dbPath;
-  }
-  return `file:${path.resolve(dbPath)}`;
-}
-async function rollbackTransaction(transaction) {
-  if (transaction.closed) {
-    return;
-  }
-  await transaction.rollback();
-}
-
-// src/config.ts
-import fs2 from "fs";
-import os from "os";
-import path2 from "path";
-import { fileURLToPath } from "url";
-
-// src/core/types.ts
-var ENTRY_TYPES = ["fact", "decision", "preference", "lesson", "relationship", "milestone"];
-var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
-var EPISODE_ACTIVITY_LEVELS = ["substantial", "minimal", "none"];
-
-// src/config.ts
-var AUTH_METHOD_DEFINITIONS = [
-  {
-    id: "openai-api-key",
-    provider: "openai",
-    title: "OpenAI API key",
-    setupDescription: "Standard OpenAI API key. Pay per token.",
-    preferredModels: ["gpt-5.4-mini", "gpt-5.4", "gpt-5.4-nano"]
-  },
-  {
-    id: "openai-subscription",
-    provider: "openai-codex",
-    title: "OpenAI - Subscription (via Codex CLI)",
-    setupDescription: "Uses your Codex CLI login. No per-token cost. Requires `codex auth`.",
-    preferredModels: ["gpt-5.4-mini", "gpt-5.4"]
-  },
-  {
-    id: "anthropic-api-key",
-    provider: "anthropic",
-    title: "Anthropic API key",
-    setupDescription: "Standard Anthropic API key. Pay per token.",
-    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
-  },
-  {
-    id: "anthropic-oauth",
-    provider: "anthropic",
-    title: "Anthropic - Claude subscription (OAuth)",
-    setupDescription: "Uses your Claude Code CLI login. No per-token cost.",
-    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
-  },
-  {
-    id: "anthropic-token",
-    provider: "anthropic",
-    title: "Anthropic - Claude subscription (long-lived token)",
-    setupDescription: "Uses a Claude long-lived token instead of an API key.",
-    preferredModels: ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
-  }
-];
-var AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((definition) => definition.id));
-var DEFAULT_CONFIG_DIR = path2.join(os.homedir(), ".agenr");
-var DEFAULT_DB_NAME = "knowledge.db";
-var CONFIG_DIR_MODE = 448;
-var CONFIG_FILE_MODE = 384;
-var DEFAULT_SURGEON_COST_CAP = 15;
-var DEFAULT_SURGEON_DAILY_COST_CAP = 75;
-var DEFAULT_SURGEON_CONTEXT_LIMIT = 0;
-var DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS = 14;
-var DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE = 9;
-var DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS = 7;
-var DEFAULT_CLAIM_EXTRACTION_CONCURRENCY = 10;
-var DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD = 0.8;
-var DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES = ["fact", "preference", "decision", "lesson"];
-function isAgenrAuthMethod(value) {
-  return AUTH_METHOD_SET.has(value);
-}
-function authMethodToProvider(auth) {
-  const definition = AUTH_METHOD_DEFINITIONS.find((candidate) => candidate.id === auth);
-  if (!definition) {
-    throw new Error(`Unsupported auth method "${auth}".`);
-  }
-  return definition.provider;
-}
-function getAuthMethodDefinition(auth) {
-  const definition = AUTH_METHOD_DEFINITIONS.find((candidate) => candidate.id === auth);
-  if (!definition) {
-    throw new Error(`Unsupported auth method "${auth}".`);
-  }
-  return definition;
-}
-function resolveConfigDir() {
-  return process.env.AGENR_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
-}
-function resolveConfigPath(options = {}) {
-  const envConfigPath = normalizeOptionalString3(process.env.AGENR_CONFIG_PATH);
-  if (envConfigPath) {
-    return envConfigPath;
-  }
-  const explicitConfigPath = normalizeOptionalString3(options.configPath);
-  if (explicitConfigPath) {
-    return explicitConfigPath;
-  }
-  const adjacentConfigPath = resolveAdjacentConfigPath(options.dbPath);
-  if (adjacentConfigPath) {
-    return adjacentConfigPath;
-  }
-  return path2.join(resolveConfigDir(), "config.json");
-}
-function resolveDbPath(config) {
-  return process.env.AGENR_DB_PATH ?? config?.dbPath ?? path2.join(resolveConfigDir(), DEFAULT_DB_NAME);
-}
-function resolveClaimExtractionConfig(config) {
-  return {
-    enabled: config?.claimExtraction?.enabled ?? true,
-    confidenceThreshold: normalizeClaimExtractionConfidence(config?.claimExtraction?.confidenceThreshold),
-    eligibleTypes: normalizeClaimExtractionEligibleTypes(config?.claimExtraction?.eligibleTypes),
-    concurrency: normalizeClaimExtractionConcurrency(config?.claimExtraction?.concurrency)
-  };
-}
-function readConfig(options = {}) {
-  const configPath = resolveFilesystemPath(resolveConfigPath(options));
-  if (!fs2.existsSync(configPath)) {
-    return {};
-  }
-  let parsed;
-  try {
-    const raw = fs2.readFileSync(configPath, "utf-8");
-    parsed = JSON.parse(raw);
-  } catch {
-    return {};
-  }
-  if (!isRecord(parsed)) {
-    return {};
-  }
-  assertSupportedConfig(parsed, configPath);
-  return parsed;
-}
-function configFileExists(options = {}) {
-  return fs2.existsSync(resolveFilesystemPath(resolveConfigPath(options)));
-}
-function writeConfig(config, options = {}) {
-  const configPath = resolveFilesystemPath(resolveConfigPath(options));
-  const configDir = path2.dirname(configPath);
-  assertSupportedConfig(config, configPath);
-  fs2.mkdirSync(configDir, { recursive: true, mode: CONFIG_DIR_MODE });
-  try {
-    fs2.chmodSync(configDir, CONFIG_DIR_MODE);
-  } catch {
-  }
-  fs2.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
-`, {
-    encoding: "utf-8",
-    mode: CONFIG_FILE_MODE
-  });
-  try {
-    fs2.chmodSync(configPath, CONFIG_FILE_MODE);
-  } catch {
-  }
-}
-function resolveAdjacentConfigPath(dbPath) {
-  const normalizedDbPath = normalizeOptionalString3(dbPath);
-  if (!normalizedDbPath || normalizedDbPath === ":memory:") {
-    return void 0;
-  }
-  if (normalizedDbPath.startsWith("file:")) {
-    try {
-      return path2.join(path2.dirname(fileURLToPath(normalizedDbPath)), "config.json");
-    } catch {
-      return void 0;
-    }
-  }
-  return path2.join(path2.dirname(normalizedDbPath), "config.json");
-}
-function normalizeOptionalString3(value) {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-function assertSupportedConfig(config, configPath) {
-  const unsupportedFields = ["apiKey", "embeddingApiKey"].filter((field) => field in config);
-  if (unsupportedFields.length === 0) {
-    return;
-  }
-  throw new Error(
-    `Unsupported agenr config field(s) in ${configPath}: ${unsupportedFields.join(", ")}. Move \`apiKey\` to \`credentials.openaiApiKey\` or \`credentials.anthropicApiKey\` depending on your configured auth, move \`embeddingApiKey\` to \`credentials.openaiApiKey\`, then remove the legacy fields.`
-  );
-}
-function resolveFilesystemPath(targetPath) {
-  if (!targetPath.startsWith("file:")) {
-    return targetPath;
-  }
-  try {
-    return fileURLToPath(targetPath);
-  } catch {
-    return targetPath;
-  }
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeClaimExtractionConfidence(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD;
-  }
-  return Math.min(1, Math.max(0, value));
-}
-function normalizeClaimExtractionEligibleTypes(value) {
-  if (!Array.isArray(value) || value.length === 0) {
-    return [...DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES];
-  }
-  const normalized = Array.from(new Set(value.filter((candidate) => ENTRY_TYPES.includes(candidate))));
-  return normalized.length > 0 ? normalized : [...DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES];
-}
-function normalizeClaimExtractionConcurrency(value) {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
-  }
-  const normalized = Math.trunc(value);
-  return normalized > 0 ? normalized : DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
-}
-
-// src/core/store/embedding-text.ts
-function composeEmbeddingText(entry) {
-  return `${entry.type}: ${entry.subject} - ${entry.content}`;
-}
-
-// src/adapters/embeddings.ts
-var OPENAI_EMBEDDINGS_URL = "https://api.openai.com/v1/embeddings";
-var EMBEDDING_MODEL = "text-embedding-3-small";
-var EMBEDDING_DIMENSIONS = 1024;
-var EMBEDDING_BATCH_SIZE = 200;
-var EMBEDDING_MAX_CONCURRENCY = 3;
-var EMBEDDING_MAX_RETRIES = 5;
-function createEmbeddingClient(apiKey, model = EMBEDDING_MODEL) {
-  const normalizedApiKey = apiKey.trim();
-  if (normalizedApiKey.length === 0) {
-    throw new Error("Embedding API key must not be empty.");
-  }
-  const normalizedModel = model.trim().length > 0 ? model.trim() : EMBEDDING_MODEL;
-  return {
-    embed: async (texts) => embedTexts(texts, normalizedApiKey, normalizedModel)
-  };
-}
-function resolveEmbeddingApiKey(config) {
-  const candidates = [config?.credentials?.openaiApiKey, process.env.OPENAI_API_KEY];
-  for (const candidate of candidates) {
-    const normalized = candidate?.trim();
-    if (normalized && normalized.length > 0) {
-      return normalized;
-    }
-  }
-  throw new Error("Embedding API key is required. Set config.credentials.openaiApiKey or OPENAI_API_KEY.");
-}
-function resolveEmbeddingModel(config) {
-  const configuredModel = config?.embeddingModel?.trim();
-  return configuredModel && configuredModel.length > 0 ? configuredModel : EMBEDDING_MODEL;
-}
-async function embedTexts(texts, apiKey, model) {
-  if (texts.length === 0) {
-    return [];
-  }
-  const chunks = chunkValues2(texts, EMBEDDING_BATCH_SIZE);
-  const chunkResults = new Array(chunks.length);
-  let nextChunkIndex = 0;
-  await Promise.all(
-    Array.from({ length: Math.min(EMBEDDING_MAX_CONCURRENCY, chunks.length) }, async () => {
-      while (true) {
-        const chunkIndex = nextChunkIndex;
-        nextChunkIndex += 1;
-        if (chunkIndex >= chunks.length) {
-          return;
-        }
-        chunkResults[chunkIndex] = await requestEmbeddingBatch(chunks[chunkIndex], apiKey, model);
-      }
-    })
-  );
-  return chunkResults.flat();
-}
-async function requestEmbeddingBatch(texts, apiKey, model) {
-  let lastError = null;
-  for (let attempt = 1; attempt <= EMBEDDING_MAX_RETRIES; attempt += 1) {
-    try {
-      const response = await fetch(OPENAI_EMBEDDINGS_URL, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          model,
-          dimensions: EMBEDDING_DIMENSIONS,
-          input: texts
-        })
-      });
-      const rawBody = await response.text();
-      if (!response.ok) {
-        lastError = buildHttpError(response.status, rawBody);
-        if (attempt < EMBEDDING_MAX_RETRIES && isRetryableStatus(response.status)) {
-          await sleep(backoffMs(attempt));
-          continue;
-        }
-        throw lastError;
-      }
-      return parseEmbeddingResponse(rawBody, texts.length);
-    } catch (error) {
-      lastError = normalizeFetchError(error);
-      if (attempt < EMBEDDING_MAX_RETRIES && isRetryableError(lastError)) {
-        await sleep(backoffMs(attempt));
-        continue;
-      }
-      throw lastError;
-    }
-  }
-  throw lastError ?? new Error("OpenAI embeddings request failed.");
-}
-function parseEmbeddingResponse(rawBody, expectedLength) {
-  let parsed;
-  try {
-    parsed = JSON.parse(rawBody);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`OpenAI embeddings response was not valid JSON: ${message}`, {
-      cause: error
-    });
-  }
-  if (!Array.isArray(parsed.data)) {
-    throw new Error("OpenAI embeddings response missing data array.");
-  }
-  const sorted = [...parsed.data].sort((left, right) => left.index - right.index);
-  if (sorted.length !== expectedLength) {
-    throw new Error(`OpenAI embeddings response length mismatch: expected ${expectedLength}, received ${sorted.length}.`);
-  }
-  return sorted.map((item) => {
-    if (!Array.isArray(item.embedding)) {
-      throw new Error("OpenAI embeddings response contained an item with no embedding array.");
-    }
-    if (!item.embedding.every((value) => typeof value === "number" && Number.isFinite(value))) {
-      throw new Error("OpenAI embeddings response contained a non-numeric embedding value.");
-    }
-    return [...item.embedding];
-  });
-}
-function normalizeFetchError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
-}
-function isRetryableStatus(status) {
-  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
-}
-function isRetryableError(error) {
-  const message = error.message.toLowerCase();
-  return message.includes("429") || message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504") || message.includes("timeout") || message.includes("network") || message.includes("connection") || message.includes("fetch failed");
-}
-function buildHttpError(status, rawBody) {
-  const detail = getErrorSnippet(rawBody);
-  if (status === 401) {
-    return new Error(`OpenAI embeddings request failed (401): invalid API key. ${detail}`);
-  }
-  if (status === 429) {
-    return new Error(`OpenAI embeddings request failed (429): rate limited. ${detail}`);
-  }
-  return new Error(`OpenAI embeddings request failed (${status}): ${detail}`);
-}
-function getErrorSnippet(rawBody) {
-  const trimmed = rawBody.trim();
-  if (trimmed.length === 0) {
-    return "unknown error";
-  }
-  try {
-    const parsed = JSON.parse(trimmed);
-    const message = parsed.error?.message;
-    if (typeof message === "string" && message.trim().length > 0) {
-      return message.trim();
-    }
-  } catch {
-  }
-  const maxLength = 200;
-  return trimmed.length <= maxLength ? trimmed : `${trimmed.slice(0, maxLength)}...`;
-}
-function chunkValues2(values, chunkSize) {
-  const chunks = [];
-  for (let index = 0; index < values.length; index += chunkSize) {
-    chunks.push(values.slice(index, index + chunkSize));
-  }
-  return chunks;
-}
-function backoffMs(attempt) {
-  return Math.min(2e3 * 2 ** (attempt - 1), 6e4);
-}
-async function sleep(durationMs) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, durationMs);
-  });
-}
-
-// src/adapters/db/recall-adapter.ts
-var ENTRY_SELECT_COLUMNS = `
-  e.id,
-  e.type,
-  e.subject,
-  e.content,
-  e.importance,
-  e.expiry,
-  e.tags,
-  e.source_file,
-  e.source_context,
-  e.embedding,
-  e.content_hash,
-  e.norm_content_hash,
-  e.quality_score,
-  e.recall_count,
-  e.last_recalled_at,
-  e.superseded_by,
-  e.valid_from,
-  e.valid_to,
-  e.claim_key,
-  e.supersession_kind,
-  e.supersession_reason,
-  e.cluster_id,
-  e.user_id,
-  e.project,
-  e.retired,
-  e.retired_at,
-  e.retired_reason,
-  e.created_at,
-  e.updated_at
-`;
-var RECALL_CANDIDATE_SELECT_COLUMNS = `
-  e.id,
-  e.subject,
-  e.content,
-  e.importance,
-  e.expiry,
-  e.embedding,
-  e.superseded_by,
-  e.claim_key,
-  e.retired,
-  e.created_at
-`;
-var FTS_TIERS = ["exact", "all_tokens", "any_tokens"];
-var PREDECESSOR_EXPANSION_LIMIT_PER_SEED = 8;
-var PREDECESSOR_EXPANSION_MAX_RESULTS = 40;
-function createRecallAdapter(executor, embeddingPort) {
-  return new LibsqlRecallAdapter(executor, embeddingPort);
-}
-var LibsqlRecallAdapter = class {
-  /**
-   * Creates a recall adapter over a SQL executor and embedding provider.
-   *
-   * @param executor - SQL executor used for reads and telemetry writes.
-   * @param embeddingPort - Embedding provider used for query embeddings.
-   */
-  constructor(executor, embeddingPort) {
-    this.executor = executor;
-    this.embeddingPort = embeddingPort;
-  }
-  pendingWrites = Promise.resolve();
-  /** Computes the query embedding by reusing the shared embedding port. */
-  async embed(text) {
-    const results = await this.embeddingPort.embed([text]);
-    return results[0] ?? [];
-  }
-  /** Finds ranking-time vector candidates with SQL-level filters applied. */
-  async vectorSearch(params) {
-    if (params.limit <= 0 || params.embedding.length === 0) {
-      return [];
-    }
-    const serializedEmbedding = serializeEmbeddingForVector(params.embedding);
-    if (!serializedEmbedding) {
-      return [];
-    }
-    const filters = buildEntryFilterClause(params.filters, "e");
-    let result;
-    try {
-      result = await this.executor.execute({
-        sql: `
-          SELECT
-            ${RECALL_CANDIDATE_SELECT_COLUMNS}
-          FROM vector_top_k('idx_entries_embedding', vector32(?), ?) AS v
-          JOIN entries AS e ON e.rowid = v.id
-          WHERE ${buildActiveEntryClause("e")}
-            ${filters.sql}
-          LIMIT ?
-        `,
-        args: [serializedEmbedding, params.limit, ...filters.args, params.limit]
-      });
-    } catch (error) {
-      throw wrapVectorError(error);
-    }
-    return result.rows.map((row) => ({
-      entry: mapRecallCandidateRow(row),
-      vectorSim: cosineSimilarity(params.embedding, readEmbedding(row, "embedding"))
-    })).filter((candidate) => candidate.vectorSim > 0).sort((left, right) => right.vectorSim - left.vectorSim).slice(0, params.limit);
-  }
-  /** Finds ranking-time FTS candidates using the exact -> AND -> OR cascade. */
-  async ftsSearch(params) {
-    if (params.limit <= 0) {
-      return [];
-    }
-    const plan = buildLexicalPlan(params.text);
-    if (plan.length === 0) {
-      return [];
-    }
-    const filters = buildEntryFilterClause(params.filters, "e");
-    const matches = /* @__PURE__ */ new Map();
-    for (const tier of plan) {
-      const query = compileLexicalTier(tier);
-      let result;
-      try {
-        result = await this.executor.execute({
-          sql: `
-            SELECT
-              ${RECALL_CANDIDATE_SELECT_COLUMNS},
-              bm25(entries_fts, 1.0, 2.0) AS rank
-            FROM entries_fts
-            JOIN entries AS e ON e.rowid = entries_fts.rowid
-            WHERE entries_fts MATCH ?
-              AND ${buildActiveEntryClause("e")}
-              ${filters.sql}
-            ORDER BY bm25(entries_fts, 1.0, 2.0)
-            LIMIT ?
-          `,
-          args: [query, ...filters.args, params.limit]
-        });
-      } catch {
-        continue;
-      }
-      for (const row of result.rows) {
-        const entryId = readRequiredString(row, "id");
-        if (matches.has(entryId)) {
-          continue;
-        }
-        matches.set(entryId, {
-          entry: mapRecallCandidateRow(row),
-          rank: readNumber(row, "rank", Number.POSITIVE_INFINITY),
-          tier: tier.tier
-        });
-      }
-    }
-    return Array.from(matches.values()).sort((left, right) => compareFtsCandidates(left, right)).slice(0, params.limit);
-  }
-  /**
-   * Finds historical predecessors scoped to a seed set of active candidate IDs.
-   *
-   * Direct supersession links are preferred. Same-claim-key siblings are used as
-   * the structural lineage path, with retired same-subject entries preserved as
-   * a weaker fallback when explicit slot identity is unavailable.
-   */
-  async fetchPredecessors(params) {
-    const normalizedIds = normalizeStrings(params.activeEntryIds);
-    if (normalizedIds.length === 0) {
-      return [];
-    }
-    const placeholders = normalizedIds.map(() => "?").join(", ");
-    const expansionLimit = normalizePredecessorExpansionLimit(normalizedIds.length);
-    const result = await this.executor.execute({
-      sql: `
-        WITH seed AS (
-          SELECT id, subject, claim_key
-          FROM entries
-          WHERE id IN (${placeholders})
-        ),
-        seed_subjects AS (
-          SELECT DISTINCT subject
-          FROM seed
-          WHERE TRIM(subject) <> ''
-        ),
-        seed_claim_keys AS (
-          SELECT DISTINCT claim_key
-          FROM seed
-          WHERE claim_key IS NOT NULL
-        ),
-        lineage AS (
-          SELECT
-            ${RECALL_CANDIDATE_SELECT_COLUMNS},
-            CASE
-              WHEN e.superseded_by IN (SELECT id FROM seed) THEN 0
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-                AND (e.retired = 1 OR e.superseded_by IS NOT NULL) THEN 1
-              WHEN e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys) THEN 2
-              WHEN e.retired = 1
-                AND e.subject IN (SELECT subject FROM seed_subjects) THEN 3
-              ELSE 4
-            END AS lineage_priority
-          FROM entries AS e
-          WHERE e.id NOT IN (SELECT id FROM seed)
-            AND (
-              e.superseded_by IN (SELECT id FROM seed)
-              OR (
-                e.claim_key IS NOT NULL
-                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
-              )
-              OR (
-                e.retired = 1
-                AND e.subject IN (SELECT subject FROM seed_subjects)
-              )
-            )
-        )
-        SELECT *
-        FROM lineage
-        ORDER BY lineage_priority ASC, created_at ASC, id ASC
-        LIMIT ?
-      `,
-      args: [...normalizedIds, expansionLimit]
-    });
-    return result.rows.map((row) => mapRecallCandidateRow(row));
-  }
-  /** Hydrates full entries for the final ranked result set. */
-  async hydrateEntries(ids) {
-    const normalizedIds = normalizeStrings(ids);
-    if (normalizedIds.length === 0) {
-      return [];
-    }
-    const placeholders = normalizedIds.map(() => "?").join(", ");
-    const result = await this.executor.execute({
-      sql: `
-        SELECT
-          ${ENTRY_SELECT_COLUMNS}
-        FROM entries AS e
-        WHERE e.id IN (${placeholders})
-      `,
-      args: normalizedIds
-    });
-    return result.rows.map((row) => mapEntryRow(row));
-  }
-  /**
-   * Queues telemetry writes internally while keeping recall callers synchronous.
-   *
-   * Errors are swallowed per entry because telemetry must never fail recall.
-   */
-  async recordRecallEvents(params) {
-    const task = this.pendingWrites.then(async () => {
-      for (const entryId of params.entryIds) {
-        try {
-          await recordRecallEvent(this.executor, entryId, params.query, params.sessionKey);
-        } catch {
-        }
-      }
-    });
-    this.pendingWrites = task.catch(() => void 0);
-    await this.pendingWrites;
-  }
-};
-function buildEntryFilterClause(filters, alias) {
-  if (!filters) {
-    return { sql: "", args: [] };
-  }
-  const clauses = [];
-  const args = [];
-  const types = normalizeStrings(filters.types);
-  if (types.length > 0) {
-    clauses.push(`${alias}.type IN (${types.map(() => "?").join(", ")})`);
-    args.push(...types);
-  }
-  const tags = normalizeStrings(filters.tags);
-  for (const tag of tags) {
-    clauses.push(`EXISTS (
-      SELECT 1
-      FROM json_each(CASE WHEN json_valid(${alias}.tags) THEN ${alias}.tags ELSE '[]' END)
-      WHERE json_each.value = ?
-    )`);
-    args.push(tag);
-  }
-  if (filters.since) {
-    clauses.push(`${alias}.created_at >= ?`);
-    args.push(filters.since.toISOString());
-  }
-  if (filters.until) {
-    clauses.push(`${alias}.created_at <= ?`);
-    args.push(filters.until.toISOString());
-  }
-  if (clauses.length === 0) {
-    return { sql: "", args };
-  }
-  return {
-    sql: `AND ${clauses.join("\n              AND ")}`,
-    args
-  };
-}
-function normalizeStrings(values) {
-  if (!values) {
-    return [];
-  }
-  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
-}
-function compareFtsCandidates(left, right) {
-  const tierDelta = ftsTierPriority(left.tier) - ftsTierPriority(right.tier);
-  if (tierDelta !== 0) {
-    return tierDelta;
-  }
-  return left.rank - right.rank;
-}
-function ftsTierPriority(tier) {
-  return FTS_TIERS.indexOf(tier);
-}
-function compileLexicalTier(tier) {
-  if (tier.tier === "exact") {
-    return `"${tier.text.replaceAll('"', '""')}"`;
-  }
-  return tier.tier === "all_tokens" ? tier.tokens.join(" ") : tier.tokens.join(" OR ");
-}
-function mapRecallCandidateRow(row) {
-  const expiry = readRequiredString(row, "expiry");
-  return {
-    id: readRequiredString(row, "id"),
-    subject: readRequiredString(row, "subject"),
-    content: readRequiredString(row, "content"),
-    importance: readNumber(row, "importance", 0),
-    expiry,
-    embedding: readEmbedding(row, "embedding"),
-    superseded_by: readOptionalString(row, "superseded_by"),
-    claim_key: readOptionalString(row, "claim_key"),
-    retired: readBoolean(row, "retired"),
-    created_at: readRequiredString(row, "created_at")
-  };
-}
-function normalizePredecessorExpansionLimit(seedCount) {
-  return Math.min(PREDECESSOR_EXPANSION_MAX_RESULTS, seedCount * PREDECESSOR_EXPANSION_LIMIT_PER_SEED);
-}
-function wrapVectorError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return new Error(`Vector search is unavailable: ${message}`);
-}
-
-export {
-  buildActiveEntryClause,
-  deserializeTags,
-  readRequiredString,
-  readOptionalString,
-  readNumber,
-  readBoolean,
-  mapEntryRow,
-  getEntry,
-  retireEntry,
-  supersedeEntry,
-  updateEntry,
-  VECTOR_INDEX_NAME,
-  getLastBulkIngestAt,
-  createDatabase,
-  ENTRY_TYPES,
-  EXPIRY_LEVELS,
-  EPISODE_ACTIVITY_LEVELS,
-  DEFAULT_SURGEON_COST_CAP,
-  DEFAULT_SURGEON_DAILY_COST_CAP,
-  DEFAULT_SURGEON_CONTEXT_LIMIT,
-  DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS,
-  DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE,
-  DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS,
-  DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
-  isAgenrAuthMethod,
-  authMethodToProvider,
-  getAuthMethodDefinition,
-  resolveConfigPath,
-  resolveDbPath,
-  resolveClaimExtractionConfig,
-  readConfig,
-  configFileExists,
-  writeConfig,
-  composeEmbeddingText,
-  EMBEDDING_MODEL,
-  EMBEDDING_DIMENSIONS,
-  createEmbeddingClient,
-  resolveEmbeddingApiKey,
-  resolveEmbeddingModel,
-  createRecallAdapter
-};