@smyslenny/agent-memory 3.1.0 → 4.1.0-alpha.1

package/dist/bin/agent-memory.js

@@ -1,97 +1,18 @@
 #!/usr/bin/env node
 // AgentMemory v2 — Sleep-cycle memory for AI agents
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/core/db.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
-var SCHEMA_VERSION = 3;
-var SCHEMA_SQL = `
--- Memory entries
-CREATE TABLE IF NOT EXISTS memories (
-  id            TEXT PRIMARY KEY,
-  content       TEXT NOT NULL,
-  type          TEXT NOT NULL CHECK(type IN ('identity','emotion','knowledge','event')),
-  priority      INTEGER NOT NULL DEFAULT 2 CHECK(priority BETWEEN 0 AND 3),
-  emotion_val   REAL NOT NULL DEFAULT 0.0,
-  vitality      REAL NOT NULL DEFAULT 1.0,
-  stability     REAL NOT NULL DEFAULT 1.0,
-  access_count  INTEGER NOT NULL DEFAULT 0,
-  last_accessed TEXT,
-  created_at    TEXT NOT NULL,
-  updated_at    TEXT NOT NULL,
-  source        TEXT,
-  agent_id      TEXT NOT NULL DEFAULT 'default',
-  hash          TEXT,
-  UNIQUE(hash, agent_id)
-);
-
--- URI paths (Content-Path separation, from nocturne)
-CREATE TABLE IF NOT EXISTS paths (
-  id          TEXT PRIMARY KEY,
-  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  agent_id    TEXT NOT NULL DEFAULT 'default',
-  uri         TEXT NOT NULL,
-  alias       TEXT,
-  domain      TEXT NOT NULL,
-  created_at  TEXT NOT NULL,
-  UNIQUE(agent_id, uri)
-);
-
--- Association network (knowledge graph)
-CREATE TABLE IF NOT EXISTS links (
-  agent_id    TEXT NOT NULL DEFAULT 'default',
-  source_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  target_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  relation    TEXT NOT NULL,
-  weight      REAL NOT NULL DEFAULT 1.0,
-  created_at  TEXT NOT NULL,
-  PRIMARY KEY (agent_id, source_id, target_id)
-);
-
--- Snapshots (version control, from nocturne + Memory Palace)
-CREATE TABLE IF NOT EXISTS snapshots (
-  id          TEXT PRIMARY KEY,
-  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
-  content     TEXT NOT NULL,
-  changed_by  TEXT,
-  action      TEXT NOT NULL CHECK(action IN ('create','update','delete','merge')),
-  created_at  TEXT NOT NULL
-);
-
--- Full-text search index (BM25)
-CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-  id UNINDEXED,
-  content,
-  tokenize='unicode61'
-);
-
--- 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)
-);
-
--- Schema version tracking
-CREATE TABLE IF NOT EXISTS schema_meta (
-  key   TEXT PRIMARY KEY,
-  value TEXT NOT NULL
-);
-
--- Indexes for common queries
-CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
-CREATE INDEX IF NOT EXISTS idx_memories_priority ON memories(priority);
-CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
-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);
-`;
 function openDatabase(opts) {
   const db = new Database(opts.path);
   if (opts.walMode !== false) {
@@ -111,6 +32,7 @@ function openDatabase(opts) {
     migrateDatabase(db, currentVersion, SCHEMA_VERSION);
   }
   ensureIndexes(db);
+  ensureFeedbackEventSchema(db);
   return db;
 }
 function now() {
@@ -129,6 +51,14 @@ function getSchemaVersion(db) {
     return null;
   }
 }
+function tableExists(db, table) {
+  try {
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(table);
+    return Boolean(row?.name);
+  } catch {
+    return false;
+  }
+}
 function tableHasColumn(db, table, column) {
   try {
     const cols = db.prepare(`PRAGMA table_info(${table})`).all();
@@ -150,6 +80,21 @@ function migrateDatabase(db, from, to) {
       v = 3;
       continue;
     }
+    if (v === 3) {
+      migrateV3ToV4(db);
+      v = 4;
+      continue;
+    }
+    if (v === 4) {
+      migrateV4ToV5(db);
+      v = 5;
+      continue;
+    }
+    if (v === 5) {
+      migrateV5ToV6(db);
+      v = 6;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -231,14 +176,14 @@ 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");
+  const hasEmotionTag = tableHasColumn(db, "memories", "emotion_tag");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag) return 6;
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings) return 4;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasEmbeddings) return 3;
   if (hasAgentScopedPaths && hasAgentScopedLinks) return 2;
   return 1;
@@ -251,14 +196,40 @@ 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 (tableHasColumn(db, "memories", "emotion_tag")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_emotion_tag ON memories(emotion_tag) WHERE emotion_tag IS NOT NULL;");
+  }
+  if (tableExists(db, "feedback_events")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);");
+    if (tableHasColumn(db, "feedback_events", "agent_id") && tableHasColumn(db, "feedback_events", "source")) {
+      db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
+    }
+  }
+}
+function ensureFeedbackEventSchema(db) {
+  if (!tableExists(db, "feedback_events")) return;
+  if (!tableHasColumn(db, "feedback_events", "source")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN source TEXT NOT NULL DEFAULT 'surface';");
+  }
+  if (!tableHasColumn(db, "feedback_events", "useful")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN useful INTEGER NOT NULL DEFAULT 1;");
+  }
+  if (!tableHasColumn(db, "feedback_events", "agent_id")) {
+    db.exec("ALTER TABLE feedback_events ADD COLUMN agent_id TEXT NOT NULL DEFAULT 'default';");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_agent_source ON feedback_events(agent_id, source, created_at DESC);");
 }
 function migrateV2ToV3(db) {
   try {
@@ -285,14 +256,237 @@ 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;
+  }
+}
+function migrateV5ToV6(db) {
+  if (tableHasColumn(db, "memories", "emotion_tag")) {
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(6));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    db.exec("ALTER TABLE memories ADD COLUMN emotion_tag TEXT;");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_emotion_tag ON memories(emotion_tag) WHERE emotion_tag IS NOT NULL;");
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(6));
+    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 = 6;
+    SCHEMA_SQL = `
+-- Memory entries
+CREATE TABLE IF NOT EXISTS memories (
+  id            TEXT PRIMARY KEY,
+  content       TEXT NOT NULL,
+  type          TEXT NOT NULL CHECK(type IN ('identity','emotion','knowledge','event')),
+  priority      INTEGER NOT NULL DEFAULT 2 CHECK(priority BETWEEN 0 AND 3),
+  emotion_val   REAL NOT NULL DEFAULT 0.0,
+  vitality      REAL NOT NULL DEFAULT 1.0,
+  stability     REAL NOT NULL DEFAULT 1.0,
+  access_count  INTEGER NOT NULL DEFAULT 0,
+  last_accessed TEXT,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  source        TEXT,
+  agent_id      TEXT NOT NULL DEFAULT 'default',
+  hash          TEXT,
+  emotion_tag   TEXT,
+  UNIQUE(hash, agent_id)
+);
 
-// src/core/memory.ts
-import { createHash } from "crypto";
+-- URI paths (Content-Path separation, from nocturne)
+CREATE TABLE IF NOT EXISTS paths (
+  id          TEXT PRIMARY KEY,
+  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  agent_id    TEXT NOT NULL DEFAULT 'default',
+  uri         TEXT NOT NULL,
+  alias       TEXT,
+  domain      TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  UNIQUE(agent_id, uri)
+);
+
+-- Association network (knowledge graph)
+CREATE TABLE IF NOT EXISTS links (
+  agent_id    TEXT NOT NULL DEFAULT 'default',
+  source_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  target_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  relation    TEXT NOT NULL,
+  weight      REAL NOT NULL DEFAULT 1.0,
+  created_at  TEXT NOT NULL,
+  PRIMARY KEY (agent_id, source_id, target_id)
+);
+
+-- Snapshots (version control, from nocturne + Memory Palace)
+CREATE TABLE IF NOT EXISTS snapshots (
+  id          TEXT PRIMARY KEY,
+  memory_id   TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  content     TEXT NOT NULL,
+  changed_by  TEXT,
+  action      TEXT NOT NULL CHECK(action IN ('create','update','delete','merge')),
+  created_at  TEXT NOT NULL
+);
+
+-- Full-text search index (BM25)
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  id UNINDEXED,
+  content,
+  tokenize='unicode61'
+);
+
+-- Embeddings (optional semantic layer)
+CREATE TABLE IF NOT EXISTS embeddings (
+  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
+CREATE TABLE IF NOT EXISTS schema_meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+CREATE INDEX IF NOT EXISTS idx_memories_priority ON memories(priority);
+CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+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);
+`;
+  }
+});
 
 // src/search/tokenizer.ts
 import { readFileSync } from "fs";
 import { createRequire } from "module";
-var _jieba;
 function getJieba() {
   if (_jieba !== void 0) return _jieba;
   try {
@@ -306,38 +500,6 @@ function getJieba() {
   }
   return _jieba;
 }
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "\u7684",
-  "\u4E86",
-  "\u5728",
-  "\u662F",
-  "\u6211",
-  "\u6709",
-  "\u548C",
-  "\u5C31",
-  "\u4E0D",
-  "\u4EBA",
-  "\u90FD",
-  "\u4E00",
-  "\u4E2A",
-  "\u4E0A",
-  "\u4E5F",
-  "\u5230",
-  "\u4ED6",
-  "\u6CA1",
-  "\u8FD9",
-  "\u8981",
-  "\u4F1A",
-  "\u5BF9",
-  "\u8BF4",
-  "\u800C",
-  "\u53BB",
-  "\u4E4B",
-  "\u88AB",
-  "\u5979",
-  "\u628A",
-  "\u90A3"
-]);
 function tokenize(text) {
   const cleaned = text.replace(/[^\w\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af\s]/g, " ");
   const tokens = [];
@@ -367,42 +529,433 @@ function tokenizeForIndex(text) {
   const tokens = tokenize(text);
   return tokens.join(" ");
 }
+var _jieba, STOPWORDS;
+var init_tokenizer = __esm({
+  "src/search/tokenizer.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "\u7684",
+      "\u4E86",
+      "\u5728",
+      "\u662F",
+      "\u6211",
+      "\u6709",
+      "\u548C",
+      "\u5C31",
+      "\u4E0D",
+      "\u4EBA",
+      "\u90FD",
+      "\u4E00",
+      "\u4E2A",
+      "\u4E0A",
+      "\u4E5F",
+      "\u5230",
+      "\u4ED6",
+      "\u6CA1",
+      "\u8FD9",
+      "\u8981",
+      "\u4F1A",
+      "\u5BF9",
+      "\u8BF4",
+      "\u800C",
+      "\u53BB",
+      "\u4E4B",
+      "\u88AB",
+      "\u5979",
+      "\u628A",
+      "\u90A3"
+    ]);
+  }
+});
 
-// src/core/memory.ts
-function contentHash(content) {
-  return createHash("sha256").update(content.trim()).digest("hex").slice(0, 16);
+// src/search/embedding.ts
+import { createHash } from "crypto";
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
 }
-var TYPE_PRIORITY = {
-  identity: 0,
-  emotion: 1,
-  knowledge: 2,
-  event: 3
-};
-var PRIORITY_STABILITY = {
-  0: Infinity,
-  // P0: never decays
-  1: 365,
-  // P1: 365-day half-life
-  2: 90,
-  // P2: 90-day half-life
-  3: 14
-  // P3: 14-day half-life
-};
-function createMemory(db, input) {
-  const hash = contentHash(input.content);
-  const agentId = input.agent_id ?? "default";
-  const priority = input.priority ?? TYPE_PRIORITY[input.type];
-  const stability = PRIORITY_STABILITY[priority];
-  const existing = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
-  if (existing) {
-    return null;
+function resolveEndpoint(baseUrl, endpoint = "/embeddings") {
+  const trimmed = trimTrailingSlashes(baseUrl);
+  if (trimmed.endsWith("/embeddings")) {
+    return trimmed;
+  }
+  const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  return `${trimmed}${normalizedEndpoint}`;
+}
+function stableProviderId(prefix, input) {
+  const digest = createHash("sha256").update(input).digest("hex").slice(0, 12);
+  return `${prefix}:${digest}`;
+}
+function getFetch(fetchImpl) {
+  const candidate = fetchImpl ?? globalThis.fetch;
+  if (!candidate) {
+    throw new Error("Global fetch is not available in this runtime");
+  }
+  return candidate;
+}
+function assertEmbeddingVector(vector, dimension, context) {
+  if (!Array.isArray(vector) || !vector.every((value) => typeof value === "number" && Number.isFinite(value))) {
+    throw new Error(`${context} returned an invalid embedding vector`);
+  }
+  if (vector.length !== dimension) {
+    throw new Error(`${context} returned dimension ${vector.length}, expected ${dimension}`);
+  }
+  return vector;
+}
+function parseOpenAIResponse(json2, dimension, context) {
+  const rows = json2?.data;
+  if (!Array.isArray(rows)) {
+    throw new Error(`${context} returned an invalid embeddings payload`);
+  }
+  return rows.map((row, index) => assertEmbeddingVector(row?.embedding, dimension, `${context} item ${index}`));
+}
+function parseLocalHttpResponse(json2, dimension, context) {
+  if (Array.isArray(json2.embeddings)) {
+    const embeddings = json2.embeddings;
+    return embeddings.map((row, index) => assertEmbeddingVector(row, dimension, `${context} item ${index}`));
+  }
+  return parseOpenAIResponse(json2, dimension, context);
+}
+async function runEmbeddingRequest(input) {
+  const fetchFn = getFetch(input.fetchImpl);
+  const response = await fetchFn(input.url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...input.headers
+    },
+    body: JSON.stringify(input.body)
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`${input.context} request failed: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}`);
+  }
+  const json2 = await response.json();
+  return input.parser(json2, input.dimension, input.context);
+}
+function createOpenAICompatibleEmbeddingProvider(opts) {
+  const url = resolveEndpoint(opts.baseUrl, opts.endpoint);
+  const providerDescriptor = `${trimTrailingSlashes(opts.baseUrl)}|${opts.model}|${opts.dimension}`;
+  const id = stableProviderId(`openai-compatible:${opts.model}`, providerDescriptor);
+  return {
+    id,
+    model: opts.model,
+    dimension: opts.dimension,
+    async embed(texts) {
+      if (texts.length === 0) return [];
+      return runEmbeddingRequest({
+        context: "openai-compatible embedding provider",
+        url,
+        dimension: opts.dimension,
+        fetchImpl: opts.fetchImpl,
+        headers: {
+          ...opts.apiKey ? { authorization: `Bearer ${opts.apiKey}` } : {},
+          ...opts.headers
+        },
+        body: {
+          model: opts.model,
+          input: texts
+        },
+        parser: parseOpenAIResponse
+      });
+    },
+    async healthcheck() {
+      await this.embed(["healthcheck"]);
+    }
+  };
+}
+function createLocalHttpEmbeddingProvider(opts) {
+  const url = resolveEndpoint(opts.baseUrl, opts.endpoint);
+  const providerDescriptor = `${trimTrailingSlashes(opts.baseUrl)}|${opts.model}|${opts.dimension}`;
+  const id = stableProviderId(`local-http:${opts.model}`, providerDescriptor);
+  return {
+    id,
+    model: opts.model,
+    dimension: opts.dimension,
+    async embed(texts) {
+      if (texts.length === 0) return [];
+      return runEmbeddingRequest({
+        context: "local-http embedding provider",
+        url,
+        dimension: opts.dimension,
+        fetchImpl: opts.fetchImpl,
+        headers: opts.headers,
+        body: {
+          model: opts.model,
+          input: texts
+        },
+        parser: parseLocalHttpResponse
+      });
+    },
+    async healthcheck() {
+      await this.embed(["healthcheck"]);
+    }
+  };
+}
+function normalizeEmbeddingBaseUrl(baseUrl) {
+  return trimTrailingSlashes(baseUrl);
+}
+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 config = resolveEmbeddingProviderConfig({ config: opts?.config, env: opts?.env });
+  if (!config) return null;
+  return createEmbeddingProvider(config, { fetchImpl: opts?.fetchImpl });
+}
+function getEmbeddingProviderFromEnv(env = process.env) {
+  try {
+    return getEmbeddingProvider({ env });
+  } catch {
+    return null;
+  }
+}
+function getConfiguredEmbeddingProviderId(opts) {
+  try {
+    const provider = getEmbeddingProvider({ config: opts?.config, env: opts?.env });
+    return provider?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+var init_providers = __esm({
+  "src/search/providers.ts"() {
+    "use strict";
+    init_embedding();
+  }
+});
+
+// src/search/vector.ts
+function encodeVector(vector) {
+  const float32 = vector instanceof Float32Array ? vector : Float32Array.from(vector);
+  return Buffer.from(float32.buffer.slice(float32.byteOffset, float32.byteOffset + float32.byteLength));
+}
+function decodeVector(blob) {
+  const buffer = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+  const aligned = buffer.byteOffset === 0 && buffer.byteLength === buffer.buffer.byteLength ? buffer.buffer : buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  return Array.from(new Float32Array(aligned));
+}
+function cosineSimilarity(a, b) {
+  const length = Math.min(a.length, b.length);
+  if (length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < length; index++) {
+    const left = Number(a[index] ?? 0);
+    const right = Number(b[index] ?? 0);
+    dot += left * right;
+    normA += left * left;
+    normB += right * right;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function markMemoryEmbeddingPending(db, memoryId, providerId, contentHash2) {
+  db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, NULL, ?, 'pending', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = NULL,
+       content_hash = excluded.content_hash,
+       status = 'pending'`
+  ).run(newId(), memoryId, providerId, contentHash2, now());
+}
+function markAllEmbeddingsPending(db, memoryId, contentHash2) {
+  const result = db.prepare(
+    `UPDATE embeddings
+     SET vector = NULL,
+         content_hash = ?,
+         status = 'pending'
+     WHERE memory_id = ?`
+  ).run(contentHash2, memoryId);
+  return result.changes;
+}
+function upsertReadyEmbedding(input) {
+  input.db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, ?, ?, 'ready', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = excluded.vector,
+       content_hash = excluded.content_hash,
+       status = 'ready'`
+  ).run(newId(), input.memoryId, input.providerId, encodeVector(input.vector), input.contentHash, now());
+}
+function markEmbeddingFailed(db, memoryId, providerId, contentHash2) {
+  db.prepare(
+    `INSERT INTO embeddings (id, memory_id, provider_id, vector, content_hash, status, created_at)
+     VALUES (?, ?, ?, NULL, ?, 'failed', ?)
+     ON CONFLICT(memory_id, provider_id) DO UPDATE SET
+       vector = NULL,
+       content_hash = excluded.content_hash,
+       status = 'failed'`
+  ).run(newId(), memoryId, providerId, contentHash2, now());
+}
+function searchByVector(db, queryVector, opts) {
+  const limit = opts.limit ?? 20;
+  const agentId = opts.agent_id ?? "default";
+  const minVitality = opts.min_vitality ?? 0;
+  const rows = db.prepare(
+    `SELECT e.provider_id, e.vector, e.content_hash,
+            m.id, m.content, m.type, m.priority, m.emotion_val, m.vitality,
+            m.stability, m.access_count, m.last_accessed, m.created_at,
+            m.updated_at, m.source, m.agent_id, m.hash
+     FROM embeddings e
+     JOIN memories m ON m.id = e.memory_id
+     WHERE e.provider_id = ?
+       AND e.status = 'ready'
+       AND e.vector IS NOT NULL
+       AND e.content_hash = m.hash
+       AND m.agent_id = ?
+       AND m.vitality >= ?`
+  ).all(opts.providerId, agentId, minVitality);
+  const scored = rows.map((row) => ({
+    provider_id: row.provider_id,
+    memory: {
+      id: row.id,
+      content: row.content,
+      type: row.type,
+      priority: row.priority,
+      emotion_val: row.emotion_val,
+      vitality: row.vitality,
+      stability: row.stability,
+      access_count: row.access_count,
+      last_accessed: row.last_accessed,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      source: row.source,
+      agent_id: row.agent_id,
+      hash: row.hash
+    },
+    similarity: cosineSimilarity(queryVector, decodeVector(row.vector))
+  })).filter((row) => Number.isFinite(row.similarity) && row.similarity > 0).sort((left, right) => right.similarity - left.similarity).slice(0, limit);
+  return scored.map((row, index) => ({
+    memory: row.memory,
+    similarity: row.similarity,
+    rank: index + 1,
+    provider_id: row.provider_id
+  }));
+}
+var init_vector = __esm({
+  "src/search/vector.ts"() {
+    "use strict";
+    init_db();
+  }
+});
+
+// src/core/memory.ts
+import { createHash as createHash2 } from "crypto";
+function contentHash(content) {
+  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, hash, providerId) {
+  if (!providerId) return;
+  try {
+    markMemoryEmbeddingPending(db, memoryId, providerId, hash);
+  } catch {
+  }
+}
+function createMemory(db, input) {
+  const hash = contentHash(input.content);
+  const agentId = input.agent_id ?? "default";
+  const priority = input.priority ?? TYPE_PRIORITY[input.type];
+  const stability = PRIORITY_STABILITY[priority];
+  const existing = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
+  if (existing) {
+    return null;
   }
   const id = newId();
   const timestamp = now();
   db.prepare(
     `INSERT INTO memories (id, content, type, priority, emotion_val, vitality, stability,
-     access_count, created_at, updated_at, source, agent_id, hash)
-     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?)`
+     access_count, created_at, updated_at, source, agent_id, hash, emotion_tag)
+     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     input.content,
@@ -414,9 +967,11 @@ function createMemory(db, input) {
     timestamp,
     input.source ?? null,
     agentId,
-    hash
+    hash,
+    input.emotion_tag ?? null
   );
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
+  markEmbeddingDirtyIfNeeded(db, id, hash, resolveEmbeddingProviderId(input.embedding_provider_id));
   return getMemory(db, id);
 }
 function getMemory(db, id) {
@@ -427,9 +982,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 = ?");
@@ -455,6 +1012,10 @@ function updateMemory(db, id, input) {
     fields.push("source = ?");
     values.push(input.source);
   }
+  if (input.emotion_tag !== void 0) {
+    fields.push("emotion_tag = ?");
+    values.push(input.emotion_tag);
+  }
   fields.push("updated_at = ?");
   values.push(now());
   values.push(id);
@@ -462,6 +1023,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);
 }
@@ -489,6 +1057,10 @@ function listMemories(db, opts) {
     conditions.push("vitality >= ?");
     params.push(opts.min_vitality);
   }
+  if (opts?.emotion_tag) {
+    conditions.push("emotion_tag = ?");
+    params.push(opts.emotion_tag);
+  }
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
   const limit = opts?.limit ?? 100;
   const offset = opts?.offset ?? 0;
@@ -513,8 +1085,215 @@ function countMemories(db, agent_id = "default") {
     by_priority: Object.fromEntries(byPriority.map((r) => [`P${r.priority}`, r.c]))
   };
 }
+var TYPE_PRIORITY, PRIORITY_STABILITY;
+var init_memory = __esm({
+  "src/core/memory.ts"() {
+    "use strict";
+    init_db();
+    init_tokenizer();
+    init_providers();
+    init_vector();
+    TYPE_PRIORITY = {
+      identity: 0,
+      emotion: 1,
+      knowledge: 2,
+      event: 3
+    };
+    PRIORITY_STABILITY = {
+      0: Infinity,
+      // P0: never decays
+      1: 365,
+      // P1: 365-day half-life
+      2: 90,
+      // P2: 90-day half-life
+      3: 14
+      // P3: 14-day half-life
+    };
+  }
+});
+
+// src/core/path.ts
+function parseUri(uri) {
+  const match = uri.match(/^([a-z]+):\/\/(.+)$/);
+  if (!match) throw new Error(`Invalid URI: ${uri}. Expected format: domain://path`);
+  return { domain: match[1], path: match[2] };
+}
+function createPath(db, memoryId, uri, alias, validDomains, agent_id) {
+  const { domain } = parseUri(uri);
+  const domains = validDomains ?? DEFAULT_DOMAINS;
+  if (!domains.has(domain)) {
+    throw new Error(`Invalid domain "${domain}". Valid: ${[...domains].join(", ")}`);
+  }
+  const memoryAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id;
+  if (!memoryAgent) throw new Error(`Memory not found: ${memoryId}`);
+  if (agent_id && agent_id !== memoryAgent) {
+    throw new Error(`Agent mismatch for path: memory agent_id=${memoryAgent}, requested agent_id=${agent_id}`);
+  }
+  const agentId = agent_id ?? memoryAgent;
+  const existing = db.prepare("SELECT id FROM paths WHERE agent_id = ? AND uri = ?").get(agentId, uri);
+  if (existing) {
+    throw new Error(`URI already exists: ${uri}`);
+  }
+  const id = newId();
+  db.prepare(
+    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(id, memoryId, agentId, uri, alias ?? null, domain, now());
+  return getPath(db, id);
+}
+function getPath(db, id) {
+  return db.prepare("SELECT * FROM paths WHERE id = ?").get(id) ?? null;
+}
+function getPathByUri(db, uri, agent_id = "default") {
+  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri = ?").get(agent_id, uri) ?? null;
+}
+var DEFAULT_DOMAINS;
+var init_path = __esm({
+  "src/core/path.ts"() {
+    "use strict";
+    init_db();
+    DEFAULT_DOMAINS = /* @__PURE__ */ new Set(["core", "emotion", "knowledge", "event", "system"]);
+  }
+});
+
+// src/sleep/boot.ts
+var boot_exports = {};
+__export(boot_exports, {
+  boot: () => boot,
+  formatNarrativeBoot: () => formatNarrativeBoot,
+  formatRelativeDate: () => formatRelativeDate,
+  loadWarmBootLayers: () => loadWarmBootLayers
+});
+function formatRelativeDate(isoDate) {
+  const diffMs = Date.now() - new Date(isoDate).getTime();
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffDays <= 0) return "\u4ECA\u5929";
+  if (diffDays === 1) return "\u6628\u5929";
+  if (diffDays <= 7) return `${diffDays}\u5929\u524D`;
+  return isoDate.slice(0, 10);
+}
+function loadWarmBootLayers(db, agentId) {
+  const identity = listMemories(db, { agent_id: agentId, type: "identity", limit: 50 });
+  const emotion = listMemories(db, { agent_id: agentId, type: "emotion", limit: 5 });
+  const event = listMemories(db, { agent_id: agentId, type: "event", limit: 7 });
+  const knowledge = listMemories(db, {
+    agent_id: agentId,
+    type: "knowledge",
+    min_vitality: 0.5,
+    limit: 10
+  });
+  return { identity, emotion, event, knowledge };
+}
+function formatNarrativeBoot(layers, agentName) {
+  const lines = [];
+  lines.push(`# ${agentName}\u7684\u56DE\u5FC6`);
+  lines.push("");
+  if (layers.identity.length > 0) {
+    lines.push("## \u6211\u662F\u8C01");
+    for (const mem of layers.identity) {
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)}`);
+    }
+    lines.push("");
+  }
+  if (layers.emotion.length > 0) {
+    lines.push("## \u6700\u8FD1\u7684\u5FC3\u60C5");
+    for (const mem of layers.emotion) {
+      const tag = mem.emotion_tag;
+      const time = formatRelativeDate(mem.updated_at);
+      const tagStr = tag ? `${tag}, ${time}` : time;
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)} (${tagStr})`);
+    }
+    lines.push("");
+  }
+  if (layers.event.length > 0) {
+    lines.push("## \u6700\u8FD1\u53D1\u751F\u7684\u4E8B");
+    for (const mem of layers.event) {
+      const time = formatRelativeDate(mem.updated_at);
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)} (${time})`);
+    }
+    lines.push("");
+  }
+  if (layers.knowledge.length > 0) {
+    lines.push("## \u8FD8\u8BB0\u5F97\u7684\u77E5\u8BC6");
+    for (const mem of layers.knowledge) {
+      lines.push(`- ${mem.content.split("\n")[0].slice(0, 200)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function boot(db, opts) {
+  const agentId = opts?.agent_id ?? "default";
+  const format = opts?.format ?? "json";
+  const agentName = opts?.agent_name ?? "Agent";
+  const corePaths = opts?.corePaths ?? [
+    "core://agent",
+    "core://user",
+    "core://agent/identity",
+    "core://user/identity"
+  ];
+  const memories = /* @__PURE__ */ new Map();
+  const identities = listMemories(db, { agent_id: agentId, priority: 0 });
+  for (const mem of identities) {
+    memories.set(mem.id, mem);
+    recordAccess(db, mem.id, 1.1);
+  }
+  const bootPaths = [];
+  for (const uri of corePaths) {
+    const path = getPathByUri(db, uri, agentId);
+    if (path) {
+      bootPaths.push(uri);
+      if (!memories.has(path.memory_id)) {
+        const mem = getMemory(db, path.memory_id);
+        if (mem) {
+          memories.set(mem.id, mem);
+          recordAccess(db, mem.id, 1.1);
+        }
+      }
+    }
+  }
+  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);
+          }
+        }
+      }
+    }
+  }
+  const result = {
+    identityMemories: [...memories.values()],
+    bootPaths
+  };
+  if (format === "narrative") {
+    const layers = loadWarmBootLayers(db, agentId);
+    result.layers = layers;
+    result.narrative = formatNarrativeBoot(layers, agentName);
+  }
+  return result;
+}
+var init_boot = __esm({
+  "src/sleep/boot.ts"() {
+    "use strict";
+    init_path();
+    init_memory();
+  }
+});
+
+// src/bin/agent-memory.ts
+init_db();
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { basename, resolve } from "path";
 
 // src/core/export.ts
+init_memory();
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 function exportMemories(db, dirPath, opts) {
@@ -577,7 +1356,17 @@ function exportMemories(db, dirPath, opts) {
   return { exported, files };
 }
 
+// src/bin/agent-memory.ts
+init_boot();
+
+// src/app/surface.ts
+init_memory();
+
+// src/search/hybrid.ts
+init_memory();
+
 // src/search/bm25.ts
+init_tokenizer();
 function searchBM25(db, query, opts) {
   const limit = opts?.limit ?? 20;
   const agentId = opts?.agent_id ?? "default";
@@ -595,12 +1384,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"
       };
     });
@@ -615,10 +1405,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"
   }));
 }
@@ -627,96 +1417,957 @@ function buildFtsQuery(text) {
   if (tokens.length === 0) return null;
   return tokens.map((w) => `"${w}"`).join(" OR ");
 }
+function rebuildBm25Index(db, opts) {
+  const memories = opts?.agent_id ? db.prepare("SELECT id, content FROM memories WHERE agent_id = ?").all(opts.agent_id) : db.prepare("SELECT id, content FROM memories").all();
+  const insert = db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)");
+  const deleteOne = db.prepare("DELETE FROM memories_fts WHERE id = ?");
+  const transaction = db.transaction(() => {
+    if (!opts?.agent_id) {
+      db.exec("DELETE FROM memories_fts");
+    }
+    for (const memory of memories) {
+      if (opts?.agent_id) {
+        deleteOne.run(memory.id);
+      }
+      insert.run(memory.id, tokenizeForIndex(memory.content));
+    }
+  });
+  transaction();
+  return { reindexed: memories.length };
+}
 
-// src/core/path.ts
-var DEFAULT_DOMAINS = /* @__PURE__ */ new Set(["core", "emotion", "knowledge", "event", "system"]);
-function parseUri(uri) {
-  const match = uri.match(/^([a-z]+):\/\/(.+)$/);
-  if (!match) throw new Error(`Invalid URI: ${uri}. Expected format: domain://path`);
-  return { domain: match[1], path: match[2] };
+// src/search/hybrid.ts
+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 createPath(db, memoryId, uri, alias, validDomains, agent_id) {
-  const { domain } = parseUri(uri);
-  const domains = validDomains ?? DEFAULT_DOMAINS;
-  if (!domains.has(domain)) {
-    throw new Error(`Invalid domain "${domain}". Valid: ${[...domains].join(", ")}`);
-  }
-  const memoryAgent = db.prepare("SELECT agent_id FROM memories WHERE id = ?").get(memoryId)?.agent_id;
-  if (!memoryAgent) throw new Error(`Memory not found: ${memoryId}`);
-  if (agent_id && agent_id !== memoryAgent) {
-    throw new Error(`Agent mismatch for path: memory agent_id=${memoryAgent}, requested agent_id=${agent_id}`);
+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
+    });
   }
-  const agentId = agent_id ?? memoryAgent;
-  const existing = db.prepare("SELECT id FROM paths WHERE agent_id = ? AND uri = ?").get(agentId, uri);
-  if (existing) {
-    throw new Error(`URI already exists: ${uri}`);
+  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
+      });
+    }
   }
-  const id = newId();
-  db.prepare(
-    "INSERT INTO paths (id, memory_id, agent_id, uri, alias, domain, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
-  ).run(id, memoryId, agentId, uri, alias ?? null, domain, now());
-  return getPath(db, id);
+  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);
 }
-function getPath(db, id) {
-  return db.prepare("SELECT * FROM paths WHERE id = ?").get(id) ?? null;
-}
-function getPathByUri(db, uri, agent_id = "default") {
-  return db.prepare("SELECT * FROM paths WHERE agent_id = ? AND uri = ?").get(agent_id, uri) ?? null;
+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
+  });
 }
-
-// src/sleep/boot.ts
-function boot(db, opts) {
+async function recallMemories(db, query, opts) {
+  const limit = opts?.limit ?? 10;
   const agentId = opts?.agent_id ?? "default";
-  const corePaths = opts?.corePaths ?? [
-    "core://agent",
-    "core://user",
-    "core://agent/identity",
-    "core://user/identity"
-  ];
-  const memories = /* @__PURE__ */ new Map();
-  const identities = listMemories(db, { agent_id: agentId, priority: 0 });
-  for (const mem of identities) {
-    memories.set(mem.id, mem);
-    recordAccess(db, mem.id, 1.1);
+  const 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 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 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 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 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 {
+    enabled: true,
+    providerId: provider.id,
+    scanned: candidates.length,
+    pending: candidates.length,
+    embedded,
+    failed
+  };
+}
+
+// src/app/surface.ts
+init_providers();
+init_tokenizer();
+init_vector();
+
+// src/app/feedback.ts
+init_db();
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function recordFeedbackEvent(db, input) {
+  const id = newId();
+  const created_at = now();
+  const agentId = input.agent_id ?? "default";
+  const useful = input.useful ? 1 : 0;
+  const value = input.useful ? 1 : 0;
+  const eventType = `${input.source}:${input.useful ? "useful" : "not_useful"}`;
+  const exists = db.prepare("SELECT id FROM memories WHERE id = ?").get(input.memory_id);
+  if (!exists) {
+    throw new Error(`Memory not found: ${input.memory_id}`);
+  }
+  try {
+    db.prepare(
+      `INSERT INTO feedback_events (id, memory_id, source, useful, agent_id, event_type, value, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(id, input.memory_id, input.source, useful, agentId, eventType, value, created_at);
+  } catch {
+    db.prepare(
+      `INSERT INTO feedback_events (id, memory_id, event_type, value, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(id, input.memory_id, eventType, value, created_at);
+  }
+  return {
+    id,
+    memory_id: input.memory_id,
+    source: input.source,
+    useful: input.useful,
+    agent_id: agentId,
+    created_at,
+    value
+  };
+}
+function getFeedbackSummary(db, memoryId, agentId) {
+  try {
+    const row = db.prepare(
+      `SELECT COUNT(*) as total,
+              COALESCE(SUM(CASE WHEN useful = 1 THEN 1 ELSE 0 END), 0) as useful,
+              COALESCE(SUM(CASE WHEN useful = 0 THEN 1 ELSE 0 END), 0) as not_useful
+       FROM feedback_events
+       WHERE memory_id = ?
+         AND (? IS NULL OR agent_id = ?)`
+    ).get(memoryId, agentId ?? null, agentId ?? null);
+    if (!row || row.total === 0) {
+      return { total: 0, useful: 0, not_useful: 0, score: 0.5 };
+    }
+    return {
+      total: row.total,
+      useful: row.useful,
+      not_useful: row.not_useful,
+      score: clamp01(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: clamp01(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 clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function uniqueTokenSet(values) {
+  return new Set(
+    values.flatMap((value) => tokenize(value ?? "")).map((token) => token.trim()).filter(Boolean)
+  );
+}
+function overlapScore(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 clamp012(shared / Math.max(left.size, right.size));
+}
+function rankScore(rank, window) {
+  if (!rank) return 0;
+  return clamp012(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 clamp012(prior * intentKeywordBoost(memory, intent));
+}
+function buildReasonCodes(input) {
+  const reasons = /* @__PURE__ */ new Set();
+  reasons.add(`type:${input.memory.type}`);
+  if (input.semanticScore > 0.2) {
+    reasons.add(`semantic:${topicLabel(input.query, input.task)}`);
+  }
+  if (input.lexicalScore > 0.2 && input.query) {
+    reasons.add(`lexical:${topicLabel(input.query)}`);
+  }
+  if (input.taskMatch > 0.2) {
+    reasons.add(`task:${topicLabel(input.task, input.intent)}`);
+  }
+  if (input.intent) {
+    reasons.add(`intent:${input.intent}`);
+  }
+  if (input.feedbackScore >= 0.67) {
+    reasons.add("feedback:reinforced");
+  } else if (input.feedbackScore <= 0.33) {
+    reasons.add("feedback:negative");
+  }
+  return [...reasons];
+}
+function collectBranch(signals, rows, key, similarity) {
+  for (const row of rows) {
+    const existing = signals.get(row.memory.id) ?? { memory: row.memory };
+    const currentRank = existing[key];
+    if (currentRank === void 0 || row.rank < currentRank) {
+      existing[key] = row.rank;
+    }
+    if (similarity) {
+      const currentSimilarity = similarity.get(row.memory.id);
+      if (currentSimilarity !== void 0) {
+        existing.semanticSimilarity = Math.max(existing.semanticSimilarity ?? 0, currentSimilarity);
+      }
+    }
+    signals.set(row.memory.id, existing);
+  }
+}
+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 = uniqueTokenSet([trimmedQuery, ...recentTurns]);
+  const taskTokens = uniqueTokenSet([trimmedTask]);
+  if (trimmedQuery) {
+    collectBranch(
+      signals,
+      searchBM25(db, trimmedQuery, {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "queryRank"
+    );
+  }
+  if (trimmedTask) {
+    collectBranch(
+      signals,
+      searchBM25(db, trimmedTask, {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "taskRank"
+    );
+  }
+  if (recentTurns.length > 0) {
+    collectBranch(
+      signals,
+      searchBM25(db, recentTurns.join(" "), {
+        agent_id: agentId,
+        limit: lexicalWindow,
+        min_vitality: minVitality
+      }),
+      "recentRank"
+    );
+  }
+  const semanticQuery = [trimmedQuery, trimmedTask, ...recentTurns].filter(Boolean).join("\n").trim();
+  if (provider && semanticQuery) {
+    try {
+      const [queryVector] = await provider.embed([semanticQuery]);
+      if (queryVector) {
+        const vectorRows = searchByVector(db, queryVector, {
+          providerId: provider.id,
+          agent_id: agentId,
+          limit: lexicalWindow,
+          min_vitality: minVitality
+        });
+        const similarity = new Map(vectorRows.map((row) => [row.memory.id, row.similarity]));
+        collectBranch(signals, vectorRows, "semanticRank", similarity);
       }
+    } catch {
+    }
+  }
+  const fallbackMemories = listMemories(db, {
+    agent_id: agentId,
+    min_vitality: minVitality,
+    limit: Math.max(48, lexicalWindow)
+  });
+  for (const memory of fallbackMemories) {
+    if (!signals.has(memory.id)) {
+      signals.set(memory.id, { memory });
     }
   }
+  const results = [...signals.values()].map((signal) => signal.memory).filter((memory) => memory.vitality >= minVitality).filter((memory) => input.types?.length ? input.types.includes(memory.type) : true).filter((memory) => input.emotion_tag ? memory.emotion_tag === input.emotion_tag : true).map((memory) => {
+    const signal = signals.get(memory.id) ?? { memory };
+    const memoryTokens = new Set(tokenize(memory.content));
+    const lexicalOverlap = overlapScore(memoryTokens, queryTokens);
+    const taskOverlap = overlapScore(memoryTokens, taskTokens);
+    const lexicalScore = clamp012(
+      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 ? clamp012(Math.max(signal.semanticSimilarity, lexicalOverlap * 0.7)) : trimmedQuery || recentTurns.length > 0 ? clamp012(lexicalOverlap * 0.7) : 0;
+    const intentScore = intentMatch(memory, input.intent);
+    const taskMatch = trimmedTask ? clamp012(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 = clamp012(
+      0.35 * semanticScore + 0.2 * lexicalScore + 0.15 * taskMatch + 0.1 * memory.vitality + 0.1 * priorityScore + 0.1 * feedbackScore
+    );
+    return {
+      memory,
+      score,
+      semantic_score: semanticScore,
+      lexical_score: lexicalScore,
+      task_match: taskMatch,
+      vitality: memory.vitality,
+      priority_prior: priorityScore,
+      feedback_score: feedbackScore,
+      feedback_summary: feedbackSummary,
+      reason_codes: buildReasonCodes({
+        memory,
+        query: semanticQuery || trimmedQuery,
+        task: trimmedTask,
+        intent: input.intent,
+        semanticScore,
+        lexicalScore,
+        taskMatch,
+        feedbackScore
+      }),
+      lexical_rank: signal.queryRank ?? signal.recentRank ?? signal.taskRank,
+      semantic_rank: signal.semanticRank,
+      semantic_similarity: signal.semanticSimilarity
+    };
+  }).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    if (right.semantic_score !== left.semantic_score) return right.semantic_score - left.semantic_score;
+    if (right.lexical_score !== left.lexical_score) return right.lexical_score - left.lexical_score;
+    if (left.memory.priority !== right.memory.priority) return left.memory.priority - right.memory.priority;
+    return right.memory.updated_at.localeCompare(left.memory.updated_at);
+  }).slice(0, limit);
   return {
-    identityMemories: [...memories.values()],
-    bootPaths
+    count: results.length,
+    query: trimmedQuery,
+    task: trimmedTask,
+    intent: input.intent,
+    results
   };
 }
 
+// src/transports/http.ts
+init_db();
+import { randomUUID as randomUUID2 } from "crypto";
+import http from "http";
+
+// src/sleep/sync.ts
+init_memory();
+init_path();
+
+// src/core/guard.ts
+init_providers();
+init_tokenizer();
+init_path();
+
+// src/core/merge.ts
+function uniqueNonEmpty(values) {
+  return [...new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value)))];
+}
+function splitClauses(content) {
+  return content.split(/[\n；;。.!?！？]+/).map((part) => part.trim()).filter(Boolean);
+}
+function mergeAliases(existing, incoming, content) {
+  const aliases = uniqueNonEmpty([
+    existing !== content ? existing : void 0,
+    incoming !== content ? incoming : void 0
+  ]);
+  return aliases.length > 0 ? aliases : void 0;
+}
+function replaceIdentity(context) {
+  const content = context.incoming.content.trim();
+  return {
+    strategy: "replace",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["identity canonicalized to the newest authoritative phrasing"]
+  };
+}
+function appendEmotionEvidence(context) {
+  const lines = uniqueNonEmpty([
+    ...context.existing.content.split(/\n+/),
+    context.incoming.content
+  ]);
+  const content = lines.length <= 1 ? lines[0] ?? context.incoming.content.trim() : [lines[0], "", ...lines.slice(1).map((line) => `- ${line.replace(/^-\s*/, "")}`)].join("\n");
+  return {
+    strategy: "append_evidence",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["emotion evidence appended to preserve timeline without duplicating identical lines"]
+  };
+}
+function synthesizeKnowledge(context) {
+  const clauses = uniqueNonEmpty([
+    ...splitClauses(context.existing.content),
+    ...splitClauses(context.incoming.content)
+  ]);
+  const content = clauses.length <= 1 ? clauses[0] ?? context.incoming.content.trim() : clauses.join("\uFF1B");
+  return {
+    strategy: "synthesize",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["knowledge statements synthesized into a canonical summary"]
+  };
+}
+function compactEventTimeline(context) {
+  const points = uniqueNonEmpty([
+    ...context.existing.content.split(/\n+/),
+    context.incoming.content
+  ]).map((line) => line.replace(/^-\s*/, ""));
+  const content = points.length <= 1 ? points[0] ?? context.incoming.content.trim() : ["Timeline:", ...points.map((line) => `- ${line}`)].join("\n");
+  return {
+    strategy: "compact_timeline",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["event observations compacted into a single timeline window"]
+  };
+}
+function buildMergePlan(context) {
+  const type = context.incoming.type ?? context.existing.type;
+  switch (type) {
+    case "identity":
+      return replaceIdentity(context);
+    case "emotion":
+      return appendEmotionEvidence(context);
+    case "knowledge":
+      return synthesizeKnowledge(context);
+    case "event":
+      return compactEventTimeline(context);
+  }
+}
+
+// src/core/guard.ts
+init_memory();
+var NEAR_EXACT_THRESHOLD = 0.93;
+var MERGE_THRESHOLD = 0.82;
+function clamp013(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function uniqueTokenSet2(text) {
+  return new Set(tokenize(text));
+}
+function overlapScore2(left, right) {
+  const a = new Set(left);
+  const b = new Set(right);
+  if (a.size === 0 || b.size === 0) return 0;
+  let shared = 0;
+  for (const token of a) {
+    if (b.has(token)) shared += 1;
+  }
+  return shared / Math.max(a.size, b.size);
+}
+function extractEntities(text) {
+  const matches = text.match(/[A-Z][A-Za-z0-9_-]+|\d+(?:[-/:]\d+)*|[#@][\w-]+|[\u4e00-\u9fff]{2,}|\w+:\/\/[^\s]+/g) ?? [];
+  return new Set(matches.map((value) => value.trim()).filter(Boolean));
+}
+function safeDomain(uri) {
+  if (!uri) return null;
+  try {
+    return parseUri(uri).domain;
+  } catch {
+    return null;
+  }
+}
+function getPrimaryUri(db, memoryId, agentId) {
+  const row = db.prepare("SELECT uri FROM paths WHERE memory_id = ? AND agent_id = ? ORDER BY created_at DESC LIMIT 1").get(memoryId, agentId);
+  return row?.uri ?? null;
+}
+function uriScopeMatch(inputUri, candidateUri) {
+  if (inputUri && candidateUri) {
+    if (inputUri === candidateUri) return 1;
+    const inputDomain2 = safeDomain(inputUri);
+    const candidateDomain2 = safeDomain(candidateUri);
+    if (inputDomain2 && candidateDomain2 && inputDomain2 === candidateDomain2) return 0.85;
+    return 0;
+  }
+  if (!inputUri && !candidateUri) {
+    return 0.65;
+  }
+  const inputDomain = safeDomain(inputUri ?? null);
+  const candidateDomain = safeDomain(candidateUri ?? null);
+  if (inputDomain && candidateDomain && inputDomain === candidateDomain) {
+    return 0.75;
+  }
+  return 0.2;
+}
+function extractObservedAt(parts, fallback) {
+  for (const part of parts) {
+    if (!part) continue;
+    const match = part.match(/(20\d{2}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2})?))?/);
+    if (!match) continue;
+    const iso = match[2] ? `${match[1]}T${match[2]}Z` : `${match[1]}T00:00:00Z`;
+    const parsed = new Date(iso);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  if (fallback) {
+    const parsed = new Date(fallback);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  return null;
+}
+function timeProximity(input, memory, candidateUri) {
+  if (input.type !== "event") {
+    return 1;
+  }
+  const inputTime = extractObservedAt([input.uri, input.source, input.content], input.now ?? null);
+  const existingTime = extractObservedAt([candidateUri, memory.source, memory.content], memory.created_at);
+  if (!inputTime || !existingTime) {
+    return 0.5;
+  }
+  const diffDays = Math.abs(inputTime.getTime() - existingTime.getTime()) / (1e3 * 60 * 60 * 24);
+  return clamp013(1 - diffDays / 7);
+}
+function scoreCandidate(input, candidate, candidateUri) {
+  const lexicalOverlap = overlapScore2(uniqueTokenSet2(input.content), uniqueTokenSet2(candidate.memory.content));
+  const entityOverlap = Math.max(
+    overlapScore2(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 = clamp013(candidate.vector_score ?? lexicalOverlap);
+  const dedupScore = clamp013(
+    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();
+  const failed = [];
+  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : input.type === "knowledge" ? 2 : 3);
+  const minLength = priority <= 1 ? 4 : 8;
+  const specificity = content.length >= minLength ? Math.min(1, content.length / 50) : 0;
+  if (specificity === 0) failed.push(`specificity (too short: ${content.length} < ${minLength} chars)`);
+  const tokens = tokenize(content);
+  const novelty = tokens.length >= 1 ? Math.min(1, tokens.length / 5) : 0;
+  if (novelty === 0) failed.push("novelty (no meaningful tokens after filtering)");
+  const hasCJK = /[\u4e00-\u9fff]/.test(content);
+  const hasCapitalized = /[A-Z][a-z]+/.test(content);
+  const hasNumbers = /\d+/.test(content);
+  const hasURI = /\w+:\/\//.test(content);
+  const hasEntityMarkers = /[@#]/.test(content);
+  const hasMeaningfulLength = content.length >= 15;
+  const topicSignals = [hasCJK, hasCapitalized, hasNumbers, hasURI, hasEntityMarkers, hasMeaningfulLength].filter(Boolean).length;
+  const relevance = topicSignals >= 1 ? Math.min(1, topicSignals / 3) : 0;
+  if (relevance === 0) failed.push("relevance (no identifiable topics/entities)");
+  const allCaps = content === content.toUpperCase() && content.length > 20 && /^[A-Z\s]+$/.test(content);
+  const hasWhitespaceOrPunctuation = /[\s，。！？,.!?；;：:]/.test(content) || content.length < 30;
+  const excessiveRepetition = /(.)\1{9,}/.test(content);
+  let coherence = 1;
+  if (allCaps) coherence -= 0.5;
+  if (!hasWhitespaceOrPunctuation) coherence -= 0.3;
+  if (excessiveRepetition) coherence -= 0.5;
+  coherence = Math.max(0, coherence);
+  if (coherence < 0.3) failed.push("coherence (garbled or malformed content)");
+  return {
+    pass: failed.length === 0,
+    scores: { specificity, novelty, relevance, coherence },
+    failedCriteria: failed
+  };
+}
+async function guard(db, input) {
+  const hash = contentHash(input.content);
+  const agentId = input.agent_id ?? "default";
+  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
+  if (exactMatch) {
+    return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
+  }
+  if (input.uri) {
+    const existingPath = getPathByUri(db, input.uri, agentId);
+    if (existingPath) {
+      return {
+        action: "update",
+        reason: `URI ${input.uri} already exists, updating canonical content`,
+        existingId: existingPath.memory_id,
+        updatedContent: input.content
+      };
+    }
+  }
+  const 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
+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",
+    priority: input.priority,
+    emotion_val: input.emotion_val,
+    source: input.source,
+    agent_id: input.agent_id,
+    uri: input.uri,
+    provider: input.provider,
+    conservative: input.conservative,
+    emotion_tag: input.emotion_tag
+  };
+  const guardResult = await guard(db, memInput);
+  switch (guardResult.action) {
+    case "skip":
+      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
+    case "add": {
+      const mem = createMemory(db, memInput);
+      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
+      ensureUriPath(db, mem.id, input.uri, input.agent_id);
+      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+    }
+    case "update": {
+      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
+      if (guardResult.updatedContent !== void 0) {
+        updateMemory(db, guardResult.existingId, { content: guardResult.updatedContent });
+      }
+      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
+      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
+    }
+    case "merge": {
+      if (!guardResult.existingId || !guardResult.mergedContent) {
+        return { action: "skipped", reason: "Missing merge data" };
+      }
+      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
+      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
+      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+    }
+  }
+}
+
+// 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,
+    emotion_tag: input.emotion_tag
+  });
+}
+
+// src/app/recall.ts
+async function recallMemory(db, input) {
+  const result = await recallMemories(db, input.query, {
+    agent_id: input.agent_id,
+    limit: input.emotion_tag ? (input.limit ?? 10) * 3 : input.limit,
+    min_vitality: input.min_vitality,
+    lexicalLimit: input.lexicalLimit,
+    vectorLimit: input.vectorLimit,
+    provider: input.provider,
+    recordAccess: input.recordAccess
+  });
+  if (input.emotion_tag) {
+    result.results = result.results.filter((r) => r.memory.emotion_tag === input.emotion_tag).slice(0, input.limit ?? 10);
+  }
+  return result;
+}
+
 // src/sleep/decay.ts
+init_db();
 var MIN_VITALITY = {
   0: 1,
   // P0: identity — never decays
@@ -777,35 +2428,102 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
 }
 
 // src/sleep/tidy.ts
+init_memory();
 function runTidy(db, opts) {
   const threshold = opts?.vitalityThreshold ?? 0.05;
   const agentId = opts?.agent_id;
   let archived = 0;
-  let orphansCleaned = 0;
   const transaction = db.transaction(() => {
     const decayed = getDecayedMemories(db, threshold, agentId ? { agent_id: agentId } : void 0);
     for (const mem of decayed) {
       deleteMemory(db, mem.id);
-      archived++;
+      archived += 1;
     }
-    const orphans = agentId ? db.prepare(
-      `DELETE FROM paths
-         WHERE agent_id = ?
-           AND memory_id NOT IN (SELECT id FROM memories WHERE agent_id = ?)`
-    ).run(agentId, agentId) : db.prepare(
-      "DELETE FROM paths WHERE memory_id NOT IN (SELECT id FROM memories)"
-    ).run();
-    orphansCleaned = orphans.changes;
   });
   transaction();
-  return { archived, orphansCleaned };
+  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 emptyMemories = 0;
+  let evicted = 0;
   const transaction = db.transaction(() => {
     const pathResult = agentId ? db.prepare(
       `DELETE FROM paths
@@ -815,154 +2533,750 @@ function runGovern(db, opts) {
     orphanPaths = pathResult.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, emptyMemories };
+  return { orphanPaths, emptyMemories, evicted };
 }
 
-// src/core/guard.ts
-function guard(db, input) {
-  const hash = contentHash(input.content);
-  const agentId = input.agent_id ?? "default";
-  const exactMatch = db.prepare("SELECT id FROM memories WHERE hash = ? AND agent_id = ?").get(hash, agentId);
-  if (exactMatch) {
-    return { action: "skip", reason: "Exact duplicate (hash match)", existingId: exactMatch.id };
+// src/sleep/jobs.ts
+init_db();
+function parseCheckpoint(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  if (input.uri) {
-    const existingPath = getPathByUri(db, input.uri, agentId);
-    if (existingPath) {
-      return {
-        action: "update",
-        reason: `URI ${input.uri} already exists, updating`,
-        existingId: existingPath.memory_id
-      };
+}
+function serializeCheckpoint(checkpoint) {
+  if (!checkpoint) return null;
+  return JSON.stringify(checkpoint);
+}
+function toJob(row) {
+  if (!row) return null;
+  return {
+    ...row,
+    checkpoint: parseCheckpoint(row.checkpoint)
+  };
+}
+function createInitialCheckpoint(phase) {
+  return {
+    requestedPhase: phase,
+    nextPhase: phase === "all" ? "decay" : phase,
+    completedPhases: [],
+    phaseResults: {}
+  };
+}
+function createMaintenanceJob(db, phase, checkpoint = createInitialCheckpoint(phase)) {
+  const jobId = newId();
+  const startedAt = now();
+  db.prepare(
+    `INSERT INTO maintenance_jobs (job_id, phase, status, checkpoint, error, started_at, finished_at)
+     VALUES (?, ?, 'running', ?, NULL, ?, NULL)`
+  ).run(jobId, phase, serializeCheckpoint(checkpoint), startedAt);
+  return getMaintenanceJob(db, jobId);
+}
+function getMaintenanceJob(db, jobId) {
+  const row = db.prepare("SELECT * FROM maintenance_jobs WHERE job_id = ?").get(jobId);
+  return toJob(row);
+}
+function findResumableMaintenanceJob(db, phase) {
+  const row = db.prepare(
+    `SELECT *
+     FROM maintenance_jobs
+     WHERE phase = ?
+       AND status IN ('running', 'failed')
+     ORDER BY started_at DESC
+     LIMIT 1`
+  ).get(phase);
+  return toJob(row);
+}
+function updateMaintenanceCheckpoint(db, jobId, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET checkpoint = ?,
+         error = NULL,
+         finished_at = NULL,
+         status = 'running'
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+function failMaintenanceJob(db, jobId, error, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET status = 'failed',
+         checkpoint = COALESCE(?, checkpoint),
+         error = ?,
+         finished_at = ?
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), error, now(), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+function completeMaintenanceJob(db, jobId, checkpoint) {
+  db.prepare(
+    `UPDATE maintenance_jobs
+     SET status = 'completed',
+         checkpoint = COALESCE(?, checkpoint),
+         error = NULL,
+         finished_at = ?
+     WHERE job_id = ?`
+  ).run(serializeCheckpoint(checkpoint), now(), jobId);
+  return getMaintenanceJob(db, jobId);
+}
+
+// src/sleep/orchestrator.ts
+var DEFAULT_RUNNERS = {
+  decay: (db, opts) => runDecay(db, opts),
+  tidy: (db, opts) => runTidy(db, opts),
+  govern: (db, opts) => runGovern(db, opts)
+};
+var PHASE_SEQUENCE = ["decay", "tidy", "govern"];
+function getSummaryStats(db, agentId) {
+  const row = agentId ? db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories WHERE agent_id = ?").get(agentId) : db.prepare("SELECT COUNT(*) as total, COALESCE(AVG(vitality), 0) as avg FROM memories").get();
+  return {
+    total: row.total,
+    avgVitality: row.avg
+  };
+}
+function getPhaseSequence(phase) {
+  return phase === "all" ? [...PHASE_SEQUENCE] : [phase];
+}
+function resolveJob(db, opts) {
+  if (opts.jobId) {
+    const job = getMaintenanceJob(db, opts.jobId);
+    if (!job) {
+      throw new Error(`Maintenance job not found: ${opts.jobId}`);
+    }
+    if (job.phase !== opts.phase) {
+      throw new Error(`Maintenance job ${opts.jobId} phase mismatch: expected ${opts.phase}, got ${job.phase}`);
     }
+    return { job, resumed: true };
   }
-  const ftsTokens = tokenize(input.content.slice(0, 200));
-  const ftsQuery = ftsTokens.length > 0 ? ftsTokens.slice(0, 8).map((w) => `"${w}"`).join(" OR ") : null;
-  if (ftsQuery) {
-    try {
-      const similar = db.prepare(
-        `SELECT m.id, m.content, m.type, rank
-           FROM memories_fts f
-           JOIN memories m ON m.id = f.id
-           WHERE memories_fts MATCH ? AND m.agent_id = ?
-           ORDER BY rank
-           LIMIT 3`
-      ).all(ftsQuery, agentId);
-      if (similar.length > 0) {
-        const topRank = Math.abs(similar[0].rank);
-        const tokenCount = ftsTokens.length;
-        const dynamicThreshold = tokenCount * 1.5;
-        if (topRank > dynamicThreshold) {
-          const existing = similar[0];
-          if (existing.type === input.type) {
-            const merged = `${existing.content}
-
-[Updated] ${input.content}`;
-            return {
-              action: "merge",
-              reason: `Similar content found (score=${topRank.toFixed(1)}, threshold=${dynamicThreshold.toFixed(1)}), merging`,
-              existingId: existing.id,
-              mergedContent: merged
-            };
-          }
-        }
-      }
-    } catch {
+  if (opts.resume !== false) {
+    const resumable = findResumableMaintenanceJob(db, opts.phase);
+    if (resumable) {
+      return { job: resumable, resumed: true };
     }
   }
-  const gateResult = fourCriterionGate(input);
-  if (!gateResult.pass) {
-    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
+  return {
+    job: createMaintenanceJob(db, opts.phase),
+    resumed: false
+  };
+}
+function nextPhase(current, requested) {
+  if (requested !== "all") return null;
+  const index = PHASE_SEQUENCE.indexOf(current);
+  return PHASE_SEQUENCE[index + 1] ?? null;
+}
+async function runReflectOrchestrator(db, opts) {
+  const runners = {
+    ...DEFAULT_RUNNERS,
+    ...opts.runners
+  };
+  const before = getSummaryStats(db, opts.agent_id);
+  const { job: baseJob, resumed } = resolveJob(db, opts);
+  let checkpoint = baseJob.checkpoint ?? createInitialCheckpoint(opts.phase);
+  const jobId = baseJob.job_id;
+  const orderedPhases = getPhaseSequence(opts.phase);
+  const startPhase = checkpoint.nextPhase ?? orderedPhases[orderedPhases.length - 1] ?? "decay";
+  const startIndex = Math.max(0, orderedPhases.indexOf(startPhase));
+  const phasesToRun = checkpoint.nextPhase === null ? [] : orderedPhases.slice(startIndex);
+  const totalPhases = Math.max(orderedPhases.length, 1);
+  opts.onProgress?.({
+    status: "started",
+    phase: opts.phase,
+    progress: checkpoint.completedPhases.length / totalPhases,
+    jobId,
+    detail: {
+      resumed,
+      nextPhase: checkpoint.nextPhase
+    }
+  });
+  try {
+    for (const phase of phasesToRun) {
+      const result = await Promise.resolve(runners[phase](db, { agent_id: opts.agent_id }));
+      checkpoint = {
+        ...checkpoint,
+        completedPhases: [.../* @__PURE__ */ new Set([...checkpoint.completedPhases, phase])],
+        phaseResults: {
+          ...checkpoint.phaseResults,
+          [phase]: result
+        },
+        nextPhase: nextPhase(phase, opts.phase)
+      };
+      updateMaintenanceCheckpoint(db, jobId, checkpoint);
+      opts.onProgress?.({
+        status: "phase-completed",
+        phase,
+        progress: checkpoint.completedPhases.length / totalPhases,
+        jobId,
+        detail: result
+      });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const failed = failMaintenanceJob(db, jobId, message, checkpoint) ?? baseJob;
+    opts.onProgress?.({
+      status: "failed",
+      phase: checkpoint.nextPhase ?? opts.phase,
+      progress: checkpoint.completedPhases.length / totalPhases,
+      jobId,
+      detail: { error: message }
+    });
+    throw Object.assign(new Error(message), { job: failed, checkpoint });
   }
-  return { action: "add", reason: "Passed all guard checks" };
+  const completedCheckpoint = {
+    ...checkpoint,
+    nextPhase: null
+  };
+  const job = completeMaintenanceJob(db, jobId, completedCheckpoint) ?? baseJob;
+  const after = getSummaryStats(db, opts.agent_id);
+  opts.onProgress?.({
+    status: "completed",
+    phase: opts.phase,
+    progress: 1,
+    jobId,
+    detail: completedCheckpoint.phaseResults
+  });
+  return {
+    job,
+    jobId,
+    phase: opts.phase,
+    resumed,
+    checkpoint: completedCheckpoint,
+    results: completedCheckpoint.phaseResults,
+    before,
+    after
+  };
 }
-function fourCriterionGate(input) {
-  const content = input.content.trim();
-  const failed = [];
-  const priority = input.priority ?? (input.type === "identity" ? 0 : input.type === "emotion" ? 1 : input.type === "knowledge" ? 2 : 3);
-  const minLength = priority <= 1 ? 4 : 8;
-  const specificity = content.length >= minLength ? Math.min(1, content.length / 50) : 0;
-  if (specificity === 0) failed.push(`specificity (too short: ${content.length} < ${minLength} chars)`);
-  const tokens = tokenize(content);
-  const novelty = tokens.length >= 1 ? Math.min(1, tokens.length / 5) : 0;
-  if (novelty === 0) failed.push("novelty (no meaningful tokens after filtering)");
-  const hasCJK = /[\u4e00-\u9fff]/.test(content);
-  const hasCapitalized = /[A-Z][a-z]+/.test(content);
-  const hasNumbers = /\d+/.test(content);
-  const hasURI = /\w+:\/\//.test(content);
-  const hasEntityMarkers = /[@#]/.test(content);
-  const hasMeaningfulLength = content.length >= 15;
-  const topicSignals = [hasCJK, hasCapitalized, hasNumbers, hasURI, hasEntityMarkers, hasMeaningfulLength].filter(Boolean).length;
-  const relevance = topicSignals >= 1 ? Math.min(1, topicSignals / 3) : 0;
-  if (relevance === 0) failed.push("relevance (no identifiable topics/entities)");
-  const allCaps = content === content.toUpperCase() && content.length > 20 && /^[A-Z\s]+$/.test(content);
-  const hasWhitespaceOrPunctuation = /[\s，。！？,.!?；;：:]/.test(content) || content.length < 30;
-  const excessiveRepetition = /(.)\1{9,}/.test(content);
-  let coherence = 1;
-  if (allCaps) {
-    coherence -= 0.5;
+
+// src/app/reflect.ts
+async function reflectMemories(db, input) {
+  const options = {
+    phase: input.phase,
+    agent_id: input.agent_id,
+    jobId: input.jobId,
+    resume: input.resume,
+    runners: input.runners,
+    onProgress: input.onProgress
+  };
+  return runReflectOrchestrator(db, options);
+}
+
+// src/app/status.ts
+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 (error) {
+    input?.onProgress?.({
+      status: "failed",
+      stage: "done",
+      progress: 1,
+      detail: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
   }
-  if (!hasWhitespaceOrPunctuation) {
-    coherence -= 0.3;
+}
+
+// src/transports/http.ts
+var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["identity", "emotion", "knowledge", "event"]);
+var VALID_PHASES = /* @__PURE__ */ new Set(["decay", "tidy", "govern", "all"]);
+var VALID_INTENTS = /* @__PURE__ */ new Set(["factual", "preference", "temporal", "planning", "design"]);
+function json(value) {
+  return JSON.stringify(value);
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sendJson(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(json(payload));
+}
+function sendError(res, statusCode, error, details) {
+  sendJson(res, statusCode, { error, details });
+}
+function openSse(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive"
+  });
+  res.write(": connected\n\n");
+}
+function sendSse(res, event, payload) {
+  if (res.writableEnded) return;
+  res.write(`event: ${event}
+`);
+  res.write(`data: ${json(payload)}
+
+`);
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
-  if (excessiveRepetition) {
-    coherence -= 0.5;
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Request body must be a JSON object");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Invalid JSON body");
   }
-  coherence = Math.max(0, coherence);
-  if (coherence < 0.3) failed.push("coherence (garbled or malformed content)");
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const result = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  return result.length > 0 ? result : [];
+}
+function wantsSse(req, body) {
+  const accept = req.headers.accept ?? "";
+  return accept.includes("text/event-stream") || body.stream === true;
+}
+function formatRecallResponse(result) {
   return {
-    pass: failed.length === 0,
-    scores: { specificity, novelty, relevance, coherence },
-    failedCriteria: failed
+    mode: result.mode,
+    provider_id: result.providerId,
+    used_vector_search: result.usedVectorSearch,
+    count: result.results.length,
+    memories: result.results.map((row) => ({
+      id: row.memory.id,
+      content: row.memory.content,
+      type: row.memory.type,
+      priority: row.memory.priority,
+      vitality: row.memory.vitality,
+      score: row.score,
+      bm25_rank: row.bm25_rank,
+      vector_rank: row.vector_rank,
+      bm25_score: row.bm25_score,
+      vector_score: row.vector_score,
+      updated_at: row.memory.updated_at
+    }))
   };
 }
-
-// src/sleep/sync.ts
-function syncOne(db, input) {
-  const memInput = {
-    content: input.content,
-    type: input.type ?? "event",
-    priority: input.priority,
-    emotion_val: input.emotion_val,
-    source: input.source,
-    agent_id: input.agent_id,
-    uri: input.uri
+function formatSurfaceResponse(result) {
+  return {
+    count: result.count,
+    query: result.query,
+    task: result.task,
+    intent: result.intent,
+    results: result.results.map((row) => ({
+      id: row.memory.id,
+      content: row.memory.content,
+      type: row.memory.type,
+      priority: row.memory.priority,
+      vitality: row.memory.vitality,
+      score: row.score,
+      semantic_score: row.semantic_score,
+      lexical_score: row.lexical_score,
+      task_match: row.task_match,
+      priority_prior: row.priority_prior,
+      feedback_score: row.feedback_score,
+      feedback_summary: row.feedback_summary,
+      reason_codes: row.reason_codes,
+      updated_at: row.memory.updated_at
+    }))
   };
-  const guardResult = guard(db, memInput);
-  switch (guardResult.action) {
-    case "skip":
-      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
-    case "add": {
-      const mem = createMemory(db, memInput);
-      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
-      if (input.uri) {
-        try {
-          createPath(db, mem.id, input.uri);
-        } catch {
+}
+function createJob(jobs, kind, agentId) {
+  const job = {
+    id: randomUUID2(),
+    kind,
+    status: "running",
+    stage: "queued",
+    progress: 0,
+    agent_id: agentId,
+    started_at: now2(),
+    finished_at: null
+  };
+  jobs.set(job.id, job);
+  return job;
+}
+function updateJob(job, patch) {
+  Object.assign(job, patch);
+  return job;
+}
+function createHttpServer(options) {
+  const ownsDb = !options?.db;
+  const db = options?.db ?? openDatabase({ path: options?.dbPath ?? process.env.AGENT_MEMORY_DB ?? "./agent-memory.db" });
+  const defaultAgentId = options?.agentId ?? process.env.AGENT_MEMORY_AGENT_ID ?? "default";
+  const jobs = /* @__PURE__ */ new Map();
+  const executeReflectJob = async (job, body, stream) => {
+    const phase = asString(body.phase) ?? "all";
+    if (!VALID_PHASES.has(phase)) {
+      throw new Error(`Invalid phase: ${String(body.phase)}`);
+    }
+    updateJob(job, { stage: phase, progress: 0.01 });
+    try {
+      const result = await reflectMemories(db, {
+        phase,
+        agent_id: asString(body.agent_id) ?? defaultAgentId,
+        runners: options?.reflectRunners,
+        onProgress: (event) => {
+          updateJob(job, {
+            stage: String(event.phase),
+            progress: event.progress,
+            backend_job_id: event.jobId ?? job.backend_job_id
+          });
+          if (stream) {
+            sendSse(stream, "progress", {
+              job,
+              event
+            });
+          }
         }
-      }
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+      });
+      updateJob(job, {
+        status: "completed",
+        stage: "done",
+        progress: 1,
+        backend_job_id: result.jobId,
+        finished_at: now2(),
+        result
+      });
+      return { job, result };
+    } catch (error) {
+      updateJob(job, {
+        status: "failed",
+        stage: "failed",
+        progress: 1,
+        finished_at: now2(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    case "update": {
-      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
-      updateMemory(db, guardResult.existingId, { content: input.content });
-      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
+  };
+  const executeReindexJob = async (job, body, stream) => {
+    updateJob(job, { stage: "fts", progress: 0.01 });
+    try {
+      const result = await reindexMemories(db, {
+        agent_id: asString(body.agent_id) ?? defaultAgentId,
+        provider: options?.provider,
+        force: asBoolean(body.full) ?? false,
+        batchSize: asNumber(body.batch_size) ?? 16,
+        onProgress: (event) => {
+          updateJob(job, {
+            stage: event.stage,
+            progress: event.progress
+          });
+          if (stream) {
+            sendSse(stream, "progress", {
+              job,
+              event
+            });
+          }
+        }
+      });
+      updateJob(job, {
+        status: "completed",
+        stage: "done",
+        progress: 1,
+        finished_at: now2(),
+        result
+      });
+      return { job, result };
+    } catch (error) {
+      updateJob(job, {
+        status: "failed",
+        stage: "failed",
+        progress: 1,
+        finished_at: now2(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    case "merge": {
-      if (!guardResult.existingId || !guardResult.mergedContent) {
-        return { action: "skipped", reason: "Missing merge data" };
+  };
+  const server = http.createServer(async (req, res) => {
+    try {
+      const method = req.method ?? "GET";
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      const pathname = url.pathname;
+      if (method === "GET" && pathname === "/health") {
+        sendJson(res, 200, {
+          ok: true,
+          service: "agent-memory",
+          time: now2()
+        });
+        return;
       }
-      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
-      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+      if (method === "GET" && pathname === "/v1/status") {
+        const agentId = url.searchParams.get("agent_id") ?? defaultAgentId;
+        sendJson(res, 200, getMemoryStatus(db, { agent_id: agentId }));
+        return;
+      }
+      if (method === "GET" && pathname.startsWith("/v1/jobs/")) {
+        const id = decodeURIComponent(pathname.slice("/v1/jobs/".length));
+        const job = jobs.get(id);
+        if (job) {
+          sendJson(res, 200, job);
+          return;
+        }
+        const maintenanceJob = getMaintenanceJob(db, id);
+        if (maintenanceJob) {
+          sendJson(res, 200, maintenanceJob);
+          return;
+        }
+        sendError(res, 404, `Job not found: ${id}`);
+        return;
+      }
+      if (method !== "POST") {
+        sendError(res, 404, `Route not found: ${method} ${pathname}`);
+        return;
+      }
+      const body = await readJsonBody(req);
+      if (pathname === "/v1/memories") {
+        const content = asString(body.content)?.trim();
+        if (!content) {
+          sendError(res, 400, "content is required");
+          return;
+        }
+        const type = asString(body.type) ?? "knowledge";
+        if (!VALID_MEMORY_TYPES.has(type)) {
+          sendError(res, 400, `Invalid memory type: ${String(body.type)}`);
+          return;
+        }
+        const result = await rememberMemory(db, {
+          content,
+          type,
+          uri: asString(body.uri),
+          source: asString(body.source),
+          emotion_val: asNumber(body.emotion_val),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          conservative: asBoolean(body.conservative),
+          provider: options?.provider
+        });
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/recall") {
+        const query = asString(body.query)?.trim();
+        if (!query) {
+          sendError(res, 400, "query is required");
+          return;
+        }
+        const result = await recallMemory(db, {
+          query,
+          limit: asNumber(body.limit),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          provider: options?.provider
+        });
+        sendJson(res, 200, formatRecallResponse(result));
+        return;
+      }
+      if (pathname === "/v1/surface") {
+        const types = asStringArray(body.types)?.filter((type) => VALID_MEMORY_TYPES.has(type));
+        const intent = asString(body.intent);
+        if (intent !== void 0 && !VALID_INTENTS.has(intent)) {
+          sendError(res, 400, `Invalid intent: ${intent}`);
+          return;
+        }
+        const result = await surfaceMemories(db, {
+          query: asString(body.query),
+          task: asString(body.task),
+          recent_turns: asStringArray(body.recent_turns),
+          intent,
+          types,
+          limit: asNumber(body.limit),
+          agent_id: asString(body.agent_id) ?? defaultAgentId,
+          provider: options?.provider
+        });
+        sendJson(res, 200, formatSurfaceResponse(result));
+        return;
+      }
+      if (pathname === "/v1/feedback") {
+        const memoryId = asString(body.memory_id)?.trim();
+        const source = asString(body.source);
+        const useful = asBoolean(body.useful);
+        if (!memoryId) {
+          sendError(res, 400, "memory_id is required");
+          return;
+        }
+        if (source !== "recall" && source !== "surface") {
+          sendError(res, 400, "source must be 'recall' or 'surface'");
+          return;
+        }
+        if (useful === void 0) {
+          sendError(res, 400, "useful must be boolean");
+          return;
+        }
+        const result = recordFeedbackEvent(db, {
+          memory_id: memoryId,
+          source,
+          useful,
+          agent_id: asString(body.agent_id) ?? defaultAgentId
+        });
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/reflect") {
+        const agentId = asString(body.agent_id) ?? defaultAgentId;
+        const job = createJob(jobs, "reflect", agentId);
+        if (wantsSse(req, body)) {
+          openSse(res);
+          sendSse(res, "job", job);
+          void executeReflectJob(job, body, res).then(({ job: currentJob, result: result2 }) => {
+            sendSse(res, "done", { job: currentJob, result: result2 });
+          }).catch((error) => {
+            sendSse(res, "error", {
+              job,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }).finally(() => {
+            if (!res.writableEnded) res.end();
+          });
+          return;
+        }
+        const result = await executeReflectJob(job, body);
+        sendJson(res, 200, result);
+        return;
+      }
+      if (pathname === "/v1/reindex") {
+        const agentId = asString(body.agent_id) ?? defaultAgentId;
+        const job = createJob(jobs, "reindex", agentId);
+        if (wantsSse(req, body)) {
+          openSse(res);
+          sendSse(res, "job", job);
+          void executeReindexJob(job, body, res).then(({ job: currentJob, result: result2 }) => {
+            sendSse(res, "done", { job: currentJob, result: result2 });
+          }).catch((error) => {
+            sendSse(res, "error", {
+              job,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }).finally(() => {
+            if (!res.writableEnded) res.end();
+          });
+          return;
+        }
+        const result = await executeReindexJob(job, body);
+        sendJson(res, 200, result);
+        return;
+      }
+      sendError(res, 404, `Route not found: ${method} ${pathname}`);
+    } catch (error) {
+      sendError(res, 500, error instanceof Error ? error.message : String(error));
     }
-  }
+  });
+  return {
+    server,
+    db,
+    jobs,
+    listen(port = 3e3, host = "127.0.0.1") {
+      return new Promise((resolve2, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+          server.off("error", reject);
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            resolve2({ port, host });
+            return;
+          }
+          resolve2({ port: address.port, host: address.address });
+        });
+      });
+    },
+    close() {
+      return new Promise((resolve2, reject) => {
+        server.close((error) => {
+          if (ownsDb) {
+            try {
+              db.close();
+            } catch {
+            }
+          }
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve2();
+        });
+      });
+    }
+  };
+}
+async function startHttpServer(options) {
+  const service = createHttpServer(options);
+  await service.listen(options?.port, options?.host);
+  return service;
 }
 
 // src/bin/agent-memory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
-import { resolve, basename } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
 var args = process.argv.slice(2);
 var command = args[0];
 function getDbPath() {
@@ -973,19 +3287,21 @@ function getAgentId() {
 }
 function printHelp() {
   console.log(`
-\u{1F9E0} AgentMemory v3 \u2014 Sleep-cycle memory for AI agents
+\u{1F9E0} AgentMemory v4 \u2014 Sleep-cycle memory for AI agents
 
 Usage: agent-memory <command> [options]
 
 Commands:
   init                               Create database
   db:migrate                         Run schema migrations (no-op if up-to-date)
-  remember <content> [--uri X] [--type T]  Store a memory
-  recall <query> [--limit N]         Search memories (BM25 + priority\xD7vitality)
-  boot                               Load identity memories
+  remember <content> [--uri X] [--type T] [--emotion-tag TAG]  Store a memory
+  recall <query> [--limit N] [--emotion-tag TAG]  Search memories (hybrid retrieval)
+  boot [--format json|narrative] [--agent-name NAME]  Load identity memories
+  surface [--out FILE] [--days N] [--limit N]  Export recent memories as Markdown
   status                             Show statistics
   reflect [decay|tidy|govern|all]    Run sleep cycle
-  reindex                            Rebuild FTS index with jieba tokenizer
+  reindex [--full] [--batch-size N]  Rebuild FTS index and embeddings (if configured)
+  serve [--host H] [--port N]        Start the HTTP/SSE API server
   migrate <dir>                      Import from Markdown files
   export <dir>                       Export memories to Markdown files
   help                               Show this help
@@ -996,10 +3312,28 @@ Environment:
 `);
 }
 function getFlag(flag) {
-  const idx = args.indexOf(flag);
-  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];
+  const index = args.indexOf(flag);
+  if (index >= 0 && index + 1 < args.length) return args[index + 1];
   return void 0;
 }
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+function getPositionalArgs(startIndex = 1) {
+  const values = [];
+  for (let index = startIndex; index < args.length; index++) {
+    const token = args[index];
+    if (token.startsWith("--")) {
+      const next = args[index + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        index += 1;
+      }
+      continue;
+    }
+    values.push(token);
+  }
+  return values;
+}
 async function main() {
   try {
     switch (command) {
@@ -1018,7 +3352,7 @@ async function main() {
         break;
       }
       case "remember": {
-        const content = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        const content = getPositionalArgs(1).join(" ");
         if (!content) {
           console.error("Usage: agent-memory remember <content>");
           process.exit(1);
@@ -1026,116 +3360,203 @@ async function main() {
         const db = openDatabase({ path: getDbPath() });
         const uri = getFlag("--uri");
         const type = getFlag("--type") ?? "knowledge";
-        const agentId = getAgentId();
-        const result = syncOne(db, { content, type, uri, source: "manual", agent_id: agentId });
+        const emotionTag = getFlag("--emotion-tag");
+        const result = await rememberMemory(db, {
+          content,
+          type,
+          uri,
+          source: "manual",
+          agent_id: getAgentId(),
+          emotion_tag: emotionTag
+        });
         console.log(`${result.action}: ${result.reason}${result.memoryId ? ` (${result.memoryId.slice(0, 8)})` : ""}`);
         db.close();
         break;
       }
       case "recall": {
-        const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+        const query = getPositionalArgs(1).join(" ");
         if (!query) {
           console.error("Usage: agent-memory recall <query>");
           process.exit(1);
         }
         const db = openDatabase({ path: getDbPath() });
-        const limit = parseInt(getFlag("--limit") ?? "10", 10);
-        const agentId = getAgentId();
-        const raw = searchBM25(db, query, { agent_id: agentId, limit: Math.max(limit * 2, limit) });
-        const weighted = raw.map((r) => {
-          const weight = [4, 3, 2, 1][r.memory.priority] ?? 1;
-          const vitality = Math.max(0.1, r.memory.vitality);
-          return { ...r, score: r.score * weight * vitality };
-        }).sort((a, b) => b.score - a.score).slice(0, limit);
-        console.log(`\u{1F50D} Results: ${weighted.length}
+        const emotionTag = getFlag("--emotion-tag");
+        const result = await recallMemory(db, {
+          query,
+          agent_id: getAgentId(),
+          limit: Number.parseInt(getFlag("--limit") ?? "10", 10),
+          emotion_tag: emotionTag
+        });
+        console.log(`\u{1F50D} Results: ${result.results.length} (${result.mode})
 `);
-        for (const r of weighted) {
-          const p = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][r.memory.priority];
-          const v = (r.memory.vitality * 100).toFixed(0);
-          console.log(`${p} P${r.memory.priority} [${v}%] ${r.memory.content.slice(0, 80)}`);
+        for (const row of result.results) {
+          const priorityLabel = ["\u{1F534}", "\u{1F7E0}", "\u{1F7E1}", "\u26AA"][row.memory.priority];
+          const vitality = (row.memory.vitality * 100).toFixed(0);
+          const branches = [
+            row.bm25_rank ? `bm25#${row.bm25_rank}` : null,
+            row.vector_rank ? `vec#${row.vector_rank}` : null
+          ].filter(Boolean).join(" + ");
+          console.log(`${priorityLabel} P${row.memory.priority} [${vitality}%] ${row.memory.content.slice(0, 80)}${branches ? `  (${branches})` : ""}`);
         }
         db.close();
         break;
       }
       case "boot": {
         const db = openDatabase({ path: getDbPath() });
-        const result = boot(db, { agent_id: getAgentId() });
-        console.log(`\u{1F9E0} Boot: ${result.identityMemories.length} identity memories loaded
+        const format = getFlag("--format") ?? "narrative";
+        const agentName = getFlag("--agent-name") ?? "Agent";
+        const result = boot(db, { agent_id: getAgentId(), format, agent_name: agentName });
+        if (format === "narrative" && result.narrative) {
+          console.log(result.narrative);
+        } else {
+          console.log(`\u{1F9E0} Boot: ${result.identityMemories.length} identity memories loaded
 `);
-        for (const m of result.identityMemories) {
-          console.log(`  \u{1F534} ${m.content.slice(0, 100)}`);
-        }
-        if (result.bootPaths.length) {
-          console.log(`
+          for (const memory of result.identityMemories) {
+            console.log(`  \u{1F534} ${memory.content.slice(0, 100)}`);
+          }
+          if (result.bootPaths.length) {
+            console.log(`
 \u{1F4CD} Boot paths: ${result.bootPaths.join(", ")}`);
+          }
+        }
+        db.close();
+        break;
+      }
+      case "surface": {
+        const db = openDatabase({ path: getDbPath() });
+        const days = Number.parseInt(getFlag("--days") ?? "7", 10);
+        const limit = Number.parseInt(getFlag("--limit") ?? "50", 10);
+        const minVitality = Number.parseFloat(getFlag("--min-vitality") ?? "0.1");
+        const outFile = getFlag("--out");
+        const typesRaw = getFlag("--types");
+        const types = typesRaw ? typesRaw.split(",").map((t) => t.trim()) : void 0;
+        const cutoff = new Date(Date.now() - days * 864e5).toISOString();
+        const surfaceResult = await surfaceMemories(db, {
+          task: "context loading",
+          intent: "temporal",
+          agent_id: getAgentId(),
+          types,
+          limit: Math.max(limit, 100),
+          // fetch more, filter by date after
+          min_vitality: minVitality
+        });
+        const filtered = surfaceResult.results.filter((r) => r.memory.updated_at >= cutoff).slice(0, limit);
+        const grouped = {};
+        for (const r of filtered) {
+          const t = r.memory.type;
+          if (!grouped[t]) grouped[t] = [];
+          grouped[t].push(r);
+        }
+        const { formatRelativeDate: formatRelativeDate2 } = await Promise.resolve().then(() => (init_boot(), boot_exports));
+        const lines = [];
+        lines.push("# Recent Memories");
+        lines.push("");
+        lines.push(`> Auto-generated by AgentMemory surface. Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        lines.push("");
+        const typeOrder = ["identity", "emotion", "knowledge", "event"];
+        const typeLabels = { identity: "Identity", emotion: "Emotion", knowledge: "Knowledge", event: "Events" };
+        for (const t of typeOrder) {
+          const items = grouped[t];
+          if (!items?.length) continue;
+          lines.push(`## ${typeLabels[t]}`);
+          for (const item of items) {
+            const content = item.memory.content.split("\n")[0].slice(0, 200);
+            const time = formatRelativeDate2(item.memory.updated_at);
+            const tag = item.memory.emotion_tag;
+            const meta = t === "emotion" && tag ? `(${tag}, ${time})` : `(${time})`;
+            lines.push(`- ${content} ${meta}`);
+          }
+          lines.push("");
+        }
+        const markdown = lines.join("\n");
+        if (outFile) {
+          writeFileSync2(outFile, markdown, "utf-8");
+          console.log(`\u2705 Surface: ${filtered.length} memories written to ${outFile}`);
+        } else {
+          console.log(markdown);
         }
         db.close();
         break;
       }
       case "status": {
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        const stats = countMemories(db, agentId);
-        const lowVit = db.prepare("SELECT COUNT(*) as c FROM memories WHERE vitality < 0.1 AND agent_id = ?").get(agentId).c;
-        const paths = db.prepare("SELECT COUNT(*) as c FROM paths WHERE agent_id = ?").get(agentId).c;
+        const status = getMemoryStatus(db, { agent_id: getAgentId() });
         console.log("\u{1F9E0} AgentMemory Status\n");
-        console.log(`  Total memories: ${stats.total}`);
-        console.log(`  By type: ${Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-        console.log(`  By priority: ${Object.entries(stats.by_priority).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-        console.log(`  Paths: ${paths}`);
-        console.log(`  Low vitality (<10%): ${lowVit}`);
+        console.log(`  Total memories: ${status.total}`);
+        console.log(`  By type: ${Object.entries(status.by_type).map(([key, value]) => `${key}=${value}`).join(", ")}`);
+        console.log(`  By priority: ${Object.entries(status.by_priority).map(([key, value]) => `${key}=${value}`).join(", ")}`);
+        console.log(`  Paths: ${status.paths}`);
+        console.log(`  Low vitality (<10%): ${status.low_vitality}`);
+        console.log(`  Feedback events: ${status.feedback_events}`);
         db.close();
         break;
       }
       case "reflect": {
         const phase = args[1] ?? "all";
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        console.log(`\u{1F319} Running ${phase} phase...
-`);
-        if (phase === "decay" || phase === "all") {
-          const r = runDecay(db, { agent_id: agentId });
-          console.log(`  Decay: ${r.updated} updated, ${r.decayed} decayed, ${r.belowThreshold} below threshold`);
-        }
-        if (phase === "tidy" || phase === "all") {
-          const r = runTidy(db, { agent_id: agentId });
-          console.log(`  Tidy: ${r.archived} archived, ${r.orphansCleaned} orphans`);
-        }
-        if (phase === "govern" || phase === "all") {
-          const r = runGovern(db, { agent_id: agentId });
-          console.log(`  Govern: ${r.orphanPaths} paths, ${r.emptyMemories} empty cleaned`);
+        const result = await reflectMemories(db, { phase, agent_id: getAgentId() });
+        console.log(`\u{1F319} Reflect job ${result.jobId}${result.resumed ? " (resume)" : ""}`);
+        for (const [name, summary] of Object.entries(result.results)) {
+          console.log(`  ${name}: ${JSON.stringify(summary)}`);
         }
         db.close();
         break;
       }
       case "reindex": {
         const db = openDatabase({ path: getDbPath() });
-        const memories = db.prepare("SELECT id, content FROM memories").all();
-        db.exec("DELETE FROM memories_fts");
-        const insert = db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)");
-        let count = 0;
-        const txn = db.transaction(() => {
-          for (const mem of memories) {
-            insert.run(mem.id, tokenizeForIndex(mem.content));
-            count++;
-          }
+        const result = await reindexMemories(db, {
+          agent_id: getAgentId(),
+          force: hasFlag("--full"),
+          batchSize: Number.parseInt(getFlag("--batch-size") ?? "16", 10)
         });
-        txn();
-        console.log(`\u{1F504} Reindexed ${count} memories with jieba tokenizer`);
+        console.log(`\u{1F504} Reindexed ${result.fts.reindexed} memories in BM25 index`);
+        if (result.embeddings.enabled) {
+          console.log(`\u{1F9EC} Embeddings: provider=${result.embeddings.providerId} scanned=${result.embeddings.scanned} embedded=${result.embeddings.embedded} failed=${result.embeddings.failed}`);
+        } else {
+          console.log("\u{1F9EC} Embeddings: disabled (no provider configured)");
+        }
         db.close();
         break;
       }
+      case "serve": {
+        const port = Number.parseInt(getFlag("--port") ?? process.env.AGENT_MEMORY_HTTP_PORT ?? "3000", 10);
+        const host = getFlag("--host") ?? process.env.AGENT_MEMORY_HTTP_HOST ?? "127.0.0.1";
+        const service = await startHttpServer({
+          dbPath: getDbPath(),
+          agentId: getAgentId(),
+          port,
+          host
+        });
+        const address = service.server.address();
+        if (address && typeof address !== "string") {
+          console.log(`\u{1F310} AgentMemory HTTP server listening on http://${address.address}:${address.port}`);
+        } else {
+          console.log(`\u{1F310} AgentMemory HTTP server listening on http://${host}:${port}`);
+        }
+        const shutdown = async () => {
+          try {
+            await service.close();
+          } finally {
+            process.exit(0);
+          }
+        };
+        process.once("SIGINT", () => {
+          void shutdown();
+        });
+        process.once("SIGTERM", () => {
+          void shutdown();
+        });
+        break;
+      }
       case "export": {
         const dir = args[1];
         if (!dir) {
           console.error("Usage: agent-memory export <directory>");
           process.exit(1);
         }
-        const dirPath = resolve(dir);
         const db = openDatabase({ path: getDbPath() });
-        const agentId = getAgentId();
-        const result = exportMemories(db, dirPath, { agent_id: agentId });
-        console.log(`\u2705 Export complete: ${result.exported} items to ${dirPath} (${result.files.length} files)`);
+        const result = exportMemories(db, resolve(dir), { agent_id: getAgentId() });
+        console.log(`\u2705 Export complete: ${result.exported} items to ${resolve(dir)} (${result.files.length} files)`);
         db.close();
         break;
       }
@@ -1153,10 +3574,10 @@ async function main() {
         const db = openDatabase({ path: getDbPath() });
         const agentId = getAgentId();
         let imported = 0;
-        const memoryFile = ["MEMORY.md", "MEMORY.qmd"].map((f) => resolve(dirPath, f)).find((p) => existsSync2(p));
+        const memoryFile = ["MEMORY.md", "MEMORY.qmd"].map((file) => resolve(dirPath, file)).find((file) => existsSync2(file));
         if (memoryFile) {
           const content = readFileSync2(memoryFile, "utf-8");
-          const sections = content.split(/^## /m).filter((s) => s.trim());
+          const sections = content.split(/^## /m).filter((section) => section.trim());
           for (const section of sections) {
             const lines = section.split("\n");
             const title = lines[0]?.trim();
@@ -1164,40 +3585,46 @@ async function main() {
             if (!body) continue;
             const type = title?.toLowerCase().includes("\u5173\u4E8E") || title?.toLowerCase().includes("about") ? "identity" : "knowledge";
             const uri = `knowledge://memory-md/${title?.replace(/[^a-z0-9\u4e00-\u9fff]/gi, "-").toLowerCase()}`;
-            syncOne(db, { content: `## ${title}
-${body}`, type, uri, source: `migrate:${basename(memoryFile)}`, agent_id: agentId });
-            imported++;
+            await rememberMemory(db, {
+              content: `## ${title}
+${body}`,
+              type,
+              uri,
+              source: `migrate:${basename(memoryFile)}`,
+              agent_id: agentId
+            });
+            imported += 1;
           }
           console.log(`\u{1F4C4} ${basename(memoryFile)}: ${sections.length} sections imported`);
         }
-        const mdFiles = readdirSync(dirPath).filter((f) => /^\d{4}-\d{2}-\d{2}\.(md|qmd)$/.test(f)).sort();
+        const mdFiles = readdirSync(dirPath).filter((file) => /^\d{4}-\d{2}-\d{2}\.(md|qmd)$/.test(file)).sort();
         for (const file of mdFiles) {
           const content = readFileSync2(resolve(dirPath, file), "utf-8");
           const date = file.replace(/\.(md|qmd)$/i, "");
-          syncOne(db, {
+          await rememberMemory(db, {
             content,
             type: "event",
             uri: `event://journal/${date}`,
             source: `migrate:${file}`,
             agent_id: agentId
           });
-          imported++;
+          imported += 1;
         }
         if (mdFiles.length) console.log(`\u{1F4DD} Journals: ${mdFiles.length} files imported`);
         const weeklyDir = resolve(dirPath, "weekly");
         if (existsSync2(weeklyDir)) {
-          const weeklyFiles = readdirSync(weeklyDir).filter((f) => f.endsWith(".md") || f.endsWith(".qmd"));
+          const weeklyFiles = readdirSync(weeklyDir).filter((file) => file.endsWith(".md") || file.endsWith(".qmd"));
           for (const file of weeklyFiles) {
             const content = readFileSync2(resolve(weeklyDir, file), "utf-8");
             const week = file.replace(/\.(md|qmd)$/i, "");
-            syncOne(db, {
+            await rememberMemory(db, {
               content,
               type: "knowledge",
               uri: `knowledge://weekly/${week}`,
               source: `migrate:weekly/${file}`,
               agent_id: agentId
             });
-            imported++;
+            imported += 1;
           }
           if (weeklyFiles.length) console.log(`\u{1F4E6} Weekly: ${weeklyFiles.length} files imported`);
         }
@@ -1217,8 +3644,8 @@ ${body}`, type, uri, source: `migrate:${basename(memoryFile)}`, agent_id: agentI
         printHelp();
         process.exit(1);
     }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     console.error("Error:", message);
     process.exit(1);
   }