@aman_asmuei/aman-agent 0.16.2 → 0.17.1

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,151 @@ function getEcosystemStatus(mcpToolCount, amemConnected) {
   };
 }
 
-// src/profile-templates.ts
-import fs5 from "fs";
+// src/memory.ts
+import {
+  createDatabase,
+  recall,
+  buildContext,
+  storeMemory,
+  consolidateMemories,
+  cosineSimilarity,
+  preloadEmbeddings,
+  buildVectorIndex,
+  recallMemories,
+  generateEmbedding,
+  getVectorIndex
+} 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() {
+  const all = getDb().checkReminders();
+  return all.filter((r) => r.scope === "global" || r.scope === currentProject);
+}
+async function memoryForget(opts) {
+  const db2 = getDb();
+  if (opts.id) {
+    const fullId = db2.resolveId(opts.id) ?? opts.id;
+    const memory = db2.getById(fullId);
+    if (!memory) return { deleted: 0, message: `Memory ${opts.id} not found.` };
+    db2.deleteMemory(fullId);
+    const vecIdx = getVectorIndex();
+    if (vecIdx) vecIdx.remove(fullId);
+    return { deleted: 1, message: `Deleted: "${memory.content}" (${memory.type})` };
+  }
+  if (opts.type) {
+    const all = db2.getAllForProject(currentProject);
+    const matches = all.filter((m) => m.type === opts.type);
+    if (matches.length === 0) return { deleted: 0, message: `No memories of type "${opts.type}" found.` };
+    const vecIdx = getVectorIndex();
+    for (const m of matches) {
+      db2.deleteMemory(m.id);
+      if (vecIdx) vecIdx.remove(m.id);
+    }
+    return { deleted: matches.length, message: `Deleted ${matches.length} "${opts.type}" memories.` };
+  }
+  if (opts.query) {
+    const queryEmbedding = await generateEmbedding(opts.query);
+    const matches = recallMemories(db2, { query: opts.query, queryEmbedding, limit: 50, minConfidence: 0, scope: currentProject });
+    if (matches.length === 0) return { deleted: 0, message: `No memories found matching "${opts.query}".` };
+    const vecIdx = getVectorIndex();
+    for (const m of matches) {
+      db2.deleteMemory(m.id);
+      if (vecIdx) vecIdx.remove(m.id);
+    }
+    return { deleted: matches.length, message: `Deleted ${matches.length} memories matching "${opts.query}".` };
+  }
+  return { deleted: 0, message: "Provide an id, type, or query to forget." };
+}
+function memoryConsolidate(dryRun = false) {
+  return consolidateMemories(getDb(), cosineSimilarity, {
+    dryRun,
+    maxStaleDays: 90,
+    minConfidence: 0.3,
+    minAccessCount: 0
+  });
+}
+function isMemoryInitialized() {
+  return db !== null;
+}
+function memoryStats() {
+  return getDb().getStats();
+}
+function memoryExport() {
+  return getDb().getAllForProject(currentProject);
+}
+function memorySince(hours) {
+  const since = Date.now() - hours * 60 * 60 * 1e3;
+  const all = getDb().getMemoriesSince(since);
+  return all.filter((m) => m.scope === "global" || m.scope === currentProject);
+}
+function memorySearch(query, limit) {
+  return getDb().fullTextSearch(query, limit, currentProject);
+}
+function reminderSet(content, dueAt) {
+  return getDb().insertReminder(content, dueAt ?? null, currentProject);
+}
+function reminderList(includeCompleted) {
+  return getDb().listReminders(includeCompleted, currentProject);
+}
+function reminderComplete(id) {
+  const fullId = getDb().resolveReminderId(id) ?? id;
+  return getDb().completeReminder(fullId);
+}
+
+// src/profile-templates.ts
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
 var BUILT_IN_PROFILES = [
   {
     name: "coder",
@@ -965,9 +1106,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 +1122,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 +1254,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 +1299,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 +1526,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 +1568,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 +1610,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,16 +1721,17 @@ 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();
   const parts = trimmed.split(/\s+/);
   const base = parts[0].toLowerCase().replace(/^\//, "");
-  const action = parts.length > 1 ? parts[1].toLowerCase() : void 0;
+  let action = parts.length > 1 ? parts[1].toLowerCase() : void 0;
+  if (action === "--help" || action === "-h") action = "help";
   const args = parts.slice(2);
   return { base, action, args };
 }
@@ -1604,9 +1746,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") {
@@ -1627,12 +1769,19 @@ async function handleIdentityCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "identity", "identity_update_section", { section, content });
     return { handled: true, output };
   }
-  return { handled: true, output: pc3.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Identity commands:"),
+      `  ${pc3.cyan("/identity")}                  View current identity`,
+      `  ${pc3.cyan("/identity update")} <section>  Update a section`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /identity ${action}. Try /identity --help`) };
 }
 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") {
@@ -1658,12 +1807,21 @@ async function handleRulesCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "rules", "rules_toggle", { category: args[0], index: parseInt(args[1], 10) });
     return { handled: true, output };
   }
-  return { handled: true, output: pc3.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Rules commands:"),
+      `  ${pc3.cyan("/rules")}                         View current rules`,
+      `  ${pc3.cyan("/rules add")} <category> <text>    Add a rule`,
+      `  ${pc3.cyan("/rules remove")} <category> <idx>  Remove a rule`,
+      `  ${pc3.cyan("/rules toggle")} <category> <idx>  Toggle a rule`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /rules ${action}. Try /rules --help`) };
 }
 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") {
@@ -1680,7 +1838,15 @@ async function handleWorkflowsCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "workflows", "workflow_remove", { name: args.join(" ") });
     return { handled: true, output };
   }
-  return { handled: true, output: pc3.yellow(`Unknown action: /workflows ${action}. Use /workflows [add|remove].`) };
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Workflow commands:"),
+      `  ${pc3.cyan("/workflows")}              View current workflows`,
+      `  ${pc3.cyan("/workflows add")} <name>    Add a workflow`,
+      `  ${pc3.cyan("/workflows remove")} <name> Remove a workflow`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /workflows ${action}. Try /workflows --help`) };
 }
 var AKIT_REGISTRY = [
   { name: "web-search", description: "Search the web for current information", category: "search", mcp: { package: "@anthropic/web-search", command: "npx", args: ["-y", "@anthropic/web-search"] } },
@@ -1702,38 +1868,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 +2049,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") {
@@ -1902,12 +2068,20 @@ async function handleSkillsCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "skills", "skill_uninstall", { name: args.join(" ") });
     return { handled: true, output };
   }
-  return { handled: true, output: pc3.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Skills commands:"),
+      `  ${pc3.cyan("/skills")}                    View installed skills`,
+      `  ${pc3.cyan("/skills install")} <name>      Install a skill`,
+      `  ${pc3.cyan("/skills uninstall")} <name>    Uninstall a skill`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 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,98 +2096,208 @@ 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) };
+  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help"].includes(action)) {
+    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) {
-      return { handled: true, output: pc3.yellow("Usage: /memory clear <category>") };
+      return { handled: true, output: pc3.yellow("Usage: /memory clear <query>  \u2014 delete memories matching a search query\n       /memory clear --type <type>  \u2014 delete all memories of a type (correction|decision|pattern|preference|topology|fact)") };
+    }
+    try {
+      if (args[0] === "--type" && args[1]) {
+        const result2 = await memoryForget({ query: args[1], type: args[1] });
+        return { handled: true, output: result2.deleted > 0 ? pc3.green(result2.message) : pc3.dim(result2.message) };
+      }
+      const result = await memoryForget({ query: args.join(" ") });
+      return { handled: true, output: result.deleted > 0 ? pc3.green(result.message) : pc3.dim(result.message) };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
-    const output = await mcpWrite(ctx, "memory", "memory_forget", { category: args[0] });
-    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.") };
     }
   }
-  return { handled: true, output: pc3.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear|timeline].`) };
+  if (action === "stats") {
+    try {
+      const stats = memoryStats();
+      const lines = [pc3.bold("Memory Statistics:"), ""];
+      lines.push(`  Total memories: ${pc3.bold(String(stats.total))}`);
+      if (Object.keys(stats.byType).length > 0) {
+        lines.push("");
+        lines.push(`  ${pc3.dim("By type:")}`);
+        for (const [type, count] of Object.entries(stats.byType)) {
+          lines.push(`    ${type.padEnd(16)} ${count}`);
+        }
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "export") {
+    try {
+      const format = args[0] === "json" ? "json" : "markdown";
+      const memories = memoryExport();
+      if (memories.length === 0) {
+        return { handled: true, output: pc3.dim("No memories to export.") };
+      }
+      if (format === "json") {
+        const jsonOut = memories.map((m) => ({ id: m.id, type: m.type, content: m.content, tags: m.tags, confidence: m.confidence, createdAt: m.createdAt, tier: m.tier }));
+        return { handled: true, output: JSON.stringify(jsonOut, null, 2) };
+      }
+      const lines = [`# Memory Export (${memories.length} memories)`, ""];
+      for (const m of memories) {
+        const date = new Date(m.createdAt).toLocaleDateString();
+        const tags = m.tags.length > 0 ? ` [${m.tags.map((t) => `#${t}`).join(", ")}]` : "";
+        lines.push(`- **[${m.type}]** ${m.content}${tags} ${pc3.dim(`(${date}, ${Math.round(m.confidence * 100)}%)`)}`);
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "since") {
+    try {
+      let hours = 24;
+      if (args[0]) {
+        const match = args[0].match(/^(\d+)(h|d|w)$/);
+        if (match) {
+          const value = parseInt(match[1], 10);
+          const unit = match[2];
+          if (unit === "h") hours = value;
+          else if (unit === "d") hours = value * 24;
+          else if (unit === "w") hours = value * 24 * 7;
+        } else {
+          return { handled: true, output: pc3.yellow("Usage: /memory since <Nh|Nd|Nw>  (e.g., 24h, 7d, 1w)") };
+        }
+      }
+      const memories = memorySince(hours);
+      if (memories.length === 0) {
+        return { handled: true, output: pc3.dim(`No memories in the last ${args[0] || "24h"}.`) };
+      }
+      const lines = [pc3.bold(`Memories since ${args[0] || "24h"} (${memories.length}):`), ""];
+      for (const m of memories) {
+        const age = Math.round((Date.now() - m.createdAt) / 36e5);
+        const ageStr = age < 1 ? "<1h ago" : `${age}h ago`;
+        lines.push(`  ${pc3.dim(ageStr.padEnd(10))} [${m.type}] ${m.content}`);
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "fts") {
+    if (args.length < 1) {
+      return { handled: true, output: pc3.yellow("Usage: /memory fts <query...>  \u2014 full-text search") };
+    }
+    try {
+      const query = args.join(" ");
+      const results = memorySearch(query, 20);
+      if (results.length === 0) {
+        return { handled: true, output: pc3.dim(`No results for full-text search: "${query}".`) };
+      }
+      const lines = [pc3.bold(`FTS results for "${query}" (${results.length}):`), ""];
+      for (const m of results) {
+        const tags = m.tags.length > 0 ? ` ${pc3.dim(m.tags.map((t) => `#${t}`).join(" "))}` : "";
+        lines.push(`  [${m.type}] ${m.content}${tags}`);
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Memory commands:"),
+      `  ${pc3.cyan("/memory")}                    View recent context`,
+      `  ${pc3.cyan("/memory")} <topic>             Context for a topic`,
+      `  ${pc3.cyan("/memory search")} <query>      Search memories (semantic)`,
+      `  ${pc3.cyan("/memory fts")} <query>          Full-text search (FTS5)`,
+      `  ${pc3.cyan("/memory since")} <Nh|Nd|Nw>    Memories from time window`,
+      `  ${pc3.cyan("/memory stats")}               Show memory statistics`,
+      `  ${pc3.cyan("/memory export")} [json]        Export all memories`,
+      `  ${pc3.cyan("/memory timeline")}            View memory timeline`,
+      `  ${pc3.cyan("/memory clear")} <query>        Delete matching memories`,
+      `  ${pc3.cyan("/memory clear --type")} <type>  Delete all of a type`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /memory ${action}. Try /memory --help`) };
 }
 function handleStatusCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
-  const amemConnected = mcpToolCount > 0;
+  const amemConnected = isMemoryInitialized();
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
   const lines = [pc3.bold("Aman Ecosystem Dashboard"), ""];
   for (const layer of status.layers) {
@@ -2029,7 +2313,7 @@ function handleStatusCommand(ctx) {
 }
 function handleDoctorCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
-  const amemConnected = mcpToolCount > 0;
+  const amemConnected = isMemoryInitialized();
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
   const lines = [pc3.bold("Aman Health Check"), ""];
   let healthy = 0;
@@ -2063,7 +2347,7 @@ function handleDoctorCommand(ctx) {
   }
   lines.push(`  ${status.amemConnected ? pc3.green("\u2713") : pc3.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc3.green("connected") : pc3.red("not connected")}`);
   if (!status.amemConnected) {
-    lines.push(`    ${pc3.dim("\u2192 Fix: npx @aman_asmuei/amem")}`);
+    lines.push(`    ${pc3.dim("\u2192 Fix: restart aman-agent (memory initializes automatically)")}`);
     fixes++;
   } else {
     healthy++;
@@ -2085,7 +2369,8 @@ function handleHelp() {
       `  ${pc3.cyan("/akit")}         Manage tools [add|remove <tool>]`,
       `  ${pc3.cyan("/skills")}       View skills [install|uninstall ...]`,
       `  ${pc3.cyan("/eval")}         View evaluation [milestone ...]`,
-      `  ${pc3.cyan("/memory")}       View recent memories [search|clear|timeline]`,
+      `  ${pc3.cyan("/memory")}       View recent memories [search|fts|since|stats|export|clear|timeline]`,
+      `  ${pc3.cyan("/reminder")}     Manage reminders [set|check|done]`,
       `  ${pc3.cyan("/status")}       Ecosystem dashboard`,
       `  ${pc3.cyan("/doctor")}       Health check all layers`,
       `  ${pc3.cyan("/decisions")}    View decision log [<project>]`,
@@ -2094,7 +2379,7 @@ function handleHelp() {
       `  ${pc3.cyan("/save")}         Save conversation to memory`,
       `  ${pc3.cyan("/model")}        Show current LLM model`,
       `  ${pc3.cyan("/update")}       Check for updates`,
-      `  ${pc3.cyan("/reconfig")}     Reset LLM config`,
+      `  ${pc3.cyan("/reset")}       Full reset [all|memory|config|identity|rules]`,
       `  ${pc3.cyan("/clear")}        Clear conversation history`,
       `  ${pc3.cyan("/quit")}         Exit`
     ].join("\n")
@@ -2103,27 +2388,62 @@ function handleHelp() {
 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);
+function handleReset(action) {
+  const dirs = {
+    config: path9.join(os9.homedir(), ".aman-agent"),
+    memory: path9.join(os9.homedir(), ".amem"),
+    identity: path9.join(os9.homedir(), ".acore"),
+    rules: path9.join(os9.homedir(), ".arules")
+  };
+  if (action === "help" || !action) {
+    return {
+      handled: true,
+      output: [
+        pc3.bold("Reset options:"),
+        `  ${pc3.cyan("/reset all")}        Full reset \u2014 config, memory, identity, rules`,
+        `  ${pc3.cyan("/reset memory")}     Clear all memories only`,
+        `  ${pc3.cyan("/reset config")}     Reset LLM config only`,
+        `  ${pc3.cyan("/reset identity")}   Reset persona/identity only`,
+        `  ${pc3.cyan("/reset rules")}      Reset guardrails only`,
+        "",
+        pc3.dim("Directories:"),
+        ...Object.entries(dirs).map(([k, v]) => `  ${k}: ${pc3.dim(v)}`)
+      ].join("\n")
+    };
+  }
+  const targets = action === "all" ? ["config", "memory", "identity", "rules"] : [action];
+  if (!targets.every((t) => t in dirs)) {
+    return { handled: true, output: pc3.red(`Unknown target: ${action}. Use /reset help`) };
+  }
+  const removed = [];
+  for (const target of targets) {
+    const dir = dirs[target];
+    if (fs9.existsSync(dir)) {
+      fs9.rmSync(dir, { recursive: true, force: true });
+      removed.push(target);
+    }
+  }
+  if (targets.includes("config")) {
+    const configDir = dirs.config;
+    fs9.mkdirSync(configDir, { recursive: true });
+    fs9.writeFileSync(path9.join(configDir, ".reconfig"), "", "utf-8");
+  }
+  if (removed.length === 0) {
+    return { handled: true, output: pc3.dim("Nothing to reset \u2014 directories don't exist.") };
   }
-  fs8.mkdirSync(configDir, { recursive: true });
-  fs8.writeFileSync(path8.join(configDir, ".reconfig"), "", "utf-8");
   return {
     handled: true,
     quit: true,
     output: [
-      pc3.green("Config reset."),
-      "Next run will prompt you to choose your LLM provider."
+      pc3.green(`Reset complete: ${removed.join(", ")}`),
+      "Restart aman-agent to begin fresh."
     ].join("\n")
   };
 }
 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 +2472,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 +2689,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 +2713,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 +2730,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 +2752,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 +2761,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 +2772,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":
@@ -2566,6 +2881,86 @@ function handlePlanCommand(action, args) {
       return { handled: true, output: pc3.yellow(`Unknown plan action: ${action}. Try /plan help`) };
   }
 }
+async function handleReminderCommand(action, args) {
+  if (!action || action === "list") {
+    try {
+      const reminders = reminderList();
+      if (reminders.length === 0) return { handled: true, output: pc3.dim("No reminders.") };
+      const lines = [pc3.bold(`Reminders (${reminders.length}):`), ""];
+      for (const r of reminders) {
+        const status = r.completed ? pc3.green("[done]") : pc3.yellow("[todo]");
+        const due = r.dueAt ? ` ${pc3.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
+        lines.push(`  ${status} ${r.content}${due} ${pc3.dim(`(${r.id.slice(0, 8)})`)}`);
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "set" || action === "add") {
+    if (args.length === 0) return { handled: true, output: pc3.yellow("Usage: /reminder set <text> [--due <time>]\n  Time formats: 1h, 2d, 1w, or ISO date (2026-04-10)") };
+    let dueAt;
+    const dueIdx = args.indexOf("--due");
+    let contentArgs = args;
+    if (dueIdx >= 0 && args[dueIdx + 1]) {
+      const dueStr = args[dueIdx + 1];
+      contentArgs = [...args.slice(0, dueIdx), ...args.slice(dueIdx + 2)];
+      const relMatch = dueStr.match(/^(\d+)(h|d|w)$/);
+      if (relMatch) {
+        const num = parseInt(relMatch[1], 10);
+        const unit = relMatch[2];
+        const ms = unit === "h" ? num * 36e5 : unit === "d" ? num * 864e5 : num * 6048e5;
+        dueAt = Date.now() + ms;
+      } else {
+        const parsed = Date.parse(dueStr);
+        if (!isNaN(parsed)) dueAt = parsed;
+      }
+    }
+    const content = contentArgs.join(" ");
+    if (!content) return { handled: true, output: pc3.yellow("Usage: /reminder set <text> [--due <time>]") };
+    try {
+      const id = reminderSet(content, dueAt);
+      const dueInfo = dueAt ? ` (due: ${new Date(dueAt).toLocaleDateString()})` : "";
+      return { handled: true, output: pc3.green(`Reminder set: "${content}"${dueInfo} (ID: ${id.slice(0, 8)})`) };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "done" || action === "complete") {
+    if (!args[0]) return { handled: true, output: pc3.yellow("Usage: /reminder done <id>") };
+    try {
+      const result = reminderComplete(args[0]);
+      return { handled: true, output: result ? pc3.green("Reminder completed.") : pc3.yellow("Reminder not found.") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "check") {
+    try {
+      const reminders = reminderCheck();
+      if (reminders.length === 0) return { handled: true, output: pc3.dim("No pending reminders.") };
+      const lines = [pc3.bold("Pending Reminders:"), ""];
+      for (const r of reminders) {
+        const icon = r.status === "overdue" ? pc3.red("!!!") : r.status === "today" ? pc3.yellow("(!)") : pc3.dim("( )");
+        const due = r.dueAt ? ` ${pc3.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
+        lines.push(`  ${icon} ${r.content}${due} ${pc3.dim(`[${r.status}]`)}`);
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "help") {
+    return { handled: true, output: [
+      pc3.bold("Reminder commands:"),
+      `  ${pc3.cyan("/reminder")}                List all reminders`,
+      `  ${pc3.cyan("/reminder set")} <text>      Create a reminder [--due 1h|2d|1w|date]`,
+      `  ${pc3.cyan("/reminder check")}           Show overdue/upcoming`,
+      `  ${pc3.cyan("/reminder done")} <id>       Mark as completed`
+    ].join("\n") };
+  }
+  return { handled: true, output: pc3.yellow(`Unknown action: /reminder ${action}. Try /reminder --help`) };
+}
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
   "exit",
@@ -2587,8 +2982,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "decisions",
   "export",
   "debug",
-  "update-config",
-  "reconfig",
+  "reset",
+  "reminder",
   "update",
   "upgrade",
   "plan",
@@ -2639,9 +3034,8 @@ async function handleCommand(input, ctx) {
       return handleExportCommand();
     case "debug":
       return handleDebugCommand();
-    case "update-config":
-    case "reconfig":
-      return handleReconfig();
+    case "reset":
+      return handleReset(action);
     case "plan":
       return handlePlanCommand(action, args);
     case "profile":
@@ -2650,6 +3044,8 @@ async function handleCommand(input, ctx) {
       return handleDelegateCommand(action, args, ctx);
     case "team":
       return handleTeamCommand(action, args, ctx);
+    case "reminder":
+      return handleReminderCommand(action, args);
     case "update":
     case "upgrade":
       return handleUpdate();
@@ -2661,8 +3057,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 = [
@@ -2865,16 +3261,18 @@ async function onSessionStart(ctx) {
   let firstRun = false;
   let resumeTopic;
   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")) {
+  if (!isMemoryInitialized()) {
+    firstRun = false;
+  } else {
+    try {
+      isHookCall = true;
+      const recallResult = await memoryRecall("*", { limit: 1 });
+      firstRun = recallResult.total === 0;
+    } catch {
       firstRun = true;
+    } finally {
+      isHookCall = false;
     }
-  } catch {
-    firstRun = true;
-  } finally {
-    isHookCall = false;
   }
   if (firstRun) {
     contextInjection = `<first-session>
@@ -2900,9 +3298,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 +3331,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 +3451,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 +3479,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 +3500,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 +3630,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 +3647,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 +4038,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 +4062,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,
@@ -3858,7 +4246,7 @@ var BackgroundTaskManager = class {
 // src/errors.ts
 var ERROR_MAPPINGS = [
   { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
-  { pattern: /401|unauthorized/i, message: "API key invalid. Run /reconfig to fix." },
+  { pattern: /401|unauthorized/i, message: "API key invalid. Run /reset config to fix." },
   { pattern: /403|forbidden/i, message: "API key doesn't have access to this model. Try a different model with --model." },
   { pattern: /fetch failed|network/i, message: "Network error. Check your internet connection." },
   { pattern: /ECONNREFUSED/i, message: "Can't reach the API. Are you behind a proxy or firewall?" },
@@ -3876,9 +4264,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 +4304,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 +4317,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 +4508,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 +4524,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 +4650,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 +4676,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 +4686,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 +4695,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 +4704,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 +4716,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 +4771,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 +4877,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 +4905,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 +4924,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 +4941,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 +4954,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 +5065,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 +5096,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 +5112,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",
@@ -4754,7 +5131,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.1.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.17.1").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p2.intro(pc7.bold("aman agent") + pc7.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -4763,7 +5140,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
       config = detected;
       const providerLabel = detected.provider === "anthropic" ? "Anthropic API key" : detected.provider === "openai" ? "OpenAI API key" : "Ollama";
       p2.log.success(`Auto-detected ${providerLabel}. Using ${pc7.bold(detected.model)}.`);
-      p2.log.info(pc7.dim("Change anytime with /reconfig"));
+      p2.log.info(pc7.dim("Change anytime with /reset config"));
       saveConfig(config);
     } else {
       p2.log.info("First-time setup \u2014 configure your LLM connection.");
@@ -4881,11 +5258,30 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   const aiName = getProfileAiName(profile);
+  try {
+    await initMemory();
+  } catch (err) {
+    p2.log.warning(`Memory initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (isMemoryInitialized()) {
+    const memSpinner = p2.spinner();
+    memSpinner.start("Consolidating memory");
+    try {
+      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");
+    }
+  }
   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,33 +5292,9 @@ 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");
-        }
-      } catch {
-        memSpinner.stop("Memory consolidation skipped");
-      }
-    }
   } else {
     p2.log.info(
-      "No MCP tools connected (install aman-mcp or amem for tool support)"
+      "No MCP tools connected (install aman-mcp for tool support)"
     );
   }
   const toolDefs = mcpTools.map((t) => ({
@@ -4971,19 +5343,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`);
   }