@aman_asmuei/aman-agent 0.23.0 → 0.24.3

package/dist/index.js

@@ -1387,18 +1387,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs15 from "fs";
-import path15 from "path";
-import os14 from "os";
+import fs16 from "fs";
+import path16 from "path";
+import os15 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs12 from "fs";
-import path12 from "path";
-import os11 from "os";
+import fs13 from "fs";
+import path13 from "path";
+import os12 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc5 from "picocolors";
 
@@ -1471,7 +1471,18 @@ import {
   buildVectorIndex,
   recallMemories,
   generateEmbedding,
-  getVectorIndex
+  getVectorIndex,
+  runDiagnostics,
+  repairDatabase,
+  loadConfig as loadConfig2,
+  saveConfig as saveConfig2,
+  multiStrategyRecall,
+  reflect,
+  isReflectionDue,
+  syncFromClaude,
+  exportForTeam,
+  importFromTeam,
+  syncToCopilot
 } from "@aman_asmuei/amem-core";
 import path6 from "path";
 import os6 from "os";
@@ -1584,19 +1595,19 @@ async function memoryForget(opts) {
   }
   return { deleted: 0, message: "Provide an id, type, or query to forget." };
 }
-var memoryConfig = {};
+var _localMemoryConfig = {};
 function setMemoryConfig(config) {
-  memoryConfig = config;
+  _localMemoryConfig = config;
 }
 function getMaxRecallTokens() {
-  return memoryConfig.maxRecallTokens ?? 1500;
+  return _localMemoryConfig.maxRecallTokens ?? 1500;
 }
 function memoryConsolidate(dryRun = false) {
   return consolidateMemories(getDb(), cosineSimilarity, {
     dryRun,
-    maxStaleDays: memoryConfig.maxStaleDays ?? 90,
-    minConfidence: memoryConfig.minConfidence ?? 0.3,
-    minAccessCount: memoryConfig.minAccessCount ?? 0
+    maxStaleDays: _localMemoryConfig.maxStaleDays ?? 90,
+    minConfidence: _localMemoryConfig.minConfidence ?? 0.3,
+    minAccessCount: _localMemoryConfig.minAccessCount ?? 0
   });
 }
 function isMemoryInitialized() {
@@ -1626,6 +1637,114 @@ function reminderComplete(id) {
   const fullId = getDb().resolveReminderId(id) ?? id;
   return getDb().completeReminder(fullId);
 }
+async function memoryDoctor() {
+  return runDiagnostics(getDb());
+}
+async function memoryRepair(opts = {}) {
+  const dryRun = opts.dryRun ?? true;
+  if (dryRun) {
+    const diag = runDiagnostics(getDb());
+    return {
+      dryRun: true,
+      status: diag.status,
+      issues: diag.issues.map((issue) => issue.message),
+      actions: diag.issues.map((issue) => `Would fix: ${issue.suggestion}`)
+    };
+  }
+  const dbPath = process.env.AMEM_DB ?? path6.join(os6.homedir(), ".amem", "memory.db");
+  const result = repairDatabase(dbPath);
+  return {
+    dryRun: false,
+    status: result.status === "repaired" ? "warning" : result.status === "failed" ? "critical" : "healthy",
+    issues: [],
+    actions: result.memoriesRecovered > 0 ? [`Recovered ${result.memoriesRecovered} memories`] : []
+  };
+}
+async function memoryConfig(updates) {
+  const current = loadConfig2();
+  if (updates && Object.keys(updates).length > 0) {
+    saveConfig2(updates);
+    return loadConfig2();
+  }
+  return current;
+}
+async function memoryMultiRecall(query, opts = {}) {
+  const queryEmbedding = await generateEmbedding(query);
+  const memories = await multiStrategyRecall(getDb(), {
+    query,
+    queryEmbedding,
+    limit: opts.limit ?? 10,
+    scope: opts.scope ?? currentProject ?? void 0
+  });
+  return { memories, total: memories.length };
+}
+async function memoryReflect(config) {
+  return reflect(getDb(), config);
+}
+function memoryTier(id, tier) {
+  try {
+    const db2 = getDb();
+    const fullId = db2.resolveId(id) ?? id;
+    db2.updateTier(fullId, tier);
+    return { id: fullId, tier, ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function memoryDetail(id) {
+  const db2 = getDb();
+  const fullId = db2.resolveId(id) ?? id;
+  return db2.getById(fullId);
+}
+function memoryRelate(fromId, toId, type, strength) {
+  try {
+    const relationId = getDb().addRelation(fromId, toId, type, strength);
+    return { ok: true, relationId };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function memoryExpire(id, reason) {
+  try {
+    const db2 = getDb();
+    const fullId = db2.resolveId(id) ?? id;
+    db2.expireMemory(fullId);
+    return { ok: true, id: fullId, ...reason !== void 0 ? { reason } : {} };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function memoryVersions(id) {
+  const db2 = getDb();
+  const fullId = db2.resolveId(id) ?? id;
+  return db2.getVersionHistory(fullId);
+}
+async function memorySync(action, opts = {}) {
+  const db2 = getDb();
+  try {
+    switch (action) {
+      case "import-claude":
+        return await syncFromClaude(db2, opts.projectFilter, opts.dryRun ?? false);
+      case "export-team": {
+        const exportOptions = {
+          userId: opts.userId ?? currentProject
+        };
+        return await exportForTeam(db2, opts.outputDir ?? process.cwd(), exportOptions);
+      }
+      case "import-team":
+        if (!opts.filePath) {
+          return { ok: false, error: "filePath is required for import-team" };
+        }
+        return await importFromTeam(db2, opts.filePath, opts.importOptions);
+      case "sync-copilot":
+        return syncToCopilot(db2, opts.copilotOptions);
+      default:
+        return { ok: false, error: `Unknown sync action: ${action}` };
+    }
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 
 // src/profile-templates.ts
 import fs7 from "fs";
@@ -2152,14 +2271,98 @@ async function editProfile(current) {
   return updated;
 }
 
+// src/files.ts
+import fs9 from "fs";
+import path9 from "path";
+import os9 from "os";
+var MAX_READ_BYTES = 5e4;
+var HOME = fs9.realpathSync(os9.homedir());
+var TMPDIR = fs9.realpathSync(os9.tmpdir());
+var CWD = fs9.realpathSync(process.cwd());
+function realOrBest(p4) {
+  const parts = p4.split(path9.sep);
+  for (let i = parts.length; i > 0; i--) {
+    const candidate = parts.slice(0, i).join(path9.sep) || path9.sep;
+    try {
+      const real = fs9.realpathSync(candidate);
+      const remainder = parts.slice(i).join(path9.sep);
+      return remainder ? `${real}${path9.sep}${remainder}` : real;
+    } catch {
+    }
+  }
+  return p4;
+}
+function isUnderDir(real, dir) {
+  return real === dir || real.startsWith(dir + path9.sep);
+}
+function assertSafePath(filePath) {
+  const resolved = path9.resolve(filePath);
+  const real = realOrBest(resolved);
+  if (!isUnderDir(real, HOME) && !isUnderDir(real, CWD) && !isUnderDir(real, TMPDIR)) {
+    throw new Error(`Path is outside allowed directories (home or cwd): ${real}`);
+  }
+  return resolved;
+}
+async function readFile(filePath) {
+  const resolved = assertSafePath(filePath);
+  if (!fs9.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  const stat = fs9.statSync(resolved);
+  if (stat.isDirectory()) {
+    throw new Error(`Path is a directory, not a file: ${resolved}. Use /file list instead.`);
+  }
+  const size = stat.size;
+  const buf = Buffer.alloc(Math.min(size, MAX_READ_BYTES));
+  const fd = fs9.openSync(resolved, "r");
+  try {
+    fs9.readSync(fd, buf, 0, buf.length, 0);
+  } finally {
+    fs9.closeSync(fd);
+  }
+  return {
+    path: resolved,
+    content: buf.toString("utf-8"),
+    size,
+    truncated: size > MAX_READ_BYTES,
+    encoding: "utf-8"
+  };
+}
+async function listFiles(dirPath, opts = {}) {
+  const resolved = assertSafePath(dirPath);
+  if (!fs9.existsSync(resolved)) {
+    throw new Error(`Directory not found: ${resolved}`);
+  }
+  const stat = fs9.statSync(resolved);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is a file, not a directory: ${resolved}. Use /file read instead.`);
+  }
+  const entries = [];
+  function walk(dir, prefix) {
+    const items = fs9.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const rel = prefix ? `${prefix}/${item.name}` : item.name;
+      if (item.isDirectory()) {
+        entries.push({ name: rel, type: "dir", size: 0 });
+        if (opts.recursive) walk(path9.join(dir, item.name), rel);
+      } else {
+        const s = fs9.statSync(path9.join(dir, item.name));
+        entries.push({ name: rel, type: "file", size: s.size });
+      }
+    }
+  }
+  walk(resolved, "");
+  return { path: resolved, entries, total: entries.length };
+}
+
 // src/delegate.ts
 import pc3 from "picocolors";
 
 // src/hooks.ts
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/personality.ts
 var FRUSTRATION_SIGNALS = [
@@ -2600,10 +2803,10 @@ async function onSessionEnd(ctx, messages, sessionId) {
       }
       console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path9.join(process.cwd(), ".acore", "context.md");
-    if (fs9.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path10.join(process.cwd(), ".acore", "context.md");
+    if (fs10.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs9.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs10.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -2621,7 +2824,7 @@ async function onSessionEnd(ctx, messages, sessionId) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs9.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs10.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
@@ -2827,43 +3030,43 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 }
 
 // src/teams.ts
-import fs10 from "fs";
-import path10 from "path";
-import os9 from "os";
+import fs11 from "fs";
+import path11 from "path";
+import os10 from "os";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path10.join(os9.homedir(), ".acore", "teams");
+  return path11.join(os10.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path10.join(ensureTeamsDir(), `${slug}.json`);
+  return path11.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs10.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs11.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs10.existsSync(fp)) return null;
+  if (!fs11.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs10.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs11.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs10.existsSync(dir)) return [];
+  if (!fs11.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs10.readdirSync(dir)) {
+  for (const file of fs11.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs10.readFileSync(path10.join(dir, file), "utf-8");
+      const content = fs11.readFileSync(path11.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -2872,8 +3075,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs10.existsSync(fp)) return false;
-  fs10.unlinkSync(fp);
+  if (!fs11.existsSync(fp)) return false;
+  fs11.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -3099,23 +3302,23 @@ var BUILT_IN_TEAMS = [
 ];
 
 // src/plans.ts
-import fs11 from "fs";
-import path11 from "path";
-import os10 from "os";
+import fs12 from "fs";
+import path12 from "path";
+import os11 from "os";
 function getPlansDir() {
-  const localDir = path11.join(process.cwd(), ".acore", "plans");
-  const localAcore = path11.join(process.cwd(), ".acore");
-  if (fs11.existsSync(localAcore)) return localDir;
-  return path11.join(os10.homedir(), ".acore", "plans");
+  const localDir = path12.join(process.cwd(), ".acore", "plans");
+  const localAcore = path12.join(process.cwd(), ".acore");
+  if (fs12.existsSync(localAcore)) return localDir;
+  return path12.join(os11.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  if (!fs12.existsSync(dir)) fs12.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path11.join(ensurePlansDir(), `${slug}.md`);
+  return path12.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -3141,7 +3344,7 @@ function parsePlan(content, filePath) {
     const createdMatch = content.match(/\*\*Created:\*\*\s*(.+)/);
     const updatedMatch = content.match(/\*\*Updated:\*\*\s*(.+)/);
     const activeMatch = content.match(/\*\*Active:\*\*\s*(.+)/);
-    const name = nameMatch?.[1]?.trim() || path11.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path12.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -3183,22 +3386,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs11.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs12.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs11.existsSync(fp)) return null;
-  const content = fs11.readFileSync(fp, "utf-8");
+  if (!fs12.existsSync(fp)) return null;
+  const content = fs12.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs11.existsSync(dir)) return [];
+  if (!fs12.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs11.readdirSync(dir)) {
+  for (const file of fs12.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path11.join(dir, file);
-    const content = fs11.readFileSync(fp, "utf-8");
+    const fp = path12.join(dir, file);
+    const content = fs12.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -3295,20 +3498,22 @@ function progressBar(pct) {
 // src/commands.ts
 import {
   getIdentity as acoreGetIdentity,
-  updateSection as acoreUpdateSection
+  updateSection as acoreUpdateSection,
+  updateDynamics as acoreUpdateDynamics
 } from "@aman_asmuei/acore-core";
 import {
   listRuleCategories as arulesListCategories,
   addRule as arulesAddRule,
   removeRule as arulesRemoveRule,
-  toggleRuleAt as arulesToggleRule
+  toggleRuleAt as arulesToggleRule,
+  checkAction as arulesCheckAction
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs12.existsSync(filePath)) {
+  if (!fs13.existsSync(filePath)) {
     return pc5.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs12.readFileSync(filePath, "utf-8").trim();
+  return fs13.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -3319,6 +3524,18 @@ function parseCommand(input) {
   const args = parts.slice(2);
   return { base, action, args };
 }
+function buildNestedUpdate(key, val) {
+  const parts = key.split(".");
+  if (parts.length === 1) return { [key]: val };
+  const result = {};
+  let curr = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    curr[parts[i]] = {};
+    curr = curr[parts[i]];
+  }
+  curr[parts[parts.length - 1]] = val;
+  return result;
+}
 async function mcpWrite(ctx, layer, tool, args) {
   if (!ctx.mcpManager) {
     return pc5.red(`Cannot modify ${layer}: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp`);
@@ -3373,13 +3590,50 @@ async function handleIdentityCommand(action, args, _ctx) {
       };
     }
   }
+  if (action === "dynamics") {
+    const updates = {};
+    for (const arg of args) {
+      const eq = arg.indexOf("=");
+      if (eq > 0) updates[arg.slice(0, eq)] = arg.slice(eq + 1);
+    }
+    if (!Object.keys(updates).length) {
+      return { handled: true, output: pc5.yellow("Usage: /identity dynamics energy=high mode=focused read='Book Title'") };
+    }
+    try {
+      await acoreUpdateDynamics({
+        energy: updates.energy,
+        activeMode: updates.mode,
+        currentRead: updates.read
+      }, AGENT_SCOPE);
+      return { handled: true, output: `Dynamics updated: ${Object.entries(updates).map(([k, v]) => `${k}=${v}`).join(", ")}` };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Dynamics error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "summary") {
+    try {
+      const identity = await acoreGetIdentity(AGENT_SCOPE);
+      if (!identity) return { handled: true, output: pc5.yellow("No identity configured.") };
+      const nameMatch = identity.content.match(/\*\*Name:\*\*\s*(.+)/);
+      const lines = [
+        `**Identity Summary**`,
+        nameMatch ? `Name: ${nameMatch[1].trim()}` : "",
+        `Scope: ${AGENT_SCOPE}`
+      ].filter(Boolean);
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Summary error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
   if (action === "help") {
     return {
       handled: true,
       output: [
         pc5.bold("Identity commands:"),
         `  ${pc5.cyan("/identity")}                  View current identity`,
-        `  ${pc5.cyan("/identity update")} <section>  Update a section`
+        `  ${pc5.cyan("/identity update")} <section>  Update a section`,
+        `  ${pc5.cyan("/identity dynamics")} key=val   Update dynamic fields (energy, mode, read)`,
+        `  ${pc5.cyan("/identity summary")}            Show structured identity summary`
       ].join("\n")
     };
   }
@@ -3495,6 +3749,26 @@ async function handleRulesCommand(action, args, _ctx) {
       };
     }
   }
+  if (action === "check") {
+    if (args.length === 0) {
+      return { handled: true, output: pc5.yellow("Usage: /rules check <action description...>") };
+    }
+    const description = args.join(" ");
+    try {
+      const result = await arulesCheckAction(description, AGENT_SCOPE);
+      if (result.safe) {
+        return { handled: true, output: pc5.green(`Action is allowed: "${description}"`) };
+      }
+      return {
+        handled: true,
+        output: pc5.red(`Action blocked: "${description}"
+Violations:
+${result.violations.map((v) => `  - ${v}`).join("\n")}`)
+      };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Check error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
   if (action === "help") {
     return {
       handled: true,
@@ -3503,7 +3777,8 @@ async function handleRulesCommand(action, args, _ctx) {
         `  ${pc5.cyan("/rules")}                         View current rules`,
         `  ${pc5.cyan("/rules add")} <category> <text>    Add a rule`,
         `  ${pc5.cyan("/rules remove")} <category> <idx>  Remove a rule`,
-        `  ${pc5.cyan("/rules toggle")} <category> <idx>  Toggle a rule`
+        `  ${pc5.cyan("/rules toggle")} <category> <idx>  Toggle a rule`,
+        `  ${pc5.cyan("/rules check")} <action...>         Check if an action is allowed`
       ].join("\n")
     };
   }
@@ -3513,9 +3788,9 @@ async function handleRulesCommand(action, args, _ctx) {
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os11.homedir();
+  const home2 = os12.homedir();
   if (!action) {
-    const content = readEcosystemFile(path12.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path13.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -3532,12 +3807,33 @@ async function handleWorkflowsCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "workflows", "workflow_remove", { name: args.join(" ") });
     return { handled: true, output };
   }
+  if (action === "get") {
+    if (args.length === 0) {
+      return { handled: true, output: pc5.yellow("Usage: /workflows get <name>") };
+    }
+    const name = args.join(" ").toLowerCase();
+    const raw = readEcosystemFile(path13.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    if (raw.startsWith("No ")) {
+      return { handled: true, output: raw };
+    }
+    const sections = raw.split(/^## /m).slice(1);
+    const match = sections.find((s) => s.split("\n")[0].trim().toLowerCase() === name);
+    if (!match) {
+      return { handled: true, output: pc5.yellow(`No workflow found: "${args.join(" ")}"`) };
+    }
+    const title = match.split("\n")[0].trim();
+    const body = match.split("\n").slice(1).join("\n").trim();
+    return { handled: true, output: `## ${title}
+
+${body}` };
+  }
   if (action === "help") {
     return { handled: true, output: [
       pc5.bold("Workflow commands:"),
       `  ${pc5.cyan("/workflows")}              View current workflows`,
       `  ${pc5.cyan("/workflows add")} <name>    Add a workflow`,
-      `  ${pc5.cyan("/workflows remove")} <name> Remove a workflow`
+      `  ${pc5.cyan("/workflows remove")} <name> Remove a workflow`,
+      `  ${pc5.cyan("/workflows get")} <name>    Show a specific workflow`
     ].join("\n") };
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /workflows ${action}. Try /workflows --help`) };
@@ -3566,10 +3862,34 @@ function handleAkitCommand(_action, _args) {
     ].join("\n")
   };
 }
+async function handleToolsCommand(action, args, _ctx) {
+  if (!action || action === "list") {
+    return handleAkitCommand(action, args);
+  }
+  if (action === "search") {
+    if (args.length === 0) {
+      return { handled: true, output: pc5.yellow("Usage: /tools search <query...>") };
+    }
+    const query = args.join(" ").toLowerCase();
+    const home2 = os12.homedir();
+    const toolsFile = path13.join(home2, ".akit", "tools.md");
+    if (!fs13.existsSync(toolsFile)) {
+      return { handled: true, output: pc5.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
+    }
+    const raw = fs13.readFileSync(toolsFile, "utf-8").trim();
+    const lines = raw.split("\n");
+    const matches = lines.filter((l) => l.toLowerCase().includes(query));
+    if (matches.length === 0) {
+      return { handled: true, output: pc5.dim(`No tools matching "${query}".`) };
+    }
+    return { handled: true, output: [pc5.bold(`Tools matching "${query}":`), ...matches].join("\n") };
+  }
+  return handleAkitCommand(action, args);
+}
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os11.homedir();
+  const home2 = os12.homedir();
   if (!action) {
-    const content = readEcosystemFile(path12.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path13.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -3586,20 +3906,38 @@ async function handleSkillsCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "skills", "skill_uninstall", { name: args.join(" ") });
     return { handled: true, output };
   }
+  if (action === "search") {
+    if (args.length === 0) {
+      return { handled: true, output: pc5.yellow("Usage: /skills search <query...>") };
+    }
+    const query = args.join(" ").toLowerCase();
+    const home3 = os12.homedir();
+    const raw = readEcosystemFile(path13.join(home3, ".askill", "skills.md"), "skills (askill)");
+    if (raw.startsWith("No ")) {
+      return { handled: true, output: raw };
+    }
+    const lines = raw.split("\n");
+    const matches = lines.filter((l) => l.toLowerCase().includes(query));
+    if (matches.length === 0) {
+      return { handled: true, output: pc5.dim(`No skills matching "${query}".`) };
+    }
+    return { handled: true, output: [pc5.bold(`Skills matching "${query}":`), ...matches].join("\n") };
+  }
   if (action === "help") {
     return { handled: true, output: [
       pc5.bold("Skills commands:"),
       `  ${pc5.cyan("/skills")}                    View installed skills`,
       `  ${pc5.cyan("/skills install")} <name>      Install a skill`,
-      `  ${pc5.cyan("/skills uninstall")} <name>    Uninstall a skill`
+      `  ${pc5.cyan("/skills uninstall")} <name>    Uninstall a skill`,
+      `  ${pc5.cyan("/skills search")} <query>       Search skills by name/description`
     ].join("\n") };
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os11.homedir();
+  const home2 = os12.homedir();
   if (!action) {
-    const content = readEcosystemFile(path12.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path13.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -3610,7 +3948,15 @@ async function handleEvalCommand(action, args, ctx) {
     const output = await mcpWrite(ctx, "eval", "eval_milestone", { text: text3 });
     return { handled: true, output };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /eval ${action}. Use /eval or /eval milestone <text>.`) };
+  if (action === "report") {
+    const evalFile = path13.join(home2, ".aeval", "eval.md");
+    if (!fs13.existsSync(evalFile)) {
+      return { handled: true, output: pc5.dim("No eval report found. Log milestones with /eval milestone <text>.") };
+    }
+    const content = fs13.readFileSync(evalFile, "utf-8").trim();
+    return { handled: true, output: [pc5.bold("Eval Report"), "", content].join("\n") };
+  }
+  return { handled: true, output: pc5.yellow(`Unknown action: /eval ${action}. Use /eval, /eval report, or /eval milestone <text>.`) };
 }
 async function handleMemoryCommand(action, args, ctx) {
   if (!action) {
@@ -3624,7 +3970,7 @@ async function handleMemoryCommand(action, args, ctx) {
       return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
-  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help"].includes(action)) {
+  if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help", "doctor", "repair", "config", "reflect", "consolidate", "tier", "detail", "relate", "expire", "versions", "sync"].includes(action)) {
     try {
       const topic = [action, ...args].join(" ");
       const result = await memoryContext(topic);
@@ -3642,8 +3988,17 @@ async function handleMemoryCommand(action, args, ctx) {
     }
     const query = args.join(" ");
     try {
-      const result = await memoryRecall(query);
-      return { handled: true, output: result.total === 0 ? pc5.dim("No memories found.") : result.text };
+      const result = await memoryMultiRecall(query, { limit: 10 });
+      if (result.total === 0) {
+        return { handled: true, output: pc5.dim("No memories found.") };
+      }
+      const header = `Search results for "${query}" (${result.total}):`;
+      const lines = [pc5.bold(header), ""];
+      for (const m of result.memories) {
+        const tags = m.tags?.length > 0 ? ` ${pc5.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: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
@@ -3808,9 +4163,214 @@ async function handleMemoryCommand(action, args, ctx) {
       `  ${pc5.cyan("/memory export")} [json]        Export all memories`,
       `  ${pc5.cyan("/memory timeline")}            View memory timeline`,
       `  ${pc5.cyan("/memory clear")} <query>        Delete matching memories`,
-      `  ${pc5.cyan("/memory clear --type")} <type>  Delete all of a type`
+      `  ${pc5.cyan("/memory clear --type")} <type>  Delete all of a type`,
+      `  ${pc5.cyan("/memory doctor")}              Run memory diagnostics`,
+      `  ${pc5.cyan("/memory repair")}              Dry-run repair (safe)`,
+      `  ${pc5.cyan("/memory config")} [key=value]  View or update config (e.g. consolidation.maxStaleDays=60)`
     ].join("\n") };
   }
+  if (action === "doctor") {
+    try {
+      const diag = await memoryDoctor();
+      const statusIcon = diag.status === "healthy" ? "\u2705" : "\u26A0\uFE0F";
+      const lines = [
+        `**Memory Diagnostics**`,
+        `Status: ${statusIcon} ${diag.status}`
+      ];
+      if (diag.issues?.length) {
+        lines.push("", "**Issues:**");
+        for (const issue of diag.issues) {
+          lines.push(`- ${typeof issue === "string" ? issue : issue.message ?? String(issue)}`);
+        }
+        lines.push("", "_Run `/memory repair` (dry-run) or `/memory repair --apply` to fix._");
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Memory doctor error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "repair") {
+    try {
+      const dryRun = !args.includes("--apply");
+      const result = await memoryRepair({ dryRun });
+      const prefix = dryRun ? "[DRY RUN] " : "";
+      const lines = [`**${prefix}Memory Repair**`];
+      if (result.actions?.length) {
+        lines.push("", "**Actions:**");
+        for (const act of result.actions) {
+          lines.push(`- ${act}`);
+        }
+      } else {
+        lines.push("No actions needed.");
+      }
+      if (dryRun) {
+        lines.push("", "_Run `/memory repair --apply` to execute._");
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Memory repair error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "config") {
+    try {
+      const kvArg = args.find((a) => a.includes("=") && !a.startsWith("-"));
+      if (kvArg) {
+        const eqIdx = kvArg.indexOf("=");
+        const key = kvArg.slice(0, eqIdx);
+        const rawVal = kvArg.slice(eqIdx + 1);
+        if (!rawVal) {
+          return { handled: true, output: pc5.yellow(`Usage: /memory config <key>=<value>`) };
+        }
+        const val = isNaN(Number(rawVal)) ? rawVal : Number(rawVal);
+        const update = buildNestedUpdate(key, val);
+        await memoryConfig(update);
+        return { handled: true, output: `\u2705 Set \`${key}\` \u2192 \`${val}\`` };
+      }
+      const config = await memoryConfig();
+      const lines = ["**Memory Config**", "```"];
+      for (const [k, v] of Object.entries(config)) {
+        if (typeof v === "object" && v !== null) {
+          for (const [sk, sv] of Object.entries(v)) {
+            lines.push(`${k}.${sk}: ${sv}`);
+          }
+        } else {
+          lines.push(`${k}: ${v}`);
+        }
+      }
+      lines.push("```", "", "_Use `/memory config key=value` to change a setting._");
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Memory config error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "reflect") {
+    try {
+      const report = await memoryReflect();
+      const lines = [
+        pc5.bold("Reflection complete"),
+        `Clusters: ${report.clusters.length}`,
+        `Contradictions: ${report.contradictions.length}`,
+        `Synthesis candidates: ${report.synthesisCandidates.length}`,
+        `Knowledge gaps: ${report.knowledgeGaps.length}`,
+        `Health score: ${(report.stats.healthScore * 100).toFixed(0)}%`,
+        `Duration: ${report.durationMs}ms`
+      ];
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Reflect error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "consolidate") {
+    const apply = args.includes("--apply");
+    try {
+      const report = memoryConsolidate(!apply);
+      const lines = [
+        apply ? pc5.bold("Consolidation applied") : pc5.bold("Consolidation dry-run"),
+        `Merged: ${report.merged}`,
+        `Pruned: ${report.pruned}`,
+        `Promoted: ${report.promoted}`,
+        `Decayed: ${report.decayed}`,
+        `Health score: ${(report.healthScore * 100).toFixed(0)}%`,
+        `Before: ${report.before.total} \u2192 After: ${report.after.total}`
+      ];
+      if (!apply) lines.push(pc5.dim("Run with --apply to execute."));
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Consolidate error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "tier") {
+    const id = args[0];
+    const tier = args[1];
+    if (!id || !tier) {
+      return { handled: true, output: pc5.yellow("Usage: /memory tier <id> <core|working|archival>") };
+    }
+    const tierResult = memoryTier(id, tier);
+    if (!tierResult.ok) {
+      return { handled: true, output: pc5.red(`Tier error: ${tierResult.error}`) };
+    }
+    return { handled: true, output: `\u2705 Memory ${tierResult.id} moved to tier: ${tierResult.tier}` };
+  }
+  if (action === "detail") {
+    const id = args[0];
+    if (!id) {
+      return { handled: true, output: pc5.yellow("Usage: /memory detail <id>") };
+    }
+    const memory = memoryDetail(id);
+    if (!memory) {
+      return { handled: true, output: pc5.dim(`Memory not found: ${id}`) };
+    }
+    const lines = [
+      pc5.bold(`Memory: ${memory.id}`),
+      `Content: ${memory.content}`,
+      `Type: ${memory.type}`,
+      `Confidence: ${memory.confidence}`,
+      `Tier: ${memory.tier ?? "working"}`,
+      `Access count: ${memory.accessCount}`,
+      `Created: ${new Date(memory.createdAt).toISOString()}`,
+      memory.tags?.length ? `Tags: ${memory.tags.join(", ")}` : ""
+    ].filter(Boolean);
+    return { handled: true, output: lines.join("\n") };
+  }
+  if (action === "relate") {
+    const [fromId, toId, relType, strengthStr] = args;
+    if (!fromId || !toId || !relType) {
+      return { handled: true, output: pc5.yellow("Usage: /memory relate <fromId> <toId> <type> [strength]") };
+    }
+    const strength = strengthStr !== void 0 ? parseFloat(strengthStr) : void 0;
+    const relResult = memoryRelate(fromId, toId, relType, strength);
+    if (!relResult.ok) {
+      return { handled: true, output: pc5.red(`Relate error: ${relResult.error}`) };
+    }
+    return { handled: true, output: `\u2705 Relation created: ${fromId} --[${relType}]--> ${toId} (id: ${relResult.relationId})` };
+  }
+  if (action === "expire") {
+    const id = args[0];
+    if (!id) {
+      return { handled: true, output: pc5.yellow("Usage: /memory expire <id> [reason]") };
+    }
+    const reason = args.slice(1).join(" ") || void 0;
+    const expireResult = memoryExpire(id, reason);
+    if (!expireResult.ok) {
+      return { handled: true, output: pc5.red(`Expire error: ${expireResult.error}`) };
+    }
+    return { handled: true, output: `\u2705 Memory ${expireResult.id} expired${reason ? `: ${reason}` : ""}` };
+  }
+  if (action === "versions") {
+    const id = args[0];
+    if (!id) {
+      return { handled: true, output: pc5.yellow("Usage: /memory versions <id>") };
+    }
+    const versions = memoryVersions(id);
+    if (!versions.length) {
+      return { handled: true, output: pc5.dim(`No version history for: ${id}`) };
+    }
+    const lines = [pc5.bold(`Version history for ${id}:`)];
+    for (const v of versions) {
+      lines.push(`  [${new Date(v.editedAt).toISOString()}] ${v.content.slice(0, 80)}${v.content.length > 80 ? "\u2026" : ""}`);
+    }
+    return { handled: true, output: lines.join("\n") };
+  }
+  if (action === "sync") {
+    const syncAction = args[0];
+    if (!syncAction) {
+      return { handled: true, output: pc5.yellow("Usage: /memory sync <import-claude|export-team|import-team|sync-copilot>") };
+    }
+    try {
+      const opts = {};
+      for (const arg of args.slice(1)) {
+        if (arg.startsWith("--")) {
+          const [k, v] = arg.slice(2).split("=");
+          opts[k] = v ?? true;
+        }
+      }
+      const result = await memorySync(syncAction, opts);
+      return { handled: true, output: `\u2705 Sync [${syncAction}] complete:
+${JSON.stringify(result, null, 2)}` };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`Sync error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
   return { handled: true, output: pc5.yellow(`Unknown action: /memory ${action}. Try /memory --help`) };
 }
 function handleStatusCommand(ctx) {
@@ -3915,10 +4475,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path12.join(os11.homedir(), ".aman-agent"),
-    memory: path12.join(os11.homedir(), ".amem"),
-    identity: path12.join(os11.homedir(), ".acore"),
-    rules: path12.join(os11.homedir(), ".arules")
+    config: path13.join(os12.homedir(), ".aman-agent"),
+    memory: path13.join(os12.homedir(), ".amem"),
+    identity: path13.join(os12.homedir(), ".acore"),
+    rules: path13.join(os12.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -3943,15 +4503,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs12.existsSync(dir)) {
-      fs12.rmSync(dir, { recursive: true, force: true });
+    if (fs13.existsSync(dir)) {
+      fs13.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir = dirs.config;
-    fs12.mkdirSync(configDir, { recursive: true });
-    fs12.writeFileSync(path12.join(configDir, ".reconfig"), "", "utf-8");
+    fs13.mkdirSync(configDir, { recursive: true });
+    fs13.writeFileSync(path13.join(configDir, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc5.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -3968,7 +4528,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.23.0" : "unknown";
+    const local = true ? "0.24.3" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -4012,11 +4572,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path12.join(os11.homedir(), ".aman-agent", "debug.log");
-  if (!fs12.existsSync(logPath)) {
+  const logPath = path13.join(os12.homedir(), ".aman-agent", "debug.log");
+  if (!fs13.existsSync(logPath)) {
     return { handled: true, output: pc5.dim("No debug log found.") };
   }
-  const content = fs12.readFileSync(logPath, "utf-8");
+  const content = fs13.readFileSync(logPath, "utf-8");
   const lines = content.trim().split("\n");
   const last20 = lines.slice(-20).join("\n");
   return { handled: true, output: pc5.bold("Debug Log (last 20 entries):\n") + pc5.dim(last20) };
@@ -4214,7 +4774,7 @@ ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path12.join(os11.homedir(), ".acore", "profiles");
+  const profilesDir = path13.join(os12.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -4282,8 +4842,8 @@ ${pc5.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path12.join(profilesDir, slug);
-      if (fs12.existsSync(profileDir)) {
+      const profileDir = path13.join(profilesDir, slug);
+      if (fs13.existsSync(profileDir)) {
         return { handled: true, output: pc5.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -4299,16 +4859,16 @@ ${pc5.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs12.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path12.join(os11.homedir(), ".acore", "core.md");
-      if (fs12.existsSync(globalCore)) {
-        let content = fs12.readFileSync(globalCore, "utf-8");
+      fs13.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path13.join(os12.homedir(), ".acore", "core.md");
+      if (fs13.existsSync(globalCore)) {
+        let content = fs13.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs12.writeFileSync(path12.join(profileDir, "core.md"), content, "utf-8");
+        fs13.writeFileSync(path13.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs12.writeFileSync(path12.join(profileDir, "core.md"), `# ${aiName}
+        fs13.writeFileSync(path13.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -4321,7 +4881,7 @@ ${pc5.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc5.green(`Profile created: ${slug}`) + `
-  Edit: ${path12.join(profileDir, "core.md")}
+  Edit: ${path13.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc5.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -4330,9 +4890,9 @@ ${pc5.dim("Edit with: /profile edit")}` };
     case "show": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile show <name>") };
-      const profileDir = path12.join(profilesDir, name);
-      if (!fs12.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      const files = fs12.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path13.join(profilesDir, name);
+      if (!fs13.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      const files = fs13.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc5.bold(name)}
 Files:
@@ -4341,9 +4901,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile delete <name>") };
-      const profileDir = path12.join(profilesDir, name);
-      if (!fs12.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      fs12.rmSync(profileDir, { recursive: true });
+      const profileDir = path13.join(profilesDir, name);
+      if (!fs13.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      fs13.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc5.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -4549,10 +5109,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path12.join(os11.homedir(), ".acore", "core.md");
+  const corePath = path13.join(os12.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs12.existsSync(corePath)) {
-    const content = fs12.readFileSync(corePath, "utf-8");
+  if (fs13.existsSync(corePath)) {
+    const content = fs13.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -4634,6 +5194,65 @@ ${pc5.dim("Existing files are backed up (.bak) before overwriting.")}` };
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /showcase ${action}. Try /showcase help`) };
 }
+async function handleFileCommand(action, args) {
+  if (!action) {
+    return {
+      handled: true,
+      output: [
+        pc5.bold("File commands:"),
+        `  ${pc5.cyan("/file read")} <path>               Read a text file (max 50 KB)`,
+        `  ${pc5.cyan("/file convert")} <path>            Attempt to read binary file as text`,
+        `  ${pc5.cyan("/file list")} <path> [--recursive]  List directory contents`
+      ].join("\n")
+    };
+  }
+  if (action === "read" || action === "convert") {
+    const filePath = args[0];
+    if (!filePath) {
+      return { handled: true, output: pc5.yellow(`Usage: /file ${action} <path>`) };
+    }
+    try {
+      const result = await readFile(filePath);
+      const lines = [
+        pc5.bold(`\u{1F4C4} ${result.path}`) + pc5.dim(` (${(result.size / 1024).toFixed(1)} KB)`),
+        "",
+        result.content
+      ];
+      if (result.truncated) {
+        lines.push("", pc5.yellow(`\u26A0 File truncated at 50 KB. Use a text editor for the full file.`));
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`File error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  if (action === "list") {
+    const dirPath = args.find((a) => !a.startsWith("-"));
+    if (!dirPath) {
+      return { handled: true, output: pc5.yellow(`Usage: /file list <path> [--recursive]`) };
+    }
+    const recursive = args.includes("--recursive") || args.includes("-r");
+    try {
+      const result = await listFiles(dirPath, { recursive });
+      const lines = [
+        pc5.bold(`\u{1F4C1} ${result.path}`) + pc5.dim(` (${result.total} items)`),
+        ""
+      ];
+      for (const entry of result.entries) {
+        if (entry.type === "dir") {
+          lines.push(`  ${pc5.cyan(entry.name + "/")}`);
+        } else {
+          const kb = entry.size > 0 ? pc5.dim(` ${(entry.size / 1024).toFixed(1)} KB`) : "";
+          lines.push(`  ${entry.name}${kb}`);
+        }
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return { handled: true, output: pc5.red(`File error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
+  }
+  return { handled: true, output: pc5.yellow(`Unknown /file subcommand: ${action}. Try /file for help.`) };
+}
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
   "exit",
@@ -4663,7 +5282,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "profile",
   "delegate",
   "team",
-  "showcase"
+  "showcase",
+  "file"
 ]);
 async function handleCommand(input, ctx) {
   const trimmed = input.trim();
@@ -4688,6 +5308,7 @@ async function handleCommand(input, ctx) {
     case "workflows":
       return handleWorkflowsCommand(action, args, ctx);
     case "tools":
+      return handleToolsCommand(action, args, ctx);
     case "akit":
       return handleAkitCommand(action, args);
     case "skills":
@@ -4722,6 +5343,8 @@ async function handleCommand(input, ctx) {
       return handleReminderCommand(action, args);
     case "showcase":
       return handleShowcaseCommand(action, args);
+    case "file":
+      return handleFileCommand(action, args);
     case "update":
     case "upgrade":
       return handleUpdate();
@@ -4804,9 +5427,9 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs13 from "fs";
-import path13 from "path";
-import os12 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 var SKILL_TRIGGERS = {
   testing: ["test", "spec", "coverage", "tdd", "jest", "vitest", "mocha", "assert", "mock", "stub", "fixture", "e2e", "integration test", "unit test"],
   "api-design": ["api", "endpoint", "rest", "graphql", "route", "controller", "middleware", "http", "request", "response", "status code", "pagination"],
@@ -4821,20 +5444,20 @@ var SKILL_TRIGGERS = {
   typescript: ["typescript", "type", "interface", "generic", "infer", "utility type", "zod", "discriminated union", "type guard", "as const"],
   accessibility: ["accessibility", "a11y", "aria", "screen reader", "wcag", "semantic html", "tab order", "focus", "contrast"]
 };
-var LEVEL_FILE = path13.join(os12.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path14.join(os13.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs13.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs13.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs14.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs14.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path13.dirname(LEVEL_FILE);
-  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
-  fs13.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path14.dirname(LEVEL_FILE);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -5163,6 +5786,7 @@ function matchKnowledge(userInput) {
 }
 
 // src/memory-extractor.ts
+import { reflect as reflect2, isReflectionDue as isReflectionDue2 } from "@aman_asmuei/amem-core";
 var VALID_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology", "decision", "correction"]);
 var MIN_RESPONSE_LENGTH = 50;
 var MIN_TURNS_BETWEEN_EMPTY = 3;
@@ -5247,7 +5871,7 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
       } catch {
       }
       try {
-        await memoryStore({
+        const storeResult = await memoryStore({
           content: candidate.content,
           type: candidate.type,
           tags: candidate.tags,
@@ -5255,18 +5879,26 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
           source: "auto-extraction",
           scope: candidate.scope
         });
-        stored++;
-        log.debug("extractor", "Stored " + candidate.type + ": " + candidate.content);
-        if (candidate.type === "pattern" || candidate.type === "preference") {
-          const skillMatch = matchPatternToSkill(candidate.content, candidate.tags);
-          if (skillMatch) {
-            enrichSkill(skillMatch, candidate.content);
+        if (storeResult.action !== "private") {
+          stored++;
+          log.debug("extractor", "Stored " + candidate.type + ": " + candidate.content);
+          if (candidate.type === "pattern" || candidate.type === "preference") {
+            const skillMatch = matchPatternToSkill(candidate.content, candidate.tags);
+            if (skillMatch) {
+              enrichSkill(skillMatch, candidate.content);
+            }
           }
         }
       } catch (err) {
         log.warn("extractor", "Failed to store: " + candidate.content, err);
       }
     }
+    if (stored > 0 && isReflectionDue2(getDb()).due) {
+      try {
+        reflect2(getDb());
+      } catch {
+      }
+    }
     return stored;
   } catch (err) {
     log.debug("extractor", "extraction failed", err);
@@ -5438,9 +6070,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs14 from "fs";
-import path14 from "path";
-import os13 from "os";
+import fs15 from "fs";
+import path15 from "path";
+import os14 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -5478,11 +6110,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path14.join(os13.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path15.join(os14.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs14.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs14.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs15.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs15.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -5491,9 +6123,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path14.dirname(HINTS_FILE);
-    fs14.mkdirSync(dir, { recursive: true });
-    fs14.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path15.dirname(HINTS_FILE);
+    fs15.mkdirSync(dir, { recursive: true });
+    fs15.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -5738,9 +6370,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path15.join(os14.homedir(), ".aman-agent", "exports");
-          fs15.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path15.join(exportDir, `${sessionId}.md`);
+          const exportDir = path16.join(os15.homedir(), ".aman-agent", "exports");
+          fs16.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path16.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -5754,7 +6386,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs15.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs16.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -5880,25 +6512,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path15.join(os14.homedir(), filePath.slice(2));
+        filePath = path16.join(os15.homedir(), filePath.slice(2));
       }
-      if (!fs15.existsSync(filePath) || !fs15.statSync(filePath).isFile()) continue;
-      const ext = path15.extname(filePath).toLowerCase();
+      if (!fs16.existsSync(filePath) || !fs16.statSync(filePath).isFile()) continue;
+      const ext = path16.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs15.statSync(filePath);
+          const stat = fs16.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path15.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path16.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs15.readFileSync(filePath).toString("base64");
+          const data = fs16.readFileSync(filePath).toString("base64");
           const mediaType = mimeMap[ext] || "image/png";
           imageBlocks.push({
             type: "image",
             source: { type: "base64", media_type: mediaType, data }
           });
-          process.stdout.write(pc7.dim(`  [attached image: ${path15.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path16.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -5906,7 +6538,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs15.readFileSync(filePath, "utf-8");
+          const content = fs16.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -5916,7 +6548,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path15.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path16.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -5925,7 +6557,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path15.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path16.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -5934,7 +6566,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path15.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path16.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -5946,7 +6578,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path15.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path16.basename(filePath)}]
 `));
           }
         } else {
@@ -6188,7 +6820,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs15.existsSync(path15.join(os14.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs16.existsSync(path16.join(os15.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -6234,9 +6866,9 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs16 from "fs";
-import path16 from "path";
-import os15 from "os";
+import fs17 from "fs";
+import path17 from "path";
+import os16 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -6345,9 +6977,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path16.join(os15.homedir(), ".aman-agent", ".reconfig");
-  if (fs16.existsSync(reconfigMarker)) {
-    fs16.unlinkSync(reconfigMarker);
+  const reconfigMarker = path17.join(os16.homedir(), ".aman-agent", ".reconfig");
+  if (fs17.existsSync(reconfigMarker)) {
+    fs17.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -6376,11 +7008,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os15.homedir();
-  const corePath = path16.join(home2, ".acore", "core.md");
-  if (fs16.existsSync(corePath)) return false;
-  fs16.mkdirSync(path16.join(home2, ".acore"), { recursive: true });
-  fs16.writeFileSync(corePath, [
+  const home2 = os16.homedir();
+  const corePath = path17.join(home2, ".acore", "core.md");
+  if (fs17.existsSync(corePath)) return false;
+  fs17.mkdirSync(path17.join(home2, ".acore"), { recursive: true });
+  fs17.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -6392,11 +7024,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path16.join(home2, ".arules");
-  const rulesPath = path16.join(rulesDir, "rules.md");
-  if (!fs16.existsSync(rulesPath)) {
-    fs16.mkdirSync(rulesDir, { recursive: true });
-    fs16.writeFileSync(rulesPath, [
+  const rulesDir = path17.join(home2, ".arules");
+  const rulesPath = path17.join(rulesDir, "rules.md");
+  if (!fs17.existsSync(rulesPath)) {
+    fs17.mkdirSync(rulesDir, { recursive: true });
+    fs17.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -6408,22 +7040,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowDir = path16.join(home2, ".aflow");
-  const flowPath = path16.join(flowDir, "flow.md");
-  if (!fs16.existsSync(flowPath)) {
-    fs16.mkdirSync(flowDir, { recursive: true });
-    fs16.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowDir = path17.join(home2, ".aflow");
+  const flowPath = path17.join(flowDir, "flow.md");
+  if (!fs17.existsSync(flowPath)) {
+    fs17.mkdirSync(flowDir, { recursive: true });
+    fs17.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillDir = path16.join(home2, ".askill");
-  const skillPath = path16.join(skillDir, "skills.md");
-  if (!fs16.existsSync(skillPath)) {
-    fs16.mkdirSync(skillDir, { recursive: true });
-    fs16.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillDir = path17.join(home2, ".askill");
+  const skillPath = path17.join(skillDir, "skills.md");
+  if (!fs17.existsSync(skillPath)) {
+    fs17.mkdirSync(skillDir, { recursive: true });
+    fs17.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.23.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.24.3").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) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -6775,19 +7407,19 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p3.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  const home2 = os15.homedir();
-  fs16.mkdirSync(path16.join(home2, ".acore"), { recursive: true });
-  fs16.writeFileSync(path16.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os16.homedir();
+  fs17.mkdirSync(path17.join(home2, ".acore"), { recursive: true });
+  fs17.writeFileSync(path17.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
   p3.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs16.mkdirSync(path16.join(home2, ".arules"), { recursive: true });
-    fs16.writeFileSync(path16.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs17.mkdirSync(path17.join(home2, ".arules"), { recursive: true });
+    fs17.writeFileSync(path17.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p3.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs16.mkdirSync(path16.join(home2, ".aflow"), { recursive: true });
-    fs16.writeFileSync(path16.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs17.mkdirSync(path17.join(home2, ".aflow"), { recursive: true });
+    fs17.writeFileSync(path17.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p3.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }