@aman_asmuei/aman-agent 0.16.2 → 0.17.0

package/dist/index.js

@@ -797,18 +797,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs12 from "fs";
-import path12 from "path";
-import os11 from "os";
+import fs13 from "fs";
+import path13 from "path";
+import os12 from "os";
 import pc6 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs8 from "fs";
-import path8 from "path";
-import os8 from "os";
+import fs9 from "fs";
+import path9 from "path";
+import os9 from "os";
 import { execFileSync } from "child_process";
 import pc3 from "picocolors";
 
@@ -869,10 +869,85 @@ function getEcosystemStatus(mcpToolCount, amemConnected) {
   };
 }
 
-// src/profile-templates.ts
-import fs5 from "fs";
+// src/memory.ts
+import {
+  createDatabase,
+  recall,
+  buildContext,
+  storeMemory,
+  consolidateMemories,
+  cosineSimilarity,
+  preloadEmbeddings,
+  buildVectorIndex
+} from "@aman_asmuei/amem-core";
 import path5 from "path";
 import os5 from "os";
+import fs5 from "fs";
+var db = null;
+var currentProject = "global";
+async function initMemory(project) {
+  if (db) return db;
+  const amemDir = process.env.AMEM_DIR ?? path5.join(os5.homedir(), ".amem");
+  if (!fs5.existsSync(amemDir)) fs5.mkdirSync(amemDir, { recursive: true });
+  const dbPath = process.env.AMEM_DB ?? path5.join(amemDir, "memory.db");
+  db = createDatabase(dbPath);
+  currentProject = project ?? "global";
+  preloadEmbeddings();
+  setTimeout(() => {
+    try {
+      buildVectorIndex(db);
+    } catch {
+    }
+  }, 1e3);
+  return db;
+}
+function getDb() {
+  if (!db) throw new Error("Memory not initialized \u2014 call initMemory() first");
+  return db;
+}
+async function memoryRecall(query, opts) {
+  return recall(getDb(), {
+    query,
+    limit: opts?.limit ?? 10,
+    compact: opts?.compact ?? true,
+    type: opts?.type,
+    tag: opts?.tag,
+    minConfidence: opts?.minConfidence,
+    explain: opts?.explain,
+    scope: currentProject
+  });
+}
+async function memoryContext(topic, maxTokens) {
+  return buildContext(getDb(), topic, { maxTokens, scope: currentProject });
+}
+async function memoryStore(opts) {
+  return storeMemory(getDb(), opts);
+}
+function memoryLog(sessionId, role, content) {
+  return getDb().appendLog({
+    sessionId,
+    role,
+    content,
+    project: currentProject,
+    metadata: {}
+  });
+}
+function reminderCheck() {
+  return getDb().checkReminders();
+}
+function memoryConsolidate(dryRun = false) {
+  return consolidateMemories(getDb(), cosineSimilarity, {
+    dryRun,
+    maxStaleDays: 90,
+    minConfidence: 0.3,
+    minAccessCount: 0
+  });
+}
+
+// src/profile-templates.ts
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
 var BUILT_IN_PROFILES = [
   {
     name: "coder",
@@ -965,9 +1040,9 @@ var BUILT_IN_PROFILES = [
 function installProfileTemplate(templateName, userName) {
   const template = BUILT_IN_PROFILES.find((t) => t.name === templateName);
   if (!template) return null;
-  const profileDir = path5.join(os5.homedir(), ".acore", "profiles", template.name);
-  if (fs5.existsSync(profileDir)) return `Profile already exists: ${template.name}`;
-  fs5.mkdirSync(profileDir, { recursive: true });
+  const profileDir = path6.join(os6.homedir(), ".acore", "profiles", template.name);
+  if (fs6.existsSync(profileDir)) return `Profile already exists: ${template.name}`;
+  fs6.mkdirSync(profileDir, { recursive: true });
   let core = template.core;
   if (userName) {
     core += `
@@ -981,12 +1056,12 @@ function installProfileTemplate(templateName, userName) {
 - Detail level: balanced
 `;
   }
-  fs5.writeFileSync(path5.join(profileDir, "core.md"), core, "utf-8");
+  fs6.writeFileSync(path6.join(profileDir, "core.md"), core, "utf-8");
   if (template.rules) {
-    fs5.writeFileSync(path5.join(profileDir, "rules.md"), template.rules, "utf-8");
+    fs6.writeFileSync(path6.join(profileDir, "rules.md"), template.rules, "utf-8");
   }
   if (template.skills) {
-    fs5.writeFileSync(path5.join(profileDir, "skills.md"), template.skills, "utf-8");
+    fs6.writeFileSync(path6.join(profileDir, "skills.md"), template.skills, "utf-8");
   }
   return null;
 }
@@ -1113,43 +1188,43 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 }
 
 // src/teams.ts
-import fs6 from "fs";
-import path6 from "path";
-import os6 from "os";
+import fs7 from "fs";
+import path7 from "path";
+import os7 from "os";
 import pc2 from "picocolors";
 function getTeamsDir() {
-  return path6.join(os6.homedir(), ".acore", "teams");
+  return path7.join(os7.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path6.join(ensureTeamsDir(), `${slug}.json`);
+  return path7.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs6.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs7.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs6.existsSync(fp)) return null;
+  if (!fs7.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs6.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs7.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs6.existsSync(dir)) return [];
+  if (!fs7.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs6.readdirSync(dir)) {
+  for (const file of fs7.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs6.readFileSync(path6.join(dir, file), "utf-8");
+      const content = fs7.readFileSync(path7.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -1158,8 +1233,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs6.existsSync(fp)) return false;
-  fs6.unlinkSync(fp);
+  if (!fs7.existsSync(fp)) return false;
+  fs7.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -1385,23 +1460,23 @@ var BUILT_IN_TEAMS = [
 ];
 
 // src/plans.ts
-import fs7 from "fs";
-import path7 from "path";
-import os7 from "os";
+import fs8 from "fs";
+import path8 from "path";
+import os8 from "os";
 function getPlansDir() {
-  const localDir = path7.join(process.cwd(), ".acore", "plans");
-  const localAcore = path7.join(process.cwd(), ".acore");
-  if (fs7.existsSync(localAcore)) return localDir;
-  return path7.join(os7.homedir(), ".acore", "plans");
+  const localDir = path8.join(process.cwd(), ".acore", "plans");
+  const localAcore = path8.join(process.cwd(), ".acore");
+  if (fs8.existsSync(localAcore)) return localDir;
+  return path8.join(os8.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path7.join(ensurePlansDir(), `${slug}.md`);
+  return path8.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -1427,7 +1502,7 @@ function parsePlan(content, filePath) {
     const createdMatch = content.match(/\*\*Created:\*\*\s*(.+)/);
     const updatedMatch = content.match(/\*\*Updated:\*\*\s*(.+)/);
     const activeMatch = content.match(/\*\*Active:\*\*\s*(.+)/);
-    const name = nameMatch?.[1]?.trim() || path7.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path8.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -1469,22 +1544,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs7.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs8.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs7.existsSync(fp)) return null;
-  const content = fs7.readFileSync(fp, "utf-8");
+  if (!fs8.existsSync(fp)) return null;
+  const content = fs8.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs7.existsSync(dir)) return [];
+  if (!fs8.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs7.readdirSync(dir)) {
+  for (const file of fs8.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path7.join(dir, file);
-    const content = fs7.readFileSync(fp, "utf-8");
+    const fp = path8.join(dir, file);
+    const content = fs8.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -1580,10 +1655,10 @@ function progressBar(pct) {
 
 // src/commands.ts
 function readEcosystemFile(filePath, label) {
-  if (!fs8.existsSync(filePath)) {
+  if (!fs9.existsSync(filePath)) {
     return pc3.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs8.readFileSync(filePath, "utf-8").trim();
+  return fs9.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -1604,9 +1679,9 @@ async function mcpWrite(ctx, layer, tool, args) {
   return pc3.green(result);
 }
 async function handleIdentityCommand(action, args, ctx) {
-  const home2 = os8.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path8.join(home2, ".acore", "core.md"), "identity (acore)");
+    const content = readEcosystemFile(path9.join(home2, ".acore", "core.md"), "identity (acore)");
     return { handled: true, output: content };
   }
   if (action === "update") {
@@ -1630,9 +1705,9 @@ async function handleIdentityCommand(action, args, ctx) {
   return { handled: true, output: pc3.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
 }
 async function handleRulesCommand(action, args, ctx) {
-  const home2 = os8.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path8.join(home2, ".arules", "rules.md"), "guardrails (arules)");
+    const content = readEcosystemFile(path9.join(home2, ".arules", "rules.md"), "guardrails (arules)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -1661,9 +1736,9 @@ async function handleRulesCommand(action, args, ctx) {
   return { handled: true, output: pc3.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os8.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path8.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path9.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -1702,38 +1777,38 @@ var AKIT_REGISTRY = [
   { name: "docling", description: "Convert PDF, DOCX, PPTX, XLSX to markdown", category: "documents", mcp: { package: "docling-mcp", command: "uvx", args: ["docling-mcp"] }, envHint: "Requires Python 3.10+. Install: pip install docling" }
 ];
 function loadAkitInstalled() {
-  const filePath = path8.join(os8.homedir(), ".akit", "installed.json");
-  if (!fs8.existsSync(filePath)) return [];
+  const filePath = path9.join(os9.homedir(), ".akit", "installed.json");
+  if (!fs9.existsSync(filePath)) return [];
   try {
-    return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveAkitInstalled(tools) {
-  const dir = path8.join(os8.homedir(), ".akit");
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.writeFileSync(path8.join(dir, "installed.json"), JSON.stringify(tools, null, 2) + "\n", "utf-8");
+  const dir = path9.join(os9.homedir(), ".akit");
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(path9.join(dir, "installed.json"), JSON.stringify(tools, null, 2) + "\n", "utf-8");
 }
 function addToAmanAgentConfig(name, mcpConfig) {
-  const configPath = path8.join(os8.homedir(), ".aman-agent", "config.json");
-  if (!fs8.existsSync(configPath)) return;
+  const configPath = path9.join(os9.homedir(), ".aman-agent", "config.json");
+  if (!fs9.existsSync(configPath)) return;
   try {
-    const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
     if (!config.mcpServers) config.mcpServers = {};
     config.mcpServers[name] = mcpConfig;
-    fs8.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 function removeFromAmanAgentConfig(name) {
-  const configPath = path8.join(os8.homedir(), ".aman-agent", "config.json");
-  if (!fs8.existsSync(configPath)) return;
+  const configPath = path9.join(os9.homedir(), ".aman-agent", "config.json");
+  if (!fs9.existsSync(configPath)) return;
   try {
-    const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
     if (config.mcpServers) {
       delete config.mcpServers[name];
-      fs8.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   } catch {
   }
@@ -1883,9 +1958,9 @@ function handleAkitCommand(action, args) {
   return { handled: true, output: lines.join("\n") };
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os8.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path8.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path9.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -1905,9 +1980,9 @@ async function handleSkillsCommand(action, args, ctx) {
   return { handled: true, output: pc3.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os8.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path8.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path9.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -1922,36 +1997,39 @@ async function handleEvalCommand(action, args, ctx) {
 }
 async function handleMemoryCommand(action, args, ctx) {
   if (!action) {
-    if (!ctx.mcpManager) {
-      return {
-        handled: true,
-        output: pc3.red("Memory not available: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp")
-      };
-    }
-    const result = await ctx.mcpManager.callTool("memory_context", { topic: "recent context" });
-    if (result.startsWith("Error")) {
-      return { handled: true, output: pc3.red(result) };
+    try {
+      const result = await memoryContext("recent context");
+      if (result.memoriesUsed === 0) {
+        return { handled: true, output: pc3.dim("No memories yet. Start chatting and I'll remember what matters.") };
+      }
+      return { handled: true, output: result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
-    return { handled: true, output: result };
   }
   if (action && !["search", "clear", "timeline"].includes(action)) {
-    if (!ctx.mcpManager) {
-      return { handled: true, output: pc3.red("Memory not available: MCP not connected.") };
-    }
-    const topic = [action, ...args].join(" ");
-    const result = await ctx.mcpManager.callTool("memory_context", { topic });
-    if (result.startsWith("Error")) {
-      return { handled: true, output: pc3.red(result) };
+    try {
+      const topic = [action, ...args].join(" ");
+      const result = await memoryContext(topic);
+      if (result.memoriesUsed === 0) {
+        return { handled: true, output: pc3.dim(`No memories found for: "${topic}".`) };
+      }
+      return { handled: true, output: result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
-    return { handled: true, output: result };
   }
   if (action === "search") {
     if (args.length < 1) {
       return { handled: true, output: pc3.yellow("Usage: /memory search <query...>") };
     }
     const query = args.join(" ");
-    const output = await mcpWrite(ctx, "memory", "memory_recall", { query });
-    return { handled: true, output };
+    try {
+      const result = await memoryRecall(query);
+      return { handled: true, output: result.total === 0 ? pc3.dim("No memories found.") : result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
   }
   if (action === "clear") {
     if (args.length < 1) {
@@ -1961,50 +2039,45 @@ async function handleMemoryCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "timeline") {
-    if (!ctx.mcpManager) {
-      return { handled: true, output: pc3.red("Memory not available: MCP not connected.") };
-    }
     try {
-      const result = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 500 });
-      if (result.startsWith("Error") || result.includes("No memories found")) {
+      const result = await memoryRecall("*", { limit: 500, compact: false });
+      if (result.total === 0) {
         return { handled: true, output: pc3.dim("No memories yet. Start chatting and I'll remember what matters.") };
       }
-      try {
-        const memories = JSON.parse(result);
-        if (Array.isArray(memories) && memories.length > 0) {
-          const byDate = /* @__PURE__ */ new Map();
-          for (const mem of memories) {
-            const date = mem.created_at ? new Date(mem.created_at).toLocaleDateString("en-US", { month: "short", day: "numeric" }) : "Unknown";
-            byDate.set(date, (byDate.get(date) || 0) + 1);
-          }
-          const maxCount = Math.max(...byDate.values());
-          const barWidth = 10;
-          const lines = [pc3.bold("Memory Timeline:"), ""];
-          for (const [date, count] of byDate) {
-            const filled = Math.round(count / maxCount * barWidth);
-            const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
-            lines.push(`  ${date.padEnd(8)} ${bar}  ${count} memories`);
-          }
-          const tags = /* @__PURE__ */ new Map();
-          for (const mem of memories) {
-            if (Array.isArray(mem.tags)) {
-              for (const tag of mem.tags) {
-                tags.set(tag, (tags.get(tag) || 0) + 1);
-              }
+      const memories = result.memories;
+      if (memories.length > 0) {
+        const byDate = /* @__PURE__ */ new Map();
+        for (const mem of memories) {
+          const createdAt = mem.created_at;
+          const date = createdAt ? new Date(createdAt).toLocaleDateString("en-US", { month: "short", day: "numeric" }) : "Unknown";
+          byDate.set(date, (byDate.get(date) || 0) + 1);
+        }
+        const maxCount = Math.max(...byDate.values());
+        const barWidth = 10;
+        const lines = [pc3.bold("Memory Timeline:"), ""];
+        for (const [date, count] of byDate) {
+          const filled = Math.round(count / maxCount * barWidth);
+          const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+          lines.push(`  ${date.padEnd(8)} ${bar}  ${count} memories`);
+        }
+        const tags = /* @__PURE__ */ new Map();
+        for (const mem of memories) {
+          const memTags = mem.tags;
+          if (Array.isArray(memTags)) {
+            for (const tag of memTags) {
+              tags.set(tag, (tags.get(tag) || 0) + 1);
             }
           }
-          lines.push("");
-          lines.push(`  Total: ${memories.length} memories`);
-          if (tags.size > 0) {
-            const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag, count]) => `#${tag} (${count})`).join(", ");
-            lines.push(`  Top tags: ${topTags}`);
-          }
-          return { handled: true, output: lines.join("\n") };
         }
-      } catch {
+        lines.push("");
+        lines.push(`  Total: ${result.total} memories`);
+        if (tags.size > 0) {
+          const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag, count]) => `#${tag} (${count})`).join(", ");
+          lines.push(`  Top tags: ${topTags}`);
+        }
+        return { handled: true, output: lines.join("\n") };
       }
-      const lineCount = result.split("\n").filter((l) => l.trim()).length;
-      return { handled: true, output: `Total memories: ~${lineCount} entries.` };
+      return { handled: true, output: `Total memories: ${result.total} entries.` };
     } catch {
       return { handled: true, output: pc3.red("Failed to retrieve memory timeline.") };
     }
@@ -2104,13 +2177,13 @@ function handleSave() {
   return { handled: true, saveConversation: true };
 }
 function handleReconfig() {
-  const configDir = path8.join(os8.homedir(), ".aman-agent");
-  const configPath = path8.join(configDir, "config.json");
-  if (fs8.existsSync(configPath)) {
-    fs8.unlinkSync(configPath);
+  const configDir = path9.join(os9.homedir(), ".aman-agent");
+  const configPath = path9.join(configDir, "config.json");
+  if (fs9.existsSync(configPath)) {
+    fs9.unlinkSync(configPath);
   }
-  fs8.mkdirSync(configDir, { recursive: true });
-  fs8.writeFileSync(path8.join(configDir, ".reconfig"), "", "utf-8");
+  fs9.mkdirSync(configDir, { recursive: true });
+  fs9.writeFileSync(path9.join(configDir, ".reconfig"), "", "utf-8");
   return {
     handled: true,
     quit: true,
@@ -2123,7 +2196,7 @@ function handleReconfig() {
 function handleUpdate() {
   try {
     const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = JSON.parse(fs8.readFileSync(path8.join(__dirname, "..", "package.json"), "utf-8")).version;
+    const local = JSON.parse(fs9.readFileSync(path9.join(__dirname, "..", "package.json"), "utf-8")).version;
     if (current === local) {
       return { handled: true, output: `${pc3.green("Up to date")} \u2014 v${local}` };
     }
@@ -2152,31 +2225,26 @@ function handleUpdate() {
     };
   }
 }
-async function handleDecisionsCommand(action, _args, ctx) {
-  if (!ctx.mcpManager) {
-    return { handled: true, output: pc3.red("Decisions not available: MCP not connected.") };
-  }
-  const scope = action || void 0;
-  const result = await ctx.mcpManager.callTool("memory_recall", {
-    query: "decision",
-    type: "decision",
-    limit: 20,
-    ...scope ? { scope } : {}
-  });
-  if (result.startsWith("Error")) {
-    return { handled: true, output: pc3.red(result) };
+async function handleDecisionsCommand(action, _args, _ctx) {
+  try {
+    const result = await memoryRecall("decision", { type: "decision", limit: 20 });
+    if (result.total === 0) {
+      return { handled: true, output: pc3.dim("No decisions recorded yet.") };
+    }
+    return { handled: true, output: pc3.bold("Decision Log:\n") + result.text };
+  } catch (err) {
+    return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
   }
-  return { handled: true, output: pc3.bold("Decision Log:\n") + result };
 }
 function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path8.join(os8.homedir(), ".aman-agent", "debug.log");
-  if (!fs8.existsSync(logPath)) {
+  const logPath = path9.join(os9.homedir(), ".aman-agent", "debug.log");
+  if (!fs9.existsSync(logPath)) {
     return { handled: true, output: pc3.dim("No debug log found.") };
   }
-  const content = fs8.readFileSync(logPath, "utf-8");
+  const content = fs9.readFileSync(logPath, "utf-8");
   const lines = content.trim().split("\n");
   const last20 = lines.slice(-20).join("\n");
   return { handled: true, output: pc3.bold("Debug Log (last 20 entries):\n") + pc3.dim(last20) };
@@ -2374,7 +2442,7 @@ ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path8.join(os8.homedir(), ".acore", "profiles");
+  const profilesDir = path9.join(os9.homedir(), ".acore", "profiles");
   if (!action || action === "list") {
     const profiles = listProfiles();
     if (profiles.length === 0) {
@@ -2398,8 +2466,8 @@ function handleProfileCommand(action, args) {
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path8.join(profilesDir, slug);
-      if (fs8.existsSync(profileDir)) {
+      const profileDir = path9.join(profilesDir, slug);
+      if (fs9.existsSync(profileDir)) {
         return { handled: true, output: pc3.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -2415,16 +2483,16 @@ function handleProfileCommand(action, args) {
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs8.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path8.join(os8.homedir(), ".acore", "core.md");
-      if (fs8.existsSync(globalCore)) {
-        let content = fs8.readFileSync(globalCore, "utf-8");
+      fs9.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path9.join(os9.homedir(), ".acore", "core.md");
+      if (fs9.existsSync(globalCore)) {
+        let content = fs9.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs8.writeFileSync(path8.join(profileDir, "core.md"), content, "utf-8");
+        fs9.writeFileSync(path9.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs8.writeFileSync(path8.join(profileDir, "core.md"), `# ${aiName}
+        fs9.writeFileSync(path9.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -2437,7 +2505,7 @@ function handleProfileCommand(action, args) {
       return {
         handled: true,
         output: pc3.green(`Profile created: ${slug}`) + `
-  Edit: ${path8.join(profileDir, "core.md")}
+  Edit: ${path9.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc3.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -2446,9 +2514,9 @@ function handleProfileCommand(action, args) {
     case "show": {
       const name = args[0];
       if (!name) return { handled: true, output: pc3.yellow("Usage: /profile show <name>") };
-      const profileDir = path8.join(profilesDir, name);
-      if (!fs8.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
-      const files = fs8.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path9.join(profilesDir, name);
+      if (!fs9.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
+      const files = fs9.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc3.bold(name)}
 Files:
@@ -2457,9 +2525,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc3.yellow("Usage: /profile delete <name>") };
-      const profileDir = path8.join(profilesDir, name);
-      if (!fs8.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
-      fs8.rmSync(profileDir, { recursive: true });
+      const profileDir = path9.join(profilesDir, name);
+      if (!fs9.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
+      fs9.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc3.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -2661,8 +2729,8 @@ async function handleCommand(input, ctx) {
 // src/hooks.ts
 import pc4 from "picocolors";
 import * as p from "@clack/prompts";
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/personality.ts
 var FRUSTRATION_SIGNALS = [
@@ -2867,10 +2935,8 @@ async function onSessionStart(ctx) {
   const visibleReminders = [];
   try {
     isHookCall = true;
-    const recallResult = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 1 });
-    if (!recallResult || recallResult.startsWith("Error") || recallResult.includes("No memories found")) {
-      firstRun = true;
-    }
+    const recallResult = await memoryRecall("*", { limit: 1 });
+    firstRun = recallResult.total === 0;
   } catch {
     firstRun = true;
   } finally {
@@ -2900,9 +2966,9 @@ ${contextInjection}`;
   if (ctx.config.memoryRecall) {
     try {
       isHookCall = true;
-      const result = await ctx.mcpManager.callTool("memory_context", { topic: "session context" });
-      if (result && !result.startsWith("Error")) {
-        greeting += result;
+      const contextResult = await memoryContext("session context");
+      if (contextResult.memoriesUsed > 0) {
+        greeting += contextResult.text;
       }
     } catch (err) {
       log.warn("hooks", "memory_context recall failed", err);
@@ -2933,12 +2999,12 @@ ${contextInjection}`;
   else greeting = timeContext;
   try {
     isHookCall = true;
-    const reminderResult = await ctx.mcpManager.callTool("reminder_check", {});
-    if (reminderResult && !reminderResult.startsWith("Error") && !reminderResult.includes("No pending")) {
-      greeting += "\n\n<pending-reminders>\n" + reminderResult + "\n</pending-reminders>";
-      const lines = reminderResult.split("\n").filter((l) => l.trim().length > 0);
-      for (const line of lines) {
-        visibleReminders.push(line.trim());
+    const reminders = reminderCheck();
+    if (reminders.length > 0) {
+      const reminderText = reminders.map((r) => r.content).join("\n");
+      greeting += "\n\n<pending-reminders>\n" + reminderText + "\n</pending-reminders>";
+      for (const r of reminders) {
+        visibleReminders.push(r.content);
       }
     }
   } catch (err) {
@@ -3053,11 +3119,7 @@ async function onSessionEnd(ctx, messages, sessionId) {
       for (const msg of textMessages) {
         try {
           isHookCall = true;
-          await ctx.mcpManager.callTool("memory_log", {
-            session_id: sessionId,
-            role: msg.role,
-            content: msg.content.slice(0, 5e3)
-          });
+          memoryLog(sessionId, msg.role, msg.content.slice(0, 5e3));
         } catch (err) {
           log.debug("hooks", "memory_log write failed for " + sessionId, err);
         } finally {
@@ -3085,10 +3147,10 @@ async function onSessionEnd(ctx, messages, sessionId) {
       }
       console.log(pc4.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path9.join(process.cwd(), ".acore", "context.md");
-    if (fs9.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path10.join(process.cwd(), ".acore", "context.md");
+    if (fs10.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs9.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs10.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -3106,7 +3168,7 @@ async function onSessionEnd(ctx, messages, sessionId) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs9.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs10.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
@@ -3236,9 +3298,9 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs10 from "fs";
-import path10 from "path";
-import os9 from "os";
+import fs11 from "fs";
+import path11 from "path";
+import os10 from "os";
 var SKILL_TRIGGERS = {
   testing: ["test", "spec", "coverage", "tdd", "jest", "vitest", "mocha", "assert", "mock", "stub", "fixture", "e2e", "integration test", "unit test"],
   "api-design": ["api", "endpoint", "rest", "graphql", "route", "controller", "middleware", "http", "request", "response", "status code", "pagination"],
@@ -3253,20 +3315,20 @@ var SKILL_TRIGGERS = {
   typescript: ["typescript", "type", "interface", "generic", "infer", "utility type", "zod", "discriminated union", "type guard", "as const"],
   accessibility: ["accessibility", "a11y", "aria", "screen reader", "wcag", "semantic html", "tab order", "focus", "contrast"]
 };
-var LEVEL_FILE = path10.join(os9.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path11.join(os10.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs10.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs10.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs11.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs11.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path10.dirname(LEVEL_FILE);
-  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path11.dirname(LEVEL_FILE);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -3644,7 +3706,7 @@ function parseExtractionResult(raw) {
     return [];
   }
 }
-async function extractMemories(userMessage, assistantResponse, client, mcpManager, state) {
+async function extractMemories(userMessage, assistantResponse, client, state) {
   if (!shouldExtract(assistantResponse, state.turnsSinceLastExtraction, state.lastExtractionCount)) {
     state.turnsSinceLastExtraction++;
     return 0;
@@ -3668,24 +3730,18 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
     let stored = 0;
     for (const candidate of candidates) {
       try {
-        const existing = await mcpManager.callTool("memory_recall", {
-          query: candidate.content,
-          limit: 1
-        });
-        if (existing && !existing.startsWith("Error")) {
-          try {
-            const parsed = JSON.parse(existing);
-            if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].score > 0.85) {
-              log.debug("extractor", "Skipping duplicate: " + candidate.content);
-              continue;
-            }
-          } catch {
+        const existing = await memoryRecall(candidate.content, { limit: 1 });
+        if (existing.total > 0 && existing.memories.length > 0) {
+          const topScore = existing.memories[0]?.score;
+          if (topScore && topScore > 0.85) {
+            log.debug("extractor", "Skipping duplicate: " + candidate.content);
+            continue;
           }
         }
       } catch {
       }
       try {
-        await mcpManager.callTool("memory_store", {
+        await memoryStore({
           content: candidate.content,
           type: candidate.type,
           tags: candidate.tags,
@@ -3876,9 +3932,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs11 from "fs";
-import path11 from "path";
-import os10 from "os";
+import fs12 from "fs";
+import path12 from "path";
+import os11 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -3916,11 +3972,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path11.join(os10.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path12.join(os11.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs11.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs11.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs12.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs12.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -3929,31 +3985,27 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path11.dirname(HINTS_FILE);
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path12.dirname(HINTS_FILE);
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
 
 // src/agent.ts
 marked.use(markedTerminal());
-async function recallForMessage(input, mcpManager) {
+async function recallForMessage(input) {
   try {
-    const result = await mcpManager.callTool("memory_recall", {
-      query: input,
-      limit: 5,
-      compact: true
-    });
-    if (!result || result.startsWith("Error") || result.includes("No memories found")) {
+    const result = await memoryRecall(input, { limit: 5, compact: true });
+    if (result.total === 0) {
       return null;
     }
-    const tokenEstimate = Math.round(result.split(/\s+/).filter(Boolean).length * 1.3);
+    const tokenEstimate = result.tokenEstimate ?? Math.round(result.text.split(/\s+/).filter(Boolean).length * 1.3);
     return {
       text: `
 
 <relevant-memories>
-${result}
+${result.text}
 </relevant-memories>`,
       tokenEstimate
     };
@@ -4124,9 +4176,9 @@ Type a message, ${pc6.dim("/help")} for commands, or ${pc6.dim("/quit")} to exit
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path12.join(os11.homedir(), ".aman-agent", "exports");
-          fs12.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path12.join(exportDir, `${sessionId}.md`);
+          const exportDir = path13.join(os12.homedir(), ".aman-agent", "exports");
+          fs13.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path13.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -4140,16 +4192,16 @@ Type a message, ${pc6.dim("/help")} for commands, or ${pc6.dim("/quit")} to exit
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs12.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs13.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc6.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc6.red("Failed to export conversation."));
         }
         continue;
       }
-      if (cmdResult.saveConversation && mcpManager) {
+      if (cmdResult.saveConversation) {
         try {
-          await saveConversationToMemory(mcpManager, messages, sessionId);
+          await saveConversationToMemory(messages, sessionId);
           console.log(pc6.green("Conversation saved to memory."));
         } catch {
           console.log(pc6.red("Failed to save conversation."));
@@ -4266,25 +4318,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path12.join(os11.homedir(), filePath.slice(2));
+        filePath = path13.join(os12.homedir(), filePath.slice(2));
       }
-      if (!fs12.existsSync(filePath) || !fs12.statSync(filePath).isFile()) continue;
-      const ext = path12.extname(filePath).toLowerCase();
+      if (!fs13.existsSync(filePath) || !fs13.statSync(filePath).isFile()) continue;
+      const ext = path13.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs12.statSync(filePath);
+          const stat = fs13.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc6.yellow(`  [skipped: ${path12.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc6.yellow(`  [skipped: ${path13.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs12.readFileSync(filePath).toString("base64");
+          const data = fs13.readFileSync(filePath).toString("base64");
           const mediaType = mimeMap[ext] || "image/png";
           imageBlocks.push({
             type: "image",
             source: { type: "base64", media_type: mediaType, data }
           });
-          process.stdout.write(pc6.dim(`  [attached image: ${path12.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc6.dim(`  [attached image: ${path13.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc6.dim(`  [could not read image: ${filePath}]
@@ -4292,7 +4344,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs12.readFileSync(filePath, "utf-8");
+          const content = fs13.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -4302,7 +4354,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc6.dim(`  [attached: ${path12.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc6.dim(`  [attached: ${path13.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc6.dim(`  [could not read: ${filePath}]
@@ -4311,7 +4363,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc6.dim(`  [converting: ${path12.basename(filePath)}...]
+            process.stdout.write(pc6.dim(`  [converting: ${path13.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -4320,7 +4372,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc6.dim(`  [attached: ${path12.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc6.dim(`  [attached: ${path13.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -4332,7 +4384,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc6.dim(`  [could not convert: ${path12.basename(filePath)}]
+            process.stdout.write(pc6.dim(`  [could not convert: ${path13.basename(filePath)}]
 `));
           }
         } else {
@@ -4387,11 +4439,11 @@ ${converted}
     }
     let augmentedSystemPrompt = activeSystemPrompt;
     let memoryTokens = 0;
-    if (mcpManager) {
-      const recall = await recallForMessage(input, mcpManager);
-      if (recall) {
-        augmentedSystemPrompt = activeSystemPrompt + recall.text;
-        memoryTokens = recall.tokenEstimate;
+    {
+      const recall2 = await recallForMessage(input);
+      if (recall2) {
+        augmentedSystemPrompt = activeSystemPrompt + recall2.text;
+        memoryTokens = recall2.tokenEstimate;
       }
     }
     const userTurnCount = messages.filter((m) => m.role === "user").length;
@@ -4493,12 +4545,10 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
             const result = await mcpManager.callTool(toolUse.name, toolUse.input);
             const skipLogging = ["memory_log", "memory_recall", "memory_context", "memory_detail", "reminder_check"].includes(toolUse.name);
             if (!skipLogging) {
-              mcpManager.callTool("memory_log", {
-                session_id: sessionId,
-                role: "system",
-                content: `[tool:${toolUse.name}] input=${JSON.stringify(toolUse.input).slice(0, 500)} result=${result.slice(0, 500)}`
-              }).catch(() => {
-              });
+              try {
+                memoryLog(sessionId, "system", `[tool:${toolUse.name}] input=${JSON.stringify(toolUse.input).slice(0, 500)} result=${result.slice(0, 500)}`);
+              } catch {
+              }
             }
             return {
               type: "tool_result",
@@ -4523,14 +4573,13 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       const footerDivider = "\u2500".repeat(Math.min(process.stdout.columns || 60, 60) - footer.length - 1);
       process.stdout.write(pc6.dim(` ${footerDivider}${footer}
 `));
-      if (mcpManager && hooksConfig?.extractMemories) {
+      if (hooksConfig?.extractMemories) {
         const assistantText = typeof response.message.content === "string" ? response.message.content : response.message.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
         if (assistantText) {
           const count = await extractMemories(
             input,
             assistantText,
             client,
-            mcpManager,
             extractorState
           );
           if (count > 0) {
@@ -4543,7 +4592,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs12.existsSync(path12.join(os11.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs13.existsSync(path13.join(os12.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -4560,16 +4609,12 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
     }
   }
 }
-async function saveConversationToMemory(mcpManager, messages, sessionId) {
+async function saveConversationToMemory(messages, sessionId) {
   const recentMessages = messages.slice(-50);
   for (const msg of recentMessages) {
     if (typeof msg.content !== "string") continue;
     try {
-      await mcpManager.callTool("memory_log", {
-        session_id: sessionId,
-        role: msg.role,
-        content: msg.content.slice(0, 5e3)
-      });
+      memoryLog(sessionId, msg.role, msg.content.slice(0, 5e3));
     } catch (err) {
       log.debug("agent", "memory_log write failed", err);
     }
@@ -4577,9 +4622,9 @@ async function saveConversationToMemory(mcpManager, messages, sessionId) {
 }
 
 // src/index.ts
-import fs13 from "fs";
-import path13 from "path";
-import os12 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -4688,9 +4733,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path13.join(os12.homedir(), ".aman-agent", ".reconfig");
-  if (fs13.existsSync(reconfigMarker)) {
-    fs13.unlinkSync(reconfigMarker);
+  const reconfigMarker = path14.join(os13.homedir(), ".aman-agent", ".reconfig");
+  if (fs14.existsSync(reconfigMarker)) {
+    fs14.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -4719,11 +4764,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os12.homedir();
-  const corePath = path13.join(home2, ".acore", "core.md");
-  if (fs13.existsSync(corePath)) return false;
-  fs13.mkdirSync(path13.join(home2, ".acore"), { recursive: true });
-  fs13.writeFileSync(corePath, [
+  const home2 = os13.homedir();
+  const corePath = path14.join(home2, ".acore", "core.md");
+  if (fs14.existsSync(corePath)) return false;
+  fs14.mkdirSync(path14.join(home2, ".acore"), { recursive: true });
+  fs14.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -4735,11 +4780,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path13.join(home2, ".arules");
-  const rulesPath = path13.join(rulesDir, "rules.md");
-  if (!fs13.existsSync(rulesPath)) {
-    fs13.mkdirSync(rulesDir, { recursive: true });
-    fs13.writeFileSync(rulesPath, [
+  const rulesDir = path14.join(home2, ".arules");
+  const rulesPath = path14.join(rulesDir, "rules.md");
+  if (!fs14.existsSync(rulesPath)) {
+    fs14.mkdirSync(rulesDir, { recursive: true });
+    fs14.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -4881,11 +4926,11 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   const aiName = getProfileAiName(profile);
+  await initMemory();
   const mcpManager = new McpManager();
   const mcpSpinner = p2.spinner();
   mcpSpinner.start("Connecting to MCP servers");
   await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
-  await mcpManager.connect("amem", "npx", ["-y", "@aman_asmuei/amem"]);
   if (config.mcpServers) {
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (name === "aman" || name === "amem") continue;
@@ -4896,25 +4941,16 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   mcpSpinner.stop("MCP connected");
   if (mcpTools.length > 0) {
     p2.log.success(`${mcpTools.length} MCP tools available`);
-    if (mcpTools.some((t) => t.name === "memory_consolidate")) {
+    {
       const memSpinner = p2.spinner();
       memSpinner.start("Consolidating memory");
       try {
-        const consolidateResult = await mcpManager.callTool("memory_consolidate", { dry_run: false });
-        if (consolidateResult && !consolidateResult.startsWith("Error")) {
-          try {
-            const report = JSON.parse(consolidateResult);
-            memSpinner.stop("Memory consolidated");
-            if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
-              p2.log.info(
-                `Memory health: ${report.healthScore ?? "?"}% ` + pc7.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
-              );
-            }
-          } catch {
-            memSpinner.stop("Memory consolidated");
-          }
-        } else {
-          memSpinner.stop("Memory consolidated");
+        const report = memoryConsolidate();
+        memSpinner.stop("Memory consolidated");
+        if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
+          p2.log.info(
+            `Memory health: ${report.healthScore ?? "?"}% ` + pc7.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
+          );
         }
       } catch {
         memSpinner.stop("Memory consolidation skipped");
@@ -4971,19 +5007,19 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p2.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  const home2 = os12.homedir();
-  fs13.mkdirSync(path13.join(home2, ".acore"), { recursive: true });
-  fs13.writeFileSync(path13.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os13.homedir();
+  fs14.mkdirSync(path14.join(home2, ".acore"), { recursive: true });
+  fs14.writeFileSync(path14.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
   p2.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs13.mkdirSync(path13.join(home2, ".arules"), { recursive: true });
-    fs13.writeFileSync(path13.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs14.mkdirSync(path14.join(home2, ".arules"), { recursive: true });
+    fs14.writeFileSync(path14.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p2.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs13.mkdirSync(path13.join(home2, ".aflow"), { recursive: true });
-    fs13.writeFileSync(path13.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs14.mkdirSync(path14.join(home2, ".aflow"), { recursive: true });
+    fs14.writeFileSync(path14.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p2.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }