@aman_asmuei/aman-agent 0.2.4 → 0.3.1

package/dist/index.js

@@ -1,18 +1,28 @@
 // src/index.ts
 import { Command } from "commander";
-import * as p from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 import pc5 from "picocolors";
 
 // src/config.ts
 import fs from "fs";
 import path from "path";
 import os from "os";
+var DEFAULT_HOOKS = {
+  memoryRecall: true,
+  sessionResume: true,
+  rulesCheck: true,
+  workflowSuggest: true,
+  evalPrompt: true,
+  autoSessionSave: true
+};
 var CONFIG_DIR = path.join(os.homedir(), ".aman-agent");
 var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 function loadConfig() {
   if (!fs.existsSync(CONFIG_PATH)) return null;
   try {
-    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    const raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    raw.hooks = { ...DEFAULT_HOOKS, ...raw.hooks };
+    return raw;
   } catch {
     return null;
   }
@@ -91,10 +101,10 @@ var ECOSYSTEM_FILES = [
   { name: "skills", dir: ".askill", file: "skills.md" }
 ];
 function assembleSystemPrompt(maxTokens) {
-  const home = os2.homedir();
+  const home2 = os2.homedir();
   const components = [];
   for (const entry of ECOSYSTEM_FILES) {
-    const filePath = path2.join(home, entry.dir, entry.file);
+    const filePath = path2.join(home2, entry.dir, entry.file);
     if (fs2.existsSync(filePath)) {
       const content = fs2.readFileSync(filePath, "utf-8").trim();
       components.push({
@@ -503,152 +513,425 @@ import * as readline from "readline";
 import pc3 from "picocolors";
 
 // src/commands.ts
+import fs4 from "fs";
+import path4 from "path";
+import os4 from "os";
+import { execFileSync } from "child_process";
+import pc from "picocolors";
+
+// src/layers/parsers.ts
 import fs3 from "fs";
 import path3 from "path";
 import os3 from "os";
-import { execFileSync } from "child_process";
-import pc from "picocolors";
+var home = os3.homedir();
+var LAYER_FILES = [
+  { name: "identity", dir: ".acore", file: "core.md" },
+  { name: "rules", dir: ".arules", file: "rules.md" },
+  { name: "workflows", dir: ".aflow", file: "flow.md" },
+  { name: "tools", dir: ".akit", file: "kit.md" },
+  { name: "skills", dir: ".askill", file: "skills.md" },
+  { name: "eval", dir: ".aeval", file: "eval.md" }
+];
+function countLines(content, pattern) {
+  return (content.match(pattern) || []).length;
+}
+function getLayerSummary(name, content) {
+  switch (name) {
+    case "identity": {
+      const nameMatch = content.match(/^# (.+)/m);
+      return nameMatch ? nameMatch[1] : "configured";
+    }
+    case "rules":
+      return `${countLines(content, /^- /gm)} rules`;
+    case "workflows":
+      return `${countLines(content, /^## /gm)} workflows`;
+    case "tools":
+      return `${countLines(content, /^- \*\*/gm)} tools`;
+    case "skills":
+      return `${countLines(content, /^### /gm)} skills`;
+    case "eval": {
+      const sessions = countLines(content, /^### Session/gm);
+      return `${sessions} sessions logged`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function getEcosystemStatus(mcpToolCount, amemConnected) {
+  const layers = LAYER_FILES.map((entry) => {
+    const filePath = path3.join(home, entry.dir, entry.file);
+    const exists = fs3.existsSync(filePath);
+    let summary = "not configured";
+    if (exists) {
+      const content = fs3.readFileSync(filePath, "utf-8");
+      summary = getLayerSummary(entry.name, content);
+    }
+    return { name: entry.name, exists, path: filePath, summary };
+  });
+  return {
+    layers,
+    mcpConnected: mcpToolCount > 0,
+    mcpToolCount,
+    amemConnected
+  };
+}
+
+// src/commands.ts
 function readEcosystemFile(filePath, label) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     return pc.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs3.readFileSync(filePath, "utf-8").trim();
+  return fs4.readFileSync(filePath, "utf-8").trim();
+}
+function parseCommand(input) {
+  const trimmed = input.trim();
+  const parts = trimmed.split(/\s+/);
+  const base = parts[0].toLowerCase().replace(/^\//, "");
+  const action = parts.length > 1 ? parts[1].toLowerCase() : void 0;
+  const args = parts.slice(2);
+  return { base, action, args };
 }
-function handleCommand(input, model) {
-  const cmd = input.trim().toLowerCase();
-  const home = os3.homedir();
-  if (cmd === "/quit" || cmd === "/exit" || cmd === "/q") {
-    return { handled: true, quit: true };
+async function mcpWrite(ctx, layer, tool, args) {
+  if (!ctx.mcpManager) {
+    return pc.red(`Cannot modify ${layer}: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp`);
   }
-  if (cmd === "/help") {
-    return {
-      handled: true,
-      output: [
-        pc.bold("Commands:"),
-        `  ${pc.cyan("/help")}       Show this help`,
-        `  ${pc.cyan("/identity")}   View your AI identity`,
-        `  ${pc.cyan("/tools")}      View installed tools`,
-        `  ${pc.cyan("/workflows")}  View defined workflows`,
-        `  ${pc.cyan("/rules")}      View guardrails`,
-        `  ${pc.cyan("/skills")}     View installed skills`,
-        `  ${pc.cyan("/remind")}     Set a reminder (e.g. /remind 30m Review PR)`,
-        `  ${pc.cyan("/model")}      Show current LLM model`,
-        `  ${pc.cyan("/update")}     Check for updates`,
-        `  ${pc.cyan("/reconfig")}   Reset LLM config (provider, model, API key)`,
-        `  ${pc.cyan("/clear")}      Clear conversation history`,
-        `  ${pc.cyan("/quit")}       Exit`
-      ].join("\n")
-    };
+  const result = await ctx.mcpManager.callTool(tool, args);
+  if (result.startsWith("Error")) {
+    return pc.red(result);
   }
-  if (cmd === "/identity") {
-    const content = readEcosystemFile(
-      path3.join(home, ".acore", "core.md"),
-      "identity (acore)"
-    );
+  return pc.green(result);
+}
+async function handleIdentityCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".acore", "core.md"), "identity (acore)");
     return { handled: true, output: content };
   }
-  if (cmd === "/tools") {
-    const content = readEcosystemFile(
-      path3.join(home, ".akit", "kit.md"),
-      "tools (akit)"
-    );
+  if (action === "update") {
+    if (args.length === 0) {
+      return {
+        handled: true,
+        output: pc.yellow("Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via MCP.")
+      };
+    }
+    const section = args[0];
+    const content = args.slice(1).join(" ");
+    if (!content) {
+      return {
+        handled: true,
+        output: pc.yellow("Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct.")
+      };
+    }
+    const output = await mcpWrite(ctx, "identity", "identity_update_section", { section, content });
+    return { handled: true, output };
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
+}
+async function handleRulesCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".arules", "rules.md"), "guardrails (arules)");
     return { handled: true, output: content };
   }
-  if (cmd === "/workflows") {
-    const content = readEcosystemFile(
-      path3.join(home, ".aflow", "flow.md"),
-      "workflows (aflow)"
-    );
+  if (action === "add") {
+    if (args.length < 2) {
+      return { handled: true, output: pc.yellow("Usage: /rules add <category> <rule text...>") };
+    }
+    const category = args[0];
+    const rule = args.slice(1).join(" ");
+    const output = await mcpWrite(ctx, "rules", "rules_add", { category, rule });
+    return { handled: true, output };
+  }
+  if (action === "remove") {
+    if (args.length < 2) {
+      return { handled: true, output: pc.yellow("Usage: /rules remove <category> <index>") };
+    }
+    const output = await mcpWrite(ctx, "rules", "rules_remove", { category: args[0], index: parseInt(args[1], 10) });
+    return { handled: true, output };
+  }
+  if (action === "toggle") {
+    if (args.length < 2) {
+      return { handled: true, output: pc.yellow("Usage: /rules toggle <category> <index>") };
+    }
+    const output = await mcpWrite(ctx, "rules", "rules_toggle", { category: args[0], index: parseInt(args[1], 10) });
+    return { handled: true, output };
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
+}
+async function handleWorkflowsCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
-  if (cmd === "/rules") {
-    const content = readEcosystemFile(
-      path3.join(home, ".arules", "rules.md"),
-      "guardrails (arules)"
-    );
+  if (action === "add") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /workflows add <name>") };
+    }
+    const output = await mcpWrite(ctx, "workflows", "workflow_add", { name: args.join(" ") });
+    return { handled: true, output };
+  }
+  if (action === "remove") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /workflows remove <name>") };
+    }
+    const output = await mcpWrite(ctx, "workflows", "workflow_remove", { name: args.join(" ") });
+    return { handled: true, output };
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /workflows ${action}. Use /workflows [add|remove].`) };
+}
+async function handleToolsCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".akit", "kit.md"), "tools (akit)");
     return { handled: true, output: content };
   }
-  if (cmd === "/skills") {
-    const content = readEcosystemFile(
-      path3.join(home, ".askill", "skills.md"),
-      "skills (askill)"
-    );
+  if (action === "add") {
+    if (args.length < 3) {
+      return { handled: true, output: pc.yellow("Usage: /tools add <name> <type> <description...>") };
+    }
+    const name = args[0];
+    const type = args[1];
+    const description = args.slice(2).join(" ");
+    const output = await mcpWrite(ctx, "tools", "tools_add", { name, type, description });
+    return { handled: true, output };
+  }
+  if (action === "remove") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /tools remove <name>") };
+    }
+    const output = await mcpWrite(ctx, "tools", "tools_remove", { name: args.join(" ") });
+    return { handled: true, output };
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /tools ${action}. Use /tools [add|remove].`) };
+}
+async function handleSkillsCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
-  if (cmd === "/model") {
-    return {
-      handled: true,
-      output: model ? `Model: ${pc.bold(model)}` : "Model: unknown"
-    };
+  if (action === "install") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /skills install <name>") };
+    }
+    const output = await mcpWrite(ctx, "skills", "skill_install", { name: args.join(" ") });
+    return { handled: true, output };
   }
-  if (cmd === "/update-config" || cmd === "/reconfig") {
-    const configPath = path3.join(os3.homedir(), ".aman-agent", "config.json");
-    if (fs3.existsSync(configPath)) {
-      fs3.unlinkSync(configPath);
+  if (action === "uninstall") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /skills uninstall <name>") };
     }
-    return {
-      handled: true,
-      quit: true,
-      output: [
-        pc.green("Config reset."),
-        `Run ${pc.bold("npx @aman_asmuei/aman-agent")} again to reconfigure your LLM provider, model, and API key.`
-      ].join("\n")
-    };
+    const output = await mcpWrite(ctx, "skills", "skill_uninstall", { name: args.join(" ") });
+    return { handled: true, output };
   }
-  if (cmd === "/update" || cmd === "/upgrade") {
-    try {
-      const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-      const local = JSON.parse(fs3.readFileSync(path3.join(__dirname, "..", "package.json"), "utf-8")).version;
-      if (current === local) {
-        return { handled: true, output: `${pc.green("Up to date")} \u2014 v${local}` };
-      }
-      return {
-        handled: true,
-        output: [
-          `${pc.yellow("Update available:")} v${local} \u2192 v${current}`,
-          "",
-          `Run this in your terminal:`,
-          `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
-          "",
-          `Or use npx (always latest):`,
-          `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
-        ].join("\n")
-      };
-    } catch {
+  return { handled: true, output: pc.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
+}
+async function handleEvalCommand(action, args, ctx) {
+  const home2 = os4.homedir();
+  if (!action) {
+    const content = readEcosystemFile(path4.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    return { handled: true, output: content };
+  }
+  if (action === "milestone") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /eval milestone <text...>") };
+    }
+    const text2 = args.join(" ");
+    const output = await mcpWrite(ctx, "eval", "eval_milestone", { text: text2 });
+    return { handled: true, output };
+  }
+  return { handled: true, output: pc.yellow(`Unknown action: /eval ${action}. Use /eval or /eval milestone <text>.`) };
+}
+async function handleMemoryCommand(action, args, ctx) {
+  if (!action) {
+    if (!ctx.mcpManager) {
       return {
         handled: true,
-        output: [
-          `To update, run in your terminal:`,
-          `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
-          "",
-          `Or use npx (always latest):`,
-          `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
-        ].join("\n")
+        output: pc.red("Memory not available: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp")
       };
     }
+    const result = await ctx.mcpManager.callTool("memory_context", {});
+    if (result.startsWith("Error")) {
+      return { handled: true, output: pc.red(result) };
+    }
+    return { handled: true, output: result };
   }
-  if (cmd === "/clear") {
-    return { handled: true, output: pc.dim("Conversation cleared."), clearHistory: true };
+  if (action === "search") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /memory search <query...>") };
+    }
+    const query = args.join(" ");
+    const output = await mcpWrite(ctx, "memory", "memory_recall", { query });
+    return { handled: true, output };
   }
-  if (cmd.startsWith("/remind")) {
-    const parts = input.trim().split(/\s+/);
-    if (parts.length < 3) {
-      return {
-        handled: true,
-        output: "Usage: /remind <time> <message>\nExamples: /remind 30m Review PR, /remind 2h Deploy, /remind tomorrow Check metrics"
-      };
+  if (action === "clear") {
+    if (args.length < 1) {
+      return { handled: true, output: pc.yellow("Usage: /memory clear <category>") };
     }
-    const timeStr = parts[1];
-    const message = parts.slice(2).join(" ");
-    return { handled: true, remind: { timeStr, message } };
+    const output = await mcpWrite(ctx, "memory", "memory_forget", { category: args[0] });
+    return { handled: true, output };
   }
-  if (cmd.startsWith("/")) {
+  return { handled: true, output: pc.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear].`) };
+}
+function handleStatusCommand(ctx) {
+  const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
+  const amemConnected = mcpToolCount > 0;
+  const status = getEcosystemStatus(mcpToolCount, amemConnected);
+  const lines = [pc.bold("Aman Ecosystem Dashboard"), ""];
+  for (const layer of status.layers) {
+    const icon = layer.exists ? pc.green("\u25CF") : pc.dim("\u25CB");
+    const name = pc.bold(layer.name.padEnd(12));
+    const summary = layer.exists ? layer.summary : pc.dim("not configured");
+    lines.push(`  ${icon} ${name} ${summary}`);
+  }
+  lines.push("");
+  lines.push(`  ${status.mcpConnected ? pc.green("\u25CF") : pc.dim("\u25CB")} ${pc.bold("MCP".padEnd(12))} ${status.mcpConnected ? `${status.mcpToolCount} tools available` : pc.dim("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc.green("\u25CF") : pc.dim("\u25CB")} ${pc.bold("Memory".padEnd(12))} ${status.amemConnected ? "connected" : pc.dim("not connected")}`);
+  return { handled: true, output: lines.join("\n") };
+}
+function handleDoctorCommand(ctx) {
+  const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
+  const amemConnected = mcpToolCount > 0;
+  const status = getEcosystemStatus(mcpToolCount, amemConnected);
+  const lines = [pc.bold("Aman Health Check"), ""];
+  for (const layer of status.layers) {
+    const check = layer.exists ? pc.green("\u2713") : pc.red("\u2717");
+    const name = layer.name.padEnd(12);
+    const detail = layer.exists ? pc.green(layer.summary) : pc.red("missing");
+    lines.push(`  ${check} ${name} ${detail}`);
+  }
+  lines.push("");
+  lines.push(`  ${status.mcpConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc.green(`${status.mcpToolCount} tools`) : pc.red("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc.green("connected") : pc.red("not connected")}`);
+  return { handled: true, output: lines.join("\n") };
+}
+function handleHelp() {
+  return {
+    handled: true,
+    output: [
+      pc.bold("Commands:"),
+      `  ${pc.cyan("/help")}         Show this help`,
+      `  ${pc.cyan("/identity")}     View identity [update <section>]`,
+      `  ${pc.cyan("/rules")}        View rules [add|remove|toggle ...]`,
+      `  ${pc.cyan("/workflows")}    View workflows [add|remove ...]`,
+      `  ${pc.cyan("/tools")}        View tools [add|remove ...]`,
+      `  ${pc.cyan("/skills")}       View skills [install|uninstall ...]`,
+      `  ${pc.cyan("/eval")}         View evaluation [milestone ...]`,
+      `  ${pc.cyan("/memory")}       View recent memories [search|clear ...]`,
+      `  ${pc.cyan("/status")}       Ecosystem dashboard`,
+      `  ${pc.cyan("/doctor")}       Health check all layers`,
+      `  ${pc.cyan("/remind")}       Set a reminder`,
+      `  ${pc.cyan("/model")}        Show current LLM model`,
+      `  ${pc.cyan("/update")}       Check for updates`,
+      `  ${pc.cyan("/reconfig")}     Reset LLM config`,
+      `  ${pc.cyan("/clear")}        Clear conversation history`,
+      `  ${pc.cyan("/quit")}         Exit`
+    ].join("\n")
+  };
+}
+function handleRemind(input) {
+  const parts = input.trim().split(/\s+/);
+  if (parts.length < 3) {
     return {
       handled: true,
-      output: `Unknown command: ${cmd}. Type ${pc.cyan("/help")} for available commands.`
+      output: "Usage: /remind <time> <message>\nExamples: /remind 30m Review PR, /remind 2h Deploy, /remind tomorrow Check metrics"
     };
   }
-  return { handled: false };
+  const timeStr = parts[1];
+  const message = parts.slice(2).join(" ");
+  return { handled: true, remind: { timeStr, message } };
+}
+function handleReconfig() {
+  const configPath = path4.join(os4.homedir(), ".aman-agent", "config.json");
+  if (fs4.existsSync(configPath)) {
+    fs4.unlinkSync(configPath);
+  }
+  return {
+    handled: true,
+    quit: true,
+    output: [
+      pc.green("Config reset."),
+      `Run ${pc.bold("npx @aman_asmuei/aman-agent")} again to reconfigure your LLM provider, model, and API key.`
+    ].join("\n")
+  };
+}
+function handleUpdate() {
+  try {
+    const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
+    const local = JSON.parse(fs4.readFileSync(path4.join(__dirname, "..", "package.json"), "utf-8")).version;
+    if (current === local) {
+      return { handled: true, output: `${pc.green("Up to date")} \u2014 v${local}` };
+    }
+    return {
+      handled: true,
+      output: [
+        `${pc.yellow("Update available:")} v${local} \u2192 v${current}`,
+        "",
+        `Run this in your terminal:`,
+        `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        "",
+        `Or use npx (always latest):`,
+        `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
+      ].join("\n")
+    };
+  } catch {
+    return {
+      handled: true,
+      output: [
+        `To update, run in your terminal:`,
+        `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        "",
+        `Or use npx (always latest):`,
+        `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
+      ].join("\n")
+    };
+  }
+}
+async function handleCommand(input, ctx) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return { handled: false };
+  const { base, action, args } = parseCommand(trimmed);
+  switch (base) {
+    case "quit":
+    case "exit":
+    case "q":
+      return { handled: true, quit: true };
+    case "help":
+      return handleHelp();
+    case "clear":
+      return { handled: true, output: pc.dim("Conversation cleared."), clearHistory: true };
+    case "model":
+      return { handled: true, output: ctx.model ? `Model: ${pc.bold(ctx.model)}` : "Model: unknown" };
+    case "identity":
+      return handleIdentityCommand(action, args, ctx);
+    case "rules":
+      return handleRulesCommand(action, args, ctx);
+    case "workflows":
+      return handleWorkflowsCommand(action, args, ctx);
+    case "tools":
+      return handleToolsCommand(action, args, ctx);
+    case "skills":
+      return handleSkillsCommand(action, args, ctx);
+    case "eval":
+      return handleEvalCommand(action, args, ctx);
+    case "memory":
+      return handleMemoryCommand(action, args, ctx);
+    case "status":
+      return handleStatusCommand(ctx);
+    case "doctor":
+      return handleDoctorCommand(ctx);
+    case "remind":
+      return handleRemind(trimmed);
+    case "update-config":
+    case "reconfig":
+      return handleReconfig();
+    case "update":
+    case "upgrade":
+      return handleUpdate();
+    default:
+      return { handled: true, output: `Unknown command: /${base}. Type ${pc.cyan("/help")} for available commands.` };
+  }
 }
 
 // src/reminders.ts
@@ -690,14 +973,175 @@ function clearReminders() {
   activeReminders.length = 0;
 }
 
+// src/hooks.ts
+import * as p from "@clack/prompts";
+var isHookCall = false;
+async function onSessionStart(ctx) {
+  let greeting = "";
+  let contextInjection = "";
+  if (ctx.config.memoryRecall) {
+    try {
+      isHookCall = true;
+      const result = await ctx.mcpManager.callTool("memory_context", {});
+      if (result && !result.startsWith("Error")) {
+        greeting += result;
+      }
+    } catch {
+    } finally {
+      isHookCall = false;
+    }
+  }
+  if (ctx.config.sessionResume) {
+    try {
+      isHookCall = true;
+      const result = await ctx.mcpManager.callTool("identity_summary", {});
+      if (result && !result.startsWith("Error")) {
+        if (greeting) greeting += "\n";
+        greeting += result;
+      }
+    } catch {
+    } finally {
+      isHookCall = false;
+    }
+  }
+  if (greeting) {
+    contextInjection = `<session-context>
+${greeting}
+</session-context>`;
+  }
+  return {
+    greeting: greeting || void 0,
+    contextInjection: contextInjection || void 0
+  };
+}
+async function onBeforeToolExec(toolName, toolArgs, ctx) {
+  if (!ctx.config.rulesCheck || isHookCall) {
+    return { allow: true };
+  }
+  if (toolName === "rules_check") {
+    return { allow: true };
+  }
+  try {
+    isHookCall = true;
+    const description = `${toolName}(${JSON.stringify(toolArgs)})`;
+    const result = await ctx.mcpManager.callTool("rules_check", {
+      action: description
+    });
+    try {
+      const parsed = JSON.parse(result);
+      if (parsed.violations && parsed.violations.length > 0) {
+        return {
+          allow: false,
+          reason: parsed.violations.join("; ")
+        };
+      }
+    } catch {
+    }
+    return { allow: true };
+  } catch {
+    return { allow: true };
+  } finally {
+    isHookCall = false;
+  }
+}
+async function onWorkflowMatch(userInput, ctx) {
+  if (!ctx.config.workflowSuggest) {
+    return null;
+  }
+  try {
+    isHookCall = true;
+    const result = await ctx.mcpManager.callTool("workflow_list", {});
+    const workflows = JSON.parse(result);
+    const inputLower = userInput.toLowerCase();
+    for (const wf of workflows) {
+      const nameLower = wf.name.toLowerCase();
+      if (inputLower.includes(nameLower)) {
+        const steps = (wf.steps || []).map((s, i) => `${i + 1}. ${s}`).join("\n");
+        return { name: wf.name, steps };
+      }
+      if (wf.description) {
+        const words = wf.description.split(/\s+/).filter((w) => w.length > 4).map((w) => w.toLowerCase());
+        for (const word of words) {
+          if (inputLower.includes(word)) {
+            const steps = (wf.steps || []).map((s, i) => `${i + 1}. ${s}`).join("\n");
+            return { name: wf.name, steps };
+          }
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    isHookCall = false;
+  }
+}
+async function onSessionEnd(ctx, messages) {
+  try {
+    if (ctx.config.evalPrompt) {
+      const rating = await p.select({
+        message: "Quick rating for this session?",
+        options: [
+          { value: "great", label: "Great" },
+          { value: "good", label: "Good" },
+          { value: "okay", label: "Okay" },
+          { value: "skip", label: "Skip" }
+        ],
+        initialValue: "skip"
+      });
+      if (!p.isCancel(rating) && rating !== "skip") {
+        try {
+          isHookCall = true;
+          await ctx.mcpManager.callTool("eval_log", {
+            rating,
+            highlights: "Quick session rating",
+            improvements: ""
+          });
+        } finally {
+          isHookCall = false;
+        }
+      }
+    }
+    if (ctx.config.autoSessionSave && messages.length > 2) {
+      let lastUserMsg = "";
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user" && typeof messages[i].content === "string") {
+          lastUserMsg = messages[i].content;
+          break;
+        }
+      }
+      if (lastUserMsg) {
+        try {
+          isHookCall = true;
+          await ctx.mcpManager.callTool("identity_update_session", {
+            resume: lastUserMsg.slice(0, 200),
+            topics: "See conversation history",
+            decisions: "See conversation history"
+          });
+        } finally {
+          isHookCall = false;
+        }
+      }
+    }
+  } catch {
+  }
+}
+
 // src/agent.ts
-async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager) {
+async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager, hooksConfig) {
   const messages = [];
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  rl.on("SIGINT", () => {
+  rl.on("SIGINT", async () => {
+    if (mcpManager && hooksConfig) {
+      try {
+        const hookCtx = { mcpManager, config: hooksConfig };
+        await onSessionEnd(hookCtx, messages);
+      } catch {
+      }
+    }
     console.log(pc3.dim("\nGoodbye.\n"));
     rl.close();
     process.exit(0);
@@ -714,13 +1158,32 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager)
 Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit.
 `
   );
+  if (mcpManager && hooksConfig) {
+    const hookCtx = { mcpManager, config: hooksConfig };
+    try {
+      const session = await onSessionStart(hookCtx);
+      if (session.greeting) console.log(pc3.dim(session.greeting));
+      if (session.contextInjection) {
+        messages.push({ role: "user", content: session.contextInjection });
+        messages.push({ role: "assistant", content: "I have context from our previous sessions. How can I help?" });
+      }
+    } catch {
+    }
+  }
   while (true) {
     const input = await prompt();
     if (!input.trim()) continue;
-    const cmdResult = handleCommand(input, model);
+    const cmdResult = await handleCommand(input, { model, mcpManager });
     if (cmdResult.handled) {
       if (cmdResult.quit) {
         clearReminders();
+        if (mcpManager && hooksConfig) {
+          try {
+            const hookCtx = { mcpManager, config: hooksConfig };
+            await onSessionEnd(hookCtx, messages);
+          } catch {
+          }
+        }
         console.log(pc3.dim("\nGoodbye.\n"));
         rl.close();
         return;
@@ -747,12 +1210,33 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
       }
       continue;
     }
+    let activeSystemPrompt = systemPrompt;
+    if (mcpManager && hooksConfig) {
+      try {
+        const hookCtx = { mcpManager, config: hooksConfig };
+        const wfMatch = await onWorkflowMatch(input, hookCtx);
+        if (wfMatch) {
+          const useIt = await new Promise((resolve) => {
+            rl.question(pc3.dim(`  Workflow "${wfMatch.name}" matches. Use it? (y/N) `), (answer) => resolve(answer.toLowerCase() === "y"));
+          });
+          if (useIt) {
+            activeSystemPrompt = systemPrompt + `
+
+<active-workflow>
+${wfMatch.steps}
+</active-workflow>`;
+            console.log(pc3.dim(`  Using "${wfMatch.name}" workflow.`));
+          }
+        }
+      } catch {
+      }
+    }
     messages.push({ role: "user", content: input });
     process.stdout.write(pc3.cyan(`
 ${aiName} > `));
     try {
       let response = await client.chat(
-        systemPrompt,
+        activeSystemPrompt,
         messages,
         (chunk) => {
           if (chunk.type === "text" && chunk.text) {
@@ -768,6 +1252,21 @@ ${aiName} > `));
       while (response.toolUses.length > 0 && mcpManager) {
         const toolResults = [];
         for (const toolUse of response.toolUses) {
+          if (hooksConfig) {
+            const hookCtx = { mcpManager, config: hooksConfig };
+            const check = await onBeforeToolExec(toolUse.name, toolUse.input, hookCtx);
+            if (!check.allow) {
+              process.stdout.write(pc3.red(`  [BLOCKED: ${check.reason}]
+`));
+              toolResults.push({
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `BLOCKED by guardrail: ${check.reason}`,
+                is_error: true
+              });
+              continue;
+            }
+          }
           process.stdout.write(
             pc3.dim(`  [using ${toolUse.name}...]
 `)
@@ -787,7 +1286,7 @@ ${aiName} > `));
           content: toolResults
         });
         response = await client.chat(
-          systemPrompt,
+          activeSystemPrompt,
           messages,
           (chunk) => {
             if (chunk.type === "text" && chunk.text) {
@@ -811,22 +1310,22 @@ Error: ${message}`));
 }
 
 // src/scheduler.ts
-import fs4 from "fs";
-import path4 from "path";
-import os4 from "os";
-var SCHEDULES_PATH = path4.join(os4.homedir(), ".aman-agent", "schedules.json");
+import fs5 from "fs";
+import path5 from "path";
+import os5 from "os";
+var SCHEDULES_PATH = path5.join(os5.homedir(), ".aman-agent", "schedules.json");
 function loadSchedules() {
-  if (!fs4.existsSync(SCHEDULES_PATH)) return [];
+  if (!fs5.existsSync(SCHEDULES_PATH)) return [];
   try {
-    return JSON.parse(fs4.readFileSync(SCHEDULES_PATH, "utf-8"));
+    return JSON.parse(fs5.readFileSync(SCHEDULES_PATH, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveSchedules(tasks) {
-  const dir = path4.dirname(SCHEDULES_PATH);
-  fs4.mkdirSync(dir, { recursive: true });
-  fs4.writeFileSync(
+  const dir = path5.dirname(SCHEDULES_PATH);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(
     SCHEDULES_PATH,
     JSON.stringify(tasks, null, 2) + "\n",
     "utf-8"
@@ -879,9 +1378,9 @@ function isDue(schedule, lastRun, now) {
 }
 
 // src/notifications.ts
-import fs5 from "fs";
-import path5 from "path";
-import os5 from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
 import pc4 from "picocolors";
 function checkNotifications() {
   const notifications = [];
@@ -892,9 +1391,9 @@ function checkNotifications() {
       message: `${task.name} (${task.schedule})`
     });
   }
-  const evalPath = path5.join(os5.homedir(), ".aeval", "eval.md");
-  if (fs5.existsSync(evalPath)) {
-    const content = fs5.readFileSync(evalPath, "utf-8");
+  const evalPath = path6.join(os6.homedir(), ".aeval", "eval.md");
+  if (fs6.existsSync(evalPath)) {
+    const content = fs6.readFileSync(evalPath, "utf-8");
     const dateMatch = content.match(/- Last updated: (.+)$/m);
     if (dateMatch) {
       const lastDate = new Date(dateMatch[1]);
@@ -924,16 +1423,16 @@ function displayNotifications(notifications) {
 }
 
 // src/index.ts
-import fs6 from "fs";
-import path6 from "path";
-import os6 from "os";
+import fs7 from "fs";
+import path7 from "path";
+import os7 from "os";
 var program = new Command();
 program.name("aman-agent").description("Your AI companion, running locally").version("0.1.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).action(async (options) => {
-  p.intro(pc5.bold("aman agent") + pc5.dim(" \u2014 starting your AI companion"));
+  p2.intro(pc5.bold("aman agent") + pc5.dim(" \u2014 starting your AI companion"));
   let config = loadConfig();
   if (!config) {
-    p.log.info("First-time setup \u2014 configure your LLM connection.");
-    const provider = await p.select({
+    p2.log.info("First-time setup \u2014 configure your LLM connection.");
+    const provider = await p2.select({
       message: "LLM provider",
       options: [
         {
@@ -946,27 +1445,27 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
       ],
       initialValue: "anthropic"
     });
-    if (p.isCancel(provider)) process.exit(0);
+    if (p2.isCancel(provider)) process.exit(0);
     let apiKey = "";
     let defaultModel = "";
     if (provider === "ollama") {
       apiKey = "ollama";
-      const modelInput = await p.text({
+      const modelInput = await p2.text({
         message: "Ollama model name",
         placeholder: "llama3.2",
         defaultValue: "llama3.2"
       });
-      if (p.isCancel(modelInput)) process.exit(0);
+      if (p2.isCancel(modelInput)) process.exit(0);
       defaultModel = modelInput || "llama3.2";
     } else if (provider === "anthropic") {
-      p.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
-      p.log.info(pc5.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
-      apiKey = await p.text({
+      p2.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
+      p2.log.info(pc5.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
+      apiKey = await p2.text({
         message: "API key (starts with sk-ant-)",
         validate: (v) => v.length === 0 ? "API key is required" : void 0
       });
-      if (p.isCancel(apiKey)) process.exit(0);
-      const modelChoice = await p.select({
+      if (p2.isCancel(apiKey)) process.exit(0);
+      const modelChoice = await p2.select({
         message: "Claude model",
         options: [
           { value: "claude-sonnet-4-5-20250514", label: "Claude Sonnet 4.5", hint: "fast, recommended" },
@@ -976,25 +1475,25 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         ],
         initialValue: "claude-sonnet-4-5-20250514"
       });
-      if (p.isCancel(modelChoice)) process.exit(0);
+      if (p2.isCancel(modelChoice)) process.exit(0);
       if (modelChoice === "custom") {
-        const customModel = await p.text({
+        const customModel = await p2.text({
           message: "Model ID",
           placeholder: "claude-sonnet-4-5-20250514",
           validate: (v) => v.length === 0 ? "Model ID is required" : void 0
         });
-        if (p.isCancel(customModel)) process.exit(0);
+        if (p2.isCancel(customModel)) process.exit(0);
         defaultModel = customModel;
       } else {
         defaultModel = modelChoice;
       }
     } else {
-      apiKey = await p.text({
+      apiKey = await p2.text({
         message: "API key",
         validate: (v) => v.length === 0 ? "API key is required" : void 0
       });
-      if (p.isCancel(apiKey)) process.exit(0);
-      const modelChoice = await p.select({
+      if (p2.isCancel(apiKey)) process.exit(0);
+      const modelChoice = await p2.select({
         message: "OpenAI model",
         options: [
           { value: "gpt-4o", label: "GPT-4o", hint: "recommended" },
@@ -1004,14 +1503,14 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         ],
         initialValue: "gpt-4o"
       });
-      if (p.isCancel(modelChoice)) process.exit(0);
+      if (p2.isCancel(modelChoice)) process.exit(0);
       if (modelChoice === "custom") {
-        const customModel = await p.text({
+        const customModel = await p2.text({
           message: "Model ID",
           placeholder: "gpt-4o",
           validate: (v) => v.length === 0 ? "Model ID is required" : void 0
         });
-        if (p.isCancel(customModel)) process.exit(0);
+        if (p2.isCancel(customModel)) process.exit(0);
         defaultModel = customModel;
       } else {
         defaultModel = modelChoice;
@@ -1019,44 +1518,44 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     }
     config = { provider, apiKey, model: defaultModel };
     saveConfig(config);
-    p.log.success("Config saved to ~/.aman-agent/config.json");
+    p2.log.success("Config saved to ~/.aman-agent/config.json");
   }
   const model = options.model || config.model;
   const budget = options.budget || void 0;
   const { prompt: systemPrompt, layers, truncated, totalTokens } = assembleSystemPrompt(budget);
   if (layers.length === 0) {
-    p.log.warning(
+    p2.log.warning(
       "No ecosystem configured. Run " + pc5.bold("npx @aman_asmuei/aman") + " first."
     );
-    p.log.info("Starting with empty system prompt.");
+    p2.log.info("Starting with empty system prompt.");
   } else {
-    p.log.success(
+    p2.log.success(
       `Loaded: ${layers.join(", ")} ${pc5.dim(`(${totalTokens.toLocaleString()} tokens)`)}`
     );
     if (truncated.length > 0) {
-      p.log.warning(`Truncated: ${truncated.join(", ")} ${pc5.dim("(over budget)")}`);
+      p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc5.dim("(over budget)")}`);
     }
   }
-  p.log.info(`Model: ${pc5.dim(model)}`);
-  const corePath = path6.join(os6.homedir(), ".acore", "core.md");
+  p2.log.info(`Model: ${pc5.dim(model)}`);
+  const corePath = path7.join(os7.homedir(), ".acore", "core.md");
   let aiName = "Assistant";
-  if (fs6.existsSync(corePath)) {
-    const content = fs6.readFileSync(corePath, "utf-8");
+  if (fs7.existsSync(corePath)) {
+    const content = fs7.readFileSync(corePath, "utf-8");
     const match = content.match(/^# (.+)$/m);
     if (match) aiName = match[1];
   }
-  p.log.success(`${pc5.bold(aiName)} is ready.`);
+  p2.log.success(`${pc5.bold(aiName)} is ready.`);
   const notifications = checkNotifications();
   displayNotifications(notifications);
   const mcpManager = new McpManager();
-  p.log.step("Connecting to MCP servers...");
+  p2.log.step("Connecting to MCP servers...");
   await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
   await mcpManager.connect("amem", "npx", ["-y", "@aman_asmuei/amem"]);
   const mcpTools = mcpManager.getTools();
   if (mcpTools.length > 0) {
-    p.log.success(`${mcpTools.length} MCP tools available`);
+    p2.log.success(`${mcpTools.length} MCP tools available`);
   } else {
-    p.log.info(
+    p2.log.info(
       "No MCP tools connected (install aman-mcp or amem for tool support)"
     );
   }
@@ -1079,7 +1578,8 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
     aiName,
     model,
     toolDefs.length > 0 ? toolDefs : void 0,
-    toolDefs.length > 0 ? mcpManager : void 0
+    toolDefs.length > 0 ? mcpManager : void 0,
+    config.hooks
   );
   await mcpManager.disconnect();
 });
@@ -1100,12 +1600,12 @@ program.command("schedule").description("Manage scheduled tasks").argument("[act
     return;
   }
   if (action === "add") {
-    const name = await p.text({
+    const name = await p2.text({
       message: "Task name?",
       validate: (v) => v.length === 0 ? "Name is required" : void 0
     });
-    if (p.isCancel(name)) return;
-    const schedule = await p.select({
+    if (p2.isCancel(name)) return;
+    const schedule = await p2.select({
       message: "Schedule?",
       options: [
         { value: "daily 9am", label: "Daily at 9am" },
@@ -1115,23 +1615,23 @@ program.command("schedule").description("Manage scheduled tasks").argument("[act
         { value: "every 4h", label: "Every 4 hours" }
       ]
     });
-    if (p.isCancel(schedule)) return;
-    const actionType = await p.select({
+    if (p2.isCancel(schedule)) return;
+    const actionType = await p2.select({
       message: "What should happen?",
       options: [
         { value: "notify", label: "Show notification" },
         { value: "auto-run", label: "Run automatically" }
       ]
     });
-    if (p.isCancel(actionType)) return;
+    if (p2.isCancel(actionType)) return;
     let taskAction = "notify";
     if (actionType === "auto-run") {
-      const cmd = await p.text({
+      const cmd = await p2.text({
         message: "Command to run?",
         placeholder: "e.g. run:daily-standup",
         validate: (v) => v.length === 0 ? "Command is required" : void 0
       });
-      if (p.isCancel(cmd)) return;
+      if (p2.isCancel(cmd)) return;
       taskAction = cmd;
     }
     const task = addSchedule({