@smyslenny/agent-memory 2.2.0 → 4.0.0-alpha.1

package/dist/bin/agent-memory.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 // AgentMemory v2 — Sleep-cycle memory for AI agents
 
+// src/bin/agent-memory.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { basename, resolve } from "path";
+
 // src/core/db.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 5;
 var SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -67,14 +71,37 @@ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
 
 -- Embeddings (optional semantic layer)
 CREATE TABLE IF NOT EXISTS embeddings (
-  agent_id    TEXT NOT NULL DEFAULT 'default',
-  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  model       TEXT NOT NULL,
-  dim         INTEGER NOT NULL,
-  vector      BLOB NOT NULL,
-  created_at  TEXT NOT NULL,
-  updated_at  TEXT NOT NULL,
-  PRIMARY KEY (agent_id, memory_id, model)
+  id           TEXT PRIMARY KEY,
+  memory_id    TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  provider_id  TEXT NOT NULL,
+  vector       BLOB,
+  content_hash TEXT NOT NULL,
+  status       TEXT NOT NULL CHECK(status IN ('pending','ready','failed')),
+  created_at   TEXT NOT NULL,
+  UNIQUE(memory_id, provider_id)
+);
+
+-- Maintenance jobs (reflect / reindex checkpoints)
+CREATE TABLE IF NOT EXISTS maintenance_jobs (
+  job_id       TEXT PRIMARY KEY,
+  phase        TEXT NOT NULL CHECK(phase IN ('decay','tidy','govern','all')),
+  status       TEXT NOT NULL CHECK(status IN ('running','completed','failed')),
+  checkpoint   TEXT,
+  error        TEXT,
+  started_at   TEXT NOT NULL,
+  finished_at  TEXT
+);
+
+-- Feedback signals (recall/surface usefulness + governance priors)
+CREATE TABLE IF NOT EXISTS feedback_events (
+  id           TEXT PRIMARY KEY,
+  memory_id    TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  source       TEXT NOT NULL DEFAULT 'surface',
+  useful       INTEGER NOT NULL DEFAULT 1,
+  agent_id     TEXT NOT NULL DEFAULT 'default',
+  event_type   TEXT NOT NULL DEFAULT 'surface:useful',
+  value        REAL NOT NULL DEFAULT 1.0,
+  created_at   TEXT NOT NULL
 );
 
 -- Schema version tracking
@@ -91,6 +118,8 @@ CREATE INDEX IF NOT EXISTS idx_memories_vitality ON memories(vitality);
 CREATE INDEX IF NOT EXISTS idx_memories_hash ON memories(hash);
 CREATE INDEX IF NOT EXISTS idx_paths_memory ON paths(memory_id);
 CREATE INDEX IF NOT EXISTS idx_paths_domain ON paths(domain);
+CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_phase_status ON maintenance_jobs(phase, status, started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);
 `;
 function openDatabase(opts) {
   const db = new Database(opts.path);
@@ -111,6 +140,7 @@ function openDatabase(opts) {
     migrateDatabase(db, currentVersion, SCHEMA_VERSION);
   }
   ensureIndexes(db);
+  ensureFeedbackEventSchema(db);
   return db;
 }
 function now() {
@@ -129,6 +159,14 @@ function getSchemaVersion(db) {
     return null;
   }
 }
+function tableExists(db, table) {
+  try {
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(table);
+    return Boolean(row?.name);
+  } catch {
+    return false;
+  }
+}
 function tableHasColumn(db, table, column) {
   try {
     const cols = db.prepare(`PRAGMA table_info(${table})`).all();
@@ -150,6 +188,16 @@ function migrateDatabase(db, from, to) {
       v = 3;
       continue;
     }
+    if (v === 3) {
+      migrateV3ToV4(db);
+      v = 4;
+      continue;
+    }
+    if (v === 4) {
+      migrateV4ToV5(db);
+      v = 5;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -231,14 +279,12 @@ function migrateV1ToV2(db) {
 function inferSchemaVersion(db) {
   const hasAgentScopedPaths = tableHasColumn(db, "paths", "agent_id");
   const hasAgentScopedLinks = tableHasColumn(db, "links", "agent_id");
-  const hasEmbeddings = (() => {
-    try {
-      const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'").get();
-      return Boolean(row);
-    } catch {
-      return false;
-    }
-  })();
+  const hasEmbeddings = tableExists(db, "embeddings");
+  const hasV4Embeddings = hasEmbeddings && tableHasColumn(db, "embeddings", "provider_id") && tableHasColumn(db, "embeddings", "status") && tableHasColumn(db, "embeddings", "content_hash") && tableHasColumn(db, "embeddings", "id");
+  const hasMaintenanceJobs = tableExists(db, "maintenance_jobs");
+  const hasFeedbackEvents = tableExists(db, "feedback_events");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings) return 4;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasEmbeddings) return 3;
   if (hasAgentScopedPaths && hasAgentScopedLinks) return 2;
   return 1;
@@ -251,14 +297,37 @@ function ensureIndexes(db) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_links_agent_source ON links(agent_id, source_id);");
     db.exec("CREATE INDEX IF NOT EXISTS idx_links_agent_target ON links(agent_id, target_id);");
   }
-  try {
-    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'").get();
-    if (row) {
+  if (tableExists(db, "embeddings")) {
+    if (tableHasColumn(db, "embeddings", "provider_id")) {
+      db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_provider_status ON embeddings(provider_id, status);");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_memory_provider ON embeddings(memory_id, provider_id);");
+    } else {
       db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_agent_model ON embeddings(agent_id, model);");
       db.exec("CREATE INDEX IF NOT EXISTS idx_embeddings_memory ON embeddings(memory_id);");
     }
-  } catch {
   }
+  if (tableExists(db, "maintenance_jobs")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_phase_status ON maintenance_jobs(phase, status, started_at DESC);");
+  }
+  if (tableExists(db, "feedback_events")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);");
+    if (tableHasColumn(db, "feedback_events", "agent_id") && tableHasColumn(db, "feedback_events", "source")) {
+      db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
+    }
+  }
+}
+function ensureFeedbackEventSchema(db) {
+  if (!tableExists(db, "feedback_events")) return;
+  if (!tableHasColumn(db, "feedback_events", "source")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN source TEXT NOT NULL DEFAULT 'surface';");
+  }
+  if (!tableHasColumn(db, "feedback_events", "useful")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN useful INTEGER NOT NULL DEFAULT 1;");
+  }
+  if (!tableHasColumn(db, "feedback_events", "agent_id")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN agent_id TEXT NOT NULL DEFAULT 'default';");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
 }
 function migrateV2ToV3(db) {
   try {
@@ -285,9 +354,97 @@ function migrateV2ToV3(db) {
     throw e;
   }
 }
+function migrateV3ToV4(db) {
+  const alreadyMigrated = tableHasColumn(db, "embeddings", "provider_id") && tableHasColumn(db, "embeddings", "status") && tableHasColumn(db, "embeddings", "content_hash") && tableHasColumn(db, "embeddings", "id");
+  if (alreadyMigrated) {
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(4));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    const legacyRows = tableExists(db, "embeddings") ? db.prepare(
+      `SELECT e.agent_id, e.memory_id, e.model, e.vector, e.created_at, m.hash
+         FROM embeddings e
+         LEFT JOIN memories m ON m.id = e.memory_id`
+    ).all() : [];
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS embeddings_v4 (
+        id           TEXT PRIMARY KEY,
+        memory_id    TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+        provider_id  TEXT NOT NULL,
+        vector       BLOB,
+        content_hash TEXT NOT NULL,
+        status       TEXT NOT NULL CHECK(status IN ('pending','ready','failed')),
+        created_at   TEXT NOT NULL,
+        UNIQUE(memory_id, provider_id)
+      );
+    `);
+    const insert = db.prepare(
+      `INSERT INTO embeddings_v4 (id, memory_id, provider_id, vector, content_hash, status, created_at)
+       VALUES (?, ?, ?, ?, ?, 'ready', ?)`
+    );
+    for (const row of legacyRows) {
+      insert.run(newId(), row.memory_id, `legacy:${row.agent_id}:${row.model}`, row.vector, row.hash ?? "", row.created_at);
+    }
+    if (tableExists(db, "embeddings")) {
+      db.exec("DROP TABLE embeddings;");
+    }
+    db.exec("ALTER TABLE embeddings_v4 RENAME TO embeddings;");
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(4));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
+function migrateV4ToV5(db) {
+  const hasMaintenanceJobs = tableExists(db, "maintenance_jobs");
+  const hasFeedbackEvents = tableExists(db, "feedback_events");
+  if (hasMaintenanceJobs && hasFeedbackEvents) {
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(5));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS maintenance_jobs (
+        job_id       TEXT PRIMARY KEY,
+        phase        TEXT NOT NULL CHECK(phase IN ('decay','tidy','govern','all')),
+        status       TEXT NOT NULL CHECK(status IN ('running','completed','failed')),
+        checkpoint   TEXT,
+        error        TEXT,
+        started_at   TEXT NOT NULL,
+        finished_at  TEXT
+      );
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS feedback_events (
+        id           TEXT PRIMARY KEY,
+        memory_id    TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+        source       TEXT NOT NULL DEFAULT 'surface',
+        useful       INTEGER NOT NULL DEFAULT 1,
+        agent_id     TEXT NOT NULL DEFAULT 'default',
+        event_type   TEXT NOT NULL DEFAULT 'surface:useful',
+        value        REAL NOT NULL DEFAULT 1.0,
+        created_at   TEXT NOT NULL
+      );
+    `);
+    db.prepare("UPDATE schema_meta SET value = ? WHERE key = 'version'").run(String(5));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 
 // src/core/memory.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 
 // src/search/tokenizer.ts
 import { readFileSync } from "fs";
@@ -368,9 +525,347 @@ function tokenizeForIndex(text) {
   return tokens.join(" ");
 }
 
+// src/search/embedding.ts
+import { createHash } from "crypto";
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveEndpoint(baseUrl, endpoint = "/embeddings") {
+  const trimmed = trimTrailingSlashes(baseUrl);
+  if (trimmed.endsWith("/embeddings")) {
+    return trimmed;
+  }
+  const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  return `${trimmed}${normalizedEndpoint}`;
+}
+function stableProviderId(prefix, input) {
+  const digest = createHash("sha256").update(input).digest("hex").slice(0, 12);
+  return `${prefix}:${digest}`;
+}
+function getFetch(fetchImpl) {
+  const candidate = fetchImpl ?? globalThis.fetch;
+  if (!candidate) {
+    throw new Error("Global fetch is not available in this runtime");
+  }
+  return candidate;
+}
+function assertEmbeddingVector(vector, dimension, context) {
+  if (!Array.isArray(vector) || !vector.every((value) => typeof value === "number" && Number.isFinite(value))) {
+    throw new Error(`${context} returned an invalid embedding vector`);
+  }
+  if (vector.length !== dimension) {
+    throw new Error(`${context} returned dimension ${vector.length}, expected ${dimension}`);
+  }
+  return vector;
+}
+function parseOpenAIResponse(json2, dimension, context) {
+  const rows = json2?.data;
+  if (!Array.isArray(rows)) {
+    throw new Error(`${context} returned an invalid embeddings payload`);
+  }
+  return rows.map((row, index) => assertEmbeddingVector(row?.embedding, dimension, `${context} item ${index}`));
+}
+function parseLocalHttpResponse(json2, dimension, context) {
+  if (Array.isArray(json2.embeddings)) {
+    const embeddings = json2.embeddings;
+    return embeddings.map((row, index) => assertEmbeddingVector(row, dimension, `${context} item ${index}`));
+  }
+  return parseOpenAIResponse(json2, dimension, context);
+}
+async function runEmbeddingRequest(input) {
+  const fetchFn = getFetch(input.fetchImpl);
+  const response = await fetchFn(input.url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...input.headers
+    },
+    body: JSON.stringify(input.body)
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`${input.context} request failed: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}`);
+  }
+  const json2 = await response.json();
+  return input.parser(json2, input.dimension, input.context);
+}
+function createOpenAICompatibleEmbeddingProvider(opts) {
+  const url = resolveEndpoint(opts.baseUrl, opts.endpoint);
+  const providerDescriptor = `${trimTrailingSlashes(opts.baseUrl)}|${opts.model}|${opts.dimension}`;
+  const id = stableProviderId(`openai-compatible:${opts.model}`, providerDescriptor);
+  return {
+    id,
+    model: opts.model,
+    dimension: opts.dimension,
+    async embed(texts) {
+      if (texts.length === 0) return [];
+      return runEmbeddingRequest({
+        context: "openai-compatible embedding provider",
+        url,
+        dimension: opts.dimension,
+        fetchImpl: opts.fetchImpl,
+        headers: {
+          ...opts.apiKey ? { authorization: `Bearer ${opts.apiKey}` } : {},
+          ...opts.headers
+        },
+        body: {
+          model: opts.model,
+          input: texts
+        },
+        parser: parseOpenAIResponse
+      });
+    },
+    async healthcheck() {
+      await this.embed(["healthcheck"]);
+    }
+  };
+}
+function createLocalHttpEmbeddingProvider(opts) {
+  const url = resolveEndpoint(opts.baseUrl, opts.endpoint);
+  const providerDescriptor = `${trimTrailingSlashes(opts.baseUrl)}|${opts.model}|${opts.dimension}`;
+  const id = stableProviderId(`local-http:${opts.model}`, providerDescriptor);
+  return {
+    id,
+    model: opts.model,
+    dimension: opts.dimension,
+    async embed(texts) {
+      if (texts.length === 0) return [];
+      return runEmbeddingRequest({
+        context: "local-http embedding provider",
+        url,
+        dimension: opts.dimension,
+        fetchImpl: opts.fetchImpl,
+        headers: opts.headers,
+        body: {
+          model: opts.model,
+          input: texts
+        },
+        parser: parseLocalHttpResponse
+      });
+    },
+    async healthcheck() {
+      await this.embed(["healthcheck"]);
+    }
+  };
+}
+function normalizeEmbeddingBaseUrl(baseUrl) {
+  return trimTrailingSlashes(baseUrl);
+}
+
+// src/search/providers.ts
+function parseDimension(raw) {
+  if (!raw) return void 0;
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function parseProvider(raw) {
+  if (!raw) return null;
+  if (raw === "openai-compatible" || raw === "local-http") {
+    return raw;
+  }
+  throw new Error(`Unsupported embedding provider: ${raw}`);
+}
+function getEmbeddingProviderConfigFromEnv(env = process.env) {
+  const provider = parseProvider(env.AGENT_MEMORY_EMBEDDING_PROVIDER);
+  if (!provider) return null;
+  const baseUrl = env.AGENT_MEMORY_EMBEDDING_BASE_URL;
+  const model = env.AGENT_MEMORY_EMBEDDING_MODEL;
+  const dimension = parseDimension(env.AGENT_MEMORY_EMBEDDING_DIMENSION);
+  if (!baseUrl) {
+    throw new Error("AGENT_MEMORY_EMBEDDING_BASE_URL is required when embeddings are enabled");
+  }
+  if (!model) {
+    throw new Error("AGENT_MEMORY_EMBEDDING_MODEL is required when embeddings are enabled");
+  }
+  if (!dimension) {
+    throw new Error("AGENT_MEMORY_EMBEDDING_DIMENSION is required when embeddings are enabled");
+  }
+  if (provider === "openai-compatible" && !env.AGENT_MEMORY_EMBEDDING_API_KEY) {
+    throw new Error("AGENT_MEMORY_EMBEDDING_API_KEY is required for openai-compatible providers");
+  }
+  return {
+    provider,
+    baseUrl,
+    model,
+    dimension,
+    apiKey: env.AGENT_MEMORY_EMBEDDING_API_KEY
+  };
+}
+function createEmbeddingProvider(input, opts) {
+  const normalized = {
+    ...input,
+    baseUrl: normalizeEmbeddingBaseUrl(input.baseUrl)
+  };
+  if (normalized.provider === "openai-compatible") {
+    return createOpenAICompatibleEmbeddingProvider({
+      baseUrl: normalized.baseUrl,
+      model: normalized.model,
+      dimension: normalized.dimension,
+      apiKey: normalized.apiKey,
+      fetchImpl: opts?.fetchImpl
+    });
+  }
+  return createLocalHttpEmbeddingProvider({
+    baseUrl: normalized.baseUrl,
+    model: normalized.model,
+    dimension: normalized.dimension,
+    fetchImpl: opts?.fetchImpl
+  });
+}
+function resolveEmbeddingProviderConfig(opts) {
+  const envConfig = getEmbeddingProviderConfigFromEnv(opts?.env);
+  if (!envConfig && !opts?.config?.provider) {
+    return null;
+  }
+  const provider = opts?.config?.provider ?? envConfig?.provider;
+  const baseUrl = opts?.config?.baseUrl ?? envConfig?.baseUrl;
+  const model = opts?.config?.model ?? envConfig?.model;
+  const dimension = opts?.config?.dimension ?? envConfig?.dimension;
+  const apiKey = opts?.config?.apiKey ?? envConfig?.apiKey;
+  if (!provider || !baseUrl || !model || !dimension) {
+    throw new Error("Incomplete embedding provider configuration");
+  }
+  if (provider === "openai-compatible" && !apiKey) {
+    throw new Error("OpenAI-compatible embedding providers require an API key");
+  }
+  return { provider, baseUrl, model, dimension, apiKey };
+}
+function getEmbeddingProvider(opts) {
+  const config = resolveEmbeddingProviderConfig({ config: opts?.config, env: opts?.env });
+  if (!config) return null;
+  return createEmbeddingProvider(config, { fetchImpl: opts?.fetchImpl });
+}
+function getEmbeddingProviderFromEnv(env = process.env) {
+  try {
+    return getEmbeddingProvider({ env });
+  } catch {
+    return null;
+  }
+}
+function getConfiguredEmbeddingProviderId(opts) {
+  try {
+    const provider = getEmbeddingProvider({ config: opts?.config, env: opts?.env });
+    return provider?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/search/vector.ts
+function encodeVector(vector) {
+  const float32 = vector instanceof Float32Array ? vector : Float32Array.from(vector);
+  return Buffer.from(float32.buffer.slice(float32.byteOffset, float32.byteOffset + float32.byteLength));
+}
+function decodeVector(blob) {
+  const buffer = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+  const aligned = buffer.byteOffset === 0 && buffer.byteLength === buffer.buffer.byteLength ? buffer.buffer : buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  return Array.from(new Float32Array(aligned));
+}
+function cosineSimilarity(a, b) {
+  const length = Math.min(a.length, b.length);
+  if (length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < length; index++) {
+    const left = Number(a[index] ?? 0);
+    const right = Number(b[index] ?? 0);
+    dot += left * right;
+    normA += left * left;
+    normB += right * right;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function markMemoryEmbeddingPending(db, memoryId, providerId, contentHash2) {
+  db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, NULL, ?, 'pending', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = NULL,
+       content_hash = excluded.content_hash,
+       status = 'pending'`
+  ).run(newId(), memoryId, providerId, contentHash2, now());
+}
+function markAllEmbeddingsPending(db, memoryId, contentHash2) {
+  const result = db.prepare(
+    `UPDATE embeddings
+     SET vector = NULL,
+         content_hash = ?,
+         status = 'pending'
+     WHERE memory_id = ?`
+  ).run(contentHash2, memoryId);
+  return result.changes;
+}
+function upsertReadyEmbedding(input) {
+  input.db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, ?, ?, 'ready', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = excluded.vector,
+       content_hash = excluded.content_hash,
+       status = 'ready'`
+  ).run(newId(), input.memoryId, input.providerId, encodeVector(input.vector), input.contentHash, now());
+}
+function markEmbeddingFailed(db, memoryId, providerId, contentHash2) {
+  db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, NULL, ?, 'failed', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = NULL,
+       content_hash = excluded.content_hash,
+       status = 'failed'`
+  ).run(newId(), memoryId, providerId, contentHash2, now());
+}
+function searchByVector(db, queryVector, opts) {
+  const limit = opts.limit ?? 20;
+  const agentId = opts.agent_id ?? "default";
+  const minVitality = opts.min_vitality ?? 0;
+  const rows = db.prepare(
+    `SELECT e.provider_id, e.vector, e.content_hash,
+            m.id, m.content, m.type, m.priority, m.emotion_val, m.vitality,
+            m.stability, m.access_count, m.last_accessed, m.created_at,
+            m.updated_at, m.source, m.agent_id, m.hash
+     FROM embeddings e
+     JOIN memories m ON m.id = e.memory_id
+     WHERE e.provider_id = ?
+       AND e.status = 'ready'
+       AND e.vector IS NOT NULL
+       AND e.content_hash = m.hash
+       AND m.agent_id = ?
+       AND m.vitality >= ?`
+  ).all(opts.providerId, agentId, minVitality);
+  const scored = rows.map((row) => ({
+    provider_id: row.provider_id,
+    memory: {
+      id: row.id,
+      content: row.content,
+      type: row.type,
+      priority: row.priority,
+      emotion_val: row.emotion_val,
+      vitality: row.vitality,
+      stability: row.stability,
+      access_count: row.access_count,
+      last_accessed: row.last_accessed,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      source: row.source,
+      agent_id: row.agent_id,
+      hash: row.hash
+    },
+    similarity: cosineSimilarity(queryVector, decodeVector(row.vector))
+  })).filter((row) => Number.isFinite(row.similarity) && row.similarity > 0).sort((left, right) => right.similarity - left.similarity).slice(0, limit);
+  return scored.map((row, index) => ({
+    memory: row.memory,
+    similarity: row.similarity,
+    rank: index + 1,
+    provider_id: row.provider_id
+  }));
+}
+
 // src/core/memory.ts
 function contentHash(content) {
-  return createHash("sha256").update(content.trim()).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(content.trim()).digest("hex").slice(0, 16);
 }
 var TYPE_PRIORITY = {
   identity: 0,
@@ -388,6 +883,19 @@ var PRIORITY_STABILITY = {
   3: 14
   // P3: 14-day half-life
 };
+function resolveEmbeddingProviderId(explicitProviderId) {
+  if (explicitProviderId !== void 0) {
+    return explicitProviderId;
+  }
+  return getConfiguredEmbeddingProviderId();
+}
+function markEmbeddingDirtyIfNeeded(db, memoryId, hash, providerId) {
+  if (!providerId) return;
+  try {
+    markMemoryEmbeddingPending(db, memoryId, providerId, hash);
+  } catch {
+  }
+}
 function createMemory(db, input) {
   const hash = contentHash(input.content);
   const agentId = input.agent_id ?? "default";
@@ -417,6 +925,7 @@ function createMemory(db, input) {
     hash
   );
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
+  markEmbeddingDirtyIfNeeded(db, id, hash, resolveEmbeddingProviderId(input.embedding_provider_id));
   return getMemory(db, id);
 }
 function getMemory(db, id) {
@@ -427,9 +936,11 @@ function updateMemory(db, id, input) {
   if (!existing) return null;
   const fields = [];
   const values = [];
+  let nextHash = null;
   if (input.content !== void 0) {
+    nextHash = contentHash(input.content);
     fields.push("content = ?", "hash = ?");
-    values.push(input.content, contentHash(input.content));
+    values.push(input.content, nextHash);
   }
   if (input.type !== void 0) {
     fields.push("type = ?");
@@ -462,6 +973,13 @@ function updateMemory(db, id, input) {
   if (input.content !== void 0) {
     db.prepare("DELETE FROM memories_fts WHERE id = ?").run(id);
     db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
+    if (nextHash) {
+      try {
+        markAllEmbeddingsPending(db, id, nextHash);
+      } catch {
+      }
+      markEmbeddingDirtyIfNeeded(db, id, nextHash, resolveEmbeddingProviderId(input.embedding_provider_id));
+    }
   }
   return getMemory(db, id);
 }
@@ -577,144 +1095,98 @@ function exportMemories(db, dirPath, opts) {
   return { exported, files };
 }
 
-// src/search/intent.ts
-var INTENT_PATTERNS = {
-  factual: [
-    // English
-    /^(what|who|where|which|how much|how many)\b/i,
-    /\b(name|address|number|password|config|setting)\b/i,
-    // Chinese - questions about facts
-    /是(什么|谁|哪|啥)/,
-    /叫(什么|啥)/,
-    /(名字|地址|号码|密码|配置|设置|账号|邮箱|链接|版本)/,
-    /(多少|几个|哪个|哪些|哪里)/,
-    // Chinese - lookup patterns
-    /(查一下|找一下|看看|搜一下)/,
-    /(.+)是什么$/
-  ],
-  temporal: [
-    // English
-    /^(when|what time|how long)\b/i,
-    /\b(yesterday|today|tomorrow|last week|recently|ago|before|after)\b/i,
-    /\b(first|latest|newest|oldest|previous|next)\b/i,
-    // Chinese - time expressions
-    /什么时候/,
-    /(昨天|今天|明天|上周|下周|最近|以前|之前|之后|刚才|刚刚)/,
-    /(几月|几号|几点|多久|多长时间)/,
-    /(上次|下次|第一次|最后一次|那天|那时)/,
-    // Date patterns
-    /\d{4}[-/.]\d{1,2}/,
-    /\d{1,2}月\d{1,2}[日号]/,
-    // Chinese - temporal context
-    /(历史|记录|日志|以来|至今|期间)/
-  ],
-  causal: [
-    // English
-    /^(why|how come|what caused)\b/i,
-    /\b(because|due to|reason|cause|result)\b/i,
-    // Chinese - causal questions
-    /为(什么|啥|何)/,
-    /(原因|导致|造成|引起|因为|所以|结果)/,
-    /(怎么回事|怎么了|咋回事|咋了)/,
-    /(为啥|凭啥|凭什么)/,
-    // Chinese - problem/diagnosis
-    /(出(了|了什么)?问题|报错|失败|出错|bug)/
-  ],
-  exploratory: [
-    // English
-    /^(how|tell me about|explain|describe|show me)\b/i,
-    /^(what do you think|what about|any)\b/i,
-    /\b(overview|summary|list|compare)\b/i,
-    // Chinese - exploratory
-    /(怎么样|怎样|如何)/,
-    /(介绍|说说|讲讲|聊聊|谈谈)/,
-    /(有哪些|有什么|有没有)/,
-    /(关于|对于|至于|关联)/,
-    /(总结|概括|梳理|回顾|盘点)/,
-    // Chinese - opinion/analysis
-    /(看法|想法|意见|建议|评价|感觉|觉得)/,
-    /(对比|比较|区别|差异|优缺点)/
-  ]
-};
-var CN_STRUCTURE_BOOSTS = {
-  factual: [/^.{1,6}(是什么|叫什么|在哪)/, /^(谁|哪)/],
-  temporal: [/^(什么时候|上次|最近)/, /(时间|日期)$/],
-  causal: [/^(为什么|为啥)/, /(为什么|怎么回事)$/],
-  exploratory: [/^(怎么|如何|说说)/, /(哪些|什么样)$/]
-};
-function classifyIntent(query) {
-  const scores = {
-    factual: 0,
-    exploratory: 0,
-    temporal: 0,
-    causal: 0
-  };
-  for (const [intent, patterns] of Object.entries(INTENT_PATTERNS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 1;
-      }
-    }
+// src/core/path.ts
+var DEFAULT_DOMAINS = /* @__PURE__ */ new Set(["core", "emotion", "knowledge", "event", "system"]);
+function parseUri(uri) {
+  const match = uri.match(/^([a-z]+):\/\/(.+)$/);
+  if (!match) throw new Error(`Invalid URI: ${uri}. Expected format: domain://path`);
+  return { domain: match[1], path: match[2] };
+}
+function createPath(db, memoryId, uri, alias, validDomains, agent_id) {
+  const { domain } = parseUri(uri);
+  const domains = validDomains ?? DEFAULT_DOMAINS;
+  if (!domains.has(domain)) {
+    throw new Error(`Invalid domain "${domain}". Valid: ${[...domains].join(", ")}`);
   }
-  for (const [intent, patterns] of Object.entries(CN_STRUCTURE_BOOSTS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 0.5;
-      }
-    }
+  const memoryAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id;
+  if (!memoryAgent) throw new Error(`Memory not found: ${memoryId}`);
+  if (agent_id && agent_id !== memoryAgent) {
+    throw new Error(`Agent mismatch for path: memory agent_id=${memoryAgent}, requested agent_id=${agent_id}`);
   }
-  const tokens = tokenize(query);
-  const totalPatternScore = Object.values(scores).reduce((a, b) => a + b, 0);
-  if (totalPatternScore === 0 && tokens.length <= 3) {
-    scores.factual += 1;
-  }
-  let maxIntent = "factual";
-  let maxScore = 0;
-  for (const [intent, score] of Object.entries(scores)) {
-    if (score > maxScore) {
-      maxScore = score;
-      maxIntent = intent;
-    }
+  const agentId = agent_id ?? memoryAgent;
+  const existing = db.prepare("SELECT id FROM paths WHERE agent_id = ? AND uri = ?").get(agentId, uri);
+  if (existing) {
+    throw new Error(`URI already exists: ${uri}`);
   }
-  const totalScore = Object.values(scores).reduce((a, b) => a + b, 0);
-  const confidence = totalScore > 0 ? Math.min(0.95, maxScore / totalScore) : 0.5;
-  return { intent: maxIntent, confidence };
+  const id = newId();
+  db.prepare(
+    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(id, memoryId, agentId, uri, alias ?? null, domain, now());
+  return getPath(db, id);
 }
-function getStrategy(intent) {
-  switch (intent) {
-    case "factual":
-      return { boostRecent: false, boostPriority: true, limit: 5 };
-    case "temporal":
-      return { boostRecent: true, boostPriority: false, limit: 10 };
-    case "causal":
-      return { boostRecent: false, boostPriority: false, limit: 10 };
-    case "exploratory":
-      return { boostRecent: false, boostPriority: false, limit: 15 };
-  }
+function getPath(db, id) {
+  return db.prepare("SELECT * FROM paths WHERE id = ?").get(id) ?? null;
+}
+function getPathByUri(db, uri, agent_id = "default") {
+  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri = ?").get(agent_id, uri) ?? null;
 }
 
-// src/search/rerank.ts
-function rerank(results, opts) {
-  const now2 = Date.now();
-  const scored = results.map((r) => {
-    let finalScore = r.score;
-    if (opts.boostPriority) {
-      const priorityMultiplier = [4, 3, 2, 1][r.memory.priority] ?? 1;
-      finalScore *= priorityMultiplier;
+// src/sleep/boot.ts
+function boot(db, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  const corePaths = opts?.corePaths ?? [
+    "core://agent",
+    "core://user",
+    "core://agent/identity",
+    "core://user/identity"
+  ];
+  const memories = /* @__PURE__ */ new Map();
+  const identities = listMemories(db, { agent_id: agentId, priority: 0 });
+  for (const mem of identities) {
+    memories.set(mem.id, mem);
+    recordAccess(db, mem.id, 1.1);
+  }
+  const bootPaths = [];
+  for (const uri of corePaths) {
+    const path = getPathByUri(db, uri, agentId);
+    if (path) {
+      bootPaths.push(uri);
+      if (!memories.has(path.memory_id)) {
+        const mem = getMemory(db, path.memory_id);
+        if (mem) {
+          memories.set(mem.id, mem);
+          recordAccess(db, mem.id, 1.1);
+        }
+      }
     }
-    if (opts.boostRecent && r.memory.updated_at) {
-      const age = now2 - new Date(r.memory.updated_at).getTime();
-      const daysSinceUpdate = age / (1e3 * 60 * 60 * 24);
-      const recencyBoost = Math.max(0.1, 1 / (1 + daysSinceUpdate * 0.1));
-      finalScore *= recencyBoost;
+  }
+  const bootEntry = getPathByUri(db, "system://boot", agentId);
+  if (bootEntry) {
+    const bootMem = getMemory(db, bootEntry.memory_id);
+    if (bootMem) {
+      const additionalUris = bootMem.content.split("\n").map((l) => l.trim()).filter((l) => l.match(/^[a-z]+:\/\//));
+      for (const uri of additionalUris) {
+        const path = getPathByUri(db, uri, agentId);
+        if (path && !memories.has(path.memory_id)) {
+          const mem = getMemory(db, path.memory_id);
+          if (mem) {
+            memories.set(mem.id, mem);
+            bootPaths.push(uri);
+          }
+        }
+      }
     }
-    finalScore *= Math.max(0.1, r.memory.vitality);
-    return { ...r, score: finalScore };
-  });
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, opts.limit);
+  }
+  return {
+    identityMemories: [...memories.values()],
+    bootPaths
+  };
 }
 
+// src/transports/http.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import http from "http";
+
 // src/search/bm25.ts
 function searchBM25(db, query, opts) {
   const limit = opts?.limit ?? 20;
@@ -733,12 +1205,13 @@ function searchBM25(db, query, opts) {
          ORDER BY rank
          LIMIT ?`
     ).all(ftsQuery, agentId, minVitality, limit);
-    return rows.map((row) => {
+    return rows.map((row, index) => {
       const { score: _score, ...memoryFields } = row;
       return {
         memory: memoryFields,
         score: Math.abs(row.score),
         // FTS5 rank is negative (lower = better)
+        rank: index + 1,
         matchReason: "bm25"
       };
     });
@@ -753,10 +1226,10 @@ function searchSimple(db, query, agentId, minVitality, limit) {
        ORDER BY priority ASC, updated_at DESC
        LIMIT ?`
   ).all(agentId, minVitality, `%${query}%`, limit);
-  return rows.map((m, i) => ({
-    memory: m,
-    score: 1 / (i + 1),
-    // Simple rank by position
+  return rows.map((memory, index) => ({
+    memory,
+    score: 1 / (index + 1),
+    rank: index + 1,
     matchReason: "like"
   }));
 }
@@ -765,381 +1238,923 @@ function buildFtsQuery(text) {
   if (tokens.length === 0) return null;
   return tokens.map((w) => `"${w}"`).join(" OR ");
 }
+function rebuildBm25Index(db, opts) {
+  const memories = opts?.agent_id ? db.prepare("SELECT id, content FROM memories WHERE agent_id = ?").all(opts.agent_id) : db.prepare("SELECT id, content FROM memories").all();
+  const insert = db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)");
+  const deleteOne = db.prepare("DELETE FROM memories_fts WHERE id = ?");
+  const transaction = db.transaction(() => {
+    if (!opts?.agent_id) {
+      db.exec("DELETE FROM memories_fts");
+    }
+    for (const memory of memories) {
+      if (opts?.agent_id) {
+        deleteOne.run(memory.id);
+      }
+      insert.run(memory.id, tokenizeForIndex(memory.content));
+    }
+  });
+  transaction();
+  return { reindexed: memories.length };
+}
 
-// src/search/embeddings.ts
-function encodeEmbedding(vector) {
-  const arr = vector instanceof Float32Array ? vector : Float32Array.from(vector);
-  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function decodeEmbedding(buf) {
-  const copy = Buffer.from(buf);
-  return new Float32Array(copy.buffer, copy.byteOffset, Math.floor(copy.byteLength / 4));
-}
-function upsertEmbedding(db, input) {
-  const ts = now();
-  const vec = input.vector instanceof Float32Array ? input.vector : Float32Array.from(input.vector);
-  const blob = encodeEmbedding(vec);
-  db.prepare(
-    `INSERT INTO embeddings (agent_id, memory_id, model, dim, vector, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(agent_id, memory_id, model) DO UPDATE SET
-       dim = excluded.dim,
-       vector = excluded.vector,
-       updated_at = excluded.updated_at`
-  ).run(input.agent_id, input.memory_id, input.model, vec.length, blob, ts, ts);
+// src/search/hybrid.ts
+var PRIORITY_WEIGHT = {
+  0: 4,
+  1: 3,
+  2: 2,
+  3: 1
+};
+var PRIORITY_PRIOR = {
+  0: 1,
+  1: 0.75,
+  2: 0.5,
+  3: 0.25
+};
+function scoreBm25Only(results, limit) {
+  return results.map((row) => {
+    const weight = PRIORITY_WEIGHT[row.memory.priority] ?? 1;
+    const vitality = Math.max(0.1, row.memory.vitality);
+    return {
+      memory: row.memory,
+      score: row.score * weight * vitality,
+      bm25_rank: row.rank,
+      bm25_score: row.score
+    };
+  }).sort((left, right) => right.score - left.score).slice(0, limit);
+}
+function priorityPrior(priority) {
+  return PRIORITY_PRIOR[priority] ?? 0.25;
+}
+function fusionScore(input) {
+  const lexical = input.bm25Rank ? 0.45 / (60 + input.bm25Rank) : 0;
+  const semantic = input.vectorRank ? 0.45 / (60 + input.vectorRank) : 0;
+  return lexical + semantic + 0.05 * priorityPrior(input.memory.priority) + 0.05 * input.memory.vitality;
+}
+function fuseHybridResults(lexical, vector, limit) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of lexical) {
+    candidates.set(row.memory.id, {
+      memory: row.memory,
+      score: 0,
+      bm25_rank: row.rank,
+      bm25_score: row.score
+    });
+  }
+  for (const row of vector) {
+    const existing = candidates.get(row.memory.id);
+    if (existing) {
+      existing.vector_rank = row.rank;
+      existing.vector_score = row.similarity;
+    } else {
+      candidates.set(row.memory.id, {
+        memory: row.memory,
+        score: 0,
+        vector_rank: row.rank,
+        vector_score: row.similarity
+      });
+    }
+  }
+  return [...candidates.values()].map((row) => ({
+    ...row,
+    score: fusionScore({ memory: row.memory, bm25Rank: row.bm25_rank, vectorRank: row.vector_rank })
+  })).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return right.memory.updated_at.localeCompare(left.memory.updated_at);
+  }).slice(0, limit);
+}
+async function searchVectorBranch(db, query, opts) {
+  const [queryVector] = await opts.provider.embed([query]);
+  if (!queryVector) return [];
+  return searchByVector(db, queryVector, {
+    providerId: opts.provider.id,
+    agent_id: opts.agent_id,
+    limit: opts.limit,
+    min_vitality: opts.min_vitality
+  });
+}
+async function recallMemories(db, query, opts) {
+  const limit = opts?.limit ?? 10;
+  const agentId = opts?.agent_id ?? "default";
+  const minVitality = opts?.min_vitality ?? 0;
+  const lexicalLimit = opts?.lexicalLimit ?? Math.max(limit * 2, limit);
+  const vectorLimit = opts?.vectorLimit ?? Math.max(limit * 2, limit);
+  const provider = opts?.provider === void 0 ? getEmbeddingProviderFromEnv() : opts.provider;
+  const lexical = searchBM25(db, query, {
+    agent_id: agentId,
+    limit: lexicalLimit,
+    min_vitality: minVitality
+  });
+  let vector = [];
+  if (provider) {
+    try {
+      vector = await searchVectorBranch(db, query, {
+        provider,
+        agent_id: agentId,
+        limit: vectorLimit,
+        min_vitality: minVitality
+      });
+    } catch {
+      vector = [];
+    }
+  }
+  const mode = vector.length > 0 && lexical.length > 0 ? "dual-path" : vector.length > 0 ? "vector-only" : "bm25-only";
+  const results = mode === "bm25-only" ? scoreBm25Only(lexical, limit) : fuseHybridResults(lexical, vector, limit);
+  if (opts?.recordAccess !== false) {
+    for (const row of results) {
+      recordAccess(db, row.memory.id);
+    }
+  }
+  return {
+    mode,
+    providerId: provider?.id ?? null,
+    usedVectorSearch: vector.length > 0,
+    results
+  };
 }
-function listEmbeddings(db, agent_id, model) {
+function listReindexCandidates(db, providerId, agentId, force) {
   const rows = db.prepare(
-    "SELECT memory_id, vector FROM embeddings WHERE agent_id = ? AND model = ?"
-  ).all(agent_id, model);
-  return rows.map((r) => ({ memory_id: r.memory_id, vector: decodeEmbedding(r.vector) }));
+    `SELECT m.id as memoryId,
+            m.content as content,
+            m.hash as contentHash,
+            e.status as embeddingStatus,
+            e.content_hash as embeddingHash
+     FROM memories m
+     LEFT JOIN embeddings e
+       ON e.memory_id = m.id
+      AND e.provider_id = ?
+     WHERE m.agent_id = ?
+       AND m.hash IS NOT NULL`
+  ).all(providerId, agentId);
+  return rows.filter((row) => {
+    if (force) return true;
+    if (!row.embeddingStatus) return true;
+    if (row.embeddingStatus !== "ready") return true;
+    return row.embeddingHash !== row.contentHash;
+  }).map((row) => ({
+    memoryId: row.memoryId,
+    content: row.content,
+    contentHash: row.contentHash
+  }));
 }
-
-// src/search/hybrid.ts
-function cosine(a, b) {
-  const n = Math.min(a.length, b.length);
-  let dot = 0;
-  let na = 0;
-  let nb = 0;
-  for (let i = 0; i < n; i++) {
-    const x = a[i];
-    const y = b[i];
-    dot += x * y;
-    na += x * x;
-    nb += y * y;
-  }
-  if (na === 0 || nb === 0) return 0;
-  return dot / (Math.sqrt(na) * Math.sqrt(nb));
-}
-function rrfScore(rank, k) {
-  return 1 / (k + rank);
-}
-function fuseRrf(lists, k) {
-  const out = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    for (let i = 0; i < list.items.length; i++) {
-      const it = list.items[i];
-      const rank = i + 1;
-      const add = rrfScore(rank, k);
-      const prev = out.get(it.id);
-      if (!prev) out.set(it.id, { score: add, sources: [list.name] });
-      else {
-        prev.score += add;
-        if (!prev.sources.includes(list.name)) prev.sources.push(list.name);
+async function reindexEmbeddings(db, opts) {
+  const provider = opts?.provider === void 0 ? getEmbeddingProviderFromEnv() : opts.provider;
+  if (!provider) {
+    return {
+      enabled: false,
+      providerId: null,
+      scanned: 0,
+      pending: 0,
+      embedded: 0,
+      failed: 0
+    };
+  }
+  const agentId = opts?.agent_id ?? "default";
+  const force = opts?.force ?? false;
+  const batchSize = Math.max(1, opts?.batchSize ?? 16);
+  const candidates = listReindexCandidates(db, provider.id, agentId, force);
+  for (const candidate of candidates) {
+    markMemoryEmbeddingPending(db, candidate.memoryId, provider.id, candidate.contentHash);
+  }
+  let embedded = 0;
+  let failed = 0;
+  for (let index = 0; index < candidates.length; index += batchSize) {
+    const batch = candidates.slice(index, index + batchSize);
+    try {
+      const vectors = await provider.embed(batch.map((row) => row.content));
+      if (vectors.length !== batch.length) {
+        throw new Error(`Expected ${batch.length} embeddings, received ${vectors.length}`);
+      }
+      for (let offset = 0; offset < batch.length; offset++) {
+        upsertReadyEmbedding({
+          db,
+          memoryId: batch[offset].memoryId,
+          providerId: provider.id,
+          vector: vectors[offset],
+          contentHash: batch[offset].contentHash
+        });
+        embedded += 1;
+      }
+    } catch {
+      for (const candidate of batch) {
+        markEmbeddingFailed(db, candidate.memoryId, provider.id, candidate.contentHash);
+        failed += 1;
       }
     }
   }
-  return out;
+  return {
+    enabled: true,
+    providerId: provider.id,
+    scanned: candidates.length,
+    pending: candidates.length,
+    embedded,
+    failed
+  };
 }
-function fetchMemories(db, ids, agentId) {
-  if (ids.length === 0) return [];
-  const placeholders = ids.map(() => "?").join(", ");
-  const sql = agentId ? `SELECT * FROM memories WHERE id IN (${placeholders}) AND agent_id = ?` : `SELECT * FROM memories WHERE id IN (${placeholders})`;
-  const rows = db.prepare(sql).all(...agentId ? [...ids, agentId] : ids);
-  return rows;
+
+// src/core/merge.ts
+function uniqueNonEmpty(values) {
+  return [...new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value)))];
+}
+function splitClauses(content) {
+  return content.split(/[\n；;。.!?！？]+/).map((part) => part.trim()).filter(Boolean);
+}
+function mergeAliases(existing, incoming, content) {
+  const aliases = uniqueNonEmpty([
+    existing !== content ? existing : void 0,
+    incoming !== content ? incoming : void 0
+  ]);
+  return aliases.length > 0 ? aliases : void 0;
+}
+function replaceIdentity(context) {
+  const content = context.incoming.content.trim();
+  return {
+    strategy: "replace",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["identity canonicalized to the newest authoritative phrasing"]
+  };
 }
-async function searchHybrid(db, query, opts) {
-  const agentId = opts?.agent_id ?? "default";
-  const limit = opts?.limit ?? 10;
-  const bm25Mult = opts?.bm25CandidateMultiplier ?? 3;
-  const semanticCandidates = opts?.semanticCandidates ?? 50;
-  const rrfK = opts?.rrfK ?? 60;
-  const bm25 = searchBM25(db, query, {
-    agent_id: agentId,
-    limit: limit * bm25Mult
-  });
-  const provider = opts?.embeddingProvider ?? null;
-  const model = opts?.embeddingModel ?? provider?.model;
-  if (!provider || !model) {
-    return bm25.slice(0, limit);
-  }
-  const embedFn = provider.embedQuery ?? provider.embed;
-  const qVec = Float32Array.from(await embedFn.call(provider, query));
-  const embeddings = listEmbeddings(db, agentId, model);
-  const scored = [];
-  for (const e of embeddings) {
-    scored.push({ id: e.memory_id, score: cosine(qVec, e.vector) });
-  }
-  scored.sort((a, b) => b.score - a.score);
-  const semanticTop = scored.slice(0, semanticCandidates);
-  const fused = fuseRrf(
-    [
-      { name: "bm25", items: bm25.map((r) => ({ id: r.memory.id, score: r.score })) },
-      { name: "semantic", items: semanticTop }
-    ],
-    rrfK
-  );
-  const ids = [...fused.keys()];
-  const memories = fetchMemories(db, ids, agentId);
-  const byId = new Map(memories.map((m) => [m.id, m]));
-  const out = [];
-  for (const [id, meta] of fused) {
-    const mem = byId.get(id);
-    if (!mem) continue;
-    out.push({
-      memory: mem,
-      score: meta.score,
-      matchReason: meta.sources.sort().join("+")
-    });
+function appendEmotionEvidence(context) {
+  const lines = uniqueNonEmpty([
+    ...context.existing.content.split(/\n+/),
+    context.incoming.content
+  ]);
+  const content = lines.length <= 1 ? lines[0] ?? context.incoming.content.trim() : [lines[0], "", ...lines.slice(1).map((line) => `- ${line.replace(/^-\s*/, "")}`)].join("\n");
+  return {
+    strategy: "append_evidence",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["emotion evidence appended to preserve timeline without duplicating identical lines"]
+  };
+}
+function synthesizeKnowledge(context) {
+  const clauses = uniqueNonEmpty([
+    ...splitClauses(context.existing.content),
+    ...splitClauses(context.incoming.content)
+  ]);
+  const content = clauses.length <= 1 ? clauses[0] ?? context.incoming.content.trim() : clauses.join("\uFF1B");
+  return {
+    strategy: "synthesize",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["knowledge statements synthesized into a canonical summary"]
+  };
+}
+function compactEventTimeline(context) {
+  const points = uniqueNonEmpty([
+    ...context.existing.content.split(/\n+/),
+    context.incoming.content
+  ]).map((line) => line.replace(/^-\s*/, ""));
+  const content = points.length <= 1 ? points[0] ?? context.incoming.content.trim() : ["Timeline:", ...points.map((line) => `- ${line}`)].join("\n");
+  return {
+    strategy: "compact_timeline",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["event observations compacted into a single timeline window"]
+  };
+}
+function buildMergePlan(context) {
+  const type = context.incoming.type ?? context.existing.type;
+  switch (type) {
+    case "identity":
+      return replaceIdentity(context);
+    case "emotion":
+      return appendEmotionEvidence(context);
+    case "knowledge":
+      return synthesizeKnowledge(context);
+    case "event":
+      return compactEventTimeline(context);
   }
-  out.sort((a, b) => b.score - a.score);
-  return out.slice(0, limit);
 }
 
-// src/search/providers.ts
-var QWEN_DEFAULT_INSTRUCTION = "Given a query, retrieve the most semantically relevant document";
-function getDefaultInstruction(model) {
-  const m = model.toLowerCase();
-  if (m.includes("qwen")) return QWEN_DEFAULT_INSTRUCTION;
-  if (m.includes("gemini")) return null;
-  return null;
+// src/core/guard.ts
+var NEAR_EXACT_THRESHOLD = 0.93;
+var MERGE_THRESHOLD = 0.82;
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function uniqueTokenSet(text) {
+  return new Set(tokenize(text));
+}
+function overlapScore(left, right) {
+  const a = new Set(left);
+  const b = new Set(right);
+  if (a.size === 0 || b.size === 0) return 0;
+  let shared = 0;
+  for (const token of a) {
+    if (b.has(token)) shared += 1;
+  }
+  return shared / Math.max(a.size, b.size);
+}
+function extractEntities(text) {
+  const matches = text.match(/[A-Z][A-Za-z0-9_-]+|\d+(?:[-/:]\d+)*|[#@][\w-]+|[\u4e00-\u9fff]{2,}|\w+:\/\/[^\s]+/g) ?? [];
+  return new Set(matches.map((value) => value.trim()).filter(Boolean));
+}
+function safeDomain(uri) {
+  if (!uri) return null;
+  try {
+    return parseUri(uri).domain;
+  } catch {
+    return null;
+  }
 }
-function resolveInstruction(model) {
-  const override = process.env.AGENT_MEMORY_EMBEDDINGS_INSTRUCTION;
-  if (override !== void 0) {
-    const normalized = override.trim();
-    if (!normalized) return null;
-    const lowered = normalized.toLowerCase();
-    if (lowered === "none" || lowered === "off" || lowered === "false" || lowered === "null") return null;
-    return normalized;
-  }
-  return getDefaultInstruction(model);
-}
-function buildQueryInput(query, instructionPrefix) {
-  if (!instructionPrefix) return query;
-  return `Instruct: ${instructionPrefix}
-Query: ${query}`;
-}
-function getEmbeddingProviderFromEnv() {
-  const provider = (process.env.AGENT_MEMORY_EMBEDDINGS_PROVIDER ?? "none").toLowerCase();
-  if (provider === "none" || provider === "off" || provider === "false") return null;
-  if (provider === "openai") {
-    const apiKey = process.env.OPENAI_API_KEY;
-    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "text-embedding-3-small";
-    const baseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
-    if (!apiKey) return null;
-    const instruction = resolveInstruction(model);
-    return createOpenAIProvider({ apiKey, model, baseUrl, instruction });
-  }
-  if (provider === "gemini" || provider === "google") {
-    const apiKey = process.env.GEMINI_API_KEY ?? process.env.OPENAI_API_KEY;
-    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "gemini-embedding-001";
-    const baseUrl = process.env.GEMINI_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta";
-    if (!apiKey) return null;
-    const instruction = resolveInstruction(model);
-    return createOpenAIProvider({ id: "gemini", apiKey, model, baseUrl, instruction });
-  }
-  if (provider === "qwen" || provider === "dashscope" || provider === "tongyi") {
-    const apiKey = process.env.DASHSCOPE_API_KEY;
-    const model = process.env.AGENT_MEMORY_EMBEDDINGS_MODEL ?? "text-embedding-v3";
-    const baseUrl = process.env.DASHSCOPE_BASE_URL ?? "https://dashscope.aliyuncs.com";
-    if (!apiKey) return null;
-    const instruction = resolveInstruction(model);
-    return createDashScopeProvider({ apiKey, model, baseUrl, instruction });
+function getPrimaryUri(db, memoryId, agentId) {
+  const row = db.prepare("SELECT uri FROM paths WHERE memory_id = ? AND agent_id = ? ORDER BY created_at DESC LIMIT 1").get(memoryId, agentId);
+  return row?.uri ?? null;
+}
+function uriScopeMatch(inputUri, candidateUri) {
+  if (inputUri && candidateUri) {
+    if (inputUri === candidateUri) return 1;
+    const inputDomain2 = safeDomain(inputUri);
+    const candidateDomain2 = safeDomain(candidateUri);
+    if (inputDomain2 && candidateDomain2 && inputDomain2 === candidateDomain2) return 0.85;
+    return 0;
+  }
+  if (!inputUri && !candidateUri) {
+    return 0.65;
+  }
+  const inputDomain = safeDomain(inputUri ?? null);
+  const candidateDomain = safeDomain(candidateUri ?? null);
+  if (inputDomain && candidateDomain && inputDomain === candidateDomain) {
+    return 0.75;
+  }
+  return 0.2;
+}
+function extractObservedAt(parts, fallback) {
+  for (const part of parts) {
+    if (!part) continue;
+    const match = part.match(/(20\d{2}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2})?))?/);
+    if (!match) continue;
+    const iso = match[2] ? `${match[1]}T${match[2]}Z` : `${match[1]}T00:00:00Z`;
+    const parsed = new Date(iso);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  if (fallback) {
+    const parsed = new Date(fallback);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
   }
   return null;
 }
-function authHeader(apiKey) {
-  return apiKey.startsWith("Bearer ") ? apiKey : `Bearer ${apiKey}`;
+function timeProximity(input, memory, candidateUri) {
+  if (input.type !== "event") {
+    return 1;
+  }
+  const inputTime = extractObservedAt([input.uri, input.source, input.content], input.now ?? null);
+  const existingTime = extractObservedAt([candidateUri, memory.source, memory.content], memory.created_at);
+  if (!inputTime || !existingTime) {
+    return 0.5;
+  }
+  const diffDays = Math.abs(inputTime.getTime() - existingTime.getTime()) / (1e3 * 60 * 60 * 24);
+  return clamp01(1 - diffDays / 7);
+}
+function scoreCandidate(input, candidate, candidateUri) {
+  const lexicalOverlap = overlapScore(uniqueTokenSet(input.content), uniqueTokenSet(candidate.memory.content));
+  const entityOverlap = Math.max(
+    overlapScore(extractEntities(input.content), extractEntities(candidate.memory.content)),
+    lexicalOverlap * 0.75
+  );
+  const uriMatch = uriScopeMatch(input.uri, candidateUri);
+  const temporal = timeProximity(input, candidate.memory, candidateUri);
+  const semantic = clamp01(candidate.vector_score ?? lexicalOverlap);
+  const dedupScore = clamp01(
+    0.5 * semantic + 0.2 * lexicalOverlap + 0.15 * uriMatch + 0.1 * entityOverlap + 0.05 * temporal
+  );
+  return {
+    semantic_similarity: semantic,
+    lexical_overlap: lexicalOverlap,
+    uri_scope_match: uriMatch,
+    entity_overlap: entityOverlap,
+    time_proximity: temporal,
+    dedup_score: dedupScore
+  };
 }
-function normalizeEmbedding(e) {
-  if (!Array.isArray(e)) throw new Error("Invalid embedding: not an array");
-  if (e.length === 0) throw new Error("Invalid embedding: empty");
-  return e.map((x) => {
-    if (typeof x !== "number" || !Number.isFinite(x)) throw new Error("Invalid embedding: non-numeric value");
-    return x;
+async function recallCandidates(db, input, agentId) {
+  const provider = input.provider === void 0 ? getEmbeddingProviderFromEnv() : input.provider;
+  const response = await recallMemories(db, input.content, {
+    agent_id: agentId,
+    limit: Math.max(6, input.candidateLimit ?? 8),
+    lexicalLimit: Math.max(8, input.candidateLimit ?? 8),
+    vectorLimit: Math.max(8, input.candidateLimit ?? 8),
+    provider,
+    recordAccess: false
   });
+  return response.results.filter((row) => row.memory.type === input.type).map((row) => {
+    const uri = getPrimaryUri(db, row.memory.id, agentId);
+    return {
+      result: row,
+      uri,
+      domain: safeDomain(uri),
+      score: scoreCandidate(input, row, uri)
+    };
+  }).sort((left, right) => right.score.dedup_score - left.score.dedup_score);
 }
-function createOpenAIProvider(opts) {
-  const baseUrl = opts.baseUrl ?? "https://api.openai.com/v1";
-  const instructionPrefix = opts.instruction ?? null;
-  async function requestEmbedding(input) {
-    const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/embeddings`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: authHeader(opts.apiKey)
-      },
-      body: JSON.stringify({ model: opts.model, input })
-    });
-    if (!resp.ok) {
-      const body = await resp.text().catch(() => "");
-      throw new Error(`OpenAI embeddings failed: ${resp.status} ${resp.statusText} ${body}`.trim());
-    }
-    const data = await resp.json();
-    return normalizeEmbedding(data.data?.[0]?.embedding);
-  }
+function fourCriterionGate(input) {
+  const content = input.content.trim();
+  const failed = [];
+  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : input.type === "knowledge" ? 2 : 3);
+  const minLength = priority <= 1 ? 4 : 8;
+  const specificity = content.length >= minLength ? Math.min(1, content.length / 50) : 0;
+  if (specificity === 0) failed.push(`specificity (too short: ${content.length} < ${minLength} chars)`);
+  const tokens = tokenize(content);
+  const novelty = tokens.length >= 1 ? Math.min(1, tokens.length / 5) : 0;
+  if (novelty === 0) failed.push("novelty (no meaningful tokens after filtering)");
+  const hasCJK = /[\u4e00-\u9fff]/.test(content);
+  const hasCapitalized = /[A-Z][a-z]+/.test(content);
+  const hasNumbers = /\d+/.test(content);
+  const hasURI = /\w+:\/\//.test(content);
+  const hasEntityMarkers = /[@#]/.test(content);
+  const hasMeaningfulLength = content.length >= 15;
+  const topicSignals = [hasCJK, hasCapitalized, hasNumbers, hasURI, hasEntityMarkers, hasMeaningfulLength].filter(Boolean).length;
+  const relevance = topicSignals >= 1 ? Math.min(1, topicSignals / 3) : 0;
+  if (relevance === 0) failed.push("relevance (no identifiable topics/entities)");
+  const allCaps = content === content.toUpperCase() && content.length > 20 && /^[A-Z\s]+$/.test(content);
+  const hasWhitespaceOrPunctuation = /[\s，。！？,.!?；;：:]/.test(content) || content.length < 30;
+  const excessiveRepetition = /(.)\1{9,}/.test(content);
+  let coherence = 1;
+  if (allCaps) coherence -= 0.5;
+  if (!hasWhitespaceOrPunctuation) coherence -= 0.3;
+  if (excessiveRepetition) coherence -= 0.5;
+  coherence = Math.max(0, coherence);
+  if (coherence < 0.3) failed.push("coherence (garbled or malformed content)");
   return {
-    id: opts.id ?? "openai",
-    model: opts.model,
-    instructionPrefix,
-    async embed(text) {
-      return requestEmbedding(text);
-    },
-    async embedQuery(query) {
-      return requestEmbedding(buildQueryInput(query, instructionPrefix));
-    }
+    pass: failed.length === 0,
+    scores: { specificity, novelty, relevance, coherence },
+    failedCriteria: failed
   };
 }
-function createDashScopeProvider(opts) {
-  const baseUrl = opts.baseUrl ?? "https://dashscope.aliyuncs.com";
-  const instructionPrefix = opts.instruction ?? null;
-  async function requestEmbedding(text) {
-    const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/api/v1/services/embeddings/text-embedding/text-embedding`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: authHeader(opts.apiKey)
-      },
-      body: JSON.stringify({
-        model: opts.model,
-        input: { texts: [text] }
-      })
-    });
-    if (!resp.ok) {
-      const body = await resp.text().catch(() => "");
-      throw new Error(`DashScope embeddings failed: ${resp.status} ${resp.statusText} ${body}`.trim());
+async function guard(db, input) {
+  const hash = contentHash(input.content);
+  const agentId = input.agent_id ?? "default";
+  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
+  if (exactMatch) {
+    return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
+  }
+  if (input.uri) {
+    const existingPath = getPathByUri(db, input.uri, agentId);
+    if (existingPath) {
+      return {
+        action: "update",
+        reason: `URI ${input.uri} already exists, updating canonical content`,
+        existingId: existingPath.memory_id,
+        updatedContent: input.content
+      };
     }
-    const data = await resp.json();
-    const emb = data.output?.embeddings?.[0]?.embedding ?? data.output?.embeddings?.[0]?.vector ?? data.output?.embedding ?? data.data?.[0]?.embedding;
-    return normalizeEmbedding(emb);
+  }
+  const gateResult = fourCriterionGate(input);
+  if (!gateResult.pass) {
+    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
+  }
+  if (input.conservative) {
+    return { action: "add", reason: "Conservative mode enabled; semantic dedup disabled" };
+  }
+  const candidates = await recallCandidates(db, input, agentId);
+  const best = candidates[0];
+  if (!best) {
+    return { action: "add", reason: "No relevant semantic candidates found" };
+  }
+  const score = best.score;
+  if (score.dedup_score >= NEAR_EXACT_THRESHOLD) {
+    const shouldUpdateMetadata = Boolean(input.uri && !getPathByUri(db, input.uri, agentId));
+    return {
+      action: shouldUpdateMetadata ? "update" : "skip",
+      reason: shouldUpdateMetadata ? `Near-exact duplicate detected (score=${score.dedup_score.toFixed(3)}), updating metadata` : `Near-exact duplicate detected (score=${score.dedup_score.toFixed(3)})`,
+      existingId: best.result.memory.id,
+      score
+    };
+  }
+  if (score.dedup_score >= MERGE_THRESHOLD) {
+    const mergePlan = buildMergePlan({
+      existing: best.result.memory,
+      incoming: {
+        content: input.content,
+        type: input.type,
+        source: input.source
+      }
+    });
+    return {
+      action: "merge",
+      reason: `Semantic near-duplicate detected (score=${score.dedup_score.toFixed(3)}), applying ${mergePlan.strategy}`,
+      existingId: best.result.memory.id,
+      mergedContent: mergePlan.content,
+      mergePlan,
+      score
+    };
   }
   return {
-    id: "dashscope",
-    model: opts.model,
-    instructionPrefix,
-    async embed(text) {
-      return requestEmbedding(text);
-    },
-    async embedQuery(query) {
-      return requestEmbedding(buildQueryInput(query, instructionPrefix));
-    }
+    action: "add",
+    reason: `Semantic score below merge threshold (score=${score.dedup_score.toFixed(3)})`,
+    score
   };
 }
 
-// src/search/embed.ts
-async function embedMemory(db, memoryId, provider, opts) {
-  const row = db.prepare("SELECT id, agent_id, content FROM memories WHERE id = ?").get(memoryId);
-  if (!row) return false;
-  if (opts?.agent_id && row.agent_id !== opts.agent_id) return false;
-  const model = opts?.model ?? provider.model;
-  const maxChars = opts?.maxChars ?? 2e3;
-  const text = row.content.length > maxChars ? row.content.slice(0, maxChars) : row.content;
-  const vector = await provider.embed(text);
-  upsertEmbedding(db, {
-    agent_id: row.agent_id,
-    memory_id: row.id,
-    model,
-    vector
-  });
-  return true;
+// src/sleep/sync.ts
+function ensureUriPath(db, memoryId, uri, agentId) {
+  if (!uri) return;
+  if (getPathByUri(db, uri, agentId ?? "default")) return;
+  try {
+    createPath(db, memoryId, uri, void 0, void 0, agentId);
+  } catch {
+  }
 }
-async function embedMissingForAgent(db, provider, opts) {
-  const agentId = opts?.agent_id ?? "default";
-  const model = opts?.model ?? provider.model;
-  const limit = opts?.limit ?? 1e3;
-  const rows = db.prepare(
-    `SELECT m.id
-     FROM memories m
-     LEFT JOIN embeddings e
-       ON e.memory_id = m.id AND e.agent_id = m.agent_id AND e.model = ?
-     WHERE m.agent_id = ? AND e.memory_id IS NULL
-     ORDER BY m.updated_at DESC
-     LIMIT ?`
-  ).all(model, agentId, limit);
-  let embedded = 0;
-  for (const r of rows) {
-    const ok = await embedMemory(db, r.id, provider, { agent_id: agentId, model, maxChars: opts?.maxChars });
-    if (ok) embedded++;
+async function syncOne(db, input) {
+  const memInput = {
+    content: input.content,
+    type: input.type ?? "event",
+    priority: input.priority,
+    emotion_val: input.emotion_val,
+    source: input.source,
+    agent_id: input.agent_id,
+    uri: input.uri,
+    provider: input.provider,
+    conservative: input.conservative
+  };
+  const guardResult = await guard(db, memInput);
+  switch (guardResult.action) {
+    case "skip":
+      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
+    case "add": {
+      const mem = createMemory(db, memInput);
+      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
+      ensureUriPath(db, mem.id, input.uri, input.agent_id);
+      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+    }
+    case "update": {
+      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
+      if (guardResult.updatedContent !== void 0) {
+        updateMemory(db, guardResult.existingId, { content: guardResult.updatedContent });
+      }
+      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
+      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
+    }
+    case "merge": {
+      if (!guardResult.existingId || !guardResult.mergedContent) {
+        return { action: "skipped", reason: "Missing merge data" };
+      }
+      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
+      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
+      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+    }
   }
-  return { embedded, scanned: rows.length };
 }
 
-// src/core/path.ts
-var DEFAULT_DOMAINS = /* @__PURE__ */ new Set(["core", "emotion", "knowledge", "event", "system"]);
-function parseUri(uri) {
-  const match = uri.match(/^([a-z]+):\/\/(.+)$/);
-  if (!match) throw new Error(`Invalid URI: ${uri}. Expected format: domain://path`);
-  return { domain: match[1], path: match[2] };
+// src/app/remember.ts
+async function rememberMemory(db, input) {
+  return syncOne(db, {
+    content: input.content,
+    type: input.type,
+    priority: input.priority,
+    emotion_val: input.emotion_val,
+    uri: input.uri,
+    source: input.source,
+    agent_id: input.agent_id,
+    provider: input.provider,
+    conservative: input.conservative
+  });
 }
-function createPath(db, memoryId, uri, alias, validDomains, agent_id) {
-  const { domain } = parseUri(uri);
-  const domains = validDomains ?? DEFAULT_DOMAINS;
-  if (!domains.has(domain)) {
-    throw new Error(`Invalid domain "${domain}". Valid: ${[...domains].join(", ")}`);
+
+// src/app/recall.ts
+async function recallMemory(db, input) {
+  return recallMemories(db, input.query, {
+    agent_id: input.agent_id,
+    limit: input.limit,
+    min_vitality: input.min_vitality,
+    lexicalLimit: input.lexicalLimit,
+    vectorLimit: input.vectorLimit,
+    provider: input.provider,
+    recordAccess: input.recordAccess
+  });
+}
+
+// src/app/feedback.ts
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function recordFeedbackEvent(db, input) {
+  const id = newId();
+  const created_at = now();
+  const agentId = input.agent_id ?? "default";
+  const useful = input.useful ? 1 : 0;
+  const value = input.useful ? 1 : 0;
+  const eventType = `${input.source}:${input.useful ? "useful" : "not_useful"}`;
+  const exists = db.prepare("SELECT id FROM memories WHERE id = ?").get(input.memory_id);
+  if (!exists) {
+    throw new Error(`Memory not found: ${input.memory_id}`);
   }
-  const memoryAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id;
-  if (!memoryAgent) throw new Error(`Memory not found: ${memoryId}`);
-  if (agent_id && agent_id !== memoryAgent) {
-    throw new Error(`Agent mismatch for path: memory agent_id=${memoryAgent}, requested agent_id=${agent_id}`);
+  try {
+    db.prepare(
+      `INSERT INTO feedback_events (id, memory_id, source, useful, agent_id, event_type, value, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(id, input.memory_id, input.source, useful, agentId, eventType, value, created_at);
+  } catch {
+    db.prepare(
+      `INSERT INTO feedback_events (id, memory_id, event_type, value, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(id, input.memory_id, eventType, value, created_at);
   }
-  const agentId = agent_id ?? memoryAgent;
-  const existing = db.prepare("SELECT id FROM paths WHERE agent_id = ? AND uri = ?").get(agentId, uri);
-  if (existing) {
-    throw new Error(`URI already exists: ${uri}`);
+  return {
+    id,
+    memory_id: input.memory_id,
+    source: input.source,
+    useful: input.useful,
+    agent_id: agentId,
+    created_at,
+    value
+  };
+}
+function getFeedbackSummary(db, memoryId, agentId) {
+  try {
+    const row = db.prepare(
+      `SELECT COUNT(*) as total,
+              COALESCE(SUM(CASE WHEN useful = 1 THEN 1 ELSE 0 END), 0) as useful,
+              COALESCE(SUM(CASE WHEN useful = 0 THEN 1 ELSE 0 END), 0) as not_useful
+       FROM feedback_events
+       WHERE memory_id = ?
+         AND (? IS NULL OR agent_id = ?)`
+    ).get(memoryId, agentId ?? null, agentId ?? null);
+    if (!row || row.total === 0) {
+      return { total: 0, useful: 0, not_useful: 0, score: 0.5 };
+    }
+    return {
+      total: row.total,
+      useful: row.useful,
+      not_useful: row.not_useful,
+      score: clamp012(row.useful / row.total)
+    };
+  } catch {
+    const row = db.prepare(
+      `SELECT COUNT(*) as total,
+              COALESCE(SUM(CASE WHEN value >= 0.5 THEN 1 ELSE 0 END), 0) as useful,
+              COALESCE(SUM(CASE WHEN value < 0.5 THEN 1 ELSE 0 END), 0) as not_useful,
+              COALESCE(AVG(value), 0.5) as avg_value
+       FROM feedback_events
+       WHERE memory_id = ?`
+    ).get(memoryId);
+    if (!row || row.total === 0) {
+      return { total: 0, useful: 0, not_useful: 0, score: 0.5 };
+    }
+    return {
+      total: row.total,
+      useful: row.useful,
+      not_useful: row.not_useful,
+      score: clamp012(row.avg_value)
+    };
   }
-  const id = newId();
-  db.prepare(
-    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
-  ).run(id, memoryId, agentId, uri, alias ?? null, domain, now());
-  return getPath(db, id);
 }
-function getPath(db, id) {
-  return db.prepare("SELECT * FROM paths WHERE id = ?").get(id) ?? null;
+
+// src/app/surface.ts
+var INTENT_PRIORS = {
+  factual: {
+    identity: 0.25,
+    emotion: 0.15,
+    knowledge: 1,
+    event: 0.8
+  },
+  preference: {
+    identity: 1,
+    emotion: 0.85,
+    knowledge: 0.55,
+    event: 0.25
+  },
+  temporal: {
+    identity: 0.15,
+    emotion: 0.35,
+    knowledge: 0.5,
+    event: 1
+  },
+  planning: {
+    identity: 0.65,
+    emotion: 0.2,
+    knowledge: 1,
+    event: 0.6
+  },
+  design: {
+    identity: 0.8,
+    emotion: 0.35,
+    knowledge: 1,
+    event: 0.25
+  }
+};
+var DESIGN_HINT_RE = /\b(ui|ux|design|style|component|layout|brand|palette|theme)\b|风格|界面|设计|配色|低饱和|玻璃拟态|渐变/i;
+var PLANNING_HINT_RE = /\b(plan|planning|todo|next|ship|build|implement|roadmap|task|milestone)\b|计划|下一步|待办|实现|重构/i;
+var FACTUAL_HINT_RE = /\b(what|fact|constraint|rule|docs|document|api|status)\b|规则|约束|文档|接口|事实/i;
+var TEMPORAL_HINT_RE = /\b(today|yesterday|tomorrow|recent|before|after|when|timeline)\b|今天|昨天|明天|最近|时间线|何时/i;
+var PREFERENCE_HINT_RE = /\b(prefer|preference|like|dislike|avoid|favorite)\b|喜欢|偏好|不喜欢|避免|讨厌/i;
+function clamp013(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function uniqueTokenSet2(values) {
+  return new Set(
+    values.flatMap((value) => tokenize(value ?? "")).map((token) => token.trim()).filter(Boolean)
+  );
 }
-function getPathByUri(db, uri, agent_id = "default") {
-  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri = ?").get(agent_id, uri) ?? null;
+function overlapScore2(left, right) {
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const token of left) {
+    if (right.has(token)) shared += 1;
+  }
+  return clamp013(shared / Math.max(left.size, right.size));
 }
-
-// src/sleep/boot.ts
-function boot(db, opts) {
-  const agentId = opts?.agent_id ?? "default";
-  const corePaths = opts?.corePaths ?? [
-    "core://agent",
-    "core://user",
-    "core://agent/identity",
-    "core://user/identity"
-  ];
-  const memories = /* @__PURE__ */ new Map();
-  const identities = listMemories(db, { agent_id: agentId, priority: 0 });
-  for (const mem of identities) {
-    memories.set(mem.id, mem);
-    recordAccess(db, mem.id, 1.1);
+function rankScore(rank, window) {
+  if (!rank) return 0;
+  return clamp013(1 - (rank - 1) / Math.max(window, 1));
+}
+function topicLabel(...parts) {
+  const token = parts.flatMap((part) => tokenize(part ?? "")).find((value) => value.trim().length > 1);
+  const label = (token ?? "context").replace(/[^\p{L}\p{N}_-]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+  return label || "context";
+}
+function intentKeywordBoost(memory, intent) {
+  const content = memory.content;
+  switch (intent) {
+    case "design":
+      return DESIGN_HINT_RE.test(content) ? 1 : 0.65;
+    case "planning":
+      return PLANNING_HINT_RE.test(content) ? 1 : 0.7;
+    case "factual":
+      return FACTUAL_HINT_RE.test(content) ? 1 : 0.75;
+    case "temporal":
+      return TEMPORAL_HINT_RE.test(content) ? 1 : 0.75;
+    case "preference":
+      return PREFERENCE_HINT_RE.test(content) ? 1 : 0.8;
   }
-  const bootPaths = [];
-  for (const uri of corePaths) {
-    const path = getPathByUri(db, uri, agentId);
-    if (path) {
-      bootPaths.push(uri);
-      if (!memories.has(path.memory_id)) {
-        const mem = getMemory(db, path.memory_id);
-        if (mem) {
-          memories.set(mem.id, mem);
-          recordAccess(db, mem.id, 1.1);
-        }
+}
+function intentMatch(memory, intent) {
+  if (!intent) return 0;
+  const prior = INTENT_PRIORS[intent][memory.type] ?? 0;
+  return clamp013(prior * intentKeywordBoost(memory, intent));
+}
+function buildReasonCodes(input) {
+  const reasons = /* @__PURE__ */ new Set();
+  reasons.add(`type:${input.memory.type}`);
+  if (input.semanticScore > 0.2) {
+    reasons.add(`semantic:${topicLabel(input.query, input.task)}`);
+  }
+  if (input.lexicalScore > 0.2 && input.query) {
+    reasons.add(`lexical:${topicLabel(input.query)}`);
+  }
+  if (input.taskMatch > 0.2) {
+    reasons.add(`task:${topicLabel(input.task, input.intent)}`);
+  }
+  if (input.intent) {
+    reasons.add(`intent:${input.intent}`);
+  }
+  if (input.feedbackScore >= 0.67) {
+    reasons.add("feedback:reinforced");
+  } else if (input.feedbackScore <= 0.33) {
+    reasons.add("feedback:negative");
+  }
+  return [...reasons];
+}
+function collectBranch(signals, rows, key, similarity) {
+  for (const row of rows) {
+    const existing = signals.get(row.memory.id) ?? { memory: row.memory };
+    const currentRank = existing[key];
+    if (currentRank === void 0 || row.rank < currentRank) {
+      existing[key] = row.rank;
+    }
+    if (similarity) {
+      const currentSimilarity = similarity.get(row.memory.id);
+      if (currentSimilarity !== void 0) {
+        existing.semanticSimilarity = Math.max(existing.semanticSimilarity ?? 0, currentSimilarity);
       }
     }
+    signals.set(row.memory.id, existing);
   }
-  const bootEntry = getPathByUri(db, "system://boot", agentId);
-  if (bootEntry) {
-    const bootMem = getMemory(db, bootEntry.memory_id);
-    if (bootMem) {
-      const additionalUris = bootMem.content.split("\n").map((l) => l.trim()).filter((l) => l.match(/^[a-z]+:\/\//));
-      for (const uri of additionalUris) {
-        const path = getPathByUri(db, uri, agentId);
-        if (path && !memories.has(path.memory_id)) {
-          const mem = getMemory(db, path.memory_id);
-          if (mem) {
-            memories.set(mem.id, mem);
-            bootPaths.push(uri);
-          }
-        }
+}
+async function surfaceMemories(db, input) {
+  const agentId = input.agent_id ?? "default";
+  const limit = Math.max(1, Math.min(input.limit ?? 5, 20));
+  const lexicalWindow = Math.max(24, limit * 6);
+  const minVitality = input.min_vitality ?? 0.05;
+  const provider = input.provider === void 0 ? getEmbeddingProviderFromEnv() : input.provider;
+  const signals = /* @__PURE__ */ new Map();
+  const trimmedQuery = input.query?.trim();
+  const trimmedTask = input.task?.trim();
+  const recentTurns = (input.recent_turns ?? []).map((turn) => turn.trim()).filter(Boolean).slice(-4);
+  const queryTokens = uniqueTokenSet2([trimmedQuery, ...recentTurns]);
+  const taskTokens = uniqueTokenSet2([trimmedTask]);
+  if (trimmedQuery) {
+    collectBranch(
+      signals,
+      searchBM25(db, trimmedQuery, {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "queryRank"
+    );
+  }
+  if (trimmedTask) {
+    collectBranch(
+      signals,
+      searchBM25(db, trimmedTask, {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "taskRank"
+    );
+  }
+  if (recentTurns.length > 0) {
+    collectBranch(
+      signals,
+      searchBM25(db, recentTurns.join(" "), {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "recentRank"
+    );
+  }
+  const semanticQuery = [trimmedQuery, trimmedTask, ...recentTurns].filter(Boolean).join("\n").trim();
+  if (provider && semanticQuery) {
+    try {
+      const [queryVector] = await provider.embed([semanticQuery]);
+      if (queryVector) {
+        const vectorRows = searchByVector(db, queryVector, {
+          providerId: provider.id,
+          agent_id: agentId,
+          limit: lexicalWindow,
+          min_vitality: minVitality
+        });
+        const similarity = new Map(vectorRows.map((row) => [row.memory.id, row.similarity]));
+        collectBranch(signals, vectorRows, "semanticRank", similarity);
       }
+    } catch {
     }
   }
+  const fallbackMemories = listMemories(db, {
+    agent_id: agentId,
+    min_vitality: minVitality,
+    limit: Math.max(48, lexicalWindow)
+  });
+  for (const memory of fallbackMemories) {
+    if (!signals.has(memory.id)) {
+      signals.set(memory.id, { memory });
+    }
+  }
+  const results = [...signals.values()].map((signal) => signal.memory).filter((memory) => memory.vitality >= minVitality).filter((memory) => input.types?.length ? input.types.includes(memory.type) : true).map((memory) => {
+    const signal = signals.get(memory.id) ?? { memory };
+    const memoryTokens = new Set(tokenize(memory.content));
+    const lexicalOverlap = overlapScore2(memoryTokens, queryTokens);
+    const taskOverlap = overlapScore2(memoryTokens, taskTokens);
+    const lexicalScore = clamp013(
+      0.45 * rankScore(signal.queryRank, lexicalWindow) + 0.15 * rankScore(signal.recentRank, lexicalWindow) + 0.15 * rankScore(signal.taskRank, lexicalWindow) + 0.25 * lexicalOverlap
+    );
+    const semanticScore = signal.semanticSimilarity !== void 0 ? clamp013(Math.max(signal.semanticSimilarity, lexicalOverlap * 0.7)) : trimmedQuery || recentTurns.length > 0 ? clamp013(lexicalOverlap * 0.7) : 0;
+    const intentScore = intentMatch(memory, input.intent);
+    const taskMatch = trimmedTask ? clamp013(0.7 * taskOverlap + 0.3 * intentScore) : intentScore;
+    const priorityScore = priorityPrior(memory.priority);
+    const feedbackSummary = getFeedbackSummary(db, memory.id, agentId);
+    const feedbackScore = feedbackSummary.score;
+    const score = clamp013(
+      0.35 * semanticScore + 0.2 * lexicalScore + 0.15 * taskMatch + 0.1 * memory.vitality + 0.1 * priorityScore + 0.1 * feedbackScore
+    );
+    return {
+      memory,
+      score,
+      semantic_score: semanticScore,
+      lexical_score: lexicalScore,
+      task_match: taskMatch,
+      vitality: memory.vitality,
+      priority_prior: priorityScore,
+      feedback_score: feedbackScore,
+      feedback_summary: feedbackSummary,
+      reason_codes: buildReasonCodes({
+        memory,
+        query: semanticQuery || trimmedQuery,
+        task: trimmedTask,
+        intent: input.intent,
+        semanticScore,
+        lexicalScore,
+        taskMatch,
+        feedbackScore
+      }),
+      lexical_rank: signal.queryRank ?? signal.recentRank ?? signal.taskRank,
+      semantic_rank: signal.semanticRank,
+      semantic_similarity: signal.semanticSimilarity
+    };
+  }).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    if (right.semantic_score !== left.semantic_score) return right.semantic_score - left.semantic_score;
+    if (right.lexical_score !== left.lexical_score) return right.lexical_score - left.lexical_score;
+    if (left.memory.priority !== right.memory.priority) return left.memory.priority - right.memory.priority;
+    return right.memory.updated_at.localeCompare(left.memory.updated_at);
+  }).slice(0, limit);
   return {
-    identityMemories: [...memories.values()],
-    bootPaths
+    count: results.length,
+    query: trimmedQuery,
+    task: trimmedTask,
+    intent: input.intent,
+    results
   };
 }
 
@@ -1203,74 +2218,100 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
   ).all(...agentId ? [threshold, agentId] : [threshold]);
 }
 
-// src/core/snapshot.ts
-function createSnapshot(db, memoryId, action, changedBy) {
-  const memory = db.prepare("SELECT content FROM memories WHERE id = ?").get(memoryId);
-  if (!memory) throw new Error(`Memory not found: ${memoryId}`);
-  const id = newId();
-  db.prepare(
-    `INSERT INTO snapshots (id, memory_id, content, changed_by, action, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`
-  ).run(id, memoryId, memory.content, changedBy ?? null, action, now());
-  return { id, memory_id: memoryId, content: memory.content, changed_by: changedBy ?? null, action, created_at: now() };
-}
-
 // src/sleep/tidy.ts
 function runTidy(db, opts) {
   const threshold = opts?.vitalityThreshold ?? 0.05;
-  const maxSnapshots = opts?.maxSnapshotsPerMemory ?? 10;
   const agentId = opts?.agent_id;
   let archived = 0;
-  let orphansCleaned = 0;
-  let snapshotsPruned = 0;
   const transaction = db.transaction(() => {
     const decayed = getDecayedMemories(db, threshold, agentId ? { agent_id: agentId } : void 0);
     for (const mem of decayed) {
-      try {
-        createSnapshot(db, mem.id, "delete", "tidy");
-      } catch {
-      }
       deleteMemory(db, mem.id);
-      archived++;
+      archived += 1;
     }
-    const orphans = agentId ? db.prepare(
-      `DELETE FROM paths
-         WHERE agent_id = ?
-           AND memory_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)`
-    ).run(agentId, agentId) : db.prepare(
-      "DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)"
-    ).run();
-    orphansCleaned = orphans.changes;
-    const memoriesWithSnapshots = agentId ? db.prepare(
-      `SELECT s.memory_id, COUNT(*) as cnt
-           FROM snapshots s
-           JOIN memories m ON m.id = s.memory_id
-           WHERE m.agent_id = ?
-           GROUP BY s.memory_id HAVING cnt > ?`
-    ).all(agentId, maxSnapshots) : db.prepare(
-      `SELECT memory_id, COUNT(*) as cnt FROM snapshots
-           GROUP BY memory_id HAVING cnt > ?`
-    ).all(maxSnapshots);
-    for (const { memory_id } of memoriesWithSnapshots) {
-      const pruned = db.prepare(
-        `DELETE FROM snapshots WHERE id NOT IN (
-            SELECT id FROM snapshots WHERE memory_id = ?
-            ORDER BY created_at DESC LIMIT ?
-          ) AND memory_id = ?`
-      ).run(memory_id, maxSnapshots, memory_id);
-      snapshotsPruned += pruned.changes;
+  });
+  transaction();
+  return { archived, orphansCleaned: 0 };
+}
+
+// src/sleep/govern.ts
+function clamp014(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function overlapScore3(left, right) {
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const token of left) {
+    if (right.has(token)) shared += 1;
+  }
+  return shared / Math.max(left.size, right.size);
+}
+function feedbackPenalty(db, memoryId) {
+  try {
+    const row = db.prepare(
+      `SELECT COUNT(*) as count, COALESCE(AVG(value), 0) as avgValue
+       FROM feedback_events
+       WHERE memory_id = ?`
+    ).get(memoryId);
+    if (!row || row.count === 0) return 1;
+    return clamp014(1 - row.avgValue);
+  } catch {
+    return 1;
+  }
+}
+function ageScore(memory, referenceMs = Date.now()) {
+  const createdAt = new Date(memory.created_at).getTime();
+  if (Number.isNaN(createdAt)) return 0;
+  const ageDays = Math.max(0, (referenceMs - createdAt) / (1e3 * 60 * 60 * 24));
+  return clamp014(ageDays / 180);
+}
+function computeEvictionScore(input) {
+  return clamp014(
+    0.4 * (1 - clamp014(input.vitality)) + 0.2 * clamp014(input.redundancy_score) + 0.2 * clamp014(input.age_score) + 0.1 * clamp014(input.low_feedback_penalty) + 0.1 * clamp014(input.low_priority_penalty)
+  );
+}
+function rankEvictionCandidates(db, opts) {
+  const agentId = opts?.agent_id;
+  const rows = db.prepare(
+    agentId ? `SELECT * FROM memories WHERE agent_id = ? AND priority > 0 AND TRIM(content) != ''` : `SELECT * FROM memories WHERE priority > 0 AND TRIM(content) != ''`
+  ).all(...agentId ? [agentId] : []);
+  const tokenSets = new Map(rows.map((memory) => [memory.id, new Set(tokenize(memory.content))]));
+  return rows.map((memory) => {
+    const ownTokens = tokenSets.get(memory.id) ?? /* @__PURE__ */ new Set();
+    const redundancy = rows.filter((candidate2) => candidate2.id !== memory.id && candidate2.type === memory.type).reduce((maxOverlap, candidate2) => {
+      const candidateTokens = tokenSets.get(candidate2.id) ?? /* @__PURE__ */ new Set();
+      return Math.max(maxOverlap, overlapScore3(ownTokens, candidateTokens));
+    }, 0);
+    const candidate = {
+      memory,
+      redundancy_score: redundancy,
+      age_score: ageScore(memory),
+      low_feedback_penalty: feedbackPenalty(db, memory.id),
+      low_priority_penalty: clamp014(memory.priority / 3),
+      eviction_score: 0
+    };
+    candidate.eviction_score = computeEvictionScore({
+      vitality: memory.vitality,
+      redundancy_score: candidate.redundancy_score,
+      age_score: candidate.age_score,
+      low_feedback_penalty: candidate.low_feedback_penalty,
+      low_priority_penalty: candidate.low_priority_penalty
+    });
+    return candidate;
+  }).sort((left, right) => {
+    if (right.eviction_score !== left.eviction_score) {
+      return right.eviction_score - left.eviction_score;
     }
+    return left.memory.priority - right.memory.priority;
   });
-  transaction();
-  return { archived, orphansCleaned, snapshotsPruned };
 }
-
-// src/sleep/govern.ts
 function runGovern(db, opts) {
   const agentId = opts?.agent_id;
+  const maxMemories = opts?.maxMemories ?? 200;
   let orphanPaths = 0;
-  let orphanLinks = 0;
   let emptyMemories = 0;
+  let evicted = 0;
   const transaction = db.transaction(() => {
     const pathResult = agentId ? db.prepare(
       `DELETE FROM paths
@@ -1278,170 +2319,749 @@ function runGovern(db, opts) {
            AND memory_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)`
     ).run(agentId, agentId) : db.prepare("DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)").run();
     orphanPaths = pathResult.changes;
-    const linkResult = agentId ? db.prepare(
-      `DELETE FROM links WHERE
-         agent_id = ? AND (
-           source_id NOT IN (SELECT id FROM memories WHERE agent_id = ?) OR
-           target_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)
-         )`
-    ).run(agentId, agentId, agentId) : db.prepare(
-      `DELETE FROM links WHERE
-         source_id NOT IN (SELECT id FROM memories) OR
-         target_id NOT IN (SELECT id FROM memories)`
-    ).run();
-    orphanLinks = linkResult.changes;
     const emptyResult = agentId ? db.prepare("DELETE FROM memories WHERE agent_id = ? AND TRIM(content) = ''").run(agentId) : db.prepare("DELETE FROM memories WHERE TRIM(content) = ''").run();
     emptyMemories = emptyResult.changes;
+    const total = db.prepare(agentId ? "SELECT COUNT(*) as c FROM memories WHERE agent_id = ?" : "SELECT COUNT(*) as c FROM memories").get(...agentId ? [agentId] : []).c;
+    const excess = Math.max(0, total - maxMemories);
+    if (excess <= 0) return;
+    const candidates = rankEvictionCandidates(db, { agent_id: agentId }).slice(0, excess);
+    for (const candidate of candidates) {
+      deleteMemory(db, candidate.memory.id);
+      evicted += 1;
+    }
   });
   transaction();
-  return { orphanPaths, orphanLinks, emptyMemories };
+  return { orphanPaths, emptyMemories, evicted };
 }
 
-// src/core/guard.ts
-function guard(db, input) {
-  const hash = contentHash(input.content);
-  const agentId = input.agent_id ?? "default";
-  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
-  if (exactMatch) {
-    return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
+// src/sleep/jobs.ts
+function parseCheckpoint(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  if (input.uri) {
-    const existingPath = getPathByUri(db, input.uri, agentId);
-    if (existingPath) {
-      return {
-        action: "update",
-        reason: `URI ${input.uri} already exists, updating`,
-        existingId: existingPath.memory_id
-      };
+}
+function serializeCheckpoint(checkpoint) {
+  if (!checkpoint) return null;
+  return JSON.stringify(checkpoint);
+}
+function toJob(row) {
+  if (!row) return null;
+  return {
+    ...row,
+    checkpoint: parseCheckpoint(row.checkpoint)
+  };
+}
+function createInitialCheckpoint(phase) {
+  return {
+    requestedPhase: phase,
+    nextPhase: phase === "all" ? "decay" : phase,
+    completedPhases: [],
+    phaseResults: {}
+  };
+}
+function createMaintenanceJob(db, phase, checkpoint = createInitialCheckpoint(phase)) {
+  const jobId = newId();
+  const startedAt = now();
+  db.prepare(
+    `INSERT INTO maintenance_jobs (job_id, phase, status, checkpoint, error, started_at, finished_at)
+     VALUES (?, ?, 'running', ?, NULL, ?, NULL)`
+  ).run(jobId, phase, serializeCheckpoint(checkpoint), startedAt);
+  return getMaintenanceJob(db, jobId);
+}
+function getMaintenanceJob(db, jobId) {
+  const row = db.prepare("SELECT * FROM maintenance_jobs WHERE job_id = ?").get(jobId);
+  return toJob(row);
+}
+function findResumableMaintenanceJob(db, phase) {
+  const row = db.prepare(
+    `SELECT *
+     FROM maintenance_jobs
+     WHERE phase = ?
+       AND status IN ('running', 'failed')
+     ORDER BY started_at DESC
+     LIMIT 1`
+  ).get(phase);
+  return toJob(row);
+}
+function updateMaintenanceCheckpoint(db, jobId, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET checkpoint = ?,
+         error = NULL,
+         finished_at = NULL,
+         status = 'running'
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+function failMaintenanceJob(db, jobId, error, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET status = 'failed',
+         checkpoint = COALESCE(?, checkpoint),
+         error = ?,
+         finished_at = ?
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), error, now(), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+function completeMaintenanceJob(db, jobId, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET status = 'completed',
+         checkpoint = COALESCE(?, checkpoint),
+         error = NULL,
+         finished_at = ?
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), now(), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+
+// src/sleep/orchestrator.ts
+var DEFAULT_RUNNERS = {
+  decay: (db, opts) => runDecay(db, opts),
+  tidy: (db, opts) => runTidy(db, opts),
+  govern: (db, opts) => runGovern(db, opts)
+};
+var PHASE_SEQUENCE = ["decay", "tidy", "govern"];
+function getSummaryStats(db, agentId) {
+  const row = agentId ? db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories WHERE agent_id = ?").get(agentId) : db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories").get();
+  return {
+    total: row.total,
+    avgVitality: row.avg
+  };
+}
+function getPhaseSequence(phase) {
+  return phase === "all" ? [...PHASE_SEQUENCE] : [phase];
+}
+function resolveJob(db, opts) {
+  if (opts.jobId) {
+    const job = getMaintenanceJob(db, opts.jobId);
+    if (!job) {
+      throw new Error(`Maintenance job not found: ${opts.jobId}`);
+    }
+    if (job.phase !== opts.phase) {
+      throw new Error(`Maintenance job ${opts.jobId} phase mismatch: expected ${opts.phase}, got ${job.phase}`);
     }
+    return { job, resumed: true };
   }
-  const ftsTokens = tokenize(input.content.slice(0, 200));
-  const ftsQuery = ftsTokens.length > 0 ? ftsTokens.slice(0, 8).map((w) => `"${w}"`).join(" OR ") : null;
-  if (ftsQuery) {
-    try {
-      const similar = db.prepare(
-        `SELECT m.id, m.content, m.type, rank
-           FROM memories_fts f
-           JOIN memories m ON m.id = f.id
-           WHERE memories_fts MATCH ? AND m.agent_id = ?
-           ORDER BY rank
-           LIMIT 3`
-      ).all(ftsQuery, agentId);
-      if (similar.length > 0) {
-        const topRank = Math.abs(similar[0].rank);
-        const tokenCount = ftsTokens.length;
-        const dynamicThreshold = tokenCount * 1.5;
-        if (topRank > dynamicThreshold) {
-          const existing = similar[0];
-          if (existing.type === input.type) {
-            const merged = `${existing.content}
-
-[Updated] ${input.content}`;
-            return {
-              action: "merge",
-              reason: `Similar content found (score=${topRank.toFixed(1)}, threshold=${dynamicThreshold.toFixed(1)}), merging`,
-              existingId: existing.id,
-              mergedContent: merged
-            };
-          }
-        }
-      }
-    } catch {
+  if (opts.resume !== false) {
+    const resumable = findResumableMaintenanceJob(db, opts.phase);
+    if (resumable) {
+      return { job: resumable, resumed: true };
     }
   }
-  const gateResult = fourCriterionGate(input);
-  if (!gateResult.pass) {
-    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
+  return {
+    job: createMaintenanceJob(db, opts.phase),
+    resumed: false
+  };
+}
+function nextPhase(current, requested) {
+  if (requested !== "all") return null;
+  const index = PHASE_SEQUENCE.indexOf(current);
+  return PHASE_SEQUENCE[index + 1] ?? null;
+}
+async function runReflectOrchestrator(db, opts) {
+  const runners = {
+    ...DEFAULT_RUNNERS,
+    ...opts.runners
+  };
+  const before = getSummaryStats(db, opts.agent_id);
+  const { job: baseJob, resumed } = resolveJob(db, opts);
+  let checkpoint = baseJob.checkpoint ?? createInitialCheckpoint(opts.phase);
+  const jobId = baseJob.job_id;
+  const orderedPhases = getPhaseSequence(opts.phase);
+  const startPhase = checkpoint.nextPhase ?? orderedPhases[orderedPhases.length - 1] ?? "decay";
+  const startIndex = Math.max(0, orderedPhases.indexOf(startPhase));
+  const phasesToRun = checkpoint.nextPhase === null ? [] : orderedPhases.slice(startIndex);
+  const totalPhases = Math.max(orderedPhases.length, 1);
+  opts.onProgress?.({
+    status: "started",
+    phase: opts.phase,
+    progress: checkpoint.completedPhases.length / totalPhases,
+    jobId,
+    detail: {
+      resumed,
+      nextPhase: checkpoint.nextPhase
+    }
+  });
+  try {
+    for (const phase of phasesToRun) {
+      const result = await Promise.resolve(runners[phase](db, { agent_id: opts.agent_id }));
+      checkpoint = {
+        ...checkpoint,
+        completedPhases: [.../* @__PURE__ */ new Set([...checkpoint.completedPhases, phase])],
+        phaseResults: {
+          ...checkpoint.phaseResults,
+          [phase]: result
+        },
+        nextPhase: nextPhase(phase, opts.phase)
+      };
+      updateMaintenanceCheckpoint(db, jobId, checkpoint);
+      opts.onProgress?.({
+        status: "phase-completed",
+        phase,
+        progress: checkpoint.completedPhases.length / totalPhases,
+        jobId,
+        detail: result
+      });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const failed = failMaintenanceJob(db, jobId, message, checkpoint) ?? baseJob;
+    opts.onProgress?.({
+      status: "failed",
+      phase: checkpoint.nextPhase ?? opts.phase,
+      progress: checkpoint.completedPhases.length / totalPhases,
+      jobId,
+      detail: { error: message }
+    });
+    throw Object.assign(new Error(message), { job: failed, checkpoint });
   }
-  return { action: "add", reason: "Passed all guard checks" };
+  const completedCheckpoint = {
+    ...checkpoint,
+    nextPhase: null
+  };
+  const job = completeMaintenanceJob(db, jobId, completedCheckpoint) ?? baseJob;
+  const after = getSummaryStats(db, opts.agent_id);
+  opts.onProgress?.({
+    status: "completed",
+    phase: opts.phase,
+    progress: 1,
+    jobId,
+    detail: completedCheckpoint.phaseResults
+  });
+  return {
+    job,
+    jobId,
+    phase: opts.phase,
+    resumed,
+    checkpoint: completedCheckpoint,
+    results: completedCheckpoint.phaseResults,
+    before,
+    after
+  };
 }
-function fourCriterionGate(input) {
-  const content = input.content.trim();
-  const failed = [];
-  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : input.type === "knowledge" ? 2 : 3);
-  const minLength = priority <= 1 ? 4 : 8;
-  const specificity = content.length >= minLength ? Math.min(1, content.length / 50) : 0;
-  if (specificity === 0) failed.push(`specificity (too short: ${content.length} < ${minLength} chars)`);
-  const tokens = tokenize(content);
-  const novelty = tokens.length >= 1 ? Math.min(1, tokens.length / 5) : 0;
-  if (novelty === 0) failed.push("novelty (no meaningful tokens after filtering)");
-  const hasCJK = /[\u4e00-\u9fff]/.test(content);
-  const hasCapitalized = /[A-Z][a-z]+/.test(content);
-  const hasNumbers = /\d+/.test(content);
-  const hasURI = /\w+:\/\//.test(content);
-  const hasEntityMarkers = /[@#]/.test(content);
-  const hasMeaningfulLength = content.length >= 15;
-  const topicSignals = [hasCJK, hasCapitalized, hasNumbers, hasURI, hasEntityMarkers, hasMeaningfulLength].filter(Boolean).length;
-  const relevance = topicSignals >= 1 ? Math.min(1, topicSignals / 3) : 0;
-  if (relevance === 0) failed.push("relevance (no identifiable topics/entities)");
-  const allCaps = content === content.toUpperCase() && content.length > 20 && /^[A-Z\s]+$/.test(content);
-  const hasWhitespaceOrPunctuation = /[\s，。！？,.!?；;：:]/.test(content) || content.length < 30;
-  const excessiveRepetition = /(.)\1{9,}/.test(content);
-  let coherence = 1;
-  if (allCaps) {
-    coherence -= 0.5;
+
+// src/app/reflect.ts
+async function reflectMemories(db, input) {
+  const options = {
+    phase: input.phase,
+    agent_id: input.agent_id,
+    jobId: input.jobId,
+    resume: input.resume,
+    runners: input.runners,
+    onProgress: input.onProgress
+  };
+  return runReflectOrchestrator(db, options);
+}
+
+// src/app/status.ts
+function getMemoryStatus(db, input) {
+  const agentId = input?.agent_id ?? "default";
+  const stats = countMemories(db, agentId);
+  const lowVitality = db.prepare(
+    "SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?"
+  ).get(agentId);
+  const totalPaths = db.prepare(
+    "SELECT COUNT(*) as c FROM paths WHERE agent_id = ?"
+  ).get(agentId);
+  const feedbackEvents = db.prepare(
+    "SELECT COUNT(*) as c FROM feedback_events WHERE agent_id = ?"
+  ).get(agentId);
+  return {
+    ...stats,
+    paths: totalPaths.c,
+    low_vitality: lowVitality.c,
+    feedback_events: feedbackEvents.c,
+    agent_id: agentId
+  };
+}
+
+// src/app/reindex.ts
+async function reindexMemories(db, input) {
+  input?.onProgress?.({ status: "started", stage: "fts", progress: 0 });
+  try {
+    const fts = rebuildBm25Index(db, { agent_id: input?.agent_id });
+    input?.onProgress?.({
+      status: "stage-completed",
+      stage: "fts",
+      progress: 0.5,
+      detail: fts
+    });
+    const embeddings = await reindexEmbeddings(db, {
+      agent_id: input?.agent_id,
+      provider: input?.provider,
+      force: input?.force,
+      batchSize: input?.batchSize
+    });
+    input?.onProgress?.({
+      status: "stage-completed",
+      stage: "embeddings",
+      progress: 0.9,
+      detail: embeddings
+    });
+    const result = { fts, embeddings };
+    input?.onProgress?.({
+      status: "completed",
+      stage: "done",
+      progress: 1,
+      detail: result
+    });
+    return result;
+  } catch (error) {
+    input?.onProgress?.({
+      status: "failed",
+      stage: "done",
+      progress: 1,
+      detail: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
   }
-  if (!hasWhitespaceOrPunctuation) {
-    coherence -= 0.3;
+}
+
+// src/transports/http.ts
+var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["identity", "emotion", "knowledge", "event"]);
+var VALID_PHASES = /* @__PURE__ */ new Set(["decay", "tidy", "govern", "all"]);
+var VALID_INTENTS = /* @__PURE__ */ new Set(["factual", "preference", "temporal", "planning", "design"]);
+function json(value) {
+  return JSON.stringify(value);
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(json(payload));
+}
+function sendError(res, statusCode, error, details) {
+  sendJson(res, statusCode, { error, details });
+}
+function openSse(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive"
+  });
+  res.write(": connected\n\n");
+}
+function sendSse(res, event, payload) {
+  if (res.writableEnded) return;
+  res.write(`event: ${event}
+`);
+  res.write(`data: ${json(payload)}
+
+`);
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
-  if (excessiveRepetition) {
-    coherence -= 0.5;
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Request body must be a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Invalid JSON body");
   }
-  coherence = Math.max(0, coherence);
-  if (coherence < 0.3) failed.push("coherence (garbled or malformed content)");
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const result = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  return result.length > 0 ? result : [];
+}
+function wantsSse(req, body) {
+  const accept = req.headers.accept ?? "";
+  return accept.includes("text/event-stream") || body.stream === true;
+}
+function formatRecallResponse(result) {
   return {
-    pass: failed.length === 0,
-    scores: { specificity, novelty, relevance, coherence },
-    failedCriteria: failed
+    mode: result.mode,
+    provider_id: result.providerId,
+    used_vector_search: result.usedVectorSearch,
+    count: result.results.length,
+    memories: result.results.map((row) => ({
+      id: row.memory.id,
+      content: row.memory.content,
+      type: row.memory.type,
+      priority: row.memory.priority,
+      vitality: row.memory.vitality,
+      score: row.score,
+      bm25_rank: row.bm25_rank,
+      vector_rank: row.vector_rank,
+      bm25_score: row.bm25_score,
+      vector_score: row.vector_score,
+      updated_at: row.memory.updated_at
+    }))
   };
 }
-
-// src/sleep/sync.ts
-function syncOne(db, input) {
-  const memInput = {
-    content: input.content,
-    type: input.type ?? "event",
-    priority: input.priority,
-    emotion_val: input.emotion_val,
-    source: input.source,
-    agent_id: input.agent_id,
-    uri: input.uri
+function formatSurfaceResponse(result) {
+  return {
+    count: result.count,
+    query: result.query,
+    task: result.task,
+    intent: result.intent,
+    results: result.results.map((row) => ({
+      id: row.memory.id,
+      content: row.memory.content,
+      type: row.memory.type,
+      priority: row.memory.priority,
+      vitality: row.memory.vitality,
+      score: row.score,
+      semantic_score: row.semantic_score,
+      lexical_score: row.lexical_score,
+      task_match: row.task_match,
+      priority_prior: row.priority_prior,
+      feedback_score: row.feedback_score,
+      feedback_summary: row.feedback_summary,
+      reason_codes: row.reason_codes,
+      updated_at: row.memory.updated_at
+    }))
   };
-  const guardResult = guard(db, memInput);
-  switch (guardResult.action) {
-    case "skip":
-      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
-    case "add": {
-      const mem = createMemory(db, memInput);
-      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
-      if (input.uri) {
-        try {
-          createPath(db, mem.id, input.uri);
-        } catch {
+}
+function createJob(jobs, kind, agentId) {
+  const job = {
+    id: randomUUID2(),
+    kind,
+    status: "running",
+    stage: "queued",
+    progress: 0,
+    agent_id: agentId,
+    started_at: now2(),
+    finished_at: null
+  };
+  jobs.set(job.id, job);
+  return job;
+}
+function updateJob(job, patch) {
+  Object.assign(job, patch);
+  return job;
+}
+function createHttpServer(options) {
+  const ownsDb = !options?.db;
+  const db = options?.db ?? openDatabase({ path: options?.dbPath ?? process.env.AGENT_MEMORY_DB ?? "./agent-memory.db" });
+  const defaultAgentId = options?.agentId ?? process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+  const jobs = /* @__PURE__ */ new Map();
+  const executeReflectJob = async (job, body, stream) => {
+    const phase = asString(body.phase) ?? "all";
+    if (!VALID_PHASES.has(phase)) {
+      throw new Error(`Invalid phase: ${String(body.phase)}`);
+    }
+    updateJob(job, { stage: phase, progress: 0.01 });
+    try {
+      const result = await reflectMemories(db, {
+        phase,
+        agent_id: asString(body.agent_id) ?? defaultAgentId,
+        runners: options?.reflectRunners,
+        onProgress: (event) => {
+          updateJob(job, {
+            stage: String(event.phase),
+            progress: event.progress,
+            backend_job_id: event.jobId ?? job.backend_job_id
+          });
+          if (stream) {
+            sendSse(stream, "progress", {
+              job,
+              event
+            });
+          }
         }
-      }
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+      });
+      updateJob(job, {
+        status: "completed",
+        stage: "done",
+        progress: 1,
+        backend_job_id: result.jobId,
+        finished_at: now2(),
+        result
+      });
+      return { job, result };
+    } catch (error) {
+      updateJob(job, {
+        status: "failed",
+        stage: "failed",
+        progress: 1,
+        finished_at: now2(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    case "update": {
-      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
-      createSnapshot(db, guardResult.existingId, "update", "sync");
-      updateMemory(db, guardResult.existingId, { content: input.content });
-      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
+  };
+  const executeReindexJob = async (job, body, stream) => {
+    updateJob(job, { stage: "fts", progress: 0.01 });
+    try {
+      const result = await reindexMemories(db, {
+        agent_id: asString(body.agent_id) ?? defaultAgentId,
+        provider: options?.provider,
+        force: asBoolean(body.full) ?? false,
+        batchSize: asNumber(body.batch_size) ?? 16,
+        onProgress: (event) => {
+          updateJob(job, {
+            stage: event.stage,
+            progress: event.progress
+          });
+          if (stream) {
+            sendSse(stream, "progress", {
+              job,
+              event
+            });
+          }
+        }
+      });
+      updateJob(job, {
+        status: "completed",
+        stage: "done",
+        progress: 1,
+        finished_at: now2(),
+        result
+      });
+      return { job, result };
+    } catch (error) {
+      updateJob(job, {
+        status: "failed",
+        stage: "failed",
+        progress: 1,
+        finished_at: now2(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    case "merge": {
-      if (!guardResult.existingId || !guardResult.mergedContent) {
-        return { action: "skipped", reason: "Missing merge data" };
+  };
+  const server = http.createServer(async (req, res) => {
+    try {
+      const method = req.method ?? "GET";
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      const pathname = url.pathname;
+      if (method === "GET" && pathname === "/health") {
+        sendJson(res, 200, {
+          ok: true,
+          service: "agent-memory",
+          time: now2()
+        });
+        return;
       }
-      createSnapshot(db, guardResult.existingId, "merge", "sync");
-      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
-      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+      if (method === "GET" && pathname === "/v1/status") {
+        const agentId = url.searchParams.get("agent_id") ?? defaultAgentId;
+        sendJson(res, 200, getMemoryStatus(db, { agent_id: agentId }));
+        return;
+      }
+      if (method === "GET" && pathname.startsWith("/v1/jobs/")) {
+        const id = decodeURIComponent(pathname.slice("/v1/jobs/".length));
+        const job = jobs.get(id);
+        if (job) {
+          sendJson(res, 200, job);
+          return;
+        }
+        const maintenanceJob = getMaintenanceJob(db, id);
+        if (maintenanceJob) {
+          sendJson(res, 200, maintenanceJob);
+          return;
+        }
+        sendError(res, 404, `Job not found: ${id}`);
+        return;
+      }
+      if (method !== "POST") {
+        sendError(res, 404, `Route not found: ${method} ${pathname}`);
+        return;
+      }
+      const body = await readJsonBody(req);
+      if (pathname === "/v1/memories") {
+        const content = asString(body.content)?.trim();
+        if (!content) {
+          sendError(res, 400, "content is required");
+          return;
+        }
+        const type = asString(body.type) ?? "knowledge";
+        if (!VALID_MEMORY_TYPES.has(type)) {
+          sendError(res, 400, `Invalid memory type: ${String(body.type)}`);
+          return;
+        }
+        const result = await rememberMemory(db, {
+          content,
+          type,
+          uri: asString(body.uri),
+          source: asString(body.source),
+          emotion_val: asNumber(body.emotion_val),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          conservative: asBoolean(body.conservative),
+          provider: options?.provider
+        });
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/recall") {
+        const query = asString(body.query)?.trim();
+        if (!query) {
+          sendError(res, 400, "query is required");
+          return;
+        }
+        const result = await recallMemory(db, {
+          query,
+          limit: asNumber(body.limit),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          provider: options?.provider
+        });
+        sendJson(res, 200, formatRecallResponse(result));
+        return;
+      }
+      if (pathname === "/v1/surface") {
+        const types = asStringArray(body.types)?.filter((type) => VALID_MEMORY_TYPES.has(type));
+        const intent = asString(body.intent);
+        if (intent !== void 0 && !VALID_INTENTS.has(intent)) {
+          sendError(res, 400, `Invalid intent: ${intent}`);
+          return;
+        }
+        const result = await surfaceMemories(db, {
+          query: asString(body.query),
+          task: asString(body.task),
+          recent_turns: asStringArray(body.recent_turns),
+          intent,
+          types,
+          limit: asNumber(body.limit),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          provider: options?.provider
+        });
+        sendJson(res, 200, formatSurfaceResponse(result));
+        return;
+      }
+      if (pathname === "/v1/feedback") {
+        const memoryId = asString(body.memory_id)?.trim();
+        const source = asString(body.source);
+        const useful = asBoolean(body.useful);
+        if (!memoryId) {
+          sendError(res, 400, "memory_id is required");
+          return;
+        }
+        if (source !== "recall" && source !== "surface") {
+          sendError(res, 400, "source must be 'recall' or 'surface'");
+          return;
+        }
+        if (useful === void 0) {
+          sendError(res, 400, "useful must be boolean");
+          return;
+        }
+        const result = recordFeedbackEvent(db, {
+          memory_id: memoryId,
+          source,
+          useful,
+          agent_id: asString(body.agent_id) ?? defaultAgentId
+        });
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/reflect") {
+        const agentId = asString(body.agent_id) ?? defaultAgentId;
+        const job = createJob(jobs, "reflect", agentId);
+        if (wantsSse(req, body)) {
+          openSse(res);
+          sendSse(res, "job", job);
+          void executeReflectJob(job, body, res).then(({ job: currentJob, result: result2 }) => {
+            sendSse(res, "done", { job: currentJob, result: result2 });
+          }).catch((error) => {
+            sendSse(res, "error", {
+              job,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }).finally(() => {
+            if (!res.writableEnded) res.end();
+          });
+          return;
+        }
+        const result = await executeReflectJob(job, body);
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/reindex") {
+        const agentId = asString(body.agent_id) ?? defaultAgentId;
+        const job = createJob(jobs, "reindex", agentId);
+        if (wantsSse(req, body)) {
+          openSse(res);
+          sendSse(res, "job", job);
+          void executeReindexJob(job, body, res).then(({ job: currentJob, result: result2 }) => {
+            sendSse(res, "done", { job: currentJob, result: result2 });
+          }).catch((error) => {
+            sendSse(res, "error", {
+              job,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }).finally(() => {
+            if (!res.writableEnded) res.end();
+          });
+          return;
+        }
+        const result = await executeReindexJob(job, body);
+        sendJson(res, 200, result);
+        return;
+      }
+      sendError(res, 404, `Route not found: ${method} ${pathname}`);
+    } catch (error) {
+      sendError(res, 500, error instanceof Error ? error.message : String(error));
     }
-  }
+  });
+  return {
+    server,
+    db,
+    jobs,
+    listen(port = 3e3, host = "127.0.0.1") {
+      return new Promise((resolve2, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+          server.off("error", reject);
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            resolve2({ port, host });
+            return;
+          }
+          resolve2({ port: address.port, host: address.address });
+        });
+      });
+    },
+    close() {
+      return new Promise((resolve2, reject) => {
+        server.close((error) => {
+          if (ownsDb) {
+            try {
+              db.close();
+            } catch {
+            }
+          }
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve2();
+        });
+      });
+    }
+  };
+}
+async function startHttpServer(options) {
+  const service = createHttpServer(options);
+  await service.listen(options?.port, options?.host);
+  return service;
 }
 
 // src/bin/agent-memory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
-import { resolve, basename } from "path";
 var args = process.argv.slice(2);
 var command = args[0];
 function getDbPath() {
@@ -1452,34 +3072,52 @@ function getAgentId() {
 }
 function printHelp() {
   console.log(`
-\u{1F9E0} AgentMemory v2 \u2014 Sleep-cycle memory for AI agents
+\u{1F9E0} AgentMemory v4 \u2014 Sleep-cycle memory for AI agents
 
 Usage: agent-memory <command> [options]
 
 Commands:
-  init                          Create database
-  db:migrate                    Run schema migrations (no-op if up-to-date)
-  embed [--limit N]             Embed missing memories (requires provider)
+  init                               Create database
+  db:migrate                         Run schema migrations (no-op if up-to-date)
   remember <content> [--uri X] [--type T]  Store a memory
-  recall <query> [--limit N]    Search memories
-  boot                          Load identity memories
-  status                        Show statistics
-  reflect [decay|tidy|govern|all]  Run sleep cycle
-  reindex                         Rebuild FTS index with jieba tokenizer
-  migrate <dir>                 Import from Markdown files
-  export <dir>                  Export memories to Markdown files
-  help                          Show this help
+  recall <query> [--limit N]         Search memories (hybrid retrieval, auto-fallback to BM25)
+  boot                               Load identity memories
+  status                             Show statistics
+  reflect [decay|tidy|govern|all]    Run sleep cycle
+  reindex [--full] [--batch-size N]  Rebuild FTS index and embeddings (if configured)
+  serve [--host H] [--port N]        Start the HTTP/SSE API server
+  migrate <dir>                      Import from Markdown files
+  export <dir>                       Export memories to Markdown files
+  help                               Show this help
 
 Environment:
-  AGENT_MEMORY_DB      Database path (default: ./agent-memory.db)
-  AGENT_MEMORY_AGENT_ID  Agent ID (default: "default")
+  AGENT_MEMORY_DB         Database path (default: ./agent-memory.db)
+  AGENT_MEMORY_AGENT_ID   Agent ID (default: "default")
 `);
 }
 function getFlag(flag) {
-  const idx = args.indexOf(flag);
-  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];
+  const index = args.indexOf(flag);
+  if (index >= 0 && index + 1 < args.length) return args[index + 1];
   return void 0;
 }
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+function getPositionalArgs(startIndex = 1) {
+  const values = [];
+  for (let index = startIndex; index < args.length; index++) {
+    const token = args[index];
+    if (token.startsWith("--")) {
+      const next = args[index + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        index += 1;
+      }
+      continue;
+    }
+    values.push(token);
+  }
+  return values;
+}
 async function main() {
   try {
     switch (command) {
@@ -1497,22 +3135,8 @@ async function main() {
         db.close();
         break;
       }
-      case "embed": {
-        const provider = getEmbeddingProviderFromEnv();
-        if (!provider) {
-          console.error("Embedding provider not configured. Set AGENT_MEMORY_EMBEDDINGS_PROVIDER=openai|qwen and the corresponding API key.");
-          process.exit(1);
-        }
-        const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        const limit = parseInt(getFlag("--limit") ?? "200");
-        const r = await embedMissingForAgent(db, provider, { agent_id: agentId, limit });
-        console.log(`\u2705 Embedded: ${r.embedded}/${r.scanned} (agent_id=${agentId}, model=${provider.model})`);
-        db.close();
-        break;
-      }
       case "remember": {
-        const content = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        const content = getPositionalArgs(1).join(" ");
         if (!content) {
           console.error("Usage: agent-memory remember <content>");
           process.exit(1);
@@ -1520,39 +3144,39 @@ async function main() {
         const db = openDatabase({ path: getDbPath() });
         const uri = getFlag("--uri");
         const type = getFlag("--type") ?? "knowledge";
-        const agentId = getAgentId();
-        const provider = getEmbeddingProviderFromEnv();
-        const result = syncOne(db, { content, type, uri, agent_id: agentId });
-        if (provider && result.memoryId && (result.action === "added" || result.action === "updated" || result.action === "merged")) {
-          try {
-            await embedMemory(db, result.memoryId, provider, { agent_id: agentId });
-          } catch {
-          }
-        }
+        const result = await rememberMemory(db, {
+          content,
+          type,
+          uri,
+          source: "manual",
+          agent_id: getAgentId()
+        });
         console.log(`${result.action}: ${result.reason}${result.memoryId ? ` (${result.memoryId.slice(0, 8)})` : ""}`);
         db.close();
         break;
       }
       case "recall": {
-        const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        const query = getPositionalArgs(1).join(" ");
         if (!query) {
           console.error("Usage: agent-memory recall <query>");
           process.exit(1);
         }
         const db = openDatabase({ path: getDbPath() });
-        const limit = parseInt(getFlag("--limit") ?? "10");
-        const { intent } = classifyIntent(query);
-        const strategy = getStrategy(intent);
-        const agentId = getAgentId();
-        const provider = getEmbeddingProviderFromEnv();
-        const raw = await searchHybrid(db, query, { agent_id: agentId, embeddingProvider: provider, limit: limit * 2 });
-        const results = rerank(raw, { ...strategy, limit });
-        console.log(`\u{1F50D} Intent: ${intent} | Results: ${results.length}
+        const result = await recallMemory(db, {
+          query,
+          agent_id: getAgentId(),
+          limit: Number.parseInt(getFlag("--limit") ?? "10", 10)
+        });
+        console.log(`\u{1F50D} Results: ${result.results.length} (${result.mode})
 `);
-        for (const r of results) {
-          const p = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][r.memory.priority];
-          const v = (r.memory.vitality * 100).toFixed(0);
-          console.log(`${p} P${r.memory.priority} [${v}%] ${r.memory.content.slice(0, 80)}`);
+        for (const row of result.results) {
+          const priorityLabel = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][row.memory.priority];
+          const vitality = (row.memory.vitality * 100).toFixed(0);
+          const branches = [
+            row.bm25_rank ? `bm25#${row.bm25_rank}` : null,
+            row.vector_rank ? `vec#${row.vector_rank}` : null
+          ].filter(Boolean).join(" + ");
+          console.log(`${priorityLabel} P${row.memory.priority} [${vitality}%] ${row.memory.content.slice(0, 80)}${branches ? `  (${branches})` : ""}`);
         }
         db.close();
         break;
@@ -1562,8 +3186,8 @@ async function main() {
         const result = boot(db, { agent_id: getAgentId() });
         console.log(`\u{1F9E0} Boot: ${result.identityMemories.length} identity memories loaded
 `);
-        for (const m of result.identityMemories) {
-          console.log(`  \u{1F534} ${m.content.slice(0, 100)}`);
+        for (const memory of result.identityMemories) {
+          console.log(`  \u{1F534} ${memory.content.slice(0, 100)}`);
         }
         if (result.bootPaths.length) {
           console.log(`
@@ -1574,74 +3198,83 @@ async function main() {
       }
       case "status": {
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        const stats = countMemories(db, agentId);
-        const lowVit = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?").get(agentId).c;
-        const paths = db.prepare("SELECT COUNT(*) as c FROM paths WHERE agent_id = ?").get(agentId).c;
-        const links = db.prepare("SELECT COUNT(*) as c FROM links WHERE agent_id = ?").get(agentId).c;
-        const snaps = db.prepare(
-          `SELECT COUNT(*) as c FROM snapshots s
-         JOIN memories m ON m.id = s.memory_id
-         WHERE m.agent_id = ?`
-        ).get(agentId).c;
+        const status = getMemoryStatus(db, { agent_id: getAgentId() });
         console.log("\u{1F9E0} AgentMemory Status\n");
-        console.log(`  Total memories: ${stats.total}`);
-        console.log(`  By type: ${Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-        console.log(`  By priority: ${Object.entries(stats.by_priority).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-        console.log(`  Paths: ${paths} | Links: ${links} | Snapshots: ${snaps}`);
-        console.log(`  Low vitality (<10%): ${lowVit}`);
+        console.log(`  Total memories: ${status.total}`);
+        console.log(`  By type: ${Object.entries(status.by_type).map(([key, value]) => `${key}=${value}`).join(", ")}`);
+        console.log(`  By priority: ${Object.entries(status.by_priority).map(([key, value]) => `${key}=${value}`).join(", ")}`);
+        console.log(`  Paths: ${status.paths}`);
+        console.log(`  Low vitality (<10%): ${status.low_vitality}`);
+        console.log(`  Feedback events: ${status.feedback_events}`);
         db.close();
         break;
       }
       case "reflect": {
         const phase = args[1] ?? "all";
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        console.log(`\u{1F319} Running ${phase} phase...
-`);
-        if (phase === "decay" || phase === "all") {
-          const r = runDecay(db, { agent_id: agentId });
-          console.log(`  Decay: ${r.updated} updated, ${r.decayed} decayed, ${r.belowThreshold} below threshold`);
-        }
-        if (phase === "tidy" || phase === "all") {
-          const r = runTidy(db, { agent_id: agentId });
-          console.log(`  Tidy: ${r.archived} archived, ${r.orphansCleaned} orphans, ${r.snapshotsPruned} snapshots pruned`);
-        }
-        if (phase === "govern" || phase === "all") {
-          const r = runGovern(db, { agent_id: agentId });
-          console.log(`  Govern: ${r.orphanPaths} paths, ${r.orphanLinks} links, ${r.emptyMemories} empty cleaned`);
+        const result = await reflectMemories(db, { phase, agent_id: getAgentId() });
+        console.log(`\u{1F319} Reflect job ${result.jobId}${result.resumed ? " (resume)" : ""}`);
+        for (const [name, summary] of Object.entries(result.results)) {
+          console.log(`  ${name}: ${JSON.stringify(summary)}`);
         }
         db.close();
         break;
       }
       case "reindex": {
         const db = openDatabase({ path: getDbPath() });
-        const memories = db.prepare("SELECT id, content FROM memories").all();
-        db.exec("DELETE FROM memories_fts");
-        const insert = db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)");
-        let count = 0;
-        const txn = db.transaction(() => {
-          for (const mem of memories) {
-            insert.run(mem.id, tokenizeForIndex(mem.content));
-            count++;
-          }
+        const result = await reindexMemories(db, {
+          agent_id: getAgentId(),
+          force: hasFlag("--full"),
+          batchSize: Number.parseInt(getFlag("--batch-size") ?? "16", 10)
         });
-        txn();
-        console.log(`\u{1F504} Reindexed ${count} memories with jieba tokenizer`);
+        console.log(`\u{1F504} Reindexed ${result.fts.reindexed} memories in BM25 index`);
+        if (result.embeddings.enabled) {
+          console.log(`\u{1F9EC} Embeddings: provider=${result.embeddings.providerId} scanned=${result.embeddings.scanned} embedded=${result.embeddings.embedded} failed=${result.embeddings.failed}`);
+        } else {
+          console.log("\u{1F9EC} Embeddings: disabled (no provider configured)");
+        }
         db.close();
         break;
       }
+      case "serve": {
+        const port = Number.parseInt(getFlag("--port") ?? process.env.AGENT_MEMORY_HTTP_PORT ?? "3000", 10);
+        const host = getFlag("--host") ?? process.env.AGENT_MEMORY_HTTP_HOST ?? "127.0.0.1";
+        const service = await startHttpServer({
+          dbPath: getDbPath(),
+          agentId: getAgentId(),
+          port,
+          host
+        });
+        const address = service.server.address();
+        if (address && typeof address !== "string") {
+          console.log(`\u{1F310} AgentMemory HTTP server listening on http://${address.address}:${address.port}`);
+        } else {
+          console.log(`\u{1F310} AgentMemory HTTP server listening on http://${host}:${port}`);
+        }
+        const shutdown = async () => {
+          try {
+            await service.close();
+          } finally {
+            process.exit(0);
+          }
+        };
+        process.once("SIGINT", () => {
+          void shutdown();
+        });
+        process.once("SIGTERM", () => {
+          void shutdown();
+        });
+        break;
+      }
       case "export": {
         const dir = args[1];
         if (!dir) {
           console.error("Usage: agent-memory export <directory>");
           process.exit(1);
         }
-        const dirPath = resolve(dir);
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        const result = exportMemories(db, dirPath, { agent_id: agentId });
-        console.log(`\u2705 Export complete: ${result.exported} items to ${dirPath} (${result.files.length} files)`);
+        const result = exportMemories(db, resolve(dir), { agent_id: getAgentId() });
+        console.log(`\u2705 Export complete: ${result.exported} items to ${resolve(dir)} (${result.files.length} files)`);
         db.close();
         break;
       }
@@ -1659,10 +3292,10 @@ async function main() {
         const db = openDatabase({ path: getDbPath() });
         const agentId = getAgentId();
         let imported = 0;
-        const memoryFile = ["MEMORY.md", "MEMORY.qmd"].map((f) => resolve(dirPath, f)).find((p) => existsSync2(p));
+        const memoryFile = ["MEMORY.md", "MEMORY.qmd"].map((file) => resolve(dirPath, file)).find((file) => existsSync2(file));
         if (memoryFile) {
           const content = readFileSync2(memoryFile, "utf-8");
-          const sections = content.split(/^## /m).filter((s) => s.trim());
+          const sections = content.split(/^## /m).filter((section) => section.trim());
           for (const section of sections) {
             const lines = section.split("\n");
             const title = lines[0]?.trim();
@@ -1670,40 +3303,46 @@ async function main() {
             if (!body) continue;
             const type = title?.toLowerCase().includes("\u5173\u4E8E") || title?.toLowerCase().includes("about") ? "identity" : "knowledge";
             const uri = `knowledge://memory-md/${title?.replace(/[^a-z0-9\u4e00-\u9fff]/gi, "-").toLowerCase()}`;
-            syncOne(db, { content: `## ${title}
-${body}`, type, uri, source: `migrate:${basename(memoryFile)}`, agent_id: agentId });
-            imported++;
+            await rememberMemory(db, {
+              content: `## ${title}
+${body}`,
+              type,
+              uri,
+              source: `migrate:${basename(memoryFile)}`,
+              agent_id: agentId
+            });
+            imported += 1;
           }
           console.log(`\u{1F4C4} ${basename(memoryFile)}: ${sections.length} sections imported`);
         }
-        const mdFiles = readdirSync(dirPath).filter((f) => /^\d{4}-\d{2}-\d{2}\.(md|qmd)$/.test(f)).sort();
+        const mdFiles = readdirSync(dirPath).filter((file) => /^\d{4}-\d{2}-\d{2}\.(md|qmd)$/.test(file)).sort();
         for (const file of mdFiles) {
           const content = readFileSync2(resolve(dirPath, file), "utf-8");
           const date = file.replace(/\.(md|qmd)$/i, "");
-          syncOne(db, {
+          await rememberMemory(db, {
             content,
             type: "event",
             uri: `event://journal/${date}`,
             source: `migrate:${file}`,
             agent_id: agentId
           });
-          imported++;
+          imported += 1;
         }
         if (mdFiles.length) console.log(`\u{1F4DD} Journals: ${mdFiles.length} files imported`);
         const weeklyDir = resolve(dirPath, "weekly");
         if (existsSync2(weeklyDir)) {
-          const weeklyFiles = readdirSync(weeklyDir).filter((f) => f.endsWith(".md") || f.endsWith(".qmd"));
+          const weeklyFiles = readdirSync(weeklyDir).filter((file) => file.endsWith(".md") || file.endsWith(".qmd"));
           for (const file of weeklyFiles) {
             const content = readFileSync2(resolve(weeklyDir, file), "utf-8");
             const week = file.replace(/\.(md|qmd)$/i, "");
-            syncOne(db, {
+            await rememberMemory(db, {
               content,
               type: "knowledge",
               uri: `knowledge://weekly/${week}`,
               source: `migrate:weekly/${file}`,
               agent_id: agentId
             });
-            imported++;
+            imported += 1;
           }
           if (weeklyFiles.length) console.log(`\u{1F4E6} Weekly: ${weeklyFiles.length} files imported`);
         }
@@ -1723,8 +3362,8 @@ ${body}`, type, uri, source: `migrate:${basename(memoryFile)}`, agent_id: agentI
         printHelp();
         process.exit(1);
     }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     console.error("Error:", message);
     process.exit(1);
   }