@hasna/mementos 0.11.1 → 0.14.2

package/dist/cli/index.js

@@ -6,39 +6,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -2909,6 +2930,44 @@ CREATE INDEX IF NOT EXISTS idx_memory_embeddings_model ON memory_embeddings(mode
 
 PRAGMA foreign_keys = ON;
 INSERT OR IGNORE INTO _migrations (id) VALUES (29);
+`,
+    `
+ALTER TABLE memories ADD COLUMN when_to_use TEXT DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_when_to_use ON memories(when_to_use) WHERE when_to_use IS NOT NULL;
+ALTER TABLE memory_versions ADD COLUMN when_to_use TEXT;
+INSERT OR IGNORE INTO _migrations (id) VALUES (30);
+`,
+    `
+CREATE TABLE IF NOT EXISTS tool_events (
+  id TEXT PRIMARY KEY,
+  tool_name TEXT NOT NULL,
+  action TEXT,
+  success INTEGER NOT NULL DEFAULT 1,
+  error_type TEXT CHECK(error_type IS NULL OR error_type IN ('timeout', 'permission', 'not_found', 'syntax', 'rate_limit', 'other')),
+  error_message TEXT,
+  tokens_used INTEGER,
+  latency_ms INTEGER,
+  context TEXT,
+  lesson TEXT,
+  when_to_use TEXT,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tool_events_tool_name ON tool_events(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_events_agent ON tool_events(agent_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_project ON tool_events(project_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_success ON tool_events(success);
+CREATE INDEX IF NOT EXISTS idx_tool_events_created ON tool_events(created_at);
+INSERT OR IGNORE INTO _migrations (id) VALUES (31);
+`,
+    `
+ALTER TABLE memories ADD COLUMN sequence_group TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN sequence_order INTEGER DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_group) WHERE sequence_group IS NOT NULL;
+INSERT OR IGNORE INTO _migrations (id) VALUES (32);
 `
   ];
 });
@@ -3317,6 +3376,9 @@ function parseMemoryRow(row) {
     session_id: row["session_id"] || null,
     machine_id: row["machine_id"] || null,
     flag: row["flag"] || null,
+    when_to_use: row["when_to_use"] || null,
+    sequence_group: row["sequence_group"] || null,
+    sequence_order: row["sequence_order"] ?? null,
     content_type: row["content_type"] || "text",
     namespace: row["namespace"] || null,
     created_by_agent: row["created_by_agent"] || null,
@@ -3375,6 +3437,7 @@ function createMemory(input, dedupeMode = "merge", db) {
       d.run(`UPDATE memories SET
            value = ?, category = ?, summary = ?, tags = ?,
            importance = ?, metadata = ?, expires_at = ?,
+           when_to_use = ?,
            pinned = COALESCE(pinned, 0),
            version = version + 1, updated_at = ?
          WHERE id = ?`, [
@@ -3385,6 +3448,7 @@ function createMemory(input, dedupeMode = "merge", db) {
         input.importance ?? 5,
         metadataJson,
         expiresAt,
+        input.when_to_use || null,
         timestamp,
         existing.id
       ]);
@@ -3409,8 +3473,8 @@ function createMemory(input, dedupeMode = "merge", db) {
       return merged;
     }
   }
-  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, namespace, created_by_agent, metadata, access_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, namespace, created_by_agent, when_to_use, sequence_group, sequence_order, metadata, access_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
     id,
     input.key,
     input.value,
@@ -3426,6 +3490,9 @@ function createMemory(input, dedupeMode = "merge", db) {
     input.machine_id || null,
     input.namespace || null,
     input.agent_id || null,
+    input.when_to_use || null,
+    input.sequence_group || null,
+    input.sequence_order ?? null,
     metadataJson,
     expiresAt,
     input.metadata?.valid_from ?? timestamp,
@@ -3636,8 +3703,8 @@ function updateMemory(id, input, db) {
     throw new VersionConflictError(id, input.version, existing.version);
   }
   try {
-    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    d.run(`INSERT OR IGNORE INTO memory_versions (id, memory_id, version, value, importance, scope, category, tags, summary, pinned, status, when_to_use, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       uuid(),
       existing.id,
       existing.version,
@@ -3649,6 +3716,7 @@ function updateMemory(id, input, db) {
       existing.summary,
       existing.pinned ? 1 : 0,
       existing.status,
+      existing.when_to_use || null,
       existing.updated_at
     ]);
   } catch {}
@@ -3694,6 +3762,10 @@ function updateMemory(id, input, db) {
     sets.push("flag = ?");
     params.push(input.flag ?? null);
   }
+  if (input.when_to_use !== undefined) {
+    sets.push("when_to_use = ?");
+    params.push(input.when_to_use ?? null);
+  }
   if (input.tags !== undefined) {
     sets.push("tags = ?");
     params.push(JSON.stringify(input.tags));
@@ -5965,6 +6037,311 @@ var init_synthesis = __esm(() => {
   init_database();
 });
 
+// src/lib/when-to-use-generator.ts
+var exports_when_to_use_generator = {};
+__export(exports_when_to_use_generator, {
+  generateWhenToUse: () => generateWhenToUse,
+  autoGenerateWhenToUse: () => autoGenerateWhenToUse
+});
+async function generateWhenToUse(key, value, category, tags) {
+  if (process.env["MEMENTOS_AUTO_WHEN_TO_USE"] !== "true")
+    return null;
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return null;
+  try {
+    const userMessage = `Key: "${key}"
+Value: "${value}"
+Category: ${category}
+Tags: ${tags.join(", ") || "none"}
+
+Generate the when_to_use activation context (1-2 sentences):`;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 150,
+        system: SYSTEM_PROMPT2,
+        messages: [{ role: "user", content: userMessage }]
+      })
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+async function autoGenerateWhenToUse(ctx) {
+  if (ctx.memory.when_to_use)
+    return;
+  if (process.env["MEMENTOS_AUTO_WHEN_TO_USE"] !== "true")
+    return;
+  try {
+    const whenToUse = await generateWhenToUse(ctx.memory.key, ctx.memory.value, ctx.memory.category, ctx.memory.tags);
+    if (whenToUse) {
+      const db = getDatabase();
+      db.run("UPDATE memories SET when_to_use = ? WHERE id = ? AND when_to_use IS NULL", [whenToUse, ctx.memory.id]);
+    }
+  } catch {}
+}
+var SYSTEM_PROMPT2 = `You generate activation contexts for memory records. Given a memory's key, value, category, and tags, output a 1-2 sentence "when to use" description that describes the SITUATION or CONDITION under which an AI agent should retrieve this memory.
+
+Rules:
+- Start with "When" or "If"
+- Describe the situation, not the content
+- Be specific enough to avoid false matches but general enough to catch relevant scenarios
+- Focus on the task/action the agent would be doing, not what the memory contains
+
+Examples:
+- Key: "preferred-language", Value: "Always use TypeScript, never JavaScript" \u2192 "When choosing a programming language for a new file or project"
+- Key: "db-migration-order", Value: "Always run migrations before deploying" \u2192 "When deploying or updating database schema"
+- Key: "bash-chain-bug", Value: "Bash tool mangles && chains" \u2192 "When chaining commands with && in the Bash tool"`;
+var init_when_to_use_generator = __esm(() => {
+  init_database();
+});
+
+// src/lib/profile-synthesizer.ts
+var exports_profile_synthesizer = {};
+__export(exports_profile_synthesizer, {
+  synthesizeProfile: () => synthesizeProfile,
+  markProfileStale: () => markProfileStale,
+  getProfileKey: () => getProfileKey
+});
+function getProfileKey(scope, id) {
+  return `_profile_${scope}_${id}`;
+}
+async function synthesizeProfile(options) {
+  const scope = options.scope || (options.project_id ? "project" : options.agent_id ? "agent" : "global");
+  const id = options.project_id || options.agent_id || "global";
+  const profileKey = getProfileKey(scope, id);
+  if (!options.force_refresh) {
+    const cached = getMemoryByKey(profileKey, "shared", undefined, options.project_id);
+    if (cached) {
+      const age = Date.now() - new Date(cached.updated_at).getTime();
+      const maxAge = 24 * 60 * 60 * 1000;
+      const isStale = cached.metadata?.stale === true;
+      if (age < maxAge && !isStale) {
+        return { profile: cached.value, memory_count: 0, from_cache: true };
+      }
+    }
+  }
+  const prefMemories = listMemories({
+    category: "preference",
+    project_id: options.project_id,
+    status: "active",
+    limit: 30
+  });
+  const factMemories = listMemories({
+    category: "fact",
+    project_id: options.project_id,
+    status: "active",
+    limit: 30
+  });
+  const allMemories = [...prefMemories, ...factMemories];
+  if (allMemories.length === 0)
+    return null;
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey) {
+    const lines = allMemories.map((m) => `- ${m.key}: ${m.value}`).join(`
+`);
+    const fallbackProfile = `## Profile
+${lines}`;
+    saveProfile(profileKey, fallbackProfile, allMemories.length, options);
+    return { profile: fallbackProfile, memory_count: allMemories.length, from_cache: false };
+  }
+  try {
+    const memoryList = allMemories.sort((a, b) => b.importance - a.importance).map((m) => `[${m.category}] ${m.key}: ${m.value}`).join(`
+`);
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 500,
+        system: PROFILE_PROMPT,
+        messages: [{ role: "user", content: `Synthesize a profile from these ${allMemories.length} memories:
+
+${memoryList}` }]
+      })
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    const profile = data.content?.[0]?.text?.trim();
+    if (!profile)
+      return null;
+    saveProfile(profileKey, profile, allMemories.length, options);
+    return { profile, memory_count: allMemories.length, from_cache: false };
+  } catch {
+    return null;
+  }
+}
+function saveProfile(key, value, memoryCount, options) {
+  try {
+    createMemory({
+      key,
+      value,
+      category: "fact",
+      scope: "shared",
+      importance: 10,
+      source: "auto",
+      tags: ["profile", "synthesized"],
+      when_to_use: "When needing to understand this agent's or project's preferences, style, and conventions",
+      metadata: { memory_count: memoryCount, synthesized_at: new Date().toISOString(), stale: false },
+      agent_id: options.agent_id,
+      project_id: options.project_id
+    });
+  } catch {}
+}
+function markProfileStale(projectId, _agentId) {
+  try {
+    const { getDatabase: getDatabase2 } = (init_database(), __toCommonJS(exports_database));
+    const db = getDatabase2();
+    db.run(`UPDATE memories SET metadata = json_set(COALESCE(metadata, '{}'), '$.stale', json('true'))
+       WHERE key LIKE '_profile_%' AND COALESCE(project_id, '') = ?`, [projectId || ""]);
+  } catch {}
+}
+var PROFILE_PROMPT = `You synthesize a coherent agent/project profile from individual preference and fact memories.
+
+Output a concise profile (200-300 words max) organized by:
+- **Stack & Tools**: Languages, frameworks, package managers, etc.
+- **Code Style**: Formatting, patterns, naming conventions
+- **Workflow**: Testing, deployment, git practices
+- **Communication**: Response style, verbosity, formatting preferences
+- **Key Facts**: Architecture decisions, constraints, team conventions
+
+Only include sections that have relevant data. Be specific and actionable.
+Output in markdown format.`;
+var init_profile_synthesizer = __esm(() => {
+  init_memories();
+});
+
+// src/lib/contradiction.ts
+var exports_contradiction = {};
+__export(exports_contradiction, {
+  invalidateFact: () => invalidateFact,
+  detectContradiction: () => detectContradiction
+});
+function invalidateFact(oldMemoryId, newMemoryId, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run("UPDATE memories SET valid_until = ?, updated_at = ? WHERE id = ?", [timestamp, timestamp, oldMemoryId]);
+  if (newMemoryId) {
+    const row = d.query("SELECT metadata FROM memories WHERE id = ?").get(newMemoryId);
+    if (row) {
+      const metadata = JSON.parse(row.metadata || "{}");
+      metadata.supersedes_id = oldMemoryId;
+      d.run("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), timestamp, newMemoryId]);
+    }
+  }
+  return {
+    invalidated_memory_id: oldMemoryId,
+    new_memory_id: newMemoryId || null,
+    valid_until: timestamp,
+    supersedes_id: oldMemoryId
+  };
+}
+function heuristicContradictionScore(newValue, existingValue, newKey, existingKey) {
+  if (newKey !== existingKey)
+    return 0;
+  const newLower = newValue.toLowerCase().trim();
+  const existingLower = existingValue.toLowerCase().trim();
+  if (newLower === existingLower)
+    return 0;
+  const newWords = new Set(newLower.split(/\s+/));
+  const existingWords = new Set(existingLower.split(/\s+/));
+  let overlap = 0;
+  for (const w of newWords) {
+    if (existingWords.has(w))
+      overlap++;
+  }
+  const totalUnique = new Set([...newWords, ...existingWords]).size;
+  const overlapRatio = totalUnique > 0 ? overlap / totalUnique : 0;
+  if (overlapRatio < 0.3)
+    return 0.7;
+  if (overlapRatio < 0.5)
+    return 0.4;
+  return 0.1;
+}
+async function llmContradictionCheck(_newValue, _existingValue, _key) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider) {
+    return { contradicts: false, confidence: 0, reasoning: "No LLM provider available" };
+  }
+  try {
+    return { contradicts: false, confidence: 0, reasoning: "LLM check skipped \u2014 using heuristic only" };
+  } catch {
+    return { contradicts: false, confidence: 0, reasoning: "LLM check failed" };
+  }
+}
+async function detectContradiction(newKey, newValue, options = {}, db) {
+  const d = db || getDatabase();
+  const { scope, project_id, min_importance = 7, use_llm = false } = options;
+  const conditions = ["key = ?", "status = 'active'", "importance >= ?"];
+  const params = [newKey, min_importance];
+  if (scope) {
+    conditions.push("scope = ?");
+    params.push(scope);
+  }
+  if (project_id) {
+    conditions.push("project_id = ?");
+    params.push(project_id);
+  }
+  conditions.push("(valid_until IS NULL OR valid_until > datetime('now'))");
+  const sql = `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY importance DESC LIMIT 10`;
+  const rows = d.query(sql).all(...params);
+  if (rows.length === 0) {
+    return { contradicts: false, conflicting_memory: null, confidence: 0, reasoning: "No existing memories with this key" };
+  }
+  let bestContradiction = {
+    contradicts: false,
+    conflicting_memory: null,
+    confidence: 0,
+    reasoning: "No contradiction detected"
+  };
+  for (const row of rows) {
+    const existing = parseMemoryRow(row);
+    const heuristicScore = heuristicContradictionScore(newValue, existing.value, newKey, existing.key);
+    if (heuristicScore > bestContradiction.confidence) {
+      bestContradiction = {
+        contradicts: heuristicScore >= 0.5,
+        conflicting_memory: existing,
+        confidence: heuristicScore,
+        reasoning: heuristicScore >= 0.7 ? `New value for "${newKey}" significantly differs from existing high-importance memory (importance ${existing.importance})` : heuristicScore >= 0.5 ? `New value for "${newKey}" partially conflicts with existing memory (importance ${existing.importance})` : `Minor difference detected for "${newKey}"`
+      };
+    }
+  }
+  if (use_llm && bestContradiction.confidence >= 0.3 && bestContradiction.confidence < 0.7 && bestContradiction.conflicting_memory) {
+    const llmResult = await llmContradictionCheck(newValue, bestContradiction.conflicting_memory.value, newKey);
+    if (llmResult.confidence > bestContradiction.confidence) {
+      bestContradiction = {
+        ...bestContradiction,
+        contradicts: llmResult.contradicts,
+        confidence: llmResult.confidence,
+        reasoning: llmResult.reasoning
+      };
+    }
+  }
+  return bestContradiction;
+}
+var init_contradiction = __esm(() => {
+  init_database();
+  init_memories();
+  init_registry();
+});
+
 // src/lib/built-in-hooks.ts
 var exports_built_in_hooks = {};
 __export(exports_built_in_hooks, {
@@ -6091,10 +6468,76 @@ var init_built_in_hooks = __esm(() => {
     description: "Generate and store vector embedding for semantic memory search",
     handler: async (ctx) => {
       const { indexMemoryEmbedding: indexMemoryEmbedding2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
-      const text = [ctx.memory.value, ctx.memory.summary].filter(Boolean).join(" ");
+      const text = ctx.memory.when_to_use || [ctx.memory.value, ctx.memory.summary].filter(Boolean).join(" ");
       indexMemoryEmbedding2(ctx.memory.id, text);
     }
   });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 60,
+    description: "Auto-generate when_to_use activation context via LLM if missing",
+    handler: async (ctx) => {
+      const { autoGenerateWhenToUse: autoGenerateWhenToUse2 } = await Promise.resolve().then(() => (init_when_to_use_generator(), exports_when_to_use_generator));
+      await autoGenerateWhenToUse2(ctx);
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 65,
+    description: "Mark synthesized profile as stale when a preference or fact memory is saved",
+    handler: async (ctx) => {
+      const category = ctx.memory?.category;
+      if (category !== "preference" && category !== "fact")
+        return;
+      try {
+        const { markProfileStale: markProfileStale2 } = await Promise.resolve().then(() => (init_profile_synthesizer(), exports_profile_synthesizer));
+        markProfileStale2(ctx.projectId, ctx.agentId);
+      } catch {}
+    }
+  });
+  hookRegistry.register({
+    type: "PostMemorySave",
+    blocking: false,
+    builtin: true,
+    priority: 70,
+    description: "Auto-decay importance of existing memories contradicted by the newly saved memory",
+    handler: async (ctx) => {
+      if (ctx.wasUpdated)
+        return;
+      const memory = ctx.memory;
+      if (memory.category !== "fact" && memory.category !== "knowledge")
+        return;
+      try {
+        const { detectContradiction: detectContradiction2 } = await Promise.resolve().then(() => (init_contradiction(), exports_contradiction));
+        const { updateMemory: updateMemory2, getMemory: getMemory2 } = await Promise.resolve().then(() => (init_memories(), exports_memories));
+        const result = await detectContradiction2(memory.key, memory.value, {
+          scope: memory.scope,
+          project_id: ctx.projectId,
+          min_importance: 1
+        });
+        if (!result.contradicts || !result.conflicting_memory)
+          return;
+        const conflicting = result.conflicting_memory;
+        if (conflicting.id === memory.id)
+          return;
+        const fresh = getMemory2(conflicting.id);
+        if (!fresh || fresh.status !== "active")
+          return;
+        const halvedImportance = Math.max(1, Math.floor(fresh.importance / 2));
+        const metadata = { ...fresh.metadata || {}, contradicted_by: memory.id };
+        updateMemory2(fresh.id, {
+          importance: halvedImportance,
+          flag: "contradicted",
+          metadata,
+          version: fresh.version
+        });
+      } catch {}
+    }
+  });
   hookRegistry.register({
     type: "PostMemoryInject",
     blocking: false,
@@ -7163,40 +7606,413 @@ var init_session_jobs = __esm(() => {
   init_database();
 });
 
-// src/lib/session-processor.ts
-function chunkTranscript(transcript, chunkSize = 2000, overlap = 200) {
-  if (!transcript || transcript.length === 0)
-    return [];
-  if (transcript.length <= chunkSize)
-    return [transcript];
-  const chunks = [];
-  let start = 0;
-  while (start < transcript.length) {
-    const end = Math.min(start + chunkSize, transcript.length);
-    chunks.push(transcript.slice(start, end));
-    if (end === transcript.length)
-      break;
-    start += chunkSize - overlap;
+// src/db/tool-events.ts
+var exports_tool_events = {};
+__export(exports_tool_events, {
+  saveToolEvent: () => saveToolEvent,
+  getToolStats: () => getToolStats,
+  getToolLessons: () => getToolLessons,
+  getToolEvents: () => getToolEvents,
+  getToolEvent: () => getToolEvent,
+  deleteToolEvents: () => deleteToolEvents
+});
+function parseToolEventRow(row) {
+  return {
+    id: row["id"],
+    tool_name: row["tool_name"],
+    action: row["action"] || null,
+    success: !!row["success"],
+    error_type: row["error_type"] || null,
+    error_message: row["error_message"] || null,
+    tokens_used: row["tokens_used"] ?? null,
+    latency_ms: row["latency_ms"] ?? null,
+    context: row["context"] || null,
+    lesson: row["lesson"] || null,
+    when_to_use: row["when_to_use"] || null,
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"]
+  };
+}
+function saveToolEvent(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const metadataJson = JSON.stringify(input.metadata || {});
+  d.run(`INSERT INTO tool_events (id, tool_name, action, success, error_type, error_message, tokens_used, latency_ms, context, lesson, when_to_use, agent_id, project_id, session_id, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.tool_name,
+    input.action || null,
+    input.success ? 1 : 0,
+    input.error_type || null,
+    input.error_message || null,
+    input.tokens_used ?? null,
+    input.latency_ms ?? null,
+    input.context || null,
+    input.lesson || null,
+    input.when_to_use || null,
+    input.agent_id || null,
+    input.project_id || null,
+    input.session_id || null,
+    metadataJson,
+    timestamp
+  ]);
+  return getToolEvent(id, d);
+}
+function getToolEvent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM tool_events WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseToolEventRow(row);
+}
+function getToolEvents(filters, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filters.tool_name) {
+    conditions.push("tool_name = ?");
+    params.push(filters.tool_name);
   }
-  return chunks;
+  if (filters.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filters.agent_id);
+  }
+  if (filters.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
+  }
+  if (filters.success !== undefined) {
+    conditions.push("success = ?");
+    params.push(filters.success ? 1 : 0);
+  }
+  if (filters.from_date) {
+    conditions.push("created_at >= ?");
+    params.push(filters.from_date);
+  }
+  if (filters.to_date) {
+    conditions.push("created_at <= ?");
+    params.push(filters.to_date);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filters.limit || 50;
+  const offset = filters.offset || 0;
+  const rows = d.query(`SELECT * FROM tool_events ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+  return rows.map(parseToolEventRow);
 }
-async function extractMemoriesFromChunk(chunk, context, db) {
-  const provider = providerRegistry.getAvailable();
-  if (!provider)
+function getToolStats(tool_name, project_id, db) {
+  const d = db || getDatabase();
+  let where = "WHERE tool_name = ?";
+  const params = [tool_name];
+  if (project_id) {
+    where += " AND project_id = ?";
+    params.push(project_id);
+  }
+  const stats = d.query(`SELECT
+      COUNT(*) as total_calls,
+      SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
+      SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failure_count,
+      AVG(CASE WHEN tokens_used IS NOT NULL THEN tokens_used END) as avg_tokens,
+      AVG(CASE WHEN latency_ms IS NOT NULL THEN latency_ms END) as avg_latency_ms,
+      MAX(created_at) as last_used
+    FROM tool_events ${where}`).get(...params);
+  const total = stats["total_calls"] || 0;
+  const successCount = stats["success_count"] || 0;
+  const errorRows = d.query(`SELECT error_type, COUNT(*) as count
+     FROM tool_events ${where} AND error_type IS NOT NULL
+     GROUP BY error_type ORDER BY count DESC LIMIT 5`).all(...params);
+  return {
+    tool_name,
+    total_calls: total,
+    success_count: successCount,
+    failure_count: stats["failure_count"] || 0,
+    success_rate: total > 0 ? successCount / total : 0,
+    avg_tokens: stats["avg_tokens"] ?? null,
+    avg_latency_ms: stats["avg_latency_ms"] ?? null,
+    common_errors: errorRows,
+    last_used: stats["last_used"] || ""
+  };
+}
+function getToolLessons(tool_name, project_id, limit, db) {
+  const d = db || getDatabase();
+  let where = "WHERE tool_name = ? AND lesson IS NOT NULL";
+  const params = [tool_name];
+  if (project_id) {
+    where += " AND project_id = ?";
+    params.push(project_id);
+  }
+  const rows = d.query(`SELECT lesson, when_to_use, created_at FROM tool_events ${where} ORDER BY created_at DESC LIMIT ?`).all(...params, limit || 20);
+  return rows;
+}
+function deleteToolEvents(filters, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filters.tool_name) {
+    conditions.push("tool_name = ?");
+    params.push(filters.tool_name);
+  }
+  if (filters.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filters.agent_id);
+  }
+  if (filters.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filters.project_id);
+  }
+  if (filters.before_date) {
+    conditions.push("created_at < ?");
+    params.push(filters.before_date);
+  }
+  if (conditions.length === 0)
     return 0;
+  const result = d.run(`DELETE FROM tool_events WHERE ${conditions.join(" AND ")}`, params);
+  return result.changes;
+}
+var init_tool_events = __esm(() => {
+  init_database();
+});
+
+// src/lib/tool-lesson-extractor.ts
+async function extractToolLessons(transcript, options) {
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return [];
   try {
-    const extracted = await provider.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
-      sessionId: context.sessionId,
-      agentId: context.agentId,
-      projectId: context.projectId
+    const truncated = transcript.length > 8000 ? transcript.slice(0, 8000) + `
+[...truncated]` : transcript;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 1500,
+        system: SYSTEM_PROMPT3,
+        messages: [{ role: "user", content: `Extract tool lessons from this session transcript:
+
+${truncated}` }]
+      })
     });
-    let savedCount = 0;
-    const sourceTag = context.source ? `source:${context.source}` : "source:manual";
-    for (const memory of extracted) {
-      if (!memory.content || !memory.content.trim())
-        continue;
-      try {
-        createMemory({
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    if (!text)
+      return [];
+    const lessons = JSON.parse(text);
+    if (!Array.isArray(lessons))
+      return [];
+    for (const lesson of lessons) {
+      if (!lesson.tool_name || !lesson.lesson)
+        continue;
+      try {
+        saveToolEvent({
+          tool_name: lesson.tool_name,
+          success: lesson.success,
+          error_type: lesson.error_type || undefined,
+          lesson: lesson.lesson,
+          when_to_use: lesson.when_to_use,
+          context: "extracted from session transcript",
+          agent_id: options?.agent_id,
+          project_id: options?.project_id,
+          session_id: options?.session_id
+        });
+      } catch {}
+      try {
+        createMemory({
+          key: `tool-lesson-${lesson.tool_name}-${Date.now()}`,
+          value: lesson.lesson,
+          category: "knowledge",
+          scope: "shared",
+          importance: 7,
+          source: "auto",
+          tags: ["tool-memory", lesson.tool_name, "auto-extracted"],
+          when_to_use: lesson.when_to_use,
+          agent_id: options?.agent_id,
+          project_id: options?.project_id,
+          session_id: options?.session_id
+        });
+      } catch {}
+    }
+    return lessons;
+  } catch {
+    return [];
+  }
+}
+var SYSTEM_PROMPT3 = `You are a tool usage analyst. Given a session transcript containing tool calls and their results, extract actionable lessons about tool usage.
+
+For each tool lesson, output a JSON array of objects with these fields:
+- tool_name: name of the tool
+- lesson: the insight (1-2 sentences)
+- when_to_use: activation context \u2014 when should an agent recall this lesson (start with "When" or "If")
+- success: boolean \u2014 was the tool call that taught this lesson successful?
+- error_type: if failed, one of: timeout, permission, not_found, syntax, rate_limit, other (or null if success)
+
+Focus on:
+1. Successful patterns: what worked and why
+2. Failure lessons: what went wrong and how to avoid it
+3. Parameter insights: optimal settings discovered
+4. Alternative tools: when one tool is better than another
+5. Error recovery: what to do when a specific error occurs
+
+Only extract genuinely useful, non-obvious lessons. Skip trivial observations.
+Output ONLY the JSON array, no markdown or explanation.`;
+var init_tool_lesson_extractor = __esm(() => {
+  init_tool_events();
+  init_memories();
+});
+
+// src/lib/procedural-extractor.ts
+async function extractProcedures(transcript, options) {
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey)
+    return [];
+  try {
+    const truncated = transcript.length > 8000 ? transcript.slice(0, 8000) + `
+[...truncated]` : transcript;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 2000,
+        system: SYSTEM_PROMPT4,
+        messages: [{ role: "user", content: `Extract procedures from this session:
+
+${truncated}` }]
+      })
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const text = data.content?.[0]?.text?.trim();
+    if (!text)
+      return [];
+    const procedures = JSON.parse(text);
+    if (!Array.isArray(procedures))
+      return [];
+    for (const proc of procedures) {
+      if (!proc.title || !proc.steps?.length)
+        continue;
+      const sequenceGroup = `proc-${shortUuid()}`;
+      for (let i = 0;i < proc.steps.length; i++) {
+        const step = proc.steps[i];
+        if (!step)
+          continue;
+        try {
+          createMemory({
+            key: `${sequenceGroup}-step-${i + 1}`,
+            value: step.action,
+            category: "procedural",
+            scope: "shared",
+            importance: 7,
+            source: "auto",
+            tags: ["procedure", "auto-extracted", proc.title.toLowerCase().replace(/\s+/g, "-")],
+            when_to_use: step.when_to_use || proc.when_to_use,
+            sequence_group: sequenceGroup,
+            sequence_order: i + 1,
+            agent_id: options?.agent_id,
+            project_id: options?.project_id,
+            session_id: options?.session_id
+          });
+        } catch {}
+      }
+      for (const pattern of proc.failure_patterns || []) {
+        try {
+          createMemory({
+            key: `${sequenceGroup}-warning-${shortUuid()}`,
+            value: `WARNING: ${pattern}`,
+            category: "procedural",
+            scope: "shared",
+            importance: 8,
+            source: "auto",
+            tags: ["procedure", "failure-pattern", "auto-extracted"],
+            when_to_use: proc.when_to_use,
+            sequence_group: sequenceGroup,
+            sequence_order: 999,
+            agent_id: options?.agent_id,
+            project_id: options?.project_id,
+            session_id: options?.session_id
+          });
+        } catch {}
+      }
+    }
+    return procedures;
+  } catch {
+    return [];
+  }
+}
+var SYSTEM_PROMPT4 = `You extract procedural knowledge from session transcripts \u2014 workflows, step sequences, and problem-solution patterns.
+
+For each procedure found, output a JSON array of objects:
+{
+  "title": "short name for the workflow",
+  "steps": [
+    {"action": "what to do", "when_to_use": "activation context for this step"},
+    {"action": "next step", "when_to_use": "activation context"}
+  ],
+  "failure_patterns": ["what to avoid and why"],
+  "when_to_use": "overall activation context for the whole procedure"
+}
+
+Focus on:
+1. Multi-step workflows that were completed successfully
+2. Step sequences where order matters
+3. Failure \u2192 recovery patterns (what went wrong, how it was fixed)
+4. Problem-solution pairs (when X happens, do Y)
+
+Only extract non-trivial procedures (3+ steps or genuinely useful patterns).
+Output ONLY the JSON array.`;
+var init_procedural_extractor = __esm(() => {
+  init_memories();
+  init_database();
+});
+
+// src/lib/session-processor.ts
+function chunkTranscript(transcript, chunkSize = 2000, overlap = 200) {
+  if (!transcript || transcript.length === 0)
+    return [];
+  if (transcript.length <= chunkSize)
+    return [transcript];
+  const chunks = [];
+  let start = 0;
+  while (start < transcript.length) {
+    const end = Math.min(start + chunkSize, transcript.length);
+    chunks.push(transcript.slice(start, end));
+    if (end === transcript.length)
+      break;
+    start += chunkSize - overlap;
+  }
+  return chunks;
+}
+async function extractMemoriesFromChunk(chunk, context, db) {
+  const provider = providerRegistry.getAvailable();
+  if (!provider)
+    return 0;
+  try {
+    const extracted = await provider.extractMemories(SESSION_EXTRACTION_USER_TEMPLATE(chunk, context.sessionId), {
+      sessionId: context.sessionId,
+      agentId: context.agentId,
+      projectId: context.projectId
+    });
+    let savedCount = 0;
+    const sourceTag = context.source ? `source:${context.source}` : "source:manual";
+    for (const memory of extracted) {
+      if (!memory.content || !memory.content.trim())
+        continue;
+      try {
+        createMemory({
           key: memory.content.slice(0, 120).replace(/\s+/g, "-").toLowerCase(),
           value: memory.content,
           category: memory.category,
@@ -7320,6 +8136,20 @@ async function processSessionJob(jobId, db) {
     }
   }
   result.memoriesExtracted = totalMemories;
+  try {
+    await extractToolLessons(job.transcript, {
+      agent_id: job.agent_id ?? undefined,
+      project_id: job.project_id ?? undefined,
+      session_id: job.session_id
+    });
+  } catch {}
+  try {
+    await extractProcedures(job.transcript, {
+      agent_id: job.agent_id ?? undefined,
+      project_id: job.project_id ?? undefined,
+      session_id: job.session_id
+    });
+  } catch {}
   try {
     if (result.errors.length > 0 && result.chunksProcessed === 0) {
       updateSessionJob(jobId, {
@@ -7351,6 +8181,8 @@ var init_session_processor = __esm(() => {
   init_memories();
   init_registry();
   init_session_jobs();
+  init_tool_lesson_extractor();
+  init_procedural_extractor();
 });
 
 // src/lib/session-queue.ts
@@ -7440,6 +8272,204 @@ var init_session_queue = __esm(() => {
   _pendingQueue = new Set;
 });
 
+// src/lib/session-registry.ts
+var exports_session_registry = {};
+__export(exports_session_registry, {
+  updateSessionAgent: () => updateSessionAgent,
+  unregisterSession: () => unregisterSession,
+  registerSession: () => registerSession,
+  listSessions: () => listSessions,
+  heartbeatSession: () => heartbeatSession,
+  getSessionsByProject: () => getSessionsByProject,
+  getSessionByAgent: () => getSessionByAgent,
+  getSession: () => getSession,
+  closeRegistry: () => closeRegistry,
+  cleanStaleSessions: () => cleanStaleSessions
+});
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+function getDb() {
+  if (_db2)
+    return _db2;
+  const dir = dirname3(DB_PATH);
+  if (!existsSync5(dir))
+    mkdirSync5(dir, { recursive: true });
+  _db2 = new Database2(DB_PATH, { create: true });
+  _db2.run("PRAGMA journal_mode = WAL");
+  _db2.run("PRAGMA busy_timeout = 3000");
+  _db2.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      pid INTEGER NOT NULL,
+      cwd TEXT NOT NULL,
+      git_root TEXT,
+      agent_name TEXT,
+      project_name TEXT,
+      tty TEXT,
+      mcp_server TEXT NOT NULL,
+      metadata TEXT DEFAULT '{}',
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_pid_mcp
+      ON sessions(pid, mcp_server);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project
+      ON sessions(project_name);
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent
+      ON sessions(agent_name);
+    CREATE INDEX IF NOT EXISTS idx_sessions_git_root
+      ON sessions(git_root);
+  `);
+  return _db2;
+}
+function generateId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function now2() {
+  return new Date().toISOString();
+}
+function parseRow2(row) {
+  return {
+    id: row["id"],
+    pid: row["pid"],
+    cwd: row["cwd"],
+    git_root: row["git_root"] || null,
+    agent_name: row["agent_name"] || null,
+    project_name: row["project_name"] || null,
+    tty: row["tty"] || null,
+    mcp_server: row["mcp_server"],
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    registered_at: row["registered_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerSession(opts) {
+  const db = getDb();
+  const pid = process.pid;
+  const cwd = opts.cwd || process.cwd();
+  const id = generateId();
+  const timestamp = now2();
+  const existing = db.query("SELECT id FROM sessions WHERE pid = ? AND mcp_server = ?").get(pid, opts.mcp_server);
+  if (existing) {
+    db.run(`UPDATE sessions SET agent_name = ?, project_name = ?, cwd = ?,
+       git_root = ?, tty = ?, metadata = ?, last_seen_at = ? WHERE id = ?`, [
+      opts.agent_name || null,
+      opts.project_name || null,
+      cwd,
+      opts.git_root || null,
+      opts.tty || null,
+      JSON.stringify(opts.metadata || {}),
+      timestamp,
+      existing.id
+    ]);
+    return getSession(existing.id);
+  }
+  db.run(`INSERT INTO sessions (id, pid, cwd, git_root, agent_name, project_name, tty, mcp_server, metadata, registered_at, last_seen_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    pid,
+    cwd,
+    opts.git_root || null,
+    opts.agent_name || null,
+    opts.project_name || null,
+    opts.tty || null,
+    opts.mcp_server,
+    JSON.stringify(opts.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getSession(id);
+}
+function heartbeatSession(id) {
+  const db = getDb();
+  db.run("UPDATE sessions SET last_seen_at = ? WHERE id = ?", [now2(), id]);
+}
+function unregisterSession(id) {
+  const db = getDb();
+  db.run("DELETE FROM sessions WHERE id = ?", [id]);
+}
+function getSession(id) {
+  const db = getDb();
+  const row = db.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  return row ? parseRow2(row) : null;
+}
+function listSessions(filter) {
+  const db = getDb();
+  const conditions = [];
+  const params = [];
+  if (filter?.project_name) {
+    conditions.push("project_name = ?");
+    params.push(filter.project_name);
+  }
+  if (filter?.git_root) {
+    conditions.push("git_root = ?");
+    params.push(filter.git_root);
+  }
+  if (filter?.mcp_server) {
+    conditions.push("mcp_server = ?");
+    params.push(filter.mcp_server);
+  }
+  if (filter?.agent_name) {
+    conditions.push("agent_name = ?");
+    params.push(filter.agent_name);
+  }
+  if (filter?.exclude_pid) {
+    conditions.push("pid != ?");
+    params.push(filter.exclude_pid);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.query(`SELECT * FROM sessions ${where} ORDER BY last_seen_at DESC`).all(...params);
+  return rows.map(parseRow2).filter((s) => {
+    if (isProcessAlive(s.pid))
+      return true;
+    db.run("DELETE FROM sessions WHERE id = ?", [s.id]);
+    return false;
+  });
+}
+function getSessionByAgent(agentName) {
+  const sessions = listSessions({ agent_name: agentName });
+  return sessions[0] || null;
+}
+function getSessionsByProject(projectName) {
+  return listSessions({ project_name: projectName });
+}
+function cleanStaleSessions() {
+  const db = getDb();
+  const rows = db.query("SELECT id, pid FROM sessions").all();
+  let cleaned = 0;
+  for (const row of rows) {
+    if (!isProcessAlive(row.pid)) {
+      db.run("DELETE FROM sessions WHERE id = ?", [row.id]);
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
+function updateSessionAgent(mcpServer, agentName) {
+  const db = getDb();
+  const pid = process.pid;
+  db.run("UPDATE sessions SET agent_name = ?, last_seen_at = ? WHERE pid = ? AND mcp_server = ?", [agentName, now2(), pid, mcpServer]);
+}
+function closeRegistry() {
+  if (_db2) {
+    _db2.close();
+    _db2 = null;
+  }
+}
+var DB_PATH, _db2 = null;
+var init_session_registry = __esm(() => {
+  DB_PATH = join5(process.env["HOME"] || process.env["USERPROFILE"] || "~", ".open-sessions-registry.db");
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -7459,10 +8489,10 @@ var {
 // src/cli/index.tsx
 init_database();
 init_memories();
-import chalk from "chalk";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, unlinkSync as unlinkSync2, accessSync, statSync, copyFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, constants as fsConstants } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
-import { homedir as homedir2 } from "os";
+import chalk2 from "chalk";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync6, unlinkSync as unlinkSync2, accessSync, statSync, copyFileSync, mkdirSync as mkdirSync6, readdirSync as readdirSync3, constants as fsConstants } from "fs";
+import { dirname as dirname4, join as join6, resolve as resolve3 } from "path";
+import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
 // src/db/agents.ts
@@ -7945,37 +8975,332 @@ var FORMAT_UNITS = [
 init_entities();
 init_relations();
 init_entity_memories();
+
+// src/cli/brains.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync3,
+  readdirSync as readdirSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import chalk from "chalk";
+
+// src/lib/gatherer.ts
+init_memories();
+var SYSTEM_PROMPT = "You are an AI assistant with persistent memory that recalls and saves information across sessions.";
+function memoryToRecallExample(memory) {
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `What do you remember about "${memory.key}"?`
+      },
+      {
+        role: "assistant",
+        content: memory.summary ? `${memory.value}
+
+Summary: ${memory.summary}` : memory.value
+      }
+    ]
+  };
+}
+function memoryToSaveExample(memory) {
+  const tags = memory.tags ?? [];
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `Remember this for me: ${memory.key} = ${memory.value}${tags.length ? ` (tags: ${tags.join(", ")})` : ""}`
+      },
+      {
+        role: "assistant",
+        content: `Saved to memory: "${memory.key}" with ${memory.category} category, importance ${memory.importance}/10, scope: ${memory.scope}.`
+      }
+    ]
+  };
+}
+function memoryToSearchExample(memories, category) {
+  const matched = memories.filter((m) => m.category === category && m.status === "active").slice(0, 5);
+  return {
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: `What ${category} memories do you have?` },
+      {
+        role: "assistant",
+        content: matched.length > 0 ? `Here are my ${category} memories:
+${matched.map((m) => `- ${m.key}: ${m.value.slice(0, 120)}${m.value.length > 120 ? "..." : ""}`).join(`
+`)}` : `I don't have any ${category} memories stored yet.`
+      }
+    ]
+  };
+}
+var gatherTrainingData = async (options = {}) => {
+  const allMemories = listMemories({ status: "active" });
+  const filtered = options.since ? allMemories.filter((m) => new Date(m.created_at) >= options.since) : allMemories;
+  const sorted = filtered.slice().sort((a, b) => b.importance - a.importance);
+  const fetchSet = options.limit ? sorted.slice(0, options.limit * 3) : sorted;
+  const examples = [];
+  for (const memory of fetchSet) {
+    examples.push(memoryToRecallExample(memory));
+    examples.push(memoryToSaveExample(memory));
+  }
+  const categories = [...new Set(fetchSet.map((m) => m.category))];
+  for (const category of categories) {
+    examples.push(memoryToSearchExample(fetchSet, category));
+  }
+  const finalExamples = options.limit ? examples.slice(0, options.limit) : examples;
+  return {
+    source: "mementos",
+    examples: finalExamples,
+    count: finalExamples.length
+  };
+};
+
+// src/lib/model-config.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var DEFAULT_MODEL = "gpt-4o-mini";
+var CONFIG_DIR = join3(homedir2(), ".mementos");
+var CONFIG_PATH = join3(CONFIG_DIR, "config.json");
+function readConfig() {
+  if (!existsSync3(CONFIG_PATH))
+    return {};
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  if (!existsSync3(CONFIG_DIR)) {
+    mkdirSync3(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function getActiveModel() {
+  const config = readConfig();
+  return config.activeModel ?? DEFAULT_MODEL;
+}
+function setActiveModel(modelId) {
+  const config = readConfig();
+  config.activeModel = modelId;
+  writeConfig(config);
+}
+function clearActiveModel() {
+  const config = readConfig();
+  delete config.activeModel;
+  writeConfig(config);
+}
+
+// src/cli/brains.ts
+function printSuccess(msg) {
+  console.log(chalk.green("\u2713 " + msg));
+}
+function printError(msg) {
+  console.error(chalk.red("\u2717 " + msg));
+}
+function printInfo(msg) {
+  console.log(chalk.cyan("\u2139 " + msg));
+}
+function makeBrainsCommand() {
+  const brains = new Command("brains");
+  brains.description("Fine-tuned model training and management (via @hasna/brains)");
+  brains.command("gather").description("Gather training data from memories and write to JSONL").option("--limit <n>", "Maximum number of examples to gather", parseInt).option("--since <date>", "Only include memories created since this date (ISO 8601)").option("--output <dir>", "Output directory (default: ~/.mementos/training/)").option("--json", "Output result summary as JSON").action(async (opts) => {
+    try {
+      const since = opts.since ? new Date(opts.since) : undefined;
+      if (since && isNaN(since.getTime())) {
+        printError(`Invalid date: ${opts.since}`);
+        process.exit(1);
+      }
+      if (!opts.json) {
+        printInfo("Gathering training data from memories...");
+      }
+      const result = await gatherTrainingData({
+        limit: opts.limit,
+        since
+      });
+      const outputDir = opts.output ?? join4(homedir3(), ".mementos", "training");
+      if (!existsSync4(outputDir)) {
+        mkdirSync4(outputDir, { recursive: true });
+      }
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const outputPath = join4(outputDir, `mementos-training-${timestamp}.jsonl`);
+      const jsonl = result.examples.map((ex) => JSON.stringify(ex)).join(`
+`);
+      writeFileSync3(outputPath, jsonl + `
+`, "utf-8");
+      if (opts.json) {
+        console.log(JSON.stringify({
+          source: result.source,
+          count: result.count,
+          path: outputPath
+        }));
+      } else {
+        printSuccess(`Gathered ${result.count} training examples from memories`);
+        console.log(chalk.dim(`  Output: ${outputPath}`));
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  brains.command("train").description("Start a fine-tuning job using gathered memory training data").option("--base-model <model>", "Base model to fine-tune", "gpt-4o-mini-2024-07-18").option("--provider <provider>", "Provider (openai|thinker-labs)", "openai").option("--dataset <path>", "Path to JSONL dataset (auto-detects latest if omitted)").option("--name <name>", "Display name for the fine-tuned model").option("--json", "Output result as JSON").action(async (opts) => {
+    try {
+      let datasetPath = opts.dataset;
+      if (!datasetPath) {
+        const trainingDir = join4(homedir3(), ".mementos", "training");
+        if (!existsSync4(trainingDir)) {
+          printError("No training data found. Run `mementos brains gather` first.");
+          process.exit(1);
+        }
+        const files = readdirSync2(trainingDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+        const latestFile = files[0];
+        if (!latestFile) {
+          printError("No JSONL training files found. Run `mementos brains gather` first.");
+          process.exit(1);
+        }
+        datasetPath = join4(trainingDir, latestFile);
+      }
+      if (!datasetPath || !existsSync4(datasetPath)) {
+        printError(`Dataset file not found: ${datasetPath ?? "(unresolved)"}`);
+        process.exit(1);
+      }
+      if (!opts.json) {
+        printInfo(`Starting fine-tuning job with dataset: ${datasetPath}`);
+      }
+      let brainsSDK;
+      try {
+        brainsSDK = await import("@hasna/brains");
+      } catch {
+        printError("@hasna/brains is not installed. Run `bun add @hasna/brains` to enable training.");
+        process.exit(1);
+      }
+      const startFinetune = brainsSDK["startFinetune"];
+      if (typeof startFinetune !== "function") {
+        printError("@hasna/brains does not export startFinetune. Please update @hasna/brains.");
+        process.exit(1);
+      }
+      const modelName = opts.name ?? `mementos-${new Date().toISOString().slice(0, 10)}`;
+      const jobResult = await startFinetune({
+        provider: opts.provider,
+        baseModel: opts.baseModel,
+        datasetPath,
+        name: modelName
+      });
+      if (opts.json) {
+        console.log(JSON.stringify(jobResult));
+      } else {
+        printSuccess(`Fine-tuning job started: ${String(jobResult["jobId"] ?? "(unknown)")}`);
+        console.log(chalk.dim(`  Provider:   ${opts.provider}`));
+        console.log(chalk.dim(`  Base model: ${opts.baseModel}`));
+        console.log(chalk.dim(`  Name:       ${modelName}`));
+        if (jobResult["jobId"]) {
+          console.log();
+          printInfo(`Use \`mementos brains model set <model-id>\` once training completes.`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  const modelCmd = brains.command("model").description("Manage the active fine-tuned model");
+  modelCmd.command("get").description("Show the currently active fine-tuned model").option("--json", "Output as JSON").action((opts) => {
+    try {
+      const active = getActiveModel();
+      const isDefault = active === DEFAULT_MODEL;
+      if (opts.json) {
+        console.log(JSON.stringify({ activeModel: active, isDefault }));
+      } else {
+        if (isDefault) {
+          console.log(`Active model: ${chalk.cyan(active)} ${chalk.dim("(default)")}`);
+        } else {
+          console.log(`Active model: ${chalk.green(active)}`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.command("set <modelId>").description("Set the active fine-tuned model ID").action((modelId) => {
+    try {
+      setActiveModel(modelId);
+      printSuccess(`Active model set to: ${modelId}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.command("clear").description(`Clear the active fine-tuned model (reverts to ${DEFAULT_MODEL})`).action(() => {
+    try {
+      clearActiveModel();
+      printSuccess(`Active model cleared. Using default: ${DEFAULT_MODEL}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  modelCmd.action((opts) => {
+    try {
+      const active = getActiveModel();
+      const isDefault = active === DEFAULT_MODEL;
+      if (opts.json) {
+        console.log(JSON.stringify({ activeModel: active, isDefault }));
+      } else {
+        if (isDefault) {
+          console.log(`Active model: ${chalk.cyan(active)} ${chalk.dim("(default)")}`);
+        } else {
+          console.log(`Active model: ${chalk.green(active)}`);
+        }
+      }
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return brains;
+}
+
+// src/cli/index.tsx
 function getPackageVersion() {
   try {
-    const pkgPath = join3(dirname3(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkgPath = join6(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 var scopeColor = {
-  global: chalk.cyan,
-  shared: chalk.yellow,
-  private: chalk.magenta,
-  working: chalk.gray
+  global: chalk2.cyan,
+  shared: chalk2.yellow,
+  private: chalk2.magenta,
+  working: chalk2.gray
 };
 var categoryColor = {
-  preference: chalk.blue,
-  fact: chalk.green,
-  knowledge: chalk.yellow,
-  history: chalk.gray,
-  procedural: chalk.cyan,
-  resource: chalk.magenta
+  preference: chalk2.blue,
+  fact: chalk2.green,
+  knowledge: chalk2.yellow,
+  history: chalk2.gray,
+  procedural: chalk2.cyan,
+  resource: chalk2.magenta
 };
 function importanceColor(importance) {
   if (importance >= 9)
-    return chalk.red.bold;
+    return chalk2.red.bold;
   if (importance >= 7)
-    return chalk.yellow;
+    return chalk2.yellow;
   if (importance >= 5)
-    return chalk.green;
-  return chalk.dim;
+    return chalk2.green;
+  return chalk2.dim;
 }
 function colorScope(scope) {
   return scopeColor[scope](scope);
@@ -7987,17 +9312,17 @@ function colorImportance(importance) {
   return importanceColor(importance)(String(importance));
 }
 var entityTypeColor = {
-  person: chalk.cyan,
-  project: chalk.yellow,
-  tool: chalk.green,
-  concept: chalk.blue,
-  file: chalk.magenta,
-  api: chalk.red,
-  pattern: chalk.gray,
-  organization: chalk.white
+  person: chalk2.cyan,
+  project: chalk2.yellow,
+  tool: chalk2.green,
+  concept: chalk2.blue,
+  file: chalk2.magenta,
+  api: chalk2.red,
+  pattern: chalk2.gray,
+  organization: chalk2.white
 };
 function colorEntityType(type) {
-  const colorFn = entityTypeColor[type] || chalk.white;
+  const colorFn = entityTypeColor[type] || chalk2.white;
   return colorFn(type);
 }
 function resolveEntityArg(nameOrId, type) {
@@ -8008,7 +9333,7 @@ function resolveEntityArg(nameOrId, type) {
   const id = resolvePartialId(db, "entities", nameOrId);
   if (id)
     return getEntity(id);
-  console.error(chalk.red(`Entity not found: ${nameOrId}`));
+  console.error(chalk2.red(`Entity not found: ${nameOrId}`));
   process.exit(1);
 }
 function outputJson(data) {
@@ -8092,44 +9417,44 @@ ${formatObj({ [k]: v }, "    ").replace(/^\s*\S+:\n/, "")}`);
   }
 }
 function formatMemoryLine(m) {
-  const id = chalk.dim(m.id.slice(0, 8));
+  const id = chalk2.dim(m.id.slice(0, 8));
   const scope = colorScope(m.scope);
   const cat = colorCategory(m.category);
   const imp = colorImportance(m.importance);
-  const pin = m.pinned ? chalk.red(" *") : "";
+  const pin = m.pinned ? chalk2.red(" *") : "";
   const value = m.value.length > 80 ? m.value.slice(0, 80) + "..." : m.value;
-  return `${id} [${scope}/${cat}] ${chalk.bold(m.key)} = ${value} (${imp})${pin}`;
+  return `${id} [${scope}/${cat}] ${chalk2.bold(m.key)} = ${value} (${imp})${pin}`;
 }
 function formatMemoryDetail(m) {
   const lines = [
-    `${chalk.bold("ID:")}         ${m.id}`,
-    `${chalk.bold("Key:")}        ${m.key}`,
-    `${chalk.bold("Value:")}      ${m.value}`,
-    `${chalk.bold("Scope:")}      ${colorScope(m.scope)}`,
-    `${chalk.bold("Category:")}   ${colorCategory(m.category)}`,
-    `${chalk.bold("Importance:")} ${colorImportance(m.importance)}/10`,
-    `${chalk.bold("Source:")}     ${m.source}`,
-    `${chalk.bold("Status:")}     ${m.status}`,
-    `${chalk.bold("Pinned:")}     ${m.pinned ? chalk.red("yes") : "no"}`
+    `${chalk2.bold("ID:")}         ${m.id}`,
+    `${chalk2.bold("Key:")}        ${m.key}`,
+    `${chalk2.bold("Value:")}      ${m.value}`,
+    `${chalk2.bold("Scope:")}      ${colorScope(m.scope)}`,
+    `${chalk2.bold("Category:")}   ${colorCategory(m.category)}`,
+    `${chalk2.bold("Importance:")} ${colorImportance(m.importance)}/10`,
+    `${chalk2.bold("Source:")}     ${m.source}`,
+    `${chalk2.bold("Status:")}     ${m.status}`,
+    `${chalk2.bold("Pinned:")}     ${m.pinned ? chalk2.red("yes") : "no"}`
   ];
   if (m.summary)
-    lines.push(`${chalk.bold("Summary:")}    ${m.summary}`);
+    lines.push(`${chalk2.bold("Summary:")}    ${m.summary}`);
   if (m.tags.length > 0)
-    lines.push(`${chalk.bold("Tags:")}       ${m.tags.join(", ")}`);
+    lines.push(`${chalk2.bold("Tags:")}       ${m.tags.join(", ")}`);
   if (m.agent_id)
-    lines.push(`${chalk.bold("Agent:")}      ${m.agent_id}`);
+    lines.push(`${chalk2.bold("Agent:")}      ${m.agent_id}`);
   if (m.project_id)
-    lines.push(`${chalk.bold("Project:")}    ${m.project_id}`);
+    lines.push(`${chalk2.bold("Project:")}    ${m.project_id}`);
   if (m.session_id)
-    lines.push(`${chalk.bold("Session:")}    ${m.session_id}`);
+    lines.push(`${chalk2.bold("Session:")}    ${m.session_id}`);
   if (m.expires_at)
-    lines.push(`${chalk.bold("Expires:")}    ${m.expires_at}`);
-  lines.push(`${chalk.bold("Access:")}     ${m.access_count}`);
-  lines.push(`${chalk.bold("Version:")}    ${m.version}`);
-  lines.push(`${chalk.bold("Created:")}    ${m.created_at}`);
-  lines.push(`${chalk.bold("Updated:")}    ${m.updated_at}`);
+    lines.push(`${chalk2.bold("Expires:")}    ${m.expires_at}`);
+  lines.push(`${chalk2.bold("Access:")}     ${m.access_count}`);
+  lines.push(`${chalk2.bold("Version:")}    ${m.version}`);
+  lines.push(`${chalk2.bold("Created:")}    ${m.created_at}`);
+  lines.push(`${chalk2.bold("Updated:")}    ${m.updated_at}`);
   if (m.accessed_at)
-    lines.push(`${chalk.bold("Accessed:")}   ${m.accessed_at}`);
+    lines.push(`${chalk2.bold("Accessed:")}   ${m.accessed_at}`);
   return lines.join(`
 `);
 }
@@ -8141,7 +9466,7 @@ function handleError(e) {
       error: e instanceof Error ? e.message : String(e)
     });
   } else {
-    console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+    console.error(chalk2.red(e instanceof Error ? e.message : String(e)));
   }
   process.exit(1);
 }
@@ -8149,7 +9474,7 @@ function resolveMemoryId(partialId) {
   const db = getDatabase();
   const id = resolvePartialId(db, "memories", partialId);
   if (!id) {
-    console.error(chalk.red(`Could not resolve memory ID: ${partialId}`));
+    console.error(chalk2.red(`Could not resolve memory ID: ${partialId}`));
     process.exit(1);
   }
   return id;
@@ -8175,10 +9500,10 @@ function resolveKeyOrId(keyOrId, opts, globalOpts) {
 program2.name("mementos").description("Universal memory system for AI agents").version(getPackageVersion()).option("--project <path>", "Project path for scoping").option("--json", "Output as JSON").option("--format <fmt>", "Output format: compact, json, csv, yaml").option("--agent <name>", "Agent name or ID").option("--session <id>", "Session ID");
 program2.command("init").description("One-command setup: register MCP, install stop hook, configure auto-start").action(async () => {
   const { platform } = process;
-  const home = homedir2();
+  const home = homedir4();
   const isMac = platform === "darwin";
   console.log("");
-  console.log(chalk.bold("  mementos \u2014 setting up your memory layer"));
+  console.log(chalk2.bold("  mementos \u2014 setting up your memory layer"));
   console.log("");
   async function run(cmd) {
     try {
@@ -8223,24 +9548,24 @@ program2.command("init").description("One-command setup: register MCP, install s
     mcpError = e instanceof Error ? e.message : String(e);
   }
   if (mcpAlreadyInstalled) {
-    console.log(chalk.dim("  \xB7 MCP already registered"));
+    console.log(chalk2.dim("  \xB7 MCP already registered"));
   } else if (mcpError) {
-    console.log(chalk.red(`  \u2717 Failed to register MCP: ${mcpError}`));
-    console.log(chalk.dim("    (Is Claude Code installed? Try: claude mcp add --transport stdio --scope user mementos -- mementos-mcp)"));
+    console.log(chalk2.red(`  \u2717 Failed to register MCP: ${mcpError}`));
+    console.log(chalk2.dim("    (Is Claude Code installed? Try: claude mcp add --transport stdio --scope user mementos -- mementos-mcp)"));
   } else {
-    console.log(chalk.green("  \u2713 MCP server registered with Claude Code"));
+    console.log(chalk2.green("  \u2713 MCP server registered with Claude Code"));
   }
-  const hooksDir = join3(home, ".claude", "hooks");
-  const hookDest = join3(hooksDir, "mementos-stop-hook.ts");
-  const settingsPath = join3(home, ".claude", "settings.json");
+  const hooksDir = join6(home, ".claude", "hooks");
+  const hookDest = join6(hooksDir, "mementos-stop-hook.ts");
+  const settingsPath = join6(home, ".claude", "settings.json");
   const hookCommand = `bun ${hookDest}`;
   let hookAlreadyInstalled = false;
   let hookError = null;
   try {
     let settings = {};
-    if (existsSync3(settingsPath)) {
+    if (existsSync6(settingsPath)) {
       try {
-        settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+        settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
       } catch {
         settings = {};
       }
@@ -8251,19 +9576,19 @@ program2.command("init").description("One-command setup: register MCP, install s
     if (alreadyHasMementos) {
       hookAlreadyInstalled = true;
     } else {
-      if (!existsSync3(hooksDir)) {
-        mkdirSync3(hooksDir, { recursive: true });
+      if (!existsSync6(hooksDir)) {
+        mkdirSync6(hooksDir, { recursive: true });
       }
-      if (!existsSync3(hookDest)) {
-        const packageDir = dirname3(dirname3(fileURLToPath(import.meta.url)));
+      if (!existsSync6(hookDest)) {
+        const packageDir = dirname4(dirname4(fileURLToPath(import.meta.url)));
         const candidatePaths = [
-          join3(packageDir, "scripts", "hooks", "claude-stop-hook.ts"),
-          join3(packageDir, "..", "scripts", "hooks", "claude-stop-hook.ts"),
-          join3(home, ".bun", "install", "global", "node_modules", "@hasna", "mementos", "scripts", "hooks", "claude-stop-hook.ts")
+          join6(packageDir, "scripts", "hooks", "claude-stop-hook.ts"),
+          join6(packageDir, "..", "scripts", "hooks", "claude-stop-hook.ts"),
+          join6(home, ".bun", "install", "global", "node_modules", "@hasna", "mementos", "scripts", "hooks", "claude-stop-hook.ts")
         ];
         let hookSourceFound = false;
         for (const src of candidatePaths) {
-          if (existsSync3(src)) {
+          if (existsSync6(src)) {
             copyFileSync(src, hookDest);
             hookSourceFound = true;
             break;
@@ -8303,7 +9628,7 @@ async function main() {
 
 main().catch(() => {});
 `;
-          writeFileSync2(hookDest, inlineHook, "utf-8");
+          writeFileSync4(hookDest, inlineHook, "utf-8");
         }
       }
       const newStopEntry = {
@@ -8312,24 +9637,24 @@ main().catch(() => {});
       };
       hooksObj["Stop"] = [...stopHooks, newStopEntry];
       settings["hooks"] = hooksObj;
-      writeFileSync2(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+      writeFileSync4(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
     }
   } catch (e) {
     hookError = e instanceof Error ? e.message : String(e);
   }
   if (hookAlreadyInstalled) {
-    console.log(chalk.dim("  \xB7 Stop hook already installed"));
+    console.log(chalk2.dim("  \xB7 Stop hook already installed"));
   } else if (hookError) {
-    console.log(chalk.red(`  \u2717 Failed to install stop hook: ${hookError}`));
+    console.log(chalk2.red(`  \u2717 Failed to install stop hook: ${hookError}`));
   } else {
-    console.log(chalk.green("  \u2713 Stop hook installed (sessions \u2192 memories)"));
+    console.log(chalk2.green("  \u2713 Stop hook installed (sessions \u2192 memories)"));
   }
   let autoStartAlreadyInstalled = false;
   let autoStartError = null;
   if (!isMac) {
-    console.log(chalk.dim(`  \xB7 Auto-start skipped (not macOS \u2014 platform: ${platform})`));
+    console.log(chalk2.dim(`  \xB7 Auto-start skipped (not macOS \u2014 platform: ${platform})`));
   } else {
-    const plistPath = join3(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
+    const plistPath = join6(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
     const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -8354,30 +9679,30 @@ main().catch(() => {});
 </plist>
 `;
     try {
-      if (existsSync3(plistPath)) {
+      if (existsSync6(plistPath)) {
         autoStartAlreadyInstalled = true;
       } else {
-        const launchAgentsDir = join3(home, "Library", "LaunchAgents");
-        if (!existsSync3(launchAgentsDir)) {
-          mkdirSync3(launchAgentsDir, { recursive: true });
+        const launchAgentsDir = join6(home, "Library", "LaunchAgents");
+        if (!existsSync6(launchAgentsDir)) {
+          mkdirSync6(launchAgentsDir, { recursive: true });
         }
-        writeFileSync2(plistPath, plistContent, "utf-8");
+        writeFileSync4(plistPath, plistContent, "utf-8");
       }
     } catch (e) {
       autoStartError = e instanceof Error ? e.message : String(e);
     }
     if (autoStartAlreadyInstalled) {
-      console.log(chalk.dim("  \xB7 Auto-start already configured"));
+      console.log(chalk2.dim("  \xB7 Auto-start already configured"));
     } else if (autoStartError) {
-      console.log(chalk.red(`  \u2717 Failed to configure auto-start: ${autoStartError}`));
+      console.log(chalk2.red(`  \u2717 Failed to configure auto-start: ${autoStartError}`));
     } else {
-      console.log(chalk.green("  \u2713 Auto-start configured (starts on login)"));
+      console.log(chalk2.green("  \u2713 Auto-start configured (starts on login)"));
     }
     if (!autoStartAlreadyInstalled && !autoStartError) {
-      const plistPath2 = join3(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
+      const plistPath2 = join6(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
       const loadResult = await run(["launchctl", "load", plistPath2]);
       if (!loadResult.ok) {
-        console.log(chalk.dim(`  \xB7 launchctl load: ${loadResult.output || "already loaded"}`));
+        console.log(chalk2.dim(`  \xB7 launchctl load: ${loadResult.output || "already loaded"}`));
       }
     }
   }
@@ -8389,18 +9714,18 @@ main().catch(() => {});
     serverRunning = res.ok;
   } catch {}
   if (serverRunning) {
-    console.log(chalk.green("  \u2713 Server running on http://127.0.0.1:19428"));
+    console.log(chalk2.green("  \u2713 Server running on http://127.0.0.1:19428"));
   } else {
-    console.log(chalk.dim("  \xB7 Server not yet running \u2014 it will start automatically on next login"));
-    console.log(chalk.dim("    (Or start it now: mementos-serve)"));
+    console.log(chalk2.dim("  \xB7 Server not yet running \u2014 it will start automatically on next login"));
+    console.log(chalk2.dim("    (Or start it now: mementos-serve)"));
   }
   console.log("");
-  console.log(chalk.bold("  You're all set. Restart Claude Code to activate."));
+  console.log(chalk2.bold("  You're all set. Restart Claude Code to activate."));
   console.log("");
   console.log("  Quick start:");
-  console.log(`    ${chalk.cyan('mementos save "my-preference" "I prefer bun over npm"')}`);
-  console.log(`    ${chalk.cyan("mementos list")}`);
-  console.log(`    ${chalk.cyan("mementos doctor")}`);
+  console.log(`    ${chalk2.cyan('mementos save "my-preference" "I prefer bun over npm"')}`);
+  console.log(`    ${chalk2.cyan("mementos list")}`);
+  console.log(`    ${chalk2.cyan("mementos doctor")}`);
   console.log("");
 });
 program2.command("save <key> <value>").description("Save a memory (create or upsert)").option("-c, --category <cat>", "Category: preference, fact, knowledge, history").option("-s, --scope <scope>", "Scope: global, shared, private").option("--importance <n>", "Importance 1-10", parseInt).option("--tags <tags>", "Comma-separated tags").option("--summary <text>", "Brief summary").option("--ttl <duration>", "Time-to-live: 30s, 5m, 2h, 1d, 1w, or milliseconds").option("--source <src>", "Source: user, agent, system, auto, imported").option("--template <name>", "Apply a template: correction, preference, decision, learning").action((key, value, opts) => {
@@ -8436,7 +9761,7 @@ program2.command("save <key> <value>").description("Save a memory (create or ups
     if (opts.template) {
       const tpl = templates[opts.template];
       if (!tpl) {
-        console.error(chalk.red(`Unknown template: ${opts.template}. Valid templates: ${Object.keys(templates).join(", ")}`));
+        console.error(chalk2.red(`Unknown template: ${opts.template}. Valid templates: ${Object.keys(templates).join(", ")}`));
         process.exit(1);
       }
       templateDefaults = tpl;
@@ -8465,7 +9790,7 @@ program2.command("save <key> <value>").description("Save a memory (create or ups
     if (globalOpts.json) {
       outputJson(memory);
     } else {
-      console.log(chalk.green(`Saved: ${memory.key} (${memory.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Saved: ${memory.key} (${memory.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -8504,7 +9829,7 @@ program2.command("recall <key>").description("Recall a memory by key").option("-
       if (globalOpts.json) {
         outputJson({ fuzzy_match: true, score: best.score, match_type: best.match_type, memory: best.memory });
       } else {
-        console.log(chalk.yellow(`No exact match, showing best result (score: ${best.score.toFixed(2)}, match: ${best.match_type}):`));
+        console.log(chalk2.yellow(`No exact match, showing best result (score: ${best.score.toFixed(2)}, match: ${best.match_type}):`));
         console.log(formatMemoryDetail(best.memory));
       }
       return;
@@ -8512,7 +9837,7 @@ program2.command("recall <key>").description("Recall a memory by key").option("-
     if (globalOpts.json) {
       outputJson({ error: `No memory found for key: ${key}` });
     } else {
-      console.error(chalk.yellow(`No memory found for key: ${key}`));
+      console.error(chalk2.yellow(`No memory found for key: ${key}`));
     }
     process.exit(1);
   } catch (e) {
@@ -8562,10 +9887,10 @@ program2.command("list").description("List memories with optional filters").opti
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk.yellow("No memories found."));
+      console.log(chalk2.yellow("No memories found."));
       return;
     }
-    console.log(chalk.bold(`${memories.length} memor${memories.length === 1 ? "y" : "ies"}:`));
+    console.log(chalk2.bold(`${memories.length} memor${memories.length === 1 ? "y" : "ies"}:`));
     for (const m of memories) {
       console.log(formatMemoryLine(m));
     }
@@ -8582,7 +9907,7 @@ program2.command("update <id>").description("Update a memory by ID").option("--v
       if (globalOpts.json) {
         outputJson({ error: `Memory not found: ${id}` });
       } else {
-        console.error(chalk.red(`Memory not found: ${id}`));
+        console.error(chalk2.red(`Memory not found: ${id}`));
       }
       process.exit(1);
     }
@@ -8611,7 +9936,7 @@ program2.command("update <id>").description("Update a memory by ID").option("--v
     if (globalOpts.json) {
       outputJson(updated);
     } else {
-      console.log(chalk.green(`Updated: ${updated.key} (${updated.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Updated: ${updated.key} (${updated.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -8627,7 +9952,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
       if (globalOpts.json) {
         outputJson({ deleted: idMatch });
       } else {
-        console.log(chalk.green(`Memory ${idMatch} deleted.`));
+        console.log(chalk2.green(`Memory ${idMatch} deleted.`));
       }
       return;
     }
@@ -8636,7 +9961,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
       if (globalOpts.json) {
         outputJson({ error: `No memory found: ${keyOrId}` });
       } else {
-        console.error(chalk.red(`No memory found: ${keyOrId}`));
+        console.error(chalk2.red(`No memory found: ${keyOrId}`));
       }
       process.exit(1);
     }
@@ -8645,7 +9970,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
       if (globalOpts.json) {
         outputJson({ deleted: matches[0].id, key: keyOrId });
       } else {
-        console.log(chalk.green(`Memory "${keyOrId}" (${matches[0].id}) deleted.`));
+        console.log(chalk2.green(`Memory "${keyOrId}" (${matches[0].id}) deleted.`));
       }
       return;
     }
@@ -8656,7 +9981,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
       if (globalOpts.json) {
         outputJson({ deleted: ids, key: keyOrId, count: ids.length });
       } else {
-        console.log(chalk.green(`Deleted ${ids.length} memories with key "${keyOrId}".`));
+        console.log(chalk2.green(`Deleted ${ids.length} memories with key "${keyOrId}".`));
       }
       return;
     }
@@ -8672,7 +9997,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
         }))
       });
     } else {
-      console.error(chalk.yellow(`Ambiguous: ${matches.length} memories match key "${keyOrId}":
+      console.error(chalk2.yellow(`Ambiguous: ${matches.length} memories match key "${keyOrId}":
 `));
       for (const m of matches) {
         const parts = [
@@ -8684,7 +10009,7 @@ program2.command("forget <keyOrId>").description("Delete a memory by key or ID")
         ].filter(Boolean).join("  ");
         console.error(parts);
       }
-      console.error(chalk.cyan(`
+      console.error(chalk2.cyan(`
 Use the full ID, or narrow with --scope, --agent, --project, or --all.`));
     }
     process.exit(1);
@@ -8702,12 +10027,12 @@ program2.command("search <query>").description("Full-text search across memories
         return;
       }
       if (history.length === 0) {
-        console.log(chalk.yellow("No search history."));
+        console.log(chalk2.yellow("No search history."));
         return;
       }
-      console.log(chalk.bold("Recent searches:"));
+      console.log(chalk2.bold("Recent searches:"));
       for (const h of history) {
-        console.log(`  ${chalk.cyan(h.query)} ${chalk.dim(`(${h.result_count} results, ${h.created_at})`)}`);
+        console.log(`  ${chalk2.cyan(h.query)} ${chalk2.dim(`(${h.result_count} results, ${h.created_at})`)}`);
       }
       return;
     }
@@ -8719,12 +10044,12 @@ program2.command("search <query>").description("Full-text search across memories
         return;
       }
       if (popular.length === 0) {
-        console.log(chalk.yellow("No search history."));
+        console.log(chalk2.yellow("No search history."));
         return;
       }
-      console.log(chalk.bold("Popular searches:"));
+      console.log(chalk2.bold("Popular searches:"));
       for (const p of popular) {
-        console.log(`  ${chalk.cyan(p.query)} ${chalk.dim(`(${p.count} times)`)}`);
+        console.log(`  ${chalk2.cyan(p.query)} ${chalk2.dim(`(${p.count} times)`)}`);
       }
       return;
     }
@@ -8771,16 +10096,16 @@ program2.command("search <query>").description("Full-text search across memories
       return;
     }
     if (results.length === 0) {
-      console.log(chalk.yellow(`No memories found matching "${query}".`));
+      console.log(chalk2.yellow(`No memories found matching "${query}".`));
       return;
     }
-    console.log(chalk.bold(`${results.length} result${results.length === 1 ? "" : "s"} for "${query}":`));
+    console.log(chalk2.bold(`${results.length} result${results.length === 1 ? "" : "s"} for "${query}":`));
     for (const r of results) {
-      const score = chalk.dim(`(score: ${r.score.toFixed(1)})`);
+      const score = chalk2.dim(`(score: ${r.score.toFixed(1)})`);
       console.log(`${formatMemoryLine(r.memory)} ${score}`);
       if (r.highlights && r.highlights.length > 0) {
         for (const h of r.highlights) {
-          console.log(chalk.dim(`    ${h.field}: ${h.snippet}`));
+          console.log(chalk2.dim(`    ${h.field}: ${h.snippet}`));
         }
       }
     }
@@ -8849,16 +10174,16 @@ program2.command("stats").description("Show memory statistics").option("--format
         console.log(`by_agent,${k},${v}`);
       return;
     }
-    console.log(chalk.bold("Memory Statistics"));
-    console.log(`${chalk.bold("Total active:")}  ${chalk.white(String(total))}`);
-    console.log(`${chalk.bold("By scope:")}      ${chalk.cyan("global")}=${stats.by_scope.global}  ${chalk.yellow("shared")}=${stats.by_scope.shared}  ${chalk.magenta("private")}=${stats.by_scope.private}  ${chalk.dim("working")}=${stats.by_scope.working}`);
-    console.log(`${chalk.bold("By category:")}   ${chalk.blue("preference")}=${stats.by_category.preference}  ${chalk.green("fact")}=${stats.by_category.fact}  ${chalk.yellow("knowledge")}=${stats.by_category.knowledge}  ${chalk.gray("history")}=${stats.by_category.history}`);
-    console.log(`${chalk.bold("By status:")}     active=${stats.by_status.active}  archived=${stats.by_status.archived}  expired=${stats.by_status.expired}`);
-    console.log(`${chalk.bold("Pinned:")}        ${stats.pinned_count}`);
-    console.log(`${chalk.bold("Expired:")}       ${stats.expired_count}`);
+    console.log(chalk2.bold("Memory Statistics"));
+    console.log(`${chalk2.bold("Total active:")}  ${chalk2.white(String(total))}`);
+    console.log(`${chalk2.bold("By scope:")}      ${chalk2.cyan("global")}=${stats.by_scope.global}  ${chalk2.yellow("shared")}=${stats.by_scope.shared}  ${chalk2.magenta("private")}=${stats.by_scope.private}  ${chalk2.dim("working")}=${stats.by_scope.working}`);
+    console.log(`${chalk2.bold("By category:")}   ${chalk2.blue("preference")}=${stats.by_category.preference}  ${chalk2.green("fact")}=${stats.by_category.fact}  ${chalk2.yellow("knowledge")}=${stats.by_category.knowledge}  ${chalk2.gray("history")}=${stats.by_category.history}`);
+    console.log(`${chalk2.bold("By status:")}     active=${stats.by_status.active}  archived=${stats.by_status.archived}  expired=${stats.by_status.expired}`);
+    console.log(`${chalk2.bold("Pinned:")}        ${stats.pinned_count}`);
+    console.log(`${chalk2.bold("Expired:")}       ${stats.expired_count}`);
     if (Object.keys(stats.by_agent).length > 0) {
       const agentParts = Object.entries(stats.by_agent).map(([k, v]) => `${k}=${v}`).join("  ");
-      console.log(`${chalk.bold("By agent:")}      ${agentParts}`);
+      console.log(`${chalk2.bold("By agent:")}      ${agentParts}`);
     }
   } catch (e) {
     handleError(e);
@@ -8923,30 +10248,30 @@ program2.command("report").description("Rich summary of memory activity and top
       const maxC = Math.max(...activityRows.map((x) => x.cnt), 1);
       return bars[Math.round(r.cnt / maxC * 7)] || "\u2581";
     }).join("");
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 mementos report \u2014 last ${days} days
 `));
-    console.log(`  ${chalk.cyan("Total:")}     ${total} memories (${chalk.yellow(String(pinned))} pinned)`);
-    console.log(`  ${chalk.cyan("Recent:")}    ${recentTotal} new \xB7 ${chalk.dim(`~${avgPerDay}/day`)}`);
-    console.log(`  ${chalk.cyan("Activity:")}  ${sparkline || chalk.dim("no activity")}`);
-    console.log(`  ${chalk.cyan("Scopes:")}    global=${byScope["global"] || 0} shared=${byScope["shared"] || 0} private=${byScope["private"] || 0}`);
-    console.log(`  ${chalk.cyan("Categories:")} knowledge=${byCat["knowledge"] || 0} fact=${byCat["fact"] || 0} preference=${byCat["preference"] || 0} history=${byCat["history"] || 0}`);
+    console.log(`  ${chalk2.cyan("Total:")}     ${total} memories (${chalk2.yellow(String(pinned))} pinned)`);
+    console.log(`  ${chalk2.cyan("Recent:")}    ${recentTotal} new \xB7 ${chalk2.dim(`~${avgPerDay}/day`)}`);
+    console.log(`  ${chalk2.cyan("Activity:")}  ${sparkline || chalk2.dim("no activity")}`);
+    console.log(`  ${chalk2.cyan("Scopes:")}    global=${byScope["global"] || 0} shared=${byScope["shared"] || 0} private=${byScope["private"] || 0}`);
+    console.log(`  ${chalk2.cyan("Categories:")} knowledge=${byCat["knowledge"] || 0} fact=${byCat["fact"] || 0} preference=${byCat["preference"] || 0} history=${byCat["history"] || 0}`);
     if (topMems.length > 0) {
       console.log(`
-  ${chalk.bold("Top memories by importance:")}`);
+  ${chalk2.bold("Top memories by importance:")}`);
       topMems.forEach((m) => {
-        console.log(`    ${chalk.green(`[${m.importance}]`)} ${chalk.bold(m.key)} ${chalk.dim(`(${m.scope}/${m.category})`)}`);
+        console.log(`    ${chalk2.green(`[${m.importance}]`)} ${chalk2.bold(m.key)} ${chalk2.dim(`(${m.scope}/${m.category})`)}`);
         console.log(`       ${m.value.slice(0, 90)}${m.value.length > 90 ? "..." : ""}`);
       });
     }
     if (topAgents.length > 0) {
       console.log(`
-  ${chalk.bold("Top agents:")}`);
+  ${chalk2.bold("Top agents:")}`);
       topAgents.forEach((a) => console.log(`    ${a.agent_id}: ${a.c} memories`));
     }
     console.log("");
   } catch (e) {
-    console.error(chalk.red(`report failed: ${e instanceof Error ? e.message : String(e)}`));
+    console.error(chalk2.red(`report failed: ${e instanceof Error ? e.message : String(e)}`));
     process.exit(1);
   }
 });
@@ -8991,21 +10316,21 @@ program2.command("stale").description("Find memories not accessed recently (for
       return;
     }
     if (rows.length === 0) {
-      console.log(chalk.green(`No stale memories (not accessed in ${days}+ days).`));
+      console.log(chalk2.green(`No stale memories (not accessed in ${days}+ days).`));
       return;
     }
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Stale memories (not accessed in ${days}+ days):
 `));
     for (const m of rows) {
-      const lastAccess = m.accessed_at ? m.accessed_at.slice(0, 10) : chalk.dim("never");
-      console.log(`  ${chalk.dim(`[${m.importance}]`)} ${chalk.bold(m.key)} ${chalk.dim(`(${m.scope}/${m.category})`)}`);
+      const lastAccess = m.accessed_at ? m.accessed_at.slice(0, 10) : chalk2.dim("never");
+      console.log(`  ${chalk2.dim(`[${m.importance}]`)} ${chalk2.bold(m.key)} ${chalk2.dim(`(${m.scope}/${m.category})`)}`);
       console.log(`    Last accessed: ${lastAccess} \xB7 ${m.access_count} reads \xB7 ${m.value.slice(0, 80)}${m.value.length > 80 ? "..." : ""}`);
     }
     console.log(`
-${chalk.dim(`${rows.length} result(s). Run 'mementos archive <key>' or 'mementos forget <key>' to clean up.`)}`);
+${chalk2.dim(`${rows.length} result(s). Run 'mementos archive <key>' or 'mementos forget <key>' to clean up.`)}`);
   } catch (e) {
-    console.error(chalk.red(`stale failed: ${e instanceof Error ? e.message : String(e)}`));
+    console.error(chalk2.red(`stale failed: ${e instanceof Error ? e.message : String(e)}`));
     process.exit(1);
   }
 });
@@ -9040,9 +10365,9 @@ program2.command("import [file]").description("Import memories from a JSON file
     if (file === "-" || !file && !process.stdin.isTTY) {
       raw = await Bun.stdin.text();
     } else if (file) {
-      raw = readFileSync2(resolve3(file), "utf-8");
+      raw = readFileSync3(resolve3(file), "utf-8");
     } else {
-      console.error(chalk.red("No input: provide a file path, use '-' for stdin, or pipe data."));
+      console.error(chalk2.red("No input: provide a file path, use '-' for stdin, or pipe data."));
       process.exit(1);
     }
     const memories = JSON.parse(raw);
@@ -9058,7 +10383,7 @@ program2.command("import [file]").description("Import memories from a JSON file
     if (globalOpts.json) {
       outputJson({ imported });
     } else {
-      console.log(chalk.green(`Imported ${imported} memor${imported === 1 ? "y" : "ies"}.`));
+      console.log(chalk2.green(`Imported ${imported} memor${imported === 1 ? "y" : "ies"}.`));
     }
   } catch (e) {
     handleError(e);
@@ -9072,12 +10397,12 @@ program2.command("clean").description("Remove expired memories and enforce quota
     if (globalOpts.json) {
       outputJson(result);
     } else {
-      console.log(chalk.bold("Cleanup complete:"));
-      console.log(`  Expired removed:    ${chalk.red(String(result.expired))}`);
-      console.log(`  Evicted (quota):    ${chalk.yellow(String(result.evicted))}`);
-      console.log(`  Archived (stale):   ${chalk.gray(String(result.archived))}`);
-      console.log(`  Archived (unused):  ${chalk.gray(String(result.unused_archived))}`);
-      console.log(`  Deprioritized:      ${chalk.blue(String(result.deprioritized))}`);
+      console.log(chalk2.bold("Cleanup complete:"));
+      console.log(`  Expired removed:    ${chalk2.red(String(result.expired))}`);
+      console.log(`  Evicted (quota):    ${chalk2.yellow(String(result.evicted))}`);
+      console.log(`  Archived (stale):   ${chalk2.gray(String(result.archived))}`);
+      console.log(`  Archived (unused):  ${chalk2.gray(String(result.unused_archived))}`);
+      console.log(`  Deprioritized:      ${chalk2.blue(String(result.deprioritized))}`);
     }
   } catch (e) {
     handleError(e);
@@ -9090,11 +10415,11 @@ program2.command("register-agent <name>").alias("init-agent").description("Regis
     if (globalOpts.json) {
       outputJson(agent);
     } else {
-      console.log(chalk.green("Agent registered:"));
-      console.log(`  ${chalk.bold("ID:")}        ${agent.id}`);
-      console.log(`  ${chalk.bold("Name:")}      ${agent.name}`);
-      console.log(`  ${chalk.bold("Role:")}      ${agent.role || "agent"}`);
-      console.log(`  ${chalk.bold("Created:")}   ${agent.created_at}`);
+      console.log(chalk2.green("Agent registered:"));
+      console.log(`  ${chalk2.bold("ID:")}        ${agent.id}`);
+      console.log(`  ${chalk2.bold("Name:")}      ${agent.name}`);
+      console.log(`  ${chalk2.bold("Role:")}      ${agent.role || "agent"}`);
+      console.log(`  ${chalk2.bold("Created:")}   ${agent.created_at}`);
     }
   } catch (e) {
     handleError(e);
@@ -9109,12 +10434,12 @@ program2.command("agents").description("List all registered agents").action(() =
       return;
     }
     if (agents.length === 0) {
-      console.log(chalk.yellow("No agents registered."));
+      console.log(chalk2.yellow("No agents registered."));
       return;
     }
-    console.log(chalk.bold(`${agents.length} agent${agents.length === 1 ? "" : "s"}:`));
+    console.log(chalk2.bold(`${agents.length} agent${agents.length === 1 ? "" : "s"}:`));
     for (const a of agents) {
-      console.log(`  ${chalk.dim(a.id)} ${chalk.bold(a.name)} ${chalk.gray(a.role || "agent")} ${chalk.dim(`last seen: ${a.last_seen_at}`)}`);
+      console.log(`  ${chalk2.dim(a.id)} ${chalk2.bold(a.name)} ${chalk2.gray(a.role || "agent")} ${chalk2.dim(`last seen: ${a.last_seen_at}`)}`);
     }
   } catch (e) {
     handleError(e);
@@ -9134,7 +10459,7 @@ program2.command("agent-update <id>").description("Update an agent's name, descr
       if (globalOpts.json) {
         outputJson({ error: "No updates provided. Use --name, --description, or --role." });
       } else {
-        console.error(chalk.red("No updates provided. Use --name, --description, or --role."));
+        console.error(chalk2.red("No updates provided. Use --name, --description, or --role."));
       }
       process.exit(1);
     }
@@ -9143,19 +10468,19 @@ program2.command("agent-update <id>").description("Update an agent's name, descr
       if (globalOpts.json) {
         outputJson({ error: `Agent not found: ${id}` });
       } else {
-        console.error(chalk.red(`Agent not found: ${id}`));
+        console.error(chalk2.red(`Agent not found: ${id}`));
       }
       process.exit(1);
     }
     if (globalOpts.json) {
       outputJson(agent);
     } else {
-      console.log(chalk.green("Agent updated:"));
-      console.log(`  ${chalk.bold("ID:")}          ${agent.id}`);
-      console.log(`  ${chalk.bold("Name:")}        ${agent.name}`);
-      console.log(`  ${chalk.bold("Description:")} ${agent.description || "-"}`);
-      console.log(`  ${chalk.bold("Role:")}        ${agent.role || "agent"}`);
-      console.log(`  ${chalk.bold("Last seen:")}   ${agent.last_seen_at}`);
+      console.log(chalk2.green("Agent updated:"));
+      console.log(`  ${chalk2.bold("ID:")}          ${agent.id}`);
+      console.log(`  ${chalk2.bold("Name:")}        ${agent.name}`);
+      console.log(`  ${chalk2.bold("Description:")} ${agent.description || "-"}`);
+      console.log(`  ${chalk2.bold("Role:")}        ${agent.role || "agent"}`);
+      console.log(`  ${chalk2.bold("Last seen:")}   ${agent.last_seen_at}`);
     }
   } catch (e) {
     handleError(e);
@@ -9168,17 +10493,17 @@ program2.command("projects").description("Manage projects").option("--add", "Add
       const name = opts.name;
       const path = opts.path;
       if (!name || !path) {
-        console.error(chalk.red("--name and --path are required when adding a project"));
+        console.error(chalk2.red("--name and --path are required when adding a project"));
         process.exit(1);
       }
       const project = registerProject(name, resolve3(path), opts.description);
       if (globalOpts.json) {
         outputJson(project);
       } else {
-        console.log(chalk.green("Project registered:"));
-        console.log(`  ${chalk.bold("ID:")}     ${project.id}`);
-        console.log(`  ${chalk.bold("Name:")}   ${project.name}`);
-        console.log(`  ${chalk.bold("Path:")}   ${project.path}`);
+        console.log(chalk2.green("Project registered:"));
+        console.log(`  ${chalk2.bold("ID:")}     ${project.id}`);
+        console.log(`  ${chalk2.bold("Name:")}   ${project.name}`);
+        console.log(`  ${chalk2.bold("Path:")}   ${project.path}`);
       }
       return;
     }
@@ -9188,12 +10513,12 @@ program2.command("projects").description("Manage projects").option("--add", "Add
       return;
     }
     if (projects.length === 0) {
-      console.log(chalk.yellow("No projects registered."));
+      console.log(chalk2.yellow("No projects registered."));
       return;
     }
-    console.log(chalk.bold(`${projects.length} project${projects.length === 1 ? "" : "s"}:`));
+    console.log(chalk2.bold(`${projects.length} project${projects.length === 1 ? "" : "s"}:`));
     for (const p of projects) {
-      console.log(`  ${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.gray(p.path)}${p.description ? chalk.dim(` \u2014 ${p.description}`) : ""}`);
+      console.log(`  ${chalk2.dim(p.id.slice(0, 8))} ${chalk2.bold(p.name)} ${chalk2.gray(p.path)}${p.description ? chalk2.dim(` \u2014 ${p.description}`) : ""}`);
     }
   } catch (e) {
     handleError(e);
@@ -9283,7 +10608,7 @@ program2.command("inject").description("Output injection context for agent syste
       if (globalOpts.json) {
         outputJson({ context: "", count: 0 });
       } else {
-        console.log(chalk.yellow("No relevant memories found for injection."));
+        console.log(chalk2.yellow("No relevant memories found for injection."));
       }
       return;
     }
@@ -9323,7 +10648,7 @@ program2.command("bulk <action> <ids...>").description("Batch operations: forget
       "unpin"
     ];
     if (!validActions.includes(action)) {
-      console.error(chalk.red(`Invalid action: ${action}. Valid: ${validActions.join(", ")}`));
+      console.error(chalk2.red(`Invalid action: ${action}. Valid: ${validActions.join(", ")}`));
       process.exit(1);
     }
     const resolvedIds = ids.map((id) => resolveMemoryId(id));
@@ -9376,7 +10701,7 @@ program2.command("bulk <action> <ids...>").description("Batch operations: forget
     if (globalOpts.json) {
       outputJson({ action, affected, ids: resolvedIds });
     } else {
-      console.log(chalk.green(`${action}: ${affected} memor${affected === 1 ? "y" : "ies"} affected.`));
+      console.log(chalk2.green(`${action}: ${affected} memor${affected === 1 ? "y" : "ies"} affected.`));
     }
   } catch (e) {
     handleError(e);
@@ -9389,7 +10714,7 @@ program2.command("doctor").description("Diagnose common issues with the mementos
   checks.push({ name: "Version", status: "ok", detail: version });
   const dbPath = getDbPath();
   let db = null;
-  if (dbPath !== ":memory:" && existsSync3(dbPath)) {
+  if (dbPath !== ":memory:" && existsSync6(dbPath)) {
     try {
       accessSync(dbPath, fsConstants.R_OK | fsConstants.W_OK);
       checks.push({ name: "Database file", status: "ok", detail: dbPath });
@@ -9408,7 +10733,7 @@ program2.command("doctor").description("Diagnose common issues with the mementos
     checks.push({ name: "Database connection", status: "fail", detail: e instanceof Error ? e.message : String(e) });
   }
   try {
-    if (dbPath !== ":memory:" && existsSync3(dbPath)) {
+    if (dbPath !== ":memory:" && existsSync6(dbPath)) {
       const stats = statSync(dbPath);
       const sizeKb = (stats.size / 1024).toFixed(1);
       const sizeMb = (stats.size / (1024 * 1024)).toFixed(2);
@@ -9446,14 +10771,14 @@ program2.command("doctor").description("Diagnose common issues with the mementos
     const byScope = {};
     let expiredCount = 0;
     let staleCount = 0;
-    const now2 = Date.now();
+    const now3 = Date.now();
     const staleThreshold = 14 * 24 * 60 * 60 * 1000;
     for (const m of all) {
       byScope[m.scope] = (byScope[m.scope] || 0) + 1;
       if (m.status === "expired")
         expiredCount++;
       const lastAccess = m.accessed_at ? new Date(m.accessed_at).getTime() : new Date(m.created_at).getTime();
-      if (now2 - lastAccess > staleThreshold && m.status === "active") {
+      if (now3 - lastAccess > staleThreshold && m.status === "active") {
         staleCount++;
       }
     }
@@ -9544,9 +10869,9 @@ program2.command("doctor").description("Diagnose common issues with the mementos
     checks.push({ name: "MCP server", status: "warn", detail: "could not check (is claude CLI installed?)" });
   }
   try {
-    const settingsFilePath = join3(homedir2(), ".claude", "settings.json");
-    if (existsSync3(settingsFilePath)) {
-      const settings = JSON.parse(readFileSync2(settingsFilePath, "utf-8"));
+    const settingsFilePath = join6(homedir4(), ".claude", "settings.json");
+    if (existsSync6(settingsFilePath)) {
+      const settings = JSON.parse(readFileSync3(settingsFilePath, "utf-8"));
       const hooksObj = settings["hooks"] || {};
       const stopHooks = hooksObj["Stop"] || [];
       const hasMementos = stopHooks.some((e) => e.hooks?.some((h) => h.command && h.command.includes("mementos")));
@@ -9562,11 +10887,11 @@ program2.command("doctor").description("Diagnose common issues with the mementos
     checks.push({ name: "Stop hook", status: "warn", detail: "could not check stop hook" });
   }
   if (process.platform === "darwin") {
-    const plistFilePath = join3(homedir2(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
+    const plistFilePath = join6(homedir4(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
     checks.push({
       name: "Auto-start",
-      status: existsSync3(plistFilePath) ? "ok" : "warn",
-      detail: existsSync3(plistFilePath) ? "configured (starts on login)" : "not configured  \u2192  run: mementos init"
+      status: existsSync6(plistFilePath) ? "ok" : "warn",
+      detail: existsSync6(plistFilePath) ? "configured (starts on login)" : "not configured  \u2192  run: mementos init"
     });
   } else {
     checks.push({ name: "Auto-start", status: "ok", detail: `n/a on ${process.platform}` });
@@ -9577,24 +10902,24 @@ function outputDoctorResults(globalOpts, checks) {
   if (globalOpts.json) {
     outputJson({ checks, healthy: checks.every((c) => c.status === "ok") });
   } else {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 mementos doctor
 `));
     for (const check of checks) {
-      const icon = check.status === "ok" ? chalk.green("\u2713") : check.status === "warn" ? chalk.yellow("\u26A0") : chalk.red("\u2717");
-      console.log(`  ${icon} ${chalk.bold(check.name)}: ${check.detail}`);
+      const icon = check.status === "ok" ? chalk2.green("\u2713") : check.status === "warn" ? chalk2.yellow("\u26A0") : chalk2.red("\u2717");
+      console.log(`  ${icon} ${chalk2.bold(check.name)}: ${check.detail}`);
     }
     const healthy = checks.every((c) => c.status === "ok");
     const warnings = checks.filter((c) => c.status === "warn").length;
     const failures = checks.filter((c) => c.status === "fail").length;
     console.log("");
     if (healthy) {
-      console.log(chalk.green("  All checks passed."));
+      console.log(chalk2.green("  All checks passed."));
     } else {
       if (failures > 0)
-        console.log(chalk.red(`  ${failures} check(s) failed.`));
+        console.log(chalk2.red(`  ${failures} check(s) failed.`));
       if (warnings > 0)
-        console.log(chalk.yellow(`  ${warnings} warning(s).`));
+        console.log(chalk2.yellow(`  ${warnings} warning(s).`));
     }
     console.log("");
   }
@@ -9608,7 +10933,7 @@ program2.command("show <id>").description("Show full detail of a memory by ID (s
       if (globalOpts.json) {
         outputJson({ error: `Memory not found: ${id}` });
       } else {
-        console.error(chalk.red(`Memory not found: ${id}`));
+        console.error(chalk2.red(`Memory not found: ${id}`));
       }
       process.exit(1);
     }
@@ -9634,24 +10959,24 @@ program2.command("history").description("List memories sorted by most recently a
       return;
     }
     if (memories.length === 0) {
-      console.log(chalk.yellow("No recently accessed memories."));
+      console.log(chalk2.yellow("No recently accessed memories."));
       return;
     }
-    console.log(chalk.bold(`${memories.length} recently accessed memor${memories.length === 1 ? "y" : "ies"}:`));
+    console.log(chalk2.bold(`${memories.length} recently accessed memor${memories.length === 1 ? "y" : "ies"}:`));
     for (const m of memories) {
-      const id = chalk.dim(m.id.slice(0, 8));
+      const id = chalk2.dim(m.id.slice(0, 8));
       const scope = colorScope(m.scope);
       const cat = colorCategory(m.category);
       const value = m.value.length > 60 ? m.value.slice(0, 60) + "..." : m.value;
-      const accessed = m.accessed_at ? chalk.dim(m.accessed_at) : chalk.dim("never");
-      console.log(`${id} [${scope}/${cat}] ${chalk.bold(m.key)} = ${value}  ${accessed}`);
+      const accessed = m.accessed_at ? chalk2.dim(m.accessed_at) : chalk2.dim("never");
+      console.log(`${id} [${scope}/${cat}] ${chalk2.bold(m.key)} = ${value}  ${accessed}`);
     }
   } catch (e) {
     handleError(e);
   }
 });
 program2.command("mcp").description("Install mementos MCP server into Claude Code, Codex, or Gemini").option("--claude", "Install into Claude Code (~/.claude/.mcp.json)").option("--codex", "Install into Codex (~/.codex/config.toml)").option("--gemini", "Install into Gemini (~/.gemini/settings.json)").option("--all", "Install into all supported agents").option("--uninstall", "Remove mementos MCP from config").action((opts) => {
-  const { readFileSync: readFileSync3, writeFileSync: writeFileSync3, existsSync: fileExists } = __require("fs");
+  const { readFileSync: readFileSync4, writeFileSync: writeFileSync5, existsSync: fileExists } = __require("fs");
   const { join: pathJoin } = __require("path");
   const { homedir: getHome } = __require("os");
   const home = getHome();
@@ -9662,8 +10987,8 @@ program2.command("mcp").description("Install mementos MCP server into Claude Cod
     opts.gemini ? "gemini" : null
   ].filter(Boolean);
   if (targets.length === 0) {
-    console.log(chalk.yellow("Specify a target: --claude, --codex, --gemini, or --all"));
-    console.log(chalk.gray("Example: mementos mcp --all"));
+    console.log(chalk2.yellow("Specify a target: --claude, --codex, --gemini, or --all"));
+    console.log(chalk2.gray("Example: mementos mcp --all"));
     return;
   }
   for (const target of targets) {
@@ -9673,25 +10998,25 @@ program2.command("mcp").description("Install mementos MCP server into Claude Cod
         if (opts.uninstall) {
           try {
             execSync(`claude mcp remove mementos`, { stdio: "pipe" });
-            console.log(chalk.green("Removed mementos from Claude Code MCP"));
+            console.log(chalk2.green("Removed mementos from Claude Code MCP"));
           } catch {
-            console.log(chalk.yellow("mementos was not installed in Claude Code (or claude CLI not found)"));
+            console.log(chalk2.yellow("mementos was not installed in Claude Code (or claude CLI not found)"));
           }
         } else {
           try {
             execSync(`claude mcp add --transport stdio --scope user mementos -- ${mementosCmd}`, { stdio: "pipe" });
-            console.log(chalk.green(`Installed mementos into Claude Code (user scope)`));
-            console.log(chalk.gray("  Restart Claude Code for the change to take effect."));
+            console.log(chalk2.green(`Installed mementos into Claude Code (user scope)`));
+            console.log(chalk2.gray("  Restart Claude Code for the change to take effect."));
           } catch (e) {
-            console.log(chalk.yellow("claude CLI not found. Run this manually:"));
-            console.log(chalk.white(`  claude mcp add --transport stdio --scope user mementos -- ${mementosCmd}`));
+            console.log(chalk2.yellow("claude CLI not found. Run this manually:"));
+            console.log(chalk2.white(`  claude mcp add --transport stdio --scope user mementos -- ${mementosCmd}`));
           }
         }
       }
       if (target === "codex") {
         const configPath = pathJoin(home, ".codex", "config.toml");
         if (fileExists(configPath)) {
-          let content = readFileSync3(configPath, "utf-8");
+          let content = readFileSync4(configPath, "utf-8");
           if (opts.uninstall) {
             content = content.replace(/\n\[mcp_servers\.mementos\]\ncommand = "[^"]*"\nargs = \[\]\n?/g, `
 `);
@@ -9702,17 +11027,17 @@ command = "${mementosCmd}"
 args = []
 `;
           }
-          writeFileSync3(configPath, content, "utf-8");
-          console.log(chalk.green(`${opts.uninstall ? "Removed from" : "Installed into"} Codex: ${configPath}`));
+          writeFileSync5(configPath, content, "utf-8");
+          console.log(chalk2.green(`${opts.uninstall ? "Removed from" : "Installed into"} Codex: ${configPath}`));
         } else {
-          console.log(chalk.yellow(`Codex config not found: ${configPath}`));
+          console.log(chalk2.yellow(`Codex config not found: ${configPath}`));
         }
       }
       if (target === "gemini") {
         const configPath = pathJoin(home, ".gemini", "settings.json");
         let config = {};
         if (fileExists(configPath)) {
-          config = JSON.parse(readFileSync3(configPath, "utf-8"));
+          config = JSON.parse(readFileSync4(configPath, "utf-8"));
         }
         const servers = config["mcpServers"] || {};
         if (opts.uninstall) {
@@ -9721,12 +11046,12 @@ args = []
           servers["mementos"] = { command: mementosCmd, args: [] };
         }
         config["mcpServers"] = servers;
-        writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
+        writeFileSync5(configPath, JSON.stringify(config, null, 2) + `
 `, "utf-8");
-        console.log(chalk.green(`${opts.uninstall ? "Removed from" : "Installed into"} Gemini: ${configPath}`));
+        console.log(chalk2.green(`${opts.uninstall ? "Removed from" : "Installed into"} Gemini: ${configPath}`));
       }
     } catch (e) {
-      console.error(chalk.red(`Failed for ${target}: ${e instanceof Error ? e.message : String(e)}`));
+      console.error(chalk2.red(`Failed for ${target}: ${e instanceof Error ? e.message : String(e)}`));
     }
   }
 });
@@ -9742,20 +11067,20 @@ program2.command("watch").description("Watch for new and changed memories in rea
         projectId = project.id;
     }
     const intervalMs = opts.interval || 500;
-    console.log(chalk.bold.cyan("Watching memories...") + chalk.dim(" (Ctrl+C to stop)"));
+    console.log(chalk2.bold.cyan("Watching memories...") + chalk2.dim(" (Ctrl+C to stop)"));
     const filters = [];
     if (opts.scope)
       filters.push(`scope=${colorScope(opts.scope)}`);
     if (opts.category)
       filters.push(`category=${colorCategory(opts.category)}`);
     if (agentId)
-      filters.push(`agent=${chalk.dim(agentId)}`);
+      filters.push(`agent=${chalk2.dim(agentId)}`);
     if (projectId)
-      filters.push(`project=${chalk.dim(projectId)}`);
+      filters.push(`project=${chalk2.dim(projectId)}`);
     if (filters.length > 0) {
-      console.log(chalk.dim("Filters: ") + filters.join(chalk.dim(" | ")));
+      console.log(chalk2.dim("Filters: ") + filters.join(chalk2.dim(" | ")));
     }
-    console.log(chalk.dim(`Poll interval: ${intervalMs}ms`));
+    console.log(chalk2.dim(`Poll interval: ${intervalMs}ms`));
     console.log();
     const filter = {
       scope: opts.scope,
@@ -9766,14 +11091,14 @@ program2.command("watch").description("Watch for new and changed memories in rea
     };
     const recent = listMemories(filter);
     if (recent.length > 0) {
-      console.log(chalk.bold.dim(`Recent (${recent.length}):`));
+      console.log(chalk2.bold.dim(`Recent (${recent.length}):`));
       for (const m of recent.reverse()) {
         console.log(formatWatchLine(m));
       }
     } else {
-      console.log(chalk.dim("No recent memories."));
+      console.log(chalk2.dim("No recent memories."));
     }
-    console.log(chalk.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Live \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk2.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Live \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log();
     const { startPolling: startPolling2 } = (init_poll(), __toCommonJS(exports_poll));
     const handle = startPolling2({
@@ -9789,13 +11114,13 @@ program2.command("watch").description("Watch for new and changed memories in rea
         }
       },
       on_error: (err) => {
-        console.error(chalk.red(`Poll error: ${err.message}`));
+        console.error(chalk2.red(`Poll error: ${err.message}`));
       }
     });
     const cleanup = () => {
       handle.stop();
       console.log();
-      console.log(chalk.dim("Stopped watching."));
+      console.log(chalk2.dim("Stopped watching."));
       process.exit(0);
     };
     process.on("SIGINT", cleanup);
@@ -9812,7 +11137,7 @@ program2.command("pin <keyOrId>").description("Pin a memory by key or partial ID
       if (globalOpts.json) {
         outputJson({ error: `No memory found: ${keyOrId}` });
       } else {
-        console.error(chalk.red(`No memory found: ${keyOrId}`));
+        console.error(chalk2.red(`No memory found: ${keyOrId}`));
       }
       process.exit(1);
     }
@@ -9823,7 +11148,7 @@ program2.command("pin <keyOrId>").description("Pin a memory by key or partial ID
     if (globalOpts.json) {
       outputJson(updated);
     } else {
-      console.log(chalk.green(`Pinned: ${updated.key} (${updated.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Pinned: ${updated.key} (${updated.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -9837,7 +11162,7 @@ program2.command("unpin <keyOrId>").description("Unpin a memory by key or partia
       if (globalOpts.json) {
         outputJson({ error: `No memory found: ${keyOrId}` });
       } else {
-        console.error(chalk.red(`No memory found: ${keyOrId}`));
+        console.error(chalk2.red(`No memory found: ${keyOrId}`));
       }
       process.exit(1);
     }
@@ -9848,7 +11173,7 @@ program2.command("unpin <keyOrId>").description("Unpin a memory by key or partia
     if (globalOpts.json) {
       outputJson(updated);
     } else {
-      console.log(chalk.green(`Unpinned: ${updated.key} (${updated.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Unpinned: ${updated.key} (${updated.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -9859,17 +11184,17 @@ program2.command("archive <keyOrId>").description("Archive a memory by key or ID
     const globalOpts = program2.opts();
     let memory = getMemory(resolvePartialId(getDatabase(), "memories", keyOrId) || keyOrId) || getMemoryByKey(keyOrId, opts.scope, globalOpts.agent);
     if (!memory) {
-      console.error(chalk.red(`No memory found: ${keyOrId}`));
+      console.error(chalk2.red(`No memory found: ${keyOrId}`));
       process.exit(1);
     }
     updateMemory(memory.id, { status: "archived", version: memory.version });
     if (globalOpts.json) {
       outputJson({ archived: true, id: memory.id, key: memory.key });
     } else {
-      console.log(chalk.green(`\u2713 Archived: ${chalk.bold(memory.key)} (${memory.id.slice(0, 8)})`));
+      console.log(chalk2.green(`\u2713 Archived: ${chalk2.bold(memory.key)} (${memory.id.slice(0, 8)})`));
     }
   } catch (e) {
-    console.error(chalk.red(`archive failed: ${e instanceof Error ? e.message : String(e)}`));
+    console.error(chalk2.red(`archive failed: ${e instanceof Error ? e.message : String(e)}`));
     process.exit(1);
   }
 });
@@ -9878,7 +11203,7 @@ program2.command("versions <keyOrId>").description("Show version history for a m
     const globalOpts = program2.opts();
     let memory = getMemory(resolvePartialId(getDatabase(), "memories", keyOrId) || keyOrId) || getMemoryByKey(keyOrId, opts.scope, globalOpts.agent);
     if (!memory) {
-      console.error(chalk.red(`No memory found: ${keyOrId}`));
+      console.error(chalk2.red(`No memory found: ${keyOrId}`));
       process.exit(1);
     }
     const versions = getMemoryVersions(memory.id);
@@ -9886,20 +11211,20 @@ program2.command("versions <keyOrId>").description("Show version history for a m
       outputJson({ memory: { id: memory.id, key: memory.key, current_version: memory.version }, versions });
       return;
     }
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 Version history: ${memory.key} (current: v${memory.version})
 `));
     if (versions.length === 0) {
-      console.log(chalk.dim("  No previous versions."));
+      console.log(chalk2.dim("  No previous versions."));
       return;
     }
     for (const v of versions) {
-      console.log(`  ${chalk.cyan(`v${v.version}`)} ${chalk.dim(v.created_at.slice(0, 16))} scope=${v.scope} imp=${v.importance}`);
+      console.log(`  ${chalk2.cyan(`v${v.version}`)} ${chalk2.dim(v.created_at.slice(0, 16))} scope=${v.scope} imp=${v.importance}`);
       console.log(`    ${v.value.slice(0, 120)}${v.value.length > 120 ? "..." : ""}`);
     }
     console.log("");
   } catch (e) {
-    console.error(chalk.red(`versions failed: ${e instanceof Error ? e.message : String(e)}`));
+    console.error(chalk2.red(`versions failed: ${e instanceof Error ? e.message : String(e)}`));
     process.exit(1);
   }
 });
@@ -9919,20 +11244,20 @@ program2.command("tail").description("Watch for new/updated memories in real-tim
     const notifyEnabled = !!opts.notify;
     const startTime = new Date().toISOString();
     if (!jsonMode) {
-      console.log(chalk.bold.cyan("Watching for memory changes...") + chalk.dim(" (Ctrl+C to stop)"));
+      console.log(chalk2.bold.cyan("Watching for memory changes...") + chalk2.dim(" (Ctrl+C to stop)"));
       const filters = [];
       if (opts.scope)
         filters.push(`scope=${colorScope(opts.scope)}`);
       if (opts.category)
         filters.push(`category=${colorCategory(opts.category)}`);
       if (agentId)
-        filters.push(`agent=${chalk.dim(agentId)}`);
+        filters.push(`agent=${chalk2.dim(agentId)}`);
       if (projectId)
-        filters.push(`project=${chalk.dim(projectId)}`);
+        filters.push(`project=${chalk2.dim(projectId)}`);
       if (filters.length > 0) {
-        console.log(chalk.dim("Filters: ") + filters.join(chalk.dim(" | ")));
+        console.log(chalk2.dim("Filters: ") + filters.join(chalk2.dim(" | ")));
       }
-      console.log(chalk.dim(`Poll interval: ${intervalMs}ms`));
+      console.log(chalk2.dim(`Poll interval: ${intervalMs}ms`));
       console.log();
     }
     const { startPolling: startPolling2 } = (init_poll(), __toCommonJS(exports_poll));
@@ -9948,7 +11273,7 @@ program2.command("tail").description("Watch for new/updated memories in real-tim
           if (jsonMode) {
             console.log(JSON.stringify({ event: isNew ? "new" : "updated", memory: m }));
           } else {
-            const prefix = isNew ? chalk.green.bold("+ ") : chalk.yellow.bold("~ ");
+            const prefix = isNew ? chalk2.green.bold("+ ") : chalk2.yellow.bold("~ ");
             console.log(prefix + formatWatchLine(m));
           }
           if (notifyEnabled)
@@ -9959,7 +11284,7 @@ program2.command("tail").description("Watch for new/updated memories in real-tim
         if (jsonMode) {
           console.error(JSON.stringify({ event: "error", message: err.message }));
         } else {
-          console.error(chalk.red(`Poll error: ${err.message}`));
+          console.error(chalk2.red(`Poll error: ${err.message}`));
         }
       }
     });
@@ -9967,7 +11292,7 @@ program2.command("tail").description("Watch for new/updated memories in real-tim
       handle.stop();
       if (!jsonMode) {
         console.log();
-        console.log(chalk.dim("Stopped watching."));
+        console.log(chalk2.dim("Stopped watching."));
       }
       process.exit(0);
     };
@@ -10059,7 +11384,7 @@ ${lines.join(`
     }
     if (lines.length === 0) {
       if (process.stdout.isTTY) {
-        console.log(chalk.yellow("No relevant memories found."));
+        console.log(chalk2.yellow("No relevant memories found."));
       }
       return;
     }
@@ -10075,18 +11400,18 @@ program2.command("backup [path]").description("Backup the SQLite database to a f
   try {
     const globalOpts = program2.opts();
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-    const backupsDir = join3(home, ".mementos", "backups");
+    const backupsDir = join6(home, ".mementos", "backups");
     if (opts.list) {
-      if (!existsSync3(backupsDir)) {
+      if (!existsSync6(backupsDir)) {
         if (globalOpts.json) {
           outputJson({ backups: [] });
           return;
         }
-        console.log(chalk.yellow("No backups directory found."));
+        console.log(chalk2.yellow("No backups directory found."));
         return;
       }
-      const files = readdirSync2(backupsDir).filter((f) => f.endsWith(".db")).map((f) => {
-        const filePath = join3(backupsDir, f);
+      const files = readdirSync3(backupsDir).filter((f) => f.endsWith(".db")).map((f) => {
+        const filePath = join6(backupsDir, f);
         const st2 = statSync(filePath);
         return { name: f, path: filePath, size: st2.size, mtime: st2.mtime };
       }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
@@ -10095,7 +11420,7 @@ program2.command("backup [path]").description("Backup the SQLite database to a f
           outputJson({ backups: [] });
           return;
         }
-        console.log(chalk.yellow("No backups found."));
+        console.log(chalk2.yellow("No backups found."));
         return;
       }
       if (globalOpts.json) {
@@ -10109,34 +11434,34 @@ program2.command("backup [path]").description("Backup the SQLite database to a f
         });
         return;
       }
-      console.log(chalk.bold(`Backups in ${backupsDir}:`));
+      console.log(chalk2.bold(`Backups in ${backupsDir}:`));
       for (const f of files) {
         const date = f.mtime.toISOString().replace("T", " ").slice(0, 19);
         const sizeMB2 = (f.size / (1024 * 1024)).toFixed(1);
         const sizeStr2 = f.size >= 1024 * 1024 ? `${sizeMB2} MB` : `${(f.size / 1024).toFixed(1)} KB`;
-        console.log(`  ${chalk.dim(date)}  ${chalk.cyan(sizeStr2.padStart(8))}  ${f.name}`);
+        console.log(`  ${chalk2.dim(date)}  ${chalk2.cyan(sizeStr2.padStart(8))}  ${f.name}`);
       }
       return;
     }
     const dbPath = getDbPath();
-    if (!existsSync3(dbPath)) {
-      console.error(chalk.red(`Database not found at ${dbPath}`));
+    if (!existsSync6(dbPath)) {
+      console.error(chalk2.red(`Database not found at ${dbPath}`));
       process.exit(1);
     }
     let dest;
     if (targetPath) {
       dest = resolve3(targetPath);
     } else {
-      if (!existsSync3(backupsDir)) {
-        mkdirSync3(backupsDir, { recursive: true });
+      if (!existsSync6(backupsDir)) {
+        mkdirSync6(backupsDir, { recursive: true });
       }
-      const now2 = new Date;
-      const ts = now2.toISOString().replace(/[-:T]/g, "").replace(/\..+/, "").slice(0, 15);
-      dest = join3(backupsDir, `mementos-${ts}.db`);
+      const now3 = new Date;
+      const ts = now3.toISOString().replace(/[-:T]/g, "").replace(/\..+/, "").slice(0, 15);
+      dest = join6(backupsDir, `mementos-${ts}.db`);
     }
-    const destDir = dirname3(dest);
-    if (!existsSync3(destDir)) {
-      mkdirSync3(destDir, { recursive: true });
+    const destDir = dirname4(dest);
+    if (!existsSync6(destDir)) {
+      mkdirSync6(destDir, { recursive: true });
     }
     copyFileSync(dbPath, dest);
     const st = statSync(dest);
@@ -10146,7 +11471,7 @@ program2.command("backup [path]").description("Backup the SQLite database to a f
       outputJson({ backed_up_to: dest, size: st.size, source: dbPath });
       return;
     }
-    console.log(`Backed up to: ${chalk.green(dest)} (size: ${sizeStr})`);
+    console.log(`Backed up to: ${chalk2.green(dest)} (size: ${sizeStr})`);
   } catch (e) {
     handleError(e);
   }
@@ -10155,31 +11480,31 @@ program2.command("restore [file]").description("Restore the database from a back
   try {
     const globalOpts = program2.opts();
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-    const backupsDir = join3(home, ".mementos", "backups");
+    const backupsDir = join6(home, ".mementos", "backups");
     let source;
     if (opts.latest) {
-      if (!existsSync3(backupsDir)) {
-        console.error(chalk.red("No backups directory found."));
+      if (!existsSync6(backupsDir)) {
+        console.error(chalk2.red("No backups directory found."));
         process.exit(1);
       }
-      const files = readdirSync2(backupsDir).filter((f) => f.endsWith(".db")).map((f) => {
-        const fp = join3(backupsDir, f);
+      const files = readdirSync3(backupsDir).filter((f) => f.endsWith(".db")).map((f) => {
+        const fp = join6(backupsDir, f);
         const st = statSync(fp);
         return { path: fp, mtime: st.mtime };
       }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
       if (files.length === 0) {
-        console.error(chalk.red("No backups found in " + backupsDir));
+        console.error(chalk2.red("No backups found in " + backupsDir));
         process.exit(1);
       }
       source = files[0].path;
     } else if (filePath) {
       source = resolve3(filePath);
     } else {
-      console.error(chalk.red("Provide a backup file path or use --latest"));
+      console.error(chalk2.red("Provide a backup file path or use --latest"));
       process.exit(1);
     }
-    if (!existsSync3(source)) {
-      console.error(chalk.red(`Backup file not found: ${source}`));
+    if (!existsSync6(source)) {
+      console.error(chalk2.red(`Backup file not found: ${source}`));
       process.exit(1);
     }
     const dbPath = getDbPath();
@@ -10187,7 +11512,7 @@ program2.command("restore [file]").description("Restore the database from a back
     const backupSizeMB = (backupStat.size / (1024 * 1024)).toFixed(1);
     const backupSizeStr = backupStat.size >= 1024 * 1024 ? `${backupSizeMB} MB` : `${(backupStat.size / 1024).toFixed(1)} KB`;
     let currentCount = 0;
-    if (existsSync3(dbPath)) {
+    if (existsSync6(dbPath)) {
       try {
         const db = getDatabase();
         const row = db.query("SELECT COUNT(*) as count FROM memories").get();
@@ -10196,8 +11521,8 @@ program2.command("restore [file]").description("Restore the database from a back
     }
     let backupCount = 0;
     try {
-      const { Database: Database2 } = __require("bun:sqlite");
-      const backupDb = new Database2(source, { readonly: true });
+      const { Database: Database3 } = __require("bun:sqlite");
+      const backupDb = new Database3(source, { readonly: true });
       const row = backupDb.query("SELECT COUNT(*) as count FROM memories").get();
       backupCount = row?.count ?? 0;
       backupDb.close();
@@ -10216,13 +11541,13 @@ program2.command("restore [file]").description("Restore the database from a back
         });
         return;
       }
-      console.log(chalk.bold("Restore preview:"));
-      console.log(`  Source:           ${chalk.cyan(source)} (${backupSizeStr})`);
-      console.log(`  Target:           ${chalk.cyan(dbPath)}`);
-      console.log(`  Current memories: ${chalk.yellow(String(currentCount))}`);
-      console.log(`  Backup memories:  ${chalk.green(String(backupCount))}`);
+      console.log(chalk2.bold("Restore preview:"));
+      console.log(`  Source:           ${chalk2.cyan(source)} (${backupSizeStr})`);
+      console.log(`  Target:           ${chalk2.cyan(dbPath)}`);
+      console.log(`  Current memories: ${chalk2.yellow(String(currentCount))}`);
+      console.log(`  Backup memories:  ${chalk2.green(String(backupCount))}`);
       console.log();
-      console.log(chalk.yellow("Use --force to confirm restore"));
+      console.log(chalk2.yellow("Use --force to confirm restore"));
       return;
     }
     copyFileSync(source, dbPath);
@@ -10245,9 +11570,9 @@ program2.command("restore [file]").description("Restore the database from a back
       });
       return;
     }
-    console.log(`Restored from: ${chalk.green(source)}`);
-    console.log(`  Previous memories: ${chalk.yellow(String(currentCount))}`);
-    console.log(`  Restored memories: ${chalk.green(String(newCount))}`);
+    console.log(`Restored from: ${chalk2.green(source)}`);
+    console.log(`  Previous memories: ${chalk2.yellow(String(currentCount))}`);
+    console.log(`  Restored memories: ${chalk2.green(String(newCount))}`);
   } catch (e) {
     handleError(e);
   }
@@ -10260,7 +11585,7 @@ program2.command("diff <id>").description("Show diff between memory versions").o
     if (!memoryId) {
       const mem = resolveKeyOrId(idArg, {}, globalOpts);
       if (!mem) {
-        console.error(chalk.red(`Memory not found: ${idArg}`));
+        console.error(chalk2.red(`Memory not found: ${idArg}`));
         process.exit(1);
       }
       memoryId = mem.id;
@@ -10273,7 +11598,7 @@ program2.command("diff <id>").description("Show diff between memory versions").o
 function diffMemory(memoryId, opts, globalOpts) {
   const current = getMemory(memoryId);
   if (!current) {
-    console.error(chalk.red(`Memory not found: ${memoryId}`));
+    console.error(chalk2.red(`Memory not found: ${memoryId}`));
     process.exit(1);
   }
   const versions = getMemoryVersions(memoryId);
@@ -10281,8 +11606,8 @@ function diffMemory(memoryId, opts, globalOpts) {
     if (globalOpts.json) {
       outputJson({ error: "No version history available", memory_id: memoryId });
     } else {
-      console.log(chalk.yellow("No version history available."));
-      console.log(chalk.dim(`Memory "${current.key}" is at version ${current.version} but has no prior snapshots.`));
+      console.log(chalk2.yellow("No version history available."));
+      console.log(chalk2.dim(`Memory "${current.key}" is at version ${current.version} but has no prior snapshots.`));
     }
     return;
   }
@@ -10293,13 +11618,13 @@ function diffMemory(memoryId, opts, globalOpts) {
   if (opts.version) {
     const targetVersion = parseInt(opts.version, 10);
     if (isNaN(targetVersion) || targetVersion < 1) {
-      console.error(chalk.red("Version must be a positive integer."));
+      console.error(chalk2.red("Version must be a positive integer."));
       process.exit(1);
     }
     if (targetVersion === current.version) {
       const prev = versions.find((v) => v.version === targetVersion - 1);
       if (!prev) {
-        console.error(chalk.red(`No version ${targetVersion - 1} found to compare against.`));
+        console.error(chalk2.red(`No version ${targetVersion - 1} found to compare against.`));
         process.exit(1);
       }
       older = prev;
@@ -10315,10 +11640,10 @@ function diffMemory(memoryId, opts, globalOpts) {
         olderVersion = prevSnap.version;
         newerVersion = targetSnap.version;
       } else if (targetSnap && !prevSnap) {
-        console.error(chalk.red(`No version ${targetVersion - 1} found to compare against.`));
+        console.error(chalk2.red(`No version ${targetVersion - 1} found to compare against.`));
         process.exit(1);
       } else {
-        console.error(chalk.red(`Version ${targetVersion} not found.`));
+        console.error(chalk2.red(`Version ${targetVersion} not found.`));
         process.exit(1);
       }
     }
@@ -10357,8 +11682,8 @@ function diffMemory(memoryId, opts, globalOpts) {
     });
     return;
   }
-  console.log(chalk.bold(`Diff for "${current.key}" (${memoryId.slice(0, 8)})`));
-  console.log(chalk.dim(`Version ${olderVersion} \u2192 ${newerVersion}`));
+  console.log(chalk2.bold(`Diff for "${current.key}" (${memoryId.slice(0, 8)})`));
+  console.log(chalk2.dim(`Version ${olderVersion} \u2192 ${newerVersion}`));
   console.log();
   let hasChanges = false;
   const n = newer;
@@ -10366,7 +11691,7 @@ function diffMemory(memoryId, opts, globalOpts) {
   const newValue = n.value;
   if (oldValue !== newValue) {
     hasChanges = true;
-    console.log(chalk.bold("  value:"));
+    console.log(chalk2.bold("  value:"));
     diffLines(oldValue, newValue);
   }
   const scalarFields = [
@@ -10380,7 +11705,7 @@ function diffMemory(memoryId, opts, globalOpts) {
   for (const field of scalarFields) {
     if (String(field.oldVal) !== String(field.newVal)) {
       hasChanges = true;
-      console.log(`  ${chalk.bold(field.name + ":")} ${chalk.red(String(field.oldVal))} \u2192 ${chalk.green(String(field.newVal))}`);
+      console.log(`  ${chalk2.bold(field.name + ":")} ${chalk2.red(String(field.oldVal))} \u2192 ${chalk2.green(String(field.newVal))}`);
     }
   }
   const oldTags = older.tags;
@@ -10389,14 +11714,14 @@ function diffMemory(memoryId, opts, globalOpts) {
     hasChanges = true;
     const removed = oldTags.filter((t) => !newTags.includes(t));
     const added = newTags.filter((t) => !oldTags.includes(t));
-    console.log(`  ${chalk.bold("tags:")}`);
+    console.log(`  ${chalk2.bold("tags:")}`);
     for (const t of removed)
-      console.log(chalk.red(`    - ${t}`));
+      console.log(chalk2.red(`    - ${t}`));
     for (const t of added)
-      console.log(chalk.green(`    + ${t}`));
+      console.log(chalk2.green(`    + ${t}`));
   }
   if (!hasChanges) {
-    console.log(chalk.dim("  No changes between these versions."));
+    console.log(chalk2.dim("  No changes between these versions."));
   }
 }
 function diffLines(oldText, newText) {
@@ -10405,22 +11730,22 @@ function diffLines(oldText, newText) {
   const newLines = newText.split(`
 `);
   if (oldLines.length === 1 && newLines.length === 1) {
-    console.log(chalk.red(`    - ${oldLines[0]}`));
-    console.log(chalk.green(`    + ${newLines[0]}`));
+    console.log(chalk2.red(`    - ${oldLines[0]}`));
+    console.log(chalk2.green(`    + ${newLines[0]}`));
     return;
   }
   const oldSet = new Set(oldLines);
   const newSet = new Set(newLines);
   for (const line of oldLines) {
     if (!newSet.has(line)) {
-      console.log(chalk.red(`    - ${line}`));
+      console.log(chalk2.red(`    - ${line}`));
     } else {
-      console.log(chalk.dim(`      ${line}`));
+      console.log(chalk2.dim(`      ${line}`));
     }
   }
   for (const line of newLines) {
     if (!oldSet.has(line)) {
-      console.log(chalk.green(`    + ${line}`));
+      console.log(chalk2.green(`    + ${line}`));
     }
   }
 }
@@ -10576,24 +11901,24 @@ function validateConfigKeyValue(key, value) {
   return null;
 }
 function getConfigPath() {
-  return join3(homedir2(), ".mementos", "config.json");
+  return join6(homedir4(), ".mementos", "config.json");
 }
 function readFileConfig() {
   const configPath = getConfigPath();
-  if (!existsSync3(configPath))
+  if (!existsSync6(configPath))
     return {};
   try {
-    return JSON.parse(readFileSync2(configPath, "utf-8"));
+    return JSON.parse(readFileSync3(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeFileConfig(data) {
   const configPath = getConfigPath();
-  const dir = dirname3(configPath);
-  if (!existsSync3(dir))
-    mkdirSync3(dir, { recursive: true });
-  writeFileSync2(configPath, JSON.stringify(data, null, 2) + `
+  const dir = dirname4(configPath);
+  if (!existsSync6(dir))
+    mkdirSync6(dir, { recursive: true });
+  writeFileSync4(configPath, JSON.stringify(data, null, 2) + `
 `, "utf-8");
 }
 program2.command("config [subcommand] [args...]").description("View or modify configuration. Subcommands: get <key>, set <key> <value>, reset [key], path").action((subcommand, args) => {
@@ -10621,13 +11946,13 @@ program2.command("config [subcommand] [args...]").description("View or modify co
     if (subcommand === "get") {
       const key = args[0];
       if (!key) {
-        console.error(chalk.red("Usage: mementos config get <key>"));
+        console.error(chalk2.red("Usage: mementos config get <key>"));
         process.exit(1);
       }
       const config = loadConfig();
       const value = getNestedValue(config, key);
       if (value === undefined) {
-        console.error(chalk.red(`Unknown config key: ${key}`));
+        console.error(chalk2.red(`Unknown config key: ${key}`));
         process.exit(1);
       }
       if (useJson) {
@@ -10643,13 +11968,13 @@ program2.command("config [subcommand] [args...]").description("View or modify co
       const key = args[0];
       const rawValue = args[1];
       if (!key || rawValue === undefined) {
-        console.error(chalk.red("Usage: mementos config set <key> <value>"));
+        console.error(chalk2.red("Usage: mementos config set <key> <value>"));
         process.exit(1);
       }
       const value = parseConfigValue(rawValue);
       const err = validateConfigKeyValue(key, value);
       if (err) {
-        console.error(chalk.red(err));
+        console.error(chalk2.red(err));
         process.exit(1);
       }
       const fileConfig = readFileConfig();
@@ -10658,7 +11983,7 @@ program2.command("config [subcommand] [args...]").description("View or modify co
       if (useJson) {
         outputJson({ key, value, saved: true });
       } else {
-        console.log(chalk.green(`Set ${key} = ${JSON.stringify(value)}`));
+        console.log(chalk2.green(`Set ${key} = ${JSON.stringify(value)}`));
       }
       return;
     }
@@ -10667,7 +11992,7 @@ program2.command("config [subcommand] [args...]").description("View or modify co
       if (key) {
         const defaultVal = getNestedValue(DEFAULT_CONFIG, key);
         if (defaultVal === undefined) {
-          console.error(chalk.red(`Unknown config key: ${key}`));
+          console.error(chalk2.red(`Unknown config key: ${key}`));
           process.exit(1);
         }
         const fileConfig = readFileConfig();
@@ -10676,22 +12001,22 @@ program2.command("config [subcommand] [args...]").description("View or modify co
         if (useJson) {
           outputJson({ key, reset: true, default_value: defaultVal });
         } else {
-          console.log(chalk.green(`Reset ${key} to default (${JSON.stringify(defaultVal)})`));
+          console.log(chalk2.green(`Reset ${key} to default (${JSON.stringify(defaultVal)})`));
         }
       } else {
         const configPath = getConfigPath();
-        if (existsSync3(configPath)) {
+        if (existsSync6(configPath)) {
           unlinkSync2(configPath);
         }
         if (useJson) {
           outputJson({ reset: true, all: true });
         } else {
-          console.log(chalk.green("Config reset to defaults (file removed)"));
+          console.log(chalk2.green("Config reset to defaults (file removed)"));
         }
       }
       return;
     }
-    console.error(chalk.red(`Unknown config subcommand: ${subcommand}`));
+    console.error(chalk2.red(`Unknown config subcommand: ${subcommand}`));
     console.error("Usage: mementos config [get|set|reset|path]");
     process.exit(1);
   } catch (e) {
@@ -10718,7 +12043,7 @@ entityCmd.command("create <name>").description("Create a knowledge graph entity"
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson(entity);
     } else {
-      console.log(chalk.green(`Entity: ${entity.name} (${entity.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Entity: ${entity.name} (${entity.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -10734,28 +12059,28 @@ entityCmd.command("show <nameOrId>").description("Show entity details with relat
       outputJson({ ...entity, related, memories });
       return;
     }
-    console.log(`${chalk.bold("ID:")}          ${entity.id}`);
-    console.log(`${chalk.bold("Name:")}        ${entity.name}`);
-    console.log(`${chalk.bold("Type:")}        ${colorEntityType(entity.type)}`);
+    console.log(`${chalk2.bold("ID:")}          ${entity.id}`);
+    console.log(`${chalk2.bold("Name:")}        ${entity.name}`);
+    console.log(`${chalk2.bold("Type:")}        ${colorEntityType(entity.type)}`);
     if (entity.description)
-      console.log(`${chalk.bold("Description:")} ${entity.description}`);
+      console.log(`${chalk2.bold("Description:")} ${entity.description}`);
     if (entity.project_id)
-      console.log(`${chalk.bold("Project:")}     ${entity.project_id}`);
-    console.log(`${chalk.bold("Created:")}     ${entity.created_at}`);
-    console.log(`${chalk.bold("Updated:")}     ${entity.updated_at}`);
+      console.log(`${chalk2.bold("Project:")}     ${entity.project_id}`);
+    console.log(`${chalk2.bold("Created:")}     ${entity.created_at}`);
+    console.log(`${chalk2.bold("Updated:")}     ${entity.updated_at}`);
     if (related.length > 0) {
       console.log(`
-${chalk.bold("Related entities:")}`);
+${chalk2.bold("Related entities:")}`);
       for (const r of related) {
-        console.log(`  ${chalk.dim(r.id.slice(0, 8))} [${colorEntityType(r.type)}] ${r.name}${r.description ? chalk.dim(` \u2014 ${r.description}`) : ""}`);
+        console.log(`  ${chalk2.dim(r.id.slice(0, 8))} [${colorEntityType(r.type)}] ${r.name}${r.description ? chalk2.dim(` \u2014 ${r.description}`) : ""}`);
       }
     }
     if (memories.length > 0) {
       console.log(`
-${chalk.bold("Linked memories:")}`);
+${chalk2.bold("Linked memories:")}`);
       for (const m of memories) {
         const value = m.value.length > 60 ? m.value.slice(0, 60) + "..." : m.value;
-        console.log(`  ${chalk.dim(m.id.slice(0, 8))} ${chalk.bold(m.key)} = ${value}`);
+        console.log(`  ${chalk2.dim(m.id.slice(0, 8))} ${chalk2.bold(m.key)} = ${value}`);
       }
     }
   } catch (e) {
@@ -10796,13 +12121,13 @@ entityCmd.command("list").description("List entities with optional filters").opt
       return;
     }
     if (entities.length === 0) {
-      console.log(chalk.yellow("No entities found."));
+      console.log(chalk2.yellow("No entities found."));
       return;
     }
-    console.log(chalk.bold(`${entities.length} entit${entities.length === 1 ? "y" : "ies"}:`));
+    console.log(chalk2.bold(`${entities.length} entit${entities.length === 1 ? "y" : "ies"}:`));
     for (const e of entities) {
-      const id = chalk.dim(e.id.slice(0, 8));
-      const desc = e.description ? chalk.dim(` (${e.description})`) : "";
+      const id = chalk2.dim(e.id.slice(0, 8));
+      const desc = e.description ? chalk2.dim(` (${e.description})`) : "";
       console.log(`${id}  ${colorEntityType(e.type)}  ${e.name}${desc}`);
     }
   } catch (e) {
@@ -10817,7 +12142,7 @@ entityCmd.command("delete <nameOrId>").description("Delete an entity and cascade
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson({ deleted: entity.id, name: entity.name });
     } else {
-      console.log(chalk.green(`Deleted entity: ${entity.name} (${entity.id.slice(0, 8)}) \u2014 relations and memory links cascaded`));
+      console.log(chalk2.green(`Deleted entity: ${entity.name} (${entity.id.slice(0, 8)}) \u2014 relations and memory links cascaded`));
     }
   } catch (e) {
     handleError(e);
@@ -10832,7 +12157,7 @@ entityCmd.command("merge <source> <target>").description("Merge source entity in
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson(merged);
     } else {
-      console.log(chalk.green(`Merged: ${srcEntity.name} \u2192 ${merged.name} (${merged.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Merged: ${srcEntity.name} \u2192 ${merged.name} (${merged.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -10844,14 +12169,14 @@ entityCmd.command("link <entity> <memoryKeyOrId>").description("Link an entity t
     const entity = resolveEntityArg(entityArg, opts.type);
     const memory = resolveKeyOrId(memoryKeyOrId, {}, globalOpts);
     if (!memory) {
-      console.error(chalk.red(`Memory not found: ${memoryKeyOrId}`));
+      console.error(chalk2.red(`Memory not found: ${memoryKeyOrId}`));
       process.exit(1);
     }
     const link = linkEntityToMemory(entity.id, memory.id, opts.role);
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson(link);
     } else {
-      console.log(chalk.green(`Linked: ${entity.name} \u2194 ${memory.key} (role: ${link.role})`));
+      console.log(chalk2.green(`Linked: ${entity.name} \u2194 ${memory.key} (role: ${link.role})`));
     }
   } catch (e) {
     handleError(e);
@@ -10872,7 +12197,7 @@ relationCmd.command("create <source> <target>").description("Create a relation b
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson(relation);
     } else {
-      console.log(chalk.green(`Relation: ${srcEntity.name} \u2014[${relation.relation_type}]\u2192 ${tgtEntity.name} (${relation.id.slice(0, 8)})`));
+      console.log(chalk2.green(`Relation: ${srcEntity.name} \u2014[${relation.relation_type}]\u2192 ${tgtEntity.name} (${relation.id.slice(0, 8)})`));
     }
   } catch (e) {
     handleError(e);
@@ -10903,7 +12228,7 @@ relationCmd.command("list <entityNameOrId>").description("List relations for an
       return;
     }
     if (relations.length === 0) {
-      console.log(chalk.yellow(`No relations found for: ${entity.name}`));
+      console.log(chalk2.yellow(`No relations found for: ${entity.name}`));
       return;
     }
     const entityCache = new Map;
@@ -10919,13 +12244,13 @@ relationCmd.command("list <entityNameOrId>").description("List relations for an
         return id.slice(0, 8);
       }
     };
-    console.log(chalk.bold(`${relations.length} relation${relations.length === 1 ? "" : "s"} for ${entity.name}:`));
+    console.log(chalk2.bold(`${relations.length} relation${relations.length === 1 ? "" : "s"} for ${entity.name}:`));
     for (const r of relations) {
       const src = resolveName(r.source_entity_id);
       const tgt = resolveName(r.target_entity_id);
-      const id = chalk.dim(r.id.slice(0, 8));
-      const weight = r.weight !== 1 ? chalk.dim(` w:${r.weight}`) : "";
-      console.log(`${id}  ${src} \u2014[${chalk.cyan(r.relation_type)}]\u2192 ${tgt}${weight}`);
+      const id = chalk2.dim(r.id.slice(0, 8));
+      const weight = r.weight !== 1 ? chalk2.dim(` w:${r.weight}`) : "";
+      console.log(`${id}  ${src} \u2014[${chalk2.cyan(r.relation_type)}]\u2192 ${tgt}${weight}`);
     }
   } catch (e) {
     handleError(e);
@@ -10937,14 +12262,14 @@ relationCmd.command("delete <id>").description("Delete a relation by ID").action
     const db = getDatabase();
     const resolvedId = resolvePartialId(db, "relations", id);
     if (!resolvedId) {
-      console.error(chalk.red(`Relation not found: ${id}`));
+      console.error(chalk2.red(`Relation not found: ${id}`));
       process.exit(1);
     }
     deleteRelation(resolvedId);
     if (globalOpts.json || globalOpts.format === "json") {
       outputJson({ deleted: resolvedId });
     } else {
-      console.log(chalk.green(`Deleted relation: ${resolvedId.slice(0, 8)}`));
+      console.log(chalk2.green(`Deleted relation: ${resolvedId.slice(0, 8)}`));
     }
   } catch (e) {
     handleError(e);
@@ -10962,7 +12287,7 @@ graphCmd.command("show <entityNameOrId>").description("Show connected entities a
       return;
     }
     if (graph.entities.length === 0) {
-      console.log(chalk.yellow(`No graph data for: ${entity.name}`));
+      console.log(chalk2.yellow(`No graph data for: ${entity.name}`));
       return;
     }
     const adj = new Map;
@@ -10994,7 +12319,7 @@ graphCmd.command("show <entityNameOrId>").description("Show connected entities a
       for (let i = 0;i < children.length; i++) {
         const child = children[i];
         const childIndent = indent + (indent === "" ? "" : isLast ? "    " : "\u2502   ");
-        const relLabel = chalk.dim(` (${child.relation})`);
+        const relLabel = chalk2.dim(` (${child.relation})`);
         const childPrefix = i === children.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
         visited.add(child.entity.id);
         console.log(`${childIndent}${childPrefix}[${colorEntityType(child.entity.type)}] ${child.entity.name}${relLabel}`);
@@ -11003,7 +12328,7 @@ graphCmd.command("show <entityNameOrId>").description("Show connected entities a
           const gc = grandChildren[j];
           const gcIndent = childIndent + (i === children.length - 1 ? "    " : "\u2502   ");
           const gcPrefix = j === grandChildren.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-          const gcRelLabel = chalk.dim(` (${gc.relation})`);
+          const gcRelLabel = chalk2.dim(` (${gc.relation})`);
           visited.add(gc.entity.id);
           console.log(`${gcIndent}${gcPrefix}[${colorEntityType(gc.entity.type)}] ${gc.entity.name}${gcRelLabel}`);
         }
@@ -11025,10 +12350,10 @@ graphCmd.command("path <from> <to>").description("Show shortest path between two
       return;
     }
     if (!path) {
-      console.log(chalk.yellow(`No path found between ${fromEntity.name} and ${toEntity.name}`));
+      console.log(chalk2.yellow(`No path found between ${fromEntity.name} and ${toEntity.name}`));
       return;
     }
-    console.log(chalk.bold(`Path (${path.length} hop${path.length === 1 ? "" : "s"}):`));
+    console.log(chalk2.bold(`Path (${path.length} hop${path.length === 1 ? "" : "s"}):`));
     for (let i = 0;i < path.length; i++) {
       const e = path[i];
       const arrow = i < path.length - 1 ? " \u2192" : "";
@@ -11055,19 +12380,19 @@ graphCmd.command("stats").description("Show knowledge graph statistics").action(
       });
       return;
     }
-    console.log(chalk.bold("Knowledge Graph Stats"));
+    console.log(chalk2.bold("Knowledge Graph Stats"));
     console.log();
-    console.log(chalk.bold(`Entities: ${totalEntities}`));
+    console.log(chalk2.bold(`Entities: ${totalEntities}`));
     for (const r of entityRows) {
       console.log(`  ${colorEntityType(r.type)}: ${r.count}`);
     }
     console.log();
-    console.log(chalk.bold(`Relations: ${totalRelations}`));
+    console.log(chalk2.bold(`Relations: ${totalRelations}`));
     for (const r of relationRows) {
-      console.log(`  ${chalk.cyan(r.relation_type)}: ${r.count}`);
+      console.log(`  ${chalk2.cyan(r.relation_type)}: ${r.count}`);
     }
     console.log();
-    console.log(chalk.bold(`Memory links: ${linkCount.count}`));
+    console.log(chalk2.bold(`Memory links: ${linkCount.count}`));
   } catch (e) {
     handleError(e);
   }
@@ -11077,14 +12402,14 @@ function formatWatchLine(m) {
   const cat = colorCategory(m.category);
   const imp = colorImportance(m.importance);
   const value = m.value.length > 100 ? m.value.slice(0, 100) + "..." : m.value;
-  const main = `  [${scope}/${cat}] ${chalk.bold(m.key)} = ${value} ${chalk.dim(`(importance: ${imp})`)}`;
+  const main = `  [${scope}/${cat}] ${chalk2.bold(m.key)} = ${value} ${chalk2.dim(`(importance: ${imp})`)}`;
   const parts = [];
   if (m.tags.length > 0)
     parts.push(`Tags: ${m.tags.join(", ")}`);
   if (m.agent_id)
     parts.push(`Agent: ${m.agent_id}`);
   parts.push(`Updated: ${m.updated_at}`);
-  const detail = chalk.dim(`    ${parts.join("  |  ")}`);
+  const detail = chalk2.dim(`    ${parts.join("  |  ")}`);
   return `${main}
 ${detail}`;
 }
@@ -11104,73 +12429,73 @@ profileCmd.command("list").description("List all available profiles").action(()
   const profiles = listProfiles();
   const active = getActiveProfile();
   if (profiles.length === 0) {
-    console.log(chalk.dim("No profiles yet. Create one with: mementos profile set <name>"));
+    console.log(chalk2.dim("No profiles yet. Create one with: mementos profile set <name>"));
     return;
   }
-  console.log(chalk.bold("Profiles:"));
+  console.log(chalk2.bold("Profiles:"));
   for (const p of profiles) {
-    const marker = p === active ? chalk.green(" \u2713 (active)") : "";
+    const marker = p === active ? chalk2.green(" \u2713 (active)") : "";
     console.log(`  ${p}${marker}`);
   }
   if (!active) {
-    console.log(chalk.dim(`
+    console.log(chalk2.dim(`
   (no active profile \u2014 using default DB)`));
   }
 });
 profileCmd.command("get").description("Show the currently active profile").action(() => {
   const active = getActiveProfile();
   if (active) {
-    console.log(chalk.green(`Active profile: ${active}`));
+    console.log(chalk2.green(`Active profile: ${active}`));
     if (!process.env["MEMENTOS_PROFILE"]) {
-      console.log(chalk.dim("(persisted in ~/.mementos/config.json)"));
+      console.log(chalk2.dim("(persisted in ~/.mementos/config.json)"));
     } else {
-      console.log(chalk.dim("(from MEMENTOS_PROFILE env var)"));
+      console.log(chalk2.dim("(from MEMENTOS_PROFILE env var)"));
     }
   } else {
-    console.log(chalk.dim("No active profile \u2014 using default DB (~/.mementos/mementos.db)"));
+    console.log(chalk2.dim("No active profile \u2014 using default DB (~/.mementos/mementos.db)"));
   }
 });
 profileCmd.command("set <name>").description("Switch to a named profile (creates the DB on first use)").action((name) => {
   const clean = name.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
   if (!clean) {
-    console.error(chalk.red("Invalid profile name. Use letters, numbers, hyphens, underscores."));
+    console.error(chalk2.red("Invalid profile name. Use letters, numbers, hyphens, underscores."));
     process.exit(1);
   }
   setActiveProfile(clean);
-  console.log(chalk.green(`\u2713 Switched to profile: ${clean}`));
-  console.log(chalk.dim(`  DB: ~/.mementos/profiles/${clean}.db (created on first use)`));
+  console.log(chalk2.green(`\u2713 Switched to profile: ${clean}`));
+  console.log(chalk2.dim(`  DB: ~/.mementos/profiles/${clean}.db (created on first use)`));
 });
 profileCmd.command("unset").description("Clear the active profile (revert to default DB)").action(() => {
   const was = getActiveProfile();
   setActiveProfile(null);
   if (was) {
-    console.log(chalk.green(`\u2713 Cleared profile (was: ${was})`));
+    console.log(chalk2.green(`\u2713 Cleared profile (was: ${was})`));
   } else {
-    console.log(chalk.dim("No active profile was set."));
+    console.log(chalk2.dim("No active profile was set."));
   }
-  console.log(chalk.dim("  Now using default DB: ~/.mementos/mementos.db"));
+  console.log(chalk2.dim("  Now using default DB: ~/.mementos/mementos.db"));
 });
 profileCmd.command("delete <name>").description("Delete a profile and its DB file (irreversible)").option("-y, --yes", "Skip confirmation prompt").action(async (name, opts) => {
   if (!opts.yes) {
     const profiles = listProfiles();
     if (!profiles.includes(name)) {
-      console.error(chalk.red(`Profile not found: ${name}`));
+      console.error(chalk2.red(`Profile not found: ${name}`));
       process.exit(1);
     }
-    process.stdout.write(chalk.yellow(`Delete profile "${name}" and its DB? This cannot be undone. [y/N] `));
+    process.stdout.write(chalk2.yellow(`Delete profile "${name}" and its DB? This cannot be undone. [y/N] `));
     const answer = await new Promise((resolve4) => {
       process.stdin.once("data", (d) => resolve4(d.toString().trim().toLowerCase()));
     });
     if (answer !== "y" && answer !== "yes") {
-      console.log(chalk.dim("Cancelled."));
+      console.log(chalk2.dim("Cancelled."));
       return;
     }
   }
   const deleted = deleteProfile(name);
   if (deleted) {
-    console.log(chalk.green(`\u2713 Profile "${name}" deleted.`));
+    console.log(chalk2.green(`\u2713 Profile "${name}" deleted.`));
   } else {
-    console.error(chalk.red(`Profile not found: ${name}`));
+    console.error(chalk2.red(`Profile not found: ${name}`));
     process.exit(1);
   }
 });
@@ -11181,23 +12506,23 @@ autoMemory.command("process <turn>").description("Enqueue text for async LLM mem
   if (opts.sync) {
     const provider = providerRegistry2.getAvailable();
     if (!provider) {
-      console.error(chalk.red("No LLM provider configured. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, CEREBRAS_API_KEY, or XAI_API_KEY."));
+      console.error(chalk2.red("No LLM provider configured. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, CEREBRAS_API_KEY, or XAI_API_KEY."));
       process.exit(1);
     }
-    console.log(chalk.dim(`Using ${provider.name} / ${provider.config.model}...`));
+    console.log(chalk2.dim(`Using ${provider.name} / ${provider.config.model}...`));
     const memories = await provider.extractMemories(turn, {
       agentId: opts.agent,
       projectId: opts.project
     });
     if (memories.length === 0) {
-      console.log(chalk.dim("Nothing worth remembering extracted."));
+      console.log(chalk2.dim("Nothing worth remembering extracted."));
     } else {
       memories.forEach((m, i) => {
-        console.log(chalk.bold(`
+        console.log(chalk2.bold(`
 [${i + 1}] ${m.category} \xB7 importance ${m.importance}/10 \xB7 ${m.suggestedScope}`));
         console.log(`  ${m.content}`);
         if (m.tags.length)
-          console.log(chalk.dim(`  tags: ${m.tags.join(", ")}`));
+          console.log(chalk2.dim(`  tags: ${m.tags.join(", ")}`));
       });
     }
   } else {
@@ -11207,8 +12532,8 @@ autoMemory.command("process <turn>").description("Enqueue text for async LLM mem
       sessionId: opts.session
     });
     const stats = getAutoMemoryStats2();
-    console.log(chalk.green("\u2713 Queued for extraction"));
-    console.log(chalk.dim(`Queue: ${stats.pending} pending \xB7 ${stats.processed} processed \xB7 ${stats.failed} failed`));
+    console.log(chalk2.green("\u2713 Queued for extraction"));
+    console.log(chalk2.dim(`Queue: ${stats.pending} pending \xB7 ${stats.processed} processed \xB7 ${stats.failed} failed`));
   }
 });
 autoMemory.command("status").description("Show auto-memory queue stats and provider health").action(async () => {
@@ -11217,14 +12542,14 @@ autoMemory.command("status").description("Show auto-memory queue stats and provi
   const stats = getAutoMemoryStats2();
   const config = providerRegistry2.getConfig();
   const health = providerRegistry2.health();
-  console.log(chalk.bold("Auto-Memory Status"));
-  console.log(`  Provider:    ${config.enabled ? chalk.green(config.provider) : chalk.red("disabled")} / ${config.model ?? "default"}`);
+  console.log(chalk2.bold("Auto-Memory Status"));
+  console.log(`  Provider:    ${config.enabled ? chalk2.green(config.provider) : chalk2.red("disabled")} / ${config.model ?? "default"}`);
   console.log(`  Queue:       ${stats.pending} pending \xB7 ${stats.processing} processing \xB7 ${stats.processed} processed`);
   console.log(`  Errors:      ${stats.failed} failed \xB7 ${stats.dropped} dropped`);
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 Provider Health`));
   for (const [name, info] of Object.entries(health)) {
-    const icon = info.available ? chalk.green("\u2713") : chalk.red("\u2717");
+    const icon = info.available ? chalk2.green("\u2713") : chalk2.red("\u2717");
     console.log(`  ${icon} ${name.padEnd(12)} ${info.model}`);
   }
 });
@@ -11237,35 +12562,35 @@ autoMemory.command("config").description("Show or update auto-memory provider co
       ...opts.model && { model: opts.model },
       ...opts.minImportance && { minImportance: Number(opts.minImportance) }
     });
-    console.log(chalk.green("\u2713 Config updated"));
+    console.log(chalk2.green("\u2713 Config updated"));
   }
   const config = providerRegistry2.getConfig();
-  console.log(chalk.bold("Auto-Memory Config"));
+  console.log(chalk2.bold("Auto-Memory Config"));
   console.log(JSON.stringify(config, null, 2));
 });
 autoMemory.command("test <turn>").description("Test extraction without saving (dry run)").option("--provider <name>", "force a specific provider").option("--agent <id>", "agent ID for context").option("--project <id>", "project ID for context").action(async (turn, opts) => {
   const { providerRegistry: providerRegistry2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
   const provider = opts.provider ? providerRegistry2.getProvider(opts.provider) : providerRegistry2.getAvailable();
   if (!provider) {
-    console.error(chalk.red("No LLM provider configured."));
+    console.error(chalk2.red("No LLM provider configured."));
     process.exit(1);
   }
-  console.log(chalk.dim(`DRY RUN \u2014 ${provider.name} / ${provider.config.model} \u2014 nothing will be saved
+  console.log(chalk2.dim(`DRY RUN \u2014 ${provider.name} / ${provider.config.model} \u2014 nothing will be saved
 `));
   const memories = await provider.extractMemories(turn, {
     agentId: opts.agent,
     projectId: opts.project
   });
   if (memories.length === 0) {
-    console.log(chalk.dim("Nothing extracted."));
+    console.log(chalk2.dim("Nothing extracted."));
   } else {
     memories.forEach((m, i) => {
-      console.log(chalk.bold(`[${i + 1}] ${m.category.toUpperCase()} \xB7 importance ${m.importance}/10 \xB7 ${m.suggestedScope}`));
-      console.log(`  ${chalk.white(m.content)}`);
+      console.log(chalk2.bold(`[${i + 1}] ${m.category.toUpperCase()} \xB7 importance ${m.importance}/10 \xB7 ${m.suggestedScope}`));
+      console.log(`  ${chalk2.white(m.content)}`);
       if (m.tags.length)
-        console.log(chalk.dim(`  tags: ${m.tags.join(", ")}`));
+        console.log(chalk2.dim(`  tags: ${m.tags.join(", ")}`));
       if (m.reasoning)
-        console.log(chalk.dim(`  why: ${m.reasoning}`));
+        console.log(chalk2.dim(`  why: ${m.reasoning}`));
       console.log();
     });
   }
@@ -11273,38 +12598,38 @@ autoMemory.command("test <turn>").description("Test extraction without saving (d
 autoMemory.command("enable").description("Enable auto-memory extraction").action(async () => {
   const { configureAutoMemory: configureAutoMemory2 } = await Promise.resolve().then(() => (init_auto_memory(), exports_auto_memory));
   configureAutoMemory2({ enabled: true });
-  console.log(chalk.green("\u2713 Auto-memory enabled"));
+  console.log(chalk2.green("\u2713 Auto-memory enabled"));
 });
 autoMemory.command("disable").description("Disable auto-memory extraction").action(async () => {
   const { configureAutoMemory: configureAutoMemory2 } = await Promise.resolve().then(() => (init_auto_memory(), exports_auto_memory));
   configureAutoMemory2({ enabled: false });
-  console.log(chalk.yellow("\u26A0 Auto-memory disabled"));
+  console.log(chalk2.yellow("\u26A0 Auto-memory disabled"));
 });
 var hooksCmd = program2.command("hooks").description("Hook registry and webhook management");
 hooksCmd.command("list").description("List registered hooks in the in-memory registry").option("--type <type>", "Filter by hook type").action(async (opts) => {
   const { hookRegistry: hookRegistry2 } = await Promise.resolve().then(() => (init_hooks(), exports_hooks));
   const hooks = hookRegistry2.list(opts.type);
   if (hooks.length === 0) {
-    console.log(chalk.gray("No hooks registered."));
+    console.log(chalk2.gray("No hooks registered."));
     return;
   }
   for (const h of hooks) {
-    const builtinTag = h.builtin ? chalk.blue(" [builtin]") : "";
-    const blockingTag = h.blocking ? chalk.red(" [blocking]") : chalk.gray(" [non-blocking]");
-    console.log(`${chalk.cyan(h.id)} ${chalk.bold(h.type)}${builtinTag}${blockingTag} priority=${h.priority}`);
+    const builtinTag = h.builtin ? chalk2.blue(" [builtin]") : "";
+    const blockingTag = h.blocking ? chalk2.red(" [blocking]") : chalk2.gray(" [non-blocking]");
+    console.log(`${chalk2.cyan(h.id)} ${chalk2.bold(h.type)}${builtinTag}${blockingTag} priority=${h.priority}`);
     if (h.description)
-      console.log(`  ${chalk.gray(h.description)}`);
+      console.log(`  ${chalk2.gray(h.description)}`);
   }
 });
 hooksCmd.command("stats").description("Show hook registry statistics").action(async () => {
   const { hookRegistry: hookRegistry2 } = await Promise.resolve().then(() => (init_hooks(), exports_hooks));
   const stats = hookRegistry2.stats();
-  console.log(chalk.bold("Hook Registry Stats"));
-  console.log(`  Total:       ${chalk.cyan(stats.total)}`);
-  console.log(`  Blocking:    ${chalk.red(stats.blocking)}`);
-  console.log(`  Non-blocking:${chalk.green(stats.nonBlocking)}`);
+  console.log(chalk2.bold("Hook Registry Stats"));
+  console.log(`  Total:       ${chalk2.cyan(stats.total)}`);
+  console.log(`  Blocking:    ${chalk2.red(stats.blocking)}`);
+  console.log(`  Non-blocking:${chalk2.green(stats.nonBlocking)}`);
   if (Object.keys(stats.byType).length > 0) {
-    console.log(chalk.bold(`
+    console.log(chalk2.bold(`
 By type:`));
     for (const [type, count] of Object.entries(stats.byType)) {
       console.log(`  ${type}: ${count}`);
@@ -11319,16 +12644,16 @@ webhooksCmd.command("list").description("List all persisted webhook hooks").opti
     enabled: opts.disabled ? false : undefined
   });
   if (webhooks.length === 0) {
-    console.log(chalk.gray("No webhooks registered."));
+    console.log(chalk2.gray("No webhooks registered."));
     return;
   }
   for (const wh of webhooks) {
-    const enabledTag = wh.enabled ? chalk.green("enabled") : chalk.red("disabled");
-    const blockingTag = wh.blocking ? chalk.red("blocking") : chalk.gray("non-blocking");
-    console.log(`${chalk.cyan(wh.id)} [${enabledTag}] ${chalk.bold(wh.type)} \u2192 ${wh.handlerUrl}`);
+    const enabledTag = wh.enabled ? chalk2.green("enabled") : chalk2.red("disabled");
+    const blockingTag = wh.blocking ? chalk2.red("blocking") : chalk2.gray("non-blocking");
+    console.log(`${chalk2.cyan(wh.id)} [${enabledTag}] ${chalk2.bold(wh.type)} \u2192 ${wh.handlerUrl}`);
     console.log(`  ${blockingTag} | priority=${wh.priority} | invocations=${wh.invocationCount} failures=${wh.failureCount}`);
     if (wh.description)
-      console.log(`  ${chalk.gray(wh.description)}`);
+      console.log(`  ${chalk2.gray(wh.description)}`);
   }
 });
 webhooksCmd.command("create <type> <url>").description("Create a persistent webhook hook").option("--blocking", "Block the operation until the webhook responds").option("--priority <n>", "Hook priority (default 50)", "50").option("--agent <id>", "Scope to specific agent").option("--project <id>", "Scope to specific project").option("--description <text>", "Human-readable description").action(async (type, url, opts) => {
@@ -11344,8 +12669,8 @@ webhooksCmd.command("create <type> <url>").description("Create a persistent webh
     description: opts.description
   });
   reloadWebhooks2();
-  console.log(chalk.green("\u2713 Webhook created"));
-  console.log(`  ID:   ${chalk.cyan(wh.id)}`);
+  console.log(chalk2.green("\u2713 Webhook created"));
+  console.log(`  ID:   ${chalk2.cyan(wh.id)}`);
   console.log(`  Type: ${wh.type}`);
   console.log(`  URL:  ${wh.handlerUrl}`);
 });
@@ -11353,9 +12678,9 @@ webhooksCmd.command("delete <id>").description("Delete a webhook by ID").action(
   const { deleteWebhookHook: deleteWebhookHook2 } = await Promise.resolve().then(() => (init_webhook_hooks(), exports_webhook_hooks));
   const deleted = deleteWebhookHook2(id);
   if (deleted) {
-    console.log(chalk.green(`\u2713 Webhook ${id} deleted`));
+    console.log(chalk2.green(`\u2713 Webhook ${id} deleted`));
   } else {
-    console.error(chalk.red(`Webhook not found: ${id}`));
+    console.error(chalk2.red(`Webhook not found: ${id}`));
     process.exit(1);
   }
 });
@@ -11365,9 +12690,9 @@ webhooksCmd.command("enable <id>").description("Enable a webhook").action(async
   const updated = updateWebhookHook2(id, { enabled: true });
   if (updated) {
     reloadWebhooks2();
-    console.log(chalk.green(`\u2713 Webhook ${id} enabled`));
+    console.log(chalk2.green(`\u2713 Webhook ${id} enabled`));
   } else {
-    console.error(chalk.red(`Webhook not found: ${id}`));
+    console.error(chalk2.red(`Webhook not found: ${id}`));
     process.exit(1);
   }
 });
@@ -11377,16 +12702,16 @@ webhooksCmd.command("disable <id>").description("Disable a webhook (without dele
   const updated = updateWebhookHook2(id, { enabled: false });
   if (updated) {
     reloadWebhooks2();
-    console.log(chalk.yellow(`\u2298 Webhook ${id} disabled`));
+    console.log(chalk2.yellow(`\u2298 Webhook ${id} disabled`));
   } else {
-    console.error(chalk.red(`Webhook not found: ${id}`));
+    console.error(chalk2.red(`Webhook not found: ${id}`));
     process.exit(1);
   }
 });
 var synthesisCmd = program2.command("synthesis").alias("synth").description("ALMA memory synthesis \u2014 analyze and consolidate memories");
 synthesisCmd.command("run").description("Run memory synthesis on the corpus").option("--project <id>", "Project ID to synthesize").option("--dry-run", "Preview proposals without applying them").option("--max-proposals <n>", "Maximum proposals to generate", "20").option("--provider <name>", "LLM provider (anthropic, openai, cerebras, grok)").action(async (opts) => {
   const { runSynthesis: runSynthesis2 } = await Promise.resolve().then(() => (init_synthesis2(), exports_synthesis2));
-  console.log(chalk.blue("Running memory synthesis..."));
+  console.log(chalk2.blue("Running memory synthesis..."));
   const result = await runSynthesis2({
     projectId: opts.project,
     dryRun: opts.dryRun ?? false,
@@ -11394,44 +12719,44 @@ synthesisCmd.command("run").description("Run memory synthesis on the corpus").op
     provider: opts.provider
   });
   if (result.dryRun) {
-    console.log(chalk.yellow(`DRY RUN \u2014 ${result.proposals.length} proposals generated (not applied)`));
+    console.log(chalk2.yellow(`DRY RUN \u2014 ${result.proposals.length} proposals generated (not applied)`));
   } else {
-    console.log(chalk.green(`\u2713 Synthesis complete`));
+    console.log(chalk2.green(`\u2713 Synthesis complete`));
     console.log(`  Corpus:    ${result.run.corpus_size} memories`);
     console.log(`  Proposals: ${result.run.proposals_generated} generated, ${result.run.proposals_accepted} applied`);
   }
   if (result.metrics) {
     console.log(`  Reduction: ${(result.metrics.corpusReduction * 100).toFixed(1)}%`);
   }
-  console.log(`  Run ID: ${chalk.cyan(result.run.id)}`);
+  console.log(`  Run ID: ${chalk2.cyan(result.run.id)}`);
 });
 synthesisCmd.command("status").description("Show recent synthesis runs").option("--project <id>", "Filter by project").action(async (opts) => {
   const { listSynthesisRuns: listSynthesisRuns2 } = await Promise.resolve().then(() => (init_synthesis(), exports_synthesis));
   const runs = listSynthesisRuns2({ project_id: opts.project, limit: 10 });
   if (runs.length === 0) {
-    console.log(chalk.gray("No synthesis runs found."));
+    console.log(chalk2.gray("No synthesis runs found."));
     return;
   }
   for (const run of runs) {
-    const statusColor = run.status === "completed" ? chalk.green : run.status === "failed" ? chalk.red : chalk.yellow;
-    console.log(`${chalk.cyan(run.id)} [${statusColor(run.status)}] corpus=${run.corpus_size} accepted=${run.proposals_accepted}/${run.proposals_generated} ${run.started_at.slice(0, 10)}`);
+    const statusColor = run.status === "completed" ? chalk2.green : run.status === "failed" ? chalk2.red : chalk2.yellow;
+    console.log(`${chalk2.cyan(run.id)} [${statusColor(run.status)}] corpus=${run.corpus_size} accepted=${run.proposals_accepted}/${run.proposals_generated} ${run.started_at.slice(0, 10)}`);
   }
 });
 synthesisCmd.command("rollback <runId>").description("Roll back a synthesis run").action(async (runId) => {
   const { rollbackSynthesis: rollbackSynthesis2 } = await Promise.resolve().then(() => (init_synthesis2(), exports_synthesis2));
-  console.log(chalk.yellow(`Rolling back synthesis run ${runId}...`));
+  console.log(chalk2.yellow(`Rolling back synthesis run ${runId}...`));
   const result = await rollbackSynthesis2(runId);
-  console.log(chalk.green(`\u2713 Rolled back ${result.rolled_back} proposals`));
+  console.log(chalk2.green(`\u2713 Rolled back ${result.rolled_back} proposals`));
   if (result.errors.length > 0) {
-    console.log(chalk.red(`  Errors: ${result.errors.join(", ")}`));
+    console.log(chalk2.red(`  Errors: ${result.errors.join(", ")}`));
   }
 });
 var sessionCmd = program2.command("session").description("Session auto-memory \u2014 ingest session transcripts for memory extraction");
 sessionCmd.command("ingest <transcriptFile>").description("Ingest a session transcript file for memory extraction").option("--session-id <id>", "Session ID (default: auto-generated)").option("--agent <id>", "Agent ID").option("--project <id>", "Project ID").option("--source <source>", "Source (claude-code, codex, manual, open-sessions)", "manual").action(async (transcriptFile, opts) => {
-  const { readFileSync: readFileSync3 } = await import("fs");
+  const { readFileSync: readFileSync4 } = await import("fs");
   const { createSessionJob: createSessionJob2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
   const { enqueueSessionJob: enqueueSessionJob2 } = await Promise.resolve().then(() => (init_session_queue(), exports_session_queue));
-  const transcript = readFileSync3(transcriptFile, "utf-8");
+  const transcript = readFileSync4(transcriptFile, "utf-8");
   const sessionId = opts.sessionId ?? `cli-${Date.now()}`;
   const job = createSessionJob2({
     session_id: sessionId,
@@ -11441,7 +12766,7 @@ sessionCmd.command("ingest <transcriptFile>").description("Ingest a session tran
     project_id: opts.project
   });
   enqueueSessionJob2(job.id);
-  console.log(chalk.green(`\u2713 Session queued: ${chalk.cyan(job.id)}`));
+  console.log(chalk2.green(`\u2713 Session queued: ${chalk2.cyan(job.id)}`));
   console.log(`  Session: ${sessionId}`);
   console.log(`  Length:  ${transcript.length} chars`);
 });
@@ -11449,16 +12774,16 @@ sessionCmd.command("status <jobId>").description("Check status of a session extr
   const { getSessionJob: getSessionJob2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
   const job = getSessionJob2(jobId);
   if (!job) {
-    console.error(chalk.red(`Job not found: ${jobId}`));
+    console.error(chalk2.red(`Job not found: ${jobId}`));
     process.exit(1);
   }
-  const statusColor = job.status === "completed" ? chalk.green : job.status === "failed" ? chalk.red : chalk.yellow;
-  console.log(`${chalk.cyan(job.id)} [${statusColor(job.status)}]`);
+  const statusColor = job.status === "completed" ? chalk2.green : job.status === "failed" ? chalk2.red : chalk2.yellow;
+  console.log(`${chalk2.cyan(job.id)} [${statusColor(job.status)}]`);
   console.log(`  Session:   ${job.session_id}`);
   console.log(`  Chunks:    ${job.chunk_count}`);
   console.log(`  Extracted: ${job.memories_extracted} memories`);
   if (job.error)
-    console.log(chalk.red(`  Error: ${job.error}`));
+    console.log(chalk2.red(`  Error: ${job.error}`));
 });
 sessionCmd.command("list").description("List session extraction jobs").option("--agent <id>", "Filter by agent").option("--project <id>", "Filter by project").option("--status <status>", "Filter by status").option("--limit <n>", "Max results", "20").action(async (opts) => {
   const { listSessionJobs: listSessionJobs2 } = await Promise.resolve().then(() => (init_session_jobs(), exports_session_jobs));
@@ -11469,12 +12794,12 @@ sessionCmd.command("list").description("List session extraction jobs").option("-
     limit: parseInt(opts.limit)
   });
   if (jobs.length === 0) {
-    console.log(chalk.gray("No session jobs found."));
+    console.log(chalk2.gray("No session jobs found."));
     return;
   }
   for (const job of jobs) {
-    const statusColor = job.status === "completed" ? chalk.green : job.status === "failed" ? chalk.red : chalk.yellow;
-    console.log(`${chalk.cyan(job.id.slice(0, 8))} [${statusColor(job.status)}] ${job.memories_extracted} memories | ${job.created_at.slice(0, 10)}`);
+    const statusColor = job.status === "completed" ? chalk2.green : job.status === "failed" ? chalk2.red : chalk2.yellow;
+    console.log(`${chalk2.cyan(job.id.slice(0, 8))} [${statusColor(job.status)}] ${job.memories_extracted} memories | ${job.created_at.slice(0, 10)}`);
   }
 });
 sessionCmd.command("setup-hook").description("Install mementos session hook into Claude Code or Codex").option("--claude", "Install Claude Code stop hook").option("--codex", "Install Codex session hook").option("--show", "Print hook script instead of installing").action(async (opts) => {
@@ -11483,26 +12808,26 @@ sessionCmd.command("setup-hook").description("Install mementos session hook into
   if (opts.claude) {
     const script = `${hookPath}/claude-stop-hook.ts`;
     if (opts.show) {
-      const { readFileSync: readFileSync3 } = await import("fs");
-      console.log(readFileSync3(script, "utf-8"));
+      const { readFileSync: readFileSync4 } = await import("fs");
+      console.log(readFileSync4(script, "utf-8"));
       return;
     }
-    console.log(chalk.bold("Claude Code stop hook installation:"));
+    console.log(chalk2.bold("Claude Code stop hook installation:"));
     console.log("");
     console.log("Add to your .claude/settings.json:");
-    console.log(chalk.cyan(JSON.stringify({
+    console.log(chalk2.cyan(JSON.stringify({
       hooks: {
         Stop: [{ matcher: "", hooks: [{ type: "command", command: `bun ${script}` }] }]
       }
     }, null, 2)));
     console.log("");
-    console.log(`Or run: ${chalk.cyan(`claude hooks add Stop "bun ${script}"`)}`);
+    console.log(`Or run: ${chalk2.cyan(`claude hooks add Stop "bun ${script}"`)}`);
   } else if (opts.codex) {
     const script = `${hookPath}/codex-stop-hook.ts`;
-    console.log(chalk.bold("Codex session hook installation:"));
+    console.log(chalk2.bold("Codex session hook installation:"));
     console.log("");
     console.log("Add to ~/.codex/config.toml:");
-    console.log(chalk.cyan(`[hooks]
+    console.log(chalk2.cyan(`[hooks]
 session_end = "bun ${script}"`));
   } else {
     console.log("Usage: mementos session setup-hook --claude | --codex");
@@ -11526,7 +12851,7 @@ program2.command("heartbeat [agent-id]").description("Update last_seen_at to sig
   if (globalOpts.json)
     console.log(JSON.stringify({ agent_id: agent.id, name: agent.name, last_seen_at: new Date().toISOString() }));
   else
-    console.log(chalk.green(`\u2665 ${agent.name} (${agent.id}) \u2014 heartbeat sent`));
+    console.log(chalk2.green(`\u2665 ${agent.name} (${agent.id}) \u2014 heartbeat sent`));
 });
 program2.command("set-focus [project]").description("Focus this agent on a project (or clear focus if no project given)").option("--agent <id>", "Agent ID").action((project, opts) => {
   const globalOpts = program2.opts();
@@ -11538,9 +12863,9 @@ program2.command("set-focus [project]").description("Focus this agent on a proje
   }
   setFocus(agentId, project ?? null);
   if (project)
-    console.log(chalk.green(`Focused: ${agentId} \u2192 project ${project}`));
+    console.log(chalk2.green(`Focused: ${agentId} \u2192 project ${project}`));
   else
-    console.log(chalk.dim(`Focus cleared for ${agentId}`));
+    console.log(chalk2.dim(`Focus cleared for ${agentId}`));
 });
 program2.command("get-focus").description("Show the current project focus for an agent").option("--agent <id>", "Agent ID").action((opts) => {
   const globalOpts = program2.opts();
@@ -11552,9 +12877,9 @@ program2.command("get-focus").description("Show the current project focus for an
   }
   const focus = getFocus(agentId);
   if (focus)
-    console.log(chalk.cyan(`Focus: ${focus}`));
+    console.log(chalk2.cyan(`Focus: ${focus}`));
   else
-    console.log(chalk.dim("No focus set."));
+    console.log(chalk2.dim("No focus set."));
 });
 program2.command("remove <nameOrId>").description("Remove/delete a memory by name or ID (alias for memory delete)").option("--agent <id>", "Agent ID").action((nameOrId, opts) => {
   const globalOpts = program2.opts();
@@ -11570,15 +12895,271 @@ program2.command("remove <nameOrId>").description("Remove/delete a memory by nam
       id = mem.id;
   }
   if (!id) {
-    console.error(chalk.red(`Memory not found: ${nameOrId}`));
+    console.error(chalk2.red(`Memory not found: ${nameOrId}`));
     process.exit(1);
   }
   const deleted = deleteMemory2(id);
   if (deleted)
-    console.log(chalk.green(`\u2713 Memory ${id.slice(0, 8)} removed`));
+    console.log(chalk2.green(`\u2713 Memory ${id.slice(0, 8)} removed`));
   else {
-    console.error(chalk.red(`Memory not found: ${nameOrId}`));
+    console.error(chalk2.red(`Memory not found: ${nameOrId}`));
     process.exit(1);
   }
 });
+program2.command("tool-events [tool_name]").description("List tool events, optionally filtered by tool name").option("--limit <n>", "Max results (default: 20)", parseInt).option("--project-id <id>", "Filter by project ID").action((toolName, opts) => {
+  try {
+    const globalOpts = program2.opts();
+    const { getToolEvents: getToolEvents2 } = (init_tool_events(), __toCommonJS(exports_tool_events));
+    const limit = opts.limit || 20;
+    const events = getToolEvents2({
+      tool_name: toolName,
+      project_id: opts.projectId,
+      limit
+    });
+    if (globalOpts.json) {
+      outputJson(events);
+      return;
+    }
+    if (events.length === 0) {
+      console.log(chalk2.yellow("No tool events found."));
+      return;
+    }
+    console.log(chalk2.bold(`${events.length} tool event${events.length === 1 ? "" : "s"}:`));
+    console.log(`  ${chalk2.dim("tool_name".padEnd(24))} ${chalk2.dim("action".padEnd(16))} ${chalk2.dim("success")} ${chalk2.dim("error_type".padEnd(20))} ${chalk2.dim("created_at")}`);
+    for (const e of events) {
+      const successStr = e.success ? chalk2.green("true   ") : chalk2.red("false  ");
+      const errorType = (e.error_type || "").padEnd(20);
+      const action = (e.action || "-").padEnd(16);
+      console.log(`  ${e.tool_name.padEnd(24)} ${action} ${successStr} ${errorType} ${chalk2.dim(e.created_at)}`);
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("tool-insights <tool_name>").description("Show tool guide/stats and lessons for a tool").option("--project-id <id>", "Filter by project ID").action((toolName, opts) => {
+  try {
+    const globalOpts = program2.opts();
+    const { getToolStats: getToolStats2, getToolLessons: getToolLessons2 } = (init_tool_events(), __toCommonJS(exports_tool_events));
+    const projectId = opts.projectId;
+    const stats = getToolStats2(toolName, projectId);
+    const lessons = getToolLessons2(toolName, projectId);
+    if (globalOpts.json) {
+      outputJson({ stats, lessons });
+      return;
+    }
+    const successRate = (stats.success_rate * 100).toFixed(1);
+    console.log(chalk2.bold(`Tool: ${toolName}`));
+    console.log(`  Calls: ${stats.total_calls}  Success: ${chalk2.green(String(stats.success_count))}  Failures: ${chalk2.red(String(stats.failure_count))}  Rate: ${successRate}%` + (stats.avg_latency_ms !== null ? `  Avg latency: ${stats.avg_latency_ms.toFixed(0)}ms` : "") + (stats.last_used ? `  Last used: ${chalk2.dim(stats.last_used)}` : ""));
+    if (stats.common_errors.length > 0) {
+      console.log(chalk2.bold(`
+  Common errors:`));
+      for (const err of stats.common_errors) {
+        console.log(`    ${chalk2.red(err.error_type)}: ${err.count} times`);
+      }
+    }
+    if (lessons.length === 0) {
+      console.log(chalk2.dim(`
+  No lessons recorded.`));
+      return;
+    }
+    console.log(chalk2.bold(`
+  Lessons (${lessons.length}):`));
+    for (const l of lessons) {
+      console.log(`    ${chalk2.cyan("-")} ${l.lesson} ${chalk2.dim(`(${l.created_at.slice(0, 10)})`)}`);
+      if (l.when_to_use) {
+        console.log(`      ${chalk2.dim("when_to_use:")} ${l.when_to_use}`);
+      }
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("synthesized-profile").description("Show or refresh the synthesized agent/project profile").option("--project-id <id>", "Project ID").option("--refresh", "Force refresh the profile (re-synthesize from memories)").action(async (opts) => {
+  try {
+    const globalOpts = program2.opts();
+    const { synthesizeProfile: synthesizeProfile2 } = await Promise.resolve().then(() => (init_profile_synthesizer(), exports_profile_synthesizer));
+    let projectId = opts.projectId;
+    if (!projectId && globalOpts.project) {
+      const project = getProject(resolve3(globalOpts.project));
+      if (project)
+        projectId = project.id;
+    }
+    const result = await synthesizeProfile2({
+      project_id: projectId,
+      agent_id: globalOpts.agent,
+      force_refresh: !!opts.refresh
+    });
+    if (!result) {
+      if (globalOpts.json) {
+        outputJson({ error: "No profile available (no preference/fact memories found)" });
+      } else {
+        console.log(chalk2.yellow("No profile available \u2014 save some preference or fact memories first."));
+      }
+      return;
+    }
+    if (globalOpts.json) {
+      outputJson(result);
+      return;
+    }
+    if (result.from_cache) {
+      console.log(chalk2.dim(`(cached profile)
+`));
+    } else {
+      console.log(chalk2.dim(`(synthesized from ${result.memory_count} memories)
+`));
+    }
+    console.log(result.profile);
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("chain <sequence_group>").description("Show a memory chain (memories linked by sequence_group, ordered by sequence_order)").action((sequenceGroup) => {
+  try {
+    const globalOpts = program2.opts();
+    const db = getDatabase();
+    const rows = db.query("SELECT * FROM memories WHERE sequence_group = ? AND status = 'active' ORDER BY sequence_order ASC").all(sequenceGroup);
+    const memories = rows.map(parseMemoryRow);
+    if (globalOpts.json) {
+      outputJson(memories);
+      return;
+    }
+    if (memories.length === 0) {
+      console.log(chalk2.yellow(`No chain found for sequence group: ${sequenceGroup}`));
+      return;
+    }
+    console.log(chalk2.bold(`Chain: ${sequenceGroup} (${memories.length} step${memories.length === 1 ? "" : "s"}):
+`));
+    for (let i = 0;i < memories.length; i++) {
+      const m = memories[i];
+      const order = m.sequence_order !== null && m.sequence_order !== undefined ? m.sequence_order : i + 1;
+      const value = m.value.length > 120 ? m.value.slice(0, 120) + "..." : m.value;
+      console.log(`  ${chalk2.cyan(String(order) + ".")} ${chalk2.bold(m.key)}: ${value}`);
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.command("when-to-use <memory_id>").description("Show the when_to_use guidance for a memory").action((memoryId) => {
+  try {
+    const globalOpts = program2.opts();
+    const resolvedId = resolveMemoryId(memoryId);
+    const memory = getMemory(resolvedId);
+    if (!memory) {
+      if (globalOpts.json) {
+        outputJson({ error: `Memory not found: ${memoryId}` });
+      } else {
+        console.error(chalk2.red(`Memory not found: ${memoryId}`));
+      }
+      process.exit(1);
+    }
+    const whenToUse = memory.when_to_use ?? null;
+    if (globalOpts.json) {
+      outputJson({ id: memory.id, key: memory.key, when_to_use: whenToUse });
+      return;
+    }
+    console.log(chalk2.bold(`${memory.key} (${memory.id.slice(0, 8)})`));
+    if (whenToUse) {
+      console.log(`  ${chalk2.cyan("when_to_use:")} ${whenToUse}`);
+    } else {
+      console.log(chalk2.dim("  (not set)"));
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+var sessionsCmd = program2.command("sessions").description("Session registry \u2014 list, clean, and inspect active Claude Code sessions");
+sessionsCmd.command("list").description("List all active sessions in the registry").option("--project <name>", "Filter by project name").option("--agent <name>", "Filter by agent name").option("--format <fmt>", "Output format: compact (default), json, yaml").action((opts) => {
+  try {
+    const globalOpts = program2.opts();
+    const { listSessions: listSessions2 } = (init_session_registry(), __toCommonJS(exports_session_registry));
+    const sessions = listSessions2({
+      project_name: opts.project,
+      agent_name: opts.agent || globalOpts.agent
+    });
+    const fmt = getOutputFormat(opts.format);
+    if (fmt === "json") {
+      outputJson(sessions);
+      return;
+    }
+    if (fmt === "yaml") {
+      outputYaml(sessions);
+      return;
+    }
+    if (sessions.length === 0) {
+      console.log(chalk2.yellow("No active sessions found."));
+      return;
+    }
+    console.log(chalk2.bold(`${sessions.length} active session${sessions.length === 1 ? "" : "s"}:
+`));
+    for (const s of sessions) {
+      const pid = chalk2.dim(`pid:${s.pid}`);
+      const agent = s.agent_name ? chalk2.cyan(s.agent_name) : chalk2.dim("(no agent)");
+      const project = s.project_name ? chalk2.yellow(s.project_name) : chalk2.dim("(no project)");
+      const mcp = chalk2.dim(s.mcp_server);
+      const self = s.pid === process.pid ? chalk2.green(" (self)") : "";
+      console.log(`  ${chalk2.bold(s.id)} ${pid}${self} ${agent} ${project} ${mcp}`);
+      console.log(`    ${chalk2.dim(`cwd: ${s.cwd}`)}  ${chalk2.dim(`last seen: ${s.last_seen_at}`)}`);
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+sessionsCmd.command("send <message>").description("Send a message to sessions (use MCP tool memory_send_channel for full support)").option("--agent <name>", "Target agent name").option("--project <name>", "Target project name").option("--all", "Broadcast to all sessions").action((message, opts) => {
+  try {
+    const globalOpts = program2.opts();
+    const { listSessions: listSessions2 } = (init_session_registry(), __toCommonJS(exports_session_registry));
+    if (!opts.agent && !opts.project && !opts.all) {
+      console.error(chalk2.red("Specify a target: --agent <name>, --project <name>, or --all"));
+      process.exit(1);
+    }
+    const filter = {};
+    if (opts.agent)
+      filter.agent_name = opts.agent;
+    if (opts.project)
+      filter.project_name = opts.project;
+    const sessions = listSessions2(opts.all ? undefined : filter);
+    if (globalOpts.json) {
+      outputJson({
+        message: "Channel push requires MCP server context. Use the memory_send_channel MCP tool.",
+        matching_sessions: sessions.length,
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          pid: s.pid,
+          agent_name: s.agent_name,
+          project_name: s.project_name
+        }))
+      });
+      return;
+    }
+    console.log(chalk2.bold(`Found ${sessions.length} matching session${sessions.length === 1 ? "" : "s"}:`));
+    for (const s of sessions) {
+      const agent = s.agent_name ? chalk2.cyan(s.agent_name) : chalk2.dim("(no agent)");
+      const project = s.project_name ? chalk2.yellow(s.project_name) : "";
+      console.log(`  ${s.id} pid:${s.pid} ${agent} ${project}`);
+    }
+    console.log();
+    console.log(chalk2.dim("Channel push requires the MCP server context."));
+    console.log(chalk2.dim("Use the MCP tool:"));
+    console.log(chalk2.cyan(`  memory_send_channel(content="${message.slice(0, 60)}${message.length > 60 ? "..." : ""}")`));
+  } catch (e) {
+    handleError(e);
+  }
+});
+sessionsCmd.command("clean").description("Remove dead/stale sessions from the registry").action(() => {
+  try {
+    const globalOpts = program2.opts();
+    const { cleanStaleSessions: cleanStaleSessions2 } = (init_session_registry(), __toCommonJS(exports_session_registry));
+    const cleaned = cleanStaleSessions2();
+    if (globalOpts.json) {
+      outputJson({ cleaned });
+    } else if (cleaned === 0) {
+      console.log(chalk2.green("No stale sessions found \u2014 registry is clean."));
+    } else {
+      console.log(chalk2.green(`Cleaned ${cleaned} stale session${cleaned === 1 ? "" : "s"}.`));
+    }
+  } catch (e) {
+    handleError(e);
+  }
+});
+program2.addCommand(makeBrainsCommand());
 program2.parse(process.argv);