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

package/dist/mcp/server.js

@@ -31,6 +31,7 @@ function openDatabase(opts) {
     migrateDatabase(db, currentVersion, SCHEMA_VERSION);
   }
   ensureIndexes(db);
+  ensureFeedbackEventSchema(db);
   return db;
 }
 function now() {
@@ -49,6 +50,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();
@@ -70,6 +79,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})`);
   }
 }
@@ -151,14 +170,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;
@@ -171,14 +188,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 {
@@ -205,11 +245,99 @@ 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;
+  }
+}
 var SCHEMA_VERSION, SCHEMA_SQL;
 var init_db = __esm({
   "src/core/db.ts"() {
     "use strict";
-    SCHEMA_VERSION = 3;
+    SCHEMA_VERSION = 5;
     SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -272,14 +400,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
@@ -296,6 +447,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);
 `;
   }
 });
@@ -384,6 +537,361 @@ var init_tokenizer = __esm({
   }
 });
 
+// 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 url2 = 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: url2,
+        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 url2 = 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: url2,
+        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);
+}
+var init_embedding = __esm({
+  "src/search/embedding.ts"() {
+    "use strict";
+  }
+});
+
+// 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 config2 = resolveEmbeddingProviderConfig({ config: opts?.config, env: opts?.env });
+  if (!config2) return null;
+  return createEmbeddingProvider(config2, { 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;
+  }
+}
+var init_providers = __esm({
+  "src/search/providers.ts"() {
+    "use strict";
+    init_embedding();
+  }
+});
+
+// src/search/vector.ts
+function encodeVector(vector) {
+  const float322 = vector instanceof Float32Array ? vector : Float32Array.from(vector);
+  return Buffer.from(float322.buffer.slice(float322.byteOffset, float322.byteOffset + float322.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
+  }));
+}
+var init_vector = __esm({
+  "src/search/vector.ts"() {
+    "use strict";
+    init_db();
+  }
+});
+
 // src/core/memory.ts
 var memory_exports = {};
 __export(memory_exports, {
@@ -396,9 +904,22 @@ __export(memory_exports, {
   recordAccess: () => recordAccess,
   updateMemory: () => updateMemory
 });
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 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);
+}
+function resolveEmbeddingProviderId(explicitProviderId) {
+  if (explicitProviderId !== void 0) {
+    return explicitProviderId;
+  }
+  return getConfiguredEmbeddingProviderId();
+}
+function markEmbeddingDirtyIfNeeded(db, memoryId, hash2, providerId) {
+  if (!providerId) return;
+  try {
+    markMemoryEmbeddingPending(db, memoryId, providerId, hash2);
+  } catch {
+  }
 }
 function createMemory(db, input) {
   const hash2 = contentHash(input.content);
@@ -429,6 +950,7 @@ function createMemory(db, input) {
     hash2
   );
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
+  markEmbeddingDirtyIfNeeded(db, id, hash2, resolveEmbeddingProviderId(input.embedding_provider_id));
   return getMemory(db, id);
 }
 function getMemory(db, id) {
@@ -439,9 +961,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 = ?");
@@ -474,6 +998,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);
 }
@@ -531,6 +1062,8 @@ var init_memory = __esm({
     "use strict";
     init_db();
     init_tokenizer();
+    init_providers();
+    init_vector();
     TYPE_PRIORITY = {
       identity: 0,
       emotion: 1,
@@ -14366,269 +14899,73 @@ function getPathsByPrefix(db, prefix, agent_id = "default") {
   return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri LIKE ? ORDER BY uri").all(agent_id, `${prefix}%`);
 }
 
-// src/core/link.ts
-init_db();
-function createLink(db, sourceId, targetId, relation, weight = 1, agent_id) {
-  const sourceAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(sourceId)?.agent_id;
-  const targetAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(targetId)?.agent_id;
-  if (!sourceAgent) throw new Error(`Source memory not found: ${sourceId}`);
-  if (!targetAgent) throw new Error(`Target memory not found: ${targetId}`);
-  if (sourceAgent !== targetAgent) throw new Error("Cross-agent links are not allowed");
-  if (agent_id && agent_id !== sourceAgent) throw new Error("Agent mismatch for link");
-  const agentId = agent_id ?? sourceAgent;
-  db.prepare(
-    `INSERT OR REPLACE INTO links (agent_id, source_id, target_id, relation, weight, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`
-  ).run(agentId, sourceId, targetId, relation, weight, now());
-  return { agent_id: agentId, source_id: sourceId, target_id: targetId, relation, weight, created_at: now() };
-}
-function getLinks(db, memoryId, agent_id) {
-  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id ?? "default";
-  return db.prepare("SELECT * FROM links WHERE agent_id = ? AND (source_id = ? OR target_id = ?)").all(agentId, memoryId, memoryId);
-}
-function traverse(db, startId, maxHops = 2, agent_id) {
-  const agentId = agent_id ?? db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(startId)?.agent_id ?? "default";
-  const visited = /* @__PURE__ */ new Set();
-  const results = [];
-  const queue = [
-    { id: startId, hop: 0, relation: "self" }
+// src/sleep/boot.ts
+init_memory();
+function boot(db, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  const corePaths = opts?.corePaths ?? [
+    "core://agent",
+    "core://user",
+    "core://agent/identity",
+    "core://user/identity"
   ];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (visited.has(current.id)) continue;
-    visited.add(current.id);
-    if (current.hop > 0) {
-      results.push(current);
-    }
-    if (current.hop < maxHops) {
-      const links = db.prepare("SELECT target_id, relation FROM links WHERE agent_id = ? AND source_id = ?").all(agentId, current.id);
-      for (const link of links) {
-        if (!visited.has(link.target_id)) {
-          queue.push({
-            id: link.target_id,
-            hop: current.hop + 1,
-            relation: link.relation
-          });
+  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);
         }
       }
-      const reverseLinks = db.prepare("SELECT source_id, relation FROM links WHERE agent_id = ? AND target_id = ?").all(agentId, current.id);
-      for (const link of reverseLinks) {
-        if (!visited.has(link.source_id)) {
-          queue.push({
-            id: link.source_id,
-            hop: current.hop + 1,
-            relation: link.relation
-          });
+    }
+  }
+  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);
+          }
         }
       }
     }
   }
-  return results;
+  return {
+    identityMemories: [...memories.values()],
+    bootPaths
+  };
 }
 
-// src/core/snapshot.ts
-init_db();
-init_tokenizer();
-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() };
-}
-function getSnapshots(db, memoryId) {
-  return db.prepare("SELECT * FROM snapshots WHERE memory_id = ? ORDER BY created_at DESC").all(memoryId);
-}
-function getSnapshot(db, id) {
-  return db.prepare("SELECT * FROM snapshots WHERE id = ?").get(id) ?? null;
-}
-function rollback(db, snapshotId) {
-  const snapshot = getSnapshot(db, snapshotId);
-  if (!snapshot) return false;
-  createSnapshot(db, snapshot.memory_id, "update", "rollback");
-  db.prepare("UPDATE memories SET content = ?, updated_at = ? WHERE id = ?").run(
-    snapshot.content,
-    now(),
-    snapshot.memory_id
-  );
-  db.prepare("DELETE FROM memories_fts WHERE id = ?").run(snapshot.memory_id);
-  db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(
-    snapshot.memory_id,
-    tokenizeForIndex(snapshot.content)
-  );
-  return true;
-}
+// src/sleep/sync.ts
+init_memory();
 
-// src/search/intent.ts
-init_tokenizer();
-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;
-      }
-    }
-  }
-  for (const [intent, patterns] of Object.entries(CN_STRUCTURE_BOOSTS)) {
-    for (const pattern of patterns) {
-      if (pattern.test(query)) {
-        scores[intent] += 0.5;
-      }
-    }
-  }
-  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 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 };
-}
-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 };
-  }
-}
+// src/search/hybrid.ts
+init_memory();
 
-// src/search/rerank.ts
-async function rerankWithProvider(results, query, provider) {
-  if (results.length === 0) return results;
-  const documents = results.map((r) => r.memory.content);
-  try {
-    const apiResults = await provider.rerank(query, documents);
-    const scoreMap = new Map(apiResults.map((r) => [r.index, r.relevance_score]));
-    return results.map((r, i) => {
-      const score = scoreMap.get(i);
-      if (score === void 0) return r;
-      return {
-        ...r,
-        score,
-        matchReason: `${r.matchReason}+rerank`
-      };
-    });
-  } catch (err) {
-    console.warn("[agent-memory] External rerank failed, falling back:", err);
-    return results;
-  }
-}
-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;
-    }
-    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;
-    }
-    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);
-}
-
-// src/search/bm25.ts
-init_tokenizer();
-function searchBM25(db, query, opts) {
-  const limit = opts?.limit ?? 20;
-  const agentId = opts?.agent_id ?? "default";
-  const minVitality = opts?.min_vitality ?? 0;
-  const ftsQuery = buildFtsQuery(query);
-  if (!ftsQuery) return [];
+// src/search/bm25.ts
+init_tokenizer();
+function searchBM25(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  const agentId = opts?.agent_id ?? "default";
+  const minVitality = opts?.min_vitality ?? 0;
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery) return [];
   try {
     const rows = db.prepare(
       `SELECT m.*, rank AS score
@@ -14640,12 +14977,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"
       };
     });
@@ -14660,10 +14998,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"
   }));
 }
@@ -14672,384 +15010,427 @@ function buildFtsQuery(text) {
   if (tokens.length === 0) return null;
   return tokens.map((w) => `"${w}"`).join(" OR ");
 }
-
-// src/search/embeddings.ts
-init_db();
-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);
-}
-function listEmbeddings(db, agent_id, model) {
-  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) }));
+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/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);
-      }
-    }
-  }
-  return out;
-}
-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;
-}
-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, meta3] of fused) {
-    const mem = byId.get(id);
-    if (!mem) continue;
-    out.push({
-      memory: mem,
-      score: meta3.score,
-      matchReason: meta3.sources.sort().join("+")
+init_providers();
+init_vector();
+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
     });
   }
-  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;
-}
-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 });
+  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 null;
+  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
+  });
 }
-function authHeader(apiKey) {
-  return apiKey.startsWith("Bearer ") ? apiKey : `Bearer ${apiKey}`;
-}
-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;
-  });
-}
-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());
+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 data = await resp.json();
-    return normalizeEmbedding(data.data?.[0]?.embedding);
   }
-  return {
-    id: opts.id ?? "openai",
-    model: opts.model,
-    instructionPrefix,
-    async embed(text) {
-      return requestEmbedding(text);
-    },
-    async embedQuery(query) {
-      return requestEmbedding(buildQueryInput(query, instructionPrefix));
+  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 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());
+function listReindexCandidates(db, providerId, agentId, force) {
+  const rows = db.prepare(
+    `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
+  }));
+}
+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;
+      }
     }
-    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);
   }
   return {
-    id: "dashscope",
-    model: opts.model,
-    instructionPrefix,
-    async embed(text) {
-      return requestEmbedding(text);
-    },
-    async embedQuery(query) {
-      return requestEmbedding(buildQueryInput(query, instructionPrefix));
-    }
+    enabled: true,
+    providerId: provider.id,
+    scanned: candidates.length,
+    pending: candidates.length,
+    embedded,
+    failed
   };
 }
 
-// src/search/rerank-provider.ts
-function authHeader2(apiKey) {
-  return apiKey.startsWith("Bearer ") ? apiKey : `Bearer ${apiKey}`;
-}
-function getRerankerProviderFromEnv() {
-  const provider = (process.env.AGENT_MEMORY_RERANK_PROVIDER ?? "none").toLowerCase();
-  if (provider === "none" || provider === "off") return null;
-  if (provider === "openai" || provider === "jina" || provider === "cohere") {
-    const apiKey = process.env.AGENT_MEMORY_RERANK_API_KEY ?? process.env.OPENAI_API_KEY;
-    const model = process.env.AGENT_MEMORY_RERANK_MODEL ?? "Qwen/Qwen3-Reranker-8B";
-    const baseUrl = process.env.AGENT_MEMORY_RERANK_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1";
-    if (!apiKey) return null;
-    return createOpenAIRerankProvider({ apiKey, model, baseUrl });
-  }
-  return null;
-}
-function createOpenAIRerankProvider(opts) {
-  const baseUrl = opts.baseUrl ?? "https://api.openai.com/v1";
+// src/core/guard.ts
+init_providers();
+init_tokenizer();
+
+// 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 {
-    id: "openai-rerank",
-    model: opts.model,
-    async rerank(query, documents) {
-      const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/rerank`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: authHeader2(opts.apiKey)
-        },
-        body: JSON.stringify({ model: opts.model, query, documents })
-      });
-      if (!resp.ok) {
-        const body = await resp.text().catch(() => "");
-        throw new Error(`Rerank API failed: ${resp.status} ${resp.statusText} ${body}`.trim());
-      }
-      const data = await resp.json();
-      const results = data.results ?? [];
-      return results.map((r) => {
-        const index = typeof r.index === "number" ? r.index : Number.NaN;
-        const relevance = typeof r.relevance_score === "number" ? r.relevance_score : Number.NaN;
-        return { index, relevance_score: relevance };
-      }).filter((r) => Number.isInteger(r.index) && Number.isFinite(r.relevance_score));
-    }
+    strategy: "replace",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["identity canonicalized to the newest authoritative phrasing"]
+  };
+}
+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"]
   };
 }
-
-// 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;
+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);
+  }
 }
 
-// src/sleep/sync.ts
-init_memory();
-
 // src/core/guard.ts
 init_memory();
-init_tokenizer();
-function guard(db, input) {
-  const hash2 = contentHash(input.content);
-  const agentId = input.agent_id ?? "default";
-  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash2, agentId);
-  if (exactMatch) {
-    return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
+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;
   }
-  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 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;
     }
   }
-  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 (fallback) {
+    const parsed = new Date(fallback);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
     }
   }
-  const gateResult = fourCriterionGate(input);
-  if (!gateResult.pass) {
-    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
+  return null;
+}
+function timeProximity(input, memory, candidateUri) {
+  if (input.type !== "event") {
+    return 1;
   }
-  return { action: "add", reason: "Passed all guard checks" };
+  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
+  };
+}
+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 fourCriterionGate(input) {
   const content = input.content.trim();
@@ -15074,15 +15455,9 @@ function fourCriterionGate(input) {
   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;
-  }
+  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 {
@@ -15091,10 +15466,81 @@ function fourCriterionGate(input) {
     failedCriteria: failed
   };
 }
+async function guard(db, input) {
+  const hash2 = contentHash(input.content);
+  const agentId = input.agent_id ?? "default";
+  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash2, 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 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 {
+    action: "add",
+    reason: `Semantic score below merge threshold (score=${score.dedup_score.toFixed(3)})`,
+    score
+  };
+}
 
 // src/sleep/sync.ts
-init_memory();
-function syncOne(db, input) {
+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 syncOne(db, input) {
   const memInput = {
     content: input.content,
     type: input.type ?? "event",
@@ -15102,38 +15548,606 @@ function syncOne(db, input) {
     emotion_val: input.emotion_val,
     source: input.source,
     agent_id: input.agent_id,
-    uri: input.uri
+    uri: input.uri,
+    provider: input.provider,
+    conservative: input.conservative
   };
-  const guardResult = guard(db, memInput);
+  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" };
-      if (input.uri) {
+      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 };
+    }
+  }
+}
+
+// src/ingest/ingest.ts
+function slugify2(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "item";
+}
+function classifyIngestType(title) {
+  const normalized = title.toLowerCase();
+  if (normalized.includes("\u60C5\u611F") || normalized.includes("emotion")) return "emotion";
+  if (normalized.includes("\u4E8B\u4EF6") || normalized.includes("event") || normalized.includes("journal")) return "event";
+  if (normalized.includes("\u8EAB\u4EFD") || normalized.includes("identity") || normalized.includes("about")) return "identity";
+  return "knowledge";
+}
+function splitIngestBlocks(text) {
+  const sections = text.split(/^##\s+/m).filter((section) => section.trim());
+  if (sections.length === 0) {
+    return [{ title: "knowledge", body: text.trim() }];
+  }
+  return sections.map((section) => {
+    const [titleLine, ...rest] = section.split("\n");
+    return {
+      title: titleLine?.trim() || "knowledge",
+      body: rest.join("\n").trim()
+    };
+  }).filter((section) => section.body.length > 0);
+}
+function extractIngestItems(text, source) {
+  const blocks = splitIngestBlocks(text);
+  const items = [];
+  let index = 0;
+  for (const block of blocks) {
+    const type = classifyIngestType(block.title);
+    const bulletItems = block.body.split(/\n+/).map((line) => line.replace(/^[-*]\s*/, "").trim()).filter(Boolean);
+    const lines = bulletItems.length > 0 ? bulletItems : [block.body.trim()];
+    for (const line of lines) {
+      index += 1;
+      const uri = type === "identity" ? `core://ingest/${slugify2(block.title)}/${index}` : `${type}://${slugify2(source ?? "ingest")}/${index}`;
+      items.push({
+        index,
+        type,
+        uri,
+        content: line
+      });
+    }
+  }
+  return items;
+}
+async function ingestText(db, options) {
+  const extracted = extractIngestItems(options.text, options.source);
+  const dryRun = options.dryRun ?? false;
+  const agentId = options.agentId ?? "default";
+  if (dryRun) {
+    return {
+      extracted: extracted.length,
+      written: 0,
+      skipped: extracted.length,
+      dry_run: true,
+      details: extracted.map((item) => ({
+        index: item.index,
+        type: item.type,
+        uri: item.uri,
+        preview: item.content.slice(0, 80)
+      }))
+    };
+  }
+  let written = 0;
+  let skipped = 0;
+  const details = [];
+  for (const item of extracted) {
+    const result = await syncOne(db, {
+      content: item.content,
+      type: item.type,
+      uri: item.uri,
+      source: `auto:${options.source ?? "ingest"}`,
+      agent_id: agentId
+    });
+    if (result.action === "added" || result.action === "updated" || result.action === "merged") {
+      written += 1;
+    } else {
+      skipped += 1;
+    }
+    details.push({
+      index: item.index,
+      type: item.type,
+      uri: item.uri,
+      action: result.action,
+      reason: result.reason,
+      memoryId: result.memoryId
+    });
+  }
+  return {
+    extracted: extracted.length,
+    written,
+    skipped,
+    dry_run: false,
+    details
+  };
+}
+
+// src/ingest/watcher.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, statSync, watch } from "fs";
+import { join, relative, resolve } from "path";
+function runAutoIngestWatcher(options) {
+  const workspaceDir = resolve(options.workspaceDir);
+  const memoryDir = join(workspaceDir, "memory");
+  const memoryMdPath = join(workspaceDir, "MEMORY.md");
+  const debounceMs = options.debounceMs ?? 1200;
+  const initialScan = options.initialScan ?? true;
+  const logger = options.logger ?? console;
+  const timers = /* @__PURE__ */ new Map();
+  const watchers = [];
+  const stats = {
+    triggers: 0,
+    filesProcessed: 0,
+    extracted: 0,
+    written: 0,
+    skipped: 0,
+    errors: 0
+  };
+  let stopped = false;
+  let queue = Promise.resolve();
+  const toSource = (absPath) => {
+    const rel = relative(workspaceDir, absPath).replace(/\\/g, "/");
+    return rel || absPath;
+  };
+  const isTrackedMarkdownFile = (absPath) => {
+    if (!absPath.endsWith(".md")) return false;
+    if (resolve(absPath) === memoryMdPath) return true;
+    const rel = relative(memoryDir, absPath).replace(/\\/g, "/");
+    if (rel.startsWith("..") || rel === "") return false;
+    return !rel.includes("/");
+  };
+  const ingestFile = async (absPath, reason) => {
+    if (stopped) return;
+    if (!existsSync(absPath)) {
+      logger.log(`[auto-ingest] skip missing file: ${toSource(absPath)} (reason=${reason})`);
+      return;
+    }
+    let isFile = false;
+    try {
+      isFile = statSync(absPath).isFile();
+    } catch (err) {
+      stats.errors += 1;
+      logger.warn(`[auto-ingest] stat failed for ${toSource(absPath)}: ${String(err)}`);
+      return;
+    }
+    if (!isFile) return;
+    try {
+      const text = readFileSync2(absPath, "utf-8");
+      const source = toSource(absPath);
+      const result = await ingestText(options.db, {
+        text,
+        source,
+        agentId: options.agentId
+      });
+      stats.filesProcessed += 1;
+      stats.extracted += result.extracted;
+      stats.written += result.written;
+      stats.skipped += result.skipped;
+      logger.log(
+        `[auto-ingest] file=${source} reason=${reason} extracted=${result.extracted} written=${result.written} skipped=${result.skipped}`
+      );
+    } catch (err) {
+      stats.errors += 1;
+      logger.error(`[auto-ingest] ingest failed for ${toSource(absPath)}: ${String(err)}`);
+    }
+  };
+  const scheduleIngest = (absPath, reason) => {
+    if (stopped) return;
+    if (!isTrackedMarkdownFile(absPath)) return;
+    stats.triggers += 1;
+    const previous = timers.get(absPath);
+    if (previous) clearTimeout(previous);
+    const timer = setTimeout(() => {
+      timers.delete(absPath);
+      queue = queue.then(() => ingestFile(absPath, reason)).catch((err) => {
+        stats.errors += 1;
+        logger.error(`[auto-ingest] queue error: ${String(err)}`);
+      });
+    }, debounceMs);
+    timers.set(absPath, timer);
+  };
+  const safeWatch = (dir, onEvent) => {
+    if (!existsSync(dir)) {
+      logger.warn(`[auto-ingest] watch path does not exist, skipping: ${dir}`);
+      return;
+    }
+    try {
+      const watcher = watch(dir, { persistent: true }, (eventType, filename) => {
+        if (!filename) return;
+        onEvent(eventType, filename.toString());
+      });
+      watchers.push(watcher);
+      logger.log(`[auto-ingest] watching ${dir}`);
+    } catch (err) {
+      stats.errors += 1;
+      logger.error(`[auto-ingest] failed to watch ${dir}: ${String(err)}`);
+    }
+  };
+  safeWatch(workspaceDir, (eventType, filename) => {
+    if (filename === "MEMORY.md") {
+      scheduleIngest(join(workspaceDir, filename), `workspace:${eventType}`);
+    }
+  });
+  safeWatch(memoryDir, (eventType, filename) => {
+    if (filename.endsWith(".md")) {
+      scheduleIngest(join(memoryDir, filename), `memory:${eventType}`);
+    }
+  });
+  if (initialScan) {
+    scheduleIngest(memoryMdPath, "initial");
+    if (existsSync(memoryDir)) {
+      for (const file2 of readdirSync(memoryDir)) {
+        if (file2.endsWith(".md")) {
+          scheduleIngest(join(memoryDir, file2), "initial");
+        }
+      }
+    }
+  }
+  return {
+    close: () => {
+      if (stopped) return;
+      stopped = true;
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      for (const watcher of watchers) {
         try {
-          createPath(db, mem.id, input.uri);
+          watcher.close();
         } catch {
         }
       }
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+      logger.log(
+        `[auto-ingest] stopped triggers=${stats.triggers} files=${stats.filesProcessed} extracted=${stats.extracted} written=${stats.written} skipped=${stats.skipped} errors=${stats.errors}`
+      );
+    }
+  };
+}
+
+// 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
+  });
+}
+
+// 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/surface.ts
+init_memory();
+init_providers();
+init_tokenizer();
+init_vector();
+
+// src/app/feedback.ts
+init_db();
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, 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)
+    };
+  }
+}
+
+// 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 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));
+}
+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;
+  }
+}
+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;
     }
-    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 };
+    if (similarity) {
+      const currentSimilarity = similarity.get(row.memory.id);
+      if (currentSimilarity !== void 0) {
+        existing.semanticSimilarity = Math.max(existing.semanticSimilarity ?? 0, currentSimilarity);
+      }
     }
-    case "merge": {
-      if (!guardResult.existingId || !guardResult.mergedContent) {
-        return { action: "skipped", reason: "Missing merge data" };
+    signals.set(row.memory.id, existing);
+  }
+}
+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);
       }
-      createSnapshot(db, guardResult.existingId, "merge", "sync");
-      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
-      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+    } 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 {
+    count: results.length,
+    query: trimmedQuery,
+    task: trimmedTask,
+    intent: input.intent,
+    results
+  };
 }
 
 // src/sleep/decay.ts
@@ -15201,59 +16215,99 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
 init_memory();
 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++;
-    }
-    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;
+      archived += 1;
     }
   });
   transaction();
-  return { archived, orphansCleaned, snapshotsPruned };
+  return { archived, orphansCleaned: 0 };
 }
 
 // src/sleep/govern.ts
+init_memory();
+init_tokenizer();
+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;
+  });
+}
 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
@@ -15261,190 +16315,509 @@ 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/sleep/boot.ts
-init_memory();
-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);
+// src/sleep/jobs.ts
+init_db();
+function parseCheckpoint(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  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 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, error48, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET status = 'failed',
+         checkpoint = COALESCE(?, checkpoint),
+         error = ?,
+         finished_at = ?
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), error48, 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 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);
-          }
-        }
-      }
+  if (opts.resume !== false) {
+    const resumable = findResumableMaintenanceJob(db, opts.phase);
+    if (resumable) {
+      return { job: resumable, resumed: true };
     }
   }
   return {
-    identityMemories: [...memories.values()],
-    bootPaths
+    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 (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    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 });
+  }
+  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
+  };
+}
+
+// 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
+init_memory();
+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 (error48) {
+    input?.onProgress?.({
+      status: "failed",
+      stage: "done",
+      progress: 1,
+      detail: error48 instanceof Error ? error48.message : String(error48)
+    });
+    throw error48;
+  }
+}
+
 // src/mcp/server.ts
 var DB_PATH = process.env.AGENT_MEMORY_DB ?? "./agent-memory.db";
 var AGENT_ID = process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+function formatMemory(memory, score) {
+  return {
+    id: memory.id,
+    uri: null,
+    content: memory.content,
+    type: memory.type,
+    priority: memory.priority,
+    vitality: memory.vitality,
+    score,
+    updated_at: memory.updated_at
+  };
+}
+function formatWarmBootNarrative(identities, emotions, knowledges, events, totalStats) {
+  const currentTime = Date.now();
+  const sevenDaysAgo = currentTime - 7 * 24 * 60 * 60 * 1e3;
+  const recentEvents = events.filter((event) => new Date(event.updated_at).getTime() >= sevenDaysAgo);
+  const olderEventCount = Math.max(0, events.length - recentEvents.length);
+  const avgVitalitySource = [...identities, ...emotions, ...knowledges, ...events];
+  const avgVitality = avgVitalitySource.length ? avgVitalitySource.reduce((sum, memory) => sum + memory.vitality, 0) / avgVitalitySource.length : 0;
+  const lines = [];
+  lines.push("## \u{1FAAA} \u6211\u662F\u8C01");
+  if (identities.length === 0) {
+    lines.push("\u6682\u65E0\u8EAB\u4EFD\u8BB0\u5FC6\u3002");
+  } else {
+    for (const memory of identities.slice(0, 6)) {
+      lines.push(`- ${memory.content.slice(0, 140)}`);
+    }
+  }
+  lines.push("", "## \u{1F495} \u6700\u8FD1\u7684\u60C5\u611F");
+  if (emotions.length === 0) {
+    lines.push("\u6682\u65E0\u60C5\u611F\u8BB0\u5FC6\u3002");
+  } else {
+    for (const memory of emotions.slice(0, 6)) {
+      lines.push(`- ${memory.content.slice(0, 140)}\uFF08vitality: ${memory.vitality.toFixed(2)}\uFF09`);
+    }
+  }
+  lines.push("", "## \u{1F9E0} \u5173\u952E\u77E5\u8BC6");
+  if (knowledges.length === 0) {
+    lines.push("\u6682\u65E0\u77E5\u8BC6\u8BB0\u5FC6\u3002");
+  } else {
+    lines.push(`\u5171 ${knowledges.length} \u6761\u6D3B\u8DC3\u77E5\u8BC6\u8BB0\u5FC6`);
+    for (const memory of knowledges.slice(0, 8)) {
+      lines.push(`- ${memory.content.slice(0, 140)}\uFF08vitality: ${memory.vitality.toFixed(2)}\uFF09`);
+    }
+  }
+  lines.push("", "## \u{1F4C5} \u8FD1\u671F\u4E8B\u4EF6");
+  if (recentEvents.length === 0) {
+    lines.push("\u6700\u8FD1 7 \u5929\u65E0\u4E8B\u4EF6\u8BB0\u5FC6\u3002");
+  } else {
+    lines.push("\u6700\u8FD1 7 \u5929\u5185\u7684\u4E8B\u4EF6\uFF1A");
+    for (const memory of recentEvents.slice(0, 8)) {
+      lines.push(`- [${memory.updated_at.slice(5, 10)}] ${memory.content.slice(0, 120)}`);
+    }
+  }
+  if (olderEventCount > 0) {
+    lines.push(`- ... \u53CA ${olderEventCount} \u6761\u66F4\u65E9\u4E8B\u4EF6`);
+  }
+  lines.push("", "## \u{1F4CA} \u8BB0\u5FC6\u6982\u51B5");
+  lines.push(
+    `\u603B\u8BA1 ${totalStats.total} \u6761 | identity: ${totalStats.by_type.identity ?? 0} | emotion: ${totalStats.by_type.emotion ?? 0} | knowledge: ${totalStats.by_type.knowledge ?? 0} | event: ${totalStats.by_type.event ?? 0}`
+  );
+  lines.push(`\u5E73\u5747 vitality: ${avgVitality.toFixed(2)}`);
+  return lines.join("\n");
+}
+function getSummaryStats2(db, agentId) {
+  const row = db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories WHERE agent_id = ?").get(agentId);
+  return { total: row.total, avgVitality: row.avg };
+}
+function formatReflectReport(input) {
+  const lines = [];
+  lines.push("## \u{1F319} Sleep Cycle \u62A5\u544A", "");
+  lines.push(`job: ${input.jobId}${input.resumed ? "\uFF08resume\uFF09" : ""}`);
+  lines.push(`phase: ${input.phase}`, "");
+  for (const phase of ["decay", "tidy", "govern"]) {
+    if (input.phase !== "all" && input.phase !== phase) continue;
+    lines.push(`### ${phase}`);
+    lines.push(JSON.stringify(input.results[phase] ?? {}, null, 2));
+    lines.push("");
+  }
+  lines.push("### \u{1F4CA} \u603B\u7ED3");
+  const delta = input.after.total - input.before.total;
+  const deltaLabel = delta > 0 ? `+${delta}` : `${delta}`;
+  lines.push(`\u8BB0\u5FC6\u603B\u6570\uFF1A${input.before.total} \u2192 ${input.after.total}\uFF08${deltaLabel}\uFF09`);
+  lines.push(`\u5E73\u5747 vitality\uFF1A${input.before.avgVitality.toFixed(2)} \u2192 ${input.after.avgVitality.toFixed(2)}`);
+  return lines.join("\n");
+}
+function formatRecallPayload(result) {
+  return {
+    mode: result.mode,
+    provider_id: result.providerId,
+    count: result.results.length,
+    memories: result.results.map((row) => ({
+      ...formatMemory(row.memory, row.score),
+      bm25_rank: row.bm25_rank,
+      vector_rank: row.vector_rank,
+      bm25_score: row.bm25_score,
+      vector_score: row.vector_score
+    }))
+  };
+}
+function formatSurfacePayload(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,
+      reason_codes: row.reason_codes,
+      updated_at: row.memory.updated_at
+    }))
+  };
+}
 function createMcpServer(dbPath, agentId) {
   const db = openDatabase({ path: dbPath ?? DB_PATH });
   const aid = agentId ?? AGENT_ID;
-  const embeddingProvider = getEmbeddingProviderFromEnv();
-  const rerankerProvider = getRerankerProviderFromEnv();
   const server = new McpServer({
     name: "agent-memory",
-    version: "2.1.0"
+    version: "4.0.0-alpha.1"
   });
   server.tool(
     "remember",
-    "Store a memory. Runs Write Guard (dedup + conflict detection + 4-criterion gate). Optionally assign a URI path.",
+    "Store a memory. Runs Write Guard (semantic dedup + merge policy + four-criterion gate). Optionally assign a URI path.",
     {
       content: external_exports.string().describe("Memory content to store"),
       type: external_exports.enum(["identity", "emotion", "knowledge", "event"]).default("knowledge").describe("Memory type (determines priority and decay rate)"),
       uri: external_exports.string().optional().describe("URI path (e.g. core://user/name, emotion://2026-02-20/love)"),
       emotion_val: external_exports.number().min(-1).max(1).default(0).describe("Emotional valence (-1 negative to +1 positive)"),
-      source: external_exports.string().optional().describe("Source annotation (e.g. session ID, date)")
+      source: external_exports.string().optional().describe("Source annotation (e.g. session ID, date)"),
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
     },
-    async ({ content, type, uri, emotion_val, source }) => {
-      const result = syncOne(db, { content, type, uri, emotion_val, source, agent_id: aid });
-      if (embeddingProvider && result.memoryId && (result.action === "added" || result.action === "updated" || result.action === "merged")) {
-        try {
-          await embedMemory(db, result.memoryId, embeddingProvider, { agent_id: aid });
-        } catch {
-        }
-      }
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
+    async ({ content, type, uri, emotion_val, source, agent_id }) => {
+      const result = await rememberMemory(db, { content, type, uri, emotion_val, source, agent_id: agent_id ?? aid });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
   server.tool(
     "recall",
-    "Search memories using intent-aware BM25 search with priority weighting. Automatically classifies query intent (factual/temporal/causal/exploratory).",
+    "Search memories using optional hybrid retrieval (BM25 + vector). Falls back to BM25-only when no embedding provider is configured.",
     {
       query: external_exports.string().describe("Search query (natural language)"),
-      limit: external_exports.number().default(10).describe("Max results to return")
+      limit: external_exports.number().default(10).describe("Max results to return"),
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
     },
-    async ({ query, limit }) => {
-      const { intent, confidence } = classifyIntent(query);
-      const strategy = getStrategy(intent);
-      let raw = await searchHybrid(db, query, { agent_id: aid, embeddingProvider, limit: limit * 2 });
-      if (rerankerProvider) {
-        raw = await rerankWithProvider(raw, query, rerankerProvider);
-      }
-      const results = rerank(raw, { ...strategy, limit });
-      const output = {
-        intent,
-        confidence,
-        count: results.length,
-        memories: results.map((r) => ({
-          id: r.memory.id,
-          content: r.memory.content,
-          type: r.memory.type,
-          priority: r.memory.priority,
-          vitality: r.memory.vitality,
-          score: r.score,
-          updated_at: r.memory.updated_at
-        }))
-      };
-      for (const r of results) {
-        recordAccess(db, r.memory.id);
-      }
-      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    async ({ query, limit, agent_id }) => {
+      const result = await recallMemory(db, { query, limit, agent_id: agent_id ?? aid });
+      return { content: [{ type: "text", text: JSON.stringify(formatRecallPayload(result), null, 2) }] };
     }
   );
   server.tool(
     "recall_path",
-    "Read memory at a specific URI path, or list memories under a URI prefix. Supports multi-hop traversal.",
+    "Read memory at a specific URI path, or list memories under a URI prefix.",
     {
       uri: external_exports.string().describe("URI path (e.g. core://user/name) or prefix (e.g. core://user/)"),
-      traverse_hops: external_exports.number().default(0).describe("Multi-hop graph traversal depth (0 = direct only)")
+      traverse_hops: external_exports.number().default(0).describe("Traversal depth (deprecated, reserved for compatibility)")
     },
-    async ({ uri, traverse_hops }) => {
+    async ({ uri }) => {
       const path = getPathByUri(db, uri, aid);
       if (path) {
-        const mem = getMemory(db, path.memory_id);
-        if (mem && mem.agent_id === aid) {
-          recordAccess(db, mem.id);
-          let related = [];
-          if (traverse_hops > 0) {
-            const hops = traverse(db, mem.id, traverse_hops, aid);
-            related = hops.map((h) => {
-              const m = getMemory(db, h.id);
-              if (!m || m.agent_id !== aid) return { id: h.id, content: "", relation: h.relation, hop: h.hop };
-              return { id: h.id, content: m.content, relation: h.relation, hop: h.hop };
-            });
-          }
+        const memory = getMemory(db, path.memory_id);
+        if (memory && memory.agent_id === aid) {
+          recordAccess(db, memory.id);
           return {
-            content: [{
-              type: "text",
-              text: JSON.stringify({ found: true, memory: mem, related }, null, 2)
-            }]
+            content: [{ type: "text", text: JSON.stringify({ found: true, memory }, null, 2) }]
           };
         }
       }
       const paths = getPathsByPrefix(db, uri, aid);
       if (paths.length > 0) {
-        const memories = paths.map((p) => {
-          const m = getMemory(db, p.memory_id);
-          if (!m || m.agent_id !== aid) return { uri: p.uri, content: void 0, type: void 0, priority: void 0 };
-          return { uri: p.uri, content: m.content, type: m.type, priority: m.priority };
+        const memories = paths.map((entry) => {
+          const memory = getMemory(db, entry.memory_id);
+          if (!memory || memory.agent_id !== aid) {
+            return { uri: entry.uri, content: void 0, type: void 0, priority: void 0 };
+          }
+          return {
+            uri: entry.uri,
+            content: memory.content,
+            type: memory.type,
+            priority: memory.priority,
+            vitality: memory.vitality
+          };
         });
         return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({ found: true, prefix: uri, count: paths.length, memories }, null, 2)
-          }]
+          content: [{ type: "text", text: JSON.stringify({ found: true, prefix: uri, count: paths.length, memories }, null, 2) }]
         };
       }
       return { content: [{ type: "text", text: JSON.stringify({ found: false, uri }, null, 2) }] };
@@ -15452,21 +16825,36 @@ function createMcpServer(dbPath, agentId) {
   );
   server.tool(
     "boot",
-    "Load core identity memories (P0) and system://boot entries. Call this when starting a new session.",
-    {},
-    async () => {
-      const result = boot(db, { agent_id: aid });
-      const output = {
-        count: result.identityMemories.length,
-        bootPaths: result.bootPaths,
-        memories: result.identityMemories.map((m) => ({
-          id: m.id,
-          content: m.content,
-          type: m.type,
-          priority: m.priority
-        }))
-      };
-      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
+    "Load startup memories. Default output is narrative markdown; pass format=json for legacy output.",
+    {
+      format: external_exports.enum(["narrative", "json"]).default("narrative").optional()
+    },
+    async ({ format }) => {
+      const outputFormat = format ?? "narrative";
+      const base = boot(db, { agent_id: aid });
+      if (outputFormat === "json") {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: base.identityMemories.length,
+              bootPaths: base.bootPaths,
+              memories: base.identityMemories.map((memory) => ({
+                id: memory.id,
+                content: memory.content,
+                type: memory.type,
+                priority: memory.priority
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+      const identity = listMemories(db, { agent_id: aid, type: "identity", limit: 12 });
+      const emotion = listMemories(db, { agent_id: aid, type: "emotion", min_vitality: 0.1, limit: 12 }).sort((a, b) => b.vitality - a.vitality);
+      const knowledge = listMemories(db, { agent_id: aid, type: "knowledge", min_vitality: 0.1, limit: 16 }).sort((a, b) => b.vitality - a.vitality);
+      const event = listMemories(db, { agent_id: aid, type: "event", min_vitality: 0, limit: 24 }).sort((a, b) => b.vitality - a.vitality);
+      const stats = countMemories(db, aid);
+      return { content: [{ type: "text", text: formatWarmBootNarrative(identity.length > 0 ? identity : base.identityMemories, emotion, knowledge, event, stats) }] };
     }
   );
   server.tool(
@@ -15477,126 +16865,123 @@ function createMcpServer(dbPath, agentId) {
       hard: external_exports.boolean().default(false).describe("Hard delete (true) or soft decay (false)")
     },
     async ({ id, hard }) => {
-      const mem = getMemory(db, id);
-      if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
+      const memory = getMemory(db, id);
+      if (!memory || memory.agent_id !== aid) {
+        return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
+      }
       if (hard) {
-        createSnapshot(db, id, "delete", "forget");
         const { deleteMemory: deleteMemory2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
         deleteMemory2(db, id);
         return { content: [{ type: "text", text: JSON.stringify({ action: "deleted", id }) }] };
       }
-      updateMemory(db, id, { vitality: Math.max(0, mem.vitality * 0.1) });
+      updateMemory(db, id, { vitality: Math.max(0, memory.vitality * 0.1) });
       return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({ action: "decayed", id, new_vitality: mem.vitality * 0.1 })
-        }]
+        content: [{ type: "text", text: JSON.stringify({ action: "decayed", id, new_vitality: memory.vitality * 0.1 }) }]
       };
     }
   );
   server.tool(
-    "link",
-    "Create or query associations between memories (knowledge graph).",
+    "reflect",
+    "Trigger sleep cycle phases via the maintenance orchestrator and return a human-readable markdown report.",
     {
-      action: external_exports.enum(["create", "query", "traverse"]).describe("Action to perform"),
-      source_id: external_exports.string().optional().describe("Source memory ID"),
-      target_id: external_exports.string().optional().describe("Target memory ID (for create)"),
-      relation: external_exports.enum(["related", "caused", "reminds", "evolved", "contradicts"]).optional().describe("Relation type"),
-      max_hops: external_exports.number().default(2).describe("Max traversal depth (for traverse action)")
+      phase: external_exports.enum(["decay", "tidy", "govern", "all"]).describe("Which sleep phase to run"),
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
     },
-    async ({ action, source_id, target_id, relation, max_hops }) => {
-      if (action === "create" && source_id && target_id && relation) {
-        const link = createLink(db, source_id, target_id, relation, 1, aid);
-        return { content: [{ type: "text", text: JSON.stringify({ created: link }) }] };
-      }
-      if (action === "query" && source_id) {
-        const links = getLinks(db, source_id, aid);
-        return { content: [{ type: "text", text: JSON.stringify({ links }) }] };
-      }
-      if (action === "traverse" && source_id) {
-        const nodes = traverse(db, source_id, max_hops, aid);
-        const detailed = nodes.map((n) => {
-          const m = getMemory(db, n.id);
-          if (!m || m.agent_id !== aid) return { ...n, content: void 0 };
-          return { ...n, content: m.content };
-        });
-        return { content: [{ type: "text", text: JSON.stringify({ nodes: detailed }) }] };
-      }
-      return { content: [{ type: "text", text: '{"error": "Invalid action or missing params"}' }] };
+    async ({ phase, agent_id }) => {
+      const effectiveAgentId = agent_id ?? aid;
+      const before = getSummaryStats2(db, effectiveAgentId);
+      const result = await reflectMemories(db, { phase, agent_id: effectiveAgentId });
+      const after = getSummaryStats2(db, effectiveAgentId);
+      const report = formatReflectReport({
+        phase,
+        jobId: result.jobId,
+        resumed: result.resumed,
+        before,
+        after,
+        results: result.results
+      });
+      return { content: [{ type: "text", text: report }] };
     }
   );
   server.tool(
-    "snapshot",
-    "View or rollback memory snapshots (version history).",
+    "status",
+    "Get memory system statistics: counts by type/priority and health metrics.",
     {
-      action: external_exports.enum(["list", "rollback"]).describe("list snapshots or rollback to one"),
-      memory_id: external_exports.string().optional().describe("Memory ID (for list)"),
-      snapshot_id: external_exports.string().optional().describe("Snapshot ID (for rollback)")
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
     },
-    async ({ action, memory_id, snapshot_id }) => {
-      if (action === "list" && memory_id) {
-        const mem = getMemory(db, memory_id);
-        if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Memory not found"}' }] };
-        const snaps = getSnapshots(db, memory_id);
-        return { content: [{ type: "text", text: JSON.stringify({ snapshots: snaps }) }] };
-      }
-      if (action === "rollback" && snapshot_id) {
-        const snap = getSnapshot(db, snapshot_id);
-        if (!snap) return { content: [{ type: "text", text: '{"error": "Snapshot not found"}' }] };
-        const mem = getMemory(db, snap.memory_id);
-        if (!mem || mem.agent_id !== aid) return { content: [{ type: "text", text: '{"error": "Snapshot not found"}' }] };
-        const ok = rollback(db, snapshot_id);
-        return { content: [{ type: "text", text: JSON.stringify({ rolled_back: ok }) }] };
-      }
-      return { content: [{ type: "text", text: '{"error": "Invalid action or missing params"}' }] };
+    async ({ agent_id }) => {
+      const stats = getMemoryStatus(db, { agent_id: agent_id ?? aid });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(stats, null, 2)
+        }]
+      };
     }
   );
   server.tool(
-    "reflect",
-    "Trigger sleep cycle phases: decay (Ebbinghaus), tidy (archive + cleanup), or govern (orphan removal).",
+    "ingest",
+    "Extract structured memories from markdown text and write via syncOne().",
     {
-      phase: external_exports.enum(["decay", "tidy", "govern", "all"]).describe("Which sleep phase to run")
+      text: external_exports.string().describe("Markdown/plain text to ingest"),
+      source: external_exports.string().optional().describe("Source annotation, e.g. memory/2026-02-23.md"),
+      dry_run: external_exports.boolean().default(false).optional().describe("Preview extraction without writing")
     },
-    async ({ phase }) => {
-      const results = {};
-      if (phase === "decay" || phase === "all") {
-        results.decay = runDecay(db, { agent_id: aid });
-      }
-      if (phase === "tidy" || phase === "all") {
-        results.tidy = runTidy(db, { agent_id: aid });
-      }
-      if (phase === "govern" || phase === "all") {
-        results.govern = runGovern(db, { agent_id: aid });
-      }
-      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    async ({ text, source, dry_run }) => {
+      const result = await ingestText(db, {
+        text,
+        source,
+        dryRun: dry_run,
+        agentId: aid
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
   server.tool(
-    "status",
-    "Get memory system statistics: counts by type/priority, health metrics.",
-    {},
-    async () => {
-      const stats = countMemories(db, aid);
-      const lowVitality = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?").get(aid);
-      const totalSnapshots = db.prepare(
-        `SELECT COUNT(*) as c
-           FROM snapshots s
-           JOIN memories m ON m.id = s.memory_id
-           WHERE m.agent_id = ?`
-      ).get(aid);
-      const totalLinks = db.prepare("SELECT COUNT(*) as c FROM links WHERE agent_id = ?").get(aid);
-      const totalPaths = db.prepare("SELECT COUNT(*) as c FROM paths WHERE agent_id = ?").get(aid);
+    "reindex",
+    "Rebuild BM25 index and (optionally) embedding vectors for the current agent.",
+    {
+      full: external_exports.boolean().default(false).optional().describe("Force full embedding rebuild instead of incremental backfill"),
+      batch_size: external_exports.number().min(1).max(128).default(16).optional().describe("Embedding batch size for reindex"),
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)")
+    },
+    async ({ full, batch_size, agent_id }) => {
+      const result = await reindexMemories(db, {
+        agent_id: agent_id ?? aid,
+        force: full ?? false,
+        batchSize: batch_size ?? 16
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.tool(
+    "surface",
+    "Context-aware readonly memory surfacing with query/task/recent_turns/intent scoring (no access recording).",
+    {
+      query: external_exports.string().optional().describe("Optional semantic query for surfacing"),
+      task: external_exports.string().optional().describe("Current task description"),
+      recent_turns: external_exports.array(external_exports.string()).optional().describe("Recent conversation turns for context"),
+      intent: external_exports.enum(["factual", "preference", "temporal", "planning", "design"]).optional().describe("Surface intent bias"),
+      types: external_exports.array(external_exports.enum(["identity", "emotion", "knowledge", "event"]).describe("Optional type filter")).optional(),
+      limit: external_exports.number().min(1).max(20).default(5).optional().describe("Max results (default 5, max 20)"),
+      agent_id: external_exports.string().optional().describe("Override agent scope (defaults to current agent)"),
+      keywords: external_exports.array(external_exports.string()).optional().describe("Deprecated alias: joined into query when query is omitted")
+    },
+    async ({ query, task, recent_turns, intent, types, limit, agent_id, keywords }) => {
+      const resolvedQuery = query ?? keywords?.join(" ");
+      const result = await surfaceMemories(db, {
+        query: resolvedQuery,
+        task,
+        recent_turns,
+        intent,
+        types,
+        limit: limit ?? 5,
+        agent_id: agent_id ?? aid
+      });
       return {
         content: [{
           type: "text",
-          text: JSON.stringify({
-            ...stats,
-            paths: totalPaths.c,
-            links: totalLinks.c,
-            snapshots: totalSnapshots.c,
-            low_vitality: lowVitality.c,
-            agent_id: aid
-          }, null, 2)
+          text: JSON.stringify(formatSurfacePayload(result), null, 2)
         }]
       };
     }
@@ -15604,8 +16989,25 @@ function createMcpServer(dbPath, agentId) {
   return { server, db };
 }
 async function main() {
-  const { server } = createMcpServer();
+  const { server, db } = createMcpServer();
   const transport = new StdioServerTransport();
+  const autoIngestEnabled = process.env.AGENT_MEMORY_AUTO_INGEST !== "0";
+  const workspaceDir = process.env.AGENT_MEMORY_WORKSPACE ?? `${process.env.HOME ?? "."}/.openclaw/workspace`;
+  const agentId = process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+  const watcher = autoIngestEnabled ? runAutoIngestWatcher({
+    db,
+    workspaceDir,
+    agentId
+  }) : null;
+  const shutdown = () => {
+    try {
+      watcher?.close();
+    } catch {
+    }
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  process.once("exit", shutdown);
   await server.connect(transport);
 }
 var isMain = process.argv[1]?.includes("server");