agenr 0.9.21 → 0.9.23

package/dist/chunk-56GW7EIS.js

@@ -0,0 +1,2821 @@
+import {
+  getCoRecallEdgeCounts,
+  parseDaysBetween,
+  toNumber,
+  toRowsAffected,
+  toStringValue
+} from "./chunk-RM5SLLEM.js";
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// src/llm/models.ts
+import { getModel } from "@mariozechner/pi-ai";
+var PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "openai-codex"]);
+var MODEL_ALIASES = {
+  anthropic: {
+    opus: "claude-opus-4-6",
+    sonnet: "claude-sonnet-4-20250514",
+    "claude-opus": "claude-opus-4-6"
+  },
+  openai: {
+    gpt: "gpt-5.2-codex",
+    "gpt-codex": "gpt-5.2-codex",
+    "gpt-4.1-nano": "openai/gpt-4.1-nano",
+    "gpt-4.1-mini": "openai/gpt-4.1-mini",
+    "gpt-4.1": "openai/gpt-4.1",
+    "gpt-5-nano": "openai/gpt-5-nano"
+  },
+  "openai-codex": {
+    codex: "gpt-5.3-codex",
+    "gpt-codex": "gpt-5.3-codex"
+  }
+};
+function isAgenrProvider(value) {
+  return PROVIDERS.has(value);
+}
+function normalizeProvider(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!isAgenrProvider(normalized)) {
+    throw new Error(
+      `Unsupported provider "${value}". Expected one of: anthropic, openai, openai-codex.`
+    );
+  }
+  return normalized;
+}
+function normalizeModelId(provider, model) {
+  const trimmed = model.trim();
+  if (!trimmed) {
+    throw new Error("Model cannot be empty.");
+  }
+  const aliasKey = trimmed.toLowerCase();
+  return MODEL_ALIASES[provider][aliasKey] ?? trimmed;
+}
+function resolveModel(providerRaw, modelRaw) {
+  const provider = normalizeProvider(providerRaw);
+  const modelId = normalizeModelId(provider, modelRaw);
+  const fallbackModelId = modelId.startsWith(`${provider}/`) ? modelId.slice(provider.length + 1) : void 0;
+  const candidateModelIds = [modelId, fallbackModelId].filter((value) => Boolean(value));
+  let model;
+  for (const candidateId of candidateModelIds) {
+    try {
+      const candidate = getModel(provider, candidateId);
+      if (candidate && typeof candidate.id === "string" && candidate.id.trim()) {
+        model = candidate;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!model) {
+    throw new Error(
+      `Model "${modelId}" is not available for provider "${provider}" in @mariozechner/pi-ai.`
+    );
+  }
+  return {
+    provider,
+    modelId,
+    model
+  };
+}
+
+// src/utils/string.ts
+function normalizeLabel(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/config.ts
+var AUTH_METHOD_DEFINITIONS = [
+  {
+    id: "anthropic-oauth",
+    provider: "anthropic",
+    title: "Anthropic -- Claude subscription (OAuth)",
+    setupDescription: "Uses your Claude Pro/Team subscription via Claude CLI credentials. No per-token cost. Requires Claude Code CLI.",
+    preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
+  },
+  {
+    id: "anthropic-token",
+    provider: "anthropic",
+    title: "Anthropic -- Claude subscription (long-lived token)",
+    setupDescription: "Uses a long-lived token from `claude setup-token`. No per-token cost. Simpler setup.",
+    preferredModels: ["claude-opus-4-6", "claude-sonnet-4-20250514", "claude-haiku-3-5-20241022"]
+  },
+  {
+    id: "anthropic-api-key",
+    provider: "anthropic",
+    title: "Anthropic -- API key",
+    setupDescription: "Standard API key from console.anthropic.com. Pay per token.",
+    preferredModels: ["claude-sonnet-4-20250514", "claude-opus-4-6", "claude-haiku-3-5-20241022"]
+  },
+  {
+    id: "openai-subscription",
+    provider: "openai-codex",
+    title: "OpenAI -- Subscription (via Codex CLI)",
+    setupDescription: "Uses your ChatGPT Plus subscription via Codex CLI credentials. No per-token cost. Requires Codex CLI.",
+    preferredModels: ["gpt-5.3-codex", "o3-codex"]
+  },
+  {
+    id: "openai-api-key",
+    provider: "openai",
+    title: "OpenAI -- API key",
+    setupDescription: "Standard API key from https://platform.openai.com/api-keys. Pay per token.",
+    preferredModels: ["gpt-4.1-nano", "gpt-4.1-mini", "gpt-5-nano"]
+  }
+];
+var AUTH_METHOD_SET = new Set(AUTH_METHOD_DEFINITIONS.map((item) => item.id));
+var PROVIDER_SET = /* @__PURE__ */ new Set(["anthropic", "openai", "openai-codex"]);
+var MODEL_TASK_KEYS = ["extraction", "claimExtraction", "contradictionJudge", "handoffSummary"];
+var CONFIG_FILE_MODE = 384;
+var CONFIG_DIR_MODE = 448;
+var DEFAULT_EMBEDDING_PROVIDER = "openai";
+var DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+var DEFAULT_EMBEDDING_DIMENSIONS = 1024;
+var DEFAULT_FORGETTING_SCORE_THRESHOLD = 0.05;
+var DEFAULT_FORGETTING_MAX_AGE_DAYS = 60;
+var DEFAULT_CONTRADICTION_ENABLED = true;
+var DEFAULT_TASK_MODEL = "gpt-4.1-nano";
+var DEFAULT_AUTO_SUPERSEDE_CONFIDENCE = 0.85;
+function isModelTask(value) {
+  return MODEL_TASK_KEYS.includes(value);
+}
+function resolveUserPath(inputPath) {
+  if (!inputPath.startsWith("~")) {
+    return inputPath;
+  }
+  return path.join(os.homedir(), inputPath.slice(1));
+}
+function resolveDefaultKnowledgeDbPath() {
+  return path.join(os.homedir(), ".agenr", "knowledge.db");
+}
+function resolveConfigPath(env = process.env) {
+  const explicit = env.AGENR_CONFIG_PATH?.trim();
+  if (explicit) {
+    return resolveUserPath(explicit);
+  }
+  return path.join(os.homedir(), ".agenr", "config.json");
+}
+function resolveConfigDir(env = process.env) {
+  return path.dirname(resolveConfigPath(env));
+}
+function isAgenrAuthMethod(value) {
+  return AUTH_METHOD_SET.has(value);
+}
+function isAgenrProvider2(value) {
+  return PROVIDER_SET.has(value);
+}
+function authMethodToProvider(auth) {
+  return AUTH_METHOD_DEFINITIONS.find((item) => item.id === auth)?.provider ?? "anthropic";
+}
+function getAuthMethodDefinition(auth) {
+  const found = AUTH_METHOD_DEFINITIONS.find((item) => item.id === auth);
+  if (!found) {
+    throw new Error(`Unsupported auth method "${auth}".`);
+  }
+  return found;
+}
+function normalizeStoredCredentials(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
+  }
+  const record = input;
+  const normalized = {};
+  if (typeof record.anthropicApiKey === "string" && record.anthropicApiKey.trim()) {
+    normalized.anthropicApiKey = record.anthropicApiKey.trim();
+  }
+  if (typeof record.anthropicOauthToken === "string" && record.anthropicOauthToken.trim()) {
+    normalized.anthropicOauthToken = record.anthropicOauthToken.trim();
+  }
+  if (typeof record.openaiApiKey === "string" && record.openaiApiKey.trim()) {
+    normalized.openaiApiKey = record.openaiApiKey.trim();
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeEmbeddingConfig(input) {
+  const normalized = {
+    provider: DEFAULT_EMBEDDING_PROVIDER,
+    model: DEFAULT_EMBEDDING_MODEL,
+    dimensions: DEFAULT_EMBEDDING_DIMENSIONS
+  };
+  if (!input || typeof input !== "object") {
+    return normalized;
+  }
+  const record = input;
+  if (record.provider === "openai") {
+    normalized.provider = record.provider;
+  }
+  if (typeof record.model === "string" && record.model.trim()) {
+    normalized.model = record.model.trim();
+  }
+  if (typeof record.dimensions === "number" && Number.isFinite(record.dimensions) && record.dimensions > 0) {
+    normalized.dimensions = Math.floor(record.dimensions);
+  }
+  if (typeof record.apiKey === "string" && record.apiKey.trim()) {
+    normalized.apiKey = record.apiKey.trim();
+  }
+  return normalized;
+}
+function normalizeDbConfig(input) {
+  const normalized = {
+    path: resolveDefaultKnowledgeDbPath()
+  };
+  if (!input || typeof input !== "object") {
+    return normalized;
+  }
+  const record = input;
+  if (typeof record.path === "string" && record.path.trim()) {
+    normalized.path = record.path.trim();
+  }
+  return normalized;
+}
+function normalizeForgettingConfig(input) {
+  const normalized = {
+    protect: [],
+    scoreThreshold: DEFAULT_FORGETTING_SCORE_THRESHOLD,
+    maxAgeDays: DEFAULT_FORGETTING_MAX_AGE_DAYS,
+    enabled: true
+  };
+  if (!input || typeof input !== "object") {
+    return normalized;
+  }
+  const record = input;
+  if (Array.isArray(record.protect)) {
+    normalized.protect = record.protect.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (typeof record.scoreThreshold === "number" && Number.isFinite(record.scoreThreshold) && record.scoreThreshold >= 0 && record.scoreThreshold <= 1) {
+    normalized.scoreThreshold = record.scoreThreshold;
+  }
+  if (typeof record.maxAgeDays === "number" && Number.isFinite(record.maxAgeDays) && record.maxAgeDays >= 0) {
+    normalized.maxAgeDays = Math.floor(record.maxAgeDays);
+  }
+  if (typeof record.enabled === "boolean") {
+    normalized.enabled = record.enabled;
+  }
+  return normalized;
+}
+function normalizeDedupConfig(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const record = input;
+  const normalized = {};
+  if (typeof record.aggressive === "boolean") {
+    normalized.aggressive = record.aggressive;
+  }
+  if (typeof record.threshold === "number" && Number.isFinite(record.threshold) && record.threshold >= 0 && record.threshold <= 1) {
+    normalized.threshold = record.threshold;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeModelsConfig(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const record = input;
+  const normalized = {};
+  if (typeof record.extraction === "string" && record.extraction.trim()) {
+    normalized.extraction = record.extraction.trim();
+  }
+  if (typeof record.claimExtraction === "string" && record.claimExtraction.trim()) {
+    normalized.claimExtraction = record.claimExtraction.trim();
+  }
+  if (typeof record.contradictionJudge === "string" && record.contradictionJudge.trim()) {
+    normalized.contradictionJudge = record.contradictionJudge.trim();
+  }
+  if (typeof record.handoffSummary === "string" && record.handoffSummary.trim()) {
+    normalized.handoffSummary = record.handoffSummary.trim();
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeLegacyContradictionModels(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const record = input;
+  const normalized = {};
+  if (typeof record.claimExtractionModel === "string" && record.claimExtractionModel.trim()) {
+    normalized.claimExtraction = record.claimExtractionModel.trim();
+  }
+  if (typeof record.judgeModel === "string" && record.judgeModel.trim()) {
+    normalized.contradictionJudge = record.judgeModel.trim();
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function toLegacyBaseModel(input) {
+  if (typeof input !== "string" || !input.trim()) {
+    return void 0;
+  }
+  return input.trim();
+}
+function resolveTaskModels(explicitModels, legacyModels, legacyBaseModel) {
+  const mergedModels = {
+    ...explicitModels ?? {}
+  };
+  if (legacyModels?.claimExtraction && !mergedModels.claimExtraction) {
+    mergedModels.claimExtraction = legacyModels.claimExtraction;
+  }
+  if (legacyModels?.contradictionJudge && !mergedModels.contradictionJudge) {
+    mergedModels.contradictionJudge = legacyModels.contradictionJudge;
+  }
+  const fallbackModel = legacyBaseModel ?? DEFAULT_TASK_MODEL;
+  return {
+    extraction: mergedModels.extraction ?? fallbackModel,
+    claimExtraction: mergedModels.claimExtraction ?? fallbackModel,
+    contradictionJudge: mergedModels.contradictionJudge ?? fallbackModel,
+    handoffSummary: mergedModels.handoffSummary ?? fallbackModel
+  };
+}
+function normalizeContradictionConfig(input) {
+  const normalized = {
+    enabled: DEFAULT_CONTRADICTION_ENABLED,
+    autoSupersedeConfidence: DEFAULT_AUTO_SUPERSEDE_CONFIDENCE
+  };
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return normalized;
+  }
+  const record = input;
+  if (typeof record.enabled === "boolean") {
+    normalized.enabled = record.enabled;
+  }
+  if (typeof record.autoSupersedeConfidence === "number" && Number.isFinite(record.autoSupersedeConfidence) && record.autoSupersedeConfidence >= 0 && record.autoSupersedeConfidence <= 1) {
+    normalized.autoSupersedeConfidence = record.autoSupersedeConfidence;
+  }
+  return normalized;
+}
+function normalizeLabelProjectMap(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const out = {};
+  for (const [rawLabel, rawProject] of Object.entries(input)) {
+    if (typeof rawProject !== "string") {
+      continue;
+    }
+    const label = normalizeLabel(rawLabel);
+    const project = rawProject.trim();
+    if (!label || !project) {
+      continue;
+    }
+    out[label] = project;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeProjectsMap(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const out = {};
+  for (const [rawDirKey, rawValue] of Object.entries(input)) {
+    if (!rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) {
+      continue;
+    }
+    const value = rawValue;
+    const normalizeDependencies = () => {
+      if (!Array.isArray(value.dependencies)) {
+        return void 0;
+      }
+      const dependencies2 = Array.from(
+        new Set(
+          value.dependencies.filter((dependency) => typeof dependency === "string").map((dependency) => dependency.trim()).filter((dependency) => dependency.length > 0)
+        )
+      );
+      return dependencies2.length > 0 ? dependencies2 : void 0;
+    };
+    if (typeof value.project === "string" && value.project.trim() && typeof value.platform === "string" && value.platform.trim()) {
+      const dirKey = rawDirKey.trim();
+      if (!dirKey) {
+        continue;
+      }
+      const entry = {
+        project: value.project.trim(),
+        platform: value.platform.trim()
+      };
+      if (typeof value.dbPath === "string" && value.dbPath.trim()) {
+        entry.dbPath = value.dbPath.trim();
+      }
+      const dependencies2 = normalizeDependencies();
+      if (dependencies2) {
+        entry.dependencies = dependencies2;
+      }
+      out[path.resolve(resolveUserPath(dirKey))] = entry;
+      continue;
+    }
+    if (typeof value.platform !== "string" || !value.platform.trim()) {
+      continue;
+    }
+    if (typeof value.projectDir !== "string" || !value.projectDir.trim()) {
+      continue;
+    }
+    const legacyProject = rawDirKey.trim();
+    if (!legacyProject) {
+      continue;
+    }
+    const legacyEntry = {
+      project: legacyProject,
+      platform: value.platform.trim()
+    };
+    if (typeof value.dbPath === "string" && value.dbPath.trim()) {
+      legacyEntry.dbPath = value.dbPath.trim();
+    }
+    const dependencies = normalizeDependencies();
+    if (dependencies) {
+      legacyEntry.dependencies = dependencies;
+    }
+    out[path.resolve(resolveUserPath(value.projectDir.trim()))] = legacyEntry;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeConfig(input) {
+  const record = input && typeof input === "object" ? input : {};
+  const explicitModels = normalizeModelsConfig(record.models);
+  const legacyModels = normalizeLegacyContradictionModels(record.contradiction);
+  const legacyBaseModel = toLegacyBaseModel(record.model);
+  const normalized = {
+    models: resolveTaskModels(explicitModels, legacyModels, legacyBaseModel),
+    embedding: normalizeEmbeddingConfig(record.embedding),
+    db: normalizeDbConfig(record.db),
+    forgetting: normalizeForgettingConfig(record.forgetting),
+    contradiction: normalizeContradictionConfig(record.contradiction)
+  };
+  if (typeof record.auth === "string") {
+    const auth = record.auth.trim();
+    if (isAgenrAuthMethod(auth)) {
+      normalized.auth = auth;
+    }
+  }
+  if (typeof record.provider === "string") {
+    const provider = record.provider.trim().toLowerCase();
+    if (isAgenrProvider2(provider)) {
+      normalized.provider = provider;
+    }
+  }
+  const credentials = normalizeStoredCredentials(record.credentials);
+  if (credentials) {
+    normalized.credentials = credentials;
+  }
+  const labelProjectMap = normalizeLabelProjectMap(record.labelProjectMap);
+  if (labelProjectMap) {
+    normalized.labelProjectMap = labelProjectMap;
+  }
+  const projects = normalizeProjectsMap(record.projects);
+  if (projects) {
+    normalized.projects = projects;
+  }
+  const dedup = normalizeDedupConfig(record.dedup);
+  if (dedup) {
+    normalized.dedup = dedup;
+  }
+  return normalized;
+}
+function ensureConfigDir(env = process.env) {
+  const configDir = resolveConfigDir(env);
+  fs.mkdirSync(configDir, { recursive: true, mode: CONFIG_DIR_MODE });
+  try {
+    fs.chmodSync(configDir, CONFIG_DIR_MODE);
+  } catch {
+  }
+}
+function readConfig(env = process.env) {
+  const configPath = resolveConfigPath(env);
+  let raw;
+  try {
+    raw = fs.readFileSync(configPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return normalizeConfig(parsed);
+}
+function writeConfig(config, env = process.env) {
+  ensureConfigDir(env);
+  const configPath = resolveConfigPath(env);
+  const normalized = normalizeConfig(config);
+  fs.writeFileSync(configPath, `${JSON.stringify(normalized, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: CONFIG_FILE_MODE
+  });
+  try {
+    fs.chmodSync(configPath, CONFIG_FILE_MODE);
+  } catch {
+  }
+}
+function resolveProjectFromGlobalConfig(projectDir, env = process.env) {
+  const config = readConfig(env);
+  if (!config?.projects) {
+    return null;
+  }
+  const resolvedDir = path.resolve(resolveUserPath(projectDir));
+  const entry = config.projects[resolvedDir];
+  if (!entry) {
+    return null;
+  }
+  return {
+    slug: entry.project,
+    platform: entry.platform,
+    dbPath: entry.dbPath
+  };
+}
+function mergeConfigPatch(current, patch) {
+  const merged = {
+    ...current ?? {},
+    ...patch
+  };
+  if (current?.credentials || patch.credentials) {
+    merged.credentials = {
+      ...current?.credentials ?? {},
+      ...patch.credentials ?? {}
+    };
+    if (Object.keys(merged.credentials).length === 0) {
+      delete merged.credentials;
+    }
+  }
+  if (current?.embedding || patch.embedding) {
+    merged.embedding = {
+      ...current?.embedding ?? {},
+      ...patch.embedding ?? {}
+    };
+  }
+  if (current?.db || patch.db) {
+    merged.db = {
+      ...current?.db ?? {},
+      ...patch.db ?? {}
+    };
+  }
+  if (current?.forgetting || patch.forgetting) {
+    merged.forgetting = {
+      ...current?.forgetting ?? {},
+      ...patch.forgetting ?? {}
+    };
+  }
+  if (current?.dedup || patch.dedup) {
+    merged.dedup = {
+      ...current?.dedup ?? {},
+      ...patch.dedup ?? {}
+    };
+  }
+  if (current?.models || patch.models) {
+    merged.models = {
+      ...current?.models ?? {},
+      ...patch.models ?? {}
+    };
+  }
+  if (current?.contradiction || patch.contradiction) {
+    merged.contradiction = {
+      ...current?.contradiction ?? {},
+      ...patch.contradiction ?? {}
+    };
+  }
+  return normalizeConfig(merged);
+}
+function modelIsValid(provider, model) {
+  try {
+    resolveModel(provider, model);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasCompleteTaskModels(models) {
+  if (!models || typeof models !== "object") {
+    return false;
+  }
+  const record = models;
+  return MODEL_TASK_KEYS.every((task) => typeof record[task] === "string" && record[task].trim().length > 0);
+}
+function appendInvalidTaskModelWarnings(config, warnings) {
+  if (!config.provider) {
+    return;
+  }
+  for (const task of MODEL_TASK_KEYS) {
+    const model = config.models[task];
+    if (!modelIsValid(config.provider, model)) {
+      warnings.push(
+        `Warning: models.${task} "${model}" is not available for provider "${config.provider}". Update it with: agenr config set models.${task} <model>.`
+      );
+    }
+  }
+}
+function normalizeValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("Value cannot be empty.");
+  }
+  return trimmed;
+}
+function isCompleteConfig(config) {
+  if (!config?.auth || !config.provider || !hasCompleteTaskModels(config.models)) {
+    return false;
+  }
+  return authMethodToProvider(config.auth) === config.provider;
+}
+function setConfigKey(current, key, value) {
+  const warnings = [];
+  const next = mergeConfigPatch(current, {});
+  if (key.startsWith("models.")) {
+    const task = key.slice("models.".length);
+    if (!isModelTask(task)) {
+      throw new Error(`Invalid model task "${task}". Expected one of: ${MODEL_TASK_KEYS.join(", ")}.`);
+    }
+    const trimmedValue = value.trim();
+    const currentModels = {
+      ...next.models
+    };
+    currentModels[task] = trimmedValue.toLowerCase() === "default" ? DEFAULT_TASK_MODEL : normalizeValue(value);
+    next.models = currentModels;
+    if (next.provider && !modelIsValid(next.provider, currentModels[task])) {
+      warnings.push(
+        `Warning: models.${task} "${currentModels[task]}" is not available for provider "${next.provider}".`
+      );
+    }
+    return { config: next, warnings };
+  }
+  const normalizedValue = normalizeValue(value);
+  if (key === "auth") {
+    if (!isAgenrAuthMethod(normalizedValue)) {
+      throw new Error(
+        `Invalid auth method "${value}". Expected one of: anthropic-oauth, anthropic-token, anthropic-api-key, openai-subscription, openai-api-key.`
+      );
+    }
+    next.auth = normalizedValue;
+    next.provider = authMethodToProvider(normalizedValue);
+    appendInvalidTaskModelWarnings(next, warnings);
+    return { config: next, warnings };
+  }
+  if (key === "provider") {
+    const provider = normalizedValue.toLowerCase();
+    if (!isAgenrProvider2(provider)) {
+      throw new Error(`Invalid provider "${value}". Expected one of: anthropic, openai, openai-codex.`);
+    }
+    if (next.auth) {
+      const expectedProvider = authMethodToProvider(next.auth);
+      if (provider !== expectedProvider) {
+        throw new Error(
+          `Provider "${provider}" is incompatible with auth "${next.auth}". Use \`agenr config set auth <method>\` to switch auth/provider together.`
+        );
+      }
+    }
+    next.provider = provider;
+    appendInvalidTaskModelWarnings(next, warnings);
+    return { config: next, warnings };
+  }
+  throw new Error('Invalid key. Expected one of: "provider", "auth", or "models.<task>".');
+}
+function setStoredCredential(current, keyName, secret) {
+  const normalizedSecret = normalizeValue(secret);
+  const next = mergeConfigPatch(current, {});
+  const credentials = {
+    ...next.credentials ?? {}
+  };
+  if (keyName === "anthropic") {
+    credentials.anthropicApiKey = normalizedSecret;
+  } else if (keyName === "anthropic-token") {
+    credentials.anthropicOauthToken = normalizedSecret;
+  } else if (keyName === "openai") {
+    credentials.openaiApiKey = normalizedSecret;
+  } else {
+    throw new Error(
+      `Invalid key name "${keyName}". Expected one of: anthropic, anthropic-token, openai.`
+    );
+  }
+  next.credentials = credentials;
+  return next;
+}
+function maskSecret(secret) {
+  if (!secret) {
+    return "(not set)";
+  }
+  const trimmed = secret.trim();
+  if (!trimmed) {
+    return "(not set)";
+  }
+  return `****${trimmed.slice(-4)}`;
+}
+function describeAuth(auth) {
+  if (auth === "anthropic-oauth") {
+    return "Anthropic subscription (OAuth)";
+  }
+  if (auth === "anthropic-token") {
+    return "Anthropic subscription (long-lived token)";
+  }
+  if (auth === "anthropic-api-key") {
+    return "Anthropic API key";
+  }
+  if (auth === "openai-subscription") {
+    return "OpenAI subscription (Codex CLI)";
+  }
+  return "OpenAI API key";
+}
+function resolveModelForTask(config, task) {
+  return config?.models?.[task] ?? DEFAULT_TASK_MODEL;
+}
+
+// src/embeddings/client.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_ATTEMPTS = 5;
+function chunkArray(values, chunkSize) {
+  const out = [];
+  for (let i = 0; i < values.length; i += chunkSize) {
+    out.push(values.slice(i, i + chunkSize));
+  }
+  return out;
+}
+function getErrorSnippet(rawBody, fallbackMessage = "unknown error") {
+  const trimmed = rawBody.trim();
+  if (!trimmed) {
+    return fallbackMessage;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const message = parsed.error?.message;
+    if (typeof message === "string" && message.trim()) {
+      return message.trim();
+    }
+  } catch {
+  }
+  const maxLength = 200;
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, maxLength)}...`;
+}
+function buildHttpError(status, body) {
+  const detail = getErrorSnippet(body);
+  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 isRetryableStatus(status) {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function isRetryableEmbeddingError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  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");
+}
+async function sleepMs(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function embedBatch(texts, apiKey) {
+  let response = null;
+  let rawBody = "";
+  let lastError = null;
+  for (let attempt = 1; attempt <= EMBEDDING_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      response = await fetch(OPENAI_EMBEDDINGS_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: EMBEDDING_MODEL,
+          dimensions: EMBEDDING_DIMENSIONS,
+          input: texts
+        })
+      });
+      rawBody = await response.text();
+    } catch (error) {
+      lastError = new Error(
+        `Failed to call OpenAI embeddings API: ${error instanceof Error ? error.message : String(error)}`
+      );
+      if (attempt < EMBEDDING_MAX_ATTEMPTS && isRetryableEmbeddingError(lastError)) {
+        const backoffMs = Math.min(2e3 * 2 ** (attempt - 1), 6e4);
+        await sleepMs(backoffMs);
+        continue;
+      }
+      throw lastError;
+    }
+    if (!response.ok) {
+      const httpError = buildHttpError(response.status, rawBody);
+      lastError = httpError;
+      if (attempt < EMBEDDING_MAX_ATTEMPTS && isRetryableStatus(response.status)) {
+        const backoffMs = Math.min(2e3 * 2 ** (attempt - 1), 6e4);
+        await sleepMs(backoffMs);
+        continue;
+      }
+      throw httpError;
+    }
+    lastError = null;
+    break;
+  }
+  if (!response || !response.ok) {
+    throw lastError instanceof Error ? lastError : new Error("OpenAI embeddings request failed.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch (error) {
+    throw new Error(
+      `OpenAI embeddings response was not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!Array.isArray(parsed.data)) {
+    throw new Error("OpenAI embeddings response missing data array.");
+  }
+  const sorted = [...parsed.data].sort((a, b) => a.index - b.index);
+  if (sorted.length !== texts.length) {
+    throw new Error(
+      `OpenAI embeddings response length mismatch: expected ${texts.length}, received ${sorted.length}.`
+    );
+  }
+  const embeddings = [];
+  for (const item of sorted) {
+    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.");
+    }
+    embeddings.push(item.embedding);
+  }
+  return embeddings;
+}
+function composeEmbeddingText(entry) {
+  return `${entry.type}: ${entry.subject} - ${entry.content}`;
+}
+async function embed(texts, apiKey) {
+  if (texts.length === 0) {
+    return [];
+  }
+  const normalizedApiKey = apiKey.trim();
+  if (!normalizedApiKey) {
+    throw new Error("OpenAI API key is required for embeddings.");
+  }
+  const batches = chunkArray(texts, EMBEDDING_BATCH_SIZE);
+  const out = new Array(texts.length);
+  let nextBatchIndex = 0;
+  const worker = async () => {
+    while (true) {
+      const batchIndex = nextBatchIndex;
+      nextBatchIndex += 1;
+      if (batchIndex >= batches.length) {
+        return;
+      }
+      const batch = batches[batchIndex];
+      const batchEmbeddings = await embedBatch(batch, normalizedApiKey);
+      const offset = batchIndex * EMBEDDING_BATCH_SIZE;
+      for (let i = 0; i < batchEmbeddings.length; i += 1) {
+        out[offset + i] = batchEmbeddings[i];
+      }
+    }
+  };
+  const workerCount = Math.min(EMBEDDING_MAX_CONCURRENCY, batches.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  if (out.some((item) => item === void 0)) {
+    throw new Error("Embedding generation failed to return all vectors.");
+  }
+  return out;
+}
+function resolveEmbeddingApiKey(config, env = process.env) {
+  const fromEmbeddingConfig = config?.embedding?.apiKey?.trim();
+  if (fromEmbeddingConfig) {
+    return fromEmbeddingConfig;
+  }
+  const fromStoredCredentials = config?.credentials?.openaiApiKey?.trim();
+  if (fromStoredCredentials) {
+    return fromStoredCredentials;
+  }
+  const fromEnv = env.OPENAI_API_KEY?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  throw new Error(
+    "OpenAI API key is required for embeddings. Set config.embedding.apiKey, config.credentials.openaiApiKey, or OPENAI_API_KEY."
+  );
+}
+
+// src/llm/credentials.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+function safeReadJson(filePath) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveUserPath2(inputPath) {
+  if (!inputPath.startsWith("~")) {
+    return inputPath;
+  }
+  return path2.join(os2.homedir(), inputPath.slice(1));
+}
+function resolveHomeDir(env = process.env) {
+  const home = env.HOME?.trim();
+  if (home) {
+    return resolveUserPath2(home);
+  }
+  return os2.homedir();
+}
+function resolveCodexHome(env = process.env) {
+  const codexHome = env.CODEX_HOME ? resolveUserPath2(env.CODEX_HOME) : "~/.codex";
+  const resolved = resolveUserPath2(codexHome);
+  try {
+    return fs2.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function parseCodexFromFile(env = process.env) {
+  const authPath = path2.join(resolveCodexHome(env), "auth.json");
+  const parsed = safeReadJson(authPath);
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const record = parsed;
+  const tokens = record.tokens;
+  if (!tokens || typeof tokens !== "object") {
+    return null;
+  }
+  const accessToken = tokens.access_token;
+  if (typeof accessToken !== "string" || !accessToken.trim()) {
+    return null;
+  }
+  return { accessToken, source: `file:${authPath}` };
+}
+function resolveCodexKeychainAccount(env = process.env) {
+  const hash = createHash("sha256").update(resolveCodexHome(env)).digest("hex");
+  return `cli|${hash.slice(0, 16)}`;
+}
+function parseCodexFromKeychain(env = process.env) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const account = resolveCodexKeychainAccount(env);
+    const raw = execSync(`security find-generic-password -s "Codex Auth" -a "${account}" -w`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    const parsed = JSON.parse(raw);
+    const tokens = parsed.tokens;
+    const accessToken = tokens?.access_token;
+    if (typeof accessToken !== "string" || !accessToken.trim()) {
+      return null;
+    }
+    return { accessToken, source: "keychain:Codex Auth" };
+  } catch {
+    return null;
+  }
+}
+function parseClaudeCredentialRecord(parsed, source) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const record = parsed;
+  const claudeOauth = record.claudeAiOauth;
+  if (!claudeOauth || typeof claudeOauth !== "object") {
+    return null;
+  }
+  const accessToken = claudeOauth.accessToken;
+  if (typeof accessToken !== "string" || !accessToken.trim()) {
+    return null;
+  }
+  return { accessToken, source };
+}
+function parseClaudeFromFiles(env = process.env) {
+  const homeDir = resolveHomeDir(env);
+  const candidates = [
+    path2.join(homeDir, ".claude", ".credentials.json"),
+    path2.join(homeDir, ".claude", "credentials.json")
+  ];
+  for (const candidate of candidates) {
+    const parsed = safeReadJson(candidate);
+    const result = parseClaudeCredentialRecord(parsed, `file:${candidate}`);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
+function parseClaudeFromKeychain() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+    return parseClaudeCredentialRecord(JSON.parse(raw), "keychain:Claude Code-credentials");
+  } catch {
+    return null;
+  }
+}
+function candidateFromToken(token, source) {
+  const normalized = token?.trim();
+  if (!normalized) {
+    return null;
+  }
+  return {
+    token: normalized,
+    source
+  };
+}
+function resolveAnthropicOauthCredentials(env) {
+  const file = parseClaudeFromFiles(env);
+  if (file) {
+    return {
+      token: file.accessToken,
+      source: file.source
+    };
+  }
+  const keychain = parseClaudeFromKeychain();
+  if (keychain) {
+    return {
+      token: keychain.accessToken,
+      source: keychain.source
+    };
+  }
+  return null;
+}
+function resolveAnthropicTokenCredentials(stored, env) {
+  return candidateFromToken(env.ANTHROPIC_OAUTH_TOKEN, "env:ANTHROPIC_OAUTH_TOKEN") ?? candidateFromToken(stored?.anthropicOauthToken, "config:credentials.anthropicOauthToken");
+}
+function resolveAnthropicApiKeyCredentials(stored, env) {
+  return candidateFromToken(env.ANTHROPIC_API_KEY, "env:ANTHROPIC_API_KEY") ?? candidateFromToken(stored?.anthropicApiKey, "config:credentials.anthropicApiKey");
+}
+function resolveOpenAISubscriptionCredentials(env) {
+  const file = parseCodexFromFile(env);
+  if (file) {
+    return {
+      token: file.accessToken,
+      source: file.source
+    };
+  }
+  const keychain = parseCodexFromKeychain(env);
+  if (keychain) {
+    return {
+      token: keychain.accessToken,
+      source: keychain.source
+    };
+  }
+  return null;
+}
+function resolveOpenAIApiKeyCredentials(stored, env) {
+  return candidateFromToken(env.OPENAI_API_KEY, "env:OPENAI_API_KEY") ?? candidateFromToken(stored?.openaiApiKey, "config:credentials.openaiApiKey");
+}
+function credentialSetupGuidance(auth) {
+  if (auth === "anthropic-oauth") {
+    return [
+      "Claude CLI credentials not found.",
+      "Install Claude Code CLI: npm install -g @anthropic-ai/claude-code",
+      "Then sign in: claude"
+    ].join(" ");
+  }
+  if (auth === "anthropic-token") {
+    return [
+      "No long-lived Anthropic token found.",
+      "Generate one with: claude setup-token",
+      "Then store it: agenr config set-key anthropic-token <token>"
+    ].join(" ");
+  }
+  if (auth === "anthropic-api-key") {
+    return [
+      "No Anthropic API key found.",
+      "Get a key from console.anthropic.com",
+      "Then store it: agenr config set-key anthropic <key>"
+    ].join(" ");
+  }
+  if (auth === "openai-subscription") {
+    return [
+      "Codex CLI credentials not found or expired.",
+      "Run: codex auth"
+    ].join(" ");
+  }
+  return [
+    "No OpenAI API key found.",
+    "Get a key from https://platform.openai.com/api-keys",
+    "Then store it: agenr config set-key openai <key>"
+  ].join(" ");
+}
+function resolveCredentialCandidate(params) {
+  const env = params.env ?? process.env;
+  if (params.auth === "anthropic-oauth") {
+    return resolveAnthropicOauthCredentials(env);
+  }
+  if (params.auth === "anthropic-token") {
+    return resolveAnthropicTokenCredentials(params.storedCredentials, env);
+  }
+  if (params.auth === "anthropic-api-key") {
+    return resolveAnthropicApiKeyCredentials(params.storedCredentials, env);
+  }
+  if (params.auth === "openai-subscription") {
+    return resolveOpenAISubscriptionCredentials(env);
+  }
+  return resolveOpenAIApiKeyCredentials(params.storedCredentials, env);
+}
+function probeCredentials(params) {
+  const candidate = resolveCredentialCandidate(params);
+  if (!candidate) {
+    return {
+      available: false,
+      guidance: credentialSetupGuidance(params.auth)
+    };
+  }
+  return {
+    available: true,
+    source: candidate.source,
+    guidance: "Credentials available.",
+    credentials: {
+      apiKey: candidate.token,
+      source: candidate.source
+    }
+  };
+}
+function resolveCredentials(params) {
+  const probe = probeCredentials(params);
+  if (!probe.available || !probe.credentials) {
+    throw new Error(`${probe.guidance} Run: agenr auth status`);
+  }
+  return probe.credentials;
+}
+
+// src/llm/stream.ts
+import { streamSimple } from "@mariozechner/pi-ai/dist/stream.js";
+function logVerbose(params, line) {
+  if (!params.verbose) {
+    return;
+  }
+  const logger = params.onVerbose ?? ((message) => process.stderr.write(`${message}
+`));
+  logger(line);
+}
+async function runSimpleStream(params) {
+  const streamFn = params.streamSimpleImpl ?? streamSimple;
+  const stream = streamFn(params.model, params.context, params.options);
+  for await (const event of stream) {
+    if (!params.verbose) {
+      continue;
+    }
+    if (event.type === "thinking_start") {
+      logVerbose(params, "[thinking]");
+    } else if (event.type === "thinking_delta") {
+      params.onStreamDelta?.(event.delta, "thinking");
+    } else if (event.type === "thinking_end") {
+      logVerbose(params, "[/thinking]");
+    } else if (event.type === "text_delta") {
+      params.onStreamDelta?.(event.delta, "text");
+    } else if (event.type === "toolcall_delta") {
+      params.onStreamDelta?.(event.delta, "text");
+    } else if (event.type === "error") {
+      logVerbose(params, `[error:${event.reason}] ${event.error.errorMessage ?? "unknown error"}`);
+    }
+  }
+  return stream.result();
+}
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var APP_VERSION = (() => {
+  try {
+    const raw = require2("../package.json");
+    if (typeof raw.version === "string" && raw.version.trim().length > 0) {
+      return raw.version.trim();
+    }
+  } catch {
+  }
+  const fromEnv = process.env.npm_package_version;
+  if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+    return fromEnv.trim();
+  }
+  return "0.0.0";
+})();
+
+// src/db/client.ts
+import { createClient } from "@libsql/client";
+import fs3 from "fs/promises";
+import os3 from "os";
+import path3 from "path";
+
+// src/db/schema.ts
+var CREATE_IDX_ENTRIES_EMBEDDING_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_entries_embedding ON entries (
+    libsql_vector_idx(embedding, 'metric=cosine', 'compress_neighbors=float8', 'max_neighbors=50')
+  )
+`;
+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_TRIGGER_AI_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_ai AFTER INSERT ON entries BEGIN
+    INSERT INTO entries_fts(rowid, content, subject) VALUES (new.rowid, new.content, new.subject);
+  END
+`;
+var CREATE_ENTRIES_FTS_TRIGGER_AD_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_ad AFTER DELETE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content, subject) VALUES ('delete', old.rowid, old.content, old.subject);
+  END
+`;
+var CREATE_ENTRIES_FTS_TRIGGER_AU_SQL = `
+  CREATE TRIGGER IF NOT EXISTS entries_au AFTER UPDATE ON entries BEGIN
+    INSERT INTO entries_fts(entries_fts, rowid, content, subject) VALUES ('delete', old.rowid, old.content, old.subject);
+    INSERT INTO entries_fts(rowid, content, subject) VALUES (new.rowid, new.content, new.subject);
+  END
+`;
+var REBUILD_ENTRIES_FTS_SQL = "INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')";
+var LEGACY_IMPORTANCE_BACKFILL_META_KEY = "legacy_importance_backfill_from_confidence_v1";
+var BULK_INGEST_META_KEY = "bulk_ingest_state";
+var CREATE_TABLE_AND_TRIGGER_STATEMENTS = [
+  `
+  CREATE TABLE IF NOT EXISTS _meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entries (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    subject TEXT NOT NULL,
+    canonical_key TEXT,
+    content TEXT NOT NULL,
+    importance INTEGER NOT NULL,
+    expiry TEXT NOT NULL,
+    scope TEXT DEFAULT 'private',
+    platform TEXT DEFAULT NULL,
+    project TEXT DEFAULT NULL,
+    source_file TEXT,
+    source_context TEXT,
+    embedding F32_BLOB(1024),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_recalled_at TEXT,
+    recall_count INTEGER DEFAULT 0,
+    confirmations INTEGER DEFAULT 0,
+    contradictions INTEGER DEFAULT 0,
+    quality_score REAL NOT NULL DEFAULT 0.5,
+    superseded_by TEXT,
+    content_hash TEXT,
+    norm_content_hash TEXT,
+    minhash_sig BLOB,
+    merged_from INTEGER DEFAULT 0,
+    consolidated_at TEXT,
+    retired INTEGER NOT NULL DEFAULT 0,
+    retired_at TEXT,
+    retired_reason TEXT,
+    suppressed_contexts TEXT,
+    FOREIGN KEY (superseded_by) REFERENCES entries(id)
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS tags (
+    entry_id TEXT NOT NULL,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (entry_id, tag),
+    FOREIGN KEY (entry_id) REFERENCES entries(id) ON DELETE CASCADE
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS relations (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    relation_type TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (source_id) REFERENCES entries(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_id) REFERENCES entries(id) ON DELETE CASCADE
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS ingest_log (
+    id TEXT PRIMARY KEY,
+    file_path TEXT NOT NULL,
+    ingested_at TEXT NOT NULL,
+    entries_added INTEGER NOT NULL,
+    entries_updated INTEGER NOT NULL,
+    entries_skipped INTEGER NOT NULL,
+    duration_ms INTEGER NOT NULL,
+    content_hash TEXT,
+    entries_superseded INTEGER NOT NULL DEFAULT 0,
+    dedup_llm_calls INTEGER NOT NULL DEFAULT 0
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entry_sources (
+    merged_entry_id TEXT NOT NULL REFERENCES entries(id),
+    source_entry_id TEXT NOT NULL REFERENCES entries(id),
+    original_confirmations INTEGER NOT NULL DEFAULT 0,
+    original_recall_count INTEGER NOT NULL DEFAULT 0,
+    original_created_at TEXT,
+    PRIMARY KEY (merged_entry_id, source_entry_id)
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS signal_watermarks (
+    consumer_id TEXT PRIMARY KEY,
+    last_received_seq INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS conflict_log (
+    id TEXT PRIMARY KEY,
+    entry_a TEXT NOT NULL,
+    entry_b TEXT NOT NULL,
+    relation TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    resolution TEXT NOT NULL,
+    resolved_at TEXT,
+    created_at TEXT NOT NULL
+  )
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS co_recall_edges (
+    entry_a TEXT NOT NULL,
+    entry_b TEXT NOT NULL,
+    edge_type TEXT NOT NULL DEFAULT 'co_recalled',
+    weight REAL NOT NULL DEFAULT 0.1,
+    session_count INTEGER NOT NULL DEFAULT 1,
+    last_co_recalled TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (entry_a, entry_b, edge_type),
+    FOREIGN KEY (entry_a) REFERENCES entries(id),
+    FOREIGN KEY (entry_b) REFERENCES entries(id)
+  )
+  `,
+  "CREATE INDEX IF NOT EXISTS idx_co_recall_a ON co_recall_edges(entry_a)",
+  "CREATE INDEX IF NOT EXISTS idx_co_recall_b ON co_recall_edges(entry_b)",
+  `
+  CREATE TABLE IF NOT EXISTS review_queue (
+    id TEXT PRIMARY KEY,
+    entry_id TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    detail TEXT,
+    suggested_action TEXT NOT NULL DEFAULT 'review',
+    status TEXT NOT NULL DEFAULT 'pending',
+    created_at TEXT NOT NULL,
+    resolved_at TEXT,
+    FOREIGN KEY (entry_id) REFERENCES entries(id)
+  )
+  `,
+  "CREATE INDEX IF NOT EXISTS idx_review_queue_status ON review_queue(status)",
+  "CREATE INDEX IF NOT EXISTS idx_review_queue_entry ON review_queue(entry_id)",
+  "CREATE UNIQUE INDEX IF NOT EXISTS idx_review_queue_pending_dedup ON review_queue(entry_id, reason) WHERE status = 'pending'",
+  CREATE_ENTRIES_FTS_TABLE_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AI_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AD_SQL,
+  CREATE_ENTRIES_FTS_TRIGGER_AU_SQL
+];
+var COLUMN_MIGRATIONS = [
+  {
+    table: "co_recall_edges",
+    column: "edge_type",
+    sql: "ALTER TABLE co_recall_edges ADD COLUMN edge_type TEXT NOT NULL DEFAULT 'co_recalled'"
+  },
+  {
+    table: "entries",
+    column: "importance",
+    sql: "ALTER TABLE entries ADD COLUMN importance INTEGER NOT NULL DEFAULT 5"
+  },
+  {
+    table: "entries",
+    column: "canonical_key",
+    sql: "ALTER TABLE entries ADD COLUMN canonical_key TEXT"
+  },
+  {
+    table: "entries",
+    column: "scope",
+    sql: "ALTER TABLE entries ADD COLUMN scope TEXT DEFAULT 'private'"
+  },
+  {
+    table: "entries",
+    column: "content_hash",
+    sql: "ALTER TABLE entries ADD COLUMN content_hash TEXT"
+  },
+  {
+    table: "entries",
+    column: "norm_content_hash",
+    sql: "ALTER TABLE entries ADD COLUMN norm_content_hash TEXT"
+  },
+  {
+    table: "entries",
+    column: "idx_entries_norm_content_hash",
+    sql: "CREATE INDEX IF NOT EXISTS idx_entries_norm_content_hash ON entries(norm_content_hash)",
+    isIndex: true
+  },
+  {
+    table: "entries",
+    column: "minhash_sig",
+    sql: "ALTER TABLE entries ADD COLUMN minhash_sig BLOB"
+  },
+  {
+    table: "entries",
+    column: "merged_from",
+    sql: "ALTER TABLE entries ADD COLUMN merged_from INTEGER DEFAULT 0"
+  },
+  {
+    table: "entries",
+    column: "consolidated_at",
+    sql: "ALTER TABLE entries ADD COLUMN consolidated_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "platform",
+    sql: "ALTER TABLE entries ADD COLUMN platform TEXT DEFAULT NULL"
+  },
+  {
+    table: "entries",
+    column: "project",
+    sql: "ALTER TABLE entries ADD COLUMN project TEXT DEFAULT NULL"
+  },
+  {
+    table: "entries",
+    column: "retired",
+    sql: "ALTER TABLE entries ADD COLUMN retired INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "entries",
+    column: "idx_entries_retired",
+    sql: "CREATE INDEX IF NOT EXISTS idx_entries_retired ON entries (retired) WHERE retired = 0",
+    isIndex: true
+  },
+  {
+    table: "entries",
+    column: "retired_at",
+    sql: "ALTER TABLE entries ADD COLUMN retired_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "retired_reason",
+    sql: "ALTER TABLE entries ADD COLUMN retired_reason TEXT"
+  },
+  {
+    table: "entries",
+    column: "suppressed_contexts",
+    sql: "ALTER TABLE entries ADD COLUMN suppressed_contexts TEXT"
+  },
+  {
+    table: "ingest_log",
+    column: "content_hash",
+    sql: "ALTER TABLE ingest_log ADD COLUMN content_hash TEXT"
+  },
+  {
+    table: "ingest_log",
+    column: "entries_superseded",
+    sql: "ALTER TABLE ingest_log ADD COLUMN entries_superseded INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "ingest_log",
+    column: "dedup_llm_calls",
+    sql: "ALTER TABLE ingest_log ADD COLUMN dedup_llm_calls INTEGER NOT NULL DEFAULT 0"
+  },
+  {
+    table: "entry_sources",
+    column: "original_created_at",
+    sql: "ALTER TABLE entry_sources ADD COLUMN original_created_at TEXT"
+  },
+  {
+    table: "entries",
+    column: "recall_intervals",
+    sql: "ALTER TABLE entries ADD COLUMN recall_intervals TEXT DEFAULT NULL"
+  },
+  {
+    table: "entries",
+    column: "quality_score",
+    sql: "ALTER TABLE entries ADD COLUMN quality_score REAL NOT NULL DEFAULT 0.5"
+  },
+  // Claim/subject fields for contradiction detection (#266)
+  {
+    table: "entries",
+    column: "subject_entity",
+    sql: "ALTER TABLE entries ADD COLUMN subject_entity TEXT"
+  },
+  {
+    table: "entries",
+    column: "subject_attribute",
+    sql: "ALTER TABLE entries ADD COLUMN subject_attribute TEXT"
+  },
+  {
+    table: "entries",
+    column: "subject_key",
+    sql: "ALTER TABLE entries ADD COLUMN subject_key TEXT"
+  },
+  {
+    table: "entries",
+    column: "claim_predicate",
+    sql: "ALTER TABLE entries ADD COLUMN claim_predicate TEXT"
+  },
+  {
+    table: "entries",
+    column: "claim_object",
+    sql: "ALTER TABLE entries ADD COLUMN claim_object TEXT"
+  },
+  {
+    table: "entries",
+    column: "claim_confidence",
+    sql: "ALTER TABLE entries ADD COLUMN claim_confidence REAL"
+  },
+  {
+    table: "entries",
+    column: "idx_entries_subject_key",
+    sql: "CREATE INDEX IF NOT EXISTS idx_entries_subject_key ON entries(subject_key) WHERE subject_key IS NOT NULL AND retired = 0 AND superseded_by IS NULL",
+    isIndex: true
+  }
+];
+var CREATE_INDEX_STATEMENTS = [
+  CREATE_IDX_ENTRIES_EMBEDDING_SQL,
+  "CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(type)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_type_canonical_key ON entries(type, canonical_key)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_expiry ON entries(expiry)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_scope ON entries(scope)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_platform ON entries(platform)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_project ON entries(project)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_created ON entries(created_at)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_superseded ON entries(superseded_by)",
+  "CREATE INDEX IF NOT EXISTS idx_entries_content_hash ON entries(content_hash)",
+  "CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag)",
+  "CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_id)",
+  "CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_id)",
+  "CREATE UNIQUE INDEX IF NOT EXISTS idx_ingest_log_file_hash ON ingest_log(file_path, content_hash)"
+];
+async function dropFtsTriggersAndIndex(db) {
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    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 db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function rebuildFtsAndTriggers(db) {
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    await db.execute(REBUILD_ENTRIES_FTS_SQL);
+    await db.execute(CREATE_ENTRIES_FTS_TRIGGER_AI_SQL);
+    await db.execute(CREATE_ENTRIES_FTS_TRIGGER_AD_SQL);
+    await db.execute(CREATE_ENTRIES_FTS_TRIGGER_AU_SQL);
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function rebuildVectorIndex(db) {
+  try {
+    await db.execute("REINDEX idx_entries_embedding");
+    return;
+  } catch {
+  }
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
+    await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
+    await db.execute("COMMIT");
+  } catch (fallbackError) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw fallbackError;
+  }
+}
+async function setBulkIngestMeta(db, phase) {
+  await db.execute({
+    sql: `
+      INSERT OR REPLACE INTO _meta (key, value, updated_at)
+      VALUES (?, json_object('phase', ?, 'started_at', datetime('now')), datetime('now'))
+    `,
+    args: [BULK_INGEST_META_KEY, phase]
+  });
+}
+async function clearBulkIngestMeta(db) {
+  await db.execute({ sql: "DELETE FROM _meta WHERE key = ?", args: [BULK_INGEST_META_KEY] });
+}
+async function getBulkIngestMeta(db) {
+  const result = await db.execute({ sql: "SELECT value FROM _meta WHERE key = ?", args: [BULK_INGEST_META_KEY] });
+  if (result.rows.length === 0) {
+    return null;
+  }
+  try {
+    const row = result.rows[0];
+    const raw = row?.value ?? (row ? Object.values(row)[0] : void 0);
+    return JSON.parse(String(raw));
+  } catch (parseError) {
+    process.stderr.write(
+      `[agenr] Warning: failed to parse bulk_ingest_state metadata: ${parseError instanceof Error ? parseError.message : String(parseError)}. Crash recovery may be skipped.
+`
+    );
+    return null;
+  }
+}
+async function initSchema(client) {
+  for (const statement of CREATE_TABLE_AND_TRIGGER_STATEMENTS) {
+    await client.execute(statement);
+  }
+  let willRunLegacyBackfill = false;
+  try {
+    const earlyEntriesInfo = await client.execute("PRAGMA table_info(entries)");
+    const earlyColumns = new Set(earlyEntriesInfo.rows.map((row) => String(row.name)));
+    if (earlyColumns.has("confidence")) {
+      const sentinel = await client.execute({
+        sql: "SELECT 1 AS found FROM _meta WHERE key = ? LIMIT 1",
+        args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+      });
+      const alreadyBackfilled = sentinel.rows.length > 0;
+      willRunLegacyBackfill = !alreadyBackfilled;
+    }
+  } catch {
+  }
+  try {
+    const entriesCountResult = await client.execute("SELECT COUNT(*) AS count FROM entries");
+    const entriesCount = Number(entriesCountResult.rows[0]?.count ?? 0);
+    const ftsCountResult = await client.execute("SELECT COUNT(*) AS count FROM entries_fts");
+    const ftsCount = Number(ftsCountResult.rows[0]?.count ?? 0);
+    if (entriesCount > 0 && ftsCount === 0 && !willRunLegacyBackfill) {
+      await client.execute(REBUILD_ENTRIES_FTS_SQL);
+    }
+  } catch {
+  }
+  for (const migration of COLUMN_MIGRATIONS) {
+    if (migration.isIndex) {
+      const existingIndex = await client.execute({
+        sql: "SELECT name FROM sqlite_master WHERE type='index' AND name=?",
+        args: [migration.column]
+      });
+      if (existingIndex.rows.length > 0) {
+        continue;
+      }
+      await client.execute(migration.sql);
+      continue;
+    }
+    const info = await client.execute(`PRAGMA table_info(${migration.table})`);
+    const hasColumn = info.rows.some((row) => String(row.name) === migration.column);
+    if (!hasColumn) {
+      await client.execute(migration.sql);
+    }
+  }
+  const entriesInfo = await client.execute("PRAGMA table_info(entries)");
+  const entryColumns = new Set(entriesInfo.rows.map((row) => String(row.name)));
+  const backfillSentinel = await client.execute({
+    sql: "SELECT 1 AS found FROM _meta WHERE key = ? LIMIT 1",
+    args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+  });
+  const legacyBackfillDone = backfillSentinel.rows.length > 0;
+  if (entryColumns.has("confidence") && entryColumns.has("importance") && !legacyBackfillDone) {
+    try {
+      await client.execute("DROP TRIGGER IF EXISTS entries_ai");
+      await client.execute("DROP TRIGGER IF EXISTS entries_ad");
+      await client.execute("DROP TRIGGER IF EXISTS entries_au");
+      await client.execute("DROP TABLE IF EXISTS entries_fts");
+    } catch {
+    }
+    await client.execute(`
+      UPDATE entries
+      SET importance = CASE lower(trim(confidence))
+        WHEN 'low' THEN 3
+        WHEN 'medium' THEN 6
+        WHEN 'high' THEN 8
+        ELSE
+          CASE
+            WHEN CAST(confidence AS INTEGER) BETWEEN 1 AND 10 THEN CAST(confidence AS INTEGER)
+            ELSE 5
+          END
+      END
+      WHERE importance = 5
+    `);
+    try {
+      await client.execute(CREATE_ENTRIES_FTS_TABLE_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AI_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AD_SQL);
+      await client.execute(CREATE_ENTRIES_FTS_TRIGGER_AU_SQL);
+      await client.execute(REBUILD_ENTRIES_FTS_SQL);
+    } catch {
+    }
+    try {
+      await client.execute({
+        sql: `
+          INSERT INTO _meta (key, value, updated_at)
+          VALUES (?, datetime('now'), datetime('now'))
+          ON CONFLICT(key) DO NOTHING
+        `,
+        args: [LEGACY_IMPORTANCE_BACKFILL_META_KEY]
+      });
+    } catch {
+    }
+  }
+  for (const statement of CREATE_INDEX_STATEMENTS) {
+    await client.execute(statement);
+  }
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('db_created_at', datetime('now'), datetime('now'))
+      ON CONFLICT(key) DO NOTHING
+    `,
+    args: []
+  });
+  await client.execute({
+    sql: `
+      INSERT INTO _meta (key, value, updated_at)
+      VALUES ('schema_version', ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `,
+    args: [APP_VERSION]
+  });
+}
+async function resetDb(db) {
+  const foreignKeysResult = await db.execute("PRAGMA foreign_keys");
+  const foreignKeysRow = foreignKeysResult.rows[0];
+  const previousForeignKeys = Number(foreignKeysRow?.foreign_keys ?? (foreignKeysRow ? Object.values(foreignKeysRow)[0] : 1)) === 0 ? 0 : 1;
+  await db.execute("PRAGMA foreign_keys=OFF");
+  try {
+    const schemaObjects = await db.execute(`
+      SELECT type, name
+      FROM sqlite_master
+      WHERE name NOT LIKE 'sqlite_%'
+      ORDER BY
+        CASE type
+          WHEN 'trigger' THEN 1
+          WHEN 'index' THEN 2
+          WHEN 'table' THEN 3
+          ELSE 4
+        END,
+        name
+    `);
+    for (const row of schemaObjects.rows) {
+      const type = String(row.type ?? "");
+      const name = String(row.name ?? "");
+      if (!type || !name) {
+        continue;
+      }
+      const safeName = name.replace(/"/g, '""');
+      if (type === "trigger") {
+        await db.execute(`DROP TRIGGER IF EXISTS "${safeName}"`);
+        continue;
+      }
+      if (type === "index") {
+        await db.execute(`DROP INDEX IF EXISTS "${safeName}"`);
+        continue;
+      }
+      if (type === "table") {
+        await db.execute(`DROP TABLE IF EXISTS "${safeName}"`);
+      }
+    }
+    await initSchema(db);
+  } finally {
+    await db.execute(`PRAGMA foreign_keys=${previousForeignKeys === 0 ? "OFF" : "ON"}`);
+  }
+}
+
+// src/db/client.ts
+var DEFAULT_DB_PATH = path3.join(os3.homedir(), ".agenr", "knowledge.db");
+var walInitByClient = /* @__PURE__ */ new WeakMap();
+var didWarnVectorIndexCorruption = false;
+var WAL_CHECKPOINT_MAX_ATTEMPTS = 5;
+var WAL_CHECKPOINT_RETRY_MS = 50;
+function resolveUserPath3(inputPath) {
+  if (!inputPath.startsWith("~")) {
+    return inputPath;
+  }
+  return path3.join(os3.homedir(), inputPath.slice(1));
+}
+function resolveDbPath(dbPath) {
+  if (dbPath === ":memory:") {
+    return dbPath;
+  }
+  return resolveUserPath3(dbPath);
+}
+function normalizeBackupSourcePath(dbPath) {
+  const strippedDbPath = dbPath.startsWith("file:") ? dbPath.slice("file:".length) : dbPath;
+  return path3.resolve(resolveDbPath(strippedDbPath));
+}
+function isErrnoCode(error, code) {
+  return error?.code === code;
+}
+async function copySidecarIfPresent(sourcePath, targetPath) {
+  try {
+    await fs3.copyFile(sourcePath, targetPath);
+  } catch (error) {
+    if (isErrnoCode(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+}
+function buildBackupPath(dbPath) {
+  const resolvedDbPath = normalizeBackupSourcePath(dbPath);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  return path3.join(
+    path3.dirname(resolvedDbPath),
+    `${path3.basename(resolvedDbPath)}.backup-pre-reset-${timestamp}Z`
+  );
+}
+function getDb(dbPath) {
+  const rawPath = dbPath?.trim() ? dbPath.trim() : DEFAULT_DB_PATH;
+  if (rawPath === ":memory:") {
+    return createClient({ url: ":memory:" });
+  }
+  if (rawPath.startsWith("file:")) {
+    const client2 = createClient({ url: rawPath });
+    walInitByClient.set(
+      client2,
+      client2.execute("PRAGMA journal_mode=WAL").then(() => client2.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+    );
+    return client2;
+  }
+  const resolvedPath = resolveDbPath(rawPath);
+  const client = createClient({ url: `file:${resolvedPath}` });
+  walInitByClient.set(
+    client,
+    client.execute("PRAGMA journal_mode=WAL").then(() => client.execute("PRAGMA busy_timeout=3000")).then(() => void 0)
+  );
+  return client;
+}
+function readCount(row, key = "cnt") {
+  if (!row || typeof row !== "object") {
+    return 0;
+  }
+  const record = row;
+  const raw = record[key] ?? Object.values(record)[0];
+  return toFiniteNumber(raw) ?? 0;
+}
+function readIntegrityValue(row) {
+  if (!row || typeof row !== "object") {
+    return "";
+  }
+  const record = row;
+  const raw = record.integrity_check ?? Object.values(record)[0];
+  return String(raw ?? "").trim();
+}
+async function checkAndRecoverBulkIngest(client) {
+  const meta = await getBulkIngestMeta(client);
+  if (!meta) {
+    return;
+  }
+  try {
+    const triggerCountResult = await client.execute(`
+      SELECT COUNT(*) AS cnt
+      FROM sqlite_master
+      WHERE type = 'trigger' AND name IN ('entries_ai', 'entries_ad', 'entries_au')
+    `);
+    const triggerCount = readCount(triggerCountResult.rows[0]);
+    const indexCountResult = await client.execute(`
+      SELECT COUNT(*) AS cnt
+      FROM sqlite_master
+      WHERE type = 'index' AND name = 'idx_entries_embedding'
+    `);
+    const indexCount = readCount(indexCountResult.rows[0]);
+    process.stderr.write(
+      `[agenr] Interrupted bulk ingest detected (phase: ${meta.phase}). Recovering...
+`
+    );
+    if (triggerCount < 3) {
+      await rebuildFtsAndTriggers(client);
+    } else if (indexCount < 1) {
+      const entriesCountResult = await client.execute("SELECT COUNT(*) AS cnt FROM entries");
+      const ftsCountResult = await client.execute("SELECT COUNT(*) AS cnt FROM entries_fts");
+      const entriesCount = readCount(entriesCountResult.rows[0]);
+      const ftsCount = readCount(ftsCountResult.rows[0]);
+      if (entriesCount > 0 && ftsCount === 0) {
+        await client.execute("INSERT INTO entries_fts(entries_fts) VALUES('rebuild')");
+      }
+    }
+    if (indexCount < 1) {
+      await rebuildVectorIndex(client);
+    }
+    try {
+      const integrityResult = await client.execute("PRAGMA integrity_check");
+      const integrity = readIntegrityValue(integrityResult.rows[0]);
+      process.stderr.write(`[agenr] integrity_check: ${integrity || "unknown"}
+`);
+    } catch (integrityError) {
+      process.stderr.write(
+        `[agenr] integrity_check failed: ${integrityError instanceof Error ? integrityError.message : String(integrityError)}
+`
+      );
+    }
+    await clearBulkIngestMeta(client);
+    process.stderr.write("[agenr] Recovery complete.\n");
+  } catch (error) {
+    throw error;
+  }
+}
+async function initDb(client, opts) {
+  const walInit = walInitByClient.get(client);
+  if (walInit) {
+    await walInit;
+    await client.execute("PRAGMA wal_autocheckpoint=1000");
+  }
+  await initSchema(client);
+  if (opts?.checkBulkRecovery === true) {
+    try {
+      await checkAndRecoverBulkIngest(client);
+    } catch (recoveryError) {
+      process.stderr.write(
+        `[agenr] Warning: bulk ingest recovery failed: ${recoveryError instanceof Error ? recoveryError.stack ?? recoveryError.message : String(recoveryError)}
+[agenr] Continuing without recovery. Run 'agenr ingest --bulk' again if FTS or vector search is degraded.
+`
+      );
+    }
+  }
+  try {
+    const hasEntries = await client.execute(
+      "SELECT 1 FROM entries WHERE embedding IS NOT NULL LIMIT 1"
+    );
+    if (hasEntries.rows.length > 0) {
+      await client.execute(`
+        SELECT count(*) FROM vector_top_k(
+          'idx_entries_embedding',
+          (SELECT embedding FROM entries WHERE embedding IS NOT NULL LIMIT 1),
+          1
+        )
+      `);
+    }
+  } catch {
+    if (!didWarnVectorIndexCorruption) {
+      didWarnVectorIndexCorruption = true;
+      process.stderr.write(
+        "\n\u26A0\uFE0F  Vector index may be corrupted. Run `agenr db rebuild-index` to fix.\n\n"
+      );
+    }
+  }
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function extractBusyFromCheckpointRow(row) {
+  if (!row || typeof row !== "object") {
+    return null;
+  }
+  const record = row;
+  const busyValue = record.busy ?? Object.values(record)[0];
+  return toFiniteNumber(busyValue);
+}
+async function validatedWalCheckpoint(client) {
+  for (let attempt = 1; attempt <= WAL_CHECKPOINT_MAX_ATTEMPTS; attempt += 1) {
+    const result = await client.execute("PRAGMA wal_checkpoint(TRUNCATE)");
+    const busy = extractBusyFromCheckpointRow(result.rows[0]);
+    if (busy === null) {
+      throw new Error("WAL checkpoint returned an unexpected result and could not be validated.");
+    }
+    if (busy === 0) {
+      return;
+    }
+    if (attempt < WAL_CHECKPOINT_MAX_ATTEMPTS) {
+      await new Promise((resolve) => setTimeout(resolve, WAL_CHECKPOINT_RETRY_MS * attempt));
+      continue;
+    }
+    throw new Error(
+      `WAL checkpoint did not finish (busy=${busy}). Active readers are blocking backup safety.`
+    );
+  }
+}
+async function walCheckpoint(client) {
+  await validatedWalCheckpoint(client);
+}
+async function backupDb(dbPath) {
+  if (dbPath === ":memory:") {
+    throw new Error("Cannot back up in-memory databases.");
+  }
+  const checkpointClient = getDb(dbPath);
+  try {
+    await walCheckpoint(checkpointClient);
+  } finally {
+    closeDb(checkpointClient);
+  }
+  const resolvedDbPath = normalizeBackupSourcePath(dbPath);
+  const backupPath = buildBackupPath(dbPath);
+  await fs3.copyFile(resolvedDbPath, backupPath);
+  await copySidecarIfPresent(`${resolvedDbPath}-wal`, `${backupPath}-wal`);
+  await copySidecarIfPresent(`${resolvedDbPath}-shm`, `${backupPath}-shm`);
+  return backupPath;
+}
+function closeDb(client) {
+  client.close();
+}
+
+// src/db/feedback.ts
+var RESPONSE_MIN_CHARS = 50;
+var RESPONSE_MAX_CHARS = 8e3;
+var SIGNAL_USED = 1;
+var SIGNAL_UNCLEAR = 0.4;
+var SIGNAL_CORRECTED = 0;
+var RESPONSE_USED_THRESHOLD = 0.5;
+var CORRECTION_THRESHOLD = 0.6;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (value <= 0) {
+    return 0;
+  }
+  if (value >= 1) {
+    return 1;
+  }
+  return value;
+}
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  if (value <= min) {
+    return min;
+  }
+  if (value >= max) {
+    return max;
+  }
+  return value;
+}
+function qualityFloorByType(type) {
+  if (type === "fact" || type === "preference") {
+    return 0.35;
+  }
+  if (type === "decision" || type === "lesson") {
+    return 0.25;
+  }
+  if (type === "todo" || type === "event" || type === "relationship") {
+    return 0.15;
+  }
+  return 0.1;
+}
+function computeDecayPenalty(daysSinceLastRecall) {
+  if (daysSinceLastRecall <= 60) {
+    return 1;
+  }
+  return Math.max(0.3, 1 - (daysSinceLastRecall - 60) / 180);
+}
+function mapBufferToVector(value) {
+  if (value instanceof ArrayBuffer) {
+    return Array.from(new Float32Array(value));
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    return Array.from(
+      new Float32Array(view.buffer, view.byteOffset, Math.floor(view.byteLength / Float32Array.BYTES_PER_ELEMENT))
+    );
+  }
+  return [];
+}
+function cosineSimilarity(a, b) {
+  const size = Math.min(a.length, b.length);
+  if (size === 0) {
+    return 0;
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < size; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA <= 0 || normB <= 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function extractTextFromContent(content, separator) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const parts = [];
+  for (const block of content) {
+    if (!isRecord(block) || block.type !== "text") {
+      continue;
+    }
+    const text = block.text;
+    if (typeof text !== "string") {
+      continue;
+    }
+    const trimmed = text.trim();
+    if (trimmed) {
+      parts.push(trimmed);
+    }
+  }
+  return parts.join(separator).trim();
+}
+function collectAssistantText(messages) {
+  const parts = [];
+  for (const message of messages) {
+    if (!isRecord(message) || message.role !== "assistant") {
+      continue;
+    }
+    const text = extractTextFromContent(message.content, "\n");
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function extractStoreContentsFromInput(input) {
+  if (!isRecord(input)) {
+    return [];
+  }
+  const out = [];
+  const directContent = input.content;
+  if (typeof directContent === "string" && directContent.trim()) {
+    out.push(directContent.trim());
+  }
+  const entries = input.entries;
+  if (Array.isArray(entries)) {
+    for (const item of entries) {
+      if (!isRecord(item)) {
+        continue;
+      }
+      const content = item.content;
+      if (typeof content === "string" && content.trim()) {
+        out.push(content.trim());
+      }
+    }
+  }
+  return out;
+}
+function parseFunctionArguments(rawArgs) {
+  if (isRecord(rawArgs)) {
+    return rawArgs;
+  }
+  if (typeof rawArgs !== "string" || !rawArgs.trim()) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(rawArgs);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function collectAgenrStoreContents(messages) {
+  const contents = [];
+  for (const message of messages) {
+    if (!isRecord(message) || message.role !== "assistant") {
+      continue;
+    }
+    const contentBlocks = message.content;
+    if (Array.isArray(contentBlocks)) {
+      for (const block of contentBlocks) {
+        if (!isRecord(block) || block.type !== "tool_use" || block.name !== "agenr_store") {
+          continue;
+        }
+        contents.push(...extractStoreContentsFromInput(block.input));
+      }
+    }
+    const toolCalls = message.tool_calls;
+    if (!Array.isArray(toolCalls)) {
+      continue;
+    }
+    for (const toolCall of toolCalls) {
+      if (!isRecord(toolCall)) {
+        continue;
+      }
+      if (typeof toolCall.name === "string" && toolCall.name === "agenr_store") {
+        const namedArgs = parseFunctionArguments(toolCall.arguments);
+        if (namedArgs) {
+          contents.push(...extractStoreContentsFromInput(namedArgs));
+        } else {
+          contents.push(...extractStoreContentsFromInput(toolCall.input));
+        }
+        continue;
+      }
+      const fn = toolCall.function;
+      if (!isRecord(fn) || fn.name !== "agenr_store") {
+        continue;
+      }
+      const args = parseFunctionArguments(fn.arguments);
+      if (args) {
+        contents.push(...extractStoreContentsFromInput(args));
+      }
+    }
+  }
+  return Array.from(new Set(contents));
+}
+async function fetchEmbeddedEntries(db, ids) {
+  const idList = Array.from(ids).filter((id) => id.trim().length > 0);
+  if (idList.length === 0) {
+    return [];
+  }
+  const placeholders = idList.map(() => "?").join(", ");
+  const result = await db.execute({
+    sql: `
+      SELECT id, embedding
+      FROM entries
+      WHERE id IN (${placeholders})
+        AND embedding IS NOT NULL
+    `,
+    args: idList
+  });
+  const embeddedEntries = [];
+  for (const row of result.rows) {
+    const id = toStringValue(row.id);
+    const embedding = mapBufferToVector(row.embedding);
+    if (!id || embedding.length === 0) {
+      continue;
+    }
+    embeddedEntries.push({ id, embedding });
+  }
+  return embeddedEntries;
+}
+async function updateQualityScores(db, updates) {
+  if (updates.length === 0) {
+    return;
+  }
+  const normalizedUpdates = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    const id = update.id.trim();
+    if (!id) {
+      continue;
+    }
+    normalizedUpdates.set(id, clamp01(update.signal));
+  }
+  if (normalizedUpdates.size === 0) {
+    return;
+  }
+  const sql = `
+    UPDATE entries
+    SET quality_score = MIN(
+      1.0,
+      MAX(
+        0.8 * COALESCE(quality_score, 0.5) + 0.2 * ?,
+        CASE WHEN type IN ('fact', 'preference') THEN 0.35 ELSE 0.1 END
+      )
+    )
+    WHERE id = ?
+  `;
+  await db.execute("BEGIN");
+  try {
+    for (const [id, signal] of normalizedUpdates.entries()) {
+      await db.execute({ sql, args: [signal, id] });
+    }
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function evolveQualityScores(db, options = {}) {
+  const result = await db.execute({
+    sql: `
+      SELECT
+        id,
+        type,
+        importance,
+        recall_count,
+        confirmations,
+        quality_score,
+        last_recalled_at,
+        created_at
+      FROM entries
+      WHERE superseded_by IS NULL
+        AND COALESCE(retired, 0) = 0
+    `,
+    args: []
+  });
+  const rows = result.rows.map((row) => ({
+    id: toStringValue(row.id).trim(),
+    type: toStringValue(row.type),
+    importance: Math.max(0, toNumber(row.importance)),
+    recallCount: Math.max(0, toNumber(row.recall_count)),
+    confirmations: Math.max(0, toNumber(row.confirmations)),
+    qualityScore: toNumber(row.quality_score),
+    lastRecalledAt: toStringValue(row.last_recalled_at),
+    createdAt: toStringValue(row.created_at)
+  })).filter((row) => row.id.length > 0);
+  if (rows.length === 0) {
+    return {
+      updated: 0,
+      stats: {
+        high: 0,
+        medium: 0,
+        low: 0,
+        avgBefore: 0,
+        avgAfter: 0
+      }
+    };
+  }
+  const edgeCounts = await getCoRecallEdgeCounts(db);
+  const maxRecallCount = rows.reduce((max, row) => Math.max(max, row.recallCount), 0);
+  const maxEdgeCount = rows.reduce((max, row) => Math.max(max, edgeCounts.get(row.id) ?? 0), 0);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  let high = 0;
+  let medium = 0;
+  let low = 0;
+  let totalBefore = 0;
+  let totalAfter = 0;
+  const updates = [];
+  for (const row of rows) {
+    const recallSignal = maxRecallCount > 0 ? clamp(row.recallCount / maxRecallCount, 0, 1) : 0;
+    const edgeSignal = maxEdgeCount > 0 ? clamp((edgeCounts.get(row.id) ?? 0) / maxEdgeCount, 0, 1) : 0;
+    const confirmSignal = clamp(row.confirmations / 3, 0, 1);
+    const importanceNormalized = clamp(row.importance / 10, 0, 1);
+    const sourceDate = row.lastRecalledAt || row.createdAt;
+    const daysSinceLastRecall = parseDaysBetween(now, sourceDate || void 0);
+    const decayPenalty = computeDecayPenalty(daysSinceLastRecall);
+    const rawQuality = (0.35 * recallSignal + 0.25 * edgeSignal + 0.2 * confirmSignal + 0.2 * importanceNormalized) * decayPenalty;
+    const evolved = clamp(rawQuality, 0.05, 1);
+    const existingQuality = clamp(Number.isFinite(row.qualityScore) ? row.qualityScore : 0.5, 0, 1);
+    const blendedQuality = 0.6 * evolved + 0.4 * existingQuality;
+    const finalQuality = clamp(Math.max(blendedQuality, qualityFloorByType(row.type)), 0.05, 1);
+    totalBefore += existingQuality;
+    totalAfter += finalQuality;
+    if (finalQuality >= 0.7) {
+      high += 1;
+    } else if (finalQuality >= 0.3) {
+      medium += 1;
+    } else {
+      low += 1;
+    }
+    updates.push({ id: row.id, qualityScore: finalQuality });
+  }
+  if (updates.length > 0) {
+    await db.execute("BEGIN");
+    try {
+      for (const update of updates) {
+        await db.execute({
+          sql: `
+            UPDATE entries
+            SET quality_score = ?
+            WHERE id = ?
+          `,
+          args: [update.qualityScore, update.id]
+        });
+      }
+      if (options.dryRun === true) {
+        await db.execute("ROLLBACK");
+      } else {
+        await db.execute("COMMIT");
+      }
+    } catch (error) {
+      try {
+        await db.execute("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  return {
+    updated: updates.length,
+    stats: {
+      high,
+      medium,
+      low,
+      avgBefore: totalBefore / updates.length,
+      avgAfter: totalAfter / updates.length
+    }
+  };
+}
+async function computeRecallFeedback(db, sessionKey, messages, recalledEntryIds, config, logger) {
+  const emptyResult = {
+    usedIds: [],
+    correctedIds: [],
+    updatedIds: []
+  };
+  if (recalledEntryIds.size === 0) {
+    return emptyResult;
+  }
+  const assistantText = collectAssistantText(messages);
+  if (assistantText.length < RESPONSE_MIN_CHARS) {
+    return emptyResult;
+  }
+  const responseCorpus = assistantText.slice(0, RESPONSE_MAX_CHARS);
+  let apiKey;
+  try {
+    apiKey = resolveEmbeddingApiKey(config, process.env);
+  } catch (error) {
+    logger.warn(
+      `[agenr] before_reset: feedback skipped for session=${sessionKey} - ${error instanceof Error ? error.message : String(error)}`
+    );
+    return emptyResult;
+  }
+  let responseEmbedding = null;
+  try {
+    const vectors = await embed([responseCorpus], apiKey);
+    responseEmbedding = vectors[0] ?? null;
+  } catch (error) {
+    logger.warn(
+      `[agenr] before_reset: feedback embedding failed for session=${sessionKey}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return emptyResult;
+  }
+  if (!responseEmbedding || responseEmbedding.length === 0) {
+    return emptyResult;
+  }
+  const recalledEntries = await fetchEmbeddedEntries(db, recalledEntryIds);
+  if (recalledEntries.length === 0) {
+    return emptyResult;
+  }
+  const storeContents = collectAgenrStoreContents(messages);
+  let correctionEmbeddings = [];
+  if (storeContents.length > 0) {
+    try {
+      correctionEmbeddings = await embed(storeContents, apiKey);
+    } catch (error) {
+      logger.warn(
+        `[agenr] before_reset: correction embedding failed for session=${sessionKey}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      correctionEmbeddings = [];
+    }
+  }
+  const correctedIds = /* @__PURE__ */ new Set();
+  if (correctionEmbeddings.length > 0) {
+    for (const entry of recalledEntries) {
+      for (const correctionEmbedding of correctionEmbeddings) {
+        if (cosineSimilarity(entry.embedding, correctionEmbedding) >= CORRECTION_THRESHOLD) {
+          correctedIds.add(entry.id);
+          break;
+        }
+      }
+    }
+  }
+  const updates = recalledEntries.map((entry) => {
+    if (correctedIds.has(entry.id)) {
+      return { id: entry.id, signal: SIGNAL_CORRECTED };
+    }
+    const sim = cosineSimilarity(entry.embedding, responseEmbedding ?? []);
+    return {
+      id: entry.id,
+      signal: sim >= RESPONSE_USED_THRESHOLD ? SIGNAL_USED : SIGNAL_UNCLEAR
+    };
+  });
+  if (updates.length > 0) {
+    await updateQualityScores(db, updates);
+  }
+  return {
+    usedIds: updates.filter((update) => update.signal === SIGNAL_USED).map((update) => update.id),
+    correctedIds: Array.from(correctedIds),
+    updatedIds: updates.map((update) => update.id)
+  };
+}
+
+// src/types.ts
+var KNOWLEDGE_TYPES = [
+  "fact",
+  "decision",
+  "preference",
+  "todo",
+  "relationship",
+  "event",
+  "lesson"
+];
+var IMPORTANCE_MIN = 1;
+var IMPORTANCE_MAX = 10;
+var EXPIRY_LEVELS = ["core", "permanent", "temporary"];
+var SCOPE_LEVELS = ["private", "personal", "public"];
+var KNOWLEDGE_PLATFORMS = ["openclaw", "claude-code", "codex", "plaud"];
+
+// src/llm/client.ts
+function resolveProviderAndModel(input) {
+  const config = input.config ?? readConfig(input.env);
+  const auth = config?.auth;
+  if (!auth) {
+    throw new Error("Not configured. Run `agenr setup`.");
+  }
+  const providerRaw = input.provider?.trim() || config.provider?.trim();
+  const modelRaw = input.model?.trim() || config?.models?.extraction?.trim();
+  if (!providerRaw || !modelRaw) {
+    throw new Error(
+      [
+        "Provider/model are not configured.",
+        "Run `agenr setup`, or pass --provider and --model to override this run."
+      ].join("\n")
+    );
+  }
+  const provider = normalizeProvider(providerRaw);
+  const expectedProvider = authMethodToProvider(auth);
+  if (provider !== expectedProvider) {
+    throw new Error(
+      [
+        `Configured auth method "${auth}" requires provider "${expectedProvider}".`,
+        "Use `agenr config set auth <method>` to switch auth/provider together."
+      ].join(" ")
+    );
+  }
+  const resolvedModel = resolveModel(provider, modelRaw);
+  return {
+    auth,
+    provider: resolvedModel.provider,
+    model: resolvedModel.modelId,
+    storedCredentials: config?.credentials
+  };
+}
+function createLlmClient(input) {
+  const resolved = resolveProviderAndModel(input);
+  const resolvedModel = resolveModel(resolved.provider, resolved.model);
+  const credentials = resolveCredentials({
+    auth: resolved.auth,
+    storedCredentials: resolved.storedCredentials,
+    env: input.env
+  });
+  return {
+    auth: resolved.auth,
+    resolvedModel,
+    credentials
+  };
+}
+
+// src/db/review-queue.ts
+import { randomUUID } from "crypto";
+var REVIEW_REASONS = ["low_quality", "contradicted", "stale", "manual"];
+var REVIEW_ACTIONS = ["retire", "review", "merge"];
+function ensureReason(reason) {
+  if (REVIEW_REASONS.includes(reason)) {
+    return reason;
+  }
+  throw new Error(`Invalid review reason: ${reason}`);
+}
+function ensureAction(action) {
+  if (REVIEW_ACTIONS.includes(action)) {
+    return action;
+  }
+  throw new Error(`Invalid review suggested action: ${action}`);
+}
+async function flagForReview(db, entryId, reason, detail, suggestedAction) {
+  const normalizedEntryId = entryId.trim();
+  const normalizedReason = ensureReason(reason);
+  const normalizedAction = ensureAction(suggestedAction);
+  if (!normalizedEntryId) {
+    throw new Error("entryId is required");
+  }
+  const id = randomUUID();
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const inserted = await db.execute({
+    sql: `
+      INSERT INTO review_queue (
+        id,
+        entry_id,
+        reason,
+        detail,
+        suggested_action,
+        status,
+        created_at
+      )
+      VALUES (?, ?, ?, ?, ?, 'pending', ?)
+      ON CONFLICT DO NOTHING
+    `,
+    args: [id, normalizedEntryId, normalizedReason, detail, normalizedAction, createdAt]
+  });
+  if (toRowsAffected(inserted.rowsAffected) === 0) {
+    return {
+      created: false,
+      id: null
+    };
+  }
+  return { created: true, id };
+}
+async function getPendingReviews(db, limit = 20) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+  const result = await db.execute({
+    sql: `
+      SELECT
+        review_queue.id,
+        review_queue.entry_id,
+        review_queue.reason,
+        review_queue.detail,
+        review_queue.suggested_action,
+        review_queue.status,
+        review_queue.created_at,
+        review_queue.resolved_at,
+        entries.subject,
+        entries.content
+      FROM review_queue
+      LEFT JOIN entries ON entries.id = review_queue.entry_id
+      WHERE review_queue.status = 'pending'
+      ORDER BY review_queue.created_at ASC
+      LIMIT ?
+    `,
+    args: [safeLimit]
+  });
+  return result.rows.map((row) => ({
+    id: toStringValue(row.id),
+    entryId: toStringValue(row.entry_id),
+    reason: ensureReason(toStringValue(row.reason)),
+    detail: toStringValue(row.detail),
+    suggestedAction: ensureAction(toStringValue(row.suggested_action)),
+    status: toStringValue(row.status) || "pending",
+    createdAt: toStringValue(row.created_at),
+    resolvedAt: toStringValue(row.resolved_at),
+    entrySubject: toStringValue(row.subject),
+    entryContent: toStringValue(row.content)
+  }));
+}
+async function resolveReview(db, reviewId, status) {
+  const normalizedReviewId = reviewId.trim();
+  if (!normalizedReviewId) {
+    return false;
+  }
+  const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.execute({
+    sql: `
+      UPDATE review_queue
+      SET status = ?,
+          resolved_at = ?
+      WHERE id = ?
+        AND status = 'pending'
+    `,
+    args: [status, resolvedAt, normalizedReviewId]
+  });
+  return toRowsAffected(result.rowsAffected) > 0;
+}
+async function checkAndFlagLowQuality(db, entryId, qualityScore, recallCount) {
+  if (!Number.isFinite(qualityScore) || !Number.isFinite(recallCount)) {
+    return;
+  }
+  if (qualityScore >= 0.2 || recallCount < 10) {
+    return;
+  }
+  const roundedQuality = Math.max(0, Math.min(1, qualityScore));
+  const detail = `quality_score ${roundedQuality.toFixed(3)} after ${Math.floor(recallCount)} recalls`;
+  await flagForReview(db, entryId, "low_quality", detail, "retire");
+}
+async function getPendingReviewById(db, reviewId) {
+  const normalizedReviewId = reviewId.trim();
+  if (!normalizedReviewId) {
+    return null;
+  }
+  const result = await db.execute({
+    sql: `
+      SELECT
+        review_queue.id,
+        review_queue.entry_id,
+        review_queue.reason,
+        review_queue.detail,
+        review_queue.suggested_action,
+        review_queue.status,
+        review_queue.created_at,
+        review_queue.resolved_at,
+        entries.subject,
+        entries.content
+      FROM review_queue
+      LEFT JOIN entries ON entries.id = review_queue.entry_id
+      WHERE review_queue.id = ?
+      LIMIT 1
+    `,
+    args: [normalizedReviewId]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    id: toStringValue(row.id),
+    entryId: toStringValue(row.entry_id),
+    reason: ensureReason(toStringValue(row.reason)),
+    detail: toStringValue(row.detail),
+    suggestedAction: ensureAction(toStringValue(row.suggested_action)),
+    status: toStringValue(row.status) || "pending",
+    createdAt: toStringValue(row.created_at),
+    resolvedAt: toStringValue(row.resolved_at),
+    entrySubject: toStringValue(row.subject),
+    entryContent: toStringValue(row.content)
+  };
+}
+async function getPendingReviewCountsByReason(db) {
+  const result = await db.execute({
+    sql: `
+      SELECT reason, COUNT(*) AS count
+      FROM review_queue
+      WHERE status = 'pending'
+      GROUP BY reason
+      ORDER BY count DESC, reason ASC
+    `,
+    args: []
+  });
+  return result.rows.map((row) => ({
+    reason: ensureReason(toStringValue(row.reason)),
+    count: toNumber(row.count)
+  }));
+}
+async function getOldestPendingReviewCreatedAt(db) {
+  const result = await db.execute({
+    sql: `
+      SELECT MIN(created_at) AS oldest_created_at
+      FROM review_queue
+      WHERE status = 'pending'
+    `,
+    args: []
+  });
+  const oldest = toStringValue(result.rows[0]?.oldest_created_at);
+  return oldest || null;
+}
+async function rehabilitateEntry(db, entryId, floor = 0.3) {
+  const normalizedEntryId = entryId.trim();
+  if (!normalizedEntryId || !Number.isFinite(floor)) {
+    return;
+  }
+  await db.execute({
+    sql: `
+      UPDATE entries
+      SET quality_score = MAX(COALESCE(quality_score, 0.5), ?)
+      WHERE id = ?
+    `,
+    args: [floor, normalizedEntryId]
+  });
+}
+
+export {
+  resolveModel,
+  normalizeLabel,
+  DEFAULT_TASK_MODEL,
+  resolveDefaultKnowledgeDbPath,
+  resolveConfigPath,
+  getAuthMethodDefinition,
+  readConfig,
+  writeConfig,
+  resolveProjectFromGlobalConfig,
+  mergeConfigPatch,
+  isCompleteConfig,
+  setConfigKey,
+  setStoredCredential,
+  maskSecret,
+  describeAuth,
+  resolveModelForTask,
+  composeEmbeddingText,
+  embed,
+  resolveEmbeddingApiKey,
+  probeCredentials,
+  runSimpleStream,
+  APP_VERSION,
+  CREATE_IDX_ENTRIES_EMBEDDING_SQL,
+  dropFtsTriggersAndIndex,
+  rebuildFtsAndTriggers,
+  rebuildVectorIndex,
+  setBulkIngestMeta,
+  clearBulkIngestMeta,
+  initSchema,
+  resetDb,
+  DEFAULT_DB_PATH,
+  buildBackupPath,
+  getDb,
+  initDb,
+  walCheckpoint,
+  backupDb,
+  closeDb,
+  evolveQualityScores,
+  computeRecallFeedback,
+  KNOWLEDGE_TYPES,
+  IMPORTANCE_MIN,
+  IMPORTANCE_MAX,
+  EXPIRY_LEVELS,
+  SCOPE_LEVELS,
+  KNOWLEDGE_PLATFORMS,
+  createLlmClient,
+  getPendingReviews,
+  resolveReview,
+  checkAndFlagLowQuality,
+  getPendingReviewById,
+  getPendingReviewCountsByReason,
+  getOldestPendingReviewCreatedAt,
+  rehabilitateEntry
+};