@aman_asmuei/aman-agent 0.17.0 → 0.17.2

package/dist/index.js

@@ -232,7 +232,7 @@ function toAnthropicMessages(messages) {
 function createAnthropicClient(apiKey, model) {
   const client = new Anthropic({ apiKey });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
+    async chat(systemPrompt, messages, onChunk, tools, options) {
       const anthropicMessages = toAnthropicMessages(messages);
       const hasTools = tools && tools.length > 0;
       try {
@@ -242,7 +242,7 @@ function createAnthropicClient(apiKey, model) {
         let currentBlockIndex = -1;
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 8192,
           system: systemPrompt,
           messages: anthropicMessages,
           stream: true
@@ -330,7 +330,9 @@ function createAnthropicClient(apiKey, model) {
 
 // src/llm/openai.ts
 import OpenAI from "openai";
-function toOpenAIMessages(systemPrompt, messages) {
+
+// src/llm/openai-compat.ts
+function toOpenAICompatibleMessages(systemPrompt, messages) {
   const result = [
     { role: "system", content: systemPrompt }
   ];
@@ -398,18 +400,20 @@ function toOpenAIMessages(systemPrompt, messages) {
   }
   return result;
 }
+
+// src/llm/openai.ts
 function createOpenAIClient(apiKey, model) {
   const client = new OpenAI({ apiKey });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
-      const openaiMessages = toOpenAIMessages(systemPrompt, messages);
+    async chat(systemPrompt, messages, onChunk, tools, options) {
+      const openaiMessages = toOpenAICompatibleMessages(systemPrompt, messages);
       const hasTools = tools && tools.length > 0;
       try {
         let fullText = "";
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 8192,
           messages: openaiMessages,
           stream: true
         };
@@ -495,74 +499,6 @@ function createOpenAIClient(apiKey, model) {
 
 // src/llm/ollama.ts
 import OpenAI2 from "openai";
-function toOllamaMessages(systemPrompt, messages) {
-  const result = [
-    { role: "system", content: systemPrompt }
-  ];
-  for (const m of messages) {
-    if (typeof m.content === "string") {
-      result.push({
-        role: m.role,
-        content: m.content
-      });
-    } else if (m.role === "assistant") {
-      const textParts = m.content.filter((b) => b.type === "text");
-      const toolUseParts = m.content.filter((b) => b.type === "tool_use");
-      const text2 = textParts.map((b) => "text" in b ? b.text : "").join("");
-      if (toolUseParts.length > 0) {
-        result.push({
-          role: "assistant",
-          content: text2 || null,
-          tool_calls: toolUseParts.map((b) => ({
-            id: "id" in b ? b.id : "",
-            type: "function",
-            function: {
-              name: "name" in b ? b.name : "",
-              arguments: JSON.stringify("input" in b ? b.input : {})
-            }
-          }))
-        });
-      } else {
-        result.push({ role: "assistant", content: text2 });
-      }
-    } else if (m.role === "user") {
-      const toolResults = m.content.filter((b) => b.type === "tool_result");
-      if (toolResults.length > 0) {
-        for (const tr of toolResults) {
-          if (tr.type === "tool_result") {
-            result.push({
-              role: "tool",
-              tool_call_id: tr.tool_use_id,
-              content: tr.content
-            });
-          }
-        }
-      } else {
-        const hasImages = m.content.some((b) => b.type === "image");
-        if (hasImages) {
-          const parts = [];
-          for (const b of m.content) {
-            if (b.type === "text") {
-              parts.push({ type: "text", text: b.text });
-            } else if (b.type === "image") {
-              parts.push({
-                type: "image_url",
-                image_url: {
-                  url: `data:${b.source.media_type};base64,${b.source.data}`
-                }
-              });
-            }
-          }
-          result.push({ role: "user", content: parts });
-        } else {
-          const text2 = m.content.map((b) => "text" in b ? b.text : "").join("");
-          result.push({ role: "user", content: text2 });
-        }
-      }
-    }
-  }
-  return result;
-}
 function createOllamaClient(model, baseURL) {
   const client = new OpenAI2({
     baseURL: baseURL || "http://localhost:11434/v1",
@@ -570,15 +506,15 @@ function createOllamaClient(model, baseURL) {
     // Ollama doesn't require a real key
   });
   return {
-    async chat(systemPrompt, messages, onChunk, tools) {
-      const ollamaMessages = toOllamaMessages(systemPrompt, messages);
+    async chat(systemPrompt, messages, onChunk, tools, options) {
+      const ollamaMessages = toOpenAICompatibleMessages(systemPrompt, messages);
       const hasTools = tools && tools.length > 0;
       try {
         let fullText = "";
         const toolCallAccumulators = /* @__PURE__ */ new Map();
         const createParams = {
           model,
-          max_tokens: 8192,
+          max_tokens: options?.maxOutputTokens ?? 4096,
           messages: ollamaMessages,
           stream: true
         };
@@ -730,12 +666,18 @@ async function withRetry(fn, options) {
 }
 
 // src/mcp/client.ts
+var TOOL_CALL_TIMEOUT_MS = 3e4;
 var McpManager = class {
   connections = [];
   tools = [];
-  async connect(name, command, args) {
+  async connect(name, command, args, env) {
     try {
-      const transport = new StdioClientTransport({ command, args, stderr: "pipe" });
+      const transport = new StdioClientTransport({
+        command,
+        args,
+        stderr: "pipe",
+        env: env ? env : void 0
+      });
       const client = new Client({
         name: `aman-agent-${name}`,
         version: "0.1.0"
@@ -746,9 +688,16 @@ var McpManager = class {
           log.debug("mcp", `[${name} stderr] ${chunk.toString().trim()}`);
         });
       }
-      this.connections.push({ name, client, transport });
+      this.connections.push({ name, client, transport, connectParams: { command, args, env } });
       const toolsResult = await client.listTools();
       for (const tool of toolsResult.tools) {
+        const existing = this.tools.find((t) => t.name === tool.name);
+        if (existing) {
+          log.warn(
+            "mcp",
+            `Warning: tool "${tool.name}" from server "${name}" shadows existing tool from "${existing.serverName}"`
+          );
+        }
         this.tools.push({
           name: tool.name,
           description: tool.description || "",
@@ -771,7 +720,15 @@ var McpManager = class {
     if (!conn) return `Error: server ${tool.serverName} not connected`;
     try {
       const result = await withRetry(
-        () => conn.client.callTool({ name: toolName, arguments: args }),
+        () => Promise.race([
+          conn.client.callTool({ name: toolName, arguments: args }),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error(`Tool ${toolName} timed out after 30s`)),
+              TOOL_CALL_TIMEOUT_MS
+            )
+          )
+        ]),
         { maxAttempts: 2, baseDelay: 500, retryable: (err) => err.message.includes("ETIMEDOUT") || err.message.includes("timeout") }
       );
       if (result.content && Array.isArray(result.content)) {
@@ -782,6 +739,23 @@ var McpManager = class {
       return `Error calling ${toolName}: ${error instanceof Error ? error.message : String(error)}`;
     }
   }
+  async reconnect(name) {
+    const connIndex = this.connections.findIndex((c) => c.name === name);
+    if (connIndex === -1) {
+      log.error("mcp", `Cannot reconnect: no connection found for "${name}"`);
+      return;
+    }
+    const conn = this.connections[connIndex];
+    const { command, args, env } = conn.connectParams;
+    try {
+      await conn.client.close();
+    } catch (err) {
+      log.debug("mcp", `Error closing old connection for ${name}`, err);
+    }
+    this.connections.splice(connIndex, 1);
+    this.tools = this.tools.filter((t) => t.serverName !== name);
+    await this.connect(name, command, args, env);
+  }
   async disconnect() {
     for (const conn of this.connections) {
       try {
@@ -878,7 +852,10 @@ import {
   consolidateMemories,
   cosineSimilarity,
   preloadEmbeddings,
-  buildVectorIndex
+  buildVectorIndex,
+  recallMemories,
+  generateEmbedding,
+  getVectorIndex
 } from "@aman_asmuei/amem-core";
 import path5 from "path";
 import os5 from "os";
@@ -890,7 +867,27 @@ async function initMemory(project) {
   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);
+  try {
+    db = createDatabase(dbPath);
+  } catch (err) {
+    const backupPath = `${dbPath}.corrupt.${Date.now()}`;
+    try {
+      if (fs5.existsSync(dbPath)) {
+        fs5.renameSync(dbPath, backupPath);
+        if (fs5.existsSync(`${dbPath}-wal`)) fs5.unlinkSync(`${dbPath}-wal`);
+        if (fs5.existsSync(`${dbPath}-shm`)) fs5.unlinkSync(`${dbPath}-shm`);
+        console.error(`[amem] Database corrupted \u2014 backed up to ${backupPath}`);
+        console.error("[amem] Creating fresh database. Previous memories are in the backup file.");
+        db = createDatabase(dbPath);
+      } else {
+        throw err;
+      }
+    } catch {
+      console.error(`[amem] Failed to initialize memory: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[amem] Try deleting ${amemDir} to reset: rm -rf ${amemDir}`);
+      throw err;
+    }
+  }
   currentProject = project ?? "global";
   preloadEmbeddings();
   setTimeout(() => {
@@ -933,16 +930,86 @@ function memoryLog(sessionId, role, content) {
   });
 }
 function reminderCheck() {
-  return getDb().checkReminders();
+  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." };
+}
+var memoryConfig = {};
+function setMemoryConfig(config) {
+  memoryConfig = config;
+}
+function getMaxRecallTokens() {
+  return memoryConfig.maxRecallTokens ?? 1500;
 }
 function memoryConsolidate(dryRun = false) {
   return consolidateMemories(getDb(), cosineSimilarity, {
     dryRun,
-    maxStaleDays: 90,
-    minConfidence: 0.3,
-    minAccessCount: 0
+    maxStaleDays: memoryConfig.maxStaleDays ?? 90,
+    minConfidence: memoryConfig.minConfidence ?? 0.3,
+    minAccessCount: memoryConfig.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";
@@ -1664,7 +1731,8 @@ 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 };
 }
@@ -1702,7 +1770,14 @@ 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 = os9.homedir();
@@ -1733,7 +1808,16 @@ 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 = os9.homedir();
@@ -1755,7 +1839,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"] } },
@@ -1977,7 +2069,15 @@ 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 = os9.homedir();
@@ -2007,7 +2107,7 @@ async function handleMemoryCommand(action, args, ctx) {
       return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
-  if (action && !["search", "clear", "timeline"].includes(action)) {
+  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help"].includes(action)) {
     try {
       const topic = [action, ...args].join(" ");
       const result = await memoryContext(topic);
@@ -2033,10 +2133,18 @@ async function handleMemoryCommand(action, args, ctx) {
   }
   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({ 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") {
     try {
@@ -2082,11 +2190,115 @@ async function handleMemoryCommand(action, args, ctx) {
       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) {
@@ -2102,7 +2314,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;
@@ -2136,7 +2348,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++;
@@ -2158,7 +2370,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>]`,
@@ -2166,8 +2379,12 @@ function handleHelp() {
       `  ${pc3.cyan("/debug")}        Show debug log`,
       `  ${pc3.cyan("/save")}         Save conversation to memory`,
       `  ${pc3.cyan("/model")}        Show current LLM model`,
+      `  ${pc3.cyan("/plan")}         Manage multi-step plans`,
+      `  ${pc3.cyan("/profile")}      Switch agent profiles`,
+      `  ${pc3.cyan("/delegate")}     Delegate tasks to sub-agents`,
+      `  ${pc3.cyan("/team")}         Manage agent teams`,
       `  ${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")
@@ -2176,27 +2393,62 @@ function handleHelp() {
 function handleSave() {
   return { handled: true, saveConversation: true };
 }
-function handleReconfig() {
-  const configDir = path9.join(os9.homedir(), ".aman-agent");
-  const configPath = path9.join(configDir, "config.json");
-  if (fs9.existsSync(configPath)) {
-    fs9.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.") };
   }
-  fs9.mkdirSync(configDir, { recursive: true });
-  fs9.writeFileSync(path9.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(fs9.readFileSync(path9.join(__dirname, "..", "package.json"), "utf-8")).version;
+    const local = true ? "0.17.2" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc3.green("Up to date")} \u2014 v${local}` };
     }
@@ -2634,6 +2886,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",
@@ -2655,8 +2987,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "decisions",
   "export",
   "debug",
-  "update-config",
-  "reconfig",
+  "reset",
+  "reminder",
   "update",
   "upgrade",
   "plan",
@@ -2707,9 +3039,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":
@@ -2718,6 +3049,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();
@@ -2933,14 +3266,18 @@ async function onSessionStart(ctx) {
   let firstRun = false;
   let resumeTopic;
   const visibleReminders = [];
-  try {
-    isHookCall = true;
-    const recallResult = await memoryRecall("*", { limit: 1 });
-    firstRun = recallResult.total === 0;
-  } catch {
-    firstRun = true;
-  } finally {
-    isHookCall = false;
+  if (!isMemoryInitialized()) {
+    firstRun = false;
+  } else {
+    try {
+      isHookCall = true;
+      const recallResult = await memoryRecall("*", { limit: 1 });
+      firstRun = recallResult.total === 0;
+    } catch {
+      firstRun = true;
+    } finally {
+      isHookCall = false;
+    }
   }
   if (firstRun) {
     contextInjection = `<first-session>
@@ -3685,8 +4022,8 @@ Rules:
 - 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 (lastExtractionCount > 0 && turnsSinceLastExtraction >= 1) return true;
   if (turnsSinceLastExtraction < MIN_TURNS_BETWEEN_EMPTY) return false;
   return true;
 }
@@ -3914,7 +4251,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?" },
@@ -4001,13 +4338,20 @@ async function recallForMessage(input) {
       return null;
     }
     const tokenEstimate = result.tokenEstimate ?? Math.round(result.text.split(/\s+/).filter(Boolean).length * 1.3);
+    const MAX_MEMORY_TOKENS = getMaxRecallTokens();
+    let memoryText = result.text;
+    if (tokenEstimate > MAX_MEMORY_TOKENS) {
+      const maxChars = MAX_MEMORY_TOKENS * 4;
+      memoryText = memoryText.slice(0, maxChars) + "\n[... memory truncated to fit token budget]";
+      log.debug("agent", `memory recall truncated from ~${tokenEstimate} to ~${MAX_MEMORY_TOKENS} tokens`);
+    }
     return {
       text: `
 
 <relevant-memories>
-${result.text}
+${memoryText}
 </relevant-memories>`,
-      tokenEstimate
+      tokenEstimate: Math.min(tokenEstimate, MAX_MEMORY_TOKENS)
     };
   } catch (err) {
     log.debug("agent", "memory recall failed", err);
@@ -4063,7 +4407,7 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
     shownHints: loadShownHints(),
     hintShownThisSession: false
   };
-  const isRetryable2 = (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 isRetryable2 = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed") || err.message.includes("socket hang up") || err.message.includes("network socket disconnected") || err.message.includes("ENOTFOUND") || err.message.includes("EAI_AGAIN");
   let responseBuffer = "";
   const onChunkHandler = (chunk) => {
     if (chunk.type === "text" && chunk.text) {
@@ -4481,7 +4825,18 @@ ${converted}
         { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable2 }
       );
       messages.push(response.message);
+      const MAX_TOOL_TURNS = 20;
+      let toolTurnCount = 0;
       while (response.toolUses.length > 0 && mcpManager) {
+        toolTurnCount++;
+        if (toolTurnCount > MAX_TOOL_TURNS) {
+          messages.push({
+            role: "assistant",
+            content: "Tool execution limit reached (20). Breaking to prevent infinite loop."
+          });
+          console.log(pc6.yellow("\n  Tool execution limit reached (20). Breaking to prevent infinite loop."));
+          break;
+        }
         const toolResults = await Promise.all(
           response.toolUses.map(async (toolUse) => {
             if (hooksConfig) {
@@ -4796,10 +5151,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
+  const flowDir = path14.join(home2, ".aflow");
+  const flowPath = path14.join(flowDir, "flow.md");
+  if (!fs14.existsSync(flowPath)) {
+    fs14.mkdirSync(flowDir, { recursive: true });
+    fs14.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  }
+  const skillDir = path14.join(home2, ".askill");
+  const skillPath = path14.join(skillDir, "skills.md");
+  if (!fs14.existsSync(skillPath)) {
+    fs14.mkdirSync(skillDir, { recursive: true });
+    fs14.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  }
   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.2").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) {
@@ -4808,7 +5175,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.");
@@ -4926,39 +5293,47 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   const aiName = getProfileAiName(profile);
-  await initMemory();
+  if (config.memory) setMemoryConfig(config.memory);
+  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"]);
+  const connections = [
+    mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"])
+  ];
   if (config.mcpServers) {
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (name === "aman" || name === "amem") continue;
-      await mcpManager.connect(name, serverConfig.command, serverConfig.args);
+      connections.push(mcpManager.connect(name, serverConfig.command, serverConfig.args, serverConfig.env));
     }
   }
+  await Promise.all(connections);
   const mcpTools = mcpManager.getTools();
   mcpSpinner.stop("MCP connected");
   if (mcpTools.length > 0) {
     p2.log.success(`${mcpTools.length} MCP tools available`);
-    {
-      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");
-      }
-    }
   } 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) => ({