@aman_asmuei/aman-agent 0.17.0 → 0.17.1

package/dist/index.js

@@ -878,7 +878,10 @@ import {
   consolidateMemories,
   cosineSimilarity,
   preloadEmbeddings,
-  buildVectorIndex
+  buildVectorIndex,
+  recallMemories,
+  generateEmbedding,
+  getVectorIndex
 } from "@aman_asmuei/amem-core";
 import path5 from "path";
 import os5 from "os";
@@ -933,7 +936,43 @@ 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." };
 }
 function memoryConsolidate(dryRun = false) {
   return consolidateMemories(getDb(), cosineSimilarity, {
@@ -943,6 +982,33 @@ function memoryConsolidate(dryRun = false) {
     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 +1730,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 +1769,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 +1807,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 +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"] } },
@@ -1977,7 +2068,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 +2106,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 +2132,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({ 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") {
     try {
@@ -2082,11 +2189,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 +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;
@@ -2136,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++;
@@ -2158,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>]`,
@@ -2167,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")
@@ -2176,20 +2388,55 @@ 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")
   };
 }
@@ -2634,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",
@@ -2655,8 +2982,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "decisions",
   "export",
   "debug",
-  "update-config",
-  "reconfig",
+  "reset",
+  "reminder",
   "update",
   "upgrade",
   "plan",
@@ -2707,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":
@@ -2718,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();
@@ -2933,14 +3261,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>
@@ -3914,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?" },
@@ -4799,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) {
@@ -4808,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.");
@@ -4926,7 +5258,26 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
   }
   const aiName = getProfileAiName(profile);
-  await initMemory();
+  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");
@@ -4941,24 +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`);
-    {
-      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) => ({