@aman_asmuei/aman-agent 0.4.0 → 0.5.1

package/dist/index.js

@@ -13,7 +13,8 @@ var DEFAULT_HOOKS = {
   rulesCheck: true,
   workflowSuggest: true,
   evalPrompt: true,
-  autoSessionSave: true
+  autoSessionSave: true,
+  extractMemories: true
 };
 var CONFIG_DIR = path.join(os.homedir(), ".aman-agent");
 var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
@@ -462,6 +463,74 @@ function createOllamaClient(model, baseURL) {
 // src/mcp/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+// src/logger.ts
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+var LOG_DIR = path3.join(os3.homedir(), ".aman-agent");
+var LOG_PATH = path3.join(LOG_DIR, "debug.log");
+var MAX_LOG_SIZE = 1048576;
+function ensureDir() {
+  if (!fs3.existsSync(LOG_DIR)) {
+    fs3.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+function maybeRotate() {
+  try {
+    if (!fs3.existsSync(LOG_PATH)) return;
+    const stat = fs3.statSync(LOG_PATH);
+    if (stat.size >= MAX_LOG_SIZE) {
+      const backupPath = LOG_PATH + ".1";
+      if (fs3.existsSync(backupPath)) fs3.unlinkSync(backupPath);
+      fs3.renameSync(LOG_PATH, backupPath);
+    }
+  } catch {
+  }
+}
+function write(level, module, message, data) {
+  try {
+    ensureDir();
+    maybeRotate();
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      module,
+      message
+    };
+    if (data !== void 0) {
+      entry.data = data instanceof Error ? data.message : String(data);
+    }
+    fs3.appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+var log = {
+  debug: (module, message, data) => write("debug", module, message, data),
+  warn: (module, message, data) => write("warn", module, message, data),
+  error: (module, message, data) => write("error", module, message, data)
+};
+
+// src/retry.ts
+async function withRetry(fn, options) {
+  const { maxAttempts, baseDelay, retryable } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (!retryable(lastError) || attempt === maxAttempts) {
+        throw lastError;
+      }
+      const delay = baseDelay * Math.pow(2, attempt - 1) * (0.5 + Math.random() * 0.5);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/mcp/client.ts
 var McpManager = class {
   connections = [];
   tools = [];
@@ -483,7 +552,8 @@ var McpManager = class {
           serverName: name
         });
       }
-    } catch {
+    } catch (err) {
+      log.error("mcp", "Failed to connect to " + name + " MCP server", err);
       console.error(`  Warning: Could not connect to ${name} MCP server`);
     }
   }
@@ -496,10 +566,10 @@ var McpManager = class {
     const conn = this.connections.find((c) => c.name === tool.serverName);
     if (!conn) return `Error: server ${tool.serverName} not connected`;
     try {
-      const result = await conn.client.callTool({
-        name: toolName,
-        arguments: args
-      });
+      const result = await withRetry(
+        () => conn.client.callTool({ name: toolName, arguments: args }),
+        { maxAttempts: 2, baseDelay: 500, retryable: (err) => err.message.includes("ETIMEDOUT") || err.message.includes("timeout") }
+      );
       if (result.content && Array.isArray(result.content)) {
         return result.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n");
       }
@@ -512,7 +582,8 @@ var McpManager = class {
     for (const conn of this.connections) {
       try {
         await conn.client.close();
-      } catch {
+      } catch (err) {
+        log.debug("mcp", "Cleanup error disconnecting " + conn.name, err);
       }
     }
     this.connections = [];
@@ -522,20 +593,23 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
 import pc3 from "picocolors";
 
 // src/commands.ts
-import fs4 from "fs";
-import path4 from "path";
-import os4 from "os";
+import fs5 from "fs";
+import path5 from "path";
+import os5 from "os";
 import { execFileSync } from "child_process";
 import pc from "picocolors";
 
 // src/layers/parsers.ts
-import fs3 from "fs";
-import path3 from "path";
-import os3 from "os";
-var home = os3.homedir();
+import fs4 from "fs";
+import path4 from "path";
+import os4 from "os";
+var home = os4.homedir();
 var LAYER_FILES = [
   { name: "identity", dir: ".acore", file: "core.md" },
   { name: "rules", dir: ".arules", file: "rules.md" },
@@ -571,11 +645,11 @@ function getLayerSummary(name, content) {
 }
 function getEcosystemStatus(mcpToolCount, amemConnected) {
   const layers = LAYER_FILES.map((entry) => {
-    const filePath = path3.join(home, entry.dir, entry.file);
-    const exists = fs3.existsSync(filePath);
+    const filePath = path4.join(home, entry.dir, entry.file);
+    const exists = fs4.existsSync(filePath);
     let summary = "not configured";
     if (exists) {
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       summary = getLayerSummary(entry.name, content);
     }
     return { name: entry.name, exists, path: filePath, summary };
@@ -590,10 +664,10 @@ function getEcosystemStatus(mcpToolCount, amemConnected) {
 
 // src/commands.ts
 function readEcosystemFile(filePath, label) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     return pc.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs4.readFileSync(filePath, "utf-8").trim();
+  return fs5.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -614,9 +688,9 @@ async function mcpWrite(ctx, layer, tool, args) {
   return pc.green(result);
 }
 async function handleIdentityCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".acore", "core.md"), "identity (acore)");
+    const content = readEcosystemFile(path5.join(home2, ".acore", "core.md"), "identity (acore)");
     return { handled: true, output: content };
   }
   if (action === "update") {
@@ -640,9 +714,9 @@ async function handleIdentityCommand(action, args, ctx) {
   return { handled: true, output: pc.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
 }
 async function handleRulesCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".arules", "rules.md"), "guardrails (arules)");
+    const content = readEcosystemFile(path5.join(home2, ".arules", "rules.md"), "guardrails (arules)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -671,9 +745,9 @@ async function handleRulesCommand(action, args, ctx) {
   return { handled: true, output: pc.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path5.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -693,9 +767,9 @@ async function handleWorkflowsCommand(action, args, ctx) {
   return { handled: true, output: pc.yellow(`Unknown action: /workflows ${action}. Use /workflows [add|remove].`) };
 }
 async function handleToolsCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".akit", "kit.md"), "tools (akit)");
+    const content = readEcosystemFile(path5.join(home2, ".akit", "kit.md"), "tools (akit)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -718,9 +792,9 @@ async function handleToolsCommand(action, args, ctx) {
   return { handled: true, output: pc.yellow(`Unknown action: /tools ${action}. Use /tools [add|remove].`) };
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path5.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -740,9 +814,9 @@ async function handleSkillsCommand(action, args, ctx) {
   return { handled: true, output: pc.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os4.homedir();
+  const home2 = os5.homedir();
   if (!action) {
-    const content = readEcosystemFile(path4.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path5.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -833,6 +907,9 @@ function handleHelp() {
       `  ${pc.cyan("/memory")}       View recent memories [search|clear ...]`,
       `  ${pc.cyan("/status")}       Ecosystem dashboard`,
       `  ${pc.cyan("/doctor")}       Health check all layers`,
+      `  ${pc.cyan("/decisions")}    View decision log [<project>]`,
+      `  ${pc.cyan("/export")}       Export conversation to markdown`,
+      `  ${pc.cyan("/debug")}        Show debug log`,
       `  ${pc.cyan("/save")}         Save conversation to memory`,
       `  ${pc.cyan("/model")}        Show current LLM model`,
       `  ${pc.cyan("/update")}       Check for updates`,
@@ -846,9 +923,9 @@ function handleSave() {
   return { handled: true, saveConversation: true };
 }
 function handleReconfig() {
-  const configPath = path4.join(os4.homedir(), ".aman-agent", "config.json");
-  if (fs4.existsSync(configPath)) {
-    fs4.unlinkSync(configPath);
+  const configPath = path5.join(os5.homedir(), ".aman-agent", "config.json");
+  if (fs5.existsSync(configPath)) {
+    fs5.unlinkSync(configPath);
   }
   return {
     handled: true,
@@ -862,7 +939,7 @@ function handleReconfig() {
 function handleUpdate() {
   try {
     const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = JSON.parse(fs4.readFileSync(path4.join(__dirname, "..", "package.json"), "utf-8")).version;
+    const local = JSON.parse(fs5.readFileSync(path5.join(__dirname, "..", "package.json"), "utf-8")).version;
     if (current === local) {
       return { handled: true, output: `${pc.green("Up to date")} \u2014 v${local}` };
     }
@@ -891,6 +968,35 @@ function handleUpdate() {
     };
   }
 }
+async function handleDecisionsCommand(action, _args, ctx) {
+  if (!ctx.mcpManager) {
+    return { handled: true, output: pc.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: pc.red(result) };
+  }
+  return { handled: true, output: pc.bold("Decision Log:\n") + result };
+}
+function handleExportCommand() {
+  return { handled: true, exportConversation: true };
+}
+function handleDebugCommand() {
+  const logPath = path5.join(os5.homedir(), ".aman-agent", "debug.log");
+  if (!fs5.existsSync(logPath)) {
+    return { handled: true, output: pc.dim("No debug log found.") };
+  }
+  const content = fs5.readFileSync(logPath, "utf-8");
+  const lines = content.trim().split("\n");
+  const last20 = lines.slice(-20).join("\n");
+  return { handled: true, output: pc.bold("Debug Log (last 20 entries):\n") + pc.dim(last20) };
+}
 async function handleCommand(input, ctx) {
   const trimmed = input.trim();
   if (!trimmed.startsWith("/")) return { handled: false };
@@ -926,6 +1032,12 @@ async function handleCommand(input, ctx) {
       return handleDoctorCommand(ctx);
     case "save":
       return handleSave();
+    case "decisions":
+      return handleDecisionsCommand(action, args, ctx);
+    case "export":
+      return handleExportCommand();
+    case "debug":
+      return handleDebugCommand();
     case "update-config":
     case "reconfig":
       return handleReconfig();
@@ -940,6 +1052,24 @@ async function handleCommand(input, ctx) {
 // src/hooks.ts
 import pc2 from "picocolors";
 import * as p from "@clack/prompts";
+function getTimeContext() {
+  const now = /* @__PURE__ */ new Date();
+  const hour = now.getHours();
+  const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  const day = days[now.getDay()];
+  let period;
+  if (hour < 6) period = "late-night";
+  else if (hour < 12) period = "morning";
+  else if (hour < 17) period = "afternoon";
+  else if (hour < 21) period = "evening";
+  else period = "night";
+  const timeStr = now.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const dateStr = now.toLocaleDateString();
+  return `<time-context>
+Current time: ${dateStr} ${timeStr} (${period}, ${day})
+Adapt your tone naturally \u2014 don't announce the time, just be contextually appropriate.
+</time-context>`;
+}
 var isHookCall = false;
 async function onSessionStart(ctx) {
   let greeting = "";
@@ -951,7 +1081,8 @@ async function onSessionStart(ctx) {
       if (result && !result.startsWith("Error")) {
         greeting += result;
       }
-    } catch {
+    } catch (err) {
+      log.warn("hooks", "memory_context recall failed", err);
     } finally {
       isHookCall = false;
     }
@@ -964,11 +1095,26 @@ async function onSessionStart(ctx) {
         if (greeting) greeting += "\n";
         greeting += result;
       }
-    } catch {
+    } catch (err) {
+      log.warn("hooks", "identity_summary failed", err);
     } finally {
       isHookCall = false;
     }
   }
+  const timeContext = getTimeContext();
+  if (greeting) greeting += "\n" + timeContext;
+  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>";
+    }
+  } catch (err) {
+    log.debug("hooks", "reminder_check failed", err);
+  } finally {
+    isHookCall = false;
+  }
   if (greeting) {
     contextInjection = `<session-context>
 ${greeting}
@@ -1000,10 +1146,12 @@ async function onBeforeToolExec(toolName, toolArgs, ctx) {
           reason: parsed.violations.join("; ")
         };
       }
-    } catch {
+    } catch (err) {
+      log.debug("hooks", "rules_check parse failed", err);
     }
     return { allow: true };
-  } catch {
+  } catch (err) {
+    log.warn("hooks", "rules_check call failed", err);
     return { allow: true };
   } finally {
     isHookCall = false;
@@ -1035,7 +1183,8 @@ async function onWorkflowMatch(userInput, ctx) {
       }
     }
     return null;
-  } catch {
+  } catch (err) {
+    log.debug("hooks", "workflow_list failed", err);
     return null;
   } finally {
     isHookCall = false;
@@ -1054,7 +1203,8 @@ async function onSessionEnd(ctx, messages, sessionId) {
             role: msg.role,
             content: msg.content.slice(0, 5e3)
           });
-        } catch {
+        } catch (err) {
+          log.debug("hooks", "memory_log write failed for " + sessionId, err);
         } finally {
           isHookCall = false;
         }
@@ -1104,7 +1254,8 @@ async function onSessionEnd(ctx, messages, sessionId) {
         }
       }
     }
-  } catch {
+  } catch (err) {
+    log.warn("hooks", "session end hook failed", err);
   }
 }
 
@@ -1131,7 +1282,7 @@ function estimateTotalTokens(messages) {
 var MAX_CONVERSATION_TOKENS = 8e4;
 var KEEP_RECENT = 10;
 var KEEP_INITIAL = 2;
-function trimConversation(messages, _client) {
+async function trimConversation(messages, client) {
   const totalTokens = estimateTotalTokens(messages);
   if (totalTokens < MAX_CONVERSATION_TOKENS || messages.length <= KEEP_INITIAL + KEEP_RECENT) {
     return;
@@ -1139,20 +1290,39 @@ function trimConversation(messages, _client) {
   const initial = messages.slice(0, KEEP_INITIAL);
   const recent = messages.slice(-KEEP_RECENT);
   const middle = messages.slice(KEEP_INITIAL, messages.length - KEEP_RECENT);
-  const summaryParts = [];
-  for (const msg of middle) {
-    if (typeof msg.content === "string" && msg.content.length > 0) {
-      const preview = msg.content.slice(0, 150);
-      summaryParts.push(`[${msg.role}]: ${preview}${msg.content.length > 150 ? "..." : ""}`);
+  const middleText = middle.filter((m) => typeof m.content === "string" && m.content.length > 0).map((m) => `[${m.role}]: ${m.content.slice(0, 500)}`).slice(0, 30).join("\n");
+  let summaryText;
+  try {
+    const summaryPrompt = "Summarize the following conversation messages in 3-5 bullet points. Preserve: decisions made, user preferences expressed, action items, and key facts discussed. Be concise.\n\n" + middleText;
+    let fullText = "";
+    await client.chat(
+      "You are a concise summarizer. Return only bullet points, no preamble.",
+      [{ role: "user", content: summaryPrompt }],
+      (chunk) => {
+        if (chunk.type === "text" && chunk.text) fullText += chunk.text;
+      }
+    );
+    summaryText = `<conversation-summary>
+Summary of ${middle.length} earlier messages:
+
+${fullText}
+</conversation-summary>`;
+    log.debug("context", `Summarized ${middle.length} messages via LLM`);
+  } catch (err) {
+    log.warn("context", "LLM summarization failed, using fallback", err);
+    const summaryParts = [];
+    for (const msg of middle) {
+      if (typeof msg.content === "string" && msg.content.length > 0) {
+        const preview = msg.content.slice(0, 150);
+        summaryParts.push(`[${msg.role}]: ${preview}${msg.content.length > 150 ? "..." : ""}`);
+      }
     }
-  }
-  const summaryText = `<conversation-summary>
-The following is a summary of ${middle.length} earlier messages that were compressed to save context:
+    summaryText = `<conversation-summary>
+Summary of ${middle.length} earlier messages:
 
 ${summaryParts.slice(0, 20).join("\n")}
-${summaryParts.length > 20 ? `
-... and ${summaryParts.length - 20} more messages` : ""}
 </conversation-summary>`;
+  }
   messages.length = 0;
   messages.push(...initial);
   messages.push({ role: "user", content: summaryText });
@@ -1160,7 +1330,151 @@ ${summaryParts.length > 20 ? `
   messages.push(...recent);
 }
 
+// src/memory-extractor.ts
+var AUTO_STORE_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology"]);
+var CONFIRM_TYPES = /* @__PURE__ */ new Set(["decision", "correction"]);
+var VALID_TYPES = /* @__PURE__ */ new Set([...AUTO_STORE_TYPES, ...CONFIRM_TYPES]);
+var MIN_RESPONSE_LENGTH = 50;
+var MIN_TURNS_BETWEEN_EMPTY = 3;
+var EXTRACTION_PROMPT = `Analyze this conversation turn. Extract any information worth remembering long-term.
+
+Return a JSON array (empty [] if nothing worth storing):
+[{
+  "content": "what to remember \u2014 be specific and self-contained",
+  "type": "preference|fact|pattern|decision|correction|topology",
+  "tags": ["relevant", "tags"],
+  "confidence": 0.0-1.0,
+  "scope": "global"
+}]
+
+Type guide:
+- "preference" = user likes/dislikes/preferences
+- "fact" = objective information about systems, people, projects
+- "pattern" = recurring behavior, coding style, approach
+- "topology" = how systems/components connect to each other
+- "decision" = explicit choice between alternatives (requires confirmation)
+- "correction" = user correcting a prior wrong assumption (requires confirmation)
+
+Rules:
+- Only extract genuinely useful LONG-TERM information
+- Skip ephemeral things ("user asked about X" is NOT useful)
+- Be conservative \u2014 90% of turns produce nothing worth storing
+- Return ONLY the JSON array, no other text`;
+function shouldExtract(assistantResponse, turnsSinceLastExtraction, lastExtractionCount) {
+  if (lastExtractionCount > 0) return true;
+  if (assistantResponse.length < MIN_RESPONSE_LENGTH) return false;
+  if (turnsSinceLastExtraction < MIN_TURNS_BETWEEN_EMPTY) return false;
+  return true;
+}
+function parseExtractionResult(raw) {
+  try {
+    let cleaned = raw.trim();
+    const codeBlockMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+      cleaned = codeBlockMatch[1].trim();
+    }
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (item) => typeof item.content === "string" && item.content.length > 0 && typeof item.type === "string" && VALID_TYPES.has(item.type)
+    );
+  } catch {
+    return [];
+  }
+}
+async function extractMemories(userMessage, assistantResponse, client, mcpManager, state, confirmFn) {
+  if (!shouldExtract(assistantResponse, state.turnsSinceLastExtraction, state.lastExtractionCount)) {
+    state.turnsSinceLastExtraction++;
+    return 0;
+  }
+  try {
+    const conversationTurn = `User: ${userMessage.slice(0, 2e3)}
+
+Assistant: ${assistantResponse.slice(0, 2e3)}`;
+    let fullText = "";
+    await client.chat(
+      EXTRACTION_PROMPT,
+      [{ role: "user", content: conversationTurn }],
+      (chunk) => {
+        if (chunk.type === "text" && chunk.text) fullText += chunk.text;
+      }
+    );
+    const candidates = parseExtractionResult(fullText);
+    state.turnsSinceLastExtraction = 0;
+    state.lastExtractionCount = candidates.length;
+    if (candidates.length === 0) return 0;
+    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 {
+          }
+        }
+      } catch {
+      }
+      if (CONFIRM_TYPES.has(candidate.type)) {
+        const confirmed = await confirmFn(candidate.content);
+        if (!confirmed) continue;
+      }
+      try {
+        await mcpManager.callTool("memory_store", {
+          content: candidate.content,
+          type: candidate.type,
+          tags: candidate.tags,
+          confidence: candidate.confidence,
+          source: "auto-extraction",
+          scope: candidate.scope
+        });
+        stored++;
+        log.debug("extractor", "Stored " + candidate.type + ": " + candidate.content);
+      } catch (err) {
+        log.warn("extractor", "Failed to store: " + candidate.content, err);
+      }
+    }
+    return stored;
+  } catch (err) {
+    log.debug("extractor", "extraction failed", err);
+    state.turnsSinceLastExtraction = 0;
+    state.lastExtractionCount = 0;
+    return 0;
+  }
+}
+
 // src/agent.ts
+async function recallForMessage(input, mcpManager) {
+  try {
+    const result = await mcpManager.callTool("memory_recall", {
+      query: input,
+      limit: 5,
+      compact: true
+    });
+    if (!result || result.startsWith("Error") || result.includes("No memories found")) {
+      return null;
+    }
+    const tokenEstimate = Math.round(result.split(/\s+/).filter(Boolean).length * 1.3);
+    return {
+      text: `
+
+<relevant-memories>
+${result}
+</relevant-memories>`,
+      tokenEstimate
+    };
+  } catch (err) {
+    log.debug("agent", "memory recall failed", err);
+    return null;
+  }
+}
 function generateSessionId() {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => n.toString().padStart(2, "0");
@@ -1169,6 +1483,16 @@ function generateSessionId() {
 async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager, hooksConfig) {
   const messages = [];
   const sessionId = generateSessionId();
+  const extractorState = { turnsSinceLastExtraction: 0, lastExtractionCount: 0 };
+  const isRetryable = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed");
+  const onChunkHandler = (chunk) => {
+    if (chunk.type === "text" && chunk.text) {
+      process.stdout.write(chunk.text);
+    }
+    if (chunk.type === "done") {
+      process.stdout.write("\n");
+    }
+  };
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -1178,7 +1502,8 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
       try {
         const hookCtx = { mcpManager, config: hooksConfig };
         await onSessionEnd(hookCtx, messages, sessionId);
-      } catch {
+      } catch (err) {
+        log.debug("agent", "session end hook failed on SIGINT", err);
       }
     }
     console.log(pc3.dim("\nGoodbye.\n"));
@@ -1206,7 +1531,8 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
         messages.push({ role: "user", content: session.contextInjection });
         messages.push({ role: "assistant", content: "I have context from our previous sessions. How can I help?" });
       }
-    } catch {
+    } catch (err) {
+      log.warn("agent", "session start hook failed", err);
     }
   }
   while (true) {
@@ -1219,13 +1545,39 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
           try {
             const hookCtx = { mcpManager, config: hooksConfig };
             await onSessionEnd(hookCtx, messages, sessionId);
-          } catch {
+          } catch (err) {
+            log.debug("agent", "session end hook failed on quit", err);
           }
         }
         console.log(pc3.dim("\nGoodbye.\n"));
         rl.close();
         return;
       }
+      if (cmdResult.exportConversation) {
+        try {
+          const exportDir = path6.join(os6.homedir(), ".aman-agent", "exports");
+          fs6.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path6.join(exportDir, `${sessionId}.md`);
+          const lines = [
+            `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
+            `**Model:** ${model}`,
+            "",
+            "---",
+            ""
+          ];
+          for (const msg of messages) {
+            if (typeof msg.content === "string") {
+              const label = msg.role === "user" ? "**You:**" : `**${aiName}:**`;
+              lines.push(`${label} ${msg.content}`, "");
+            }
+          }
+          fs6.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          console.log(pc3.green(`Exported to ${exportPath}`));
+        } catch {
+          console.log(pc3.red("Failed to export conversation."));
+        }
+        continue;
+      }
       if (cmdResult.saveConversation && mcpManager) {
         try {
           await saveConversationToMemory(mcpManager, messages, sessionId);
@@ -1261,79 +1613,102 @@ ${wfMatch.steps}
             console.log(pc3.dim(`  Using "${wfMatch.name}" workflow.`));
           }
         }
-      } catch {
+      } catch (err) {
+        log.debug("agent", "workflow match failed", err);
       }
     }
-    trimConversation(messages, client);
+    await trimConversation(messages, client);
     messages.push({ role: "user", content: input });
+    let augmentedSystemPrompt = activeSystemPrompt;
+    if (mcpManager) {
+      const recall = await recallForMessage(input, mcpManager);
+      if (recall) {
+        augmentedSystemPrompt = activeSystemPrompt + recall.text;
+        process.stdout.write(pc3.dim(`  [memories: ~${recall.tokenEstimate} tokens]
+`));
+      }
+    }
     process.stdout.write(pc3.cyan(`
 ${aiName} > `));
     try {
-      let response = await client.chat(
-        activeSystemPrompt,
-        messages,
-        (chunk) => {
-          if (chunk.type === "text" && chunk.text) {
-            process.stdout.write(chunk.text);
-          }
-          if (chunk.type === "done") {
-            process.stdout.write("\n");
-          }
-        },
-        tools
+      let response = await withRetry(
+        () => client.chat(augmentedSystemPrompt, messages, onChunkHandler, tools),
+        { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable }
       );
       messages.push(response.message);
       while (response.toolUses.length > 0 && mcpManager) {
-        const toolResults = [];
-        for (const toolUse of response.toolUses) {
-          if (hooksConfig) {
-            const hookCtx = { mcpManager, config: hooksConfig };
-            const check = await onBeforeToolExec(toolUse.name, toolUse.input, hookCtx);
-            if (!check.allow) {
-              process.stdout.write(pc3.red(`  [BLOCKED: ${check.reason}]
+        const toolResults = await Promise.all(
+          response.toolUses.map(async (toolUse) => {
+            if (hooksConfig) {
+              const hookCtx = { mcpManager, config: hooksConfig };
+              const check = await onBeforeToolExec(toolUse.name, toolUse.input, hookCtx);
+              if (!check.allow) {
+                process.stdout.write(pc3.red(`  [BLOCKED: ${check.reason}]
+`));
+                return {
+                  type: "tool_result",
+                  tool_use_id: toolUse.id,
+                  content: `BLOCKED by guardrail: ${check.reason}`,
+                  is_error: true
+                };
+              }
+            }
+            process.stdout.write(pc3.dim(`  [using ${toolUse.name}...]
 `));
-              toolResults.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: `BLOCKED by guardrail: ${check.reason}`,
-                is_error: true
+            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(() => {
               });
-              continue;
             }
-          }
-          process.stdout.write(
-            pc3.dim(`  [using ${toolUse.name}...]
-`)
-          );
-          const result = await mcpManager.callTool(
-            toolUse.name,
-            toolUse.input
-          );
-          toolResults.push({
-            type: "tool_result",
-            tool_use_id: toolUse.id,
-            content: result
-          });
-        }
+            return {
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: result
+            };
+          })
+        );
         messages.push({
           role: "user",
           content: toolResults
         });
-        response = await client.chat(
-          activeSystemPrompt,
-          messages,
-          (chunk) => {
-            if (chunk.type === "text" && chunk.text) {
-              process.stdout.write(chunk.text);
-            }
-            if (chunk.type === "done") {
-              process.stdout.write("\n");
-            }
-          },
-          tools
+        response = await withRetry(
+          () => client.chat(augmentedSystemPrompt, messages, onChunkHandler, tools),
+          { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable }
         );
         messages.push(response.message);
       }
+      if (mcpManager && 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 confirmFn = async (content) => {
+            return new Promise((resolve) => {
+              rl.question(
+                pc3.dim(`  Remember: "${content}"? (y/N) `),
+                (answer) => resolve(answer.toLowerCase() === "y")
+              );
+            });
+          };
+          const count = await extractMemories(
+            input,
+            assistantText,
+            client,
+            mcpManager,
+            extractorState,
+            confirmFn
+          );
+          if (count > 0) {
+            process.stdout.write(pc3.dim(`  [${count} memory${count > 1 ? "ies" : ""} stored]
+`));
+          }
+        }
+      } else {
+        extractorState.turnsSinceLastExtraction++;
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error occurred";
       console.error(pc3.red(`
@@ -1352,15 +1727,16 @@ async function saveConversationToMemory(mcpManager, messages, sessionId) {
         role: msg.role,
         content: msg.content.slice(0, 5e3)
       });
-    } catch {
+    } catch (err) {
+      log.debug("agent", "memory_log write failed", err);
     }
   }
 }
 
 // src/index.ts
-import fs5 from "fs";
-import path5 from "path";
-import os5 from "os";
+import fs7 from "fs";
+import path7 from "path";
+import os7 from "os";
 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).action(async (options) => {
   p2.intro(pc4.bold("aman agent") + pc4.dim(" \u2014 starting your AI companion"));
@@ -1472,10 +1848,10 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   p2.log.info(`Model: ${pc4.dim(model)}`);
-  const corePath = path5.join(os5.homedir(), ".acore", "core.md");
+  const corePath = path7.join(os7.homedir(), ".acore", "core.md");
   let aiName = "Assistant";
-  if (fs5.existsSync(corePath)) {
-    const content = fs5.readFileSync(corePath, "utf-8");
+  if (fs7.existsSync(corePath)) {
+    const content = fs7.readFileSync(corePath, "utf-8");
     const match = content.match(/^# (.+)$/m);
     if (match) aiName = match[1];
   }
@@ -1487,6 +1863,23 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   const mcpTools = mcpManager.getTools();
   if (mcpTools.length > 0) {
     p2.log.success(`${mcpTools.length} MCP tools available`);
+    if (mcpTools.some((t) => t.name === "memory_consolidate")) {
+      try {
+        const consolidateResult = await mcpManager.callTool("memory_consolidate", { dry_run: false });
+        if (consolidateResult && !consolidateResult.startsWith("Error")) {
+          try {
+            const report = JSON.parse(consolidateResult);
+            if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
+              p2.log.info(
+                `Memory health: ${report.healthScore ?? "?"}% ` + pc4.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
+              );
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
   } else {
     p2.log.info(
       "No MCP tools connected (install aman-mcp or amem for tool support)"