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

package/dist/bin/agent-memory.js

@@ -1,126 +1,18 @@
 #!/usr/bin/env node
 // AgentMemory v2 — Sleep-cycle memory for AI agents
-
-// src/bin/agent-memory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
-import { basename, resolve } from "path";
+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 = 5;
-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 (
-  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);
-`;
 function openDatabase(opts) {
   const db = new Database(opts.path);
   if (opts.walMode !== false) {
@@ -198,6 +90,11 @@ function migrateDatabase(db, from, to) {
       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})`);
   }
 }
@@ -283,6 +180,8 @@ function inferSchemaVersion(db) {
   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;
@@ -309,6 +208,9 @@ function ensureIndexes(db) {
   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")) {
@@ -442,14 +344,149 @@ function migrateV4ToV5(db) {
     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 as createHash2 } 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 {
@@ -463,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 = [];
@@ -524,6 +529,44 @@ 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/search/embedding.ts
 import { createHash } from "crypto";
@@ -651,6 +694,11 @@ function createLocalHttpEmbeddingProvider(opts) {
 function normalizeEmbeddingBaseUrl(baseUrl) {
   return trimTrailingSlashes(baseUrl);
 }
+var init_embedding = __esm({
+  "src/search/embedding.ts"() {
+    "use strict";
+  }
+});
 
 // src/search/providers.ts
 function parseDimension(raw) {
@@ -750,6 +798,12 @@ function getConfiguredEmbeddingProviderId(opts) {
     return null;
   }
 }
+var init_providers = __esm({
+  "src/search/providers.ts"() {
+    "use strict";
+    init_embedding();
+  }
+});
 
 // src/search/vector.ts
 function encodeVector(vector) {
@@ -862,27 +916,18 @@ function searchByVector(db, queryVector, opts) {
     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);
 }
-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 resolveEmbeddingProviderId(explicitProviderId) {
   if (explicitProviderId !== void 0) {
     return explicitProviderId;
@@ -909,8 +954,8 @@ function createMemory(db, input) {
   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,
@@ -922,7 +967,8 @@ 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));
@@ -966,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);
@@ -1007,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;
@@ -1031,72 +1085,34 @@ function countMemories(db, agent_id = "default") {
     by_priority: Object.fromEntries(byPriority.map((r) => [`P${r.priority}`, r.c]))
   };
 }
-
-// src/core/export.ts
-import { writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-function exportMemories(db, dirPath, opts) {
-  const agentId = opts?.agent_id ?? "default";
-  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
-  let exported = 0;
-  const files = [];
-  const identities = listMemories(db, { agent_id: agentId, type: "identity" });
-  const knowledge = listMemories(db, { agent_id: agentId, type: "knowledge" });
-  const emotions = listMemories(db, { agent_id: agentId, type: "emotion" });
-  if (identities.length || knowledge.length || emotions.length) {
-    const sections = ["# Agent Memory Export\n"];
-    if (identities.length) {
-      sections.push("## Identity\n");
-      for (const m of identities) {
-        sections.push(`- ${m.content}
-`);
-        exported++;
-      }
-    }
-    if (emotions.length) {
-      sections.push("\n## Emotions\n");
-      for (const m of emotions) {
-        sections.push(`- ${m.content}
-`);
-        exported++;
-      }
-    }
-    if (knowledge.length) {
-      sections.push("\n## Knowledge\n");
-      for (const m of knowledge) {
-        sections.push(`- ${m.content}
-`);
-        exported++;
-      }
-    }
-    const memoryPath = join(dirPath, "MEMORY.md");
-    writeFileSync(memoryPath, sections.join("\n"));
-    files.push(memoryPath);
-  }
-  const events = listMemories(db, { agent_id: agentId, type: "event", limit: 1e4 });
-  const byDate = /* @__PURE__ */ new Map();
-  for (const ev of events) {
-    const date = ev.created_at.slice(0, 10);
-    if (!byDate.has(date)) byDate.set(date, []);
-    byDate.get(date).push(ev);
-  }
-  for (const [date, mems] of byDate) {
-    const lines = [`# ${date}
-`];
-    for (const m of mems) {
-      lines.push(`- ${m.content}
-`);
-      exported++;
-    }
-    const filePath = join(dirPath, `${date}.md`);
-    writeFileSync(filePath, lines.join("\n"));
-    files.push(filePath);
+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
+    };
   }
-  return { exported, files };
-}
+});
 
 // 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`);
@@ -1130,10 +1146,85 @@ function getPath(db, id) {
 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",
@@ -1177,17 +1268,105 @@ function boot(db, opts) {
       }
     }
   }
-  return {
+  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/transports/http.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import http from "http";
+// 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) {
+  const agentId = opts?.agent_id ?? "default";
+  if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+  let exported = 0;
+  const files = [];
+  const identities = listMemories(db, { agent_id: agentId, type: "identity" });
+  const knowledge = listMemories(db, { agent_id: agentId, type: "knowledge" });
+  const emotions = listMemories(db, { agent_id: agentId, type: "emotion" });
+  if (identities.length || knowledge.length || emotions.length) {
+    const sections = ["# Agent Memory Export\n"];
+    if (identities.length) {
+      sections.push("## Identity\n");
+      for (const m of identities) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    if (emotions.length) {
+      sections.push("\n## Emotions\n");
+      for (const m of emotions) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    if (knowledge.length) {
+      sections.push("\n## Knowledge\n");
+      for (const m of knowledge) {
+        sections.push(`- ${m.content}
+`);
+        exported++;
+      }
+    }
+    const memoryPath = join(dirPath, "MEMORY.md");
+    writeFileSync(memoryPath, sections.join("\n"));
+    files.push(memoryPath);
+  }
+  const events = listMemories(db, { agent_id: agentId, type: "event", limit: 1e4 });
+  const byDate = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const date = ev.created_at.slice(0, 10);
+    if (!byDate.has(date)) byDate.set(date, []);
+    byDate.get(date).push(ev);
+  }
+  for (const [date, mems] of byDate) {
+    const lines = [`# ${date}
+`];
+    for (const m of mems) {
+      lines.push(`- ${m.content}
+`);
+      exported++;
+    }
+    const filePath = join(dirPath, `${date}.md`);
+    writeFileSync(filePath, lines.join("\n"));
+    files.push(filePath);
+  }
+  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";
@@ -1258,6 +1437,8 @@ function rebuildBm25Index(db, opts) {
 }
 
 // src/search/hybrid.ts
+init_providers();
+init_vector();
 var PRIORITY_WEIGHT = {
   0: 4,
   1: 3,
@@ -1451,714 +1632,742 @@ async function reindexEmbeddings(db, opts) {
   };
 }
 
-// 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/app/surface.ts
+init_providers();
+init_tokenizer();
+init_vector();
 
-// src/core/guard.ts
-var NEAR_EXACT_THRESHOLD = 0.93;
-var MERGE_THRESHOLD = 0.82;
+// src/app/feedback.ts
+init_db();
 function clamp01(value) {
   if (!Number.isFinite(value)) return 0;
   return Math.max(0, Math.min(1, value));
 }
-function uniqueTokenSet(text) {
-  return new Set(tokenize(text));
-}
-function overlapScore(left, right) {
-  const a = new Set(left);
-  const b = new Set(right);
-  if (a.size === 0 || b.size === 0) return 0;
-  let shared = 0;
-  for (const token of a) {
-    if (b.has(token)) shared += 1;
+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}`);
   }
-  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;
+    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 {
-    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;
+    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 0.2;
+  return {
+    id,
+    memory_id: input.memory_id,
+    source: input.source,
+    useful: input.useful,
+    agent_id: agentId,
+    created_at,
+    value
+  };
 }
-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;
+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 };
     }
-  }
-  if (fallback) {
-    const parsed = new Date(fallback);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
+    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)
+    };
   }
-  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;
+
+// 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
   }
-  const diffDays = Math.abs(inputTime.getTime() - existingTime.getTime()) / (1e3 * 60 * 60 * 24);
-  return clamp01(1 - diffDays / 7);
+};
+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 scoreCandidate(input, candidate, candidateUri) {
-  const lexicalOverlap = overlapScore(uniqueTokenSet(input.content), uniqueTokenSet(candidate.memory.content));
-  const entityOverlap = Math.max(
-    overlapScore(extractEntities(input.content), extractEntities(candidate.memory.content)),
-    lexicalOverlap * 0.75
-  );
-  const uriMatch = uriScopeMatch(input.uri, candidateUri);
-  const temporal = timeProximity(input, candidate.memory, candidateUri);
-  const semantic = clamp01(candidate.vector_score ?? lexicalOverlap);
-  const dedupScore = clamp01(
-    0.5 * semantic + 0.2 * lexicalOverlap + 0.15 * uriMatch + 0.1 * entityOverlap + 0.05 * temporal
+function uniqueTokenSet(values) {
+  return new Set(
+    values.flatMap((value) => tokenize(value ?? "")).map((token) => token.trim()).filter(Boolean)
   );
-  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 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 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
-  };
+function rankScore(rank, window) {
+  if (!rank) return 0;
+  return clamp012(1 - (rank - 1) / Math.max(window, 1));
 }
-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 };
+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;
   }
-  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
-      };
-    }
+}
+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)}`);
   }
-  const gateResult = fourCriterionGate(input);
-  if (!gateResult.pass) {
-    return { action: "skip", reason: `Gate rejected: ${gateResult.failedCriteria.join(", ")}` };
+  if (input.lexicalScore > 0.2 && input.query) {
+    reasons.add(`lexical:${topicLabel(input.query)}`);
   }
-  if (input.conservative) {
-    return { action: "add", reason: "Conservative mode enabled; semantic dedup disabled" };
+  if (input.taskMatch > 0.2) {
+    reasons.add(`task:${topicLabel(input.task, input.intent)}`);
   }
-  const candidates = await recallCandidates(db, input, agentId);
-  const best = candidates[0];
-  if (!best) {
-    return { action: "add", reason: "No relevant semantic candidates found" };
+  if (input.intent) {
+    reasons.add(`intent:${input.intent}`);
   }
-  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 (input.feedbackScore >= 0.67) {
+    reasons.add("feedback:reinforced");
+  } else if (input.feedbackScore <= 0.33) {
+    reasons.add("feedback:negative");
   }
-  if (score.dedup_score >= MERGE_THRESHOLD) {
-    const mergePlan = buildMergePlan({
-      existing: best.result.memory,
-      incoming: {
-        content: input.content,
-        type: input.type,
-        source: input.source
+  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 {
-      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
+      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 {
-    action: "add",
-    reason: `Semantic score below merge threshold (score=${score.dedup_score.toFixed(3)})`,
-    score
+    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
-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 {
-  }
+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)))];
 }
-async function syncOne(db, input) {
-  const memInput = {
-    content: input.content,
-    type: input.type ?? "event",
-    priority: input.priority,
-    emotion_val: input.emotion_val,
-    source: input.source,
-    agent_id: input.agent_id,
-    uri: input.uri,
-    provider: input.provider,
-    conservative: input.conservative
-  };
-  const guardResult = await guard(db, memInput);
-  switch (guardResult.action) {
-    case "skip":
-      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
-    case "add": {
-      const mem = createMemory(db, memInput);
-      if (!mem) return { action: "skipped", reason: "createMemory returned null" };
-      ensureUriPath(db, mem.id, input.uri, input.agent_id);
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
-    }
-    case "update": {
-      if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
-      if (guardResult.updatedContent !== void 0) {
-        updateMemory(db, guardResult.existingId, { content: guardResult.updatedContent });
-      }
-      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
-      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
-    }
-    case "merge": {
-      if (!guardResult.existingId || !guardResult.mergedContent) {
-        return { action: "skipped", reason: "Missing merge data" };
-      }
-      updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
-      ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
-      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
-    }
-  }
+function splitClauses(content) {
+  return content.split(/[\n；;。.!?！？]+/).map((part) => part.trim()).filter(Boolean);
 }
-
-// src/app/remember.ts
-async function rememberMemory(db, input) {
-  return syncOne(db, {
-    content: input.content,
-    type: input.type,
-    priority: input.priority,
-    emotion_val: input.emotion_val,
-    uri: input.uri,
-    source: input.source,
-    agent_id: input.agent_id,
-    provider: input.provider,
-    conservative: input.conservative
-  });
+function mergeAliases(existing, incoming, content) {
+  const aliases = uniqueNonEmpty([
+    existing !== content ? existing : void 0,
+    incoming !== content ? incoming : void 0
+  ]);
+  return aliases.length > 0 ? aliases : void 0;
 }
-
-// src/app/recall.ts
-async function recallMemory(db, input) {
-  return recallMemories(db, input.query, {
-    agent_id: input.agent_id,
-    limit: input.limit,
-    min_vitality: input.min_vitality,
-    lexicalLimit: input.lexicalLimit,
-    vectorLimit: input.vectorLimit,
-    provider: input.provider,
-    recordAccess: input.recordAccess
-  });
+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"]
+  };
 }
-
-// src/app/feedback.ts
-function clamp012(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
+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 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);
-  }
+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 {
-    id,
-    memory_id: input.memory_id,
-    source: input.source,
-    useful: input.useful,
-    agent_id: agentId,
-    created_at,
-    value
+    strategy: "synthesize",
+    content,
+    aliases: mergeAliases(context.existing.content, context.incoming.content, content),
+    notes: ["knowledge statements synthesized into a canonical summary"]
   };
 }
-function getFeedbackSummary(db, memoryId, agentId) {
-  try {
-    const row = db.prepare(
-      `SELECT COUNT(*) as total,
-              COALESCE(SUM(CASE WHEN useful = 1 THEN 1 ELSE 0 END), 0) as useful,
-              COALESCE(SUM(CASE WHEN useful = 0 THEN 1 ELSE 0 END), 0) as not_useful
-       FROM feedback_events
-       WHERE memory_id = ?
-         AND (? IS NULL OR agent_id = ?)`
-    ).get(memoryId, agentId ?? null, agentId ?? null);
-    if (!row || row.total === 0) {
-      return { total: 0, useful: 0, not_useful: 0, score: 0.5 };
-    }
-    return {
-      total: row.total,
-      useful: row.useful,
-      not_useful: row.not_useful,
-      score: clamp012(row.useful / row.total)
-    };
-  } catch {
-    const row = db.prepare(
-      `SELECT COUNT(*) as total,
-              COALESCE(SUM(CASE WHEN value >= 0.5 THEN 1 ELSE 0 END), 0) as useful,
-              COALESCE(SUM(CASE WHEN value < 0.5 THEN 1 ELSE 0 END), 0) as not_useful,
-              COALESCE(AVG(value), 0.5) as avg_value
-       FROM feedback_events
-       WHERE memory_id = ?`
-    ).get(memoryId);
-    if (!row || row.total === 0) {
-      return { total: 0, useful: 0, not_useful: 0, score: 0.5 };
-    }
-    return {
-      total: row.total,
-      useful: row.useful,
-      not_useful: row.not_useful,
-      score: clamp012(row.avg_value)
-    };
+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/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;
+// 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(values) {
-  return new Set(
-    values.flatMap((value) => tokenize(value ?? "")).map((token) => token.trim()).filter(Boolean)
-  );
+function uniqueTokenSet2(text) {
+  return new Set(tokenize(text));
 }
 function overlapScore2(left, right) {
-  if (left.size === 0 || right.size === 0) return 0;
+  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 left) {
-    if (right.has(token)) shared += 1;
+  for (const token of a) {
+    if (b.has(token)) shared += 1;
   }
-  return clamp013(shared / Math.max(left.size, right.size));
+  return shared / Math.max(a.size, b.size);
 }
-function rankScore(rank, window) {
-  if (!rank) return 0;
-  return clamp013(1 - (rank - 1) / Math.max(window, 1));
+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 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 safeDomain(uri) {
+  if (!uri) return null;
+  try {
+    return parseUri(uri).domain;
+  } catch {
+    return null;
+  }
 }
-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 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 intentMatch(memory, intent) {
-  if (!intent) return 0;
-  const prior = INTENT_PRIORS[intent][memory.type] ?? 0;
-  return clamp013(prior * intentKeywordBoost(memory, intent));
+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 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)}`);
+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" };
   }
-  if (input.lexicalScore > 0.2 && input.query) {
-    reasons.add(`lexical:${topicLabel(input.query)}`);
+  const candidates = await recallCandidates(db, input, agentId);
+  const best = candidates[0];
+  if (!best) {
+    return { action: "add", reason: "No relevant semantic candidates found" };
   }
-  if (input.taskMatch > 0.2) {
-    reasons.add(`task:${topicLabel(input.task, input.intent)}`);
+  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 (input.intent) {
-    reasons.add(`intent:${input.intent}`);
+  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
+    };
   }
-  if (input.feedbackScore >= 0.67) {
-    reasons.add("feedback:reinforced");
-  } else if (input.feedbackScore <= 0.33) {
-    reasons.add("feedback:negative");
+  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 {
   }
-  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;
+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 };
     }
-    if (similarity) {
-      const currentSimilarity = similarity.get(row.memory.id);
-      if (currentSimilarity !== void 0) {
-        existing.semanticSimilarity = Math.max(existing.semanticSimilarity ?? 0, currentSimilarity);
+    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 };
     }
-    signals.set(row.memory.id, existing);
-  }
-}
-async function surfaceMemories(db, input) {
-  const agentId = input.agent_id ?? "default";
-  const limit = Math.max(1, Math.min(input.limit ?? 5, 20));
-  const lexicalWindow = Math.max(24, limit * 6);
-  const minVitality = input.min_vitality ?? 0.05;
-  const provider = input.provider === void 0 ? getEmbeddingProviderFromEnv() : input.provider;
-  const signals = /* @__PURE__ */ new Map();
-  const trimmedQuery = input.query?.trim();
-  const trimmedTask = input.task?.trim();
-  const recentTurns = (input.recent_turns ?? []).map((turn) => turn.trim()).filter(Boolean).slice(-4);
-  const queryTokens = uniqueTokenSet2([trimmedQuery, ...recentTurns]);
-  const taskTokens = uniqueTokenSet2([trimmedTask]);
-  if (trimmedQuery) {
-    collectBranch(
-      signals,
-      searchBM25(db, trimmedQuery, {
-        agent_id: agentId,
-        limit: lexicalWindow,
-        min_vitality: minVitality
-      }),
-      "queryRank"
-    );
-  }
-  if (trimmedTask) {
-    collectBranch(
-      signals,
-      searchBM25(db, trimmedTask, {
-        agent_id: agentId,
-        limit: lexicalWindow,
-        min_vitality: minVitality
-      }),
-      "taskRank"
-    );
-  }
-  if (recentTurns.length > 0) {
-    collectBranch(
-      signals,
-      searchBM25(db, recentTurns.join(" "), {
-        agent_id: agentId,
-        limit: lexicalWindow,
-        min_vitality: minVitality
-      }),
-      "recentRank"
-    );
-  }
-  const semanticQuery = [trimmedQuery, trimmedTask, ...recentTurns].filter(Boolean).join("\n").trim();
-  if (provider && semanticQuery) {
-    try {
-      const [queryVector] = await provider.embed([semanticQuery]);
-      if (queryVector) {
-        const vectorRows = searchByVector(db, queryVector, {
-          providerId: provider.id,
-          agent_id: agentId,
-          limit: lexicalWindow,
-          min_vitality: minVitality
-        });
-        const similarity = new Map(vectorRows.map((row) => [row.memory.id, row.similarity]));
-        collectBranch(signals, vectorRows, "semanticRank", similarity);
+    case "merge": {
+      if (!guardResult.existingId || !guardResult.mergedContent) {
+        return { action: "skipped", reason: "Missing merge data" };
       }
-    } catch {
+      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 };
     }
   }
-  const fallbackMemories = listMemories(db, {
-    agent_id: agentId,
-    min_vitality: minVitality,
-    limit: Math.max(48, lexicalWindow)
+}
+
+// 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
   });
-  for (const memory of fallbackMemories) {
-    if (!signals.has(memory.id)) {
-      signals.set(memory.id, { memory });
-    }
+}
+
+// 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);
   }
-  const results = [...signals.values()].map((signal) => signal.memory).filter((memory) => memory.vitality >= minVitality).filter((memory) => input.types?.length ? input.types.includes(memory.type) : true).map((memory) => {
-    const signal = signals.get(memory.id) ?? { memory };
-    const memoryTokens = new Set(tokenize(memory.content));
-    const lexicalOverlap = overlapScore2(memoryTokens, queryTokens);
-    const taskOverlap = overlapScore2(memoryTokens, taskTokens);
-    const lexicalScore = clamp013(
-      0.45 * rankScore(signal.queryRank, lexicalWindow) + 0.15 * rankScore(signal.recentRank, lexicalWindow) + 0.15 * rankScore(signal.taskRank, lexicalWindow) + 0.25 * lexicalOverlap
-    );
-    const semanticScore = signal.semanticSimilarity !== void 0 ? clamp013(Math.max(signal.semanticSimilarity, lexicalOverlap * 0.7)) : trimmedQuery || recentTurns.length > 0 ? clamp013(lexicalOverlap * 0.7) : 0;
-    const intentScore = intentMatch(memory, input.intent);
-    const taskMatch = trimmedTask ? clamp013(0.7 * taskOverlap + 0.3 * intentScore) : intentScore;
-    const priorityScore = priorityPrior(memory.priority);
-    const feedbackSummary = getFeedbackSummary(db, memory.id, agentId);
-    const feedbackScore = feedbackSummary.score;
-    const score = clamp013(
-      0.35 * semanticScore + 0.2 * lexicalScore + 0.15 * taskMatch + 0.1 * memory.vitality + 0.1 * priorityScore + 0.1 * feedbackScore
-    );
-    return {
-      memory,
-      score,
-      semantic_score: semanticScore,
-      lexical_score: lexicalScore,
-      task_match: taskMatch,
-      vitality: memory.vitality,
-      priority_prior: priorityScore,
-      feedback_score: feedbackScore,
-      feedback_summary: feedbackSummary,
-      reason_codes: buildReasonCodes({
-        memory,
-        query: semanticQuery || trimmedQuery,
-        task: trimmedTask,
-        intent: input.intent,
-        semanticScore,
-        lexicalScore,
-        taskMatch,
-        feedbackScore
-      }),
-      lexical_rank: signal.queryRank ?? signal.recentRank ?? signal.taskRank,
-      semantic_rank: signal.semanticRank,
-      semantic_similarity: signal.semanticSimilarity
-    };
-  }).sort((left, right) => {
-    if (right.score !== left.score) return right.score - left.score;
-    if (right.semantic_score !== left.semantic_score) return right.semantic_score - left.semantic_score;
-    if (right.lexical_score !== left.lexical_score) return right.lexical_score - left.lexical_score;
-    if (left.memory.priority !== right.memory.priority) return left.memory.priority - right.memory.priority;
-    return right.memory.updated_at.localeCompare(left.memory.updated_at);
-  }).slice(0, limit);
-  return {
-    count: results.length,
-    query: trimmedQuery,
-    task: trimmedTask,
-    intent: input.intent,
-    results
-  };
+  return result;
 }
 
 // src/sleep/decay.ts
+init_db();
 var MIN_VITALITY = {
   0: 1,
   // P0: identity — never decays
@@ -2219,6 +2428,7 @@ 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;
@@ -2235,6 +2445,8 @@ function runTidy(db, opts) {
 }
 
 // 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));
@@ -2335,6 +2547,7 @@ function runGovern(db, opts) {
 }
 
 // src/sleep/jobs.ts
+init_db();
 function parseCheckpoint(raw) {
   if (!raw) return null;
   try {
@@ -2560,6 +2773,7 @@ async function reflectMemories(db, input) {
 }
 
 // src/app/status.ts
+init_memory();
 function getMemoryStatus(db, input) {
   const agentId = input?.agent_id ?? "default";
   const stats = countMemories(db, agentId);
@@ -3062,6 +3276,7 @@ async function startHttpServer(options) {
 }
 
 // src/bin/agent-memory.ts
+import { writeFileSync as writeFileSync2 } from "fs";
 var args = process.argv.slice(2);
 var command = args[0];
 function getDbPath() {
@@ -3079,9 +3294,10 @@ 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 (hybrid retrieval, auto-fallback to BM25)
-  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 [--full] [--batch-size N]  Rebuild FTS index and embeddings (if configured)
@@ -3144,12 +3360,14 @@ async function main() {
         const db = openDatabase({ path: getDbPath() });
         const uri = getFlag("--uri");
         const type = getFlag("--type") ?? "knowledge";
+        const emotionTag = getFlag("--emotion-tag");
         const result = await rememberMemory(db, {
           content,
           type,
           uri,
           source: "manual",
-          agent_id: getAgentId()
+          agent_id: getAgentId(),
+          emotion_tag: emotionTag
         });
         console.log(`${result.action}: ${result.reason}${result.memoryId ? ` (${result.memoryId.slice(0, 8)})` : ""}`);
         db.close();
@@ -3162,10 +3380,12 @@ async function main() {
           process.exit(1);
         }
         const db = openDatabase({ path: getDbPath() });
+        const emotionTag = getFlag("--emotion-tag");
         const result = await recallMemory(db, {
           query,
           agent_id: getAgentId(),
-          limit: Number.parseInt(getFlag("--limit") ?? "10", 10)
+          limit: Number.parseInt(getFlag("--limit") ?? "10", 10),
+          emotion_tag: emotionTag
         });
         console.log(`\u{1F50D} Results: ${result.results.length} (${result.mode})
 `);
@@ -3183,15 +3403,77 @@ async function main() {
       }
       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 memory of result.identityMemories) {
-          console.log(`  \u{1F534} ${memory.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;