@edihasaj/recall 0.5.2

package/dist/chunk-IILLSHLM.js

@@ -0,0 +1,3021 @@
+import {
+  activityEvents,
+  auditTrail,
+  feedbackEvents,
+  historySnippets,
+  memories,
+  memoryEmbeddings,
+  memoryMaintenanceTasks
+} from "./chunk-A5UIRZU6.js";
+
+// src/maintenance/tasks.ts
+import { and as and2, desc as desc2, eq as eq7, gt, inArray as inArray2, lt, or, isNull, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID4 } from "crypto";
+import { z as z2 } from "zod";
+
+// src/embeddings/embeddings.ts
+import { createHash } from "crypto";
+import { eq as eq3 } from "drizzle-orm";
+
+// src/types.ts
+import { z } from "zod";
+var MemoryStatus = z.enum([
+  "transient",
+  "candidate",
+  "active",
+  "rejected"
+]);
+var MemoryType = z.enum([
+  "rule",
+  "command",
+  "gotcha",
+  "decision",
+  "review_pattern"
+]);
+var MemoryScope = z.enum(["session", "path", "repo", "team", "global"]);
+var MemorySource = z.enum([
+  "user_correction",
+  "user_reported_review",
+  "repo_scan",
+  "config_parse"
+]);
+var FeedbackOutcome = z.enum([
+  "followed",
+  "overridden",
+  "ignored",
+  "contradicted"
+]);
+var EvidenceEntry = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("session_correction"),
+    session: z.string(),
+    timestamp: z.string(),
+    context: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("review_feedback"),
+    reported_by_user: z.boolean(),
+    reviewer: z.string().optional(),
+    timestamp: z.string(),
+    context: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("repo_scan"),
+    file: z.string(),
+    timestamp: z.string()
+  }),
+  z.object({
+    type: z.literal("repeated_correction"),
+    count: z.number(),
+    sessions: z.array(z.string()),
+    timestamp: z.string()
+  })
+]);
+var CaptureContextToolCall = z.object({
+  name: z.string(),
+  path: z.string().optional(),
+  exit_code: z.number().optional()
+});
+var CaptureContext = z.object({
+  prev_assistant_text: z.string().optional(),
+  recent_tool_calls: z.array(CaptureContextToolCall).max(5).optional(),
+  repo: z.string().nullable().optional(),
+  path: z.string().nullable().optional(),
+  agent: z.string().optional()
+});
+var MemoryItem = z.object({
+  id: z.string().uuid(),
+  type: MemoryType,
+  text: z.string(),
+  scope: MemoryScope,
+  path_scope: z.string().nullable(),
+  repo: z.string().nullable(),
+  status: MemoryStatus,
+  confidence: z.number().min(0).max(1),
+  source: MemorySource,
+  evidence: z.array(EvidenceEntry),
+  capture_context: CaptureContext.nullable(),
+  supersedes: z.string().uuid().nullable(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  last_validated_at: z.string().nullable(),
+  last_injected_at: z.string().nullable(),
+  injection_count: z.number().int().nonnegative(),
+  override_count: z.number().int().nonnegative(),
+  repetition_count: z.number().int().nonnegative(),
+  auto_inject: z.boolean()
+});
+var FeedbackEvent = z.object({
+  id: z.string().uuid(),
+  memory_id: z.string().uuid(),
+  session_id: z.string(),
+  injected: z.boolean(),
+  outcome: FeedbackOutcome,
+  timestamp: z.string()
+});
+var MemoryInjection = z.object({
+  id: z.string().uuid(),
+  memory_id: z.string().uuid(),
+  session_id: z.string(),
+  repo: z.string().nullable(),
+  injected_at: z.string(),
+  outcome: FeedbackOutcome.nullable(),
+  outcome_at: z.string().nullable()
+});
+var MaintenanceTaskKind = z.enum([
+  "summarize_history",
+  "merge_duplicates",
+  "refine_candidate",
+  "summarize_session",
+  "synthesize_repo",
+  "verify_capture"
+]);
+var MaintenanceTaskStatus = z.enum([
+  "pending",
+  "claimed",
+  "submitted",
+  "completed",
+  "abandoned"
+]);
+var MaintenanceTask = z.object({
+  id: z.string().uuid(),
+  kind: MaintenanceTaskKind,
+  status: MaintenanceTaskStatus,
+  priority: z.number().int(),
+  repo: z.string().nullable(),
+  target_key: z.string(),
+  payload: z.record(z.string(), z.unknown()),
+  result: z.record(z.string(), z.unknown()).nullable(),
+  failure_reason: z.string().nullable(),
+  claimed_by: z.string().nullable(),
+  claimed_at: z.string().nullable(),
+  claim_expires_at: z.string().nullable(),
+  submitted_at: z.string().nullable(),
+  completed_at: z.string().nullable(),
+  created_at: z.string(),
+  attempts: z.number().int().nonnegative(),
+  max_attempts: z.number().int().positive()
+});
+var ACTIVITY_SOURCE_PATTERN = /^(cli|daemon|mcp|system|hook)(:[a-z0-9][a-z0-9._-]*)?$/;
+var ActivitySource = z.string().regex(ACTIVITY_SOURCE_PATTERN);
+function tagActivitySource(transport, agent) {
+  if (!agent) return transport;
+  const normalized = agent.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+  if (!normalized) return transport;
+  return `${transport}:${normalized}`;
+}
+var ActivityEventType = z.enum([
+  "compile",
+  "query",
+  "scan",
+  "correction",
+  "review",
+  "feedback",
+  "signal",
+  "session_start",
+  "session_event",
+  "session_end",
+  "tool_call"
+]);
+var ActivityEvent = z.object({
+  id: z.string().uuid(),
+  session_id: z.string().nullable(),
+  repo: z.string().nullable(),
+  path: z.string().nullable(),
+  source: ActivitySource,
+  event_type: ActivityEventType,
+  memory_ids: z.array(z.string().uuid()),
+  request: z.record(z.string(), z.unknown()),
+  result: z.record(z.string(), z.unknown()),
+  created_at: z.string()
+});
+var ActivityEventQuery = z.object({
+  repo: z.string().optional(),
+  session_id: z.string().optional(),
+  source: ActivitySource.optional(),
+  event_type: ActivityEventType.optional(),
+  since: z.string().optional(),
+  limit: z.number().int().positive().optional()
+});
+var HookCallEvent = z.enum([
+  "session_started",
+  "prompt_submitted",
+  "tool_invoked",
+  "session_ended"
+]);
+var HookCall = z.object({
+  id: z.string().uuid(),
+  event: HookCallEvent,
+  agent: z.string(),
+  duration_ms: z.number().int().nonnegative(),
+  ok: z.boolean(),
+  created_at: z.string()
+});
+var HookCallStatsQuery = z.object({
+  agent: z.string().optional(),
+  event: HookCallEvent.optional(),
+  limit: z.number().int().positive().optional()
+});
+var HookCallStatsRow = z.object({
+  event: HookCallEvent,
+  agent: z.string(),
+  total_calls: z.number().int().nonnegative(),
+  ok_calls: z.number().int().nonnegative(),
+  error_calls: z.number().int().nonnegative(),
+  avg_duration_ms: z.number().nonnegative(),
+  max_duration_ms: z.number().int().nonnegative(),
+  last_called_at: z.string()
+});
+var CONFIDENCE = {
+  /** Below this → transient, never stored durably */
+  TRANSIENT_MAX: 0.3,
+  /** Below this → candidate, stored but not injected */
+  CANDIDATE_MAX: 0.6,
+  /** At or above this → active, injected when scope matches */
+  ACTIVE_MIN: 0.6
+};
+var PROMOTION = {
+  /** User explicitly confirms */
+  EXPLICIT_CONFIRM: 0.8,
+  /** Same correction repeats */
+  REPEAT_CORRECTION: 0.2,
+  /** User-reported review feedback */
+  REVIEW_FEEDBACK: 0.3,
+  /** Passive gain per use without override */
+  PASSIVE_GAIN: 0.05
+};
+var CompilerConfig = z.object({
+  confidence_threshold: z.number().default(0.6),
+  max_lines: z.number().default(15),
+  max_commands: z.number().default(3),
+  max_gotchas: z.number().default(3),
+  max_history_snippets: z.number().default(2),
+  token_budget: z.number().default(2e3),
+  include_candidates: z.boolean().default(false)
+});
+var MemoryQuery = z.object({
+  repo: z.string().optional(),
+  path: z.string().optional(),
+  scope: MemoryScope.optional(),
+  type: MemoryType.optional(),
+  status: MemoryStatus.optional(),
+  min_confidence: z.number().optional(),
+  semantic_query: z.string().optional(),
+  auto_inject: z.boolean().optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional()
+});
+var SyncConfig = z.object({
+  remote_url: z.string().url(),
+  api_key: z.string(),
+  team_id: z.string().optional(),
+  auto_sync: z.boolean().default(false),
+  sync_interval_seconds: z.number().default(300)
+});
+var SyncDirection = z.enum(["push", "pull", "both"]);
+var SyncResult = z.object({
+  pushed: z.number(),
+  pulled: z.number(),
+  conflicts: z.number(),
+  errors: z.array(z.string())
+});
+var TeamMember = z.object({
+  id: z.string().uuid(),
+  team_id: z.string().uuid(),
+  user_id: z.string(),
+  role: z.enum(["owner", "admin", "member"]),
+  joined_at: z.string()
+});
+var EmbeddingConfig = z.object({
+  provider: z.enum(["nomic", "multilingual-e5", "bge-small-en-v1.5"]).default("nomic"),
+  model: z.string().default("nomic-ai/nomic-embed-text-v1.5"),
+  dimensions: z.number().default(512),
+  version: z.string().default("v1"),
+  similarity_threshold: z.number().default(0.8)
+});
+var HistorySnippetKind = z.enum([
+  "session_summary",
+  "correction_summary",
+  "decision_summary",
+  "review_summary",
+  "compile_summary",
+  "repo_synthesis"
+]);
+var HistorySnippet = z.object({
+  id: z.string().uuid(),
+  repo: z.string().nullable(),
+  session_id: z.string().nullable(),
+  kind: HistorySnippetKind,
+  text: z.string(),
+  source_activity_ids: z.array(z.string().uuid()),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var EvalSession = z.object({
+  id: z.string().uuid(),
+  repo: z.string(),
+  started_at: z.string(),
+  ended_at: z.string().nullable(),
+  memories_injected: z.number(),
+  memories_followed: z.number(),
+  memories_overridden: z.number(),
+  user_corrections: z.number(),
+  test_passes: z.number(),
+  test_failures: z.number()
+});
+var MaintenanceEvalMetrics = z.object({
+  total_completed: z.number(),
+  total_abandoned: z.number(),
+  abandon_rate: z.number(),
+  mean_completion_ms: z.number().nullable(),
+  completed_by_kind: z.record(z.number()),
+  merge_precision: z.number().nullable(),
+  merge_rollbacks: z.number()
+});
+var EvalMetrics = z.object({
+  total_sessions: z.number(),
+  injection_rate: z.number(),
+  follow_rate: z.number(),
+  override_rate: z.number(),
+  correction_frequency: z.number(),
+  avg_confidence_at_injection: z.number(),
+  memory_effectiveness: z.number(),
+  maintenance: MaintenanceEvalMetrics.optional()
+});
+var RetrievalEvalCase = z.object({
+  name: z.string(),
+  repo: z.string(),
+  path: z.string().optional(),
+  query_text: z.string().default(""),
+  include_candidates: z.boolean().default(false),
+  confidence_threshold: z.number().optional(),
+  max_lines: z.number().optional(),
+  max_commands: z.number().optional(),
+  max_gotchas: z.number().optional(),
+  token_budget: z.number().optional(),
+  expected_all_texts: z.array(z.string()).default([]),
+  expected_any_texts: z.array(z.string()).default([]),
+  forbidden_texts: z.array(z.string()).default([]),
+  min_included: z.number().int().nonnegative().optional(),
+  max_included: z.number().int().nonnegative().optional()
+});
+var RetrievalEvalFile = z.object({
+  cases: z.array(RetrievalEvalCase)
+});
+var ImplicitSignal = z.object({
+  id: z.string().uuid(),
+  memory_id: z.string().uuid(),
+  session_id: z.string(),
+  signal_type: z.enum([
+    "test_pass",
+    "test_fail",
+    "file_unchanged",
+    "file_rewritten",
+    "task_accepted",
+    "task_rejected"
+  ]),
+  timestamp: z.string(),
+  context: z.string().optional()
+});
+var RecallConfig = z.object({
+  sync: SyncConfig.optional(),
+  embeddings: EmbeddingConfig.optional()
+});
+var PolicyRule = z.object({
+  id: z.string().uuid(),
+  org_id: z.string(),
+  rule_type: z.enum([
+    "min_confidence",
+    "require_approval",
+    "allowed_sources",
+    "blocked_scopes",
+    "auto_approve_pattern",
+    "max_active_per_repo",
+    "require_evidence_count"
+  ]),
+  config: z.record(z.unknown()),
+  enabled: z.boolean(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var ApprovalStatus = z.enum(["pending", "approved", "denied"]);
+var ApprovalRequest = z.object({
+  id: z.string().uuid(),
+  memory_id: z.string().uuid(),
+  org_id: z.string(),
+  requested_by: z.string(),
+  status: ApprovalStatus,
+  reviewed_by: z.string().nullable(),
+  reason: z.string().nullable(),
+  created_at: z.string(),
+  resolved_at: z.string().nullable()
+});
+var HealthScore = z.object({
+  memory_id: z.string().uuid(),
+  score: z.number().min(0).max(1),
+  confidence_component: z.number(),
+  freshness_component: z.number(),
+  follow_rate_component: z.number(),
+  signal_ratio_component: z.number(),
+  computed_at: z.string()
+});
+var Contradiction = z.object({
+  id: z.string().uuid(),
+  memory_a_id: z.string().uuid(),
+  memory_b_id: z.string().uuid(),
+  contradiction_type: z.enum([
+    "direct_negation",
+    "conflicting_rules",
+    "scope_overlap",
+    "superseded"
+  ]),
+  severity: z.enum(["low", "medium", "high"]),
+  description: z.string(),
+  resolved: z.boolean(),
+  resolution: z.string().nullable(),
+  detected_at: z.string(),
+  resolved_at: z.string().nullable()
+});
+var PruneConfig = z.object({
+  repo: z.string().optional(),
+  stale_days: z.number().default(90),
+  rejected_retention_days: z.number().default(30),
+  transient_retention_days: z.number().default(7),
+  min_health_score: z.number().default(0.2),
+  dry_run: z.boolean().default(false)
+});
+var AuditAction = z.enum([
+  "created",
+  "promoted",
+  "demoted",
+  "rejected",
+  "confirmed",
+  "reactivated",
+  "edited",
+  "pruned",
+  "policy_applied",
+  "approval_requested",
+  "approval_resolved",
+  "contradiction_detected",
+  "contradiction_resolved",
+  "rolled_back"
+]);
+var AuditEntry = z.object({
+  id: z.string().uuid(),
+  memory_id: z.string().uuid(),
+  action: AuditAction,
+  actor: z.string(),
+  before_snapshot: z.string().nullable(),
+  after_snapshot: z.string().nullable(),
+  reason: z.string().nullable(),
+  timestamp: z.string()
+});
+
+// src/embeddings/cache.ts
+import { existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getEmbeddingCacheRoot() {
+  if (process.platform === "linux" && process.env.XDG_CACHE_HOME) {
+    return join(process.env.XDG_CACHE_HOME, "recall", "models");
+  }
+  return join(homedir(), ".recall", "models");
+}
+function getEmbeddingCachePath(config) {
+  return join(getEmbeddingCacheRoot(), config.provider, ...config.model.split("/"));
+}
+function ensureEmbeddingCachePath(config) {
+  const cachePath = getEmbeddingCachePath(config);
+  mkdirSync(cachePath, { recursive: true });
+  return cachePath;
+}
+function getDirectorySize(path) {
+  if (!existsSync(path)) return 0;
+  const stat = statSync(path);
+  if (!stat.isDirectory()) return stat.size;
+  let total = 0;
+  for (const entry of readdirSync(path, { withFileTypes: true })) {
+    total += getDirectorySize(join(path, entry.name));
+  }
+  return total;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 ** 2) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 ** 3) return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+  return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+}
+
+// src/embeddings/providers/bge-small-en-v1.5.ts
+import { pipeline } from "@huggingface/transformers";
+var BGE_MODEL = "Xenova/bge-small-en-v1.5";
+var BGE_DIMENSIONS = 384;
+var extractorPromise = null;
+function getModel(config) {
+  return config.model || BGE_MODEL;
+}
+function getDimensions(config) {
+  const dimensions = config.dimensions || BGE_DIMENSIONS;
+  if (!Number.isInteger(dimensions) || dimensions <= 0) {
+    throw new Error(`Invalid bge-small-en-v1.5 embedding dimensions: ${dimensions}`);
+  }
+  if (dimensions > BGE_DIMENSIONS) {
+    throw new Error(`bge-small-en-v1.5 embeddings support at most ${BGE_DIMENSIONS} dimensions`);
+  }
+  return dimensions;
+}
+async function getExtractor(config) {
+  const cacheDir = ensureEmbeddingCachePath({
+    provider: config.provider,
+    model: getModel(config)
+  });
+  extractorPromise ??= pipeline("feature-extraction", getModel(config), {
+    cache_dir: cacheDir,
+    dtype: "q8"
+  });
+  return extractorPromise;
+}
+function tensorToEmbeddings(tensor) {
+  const [rows, columns] = tensor.dims.length === 1 ? [1, tensor.dims[0]] : tensor.dims;
+  if (!rows || !columns) {
+    throw new Error(`Unexpected bge-small-en-v1.5 tensor shape: [${tensor.dims.join(", ")}]`);
+  }
+  const embeddings = [];
+  for (let row = 0; row < rows; row++) {
+    const start = row * columns;
+    const end = start + columns;
+    embeddings.push(Float32Array.from(tensor.data.subarray(start, end)));
+  }
+  return embeddings;
+}
+async function embedTexts(texts, config) {
+  if (texts.length === 0) return [];
+  const extractor = await getExtractor(config);
+  const embeddings = await extractor(texts, {
+    pooling: "mean",
+    normalize: true
+  });
+  return tensorToEmbeddings(
+    embeddings.dims.at(-1) === getDimensions(config) ? embeddings : embeddings.slice(null, [0, getDimensions(config)]).normalize(2, -1)
+  );
+}
+function createBgeSmallEnV15Provider(config) {
+  return {
+    async embed(text, _purpose = "document") {
+      const [embedding] = await embedTexts([text], config);
+      return embedding;
+    },
+    async embedBatch(texts, _purpose = "document") {
+      return embedTexts(texts, config);
+    },
+    async prepare() {
+      await getExtractor(config);
+    },
+    metadata() {
+      const dims = getDimensions(config);
+      return {
+        model: getModel(config),
+        dimensions: dims,
+        canonical_dimensions: dims,
+        index_dimensions: dims,
+        version: config.version,
+        estimated_size_mb: 133
+      };
+    }
+  };
+}
+
+// src/embeddings/providers/multilingual-e5.ts
+import { pipeline as pipeline2 } from "@huggingface/transformers";
+var MULTILINGUAL_E5_MODEL = "Xenova/multilingual-e5-small";
+var MULTILINGUAL_E5_NATIVE_DIMENSIONS = 384;
+var MULTILINGUAL_E5_PREFIXES = {
+  document: "passage: ",
+  query: "query: "
+};
+var extractorPromise2 = null;
+function getModel2(config) {
+  return config.model || MULTILINGUAL_E5_MODEL;
+}
+function getDimensions2(config) {
+  const dimensions = config.dimensions || MULTILINGUAL_E5_NATIVE_DIMENSIONS;
+  if (!Number.isInteger(dimensions) || dimensions <= 0) {
+    throw new Error(`Invalid multilingual-e5 embedding dimensions: ${dimensions}`);
+  }
+  if (dimensions > MULTILINGUAL_E5_NATIVE_DIMENSIONS) {
+    throw new Error(`multilingual-e5 embeddings support at most ${MULTILINGUAL_E5_NATIVE_DIMENSIONS} dimensions`);
+  }
+  return dimensions;
+}
+function prefixTexts(texts, purpose) {
+  const prefix = MULTILINGUAL_E5_PREFIXES[purpose];
+  return texts.map((text) => `${prefix}${text}`);
+}
+async function getExtractor2(config) {
+  const cacheDir = ensureEmbeddingCachePath({
+    provider: config.provider,
+    model: getModel2(config)
+  });
+  extractorPromise2 ??= pipeline2("feature-extraction", getModel2(config), {
+    cache_dir: cacheDir,
+    dtype: "q8"
+  });
+  return extractorPromise2;
+}
+function tensorToEmbeddings2(tensor) {
+  const [rows, columns] = tensor.dims.length === 1 ? [1, tensor.dims[0]] : tensor.dims;
+  if (!rows || !columns) {
+    throw new Error(`Unexpected multilingual-e5 tensor shape: [${tensor.dims.join(", ")}]`);
+  }
+  const embeddings = [];
+  for (let row = 0; row < rows; row++) {
+    const start = row * columns;
+    const end = start + columns;
+    embeddings.push(Float32Array.from(tensor.data.subarray(start, end)));
+  }
+  return embeddings;
+}
+async function embedTexts2(texts, config, purpose) {
+  if (texts.length === 0) return [];
+  const extractor = await getExtractor2(config);
+  const embeddings = await extractor(prefixTexts(texts, purpose), {
+    pooling: "mean",
+    normalize: true
+  });
+  return tensorToEmbeddings2(
+    embeddings.dims.at(-1) === getDimensions2(config) ? embeddings : embeddings.slice(null, [0, getDimensions2(config)]).normalize(2, -1)
+  );
+}
+function createMultilingualE5Provider(config) {
+  return {
+    async embed(text, purpose = "document") {
+      const [embedding] = await embedTexts2([text], config, purpose);
+      return embedding;
+    },
+    async embedBatch(texts, purpose = "document") {
+      return embedTexts2(texts, config, purpose);
+    },
+    async prepare() {
+      await getExtractor2(config);
+    },
+    metadata() {
+      const dims = getDimensions2(config);
+      return {
+        model: getModel2(config),
+        dimensions: dims,
+        canonical_dimensions: dims,
+        index_dimensions: dims,
+        version: config.version,
+        task_prefix: `${MULTILINGUAL_E5_PREFIXES.document.trim()} | ${MULTILINGUAL_E5_PREFIXES.query.trim()}`,
+        estimated_size_mb: 113
+      };
+    }
+  };
+}
+
+// src/embeddings/providers/nomic.ts
+import { layer_norm, pipeline as pipeline3 } from "@huggingface/transformers";
+var NOMIC_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+var NOMIC_NATIVE_DIMENSIONS = 768;
+var NOMIC_PREFIXES = {
+  document: "search_document: ",
+  query: "search_query: "
+};
+var extractorPromise3 = null;
+function getModel3(config) {
+  return config.model || NOMIC_MODEL;
+}
+function getDimensions3(config) {
+  const dimensions = config.dimensions || 512;
+  if (!Number.isInteger(dimensions) || dimensions <= 0) {
+    throw new Error(`Invalid nomic embedding dimensions: ${dimensions}`);
+  }
+  if (dimensions > NOMIC_NATIVE_DIMENSIONS) {
+    throw new Error(`Nomic embeddings support at most ${NOMIC_NATIVE_DIMENSIONS} dimensions`);
+  }
+  return dimensions;
+}
+function prefixTexts2(texts, purpose) {
+  const prefix = NOMIC_PREFIXES[purpose];
+  return texts.map((text) => `${prefix}${text}`);
+}
+async function getExtractor3(config) {
+  const cacheDir = ensureEmbeddingCachePath({
+    provider: config.provider,
+    model: getModel3(config)
+  });
+  extractorPromise3 ??= pipeline3("feature-extraction", getModel3(config), {
+    cache_dir: cacheDir,
+    dtype: "q8"
+  });
+  return extractorPromise3;
+}
+function tensorToEmbeddings3(tensor) {
+  const [rows, columns] = tensor.dims.length === 1 ? [1, tensor.dims[0]] : tensor.dims;
+  if (!rows || !columns) {
+    throw new Error(`Unexpected nomic tensor shape: [${tensor.dims.join(", ")}]`);
+  }
+  const embeddings = [];
+  for (let row = 0; row < rows; row++) {
+    const start = row * columns;
+    const end = start + columns;
+    embeddings.push(Float32Array.from(tensor.data.subarray(start, end)));
+  }
+  return embeddings;
+}
+async function embedTexts3(texts, config, purpose) {
+  if (texts.length === 0) return [];
+  const extractor = await getExtractor3(config);
+  const rawEmbeddings = await extractor(prefixTexts2(texts, purpose), {
+    pooling: "mean"
+  });
+  const nativeDimensions = rawEmbeddings.dims.at(-1);
+  if (!nativeDimensions) {
+    throw new Error("Nomic extractor returned an embedding tensor without dimensions");
+  }
+  const normalized = layer_norm(rawEmbeddings, [nativeDimensions]).normalize(2, -1);
+  return tensorToEmbeddings3(normalized);
+}
+function createNomicProvider(config) {
+  return {
+    async embed(text, purpose = "document") {
+      const [embedding] = await embedTexts3([text], config, purpose);
+      return embedding;
+    },
+    async embedBatch(texts, purpose = "document") {
+      return embedTexts3(texts, config, purpose);
+    },
+    async prepare() {
+      await getExtractor3(config);
+    },
+    metadata() {
+      const indexDimensions = getDimensions3(config);
+      return {
+        model: getModel3(config),
+        dimensions: indexDimensions,
+        canonical_dimensions: NOMIC_NATIVE_DIMENSIONS,
+        index_dimensions: indexDimensions,
+        version: config.version,
+        task_prefix: `${NOMIC_PREFIXES.document.trim()} | ${NOMIC_PREFIXES.query.trim()}`,
+        estimated_size_mb: 140
+      };
+    }
+  };
+}
+
+// src/embeddings/providers/index.ts
+function resolveProvider(config) {
+  switch (config.provider) {
+    case "bge-small-en-v1.5":
+      return createBgeSmallEnV15Provider(config);
+    case "multilingual-e5":
+      return createMultilingualE5Provider(config);
+    case "nomic":
+      return createNomicProvider(config);
+    default:
+      throw new Error(`Unsupported embedding provider: ${config.provider}`);
+  }
+}
+
+// src/vector/sqlite-vec.ts
+import * as sqliteVec from "sqlite-vec";
+import { eq } from "drizzle-orm";
+var VEC_MEMORY_INDEX = "vec_memory_index";
+var loadedClients = /* @__PURE__ */ new WeakSet();
+function getSqlite(db) {
+  return db.$client;
+}
+function hasMemoryVecIndex(db) {
+  return Boolean(
+    getSqlite(db).prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_MEMORY_INDEX)
+  );
+}
+function ensureSqliteVecLoaded(db) {
+  const sqlite = getSqlite(db);
+  if (loadedClients.has(sqlite)) return;
+  sqliteVec.load(sqlite);
+  loadedClients.add(sqlite);
+}
+function getMemoryVecDimension(rows) {
+  const dimensions = [...new Set(rows.map((row) => row.index_dimensions))];
+  if (dimensions.length === 0) return null;
+  if (dimensions.length > 1) {
+    throw new Error(
+      `sqlite-vec index rebuild refused mixed memory embedding dimensions: ${dimensions.join(", ")}.`
+    );
+  }
+  return dimensions[0];
+}
+function ensureMemoryVecIndex(db, dimensions) {
+  ensureSqliteVecLoaded(db);
+  const sqlite = getSqlite(db);
+  const existing = sqlite.prepare("select sql from sqlite_master where type = 'table' and name = ?").get(VEC_MEMORY_INDEX);
+  const expectedDimension = `float[${dimensions}]`;
+  if (existing?.sql && !existing.sql.includes(expectedDimension)) {
+    throw new Error(
+      `sqlite-vec index dimension mismatch. Expected ${expectedDimension}. Run \`recall embeddings rebuild-index\`.`
+    );
+  }
+  sqlite.exec(`
+    create virtual table if not exists ${VEC_MEMORY_INDEX} using vec0(
+      embedding float[${dimensions}] distance_metric=cosine,
+      memory_id text,
+      repo text,
+      status text,
+      type text,
+      scope text
+    );
+  `);
+}
+function dropMemoryVecIndex(db) {
+  ensureSqliteVecLoaded(db);
+  getSqlite(db).exec(`drop table if exists ${VEC_MEMORY_INDEX};`);
+}
+function upsertMemoryVecRow(db, memory, embeddingRow) {
+  ensureMemoryVecIndex(db, embeddingRow.index_dimensions);
+  const sqlite = getSqlite(db);
+  sqlite.prepare(`delete from ${VEC_MEMORY_INDEX} where memory_id = ?`).run(memory.id);
+  sqlite.prepare(`
+    insert into ${VEC_MEMORY_INDEX} (
+      embedding,
+      memory_id,
+      repo,
+      status,
+      type,
+      scope
+    ) values (?, ?, ?, ?, ?, ?)
+  `).run(
+    projectIndexBuffer(embeddingRow.embedding, embeddingRow.index_dimensions),
+    memory.id,
+    memory.repo ?? "",
+    memory.status,
+    memory.type,
+    memory.scope
+  );
+}
+function removeMemoryVecRow(db, memoryId, config) {
+  ensureSqliteVecLoaded(db);
+  if (!hasMemoryVecIndex(db)) return;
+  getSqlite(db).prepare(`delete from ${VEC_MEMORY_INDEX} where memory_id = ?`).run(memoryId);
+}
+function rebuildMemoryVecIndex(db, config, options = {}) {
+  const rows = db.select({
+    id: memories.id,
+    repo: memories.repo,
+    status: memories.status,
+    type: memories.type,
+    scope: memories.scope,
+    index_dimensions: memoryEmbeddings.index_dimensions,
+    embedding: memoryEmbeddings.embedding
+  }).from(memories).innerJoin(memoryEmbeddings, eq(memoryEmbeddings.memory_id, memories.id)).all().filter((row) => !options.repo || row.repo === options.repo);
+  const storedDimension = getMemoryVecDimension(rows);
+  const targetDimension = storedDimension ?? config.dimensions;
+  if (options.repo) {
+    if (rows.length > 0) {
+      ensureMemoryVecIndex(db, targetDimension);
+    }
+    if (!hasMemoryVecIndex(db)) return 0;
+    getSqlite(db).prepare(`delete from ${VEC_MEMORY_INDEX} where repo = ?`).run(options.repo);
+    if (rows.length === 0) return 0;
+  } else {
+    dropMemoryVecIndex(db);
+    ensureMemoryVecIndex(db, targetDimension);
+  }
+  const sqlite = getSqlite(db);
+  const stmt = sqlite.prepare(`
+    insert into ${VEC_MEMORY_INDEX} (
+      embedding,
+      memory_id,
+      repo,
+      status,
+      type,
+      scope
+    ) values (?, ?, ?, ?, ?, ?)
+  `);
+  const insertMany = sqlite.transaction((batch) => {
+    for (const row of batch) {
+      stmt.run(
+        projectIndexBuffer(row.embedding, row.index_dimensions),
+        row.id,
+        row.repo ?? "",
+        row.status,
+        row.type,
+        row.scope
+      );
+    }
+  });
+  insertMany(rows);
+  return rows.length;
+}
+function projectIndexBuffer(buffer, indexDimensions) {
+  const embedding = new Float32Array(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength / Float32Array.BYTES_PER_ELEMENT
+  );
+  if (embedding.length === indexDimensions) {
+    return buffer;
+  }
+  if (embedding.length < indexDimensions) {
+    throw new Error(`Canonical embedding width ${embedding.length} is smaller than index width ${indexDimensions}.`);
+  }
+  const sliced = embedding.slice(0, indexDimensions);
+  let norm = 0;
+  for (const value of sliced) norm += value * value;
+  const scale = Math.sqrt(norm) || 1;
+  for (let i = 0; i < sliced.length; i++) {
+    sliced[i] /= scale;
+  }
+  return Buffer.from(sliced.buffer, sliced.byteOffset, sliced.byteLength);
+}
+function verifyMemoryVecIndex(db, options = {}) {
+  ensureSqliteVecLoaded(db);
+  const sqlite = getSqlite(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_MEMORY_INDEX);
+  const expectedRows = db.select({
+    memory_id: memoryEmbeddings.memory_id,
+    repo: memories.repo
+  }).from(memoryEmbeddings).innerJoin(memories, eq(memories.id, memoryEmbeddings.memory_id)).all().filter((row) => !options.repo || row.repo === options.repo);
+  let indexed = 0;
+  if (exists) {
+    if (options.repo) {
+      const result = sqlite.prepare(`select count(*) as count from ${VEC_MEMORY_INDEX} where repo = ?`).get(options.repo);
+      indexed = result.count;
+    } else {
+      const result = sqlite.prepare(`select count(*) as count from ${VEC_MEMORY_INDEX}`).get();
+      indexed = result.count;
+    }
+  }
+  return {
+    expected: expectedRows.length,
+    indexed,
+    drift: expectedRows.length - indexed
+  };
+}
+function searchMemoryVecIndex(db, queryEmbedding, options = {}) {
+  ensureSqliteVecLoaded(db);
+  const sqlite = getSqlite(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_MEMORY_INDEX);
+  if (!exists) return [];
+  const limit = options.limit ?? 10;
+  if (options.repo) {
+    return sqlite.prepare(`
+      select memory_id, distance
+      from ${VEC_MEMORY_INDEX}
+      where embedding match ?
+        and k = ?
+        and repo = ?
+      order by distance
+    `).all(queryEmbedding, limit, options.repo);
+  }
+  return sqlite.prepare(`
+    select memory_id, distance
+    from ${VEC_MEMORY_INDEX}
+    where embedding match ?
+      and k = ?
+    order by distance
+  `).all(queryEmbedding, limit);
+}
+
+// src/vector/sqlite-fts.ts
+import { eq as eq2 } from "drizzle-orm";
+var FTS_MEMORY_INDEX = "fts_memory_index";
+function getSqlite2(db) {
+  return db.$client;
+}
+function shouldIndexLexically(memory) {
+  return memory.status !== "rejected" && memory.status !== "transient";
+}
+function buildFtsQuery(query) {
+  const tokens = query.match(/[A-Za-z0-9_.:/-]+/g)?.map((token) => token.replace(/"/g, '""')).filter(Boolean) ?? [];
+  if (tokens.length === 0) return null;
+  return tokens.map((token) => `"${token}"`).join(" ");
+}
+function ensureMemoryFtsIndex(db) {
+  const sqlite = getSqlite2(db);
+  sqlite.exec(`
+    create virtual table if not exists ${FTS_MEMORY_INDEX} using fts5(
+      memory_id UNINDEXED,
+      text,
+      repo UNINDEXED,
+      status UNINDEXED,
+      type UNINDEXED,
+      scope UNINDEXED,
+      path_scope UNINDEXED
+    );
+  `);
+}
+function dropMemoryFtsIndex(db) {
+  getSqlite2(db).exec(`drop table if exists ${FTS_MEMORY_INDEX};`);
+}
+function removeMemoryFtsRow(db, memoryId) {
+  const sqlite = getSqlite2(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(FTS_MEMORY_INDEX);
+  if (!exists) return;
+  sqlite.prepare(`delete from ${FTS_MEMORY_INDEX} where memory_id = ?`).run(memoryId);
+}
+function upsertMemoryFtsRow(db, memory) {
+  ensureMemoryFtsIndex(db);
+  if (!shouldIndexLexically(memory)) {
+    removeMemoryFtsRow(db, memory.id);
+    return;
+  }
+  const sqlite = getSqlite2(db);
+  sqlite.prepare(`delete from ${FTS_MEMORY_INDEX} where memory_id = ?`).run(memory.id);
+  sqlite.prepare(`
+    insert into ${FTS_MEMORY_INDEX} (
+      memory_id,
+      text,
+      repo,
+      status,
+      type,
+      scope,
+      path_scope
+    ) values (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    memory.id,
+    memory.text,
+    memory.repo ?? "",
+    memory.status,
+    memory.type,
+    memory.scope,
+    memory.path_scope ?? ""
+  );
+}
+function syncMemoryFtsIndex(db, memoryId) {
+  const memory = db.select().from(memories).where(eq2(memories.id, memoryId)).get();
+  if (!memory) {
+    removeMemoryFtsRow(db, memoryId);
+    return "removed";
+  }
+  upsertMemoryFtsRow(db, memory);
+  return shouldIndexLexically(memory) ? "stored" : "removed";
+}
+function rebuildMemoryFtsIndex(db, options = {}) {
+  if (options.repo) {
+    ensureMemoryFtsIndex(db);
+    getSqlite2(db).prepare(`delete from ${FTS_MEMORY_INDEX} where repo = ?`).run(options.repo);
+  } else {
+    dropMemoryFtsIndex(db);
+    ensureMemoryFtsIndex(db);
+  }
+  const rows = db.select().from(memories).all().filter((row) => !options.repo || row.repo === options.repo).filter((row) => shouldIndexLexically(row));
+  const sqlite = getSqlite2(db);
+  const stmt = sqlite.prepare(`
+    insert into ${FTS_MEMORY_INDEX} (
+      memory_id,
+      text,
+      repo,
+      status,
+      type,
+      scope,
+      path_scope
+    ) values (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertMany = sqlite.transaction((batch) => {
+    for (const row of batch) {
+      stmt.run(
+        row.id,
+        row.text,
+        row.repo ?? "",
+        row.status,
+        row.type,
+        row.scope,
+        row.path_scope ?? ""
+      );
+    }
+  });
+  insertMany(rows);
+  return rows.length;
+}
+function verifyMemoryFtsIndex(db, options = {}) {
+  const sqlite = getSqlite2(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(FTS_MEMORY_INDEX);
+  const expected = db.select().from(memories).all().filter((row) => !options.repo || row.repo === options.repo).filter((row) => shouldIndexLexically(row)).length;
+  let indexed = 0;
+  if (exists) {
+    if (options.repo) {
+      const result = sqlite.prepare(`select count(*) as count from ${FTS_MEMORY_INDEX} where repo = ?`).get(options.repo);
+      indexed = result.count;
+    } else {
+      const result = sqlite.prepare(`select count(*) as count from ${FTS_MEMORY_INDEX}`).get();
+      indexed = result.count;
+    }
+  }
+  return {
+    expected,
+    indexed,
+    drift: expected - indexed
+  };
+}
+function searchMemoryFtsIndex(db, query, options = {}) {
+  ensureMemoryFtsIndex(db);
+  const sqlite = getSqlite2(db);
+  const limit = options.limit ?? 10;
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery) return [];
+  if (options.repo) {
+    return sqlite.prepare(`
+      select memory_id, bm25(${FTS_MEMORY_INDEX}) as lexical_rank
+      from ${FTS_MEMORY_INDEX}
+      where ${FTS_MEMORY_INDEX} match ?
+        and repo = ?
+      order by lexical_rank
+      limit ?
+    `).all(ftsQuery, options.repo, limit);
+  }
+  return sqlite.prepare(`
+    select memory_id, bm25(${FTS_MEMORY_INDEX}) as lexical_rank
+    from ${FTS_MEMORY_INDEX}
+    where ${FTS_MEMORY_INDEX} match ?
+    order by lexical_rank
+    limit ?
+  `).all(ftsQuery, limit);
+}
+
+// src/embeddings/embeddings.ts
+var EMBEDDING_BATCH_SIZE = 100;
+var MIN_HYBRID_VECTOR_SIMILARITY = 0.7;
+var pendingEmbeddingJobs = /* @__PURE__ */ new Set();
+var EMBEDDING_DEFAULTS = {
+  nomic: {
+    model: "nomic-ai/nomic-embed-text-v1.5",
+    dimensions: 512
+  },
+  "multilingual-e5": {
+    model: "Xenova/multilingual-e5-small",
+    dimensions: 384
+  },
+  "bge-small-en-v1.5": {
+    model: "Xenova/bge-small-en-v1.5",
+    dimensions: 384
+  }
+};
+function loadEmbeddingConfigFromEnv() {
+  if (process.env.RECALL_EMBEDDINGS_DISABLED === "true") return null;
+  const provider = process.env.RECALL_EMBEDDING_PROVIDER === "multilingual-e5" ? "multilingual-e5" : "nomic";
+  const defaults = EMBEDDING_DEFAULTS[provider];
+  return {
+    provider,
+    model: process.env.RECALL_EMBEDDING_MODEL ?? defaults.model,
+    dimensions: parseInt(process.env.RECALL_EMBEDDING_DIMS ?? `${defaults.dimensions}`, 10),
+    version: process.env.RECALL_EMBEDDING_VERSION ?? "v1",
+    similarity_threshold: parseFloat(process.env.RECALL_SIMILARITY_THRESHOLD ?? "0.8")
+  };
+}
+function getEmbeddingModelInfo(config = loadEmbeddingConfigFromEnv()) {
+  if (!config) return null;
+  const provider = resolveProvider(config);
+  const metadata = provider.metadata();
+  const cachePath = getEmbeddingCachePath({
+    provider: config.provider,
+    model: metadata.model
+  });
+  const sizeBytes = getDirectorySize(cachePath);
+  return {
+    provider: config.provider,
+    model: metadata.model,
+    dimensions: metadata.dimensions,
+    canonical_dimensions: metadata.canonical_dimensions,
+    index_dimensions: metadata.index_dimensions,
+    version: metadata.version,
+    task_prefix: metadata.task_prefix,
+    estimated_size_mb: metadata.estimated_size_mb,
+    cache_path: cachePath,
+    cached: sizeBytes > 0,
+    size_bytes: sizeBytes,
+    size_label: formatBytes(sizeBytes)
+  };
+}
+async function ensureEmbeddingProviderReady(config = loadEmbeddingConfigFromEnv()) {
+  if (!config) return null;
+  const provider = resolveProvider(config);
+  if (provider.prepare) {
+    await provider.prepare();
+  } else {
+    await provider.embed("recall provider warmup", "document");
+  }
+  return getEmbeddingModelInfo(config);
+}
+function getEmbeddingVersion(config) {
+  return config.version || `${config.provider}:${config.model}:${config.dimensions}`;
+}
+function hashMemoryText(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function shouldEmbedMemory(row) {
+  if (row.status === "transient") return false;
+  if (row.status === "rejected") {
+    return row.source === "user_correction" || row.source === "user_reported_review";
+  }
+  return row.confidence >= CONFIDENCE.TRANSIENT_MAX;
+}
+function serializeEmbedding(embedding) {
+  return Buffer.from(
+    embedding.buffer,
+    embedding.byteOffset,
+    embedding.byteLength
+  );
+}
+function deserializeEmbedding(buffer) {
+  return new Float32Array(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength / Float32Array.BYTES_PER_ELEMENT
+  );
+}
+function rowNeedsEmbeddingRefresh(row, existing, config) {
+  const metadata = resolveProvider(config).metadata();
+  if (!existing) return true;
+  return existing.model !== config.model || existing.embedding_dimensions !== metadata.canonical_dimensions || existing.index_dimensions !== metadata.index_dimensions || existing.version !== getEmbeddingVersion(config) || existing.content_hash !== hashMemoryText(row.text);
+}
+function projectEmbeddingToIndex(embedding, indexDimensions) {
+  if (embedding.length === indexDimensions) {
+    return embedding;
+  }
+  if (embedding.length < indexDimensions) {
+    throw new Error(`Embedding width ${embedding.length} is smaller than index width ${indexDimensions}.`);
+  }
+  const sliced = embedding.slice(0, indexDimensions);
+  let norm = 0;
+  for (const value of sliced) norm += value * value;
+  const scale = Math.sqrt(norm) || 1;
+  for (let i = 0; i < sliced.length; i++) {
+    sliced[i] /= scale;
+  }
+  return sliced;
+}
+async function generateEmbedding(text, config, purpose = "document") {
+  return resolveProvider(config).embed(text, purpose);
+}
+async function generateEmbeddings(texts, config, purpose = "document") {
+  if (texts.length === 0) return [];
+  return resolveProvider(config).embedBatch(texts, purpose);
+}
+function storeEmbedding(db, memoryId, text, embedding, config) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = resolveProvider(config).metadata();
+  const payload = {
+    memory_id: memoryId,
+    model: config.model,
+    embedding_dimensions: metadata.canonical_dimensions,
+    index_dimensions: metadata.index_dimensions,
+    version: getEmbeddingVersion(config),
+    content_hash: hashMemoryText(text),
+    updated_at: now,
+    embedding: serializeEmbedding(embedding)
+  };
+  db.insert(memoryEmbeddings).values(payload).onConflictDoUpdate({
+    target: memoryEmbeddings.memory_id,
+    set: {
+      model: payload.model,
+      embedding_dimensions: payload.embedding_dimensions,
+      index_dimensions: payload.index_dimensions,
+      version: payload.version,
+      content_hash: payload.content_hash,
+      updated_at: payload.updated_at,
+      embedding: payload.embedding
+    }
+  }).run();
+}
+function removeStoredEmbedding(db, memoryId) {
+  const result = db.delete(memoryEmbeddings).where(eq3(memoryEmbeddings.memory_id, memoryId)).run();
+  return result.changes > 0;
+}
+async function syncMemoryEmbedding(db, memoryId, config) {
+  const memory = db.select().from(memories).where(eq3(memories.id, memoryId)).get();
+  if (!memory || !shouldEmbedMemory(memory)) {
+    removeStoredEmbedding(db, memoryId);
+    removeMemoryVecRow(db, memoryId, config);
+    return "removed";
+  }
+  const existing = db.select().from(memoryEmbeddings).where(eq3(memoryEmbeddings.memory_id, memoryId)).get();
+  if (!rowNeedsEmbeddingRefresh(memory, existing, config)) {
+    if (existing) {
+      upsertMemoryVecRow(db, memory, existing);
+    }
+    return "skipped";
+  }
+  const embedding = await generateEmbedding(memory.text, config, "document");
+  const stillExists = db.select({ id: memories.id }).from(memories).where(eq3(memories.id, memoryId)).get();
+  if (!stillExists) {
+    removeStoredEmbedding(db, memoryId);
+    removeMemoryVecRow(db, memoryId, config);
+    return "removed";
+  }
+  storeEmbedding(db, memory.id, memory.text, embedding, config);
+  const refreshed = db.select().from(memoryEmbeddings).where(eq3(memoryEmbeddings.memory_id, memory.id)).get();
+  if (!refreshed) {
+    throw new Error(`Failed to reload embedding row for ${memory.id}`);
+  }
+  upsertMemoryVecRow(db, memory, refreshed);
+  return existing ? "updated" : "stored";
+}
+function queueMemoryEmbeddingSync(db, memoryId, config = loadEmbeddingConfigFromEnv()) {
+  syncMemoryFtsIndex(db, memoryId);
+  if (!config) return null;
+  const job = syncMemoryEmbedding(db, memoryId, config).then(() => void 0).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[recall] embedding sync failed for ${memoryId.slice(0, 8)}: ${message}`);
+  }).finally(() => {
+    pendingEmbeddingJobs.delete(job);
+  });
+  pendingEmbeddingJobs.add(job);
+  return job;
+}
+async function bootstrapEmbeddings(db, config, options = {}) {
+  const rows = db.select().from(memories).all();
+  const existingRows = db.select().from(memoryEmbeddings).all();
+  const existingById = new Map(existingRows.map((row) => [row.memory_id, row]));
+  const eligible = rows.filter((row) => {
+    if (options.repo && row.repo !== options.repo) return false;
+    return shouldEmbedMemory(row);
+  });
+  const pending = eligible.filter((row) => rowNeedsEmbeddingRefresh(row, existingById.get(row.id), config));
+  for (const row of rows) {
+    if (options.repo && row.repo !== options.repo) continue;
+    if (!shouldEmbedMemory(row)) {
+      removeStoredEmbedding(db, row.id);
+      removeMemoryVecRow(db, row.id, config);
+    }
+  }
+  let total = 0;
+  for (let i = 0; i < pending.length; i += EMBEDDING_BATCH_SIZE) {
+    const batch = pending.slice(i, i + EMBEDDING_BATCH_SIZE);
+    const embeddings = await generateEmbeddings(
+      batch.map((row) => row.text),
+      config,
+      "document"
+    );
+    for (let j = 0; j < batch.length; j++) {
+      storeEmbedding(db, batch[j].id, batch[j].text, embeddings[j], config);
+      total++;
+    }
+  }
+  rebuildMemoryFtsIndex(db, options);
+  rebuildMemoryVecIndex(db, config, options);
+  return total;
+}
+function verifyEmbeddings(db, config, options = {}) {
+  const rows = db.select().from(memories).all();
+  const embeddingRows = db.select().from(memoryEmbeddings).all();
+  const embeddingById = new Map(embeddingRows.map((row) => [row.memory_id, row]));
+  let eligible = 0;
+  let stale = 0;
+  for (const row of rows) {
+    if (options.repo && row.repo !== options.repo) continue;
+    if (!shouldEmbedMemory(row)) continue;
+    eligible++;
+    if (rowNeedsEmbeddingRefresh(row, embeddingById.get(row.id), config)) {
+      stale++;
+    }
+  }
+  const vec = verifyMemoryVecIndex(db, options);
+  const fts = verifyMemoryFtsIndex(db, options);
+  return {
+    eligible,
+    stored: embeddingRows.filter((row) => {
+      if (!options.repo) return true;
+      const memory = rows.find((item) => item.id === row.memory_id);
+      return memory?.repo === options.repo;
+    }).length,
+    stale,
+    indexed: vec.indexed,
+    index_drift: vec.drift,
+    lexical_indexed: fts.indexed,
+    lexical_drift: fts.drift
+  };
+}
+function rebuildEmbeddingIndex(db, config, options = {}) {
+  const lexicalRows = rebuildMemoryFtsIndex(db, options);
+  const vectorRows = config ? rebuildMemoryVecIndex(db, config, options) : 0;
+  return {
+    vector_rows: vectorRows,
+    lexical_rows: lexicalRows
+  };
+}
+function lexicalRankToScore(rank, position) {
+  const safeRank = Number.isFinite(rank) ? Math.abs(rank) : position + 1;
+  return 1 / (1 + safeRank + position);
+}
+async function hybridSearch(db, query, config, options = {}) {
+  const limit = options.limit ?? 10;
+  const minSimilarity = config ? Math.max(config.similarity_threshold, MIN_HYBRID_VECTOR_SIMILARITY) : null;
+  const lexicalMatches = searchMemoryFtsIndex(db, query, {
+    repo: options.repo,
+    limit: Math.max(limit * 2, 20)
+  });
+  const semanticMatches = config ? searchMemoryVecIndex(
+    db,
+    projectEmbeddingToIndex(
+      await generateEmbedding(query, config, "query"),
+      resolveProvider(config).metadata().index_dimensions
+    ),
+    { repo: options.repo, limit: Math.max(limit * 2, 20) }
+  ) : [];
+  const rowsById = new Map(
+    db.select().from(memories).all().map((row) => [row.id, row])
+  );
+  const merged = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lexicalMatches.length; i++) {
+    const match = lexicalMatches[i];
+    const row = rowsById.get(match.memory_id);
+    if (!row || !shouldEmbedMemory(row)) continue;
+    const lexicalScore = lexicalRankToScore(match.lexical_rank, i);
+    merged.set(match.memory_id, {
+      memory: rowToMemory(row),
+      similarity: 0,
+      lexical_score: lexicalScore,
+      score: lexicalScore * 0.35
+    });
+  }
+  for (const match of semanticMatches) {
+    const row = rowsById.get(match.memory_id);
+    if (!row || !shouldEmbedMemory(row)) continue;
+    const similarity = Math.max(0, 1 - match.distance);
+    if (minSimilarity !== null && similarity < minSimilarity) continue;
+    const existing = merged.get(match.memory_id);
+    if (existing) {
+      existing.similarity = similarity;
+      existing.score = similarity * 0.65 + existing.lexical_score * 0.35;
+    } else {
+      merged.set(match.memory_id, {
+        memory: rowToMemory(row),
+        similarity,
+        lexical_score: 0,
+        score: similarity * 0.65
+      });
+    }
+  }
+  return [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function findSemanticDuplicates(db, text, config, threshold, options = {}) {
+  const queryEmbedding = await generateEmbedding(text, config, "query");
+  const dupThreshold = threshold ?? config.similarity_threshold;
+  const rows = db.select().from(memories).all();
+  const embeddingsById = new Map(
+    db.select().from(memoryEmbeddings).all().map((row) => [row.memory_id, row])
+  );
+  const duplicates = [];
+  for (const row of rows) {
+    if (options.repo && row.repo !== options.repo) continue;
+    if (options.type && row.type !== options.type) continue;
+    if (row.status === "rejected") continue;
+    if (!shouldEmbedMemory(row)) continue;
+    const embeddingRow = embeddingsById.get(row.id);
+    if (!embeddingRow?.embedding) continue;
+    const similarity = cosineSimilarity(
+      queryEmbedding,
+      deserializeEmbedding(embeddingRow.embedding)
+    );
+    if (similarity >= dupThreshold) {
+      duplicates.push({ id: row.id, text: row.text, similarity });
+    }
+  }
+  return duplicates.sort((a, b) => b.similarity - a.similarity).slice(0, options.limit ?? 10);
+}
+async function findSimilarRejectedExemplar(db, text, config, threshold) {
+  const queryEmbedding = await generateEmbedding(text, config, "query");
+  const rejectedRows = db.select().from(memories).where(eq3(memories.status, "rejected")).all().filter((row) => row.source === "user_correction" || row.source === "user_reported_review");
+  if (rejectedRows.length === 0) return null;
+  const embeddingsById = new Map(
+    db.select().from(memoryEmbeddings).all().map((row) => [row.memory_id, row])
+  );
+  let best = null;
+  for (const row of rejectedRows) {
+    const embeddingRow = embeddingsById.get(row.id);
+    if (!embeddingRow?.embedding) continue;
+    const similarity = cosineSimilarity(
+      queryEmbedding,
+      deserializeEmbedding(embeddingRow.embedding)
+    );
+    if (similarity >= threshold && (!best || similarity > best.similarity)) {
+      best = { id: row.id, text: row.text, similarity };
+    }
+  }
+  return best;
+}
+function rowToMemory(row) {
+  const evidence = typeof row.evidence === "string" ? JSON.parse(row.evidence) : Array.isArray(row.evidence) ? row.evidence : [];
+  const captureContext = typeof row.capture_context === "string" ? JSON.parse(row.capture_context) : row.capture_context ?? null;
+  return {
+    id: row.id,
+    type: row.type,
+    text: row.text,
+    scope: row.scope,
+    path_scope: row.path_scope,
+    repo: row.repo,
+    status: row.status,
+    confidence: row.confidence,
+    source: row.source,
+    evidence,
+    capture_context: captureContext,
+    supersedes: row.supersedes,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    last_validated_at: row.last_validated_at,
+    last_injected_at: row.last_injected_at,
+    injection_count: row.injection_count,
+    override_count: row.override_count,
+    repetition_count: row.repetition_count,
+    auto_inject: row.auto_inject
+  };
+}
+
+// src/maintenance/appliers.ts
+import { eq as eq6 } from "drizzle-orm";
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/models/memory.ts
+import { eq as eq4, and, gte, inArray, like, sql } from "drizzle-orm";
+import { randomUUID } from "crypto";
+
+// src/models/dedupe.ts
+function normalizeDedupeText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").replace(/[\s.;:,!?`]+$/g, "").trim();
+}
+function memoryDedupeKey(input) {
+  return [
+    "memory",
+    input.type,
+    input.scope,
+    input.repo ?? "",
+    input.path_scope ?? "",
+    normalizeDedupeText(input.text)
+  ].join("");
+}
+function historySnippetDedupeKey(input) {
+  return [
+    "history",
+    input.repo ?? "",
+    input.session_id ?? "",
+    input.kind,
+    normalizeDedupeText(input.text)
+  ].join("");
+}
+function activityEventDedupeKey(input) {
+  if (!input.session_id) return null;
+  return [
+    "activity",
+    input.session_id,
+    input.repo ?? "",
+    input.path ?? "",
+    input.source,
+    input.event_type,
+    stableDedupeJson(stripVolatileFields(input.request ?? {})),
+    stableDedupeJson(stripVolatileFields(input.result ?? {}))
+  ].join("");
+}
+function hookCallDedupeKey(input) {
+  if (!input.session_id) return null;
+  return [
+    "hook",
+    input.session_id,
+    input.agent,
+    input.event,
+    input.ok ? "ok" : "error",
+    stableDedupeJson(stripVolatileFields(input.payload ?? {}))
+  ].join("");
+}
+function stripVolatileFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(stripVolatileFields);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (/_at$/u.test(key) || key === "timestamp") continue;
+    if (entry === void 0) continue;
+    out[key] = stripVolatileFields(entry);
+  }
+  return out;
+}
+function stableDedupeJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableDedupeJson).join(",")}]`;
+  }
+  if (!value || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableDedupeJson(record[key])}`).join(",")}}`;
+}
+
+// src/models/memory.ts
+function statusFromConfidence(confidence) {
+  if (confidence < CONFIDENCE.TRANSIENT_MAX) return "transient";
+  if (confidence < CONFIDENCE.CANDIDATE_MAX) return "candidate";
+  return "active";
+}
+function createMemory(db, input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = randomUUID();
+  const confidence = input.confidence ?? 0.35;
+  const status = statusFromConfidence(confidence);
+  const dedupeKey = input.dedupe === false ? null : memoryDedupeKey({
+    type: input.type,
+    scope: input.scope,
+    repo: input.repo ?? null,
+    path_scope: input.path_scope ?? null,
+    text: input.text
+  });
+  if (dedupeKey) {
+    const existing = db.select().from(memories).where(and(eq4(memories.dedupe_key, dedupeKey), sql`${memories.status} != 'rejected'`)).get();
+    if (existing) return existing.id;
+  }
+  db.insert(memories).values({
+    id,
+    type: input.type,
+    text: input.text,
+    scope: input.scope,
+    path_scope: input.path_scope ?? null,
+    repo: input.repo ?? null,
+    status,
+    confidence,
+    source: input.source,
+    evidence: input.evidence ?? [],
+    capture_context: input.capture_context ? input.capture_context : null,
+    supersedes: input.supersedes ?? null,
+    dedupe_key: dedupeKey,
+    created_at: now,
+    updated_at: now,
+    last_validated_at: null,
+    last_injected_at: null,
+    injection_count: 0,
+    override_count: 0,
+    repetition_count: 0
+  }).run();
+  queueMemoryEmbeddingSync(db, id);
+  return id;
+}
+function getMemory(db, id) {
+  const row = db.select().from(memories).where(eq4(memories.id, id)).get();
+  if (!row) return void 0;
+  return rowToMemory2(row);
+}
+function queryMemories(db, query) {
+  const conditions = [];
+  if (query.repo) conditions.push(eq4(memories.repo, query.repo));
+  if (query.status) conditions.push(eq4(memories.status, query.status));
+  if (query.type) conditions.push(eq4(memories.type, query.type));
+  if (query.scope) conditions.push(eq4(memories.scope, query.scope));
+  if (query.min_confidence != null)
+    conditions.push(gte(memories.confidence, query.min_confidence));
+  if (query.path) conditions.push(like(memories.path_scope, `%${query.path}%`));
+  if (query.auto_inject != null) conditions.push(eq4(memories.auto_inject, query.auto_inject));
+  let statement = db.select().from(memories).$dynamic();
+  if (conditions.length > 0) {
+    statement = statement.where(and(...conditions));
+  }
+  if (query.offset != null) {
+    statement = statement.offset(query.offset);
+  }
+  if (query.limit != null) {
+    statement = statement.limit(query.limit);
+  }
+  const rows = statement.all();
+  return rows.map(rowToMemory2);
+}
+function listMemories(db, repo, options = {}) {
+  return queryMemories(db, {
+    repo,
+    limit: options.limit,
+    offset: options.offset
+  });
+}
+function listRepos(db) {
+  return [...new Set(
+    db.select({ repo: memories.repo }).from(memories).all().map((row) => row.repo).filter((repo) => Boolean(repo))
+  )].sort();
+}
+function promoteMemory(db, id, reason, evidence) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  if (mem.status === "rejected") return false;
+  let newConfidence;
+  if (reason === "explicit_confirm") {
+    newConfidence = Math.max(mem.confidence, PROMOTION.EXPLICIT_CONFIRM);
+  } else if (reason === "repeat_correction") {
+    newConfidence = Math.min(1, mem.confidence + PROMOTION.REPEAT_CORRECTION);
+  } else if (reason === "review_feedback") {
+    newConfidence = Math.min(1, mem.confidence + PROMOTION.REVIEW_FEEDBACK);
+  } else {
+    newConfidence = Math.min(1, mem.confidence + PROMOTION.PASSIVE_GAIN);
+  }
+  const newStatus = statusFromConfidence(newConfidence);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newEvidence = evidence ? [...mem.evidence, evidence] : mem.evidence;
+  db.update(memories).set({
+    confidence: newConfidence,
+    status: newStatus,
+    evidence: newEvidence,
+    updated_at: now,
+    last_validated_at: now
+  }).where(eq4(memories.id, id)).run();
+  queueMemoryEmbeddingSync(db, id);
+  return true;
+}
+function demoteMemory(db, id, reason) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  const newConfidence = Math.max(0, mem.confidence - 0.3);
+  const newStatus = statusFromConfidence(newConfidence);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({
+    confidence: newConfidence,
+    status: newStatus === "transient" ? "candidate" : newStatus,
+    // don't lose it completely
+    updated_at: now
+  }).where(eq4(memories.id, id)).run();
+  queueMemoryEmbeddingSync(db, id);
+  return true;
+}
+function demoteGlobalMemory(db, id, opts = {}) {
+  const mem = getMemory(db, id);
+  if (!mem) return { ok: false, reason: "not_found" };
+  if (mem.scope !== "global") return { ok: false, reason: "not_global" };
+  const targetRepo = opts.repo?.trim() || null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (targetRepo) {
+    const newDedupe = memoryDedupeKey({
+      type: mem.type,
+      scope: "repo",
+      repo: targetRepo,
+      path_scope: mem.path_scope,
+      text: mem.text
+    });
+    db.update(memories).set({
+      scope: "repo",
+      repo: targetRepo,
+      dedupe_key: newDedupe,
+      updated_at: now
+    }).where(eq4(memories.id, id)).run();
+  } else {
+    db.update(memories).set({
+      status: "rejected",
+      confidence: 0,
+      dedupe_key: null,
+      updated_at: now
+    }).where(eq4(memories.id, id)).run();
+  }
+  queueMemoryEmbeddingSync(db, id);
+  const updated = getMemory(db, id);
+  return { ok: true, outcome: targetRepo ? "rescoped" : "rejected", memory: updated };
+}
+function rejectMemory(db, id) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  db.update(memories).set({
+    status: "rejected",
+    confidence: 0,
+    dedupe_key: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq4(memories.id, id)).run();
+  queueMemoryEmbeddingSync(db, id);
+  return true;
+}
+function confirmMemory(db, id) {
+  return promoteMemory(db, id, "explicit_confirm", {
+    type: "session_correction",
+    session: "cli",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    context: "user explicitly confirmed"
+  });
+}
+function appendEvidence(db, id, evidence) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  if (hasEquivalentEvidence(mem.evidence, evidence)) return true;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({
+    evidence: [...mem.evidence, evidence],
+    updated_at: now,
+    last_validated_at: now
+  }).where(eq4(memories.id, id)).run();
+  return true;
+}
+function updateMemoryCaptureContext(db, id, captureContext) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  db.update(memories).set({
+    capture_context: captureContext,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq4(memories.id, id)).run();
+  return true;
+}
+function incrementMemoryRepetition(db, id) {
+  const mem = getMemory(db, id);
+  if (!mem) return false;
+  db.update(memories).set({
+    repetition_count: sql`repetition_count + 1`,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq4(memories.id, id)).run();
+  return true;
+}
+function countDistinctCorrectionSessions(mem) {
+  const sessions = /* @__PURE__ */ new Set();
+  for (const entry of mem.evidence) {
+    if (entry.type === "session_correction") {
+      sessions.add(entry.session);
+    } else if (entry.type === "repeated_correction") {
+      for (const session of entry.sessions) {
+        sessions.add(session);
+      }
+    }
+  }
+  return sessions.size;
+}
+function recordFeedback(db, memoryId, sessionId, injected, outcome) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(feedbackEvents).values({
+    id,
+    memory_id: memoryId,
+    session_id: sessionId,
+    injected,
+    outcome,
+    timestamp: now
+  }).run();
+  const mem = getMemory(db, memoryId);
+  if (!mem) return id;
+  const delta = outcome === "followed" ? 0.05 : outcome === "overridden" ? -0.15 : outcome === "ignored" ? -0.02 : -0.25;
+  const nextConfidence = Math.max(0, Math.min(1, mem.confidence + delta));
+  const nextStatus = statusFromConfidence(nextConfidence);
+  if (injected) {
+    db.update(memories).set({
+      confidence: nextConfidence,
+      status: nextStatus === "transient" ? "candidate" : nextStatus,
+      updated_at: now,
+      last_injected_at: now,
+      injection_count: sql`injection_count + 1`,
+      ...outcome === "overridden" || outcome === "contradicted" ? { override_count: sql`override_count + 1` } : {}
+    }).where(eq4(memories.id, memoryId)).run();
+  } else {
+    db.update(memories).set({
+      confidence: nextConfidence,
+      status: nextStatus === "transient" ? "candidate" : nextStatus,
+      updated_at: now
+    }).where(eq4(memories.id, memoryId)).run();
+  }
+  return id;
+}
+function getMemoryFeedback(db, memoryId) {
+  return db.select().from(feedbackEvents).where(eq4(feedbackEvents.memory_id, memoryId)).all();
+}
+function getMemoryFeedbackSummaries(db, memoryIds) {
+  const empty = () => ({
+    followed: 0,
+    overridden: 0,
+    contradicted: 0,
+    ignored: 0,
+    resolved: 0
+  });
+  const result = /* @__PURE__ */ new Map();
+  if (memoryIds.length === 0) return result;
+  for (const id of memoryIds) result.set(id, empty());
+  const rows = db.select({
+    memory_id: feedbackEvents.memory_id,
+    outcome: feedbackEvents.outcome,
+    count: sql`count(*)`.as("count")
+  }).from(feedbackEvents).where(inArray(feedbackEvents.memory_id, [...memoryIds])).groupBy(feedbackEvents.memory_id, feedbackEvents.outcome).all();
+  for (const row of rows) {
+    const entry = result.get(row.memory_id) ?? empty();
+    if (row.outcome === "followed") entry.followed += row.count;
+    else if (row.outcome === "overridden") entry.overridden += row.count;
+    else if (row.outcome === "contradicted") entry.contradicted += row.count;
+    else if (row.outcome === "ignored") entry.ignored += row.count;
+    if (row.outcome !== "ignored") entry.resolved += row.count;
+    result.set(row.memory_id, entry);
+  }
+  return result;
+}
+var FEEDBACK_MATURITY = 5;
+function feedbackWeightedScore(confidence, summary) {
+  const total = summary.resolved;
+  const maturity = Math.min(total, FEEDBACK_MATURITY) / FEEDBACK_MATURITY;
+  if (maturity === 0) return confidence;
+  const positive = summary.followed;
+  const negative = summary.overridden + 2 * summary.contradicted;
+  const numerator = Math.max(0, positive - negative + 1);
+  const denominator = Math.max(1, total + 2);
+  const empirical = Math.min(1, numerator / denominator);
+  return (1 - maturity) * confidence + maturity * empirical;
+}
+function rowToMemory2(row) {
+  const evidence = typeof row.evidence === "string" ? JSON.parse(row.evidence) : Array.isArray(row.evidence) ? row.evidence : [];
+  const captureContext = typeof row.capture_context === "string" ? JSON.parse(row.capture_context) : row.capture_context ?? null;
+  return {
+    id: row.id,
+    type: row.type,
+    text: row.text,
+    scope: row.scope,
+    path_scope: row.path_scope,
+    repo: row.repo,
+    status: row.status,
+    confidence: row.confidence,
+    source: row.source,
+    evidence,
+    capture_context: captureContext,
+    supersedes: row.supersedes,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    last_validated_at: row.last_validated_at,
+    last_injected_at: row.last_injected_at,
+    injection_count: row.injection_count,
+    override_count: row.override_count,
+    repetition_count: row.repetition_count,
+    auto_inject: row.auto_inject
+  };
+}
+function hasEquivalentEvidence(existing, next) {
+  return existing.some((entry) => {
+    if (entry.type !== next.type) return false;
+    if (entry.type === "session_correction" && next.type === "session_correction") {
+      return entry.session === next.session;
+    }
+    if (entry.type === "review_feedback" && next.type === "review_feedback") {
+      return entry.reviewer === next.reviewer && entry.context === next.context;
+    }
+    if (entry.type === "repo_scan" && next.type === "repo_scan") {
+      return entry.file === next.file;
+    }
+    if (entry.type === "repeated_correction" && next.type === "repeated_correction") {
+      return entry.sessions.join("|") === next.sessions.join("|");
+    }
+    return false;
+  });
+}
+
+// src/audit/trail.ts
+import { eq as eq5, desc } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+function recordAudit(db, memoryId, action, actor, reason, beforeSnapshot, afterSnapshot) {
+  const id = randomUUID2();
+  if (afterSnapshot === void 0) {
+    const mem = getMemory(db, memoryId);
+    if (mem) {
+      afterSnapshot = JSON.stringify(mem);
+    }
+  }
+  db.insert(auditTrail).values({
+    id,
+    memory_id: memoryId,
+    action,
+    actor,
+    before_snapshot: beforeSnapshot ?? null,
+    after_snapshot: afterSnapshot ?? null,
+    reason: reason ?? null,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+  return id;
+}
+function recordAuditWithSnapshot(db, memoryId, action, actor, reason, before, after) {
+  return recordAudit(
+    db,
+    memoryId,
+    action,
+    actor,
+    reason,
+    before ? JSON.stringify(before) : null,
+    after ? JSON.stringify(after) : null
+  );
+}
+function getAuditTrail(db, memoryId) {
+  return db.select().from(auditTrail).where(eq5(auditTrail.memory_id, memoryId)).orderBy(desc(auditTrail.timestamp)).all().map(rowToAudit);
+}
+function getRecentAudit(db, limit = 50) {
+  return db.select().from(auditTrail).orderBy(desc(auditTrail.timestamp)).limit(limit).all().map(rowToAudit);
+}
+function diffSnapshots(before, after) {
+  if (!before || !after) return [];
+  const a = JSON.parse(before);
+  const b = JSON.parse(after);
+  const diffs = [];
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) {
+    if (key === "evidence" || key === "embedding") continue;
+    const va = JSON.stringify(a[key]);
+    const vb = JSON.stringify(b[key]);
+    if (va !== vb) {
+      diffs.push({ field: key, before: a[key], after: b[key] });
+    }
+  }
+  return diffs;
+}
+function rollbackMemory(db, memoryId, auditEntryId, actor) {
+  const entry = db.select().from(auditTrail).where(eq5(auditTrail.id, auditEntryId)).get();
+  if (!entry) return false;
+  const snapshot = entry.before_snapshot;
+  if (!snapshot) return false;
+  const beforeRollback = getMemory(db, memoryId);
+  const restored = JSON.parse(snapshot);
+  db.update(memories).set({
+    text: restored.text,
+    type: restored.type,
+    scope: restored.scope,
+    path_scope: restored.path_scope,
+    status: restored.status,
+    confidence: restored.confidence,
+    source: restored.source,
+    evidence: restored.evidence,
+    capture_context: restored.capture_context,
+    repetition_count: restored.repetition_count,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq5(memories.id, memoryId)).run();
+  queueMemoryEmbeddingSync(db, memoryId);
+  recordAuditWithSnapshot(
+    db,
+    memoryId,
+    "rolled_back",
+    actor,
+    `Rolled back to state from ${entry.timestamp}`,
+    beforeRollback ?? null,
+    getMemory(db, memoryId) ?? null
+  );
+  return true;
+}
+function formatAuditTrail(entries) {
+  if (entries.length === 0) return "No audit entries.";
+  const lines = ["# Audit Trail", ""];
+  for (const e of entries) {
+    const diffs = diffSnapshots(e.before_snapshot, e.after_snapshot);
+    const diffStr = diffs.length > 0 ? ` [${diffs.map((d) => `${d.field}: ${JSON.stringify(d.before)} \u2192 ${JSON.stringify(d.after)}`).join(", ")}]` : "";
+    lines.push(
+      `${e.timestamp.slice(0, 19)}  ${e.action.padEnd(22)} by ${e.actor}${e.reason ? ` \u2014 ${e.reason}` : ""}${diffStr}`
+    );
+  }
+  return lines.join("\n");
+}
+function rowToAudit(row) {
+  return {
+    id: row.id,
+    memory_id: row.memory_id,
+    action: row.action,
+    actor: row.actor,
+    before_snapshot: row.before_snapshot,
+    after_snapshot: row.after_snapshot,
+    reason: row.reason,
+    timestamp: row.timestamp
+  };
+}
+
+// src/maintenance/appliers.ts
+var ApplyError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ApplyError";
+  }
+  code;
+};
+function applyRefineCandidate(db, task, result) {
+  const memoryId = task.payload.memory_id;
+  if (!memoryId) throw new ApplyError("payload missing memory_id", "invalid-state");
+  const before = getMemory(db, memoryId);
+  if (!before) throw new ApplyError(`memory ${memoryId} not found`, "target-missing");
+  const actor = `maintenance:${task.claimed_by ?? "unknown"}`;
+  if (result.verdict === "reject") {
+    return rejectMemoryFromTask(db, task, memoryId, before, actor, result.rationale);
+  }
+  const changed = [];
+  if (before.text !== result.refined_text) changed.push("text");
+  if (before.scope !== result.scope) changed.push("scope");
+  const newPathScope = result.path_scope ?? null;
+  if (before.path_scope !== newPathScope) changed.push("path_scope");
+  if (changed.length === 0) {
+    return { audit_entry_id: null, target_id: memoryId, changed_fields: [] };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({
+    text: result.refined_text,
+    scope: result.scope,
+    path_scope: newPathScope,
+    updated_at: now,
+    last_validated_at: now
+  }).where(eq6(memories.id, memoryId)).run();
+  queueMemoryEmbeddingSync(db, memoryId);
+  const after = getMemory(db, memoryId);
+  const reason = result.rationale ? `refined:${task.id}:${result.rationale.slice(0, 200)}` : `refined:${task.id}`;
+  const auditId = recordAuditWithSnapshot(
+    db,
+    memoryId,
+    "edited",
+    actor,
+    reason,
+    before,
+    after ?? null
+  );
+  return { audit_entry_id: auditId, target_id: memoryId, changed_fields: changed };
+}
+function applyVerifyCapture(db, task, result) {
+  const memoryId = task.payload.memory_id;
+  if (!memoryId) throw new ApplyError("payload missing memory_id", "invalid-state");
+  const before = getMemory(db, memoryId);
+  if (!before) throw new ApplyError(`memory ${memoryId} not found`, "target-missing");
+  const actor = `maintenance:${task.claimed_by ?? "unknown"}`;
+  if (result.verdict === "reject") {
+    return rejectMemoryFromTask(db, task, memoryId, before, actor, result.reason);
+  }
+  if (result.verdict === "save") {
+    return { audit_entry_id: null, target_id: memoryId, changed_fields: [] };
+  }
+  const newText = result.cleaned_text ?? before.text;
+  const newScope = result.scope ?? before.scope;
+  const newPathScope = result.path_scope ?? before.path_scope;
+  const changed = [];
+  if (before.text !== newText) changed.push("text");
+  if (before.scope !== newScope) changed.push("scope");
+  if (before.path_scope !== newPathScope) changed.push("path_scope");
+  if (changed.length === 0) {
+    return { audit_entry_id: null, target_id: memoryId, changed_fields: [] };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({
+    text: newText,
+    scope: newScope,
+    path_scope: newPathScope,
+    updated_at: now,
+    last_validated_at: now
+  }).where(eq6(memories.id, memoryId)).run();
+  queueMemoryEmbeddingSync(db, memoryId);
+  const after = getMemory(db, memoryId);
+  const reason = result.reason ? `verify:rewrite:${task.id}:${result.reason.slice(0, 200)}` : `verify:rewrite:${task.id}`;
+  const auditId = recordAuditWithSnapshot(
+    db,
+    memoryId,
+    "edited",
+    actor,
+    reason,
+    before,
+    after ?? null
+  );
+  return { audit_entry_id: auditId, target_id: memoryId, changed_fields: changed };
+}
+function rejectMemoryFromTask(db, task, memoryId, before, actor, reasonText) {
+  if (before.status === "rejected") {
+    return { audit_entry_id: null, target_id: memoryId, changed_fields: [] };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memories).set({ status: "rejected", confidence: 0, dedupe_key: null, updated_at: now }).where(eq6(memories.id, memoryId)).run();
+  queueMemoryEmbeddingSync(db, memoryId);
+  const after = getMemory(db, memoryId);
+  const reason = reasonText ? `${task.kind}:reject:${task.id}:${reasonText.slice(0, 200)}` : `${task.kind}:reject:${task.id}`;
+  const auditId = recordAuditWithSnapshot(
+    db,
+    memoryId,
+    "rejected",
+    actor,
+    reason,
+    before,
+    after ?? null
+  );
+  return { audit_entry_id: auditId, target_id: memoryId, changed_fields: ["status"] };
+}
+function applySummarizeHistory(db, task, result) {
+  const snippetId = task.payload.snippet_id;
+  if (!snippetId) throw new ApplyError("payload missing snippet_id", "invalid-state");
+  const existing = db.select().from(historySnippets).where(eq6(historySnippets.id, snippetId)).get();
+  if (!existing) throw new ApplyError(`history snippet ${snippetId} not found`, "target-missing");
+  const changed = [];
+  if (existing.text !== result.summary_text) changed.push("text");
+  if (changed.length === 0) {
+    return { audit_entry_id: null, target_id: snippetId, changed_fields: [] };
+  }
+  db.update(historySnippets).set({
+    text: result.summary_text,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq6(historySnippets.id, snippetId)).run();
+  return { audit_entry_id: null, target_id: snippetId, changed_fields: changed };
+}
+function applyMergeDuplicates(db, task, result) {
+  const payload = task.payload;
+  const candidates = payload.candidates ?? [];
+  if (candidates.length < 2) {
+    throw new ApplyError("merge_duplicates payload needs \u22652 candidates", "invalid-state");
+  }
+  const winnerId = result.winner_id;
+  if (!candidates.some((c) => c.id === winnerId)) {
+    throw new ApplyError(`winner_id ${winnerId} not in candidates`, "invalid-state");
+  }
+  const winner = getMemory(db, winnerId);
+  if (!winner) throw new ApplyError(`winner ${winnerId} not found`, "target-missing");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const changed = [];
+  const actor = `maintenance:${task.claimed_by ?? "unknown"}`;
+  const nextText = result.winner_text ?? winner.text;
+  const nextScope = result.winner_scope ?? winner.scope;
+  const nextPathScope = result.winner_path_scope !== void 0 ? result.winner_path_scope ?? null : winner.path_scope;
+  const winnerChanged = nextText !== winner.text || nextScope !== winner.scope || nextPathScope !== winner.path_scope;
+  if (winnerChanged) {
+    db.update(memories).set({
+      text: nextText,
+      scope: nextScope,
+      path_scope: nextPathScope,
+      updated_at: now,
+      last_validated_at: now
+    }).where(eq6(memories.id, winnerId)).run();
+    queueMemoryEmbeddingSync(db, winnerId);
+    const after = getMemory(db, winnerId);
+    recordAuditWithSnapshot(
+      db,
+      winnerId,
+      "edited",
+      actor,
+      `merged_winner:${task.id}`,
+      winner,
+      after ?? null
+    );
+    changed.push(`winner:${winnerId}`);
+  }
+  for (const cand of candidates) {
+    if (cand.id === winnerId) continue;
+    const loser = getMemory(db, cand.id);
+    if (!loser) continue;
+    if (loser.status === "rejected") continue;
+    db.update(memories).set({
+      status: "rejected",
+      supersedes: winnerId,
+      dedupe_key: null,
+      updated_at: now
+    }).where(eq6(memories.id, cand.id)).run();
+    queueMemoryEmbeddingSync(db, cand.id);
+    const afterLoser = getMemory(db, cand.id);
+    recordAuditWithSnapshot(
+      db,
+      cand.id,
+      "rejected",
+      actor,
+      `merged_into:${winnerId}:${task.id}`,
+      loser,
+      afterLoser ?? null
+    );
+    changed.push(`loser:${cand.id}`);
+  }
+  return {
+    audit_entry_id: null,
+    target_id: winnerId,
+    changed_fields: changed
+  };
+}
+function applySummarizeSession(db, task, result) {
+  const payload = task.payload;
+  const sessionId = payload.session_id;
+  if (!sessionId) throw new ApplyError("payload missing session_id", "invalid-state");
+  const id = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(historySnippets).values({
+    id,
+    repo: payload.repo ?? null,
+    session_id: sessionId,
+    kind: "session_summary",
+    text: result.summary_text,
+    source_activity_ids: payload.source_activity_ids ?? [],
+    created_at: now,
+    updated_at: now
+  }).run();
+  return { audit_entry_id: null, target_id: id, changed_fields: ["text"] };
+}
+function applySynthesizeRepo(db, task, result) {
+  const payload = task.payload;
+  const repo = payload.repo;
+  if (!repo) throw new ApplyError("payload missing repo", "invalid-state");
+  const id = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(historySnippets).values({
+    id,
+    repo,
+    session_id: null,
+    kind: "repo_synthesis",
+    text: result.summary_text,
+    source_activity_ids: [],
+    created_at: now,
+    updated_at: now
+  }).run();
+  return { audit_entry_id: null, target_id: id, changed_fields: ["text"] };
+}
+function applyTaskResult(db, task, result) {
+  switch (task.kind) {
+    case "verify_capture":
+      return applyVerifyCapture(db, task, result);
+    case "refine_candidate":
+      return applyRefineCandidate(db, task, result);
+    case "summarize_history":
+      return applySummarizeHistory(db, task, result);
+    case "merge_duplicates":
+      return applyMergeDuplicates(db, task, result);
+    case "summarize_session":
+      return applySummarizeSession(db, task, result);
+    case "synthesize_repo":
+      return applySynthesizeRepo(db, task, result);
+    default: {
+      const never = task.kind;
+      throw new ApplyError(`unknown kind ${never}`, "unsupported-kind");
+    }
+  }
+}
+
+// src/maintenance/tasks.ts
+var OPEN_STATUSES = ["pending", "claimed", "submitted"];
+var ACTIVE_STATUSES = [...OPEN_STATUSES, "completed"];
+var DEFAULT_LEASE_SECONDS = 600;
+var DEFAULT_PRIORITIES = {
+  verify_capture: 12,
+  refine_candidate: 10,
+  merge_duplicates: 8,
+  summarize_history: 5,
+  summarize_session: 3,
+  synthesize_repo: 1
+};
+var DEFAULT_ENQUEUE_CONFIG = {
+  max_pending: 50,
+  max_per_kind: 10,
+  refine_min_repetition: 1,
+  summary_max_age_days: 7,
+  merge_similarity_threshold: 0.9,
+  session_min_activity_events: 5,
+  repo_synthesis_min_memories: 20,
+  repo_synthesis_refresh_days: 30
+};
+function rowToTask(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    status: row.status,
+    priority: row.priority,
+    repo: row.repo,
+    target_key: row.target_key,
+    payload: row.payload ?? {},
+    result: row.result ?? null,
+    failure_reason: row.failure_reason,
+    claimed_by: row.claimed_by,
+    claimed_at: row.claimed_at,
+    claim_expires_at: row.claim_expires_at,
+    submitted_at: row.submitted_at,
+    completed_at: row.completed_at,
+    created_at: row.created_at,
+    attempts: row.attempts,
+    max_attempts: row.max_attempts
+  };
+}
+function targetKey(kind, target) {
+  return `${kind}:${target}`;
+}
+function hasActiveTaskForTarget(db, kind, target) {
+  const row = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and2(
+    eq7(memoryMaintenanceTasks.kind, kind),
+    eq7(memoryMaintenanceTasks.target_key, targetKey(kind, target)),
+    inArray2(memoryMaintenanceTasks.status, ACTIVE_STATUSES)
+  )).limit(1).get();
+  return Boolean(row);
+}
+function insertTaskIdempotent(db, input) {
+  if (hasActiveTaskForTarget(db, input.kind, input.target)) return null;
+  const id = randomUUID4();
+  db.insert(memoryMaintenanceTasks).values({
+    id,
+    kind: input.kind,
+    status: "pending",
+    priority: input.priority ?? DEFAULT_PRIORITIES[input.kind] ?? 0,
+    repo: input.repo ?? null,
+    target_key: targetKey(input.kind, input.target),
+    payload: input.payload,
+    result: null,
+    failure_reason: null,
+    claimed_by: null,
+    claimed_at: null,
+    claim_expires_at: null,
+    submitted_at: null,
+    completed_at: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    attempts: 0,
+    max_attempts: input.max_attempts ?? 3
+  }).run();
+  return id;
+}
+function deleteTask(db, id) {
+  const result = db.delete(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.id, id)).run();
+  return result.changes > 0;
+}
+function getTaskStats(db) {
+  const rows = db.select().from(memoryMaintenanceTasks).all();
+  const by_status = { pending: 0, claimed: 0, submitted: 0, completed: 0, abandoned: 0 };
+  const by_kind = { verify_capture: 0, refine_candidate: 0, merge_duplicates: 0, summarize_history: 0, summarize_session: 0, synthesize_repo: 0 };
+  const by_kind_status = {};
+  const dayAgo = new Date(Date.now() - 864e5).toISOString();
+  let completed_last_24h = 0;
+  let abandoned_last_24h = 0;
+  let pending_oldest = null;
+  let completionDurations = [];
+  for (const row of rows) {
+    by_status[row.status] += 1;
+    by_kind[row.kind] += 1;
+    const key = `${row.kind}:${row.status}`;
+    by_kind_status[key] = (by_kind_status[key] ?? 0) + 1;
+    if (row.status === "pending") {
+      if (!pending_oldest || row.created_at < pending_oldest) pending_oldest = row.created_at;
+    }
+    if (row.completed_at && row.completed_at >= dayAgo) {
+      if (row.status === "completed") completed_last_24h += 1;
+      if (row.status === "abandoned") abandoned_last_24h += 1;
+    }
+    if (row.status === "completed" && row.completed_at) {
+      const delta = new Date(row.completed_at).getTime() - new Date(row.created_at).getTime();
+      if (Number.isFinite(delta) && delta >= 0) completionDurations.push(delta);
+    }
+  }
+  const mean_completion_ms = completionDurations.length ? completionDurations.reduce((a, b) => a + b, 0) / completionDurations.length : null;
+  return {
+    total: rows.length,
+    by_status,
+    by_kind,
+    by_kind_status,
+    pending_oldest_created_at: pending_oldest,
+    completed_last_24h,
+    abandoned_last_24h,
+    mean_completion_ms
+  };
+}
+function getTask(db, id) {
+  const row = db.select().from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.id, id)).get();
+  return row ? rowToTask(row) : void 0;
+}
+function listTasks(db, query = {}) {
+  const conditions = [];
+  if (query.status) {
+    const statuses = Array.isArray(query.status) ? query.status : [query.status];
+    conditions.push(inArray2(memoryMaintenanceTasks.status, statuses));
+  }
+  if (query.kinds?.length) {
+    conditions.push(inArray2(memoryMaintenanceTasks.kind, query.kinds));
+  }
+  if (query.repo) {
+    conditions.push(eq7(memoryMaintenanceTasks.repo, query.repo));
+  }
+  let stmt = db.select().from(memoryMaintenanceTasks).$dynamic();
+  if (conditions.length) stmt = stmt.where(and2(...conditions));
+  stmt = stmt.orderBy(sql2`${memoryMaintenanceTasks.priority} DESC`, memoryMaintenanceTasks.created_at).limit(query.limit ?? 50);
+  return stmt.all().map(rowToTask);
+}
+function sweepExpiredLeases(db, now = /* @__PURE__ */ new Date()) {
+  const nowIso = now.toISOString();
+  const result = db.update(memoryMaintenanceTasks).set({
+    status: "pending",
+    claimed_by: null,
+    claimed_at: null,
+    claim_expires_at: null,
+    attempts: sql2`${memoryMaintenanceTasks.attempts} + 1`
+  }).where(and2(
+    eq7(memoryMaintenanceTasks.status, "claimed"),
+    lt(memoryMaintenanceTasks.claim_expires_at, nowIso)
+  )).run();
+  return result.changes;
+}
+function expireStalePendingTasks(db, maxAgeDays, now = /* @__PURE__ */ new Date()) {
+  const cutoff = new Date(now.getTime() - maxAgeDays * 864e5).toISOString();
+  const result = db.update(memoryMaintenanceTasks).set({
+    status: "abandoned",
+    failure_reason: "expired_no_dispatcher",
+    completed_at: now.toISOString()
+  }).where(and2(
+    eq7(memoryMaintenanceTasks.status, "pending"),
+    lt(memoryMaintenanceTasks.created_at, cutoff)
+  )).run();
+  return result.changes;
+}
+function abandonOverAttemptTasks(db) {
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const result = db.update(memoryMaintenanceTasks).set({
+    status: "abandoned",
+    failure_reason: "max_attempts_exceeded",
+    completed_at: nowIso
+  }).where(and2(
+    inArray2(memoryMaintenanceTasks.status, ["pending", "claimed"]),
+    sql2`${memoryMaintenanceTasks.attempts} >= ${memoryMaintenanceTasks.max_attempts}`
+  )).run();
+  return result.changes;
+}
+function applyBacklogCaps(db, config) {
+  let dropped = 0;
+  const overKindRows = db.select({
+    kind: memoryMaintenanceTasks.kind,
+    count: sql2`count(*)`.as("count")
+  }).from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.status, "pending")).groupBy(memoryMaintenanceTasks.kind).all();
+  for (const { kind, count } of overKindRows) {
+    if (count <= config.max_per_kind) continue;
+    const toDrop = count - config.max_per_kind;
+    dropped += dropLowestPriorityPending(db, toDrop, { kind });
+  }
+  const pendingCount = db.select({ n: sql2`count(*)` }).from(memoryMaintenanceTasks).where(eq7(memoryMaintenanceTasks.status, "pending")).get()?.n ?? 0;
+  if (pendingCount > config.max_pending) {
+    dropped += dropLowestPriorityPending(db, pendingCount - config.max_pending);
+  }
+  return dropped;
+}
+function dropLowestPriorityPending(db, limit, filter = {}) {
+  const conditions = [eq7(memoryMaintenanceTasks.status, "pending")];
+  if (filter.kind) conditions.push(eq7(memoryMaintenanceTasks.kind, filter.kind));
+  const ids = db.select({ id: memoryMaintenanceTasks.id }).from(memoryMaintenanceTasks).where(and2(...conditions)).orderBy(memoryMaintenanceTasks.priority, sql2`${memoryMaintenanceTasks.created_at} DESC`).limit(limit).all().map((r) => r.id);
+  if (!ids.length) return 0;
+  const result = db.delete(memoryMaintenanceTasks).where(inArray2(memoryMaintenanceTasks.id, ids)).run();
+  return result.changes;
+}
+function enqueueVerifyCapture(db, memory) {
+  return insertTaskIdempotent(db, {
+    kind: "verify_capture",
+    target: memory.id,
+    repo: memory.repo,
+    payload: {
+      memory_id: memory.id,
+      text: memory.text,
+      inferred_scope: memory.scope,
+      inferred_path_scope: memory.path_scope,
+      repo: memory.repo,
+      capture_context: memory.capture_context ?? null
+    }
+  });
+}
+function produceRefineCandidateTasks(db, config) {
+  const candidates = db.select().from(memories).where(and2(
+    eq7(memories.status, "candidate"),
+    or(eq7(memories.scope, "repo"), isNull(memories.path_scope))
+  )).all();
+  let enqueued = 0;
+  for (const row of candidates) {
+    if (row.repetition_count < config.refine_min_repetition) continue;
+    if (!row.repo) continue;
+    const id = insertTaskIdempotent(db, {
+      kind: "refine_candidate",
+      target: row.id,
+      repo: row.repo,
+      payload: {
+        memory_id: row.id,
+        text: row.text,
+        current_scope: row.scope,
+        current_path_scope: row.path_scope,
+        repo: row.repo,
+        capture_context: row.capture_context ?? null,
+        repetition_count: row.repetition_count
+      }
+    });
+    if (id) enqueued += 1;
+  }
+  return enqueued;
+}
+function produceSummarizeHistoryTasks(db, config) {
+  const cutoff = new Date(Date.now() - config.summary_max_age_days * 864e5).toISOString();
+  const snippets = db.select().from(historySnippets).where(sql2`${historySnippets.created_at} >= ${cutoff}`).all();
+  let enqueued = 0;
+  for (const snippet of snippets) {
+    if (!snippetHasMeaningfulContent(snippet.text)) continue;
+    const id = insertTaskIdempotent(db, {
+      kind: "summarize_history",
+      target: snippet.id,
+      repo: snippet.repo ?? null,
+      payload: {
+        snippet_id: snippet.id,
+        kind: snippet.kind,
+        repo: snippet.repo,
+        session_id: snippet.session_id,
+        current_text: snippet.text,
+        source_activity_ids: snippet.source_activity_ids
+      }
+    });
+    if (id) enqueued += 1;
+  }
+  return enqueued;
+}
+function snippetHasMeaningfulContent(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return false;
+  return lines.some(
+    (line) => line.startsWith("Corrections:") || line.startsWith("Reviews:") || line.startsWith("Latest compile included") || line.startsWith("Prompts:")
+  );
+}
+async function produceMergeDuplicateTasks(db, config) {
+  const embeddingConfig = loadEmbeddingConfigFromEnv();
+  if (!embeddingConfig) return 0;
+  const activeMemories = db.select().from(memories).where(eq7(memories.status, "active")).all();
+  const visited = /* @__PURE__ */ new Set();
+  let enqueued = 0;
+  for (const mem of activeMemories) {
+    if (visited.has(mem.id)) continue;
+    if (!mem.repo) continue;
+    const threshold = mem.type === "command" ? Math.min(config.merge_similarity_threshold, 0.85) : config.merge_similarity_threshold;
+    const duplicates = await findSemanticDuplicates(
+      db,
+      mem.text,
+      embeddingConfig,
+      threshold,
+      { repo: mem.repo, type: mem.type, limit: 10 }
+    );
+    const peers = duplicates.filter((d) => d.id !== mem.id);
+    if (peers.length === 0) continue;
+    const cluster = [mem.id, ...peers.map((p) => p.id)].sort();
+    if (cluster[0] !== mem.id) {
+      for (const id2 of cluster) visited.add(id2);
+      continue;
+    }
+    const clusterRows = db.select().from(memories).where(inArray2(memories.id, cluster)).all();
+    const candidates = clusterRows.map((row) => ({
+      id: row.id,
+      text: row.text,
+      scope: row.scope,
+      path_scope: row.path_scope,
+      confidence: row.confidence
+    }));
+    const id = insertTaskIdempotent(db, {
+      kind: "merge_duplicates",
+      target: cluster[0],
+      repo: mem.repo,
+      payload: {
+        repo: mem.repo,
+        type: mem.type,
+        candidates
+      }
+    });
+    if (id) enqueued += 1;
+    for (const memberId of cluster) visited.add(memberId);
+  }
+  return enqueued;
+}
+function produceSummarizeSessionTasks(db, config) {
+  const cutoff = new Date(Date.now() - config.summary_max_age_days * 864e5).toISOString();
+  const sessionEnds = db.select().from(activityEvents).where(and2(
+    eq7(activityEvents.event_type, "session_end"),
+    gt(activityEvents.created_at, cutoff)
+  )).orderBy(desc2(activityEvents.created_at)).all();
+  let enqueued = 0;
+  for (const end of sessionEnds) {
+    if (!end.session_id) continue;
+    const events = db.select().from(activityEvents).where(eq7(activityEvents.session_id, end.session_id)).all();
+    if (events.length < config.session_min_activity_events) continue;
+    const existing = db.select().from(historySnippets).where(and2(
+      eq7(historySnippets.session_id, end.session_id),
+      eq7(historySnippets.kind, "session_summary")
+    )).get();
+    if (existing) continue;
+    const repo = end.repo ?? events.find((e) => e.repo)?.repo ?? null;
+    const eventTypes = [...new Set(events.map((e) => e.event_type))];
+    const id = insertTaskIdempotent(db, {
+      kind: "summarize_session",
+      target: end.session_id,
+      repo,
+      payload: {
+        session_id: end.session_id,
+        repo,
+        event_count: events.length,
+        event_types: eventTypes,
+        source_activity_ids: events.map((e) => e.id)
+      }
+    });
+    if (id) enqueued += 1;
+  }
+  return enqueued;
+}
+function produceSynthesizeRepoTasks(db, config) {
+  const rows = db.select({
+    repo: memories.repo,
+    count: sql2`count(*)`.as("count")
+  }).from(memories).where(eq7(memories.status, "active")).groupBy(memories.repo).all();
+  const cutoff = new Date(Date.now() - config.repo_synthesis_refresh_days * 864e5).toISOString();
+  let enqueued = 0;
+  for (const { repo, count } of rows) {
+    if (!repo) continue;
+    if (count < config.repo_synthesis_min_memories) continue;
+    const recent = db.select().from(historySnippets).where(and2(
+      eq7(historySnippets.repo, repo),
+      eq7(historySnippets.kind, "repo_synthesis"),
+      gt(historySnippets.updated_at, cutoff)
+    )).get();
+    if (recent) continue;
+    const topMemories = db.select().from(memories).where(and2(
+      eq7(memories.repo, repo),
+      eq7(memories.status, "active")
+    )).orderBy(desc2(memories.confidence)).limit(20).all().map((row) => ({
+      id: row.id,
+      text: row.text,
+      type: row.type,
+      scope: row.scope,
+      confidence: row.confidence
+    }));
+    const id = insertTaskIdempotent(db, {
+      kind: "synthesize_repo",
+      target: repo,
+      repo,
+      payload: {
+        repo,
+        memory_count: count,
+        top_memories: topMemories
+      }
+    });
+    if (id) enqueued += 1;
+  }
+  return enqueued;
+}
+async function enqueueMaintenanceTasks(db, config = DEFAULT_ENQUEUE_CONFIG) {
+  const expired = sweepExpiredLeases(db);
+  abandonOverAttemptTasks(db);
+  const expiredPending = expireStalePendingTasks(db, config.summary_max_age_days * 2);
+  const counts = {};
+  counts.refine_candidate = produceRefineCandidateTasks(db, config);
+  counts.summarize_history = produceSummarizeHistoryTasks(db, config);
+  counts.summarize_session = produceSummarizeSessionTasks(db, config);
+  counts.synthesize_repo = produceSynthesizeRepoTasks(db, config);
+  counts.merge_duplicates = await produceMergeDuplicateTasks(db, config);
+  const dropped = applyBacklogCaps(db, config);
+  const total = Object.values(counts).reduce((sum, n) => sum + (n ?? 0), 0);
+  return {
+    tasks_enqueued: total,
+    per_kind: counts,
+    expired_leases_swept: expired,
+    dropped_over_cap: dropped,
+    expired_pending_tasks: expiredPending
+  };
+}
+var MemoryScope2 = z2.enum(["session", "path", "repo", "team", "global"]);
+var RefineCandidateResult = z2.object({
+  refined_text: z2.string().min(1).max(4e3),
+  scope: MemoryScope2,
+  path_scope: z2.string().max(512).nullable().optional(),
+  rationale: z2.string().max(2e3).optional(),
+  // Optional verdict — when present, the LLM may also reject a re-captured
+  // fragment instead of refining it. Backwards-compatible: omitted means
+  // "rewrite" (legacy refine behavior).
+  verdict: z2.enum(["rewrite", "reject"]).optional()
+});
+var VerifyCaptureResult = z2.object({
+  verdict: z2.enum(["save", "rewrite", "reject"]),
+  cleaned_text: z2.string().min(1).max(4e3).optional(),
+  scope: MemoryScope2.optional(),
+  path_scope: z2.string().max(512).nullable().optional(),
+  is_destructive_risky: z2.boolean().optional(),
+  reason: z2.string().max(2e3).optional()
+});
+var SummarizeHistoryResult = z2.object({
+  summary_text: z2.string().min(1).max(4e3),
+  tags: z2.array(z2.string().max(64)).max(20).optional()
+});
+var MergeDuplicatesResult = z2.object({
+  winner_id: z2.string().uuid(),
+  winner_text: z2.string().min(1).max(4e3).optional(),
+  winner_scope: MemoryScope2.optional(),
+  winner_path_scope: z2.string().max(512).nullable().optional(),
+  rationale: z2.string().max(2e3).optional()
+});
+var SummarizeSessionResult = z2.object({
+  summary_text: z2.string().min(1).max(4e3)
+});
+var SynthesizeRepoResult = z2.object({
+  summary_text: z2.string().min(1).max(8e3)
+});
+var RESULT_SCHEMAS = {
+  verify_capture: VerifyCaptureResult,
+  refine_candidate: RefineCandidateResult,
+  summarize_history: SummarizeHistoryResult,
+  merge_duplicates: MergeDuplicatesResult,
+  summarize_session: SummarizeSessionResult,
+  synthesize_repo: SynthesizeRepoResult
+};
+function payloadSummary(payload) {
+  const out = {};
+  for (const [k, v] of Object.entries(payload)) {
+    if (typeof v === "string") {
+      out[k] = v.length > 160 ? `${v.slice(0, 157)}...` : v;
+    } else if (Array.isArray(v)) {
+      out[k] = `array(${v.length})`;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function peekTasks(db, options = {}) {
+  const tasks = listTasks(db, {
+    status: "pending",
+    repo: options.repo,
+    kinds: options.kinds,
+    limit: Math.min(options.limit ?? 3, 10)
+  });
+  return tasks.map((t) => ({
+    id: t.id,
+    kind: t.kind,
+    priority: t.priority,
+    repo: t.repo,
+    created_at: t.created_at,
+    payload_summary: payloadSummary(t.payload)
+  }));
+}
+var TaskClaimConflictError = class extends Error {
+  constructor(taskId, reason) {
+    super(`Task ${taskId} cannot be claimed: ${reason}`);
+    this.taskId = taskId;
+    this.reason = reason;
+    this.name = "TaskClaimConflictError";
+  }
+  taskId;
+  reason;
+};
+function claimTask(db, taskId, agent, leaseSeconds = DEFAULT_LEASE_SECONDS) {
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + leaseSeconds * 1e3).toISOString();
+  const nowIso = now.toISOString();
+  const result = db.update(memoryMaintenanceTasks).set({
+    status: "claimed",
+    claimed_by: agent,
+    claimed_at: nowIso,
+    claim_expires_at: expiresAt
+  }).where(and2(
+    eq7(memoryMaintenanceTasks.id, taskId),
+    eq7(memoryMaintenanceTasks.status, "pending")
+  )).run();
+  if (result.changes === 0) {
+    const existing = getTask(db, taskId);
+    throw new TaskClaimConflictError(taskId, existing ? "not-pending" : "not-found");
+  }
+  const task = getTask(db, taskId);
+  return { task, lease_expires_at: expiresAt };
+}
+function submitTask(db, taskId, agent, result) {
+  const existing = getTask(db, taskId);
+  if (!existing) return { status: "rejected", task_id: taskId, reason: "not-found", attempts: 0, abandoned: false };
+  if (existing.status !== "claimed") {
+    return { status: "rejected", task_id: taskId, reason: `not-claimed (status=${existing.status})`, attempts: existing.attempts, abandoned: false };
+  }
+  if (existing.claimed_by !== agent) {
+    return { status: "rejected", task_id: taskId, reason: "not-claim-holder", attempts: existing.attempts, abandoned: false };
+  }
+  const schema = RESULT_SCHEMAS[existing.kind];
+  const parsed = schema.safeParse(result);
+  if (!parsed.success) {
+    const attempts = existing.attempts + 1;
+    const abandoned = attempts >= existing.max_attempts;
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    db.update(memoryMaintenanceTasks).set({
+      status: abandoned ? "abandoned" : "pending",
+      claimed_by: null,
+      claimed_at: null,
+      claim_expires_at: null,
+      attempts,
+      failure_reason: parsed.error.issues.map((i) => `${i.path.join(".")}:${i.message}`).join("; ").slice(0, 500),
+      completed_at: abandoned ? now2 : null
+    }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+    return {
+      status: "rejected",
+      task_id: taskId,
+      reason: `validation-failed: ${parsed.error.issues[0]?.message ?? "shape mismatch"}`,
+      attempts,
+      abandoned
+    };
+  }
+  let applyOutcome;
+  try {
+    applyOutcome = applyTaskResult(db, existing, parsed.data);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const attempts = existing.attempts + 1;
+    const code = err instanceof ApplyError ? err.code : "apply-error";
+    const abandoned = code === "target-missing" || code === "invalid-state" || code === "unsupported-kind" || attempts >= existing.max_attempts;
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    db.update(memoryMaintenanceTasks).set({
+      status: abandoned ? "abandoned" : "pending",
+      claimed_by: null,
+      claimed_at: null,
+      claim_expires_at: null,
+      attempts,
+      failure_reason: `apply-failed: ${message}`.slice(0, 500),
+      completed_at: abandoned ? now2 : null
+    }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+    return {
+      status: "rejected",
+      task_id: taskId,
+      reason: `apply-failed: ${message}`,
+      attempts,
+      abandoned
+    };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(memoryMaintenanceTasks).set({
+    status: "completed",
+    result: parsed.data,
+    submitted_at: now,
+    completed_at: now,
+    failure_reason: null
+  }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+  return {
+    status: "applied",
+    task_id: taskId,
+    kind: existing.kind,
+    target_id: applyOutcome.target_id,
+    changed_fields: applyOutcome.changed_fields,
+    audit_entry_id: applyOutcome.audit_entry_id
+  };
+}
+function releaseTask(db, taskId, agent, reason) {
+  const existing = getTask(db, taskId);
+  if (!existing) return { status: "not-found" };
+  if (existing.status !== "claimed" || existing.claimed_by !== agent) {
+    return { status: "not-claimed" };
+  }
+  db.update(memoryMaintenanceTasks).set({
+    status: "pending",
+    claimed_by: null,
+    claimed_at: null,
+    claim_expires_at: null,
+    failure_reason: reason ? reason.slice(0, 500) : null
+  }).where(eq7(memoryMaintenanceTasks.id, taskId)).run();
+  return { status: "released" };
+}
+
+export {
+  getEmbeddingCacheRoot,
+  memoryDedupeKey,
+  historySnippetDedupeKey,
+  activityEventDedupeKey,
+  hookCallDedupeKey,
+  tagActivitySource,
+  CONFIDENCE,
+  RetrievalEvalCase,
+  RetrievalEvalFile,
+  resolveProvider,
+  loadEmbeddingConfigFromEnv,
+  getEmbeddingModelInfo,
+  ensureEmbeddingProviderReady,
+  projectEmbeddingToIndex,
+  generateEmbedding,
+  generateEmbeddings,
+  queueMemoryEmbeddingSync,
+  bootstrapEmbeddings,
+  verifyEmbeddings,
+  rebuildEmbeddingIndex,
+  hybridSearch,
+  findSemanticDuplicates,
+  findSimilarRejectedExemplar,
+  statusFromConfidence,
+  createMemory,
+  getMemory,
+  queryMemories,
+  listMemories,
+  listRepos,
+  promoteMemory,
+  demoteMemory,
+  demoteGlobalMemory,
+  rejectMemory,
+  confirmMemory,
+  appendEvidence,
+  updateMemoryCaptureContext,
+  incrementMemoryRepetition,
+  countDistinctCorrectionSessions,
+  recordFeedback,
+  getMemoryFeedback,
+  getMemoryFeedbackSummaries,
+  feedbackWeightedScore,
+  recordAudit,
+  recordAuditWithSnapshot,
+  getAuditTrail,
+  getRecentAudit,
+  rollbackMemory,
+  formatAuditTrail,
+  DEFAULT_LEASE_SECONDS,
+  DEFAULT_PRIORITIES,
+  DEFAULT_ENQUEUE_CONFIG,
+  targetKey,
+  hasActiveTaskForTarget,
+  insertTaskIdempotent,
+  deleteTask,
+  getTaskStats,
+  getTask,
+  listTasks,
+  sweepExpiredLeases,
+  expireStalePendingTasks,
+  abandonOverAttemptTasks,
+  applyBacklogCaps,
+  enqueueVerifyCapture,
+  produceRefineCandidateTasks,
+  produceSummarizeHistoryTasks,
+  snippetHasMeaningfulContent,
+  produceMergeDuplicateTasks,
+  produceSummarizeSessionTasks,
+  produceSynthesizeRepoTasks,
+  enqueueMaintenanceTasks,
+  peekTasks,
+  TaskClaimConflictError,
+  claimTask,
+  submitTask,
+  releaseTask
+};
+//# sourceMappingURL=chunk-IILLSHLM.js.map