@aman_asmuei/aman-agent 0.28.0 → 0.30.0

package/dist/index.js

@@ -1721,20 +1721,20 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs20 from "fs";
-import path20 from "path";
-import os19 from "os";
+import fs21 from "fs";
+import path21 from "path";
+import os20 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs17 from "fs";
-import path17 from "path";
-import os16 from "os";
+import fs18 from "fs";
+import path18 from "path";
+import os17 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 
 // src/layers/parsers.ts
 import fs5 from "fs";
@@ -4843,6 +4843,200 @@ function progressBar(pct) {
 
 // src/commands.ts
 init_user_model();
+
+// src/background.ts
+import fs17 from "fs";
+import path17 from "path";
+import os16 from "os";
+import pc5 from "picocolors";
+var BACKGROUND_ELIGIBLE = /* @__PURE__ */ new Set([
+  "run_tests",
+  "npm_test",
+  "build",
+  "npm_build",
+  "file_search",
+  "code_search",
+  "grep_search",
+  "git_clone",
+  "docker_build",
+  "docker_run"
+]);
+var NEVER_BACKGROUND = /* @__PURE__ */ new Set([
+  "memory_recall",
+  "memory_store",
+  "memory_log",
+  "memory_context",
+  "memory_detail",
+  "identity_read",
+  "identity_summary",
+  "identity_update_session",
+  "identity_update_dynamics",
+  "rules_check",
+  "rules_list",
+  "workflow_list",
+  "workflow_get",
+  "skill_list",
+  "skill_search",
+  "eval_status",
+  "eval_log",
+  "reminder_check",
+  "reminder_set",
+  "file_read",
+  "doc_convert",
+  "file_list",
+  "avatar_prompt"
+]);
+var TASK_LOG_DIR = path17.join(os16.homedir(), ".aman-agent");
+var TASK_LOG_FILE = path17.join(TASK_LOG_DIR, "bg-tasks.json");
+var MAX_LOG_ENTRIES = 50;
+function loadTaskLog() {
+  try {
+    if (!fs17.existsSync(TASK_LOG_FILE)) return [];
+    const raw = fs17.readFileSync(TASK_LOG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function saveTaskLog(entries) {
+  try {
+    if (!fs17.existsSync(TASK_LOG_DIR)) fs17.mkdirSync(TASK_LOG_DIR, { recursive: true });
+    const trimmed = entries.slice(-MAX_LOG_ENTRIES);
+    fs17.writeFileSync(TASK_LOG_FILE, JSON.stringify(trimmed, null, 2));
+  } catch (err) {
+    log.debug("background", "Failed to save task log", err);
+  }
+}
+function logTaskStart(task) {
+  const entries = loadTaskLog();
+  for (const e of entries) {
+    if (e.status === "running") e.status = "interrupted";
+  }
+  entries.push({
+    id: task.id,
+    toolName: task.toolName,
+    startedAt: task.startedAt,
+    status: "running"
+  });
+  saveTaskLog(entries);
+}
+function logTaskComplete(task) {
+  const entries = loadTaskLog();
+  const entry = entries.find((e) => e.id === task.id);
+  if (entry) {
+    entry.completedAt = Date.now();
+    entry.status = task.error ? "failed" : "completed";
+    entry.resultPreview = (task.result || "").slice(0, 200);
+    entry.error = task.error;
+  }
+  saveTaskLog(entries);
+}
+function shouldRunInBackground(toolName) {
+  if (NEVER_BACKGROUND.has(toolName)) return false;
+  if (BACKGROUND_ELIGIBLE.has(toolName)) return true;
+  return false;
+}
+var BackgroundTaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  taskCounter = 0;
+  /**
+   * Launch a tool call in the background.
+   */
+  launch(toolName, toolUseId, mcpManager, toolInput) {
+    const id = `bg-${++this.taskCounter}`;
+    const task = {
+      id,
+      toolName,
+      toolUseId,
+      startedAt: Date.now(),
+      done: false,
+      promise: mcpManager.callTool(toolName, toolInput).then(
+        (result) => {
+          task.result = result;
+          task.done = true;
+          logTaskComplete(task);
+          return result;
+        },
+        (error) => {
+          task.error = error instanceof Error ? error.message : String(error);
+          task.done = true;
+          logTaskComplete(task);
+          return `Error: ${task.error}`;
+        }
+      )
+    };
+    this.tasks.set(id, task);
+    logTaskStart(task);
+    process.stdout.write(pc5.dim(`  [${toolName} running in background (${id})...]
+`));
+    return task;
+  }
+  /**
+   * Check for completed background tasks and return their results.
+   */
+  collectCompleted() {
+    const completed = [];
+    for (const [id, task] of this.tasks) {
+      if (task.done) {
+        completed.push(task);
+        this.tasks.delete(id);
+      }
+    }
+    return completed;
+  }
+  /**
+   * Display completed background task results to the user.
+   */
+  displayCompleted() {
+    const completed = this.collectCompleted();
+    const outputs = [];
+    for (const task of completed) {
+      const elapsed = ((Date.now() - task.startedAt) / 1e3).toFixed(1);
+      if (task.error) {
+        process.stdout.write(pc5.yellow(`
+  [${task.id}] ${task.toolName} failed after ${elapsed}s: ${task.error}
+`));
+        outputs.push(`[Background task ${task.toolName} failed: ${task.error}]`);
+      } else {
+        process.stdout.write(pc5.green(`
+  [${task.id}] ${task.toolName} completed in ${elapsed}s
+`));
+        const preview = (task.result || "").slice(0, 200);
+        if (preview) {
+          process.stdout.write(pc5.dim(`  ${preview}${(task.result || "").length > 200 ? "..." : ""}
+`));
+        }
+        outputs.push(`[Background task ${task.toolName} completed: ${task.result}]`);
+      }
+    }
+    return outputs;
+  }
+  /**
+   * Wait for all pending background tasks to complete.
+   */
+  async waitAll() {
+    const pending = [...this.tasks.values()].filter((t) => !t.done);
+    if (pending.length === 0) return;
+    process.stdout.write(pc5.dim(`
+  Waiting for ${pending.length} background task(s)...
+`));
+    await Promise.allSettled(pending.map((t) => t.promise));
+  }
+  /**
+   * Number of currently running tasks.
+   */
+  get pendingCount() {
+    return [...this.tasks.values()].filter((t) => !t.done).length;
+  }
+  /**
+   * Check if any tasks have completed (non-blocking).
+   */
+  get hasCompleted() {
+    return [...this.tasks.values()].some((t) => t.done);
+  }
+};
+
+// src/commands.ts
 import {
   getIdentity as acoreGetIdentity,
   updateSection as acoreUpdateSection,
@@ -4857,10 +5051,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs17.existsSync(filePath)) {
-    return pc5.dim(`No ${label} file found at ${filePath}`);
+  if (!fs18.existsSync(filePath)) {
+    return pc6.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs17.readFileSync(filePath, "utf-8").trim();
+  return fs18.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -4885,13 +5079,13 @@ function buildNestedUpdate(key, val) {
 }
 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`);
+    return pc6.red(`Cannot modify ${layer}: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp`);
   }
   const result = await ctx.mcpManager.callTool(tool, args);
   if (result.startsWith("Error")) {
-    return pc5.red(result);
+    return pc6.red(result);
   }
-  return pc5.green(result);
+  return pc6.green(result);
 }
 async function handleIdentityCommand(action, args, _ctx) {
   if (!action) {
@@ -4899,7 +5093,7 @@ async function handleIdentityCommand(action, args, _ctx) {
     if (!identity) {
       return {
         handled: true,
-        output: pc5.dim(
+        output: pc6.dim(
           `No identity configured for ${AGENT_SCOPE}. Run: npx @aman_asmuei/acore`
         )
       };
@@ -4910,7 +5104,7 @@ async function handleIdentityCommand(action, args, _ctx) {
     if (args.length === 0) {
       return {
         handled: true,
-        output: pc5.yellow(
+        output: pc6.yellow(
           "Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via acore-core."
         )
       };
@@ -4920,18 +5114,18 @@ async function handleIdentityCommand(action, args, _ctx) {
     if (!content) {
       return {
         handled: true,
-        output: pc5.yellow(
+        output: pc6.yellow(
           "Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct."
         )
       };
     }
     try {
       await acoreUpdateSection(section, content, AGENT_SCOPE);
-      return { handled: true, output: pc5.green(`Updated section: ${section}`) };
+      return { handled: true, output: pc6.green(`Updated section: ${section}`) };
     } catch (err) {
       return {
         handled: true,
-        output: pc5.red(
+        output: pc6.red(
           `Failed to update ${section}: ${err instanceof Error ? err.message : String(err)}`
         )
       };
@@ -4940,16 +5134,16 @@ async function handleIdentityCommand(action, args, _ctx) {
   if (action === "dynamics") {
     if (args.includes("--json")) {
       const model2 = await loadUserModel();
-      if (!model2) return { handled: true, output: pc5.dim("No user model yet. Complete a few sessions first.") };
+      if (!model2) return { handled: true, output: pc6.dim("No user model yet. Complete a few sessions first.") };
       return { handled: true, output: JSON.stringify(model2, null, 2) };
     }
     if (args.includes("--reset")) {
       const modelPath = defaultModelPath();
-      if (fs17.existsSync(modelPath)) {
-        fs17.unlinkSync(modelPath);
-        return { handled: true, output: pc5.green("User model reset. Starting fresh.") };
+      if (fs18.existsSync(modelPath)) {
+        fs18.unlinkSync(modelPath);
+        return { handled: true, output: pc6.green("User model reset. Starting fresh.") };
       }
-      return { handled: true, output: pc5.dim("No user model to reset.") };
+      return { handled: true, output: pc6.dim("No user model to reset.") };
     }
     const updates = {};
     for (const arg of args) {
@@ -4965,25 +5159,25 @@ async function handleIdentityCommand(action, args, _ctx) {
         }, 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)}`) };
+        return { handled: true, output: pc6.red(`Dynamics error: ${err instanceof Error ? err.message : String(err)}`) };
       }
     }
     const model = await loadUserModel();
     if (!model) {
-      return { handled: true, output: pc5.dim("No user model yet. Complete a few sessions to start building your profile.") };
+      return { handled: true, output: pc6.dim("No user model yet. Complete a few sessions to start building your profile.") };
     }
     const p4 = model.profile;
     const trustBar = "\u2588".repeat(Math.round(p4.trustScore * 10)) + "\u2591".repeat(10 - Math.round(p4.trustScore * 10));
     const frustBar = "\u2588".repeat(Math.round(p4.baselineFrustration * 10)) + "\u2591".repeat(10 - Math.round(p4.baselineFrustration * 10));
     const lines = [
-      pc5.bold("  Dynamic User Model"),
+      pc6.bold("  Dynamic User Model"),
       "",
-      `  ${pc5.cyan("Trust")}        ${trustBar} ${(p4.trustScore * 100).toFixed(0)}%  ${p4.trustTrajectory === "ascending" ? pc5.green("\u2191") : p4.trustTrajectory === "declining" ? pc5.red("\u2193") : "\u2192"}`,
-      `  ${pc5.cyan("Sessions")}     ${p4.totalSessions} total (${model.sessions.length} in window)`,
-      `  ${pc5.cyan("Sentiment")}    ${frustBar} frustration baseline  ${p4.sentimentTrend === "improving" ? pc5.green("improving") : p4.sentimentTrend === "worsening" ? pc5.red("worsening") : "stable"}`,
+      `  ${pc6.cyan("Trust")}        ${trustBar} ${(p4.trustScore * 100).toFixed(0)}%  ${p4.trustTrajectory === "ascending" ? pc6.green("\u2191") : p4.trustTrajectory === "declining" ? pc6.red("\u2193") : "\u2192"}`,
+      `  ${pc6.cyan("Sessions")}     ${p4.totalSessions} total (${model.sessions.length} in window)`,
+      `  ${pc6.cyan("Sentiment")}    ${frustBar} frustration baseline  ${p4.sentimentTrend === "improving" ? pc6.green("improving") : p4.sentimentTrend === "worsening" ? pc6.red("worsening") : "stable"}`,
       "",
-      `  ${pc5.cyan("Preferred")}    ${p4.preferredTimePeriod} (${Object.entries(p4.energyDistribution).map(([k, v]) => `${k}: ${v}`).join(", ")})`,
-      `  ${pc5.cyan("Avg session")}  ${p4.avgSessionMinutes.toFixed(0)} min, ${p4.avgTurnsPerSession.toFixed(0)} turns  ${p4.engagementTrend === "increasing" ? pc5.green("\u2191") : p4.engagementTrend === "decreasing" ? pc5.red("\u2193") : "\u2192"}`
+      `  ${pc6.cyan("Preferred")}    ${p4.preferredTimePeriod} (${Object.entries(p4.energyDistribution).map(([k, v]) => `${k}: ${v}`).join(", ")})`,
+      `  ${pc6.cyan("Avg session")}  ${p4.avgSessionMinutes.toFixed(0)} min, ${p4.avgTurnsPerSession.toFixed(0)} turns  ${p4.engagementTrend === "increasing" ? pc6.green("\u2191") : p4.engagementTrend === "decreasing" ? pc6.red("\u2193") : "\u2192"}`
     ];
     if (p4.totalSessions >= 10) {
       const corrs = [];
@@ -4997,22 +5191,22 @@ async function handleIdentityCommand(action, args, _ctx) {
         corrs.push(`late night (${p4.frustrationCorrelations.lateNight.toFixed(2)})`);
       }
       if (corrs.length > 0) {
-        lines.push(`  ${pc5.cyan("Frustration")}  correlates with: ${corrs.join(", ")}`);
+        lines.push(`  ${pc6.cyan("Frustration")}  correlates with: ${corrs.join(", ")}`);
       }
     }
     const nudgeKeys = Object.keys(p4.nudgeStats);
     if (nudgeKeys.length > 0) {
       lines.push("");
-      lines.push(`  ${pc5.cyan("Nudges")}       ${nudgeKeys.map((k) => `${k}: ${p4.nudgeStats[k].fired}\xD7`).join(", ")}`);
+      lines.push(`  ${pc6.cyan("Nudges")}       ${nudgeKeys.map((k) => `${k}: ${p4.nudgeStats[k].fired}\xD7`).join(", ")}`);
     }
     lines.push("");
-    lines.push(pc5.dim(`  Use --json for raw data, --reset to start fresh`));
+    lines.push(pc6.dim(`  Use --json for raw data, --reset to start fresh`));
     return { handled: true, output: lines.join("\n") };
   }
   if (action === "summary") {
     try {
       const identity = await acoreGetIdentity(AGENT_SCOPE);
-      if (!identity) return { handled: true, output: pc5.yellow("No identity configured.") };
+      if (!identity) return { handled: true, output: pc6.yellow("No identity configured.") };
       const nameMatch = identity.content.match(/\*\*Name:\*\*\s*(.+)/);
       const lines = [
         `**Identity Summary**`,
@@ -5021,27 +5215,27 @@ async function handleIdentityCommand(action, args, _ctx) {
       ].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)}`) };
+      return { handled: true, output: pc6.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 dynamics")}           View user model (trust, sentiment, patterns)`,
-        `  ${pc5.cyan("/identity dynamics")} key=val   Update dynamic fields (energy, mode, read)`,
-        `  ${pc5.cyan("/identity dynamics")} --json    Raw JSON user model`,
-        `  ${pc5.cyan("/identity dynamics")} --reset   Reset user model`,
-        `  ${pc5.cyan("/identity summary")}            Show structured identity summary`
+        pc6.bold("Identity commands:"),
+        `  ${pc6.cyan("/identity")}                  View current identity`,
+        `  ${pc6.cyan("/identity update")} <section>  Update a section`,
+        `  ${pc6.cyan("/identity dynamics")}           View user model (trust, sentiment, patterns)`,
+        `  ${pc6.cyan("/identity dynamics")} key=val   Update dynamic fields (energy, mode, read)`,
+        `  ${pc6.cyan("/identity dynamics")} --json    Raw JSON user model`,
+        `  ${pc6.cyan("/identity dynamics")} --reset   Reset user model`,
+        `  ${pc6.cyan("/identity summary")}            Show structured identity summary`
       ].join("\n")
     };
   }
   return {
     handled: true,
-    output: pc5.yellow(
+    output: pc6.yellow(
       `Unknown action: /identity ${action}. Try /identity --help`
     )
   };
@@ -5052,14 +5246,14 @@ async function handleRulesCommand(action, args, _ctx) {
     if (cats.length === 0) {
       return {
         handled: true,
-        output: pc5.dim(
+        output: pc6.dim(
           `No rules configured for ${AGENT_SCOPE}. Run: npx @aman_asmuei/arules`
         )
       };
     }
     const lines = [];
     for (const cat of cats) {
-      lines.push(pc5.bold(`## ${cat.name}`));
+      lines.push(pc6.bold(`## ${cat.name}`));
       for (const rule of cat.rules) {
         lines.push(`  - ${rule}`);
       }
@@ -5071,7 +5265,7 @@ async function handleRulesCommand(action, args, _ctx) {
     if (args.length < 2) {
       return {
         handled: true,
-        output: pc5.yellow("Usage: /rules add <category> <rule text...>")
+        output: pc6.yellow("Usage: /rules add <category> <rule text...>")
       };
     }
     const category = args[0];
@@ -5080,12 +5274,12 @@ async function handleRulesCommand(action, args, _ctx) {
       await arulesAddRule(category, rule, AGENT_SCOPE);
       return {
         handled: true,
-        output: pc5.green(`Added rule to "${category}": ${rule}`)
+        output: pc6.green(`Added rule to "${category}": ${rule}`)
       };
     } catch (err) {
       return {
         handled: true,
-        output: pc5.red(
+        output: pc6.red(
           `Failed: ${err instanceof Error ? err.message : String(err)}`
         )
       };
@@ -5095,7 +5289,7 @@ async function handleRulesCommand(action, args, _ctx) {
     if (args.length < 2) {
       return {
         handled: true,
-        output: pc5.yellow("Usage: /rules remove <category> <index>")
+        output: pc6.yellow("Usage: /rules remove <category> <index>")
       };
     }
     const category = args[0];
@@ -5103,19 +5297,19 @@ async function handleRulesCommand(action, args, _ctx) {
     if (isNaN(idx) || idx < 1) {
       return {
         handled: true,
-        output: pc5.yellow("Index must be a positive integer.")
+        output: pc6.yellow("Index must be a positive integer.")
       };
     }
     try {
       await arulesRemoveRule(category, idx, AGENT_SCOPE);
       return {
         handled: true,
-        output: pc5.green(`Removed rule ${idx} from "${category}"`)
+        output: pc6.green(`Removed rule ${idx} from "${category}"`)
       };
     } catch (err) {
       return {
         handled: true,
-        output: pc5.red(
+        output: pc6.red(
           `Failed: ${err instanceof Error ? err.message : String(err)}`
         )
       };
@@ -5125,7 +5319,7 @@ async function handleRulesCommand(action, args, _ctx) {
     if (args.length < 2) {
       return {
         handled: true,
-        output: pc5.yellow("Usage: /rules toggle <category> <index>")
+        output: pc6.yellow("Usage: /rules toggle <category> <index>")
       };
     }
     const category = args[0];
@@ -5133,19 +5327,19 @@ async function handleRulesCommand(action, args, _ctx) {
     if (isNaN(idx) || idx < 1) {
       return {
         handled: true,
-        output: pc5.yellow("Index must be a positive integer.")
+        output: pc6.yellow("Index must be a positive integer.")
       };
     }
     try {
       await arulesToggleRule(category, idx, AGENT_SCOPE);
       return {
         handled: true,
-        output: pc5.green(`Toggled rule ${idx} in "${category}"`)
+        output: pc6.green(`Toggled rule ${idx} in "${category}"`)
       };
     } catch (err) {
       return {
         handled: true,
-        output: pc5.red(
+        output: pc6.red(
           `Failed: ${err instanceof Error ? err.message : String(err)}`
         )
       };
@@ -5153,75 +5347,75 @@ async function handleRulesCommand(action, args, _ctx) {
   }
   if (action === "check") {
     if (args.length === 0) {
-      return { handled: true, output: pc5.yellow("Usage: /rules check <action description...>") };
+      return { handled: true, output: pc6.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: pc6.green(`Action is allowed: "${description}"`) };
       }
       return {
         handled: true,
-        output: pc5.red(`Action blocked: "${description}"
+        output: pc6.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)}`) };
+      return { handled: true, output: pc6.red(`Check error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "help") {
     return {
       handled: true,
       output: [
-        pc5.bold("Rules commands:"),
-        `  ${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 check")} <action...>         Check if an action is allowed`
+        pc6.bold("Rules commands:"),
+        `  ${pc6.cyan("/rules")}                         View current rules`,
+        `  ${pc6.cyan("/rules add")} <category> <text>    Add a rule`,
+        `  ${pc6.cyan("/rules remove")} <category> <idx>  Remove a rule`,
+        `  ${pc6.cyan("/rules toggle")} <category> <idx>  Toggle a rule`,
+        `  ${pc6.cyan("/rules check")} <action...>         Check if an action is allowed`
       ].join("\n")
     };
   }
   return {
     handled: true,
-    output: pc5.yellow(`Unknown action: /rules ${action}. Try /rules --help`)
+    output: pc6.yellow(`Unknown action: /rules ${action}. Try /rules --help`)
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os16.homedir();
+  const home2 = os17.homedir();
   if (!action) {
-    const content = readEcosystemFile(path17.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path18.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /workflows add <name>") };
+      return { handled: true, output: pc6.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: pc5.yellow("Usage: /workflows remove <name>") };
+      return { handled: true, output: pc6.yellow("Usage: /workflows remove <name>") };
     }
     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>") };
+      return { handled: true, output: pc6.yellow("Usage: /workflows get <name>") };
     }
     const name = args.join(" ").toLowerCase();
-    const raw = readEcosystemFile(path17.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path18.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(" ")}"`) };
+      return { handled: true, output: pc6.yellow(`No workflow found: "${args.join(" ")}"`) };
     }
     const title = match.split("\n")[0].trim();
     const body = match.split("\n").slice(1).join("\n").trim();
@@ -5231,34 +5425,34 @@ ${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 get")} <name>    Show a specific workflow`
+      pc6.bold("Workflow commands:"),
+      `  ${pc6.cyan("/workflows")}              View current workflows`,
+      `  ${pc6.cyan("/workflows add")} <name>    Add a workflow`,
+      `  ${pc6.cyan("/workflows remove")} <name> Remove a workflow`,
+      `  ${pc6.cyan("/workflows get")} <name>    Show a specific workflow`
     ].join("\n") };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /workflows ${action}. Try /workflows --help`) };
+  return { handled: true, output: pc6.yellow(`Unknown action: /workflows ${action}. Try /workflows --help`) };
 }
 function handleAkitCommand(_action, _args) {
   return {
     handled: true,
     output: [
-      pc5.bold("akit \u2014 Tool Management"),
+      pc6.bold("akit \u2014 Tool Management"),
       "",
-      pc5.dim(
+      pc6.dim(
         "Tool management is now handled by the standalone akit CLI rather than"
       ),
-      pc5.dim(
+      pc6.dim(
         "duplicated inside aman-agent. The akit slash command is informational only."
       ),
       "",
-      `  ${pc5.cyan("npx @aman_asmuei/akit list")}              List installed tools`,
-      `  ${pc5.cyan("npx @aman_asmuei/akit search <query>")}    Search the tool registry`,
-      `  ${pc5.cyan("npx @aman_asmuei/akit add <tool>")}        Install a tool`,
-      `  ${pc5.cyan("npx @aman_asmuei/akit remove <tool>")}     Uninstall a tool`,
+      `  ${pc6.cyan("npx @aman_asmuei/akit list")}              List installed tools`,
+      `  ${pc6.cyan("npx @aman_asmuei/akit search <query>")}    Search the tool registry`,
+      `  ${pc6.cyan("npx @aman_asmuei/akit add <tool>")}        Install a tool`,
+      `  ${pc6.cyan("npx @aman_asmuei/akit remove <tool>")}     Uninstall a tool`,
       "",
-      pc5.dim(
+      pc6.dim(
         "Restart aman-agent after installing/removing tools to pick up changes."
       )
     ].join("\n")
@@ -5270,81 +5464,81 @@ async function handleToolsCommand(action, args, _ctx) {
   }
   if (action === "search") {
     if (args.length === 0) {
-      return { handled: true, output: pc5.yellow("Usage: /tools search <query...>") };
+      return { handled: true, output: pc6.yellow("Usage: /tools search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home2 = os16.homedir();
-    const toolsFile = path17.join(home2, ".akit", "tools.md");
-    if (!fs17.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 home2 = os17.homedir();
+    const toolsFile = path18.join(home2, ".akit", "tools.md");
+    if (!fs18.existsSync(toolsFile)) {
+      return { handled: true, output: pc6.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
     }
-    const raw = fs17.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs18.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: pc6.dim(`No tools matching "${query}".`) };
     }
-    return { handled: true, output: [pc5.bold(`Tools matching "${query}":`), ...matches].join("\n") };
+    return { handled: true, output: [pc6.bold(`Tools matching "${query}":`), ...matches].join("\n") };
   }
   return handleAkitCommand(action, args);
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os16.homedir();
+  const home2 = os17.homedir();
   if (!action) {
-    const content = readEcosystemFile(path17.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path18.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /skills install <name>") };
+      return { handled: true, output: pc6.yellow("Usage: /skills install <name>") };
     }
     const output = await mcpWrite(ctx, "skills", "skill_install", { name: args.join(" ") });
     return { handled: true, output };
   }
   if (action === "uninstall") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /skills uninstall <name>") };
+      return { handled: true, output: pc6.yellow("Usage: /skills uninstall <name>") };
     }
     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...>") };
+      return { handled: true, output: pc6.yellow("Usage: /skills search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home3 = os16.homedir();
-    const raw = readEcosystemFile(path17.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const home3 = os17.homedir();
+    const raw = readEcosystemFile(path18.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: pc6.dim(`No skills matching "${query}".`) };
     }
-    return { handled: true, output: [pc5.bold(`Skills matching "${query}":`), ...matches].join("\n") };
+    return { handled: true, output: [pc6.bold(`Skills matching "${query}":`), ...matches].join("\n") };
   }
   if (action === "list") {
     const autoOnly = args.includes("--auto");
     if (autoOnly) {
-      const logPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-log.json");
+      const logPath = path18.join(os17.homedir(), ".aman-agent", "crystallization-log.json");
       try {
-        const content2 = fs17.readFileSync(logPath, "utf-8");
+        const content2 = fs18.readFileSync(logPath, "utf-8");
         const entries = JSON.parse(content2);
         if (entries.length === 0) {
-          return { handled: true, output: pc5.dim("No crystallized skills yet.") };
+          return { handled: true, output: pc6.dim("No crystallized skills yet.") };
         }
-        const suggestionsPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-suggestions.json");
+        const suggestionsPath = path18.join(os17.homedir(), ".aman-agent", "crystallization-suggestions.json");
         let sugCounts = {};
         try {
-          const sc = fs17.readFileSync(suggestionsPath, "utf-8");
+          const sc = fs18.readFileSync(suggestionsPath, "utf-8");
           sugCounts = JSON.parse(sc);
         } catch {
         }
         let versionCounts = {};
         try {
-          const skillsContent = fs17.readFileSync(path17.join(os16.homedir(), ".askill", "skills.md"), "utf-8");
+          const skillsContent = fs18.readFileSync(path18.join(os17.homedir(), ".askill", "skills.md"), "utf-8");
           const versionRe = /^# (.+)\.v(\d+)$/gm;
           let vMatch;
           while ((vMatch = versionRe.exec(skillsContent)) !== null) {
@@ -5354,62 +5548,62 @@ async function handleSkillsCommand(action, args, ctx) {
           }
         } catch {
         }
-        const lines = [pc5.bold(`Crystallized skills (${entries.length}):`)];
+        const lines = [pc6.bold(`Crystallized skills (${entries.length}):`)];
         for (const entry of entries) {
           const date = entry.createdAt.slice(0, 10);
           const count = sugCounts[entry.name];
-          const reinforced = count && count >= 3 ? pc5.green(` \u2605 reinforced (${count}\xD7)`) : "";
+          const reinforced = count && count >= 3 ? pc6.green(` \u2605 reinforced (${count}\xD7)`) : "";
           const versions = versionCounts[entry.name];
-          const versionLabel = versions ? pc5.dim(` [v${versions + 1}]`) : "";
-          lines.push(`  ${pc5.cyan(entry.name)} (${date}, conf ${entry.confidence})${reinforced}${versionLabel}`);
-          lines.push(pc5.dim(`    triggers: ${entry.triggers.join(", ")}`));
+          const versionLabel = versions ? pc6.dim(` [v${versions + 1}]`) : "";
+          lines.push(`  ${pc6.cyan(entry.name)} (${date}, conf ${entry.confidence})${reinforced}${versionLabel}`);
+          lines.push(pc6.dim(`    triggers: ${entry.triggers.join(", ")}`));
         }
         return { handled: true, output: lines.join("\n") };
       } catch {
-        return { handled: true, output: pc5.dim("No crystallized skills yet.") };
+        return { handled: true, output: pc6.dim("No crystallized skills yet.") };
       }
     }
-    const content = readEcosystemFile(path17.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path18.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "crystallize") {
-    const pmDir = path17.join(os16.homedir(), ".acore", "postmortems");
+    const pmDir = path18.join(os17.homedir(), ".acore", "postmortems");
     try {
-      const files = fs17.readdirSync(pmDir);
+      const files = fs18.readdirSync(pmDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
       if (jsonFiles.length === 0) {
         return {
           handled: true,
-          output: pc5.dim("No post-mortems found. Run a session that triggers a post-mortem first.")
+          output: pc6.dim("No post-mortems found. Run a session that triggers a post-mortem first.")
         };
       }
       const latest = jsonFiles[0];
-      const content = fs17.readFileSync(path17.join(pmDir, latest), "utf-8");
+      const content = fs18.readFileSync(path18.join(pmDir, latest), "utf-8");
       const report = JSON.parse(content);
       if (!report.crystallizationCandidates || report.crystallizationCandidates.length === 0) {
         return {
           handled: true,
-          output: pc5.dim(`No crystallization candidates in the most recent post-mortem (${latest}). Run a longer session or wait for the next auto-postmortem.`)
+          output: pc6.dim(`No crystallization candidates in the most recent post-mortem (${latest}). Run a longer session or wait for the next auto-postmortem.`)
         };
       }
-      const skillsMdPath = path17.join(os16.homedir(), ".askill", "skills.md");
-      const logPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-log.json");
+      const skillsMdPath = path18.join(os17.homedir(), ".askill", "skills.md");
+      const logPath = path18.join(os17.homedir(), ".aman-agent", "crystallization-log.json");
       const postmortemFilename = latest.replace(/\.json$/, ".md");
       const lines = [
-        pc5.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
+        pc6.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
       ];
       let written = 0;
       for (const raw of report.crystallizationCandidates) {
         const candidate = validateCandidate(raw);
         if (!candidate) {
           const rawName = raw.name ?? "unknown";
-          lines.push(pc5.dim(`  \u2298 ${rawName} \u2014 failed validation`));
+          lines.push(pc6.dim(`  \u2298 ${rawName} \u2014 failed validation`));
           continue;
         }
         const result = await writeSkillToFile(candidate, skillsMdPath, postmortemFilename);
         if (result.written) {
           written++;
-          lines.push(pc5.green(`  \u2713 Crystallized: ${candidate.name}`));
+          lines.push(pc6.green(`  \u2713 Crystallized: ${candidate.name}`));
           await appendCrystallizationLog(
             {
               name: candidate.name,
@@ -5421,68 +5615,101 @@ async function handleSkillsCommand(action, args, ctx) {
             logPath
           );
         } else {
-          lines.push(pc5.yellow(`  \u2298 ${candidate.name} \u2014 ${result.reason}`));
+          lines.push(pc6.yellow(`  \u2298 ${candidate.name} \u2014 ${result.reason}`));
         }
       }
       if (written > 0) {
         lines.push("");
-        lines.push(pc5.dim(`Crystallized skills will auto-activate in your next session.`));
+        lines.push(pc6.dim(`Crystallized skills will auto-activate in your next session.`));
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
       return {
         handled: true,
-        output: pc5.red(`Failed to load post-mortems: ${err instanceof Error ? err.message : String(err)}`)
+        output: pc6.red(`Failed to load post-mortems: ${err instanceof Error ? err.message : String(err)}`)
       };
     }
   }
   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 search")} <query>         Search skills by name/description`,
-      `  ${pc5.cyan("/skills crystallize")}            Crystallize skills from most recent post-mortem`,
-      `  ${pc5.cyan("/skills list --auto")}            List crystallized (auto-created) skills`
+      pc6.bold("Skills commands:"),
+      `  ${pc6.cyan("/skills")}                      View installed skills`,
+      `  ${pc6.cyan("/skills install")} <name>        Install a skill`,
+      `  ${pc6.cyan("/skills uninstall")} <name>      Uninstall a skill`,
+      `  ${pc6.cyan("/skills search")} <query>         Search skills by name/description`,
+      `  ${pc6.cyan("/skills crystallize")}            Crystallize skills from most recent post-mortem`,
+      `  ${pc6.cyan("/skills list --auto")}            List crystallized (auto-created) skills`
     ].join("\n") };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
+  return { handled: true, output: pc6.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os16.homedir();
+  const home2 = os17.homedir();
   if (!action) {
-    const content = readEcosystemFile(path17.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path18.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /eval milestone <text...>") };
+      return { handled: true, output: pc6.yellow("Usage: /eval milestone <text...>") };
     }
     const text3 = args.join(" ");
     const output = await mcpWrite(ctx, "eval", "eval_milestone", { text: text3 });
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path17.join(home2, ".aeval", "eval.md");
-    if (!fs17.existsSync(evalFile)) {
-      return { handled: true, output: pc5.dim("No eval report found. Log milestones with /eval milestone <text>.") };
+    const evalFile = path18.join(home2, ".aeval", "eval.md");
+    const lines = [pc6.bold("\u{1F4CA} Eval Report")];
+    if (fs18.existsSync(evalFile)) {
+      lines.push("", fs18.readFileSync(evalFile, "utf-8").trim());
+    } else {
+      lines.push("", pc6.dim("No eval log yet. Use /eval milestone <text> to start."));
+    }
+    try {
+      const model = await loadUserModel();
+      if (model && model.sessions.length >= 3) {
+        const profile = computeProfile(model.sessions, model.profile.totalSessions);
+        const burnout = predictBurnout(model.sessions);
+        lines.push("", pc6.bold("\u2500\u2500 Analytics \u2500\u2500"));
+        lines.push(`  Sessions tracked: ${pc6.cyan(String(profile.totalSessions))}`);
+        lines.push(`  Trust score:      ${pc6.cyan(profile.trustScore.toFixed(2))}`);
+        lines.push(`  Sentiment trend:  ${pc6.cyan(profile.sentimentTrend)}`);
+        const topEnergy = Object.entries(profile.energyDistribution).sort((a, b) => b[1] - a[1]).slice(0, 2).map(([k, v]) => `${k} ${(v * 100).toFixed(0)}%`);
+        lines.push(`  Top energy:       ${pc6.cyan(topEnergy.join(", "))}`);
+        const riskColor = burnout.risk > 0.7 ? pc6.red : burnout.risk > 0.4 ? pc6.yellow : pc6.green;
+        lines.push(`  Burnout risk:     ${riskColor((burnout.risk * 100).toFixed(0) + "%")} ${burnout.factors.length > 0 ? pc6.dim("(" + burnout.factors.join(", ") + ")") : ""}`);
+        const cors = Object.entries(profile.frustrationCorrelations).filter(([, v]) => Math.abs(v) > 0.3).sort((a, b) => Math.abs(b[1]) - Math.abs(a[1])).slice(0, 3);
+        if (cors.length > 0) {
+          lines.push(`  Frustration corr: ${cors.map(([k, v]) => `${k} ${v > 0 ? "\u2191" : "\u2193"}${Math.abs(v).toFixed(2)}`).join(", ")}`);
+        }
+      }
+    } catch {
     }
-    const content = fs17.readFileSync(evalFile, "utf-8").trim();
-    return { handled: true, output: [pc5.bold("Eval Report"), "", content].join("\n") };
+    try {
+      const taskLog = loadTaskLog();
+      if (taskLog.length > 0) {
+        const completed = taskLog.filter((t) => t.status === "completed").length;
+        const failed = taskLog.filter((t) => t.status === "failed").length;
+        const interrupted = taskLog.filter((t) => t.status === "interrupted").length;
+        lines.push("", pc6.bold("\u2500\u2500 Background Tasks \u2500\u2500"));
+        lines.push(`  Total: ${taskLog.length}  \u2705 ${completed}  \u274C ${failed}  \u26A0\uFE0F ${interrupted}`);
+      }
+    } catch {
+    }
+    return { handled: true, output: lines.join("\n") };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /eval ${action}. Use /eval, /eval report, or /eval milestone <text>.`) };
+  return { handled: true, output: pc6.yellow(`Unknown action: /eval ${action}. Use /eval, /eval report, or /eval milestone <text>.`) };
 }
 async function handleMemoryCommand(action, args, ctx) {
   if (!action) {
     try {
       const result = await memoryContext("recent context");
       if (result.memoriesUsed === 0) {
-        return { handled: true, output: pc5.dim("No memories yet. Start chatting and I'll remember what matters.") };
+        return { handled: true, output: pc6.dim("No memories yet. Start chatting and I'll remember what matters.") };
       }
       return { handled: true, output: result.text };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action && !["search", "clear", "timeline", "stats", "export", "since", "fts", "help", "doctor", "repair", "config", "reflect", "consolidate", "tier", "detail", "relate", "expire", "versions", "sync"].includes(action)) {
@@ -5490,54 +5717,54 @@ async function handleMemoryCommand(action, args, ctx) {
       const topic = [action, ...args].join(" ");
       const result = await memoryContext(topic);
       if (result.memoriesUsed === 0) {
-        return { handled: true, output: pc5.dim(`No memories found for: "${topic}".`) };
+        return { handled: true, output: pc6.dim(`No memories found for: "${topic}".`) };
       }
       return { handled: true, output: result.text };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "search") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /memory search <query...>") };
+      return { handled: true, output: pc6.yellow("Usage: /memory search <query...>") };
     }
     const query = args.join(" ");
     try {
       const result = await memoryMultiRecall(query, { limit: 10 });
       if (result.total === 0) {
-        return { handled: true, output: pc5.dim("No memories found.") };
+        return { handled: true, output: pc6.dim("No memories found.") };
       }
       const header = `Search results for "${query}" (${result.total}):`;
-      const lines = [pc5.bold(header), ""];
+      const lines = [pc6.bold(header), ""];
       for (const m of result.memories) {
-        const tags = m.tags?.length > 0 ? ` ${pc5.dim(m.tags.map((t) => `#${t}`).join(" "))}` : "";
+        const tags = m.tags?.length > 0 ? ` ${pc6.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)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "clear") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /memory clear <query>  \u2014 delete memories matching a search query\n       /memory clear --type <type>  \u2014 delete all memories of a type (correction|decision|pattern|preference|topology|fact)") };
+      return { handled: true, output: pc6.yellow("Usage: /memory clear <query>  \u2014 delete memories matching a search query\n       /memory clear --type <type>  \u2014 delete all memories of a type (correction|decision|pattern|preference|topology|fact)") };
     }
     try {
       if (args[0] === "--type" && args[1]) {
         const result2 = await memoryForget({ type: args[1] });
-        return { handled: true, output: result2.deleted > 0 ? pc5.green(result2.message) : pc5.dim(result2.message) };
+        return { handled: true, output: result2.deleted > 0 ? pc6.green(result2.message) : pc6.dim(result2.message) };
       }
       const result = await memoryForget({ query: args.join(" ") });
-      return { handled: true, output: result.deleted > 0 ? pc5.green(result.message) : pc5.dim(result.message) };
+      return { handled: true, output: result.deleted > 0 ? pc6.green(result.message) : pc6.dim(result.message) };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "timeline") {
     try {
       const result = await memoryRecall("*", { limit: 500, compact: false });
       if (result.total === 0) {
-        return { handled: true, output: pc5.dim("No memories yet. Start chatting and I'll remember what matters.") };
+        return { handled: true, output: pc6.dim("No memories yet. Start chatting and I'll remember what matters.") };
       }
       const memories = result.memories;
       if (memories.length > 0) {
@@ -5549,7 +5776,7 @@ async function handleMemoryCommand(action, args, ctx) {
         }
         const maxCount = Math.max(...byDate.values());
         const barWidth = 10;
-        const lines = [pc5.bold("Memory Timeline:"), ""];
+        const lines = [pc6.bold("Memory Timeline:"), ""];
         for (const [date, count] of byDate) {
           const filled = Math.round(count / maxCount * barWidth);
           const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
@@ -5574,24 +5801,24 @@ async function handleMemoryCommand(action, args, ctx) {
       }
       return { handled: true, output: `Total memories: ${result.total} entries.` };
     } catch {
-      return { handled: true, output: pc5.red("Failed to retrieve memory timeline.") };
+      return { handled: true, output: pc6.red("Failed to retrieve memory timeline.") };
     }
   }
   if (action === "stats") {
     try {
       const stats = memoryStats();
-      const lines = [pc5.bold("Memory Statistics:"), ""];
-      lines.push(`  Total memories: ${pc5.bold(String(stats.total))}`);
+      const lines = [pc6.bold("Memory Statistics:"), ""];
+      lines.push(`  Total memories: ${pc6.bold(String(stats.total))}`);
       if (Object.keys(stats.byType).length > 0) {
         lines.push("");
-        lines.push(`  ${pc5.dim("By type:")}`);
+        lines.push(`  ${pc6.dim("By type:")}`);
         for (const [type, count] of Object.entries(stats.byType)) {
           lines.push(`    ${type.padEnd(16)} ${count}`);
         }
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "export") {
@@ -5599,7 +5826,7 @@ async function handleMemoryCommand(action, args, ctx) {
       const format = args[0] === "json" ? "json" : "markdown";
       const memories = memoryExport();
       if (memories.length === 0) {
-        return { handled: true, output: pc5.dim("No memories to export.") };
+        return { handled: true, output: pc6.dim("No memories to export.") };
       }
       if (format === "json") {
         const jsonOut = memories.map((m) => ({ id: m.id, type: m.type, content: m.content, tags: m.tags, confidence: m.confidence, createdAt: m.createdAt, tier: m.tier }));
@@ -5609,11 +5836,11 @@ async function handleMemoryCommand(action, args, ctx) {
       for (const m of memories) {
         const date = new Date(m.createdAt).toLocaleDateString();
         const tags = m.tags.length > 0 ? ` [${m.tags.map((t) => `#${t}`).join(", ")}]` : "";
-        lines.push(`- **[${m.type}]** ${m.content}${tags} ${pc5.dim(`(${date}, ${Math.round(m.confidence * 100)}%)`)}`);
+        lines.push(`- **[${m.type}]** ${m.content}${tags} ${pc6.dim(`(${date}, ${Math.round(m.confidence * 100)}%)`)}`);
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "since") {
@@ -5628,60 +5855,60 @@ async function handleMemoryCommand(action, args, ctx) {
           else if (unit === "d") hours = value * 24;
           else if (unit === "w") hours = value * 24 * 7;
         } else {
-          return { handled: true, output: pc5.yellow("Usage: /memory since <Nh|Nd|Nw>  (e.g., 24h, 7d, 1w)") };
+          return { handled: true, output: pc6.yellow("Usage: /memory since <Nh|Nd|Nw>  (e.g., 24h, 7d, 1w)") };
         }
       }
       const memories = memorySince(hours);
       if (memories.length === 0) {
-        return { handled: true, output: pc5.dim(`No memories in the last ${args[0] || "24h"}.`) };
+        return { handled: true, output: pc6.dim(`No memories in the last ${args[0] || "24h"}.`) };
       }
-      const lines = [pc5.bold(`Memories since ${args[0] || "24h"} (${memories.length}):`), ""];
+      const lines = [pc6.bold(`Memories since ${args[0] || "24h"} (${memories.length}):`), ""];
       for (const m of memories) {
         const age = Math.round((Date.now() - m.createdAt) / 36e5);
         const ageStr = age < 1 ? "<1h ago" : `${age}h ago`;
-        lines.push(`  ${pc5.dim(ageStr.padEnd(10))} [${m.type}] ${m.content}`);
+        lines.push(`  ${pc6.dim(ageStr.padEnd(10))} [${m.type}] ${m.content}`);
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "fts") {
     if (args.length < 1) {
-      return { handled: true, output: pc5.yellow("Usage: /memory fts <query...>  \u2014 full-text search") };
+      return { handled: true, output: pc6.yellow("Usage: /memory fts <query...>  \u2014 full-text search") };
     }
     try {
       const query = args.join(" ");
       const results = memorySearch(query, 20);
       if (results.length === 0) {
-        return { handled: true, output: pc5.dim(`No results for full-text search: "${query}".`) };
+        return { handled: true, output: pc6.dim(`No results for full-text search: "${query}".`) };
       }
-      const lines = [pc5.bold(`FTS results for "${query}" (${results.length}):`), ""];
+      const lines = [pc6.bold(`FTS results for "${query}" (${results.length}):`), ""];
       for (const m of results) {
-        const tags = m.tags.length > 0 ? ` ${pc5.dim(m.tags.map((t) => `#${t}`).join(" "))}` : "";
+        const tags = m.tags.length > 0 ? ` ${pc6.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)}`) };
+      return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "help") {
     return { handled: true, output: [
-      pc5.bold("Memory commands:"),
-      `  ${pc5.cyan("/memory")}                    View recent context`,
-      `  ${pc5.cyan("/memory")} <topic>             Context for a topic`,
-      `  ${pc5.cyan("/memory search")} <query>      Search memories (semantic)`,
-      `  ${pc5.cyan("/memory fts")} <query>          Full-text search (FTS5)`,
-      `  ${pc5.cyan("/memory since")} <Nh|Nd|Nw>    Memories from time window`,
-      `  ${pc5.cyan("/memory stats")}               Show memory statistics`,
-      `  ${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 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)`
+      pc6.bold("Memory commands:"),
+      `  ${pc6.cyan("/memory")}                    View recent context`,
+      `  ${pc6.cyan("/memory")} <topic>             Context for a topic`,
+      `  ${pc6.cyan("/memory search")} <query>      Search memories (semantic)`,
+      `  ${pc6.cyan("/memory fts")} <query>          Full-text search (FTS5)`,
+      `  ${pc6.cyan("/memory since")} <Nh|Nd|Nw>    Memories from time window`,
+      `  ${pc6.cyan("/memory stats")}               Show memory statistics`,
+      `  ${pc6.cyan("/memory export")} [json]        Export all memories`,
+      `  ${pc6.cyan("/memory timeline")}            View memory timeline`,
+      `  ${pc6.cyan("/memory clear")} <query>        Delete matching memories`,
+      `  ${pc6.cyan("/memory clear --type")} <type>  Delete all of a type`,
+      `  ${pc6.cyan("/memory doctor")}              Run memory diagnostics`,
+      `  ${pc6.cyan("/memory repair")}              Dry-run repair (safe)`,
+      `  ${pc6.cyan("/memory config")} [key=value]  View or update config (e.g. consolidation.maxStaleDays=60)`
     ].join("\n") };
   }
   if (action === "doctor") {
@@ -5701,7 +5928,7 @@ async function handleMemoryCommand(action, args, ctx) {
       }
       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)}`) };
+      return { handled: true, output: pc6.red(`Memory doctor error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "repair") {
@@ -5723,7 +5950,7 @@ async function handleMemoryCommand(action, args, ctx) {
       }
       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)}`) };
+      return { handled: true, output: pc6.red(`Memory repair error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "config") {
@@ -5734,7 +5961,7 @@ async function handleMemoryCommand(action, args, ctx) {
         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>`) };
+          return { handled: true, output: pc6.yellow(`Usage: /memory config <key>=<value>`) };
         }
         const val = isNaN(Number(rawVal)) ? rawVal : Number(rawVal);
         const update = buildNestedUpdate(key, val);
@@ -5755,14 +5982,14 @@ async function handleMemoryCommand(action, args, ctx) {
       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)}`) };
+      return { handled: true, output: pc6.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"),
+        pc6.bold("Reflection complete"),
         `Clusters: ${report.clusters.length}`,
         `Contradictions: ${report.contradictions.length}`,
         `Synthesis candidates: ${report.synthesisCandidates.length}`,
@@ -5772,7 +5999,7 @@ async function handleMemoryCommand(action, args, ctx) {
       ];
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Reflect error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Reflect error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "consolidate") {
@@ -5780,7 +6007,7 @@ async function handleMemoryCommand(action, args, ctx) {
     try {
       const report = memoryConsolidate(!apply);
       const lines = [
-        apply ? pc5.bold("Consolidation applied") : pc5.bold("Consolidation dry-run"),
+        apply ? pc6.bold("Consolidation applied") : pc6.bold("Consolidation dry-run"),
         `Merged: ${report.merged}`,
         `Pruned: ${report.pruned}`,
         `Promoted: ${report.promoted}`,
@@ -5788,35 +6015,35 @@ async function handleMemoryCommand(action, args, ctx) {
         `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."));
+      if (!apply) lines.push(pc6.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)}`) };
+      return { handled: true, output: pc6.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>") };
+      return { handled: true, output: pc6.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: pc6.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>") };
+      return { handled: true, output: pc6.yellow("Usage: /memory detail <id>") };
     }
     const memory = memoryDetail(id);
     if (!memory) {
-      return { handled: true, output: pc5.dim(`Memory not found: ${id}`) };
+      return { handled: true, output: pc6.dim(`Memory not found: ${id}`) };
     }
     const lines = [
-      pc5.bold(`Memory: ${memory.id}`),
+      pc6.bold(`Memory: ${memory.id}`),
       `Content: ${memory.content}`,
       `Type: ${memory.type}`,
       `Confidence: ${memory.confidence}`,
@@ -5830,37 +6057,37 @@ async function handleMemoryCommand(action, args, ctx) {
   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]") };
+      return { handled: true, output: pc6.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: pc6.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]") };
+      return { handled: true, output: pc6.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: pc6.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>") };
+      return { handled: true, output: pc6.yellow("Usage: /memory versions <id>") };
     }
     const versions = memoryVersions(id);
     if (!versions.length) {
-      return { handled: true, output: pc5.dim(`No version history for: ${id}`) };
+      return { handled: true, output: pc6.dim(`No version history for: ${id}`) };
     }
-    const lines = [pc5.bold(`Version history for ${id}:`)];
+    const lines = [pc6.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" : ""}`);
     }
@@ -5869,7 +6096,7 @@ async function handleMemoryCommand(action, args, ctx) {
   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>") };
+      return { handled: true, output: pc6.yellow("Usage: /memory sync <import-claude|export-team|import-team|sync-copilot>") };
     }
     try {
       const opts = {};
@@ -5883,64 +6110,64 @@ async function handleMemoryCommand(action, args, ctx) {
       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: pc6.red(`Sync error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /memory ${action}. Try /memory --help`) };
+  return { handled: true, output: pc6.yellow(`Unknown action: /memory ${action}. Try /memory --help`) };
 }
 function handleStatusCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
   const amemConnected = isMemoryInitialized();
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
-  const lines = [pc5.bold("Aman Ecosystem Dashboard"), ""];
+  const lines = [pc6.bold("Aman Ecosystem Dashboard"), ""];
   for (const layer of status.layers) {
-    const icon = layer.exists ? pc5.green("\u25CF") : pc5.dim("\u25CB");
-    const name = pc5.bold(layer.name.padEnd(12));
-    const summary = layer.exists ? layer.summary : pc5.dim("not configured");
+    const icon = layer.exists ? pc6.green("\u25CF") : pc6.dim("\u25CB");
+    const name = pc6.bold(layer.name.padEnd(12));
+    const summary = layer.exists ? layer.summary : pc6.dim("not configured");
     lines.push(`  ${icon} ${name} ${summary}`);
   }
   lines.push("");
-  lines.push(`  ${status.mcpConnected ? pc5.green("\u25CF") : pc5.dim("\u25CB")} ${pc5.bold("MCP".padEnd(12))} ${status.mcpConnected ? `${status.mcpToolCount} tools available` : pc5.dim("not connected")}`);
-  lines.push(`  ${status.amemConnected ? pc5.green("\u25CF") : pc5.dim("\u25CB")} ${pc5.bold("Memory".padEnd(12))} ${status.amemConnected ? "connected" : pc5.dim("not connected")}`);
+  lines.push(`  ${status.mcpConnected ? pc6.green("\u25CF") : pc6.dim("\u25CB")} ${pc6.bold("MCP".padEnd(12))} ${status.mcpConnected ? `${status.mcpToolCount} tools available` : pc6.dim("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc6.green("\u25CF") : pc6.dim("\u25CB")} ${pc6.bold("Memory".padEnd(12))} ${status.amemConnected ? "connected" : pc6.dim("not connected")}`);
   return { handled: true, output: lines.join("\n") };
 }
 function handleDoctorCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
   const amemConnected = isMemoryInitialized();
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
-  const lines = [pc5.bold("Aman Health Check"), ""];
+  const lines = [pc6.bold("Aman Health Check"), ""];
   let healthy = 0;
   let fixes = 0;
   let suggestions = 0;
   for (const layer of status.layers) {
     if (layer.exists) {
-      lines.push(`  ${pc5.green("\u2713")} ${layer.name.padEnd(12)} ${pc5.green(layer.summary)}`);
+      lines.push(`  ${pc6.green("\u2713")} ${layer.name.padEnd(12)} ${pc6.green(layer.summary)}`);
       healthy++;
     } else {
       const isRequired = ["identity", "rules"].includes(layer.name.toLowerCase());
       if (isRequired) {
-        lines.push(`  ${pc5.red("\u2717")} ${layer.name.padEnd(12)} ${pc5.red("missing")}`);
-        lines.push(`    ${pc5.dim("\u2192 Fix: aman-agent init")}`);
+        lines.push(`  ${pc6.red("\u2717")} ${layer.name.padEnd(12)} ${pc6.red("missing")}`);
+        lines.push(`    ${pc6.dim("\u2192 Fix: aman-agent init")}`);
         fixes++;
       } else {
-        lines.push(`  ${pc5.yellow("\u26A0")} ${layer.name.padEnd(12)} ${pc5.yellow("empty")}`);
+        lines.push(`  ${pc6.yellow("\u26A0")} ${layer.name.padEnd(12)} ${pc6.yellow("empty")}`);
         const cmd = layer.name.toLowerCase() === "workflows" ? "/workflows add <name>" : layer.name.toLowerCase() === "tools" ? "/tools add <name> <type> <desc>" : layer.name.toLowerCase() === "skills" ? "/skills install <name>" : "";
-        if (cmd) lines.push(`    ${pc5.dim(`\u2192 Add with ${cmd}`)}`);
+        if (cmd) lines.push(`    ${pc6.dim(`\u2192 Add with ${cmd}`)}`);
         suggestions++;
       }
     }
   }
   lines.push("");
-  lines.push(`  ${status.mcpConnected ? pc5.green("\u2713") : pc5.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc5.green(`${status.mcpToolCount} tools`) : pc5.red("not connected")}`);
+  lines.push(`  ${status.mcpConnected ? pc6.green("\u2713") : pc6.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc6.green(`${status.mcpToolCount} tools`) : pc6.red("not connected")}`);
   if (!status.mcpConnected) {
-    lines.push(`    ${pc5.dim("\u2192 Fix: ensure npx is available and network is connected")}`);
+    lines.push(`    ${pc6.dim("\u2192 Fix: ensure npx is available and network is connected")}`);
     fixes++;
   } else {
     healthy++;
   }
-  lines.push(`  ${status.amemConnected ? pc5.green("\u2713") : pc5.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc5.green("connected") : pc5.red("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc6.green("\u2713") : pc6.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc6.green("connected") : pc6.red("not connected")}`);
   if (!status.amemConnected) {
-    lines.push(`    ${pc5.dim("\u2192 Fix: restart aman-agent (memory initializes automatically)")}`);
+    lines.push(`    ${pc6.dim("\u2192 Fix: restart aman-agent (memory initializes automatically)")}`);
     fixes++;
   } else {
     healthy++;
@@ -5954,36 +6181,36 @@ function handleHelp() {
   return {
     handled: true,
     output: [
-      pc5.bold("Commands:"),
-      `  ${pc5.cyan("/help")}         Show this help`,
-      `  ${pc5.cyan("/identity")}     View identity [update <section>]`,
-      `  ${pc5.cyan("/rules")}        View rules [add|remove|toggle ...]`,
-      `  ${pc5.cyan("/workflows")}    View workflows [add|remove ...]`,
-      `  ${pc5.cyan("/akit")}         Manage tools [add|remove <tool>]`,
-      `  ${pc5.cyan("/skills")}       View skills [install|uninstall|crystallize|list --auto]`,
-      `  ${pc5.cyan("/eval")}         View evaluation [milestone ...]`,
-      `  ${pc5.cyan("/memory")}       View recent memories [search|fts|since|stats|export|clear|timeline]`,
-      `  ${pc5.cyan("/reminder")}     Manage reminders [set|check|done]`,
-      `  ${pc5.cyan("/status")}       Ecosystem dashboard`,
-      `  ${pc5.cyan("/doctor")}       Health check all layers`,
-      `  ${pc5.cyan("/decisions")}    View decision log [<project>]`,
-      `  ${pc5.cyan("/export")}       Export conversation to markdown`,
-      `  ${pc5.cyan("/debug")}        Show debug log`,
-      `  ${pc5.cyan("/save")}         Save conversation to memory`,
-      `  ${pc5.cyan("/model")}        Show current LLM model`,
-      `  ${pc5.cyan("/plan")}         Manage multi-step plans`,
-      `  ${pc5.cyan("/profile me")}   View your profile`,
-      `  ${pc5.cyan("/profile edit")} Edit your profile`,
-      `  ${pc5.cyan("/profile")}      List agent profiles`,
-      `  ${pc5.cyan("/showcase")}     Browse & switch companion templates`,
-      `  ${pc5.cyan("/delegate")}     Delegate tasks to sub-agents`,
-      `  ${pc5.cyan("/team")}         Manage agent teams`,
-      `  ${pc5.cyan("/observe")}      Session observation dashboard [pause|resume]`,
-      `  ${pc5.cyan("/postmortem")}   Generate post-mortem [last|list|--since 7d]`,
-      `  ${pc5.cyan("/update")}       Check for updates`,
-      `  ${pc5.cyan("/reset")}       Full reset [all|memory|config|identity|rules]`,
-      `  ${pc5.cyan("/clear")}        Clear conversation history`,
-      `  ${pc5.cyan("/quit")}         Exit`
+      pc6.bold("Commands:"),
+      `  ${pc6.cyan("/help")}         Show this help`,
+      `  ${pc6.cyan("/identity")}     View identity [update <section>]`,
+      `  ${pc6.cyan("/rules")}        View rules [add|remove|toggle ...]`,
+      `  ${pc6.cyan("/workflows")}    View workflows [add|remove ...]`,
+      `  ${pc6.cyan("/akit")}         Manage tools [add|remove <tool>]`,
+      `  ${pc6.cyan("/skills")}       View skills [install|uninstall|crystallize|list --auto]`,
+      `  ${pc6.cyan("/eval")}         View evaluation [milestone ...]`,
+      `  ${pc6.cyan("/memory")}       View recent memories [search|fts|since|stats|export|clear|timeline]`,
+      `  ${pc6.cyan("/reminder")}     Manage reminders [set|check|done]`,
+      `  ${pc6.cyan("/status")}       Ecosystem dashboard`,
+      `  ${pc6.cyan("/doctor")}       Health check all layers`,
+      `  ${pc6.cyan("/decisions")}    View decision log [<project>]`,
+      `  ${pc6.cyan("/export")}       Export conversation to markdown`,
+      `  ${pc6.cyan("/debug")}        Show debug log`,
+      `  ${pc6.cyan("/save")}         Save conversation to memory`,
+      `  ${pc6.cyan("/model")}        Show current LLM model`,
+      `  ${pc6.cyan("/plan")}         Manage multi-step plans`,
+      `  ${pc6.cyan("/profile me")}   View your profile`,
+      `  ${pc6.cyan("/profile edit")} Edit your profile`,
+      `  ${pc6.cyan("/profile")}      List agent profiles`,
+      `  ${pc6.cyan("/showcase")}     Browse & switch companion templates`,
+      `  ${pc6.cyan("/delegate")}     Delegate tasks to sub-agents`,
+      `  ${pc6.cyan("/team")}         Manage agent teams`,
+      `  ${pc6.cyan("/observe")}      Session observation dashboard [pause|resume]`,
+      `  ${pc6.cyan("/postmortem")}   Generate post-mortem [last|list|--since 7d]`,
+      `  ${pc6.cyan("/update")}       Check for updates`,
+      `  ${pc6.cyan("/reset")}       Full reset [all|memory|config|identity|rules]`,
+      `  ${pc6.cyan("/clear")}        Clear conversation history`,
+      `  ${pc6.cyan("/quit")}         Exit`
     ].join("\n")
   };
 }
@@ -5992,52 +6219,52 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path17.join(os16.homedir(), ".aman-agent"),
-    memory: path17.join(os16.homedir(), ".amem"),
-    identity: path17.join(os16.homedir(), ".acore"),
-    rules: path17.join(os16.homedir(), ".arules")
+    config: path18.join(os17.homedir(), ".aman-agent"),
+    memory: path18.join(os17.homedir(), ".amem"),
+    identity: path18.join(os17.homedir(), ".acore"),
+    rules: path18.join(os17.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
       handled: true,
       output: [
-        pc5.bold("Reset options:"),
-        `  ${pc5.cyan("/reset all")}        Full reset \u2014 config, memory, identity, rules`,
-        `  ${pc5.cyan("/reset memory")}     Clear all memories only`,
-        `  ${pc5.cyan("/reset config")}     Reset LLM config only`,
-        `  ${pc5.cyan("/reset identity")}   Reset persona/identity only`,
-        `  ${pc5.cyan("/reset rules")}      Reset guardrails only`,
+        pc6.bold("Reset options:"),
+        `  ${pc6.cyan("/reset all")}        Full reset \u2014 config, memory, identity, rules`,
+        `  ${pc6.cyan("/reset memory")}     Clear all memories only`,
+        `  ${pc6.cyan("/reset config")}     Reset LLM config only`,
+        `  ${pc6.cyan("/reset identity")}   Reset persona/identity only`,
+        `  ${pc6.cyan("/reset rules")}      Reset guardrails only`,
         "",
-        pc5.dim("Directories:"),
-        ...Object.entries(dirs).map(([k, v]) => `  ${k}: ${pc5.dim(v)}`)
+        pc6.dim("Directories:"),
+        ...Object.entries(dirs).map(([k, v]) => `  ${k}: ${pc6.dim(v)}`)
       ].join("\n")
     };
   }
   const targets = action === "all" ? ["config", "memory", "identity", "rules"] : [action];
   if (!targets.every((t) => t in dirs)) {
-    return { handled: true, output: pc5.red(`Unknown target: ${action}. Use /reset help`) };
+    return { handled: true, output: pc6.red(`Unknown target: ${action}. Use /reset help`) };
   }
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs17.existsSync(dir)) {
-      fs17.rmSync(dir, { recursive: true, force: true });
+    if (fs18.existsSync(dir)) {
+      fs18.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir = dirs.config;
-    fs17.mkdirSync(configDir, { recursive: true });
-    fs17.writeFileSync(path17.join(configDir, ".reconfig"), "", "utf-8");
+    fs18.mkdirSync(configDir, { recursive: true });
+    fs18.writeFileSync(path18.join(configDir, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
-    return { handled: true, output: pc5.dim("Nothing to reset \u2014 directories don't exist.") };
+    return { handled: true, output: pc6.dim("Nothing to reset \u2014 directories don't exist.") };
   }
   return {
     handled: true,
     quit: true,
     output: [
-      pc5.green(`Reset complete: ${removed.join(", ")}`),
+      pc6.green(`Reset complete: ${removed.join(", ")}`),
       "Restart aman-agent to begin fresh."
     ].join("\n")
   };
@@ -6045,20 +6272,20 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.28.0" : "unknown";
+    const local = true ? "0.30.0" : "unknown";
     if (current === local) {
-      return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
+      return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
     return {
       handled: true,
       output: [
-        `${pc5.yellow("Update available:")} v${local} \u2192 v${current}`,
+        `${pc6.yellow("Update available:")} v${local} \u2192 v${current}`,
         "",
         `Run this in your terminal:`,
-        `  ${pc5.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        `  ${pc6.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
         "",
         `Or use npx (always latest):`,
-        `  ${pc5.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc6.bold("npx @aman_asmuei/aman-agent@latest")}`
       ].join("\n")
     };
   } catch {
@@ -6066,10 +6293,10 @@ function handleUpdate() {
       handled: true,
       output: [
         `To update, run in your terminal:`,
-        `  ${pc5.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        `  ${pc6.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
         "",
         `Or use npx (always latest):`,
-        `  ${pc5.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc6.bold("npx @aman_asmuei/aman-agent@latest")}`
       ].join("\n")
     };
   }
@@ -6078,25 +6305,25 @@ async function handleDecisionsCommand(action, _args, _ctx) {
   try {
     const result = await memoryRecall("decision", { type: "decision", limit: 20 });
     if (result.total === 0) {
-      return { handled: true, output: pc5.dim("No decisions recorded yet.") };
+      return { handled: true, output: pc6.dim("No decisions recorded yet.") };
     }
-    return { handled: true, output: pc5.bold("Decision Log:\n") + result.text };
+    return { handled: true, output: pc6.bold("Decision Log:\n") + result.text };
   } catch (err) {
-    return { handled: true, output: pc5.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    return { handled: true, output: pc6.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
   }
 }
 function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path17.join(os16.homedir(), ".aman-agent", "debug.log");
-  if (!fs17.existsSync(logPath)) {
-    return { handled: true, output: pc5.dim("No debug log found.") };
+  const logPath = path18.join(os17.homedir(), ".aman-agent", "debug.log");
+  if (!fs18.existsSync(logPath)) {
+    return { handled: true, output: pc6.dim("No debug log found.") };
   }
-  const content = fs17.readFileSync(logPath, "utf-8");
+  const content = fs18.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) };
+  return { handled: true, output: pc6.bold("Debug Log (last 20 entries):\n") + pc6.dim(last20) };
 }
 async function handleTeamCommand(action, args, ctx) {
   if (!action || action === "list") {
@@ -6104,12 +6331,12 @@ async function handleTeamCommand(action, args, ctx) {
     if (teams.length === 0) {
       return {
         handled: true,
-        output: pc5.dim("No teams yet. Create one:") + "\n  /team create <name>     Create from built-in template\n  /team create            Show available templates"
+        output: pc6.dim("No teams yet. Create one:") + "\n  /team create <name>     Create from built-in template\n  /team create            Show available templates"
       };
     }
     const lines = teams.map((t) => {
       const members = t.members.map((m) => m.profile).join(", ");
-      return `  ${pc5.bold(t.name)} (${t.workflow}) \u2014 ${members}`;
+      return `  ${pc6.bold(t.name)} (${t.workflow}) \u2014 ${members}`;
     });
     return { handled: true, output: "Teams:\n" + lines.join("\n") };
   }
@@ -6119,8 +6346,8 @@ async function handleTeamCommand(action, args, ctx) {
       if (!name) {
         const lines = BUILT_IN_TEAMS.map((t) => {
           const members2 = t.members.map((m) => m.profile).join(" \u2192 ");
-          return `  ${pc5.bold(t.name)} (${t.workflow}) \u2014 ${members2}
-    ${pc5.dim(t.goal)}`;
+          return `  ${pc6.bold(t.name)} (${t.workflow}) \u2014 ${members2}
+    ${pc6.dim(t.goal)}`;
         });
         return {
           handled: true,
@@ -6130,15 +6357,15 @@ async function handleTeamCommand(action, args, ctx) {
       const builtIn = BUILT_IN_TEAMS.find((t) => t.name === name);
       if (builtIn) {
         createTeam(builtIn);
-        return { handled: true, output: pc5.green(`Team installed: ${builtIn.name}`) + "\n\n" + formatTeam(builtIn) };
+        return { handled: true, output: pc6.green(`Team installed: ${builtIn.name}`) + "\n\n" + formatTeam(builtIn) };
       }
       const mode = args[1];
       const membersStr = args[2];
       if (!mode || !membersStr) {
-        return { handled: true, output: pc5.yellow("Usage: /team create <name> <pipeline|parallel|coordinator> <profile1:role>,<profile2:role>") };
+        return { handled: true, output: pc6.yellow("Usage: /team create <name> <pipeline|parallel|coordinator> <profile1:role>,<profile2:role>") };
       }
       if (!["pipeline", "parallel", "coordinator"].includes(mode)) {
-        return { handled: true, output: pc5.yellow("Mode must be: pipeline, parallel, or coordinator") };
+        return { handled: true, output: pc6.yellow("Mode must be: pipeline, parallel, or coordinator") };
       }
       const members = membersStr.split(",").map((m) => {
         const [profile, ...roleParts] = m.trim().split(":");
@@ -6152,34 +6379,34 @@ async function handleTeamCommand(action, args, ctx) {
         workflow: mode
       };
       createTeam(team);
-      return { handled: true, output: pc5.green(`Team created!`) + "\n\n" + formatTeam(team) };
+      return { handled: true, output: pc6.green(`Team created!`) + "\n\n" + formatTeam(team) };
     }
     case "run": {
       const teamName = args[0];
       const task = args.slice(1).join(" ");
       if (!teamName || !task) {
-        return { handled: true, output: pc5.yellow("Usage: /team run <team-name> <task description>") };
+        return { handled: true, output: pc6.yellow("Usage: /team run <team-name> <task description>") };
       }
       const team = loadTeam(teamName);
-      if (!team) return { handled: true, output: pc5.red(`Team not found: ${teamName}`) };
+      if (!team) return { handled: true, output: pc6.red(`Team not found: ${teamName}`) };
       if (!ctx.llmClient || !ctx.mcpManager) {
-        return { handled: true, output: pc5.red("Team execution requires LLM client and MCP.") };
+        return { handled: true, output: pc6.red("Team execution requires LLM client and MCP.") };
       }
       const result = await runTeam(team, task, ctx.llmClient, ctx.mcpManager, ctx.tools);
       return { handled: true, output: formatTeamResult(result) };
     }
     case "show": {
       const name = args[0];
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /team show <name>") };
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /team show <name>") };
       const team = loadTeam(name);
-      if (!team) return { handled: true, output: pc5.red(`Team not found: ${name}`) };
+      if (!team) return { handled: true, output: pc6.red(`Team not found: ${name}`) };
       return { handled: true, output: formatTeam(team) };
     }
     case "delete": {
       const name = args[0];
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /team delete <name>") };
-      if (!deleteTeam(name)) return { handled: true, output: pc5.red(`Team not found: ${name}`) };
-      return { handled: true, output: pc5.dim(`Team deleted: ${name}`) };
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /team delete <name>") };
+      if (!deleteTeam(name)) return { handled: true, output: pc6.red(`Team not found: ${name}`) };
+      return { handled: true, output: pc6.dim(`Team deleted: ${name}`) };
     }
     case "help":
       return { handled: true, output: `Team commands:
@@ -6202,7 +6429,7 @@ Examples:
   /team create review-squad pipeline coder:implement,researcher:review
   /team run review-squad Build a rate limiter in TypeScript` };
     default:
-      return { handled: true, output: pc5.yellow(`Unknown team action: ${action}. Try /team help`) };
+      return { handled: true, output: pc6.yellow(`Unknown team action: ${action}. Try /team help`) };
   }
 }
 async function handleDelegateCommand(action, args, ctx) {
@@ -6231,13 +6458,13 @@ The pipeline mode passes each agent's output to the next:
   writer drafts \u2192 researcher reviews \u2192 writer polishes` };
   }
   if (!ctx.llmClient || !ctx.mcpManager) {
-    return { handled: true, output: pc5.red("Delegation requires LLM client and MCP. Not available.") };
+    return { handled: true, output: pc6.red("Delegation requires LLM client and MCP. Not available.") };
   }
   if (action === "pipeline") {
     const profileList = args[0];
     const task2 = args.slice(1).join(" ");
     if (!profileList || !task2) {
-      return { handled: true, output: pc5.yellow("Usage: /delegate pipeline <profile1>,<profile2> <task>") };
+      return { handled: true, output: pc6.yellow("Usage: /delegate pipeline <profile1>,<profile2> <task>") };
     }
     const profiles = profileList.split(",").map((p4) => p4.trim());
     const steps = profiles.map((profile2, i) => {
@@ -6248,7 +6475,7 @@ The pipeline mode passes each agent's output to the next:
 
 {{input}}` };
     });
-    process.stdout.write(pc5.dim(`
+    process.stdout.write(pc6.dim(`
   Pipeline: ${profiles.join(" \u2192 ")}
 `));
     const results = await delegatePipeline(steps, task2, ctx.llmClient, ctx.mcpManager, { tools: ctx.tools });
@@ -6256,12 +6483,12 @@ The pipeline mode passes each agent's output to the next:
     for (const r of results) {
       if (r.success) {
         output.push(`
-${pc5.bold(`[${r.profile}]`)} ${pc5.green("\u2713")} (${r.turns} tool turns)`);
+${pc6.bold(`[${r.profile}]`)} ${pc6.green("\u2713")} (${r.turns} tool turns)`);
         output.push(r.response.slice(0, 2e3));
-        if (r.toolsUsed.length > 0) output.push(pc5.dim(`  Tools: ${r.toolsUsed.join(", ")}`));
+        if (r.toolsUsed.length > 0) output.push(pc6.dim(`  Tools: ${r.toolsUsed.join(", ")}`));
       } else {
         output.push(`
-${pc5.bold(`[${r.profile}]`)} ${pc5.red("\u2717")} ${r.error}`);
+${pc6.bold(`[${r.profile}]`)} ${pc6.red("\u2717")} ${r.error}`);
       }
     }
     return { handled: true, output: output.join("\n") };
@@ -6269,15 +6496,15 @@ ${pc5.bold(`[${r.profile}]`)} ${pc5.red("\u2717")} ${r.error}`);
   const profile = action;
   const task = args.join(" ");
   if (!task) {
-    return { handled: true, output: pc5.yellow(`Usage: /delegate ${profile} <task description>`) };
+    return { handled: true, output: pc6.yellow(`Usage: /delegate ${profile} <task description>`) };
   }
-  process.stdout.write(pc5.dim(`
+  process.stdout.write(pc6.dim(`
   [delegating to ${profile}...]
 
 `));
   const result = await delegateTask(task, profile, ctx.llmClient, ctx.mcpManager, { tools: ctx.tools });
   if (!result.success) {
-    return { handled: true, output: pc5.red(`Delegation failed: ${result.error}`) };
+    return { handled: true, output: pc6.red(`Delegation failed: ${result.error}`) };
   }
   const meta = [];
   if (result.toolsUsed.length > 0) meta.push(`Tools: ${result.toolsUsed.join(", ")}`);
@@ -6285,31 +6512,31 @@ ${pc5.bold(`[${r.profile}]`)} ${pc5.red("\u2717")} ${r.error}`);
   return {
     handled: true,
     output: `
-${pc5.bold(`[${profile}]`)} ${pc5.green("\u2713")}${meta.length > 0 ? " " + pc5.dim(`(${meta.join(", ")})`) : ""}
+${pc6.bold(`[${profile}]`)} ${pc6.green("\u2713")}${meta.length > 0 ? " " + pc6.dim(`(${meta.join(", ")})`) : ""}
 
 ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path17.join(os16.homedir(), ".acore", "profiles");
+  const profilesDir = path18.join(os17.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
-      return { handled: true, output: pc5.dim("No user profile yet. Run /profile edit to set one up.") };
+      return { handled: true, output: pc6.dim("No user profile yet. Run /profile edit to set one up.") };
     }
     const lines = [
-      `  ${pc5.bold("Name:")}       ${user.name}`,
-      `  ${pc5.bold("Role:")}       ${user.roleLabel}`,
-      `  ${pc5.bold("Expertise:")}  ${user.expertiseLabel}`,
-      `  ${pc5.bold("Style:")}      ${user.styleLabel}`
+      `  ${pc6.bold("Name:")}       ${user.name}`,
+      `  ${pc6.bold("Role:")}       ${user.roleLabel}`,
+      `  ${pc6.bold("Expertise:")}  ${user.expertiseLabel}`,
+      `  ${pc6.bold("Style:")}      ${user.styleLabel}`
     ];
-    if (user.workingOn) lines.push(`  ${pc5.bold("Working on:")} ${user.workingOn}`);
-    if (user.notes) lines.push(`  ${pc5.bold("Notes:")}      ${user.notes}`);
-    lines.push(`  ${pc5.dim(`Updated: ${user.updatedAt}`)}`);
+    if (user.workingOn) lines.push(`  ${pc6.bold("Working on:")} ${user.workingOn}`);
+    if (user.notes) lines.push(`  ${pc6.bold("Notes:")}      ${user.notes}`);
+    lines.push(`  ${pc6.dim(`Updated: ${user.updatedAt}`)}`);
     return { handled: true, output: `Your profile:
 ${lines.join("\n")}
 
-${pc5.dim("Edit with: /profile edit")}` };
+${pc6.dim("Edit with: /profile edit")}` };
   }
   if (action === "edit") {
     const current = loadUserIdentity();
@@ -6333,25 +6560,25 @@ ${pc5.dim("Edit with: /profile edit")}` };
   if (!action || action === "list") {
     const profiles = listProfiles();
     const user = loadUserIdentity();
-    const userLine = user ? `${pc5.bold("You:")} ${user.name} (${user.roleLabel}, ${user.expertiseLabel})
+    const userLine = user ? `${pc6.bold("You:")} ${user.name} (${user.roleLabel}, ${user.expertiseLabel})
 
-` : `${pc5.dim("No user profile. Set up with: /profile edit")}
+` : `${pc6.dim("No user profile. Set up with: /profile edit")}
 
 `;
     if (profiles.length === 0) {
-      return { handled: true, output: userLine + pc5.dim("No agent profiles yet. Create one with: /profile create <name>") };
+      return { handled: true, output: userLine + pc6.dim("No agent profiles yet. Create one with: /profile create <name>") };
     }
     const lines = profiles.map(
-      (p4) => `  ${pc5.bold(p4.name)} \u2014 ${p4.aiName} (${pc5.dim(p4.personality)})`
+      (p4) => `  ${pc6.bold(p4.name)} \u2014 ${p4.aiName} (${pc6.dim(p4.personality)})`
     );
-    return { handled: true, output: userLine + "Agent profiles:\n" + lines.join("\n") + "\n\n" + pc5.dim("Switch with: aman-agent --profile <name>") };
+    return { handled: true, output: userLine + "Agent profiles:\n" + lines.join("\n") + "\n\n" + pc6.dim("Switch with: aman-agent --profile <name>") };
   }
   switch (action) {
     case "create": {
       const name = args[0];
       if (!name) {
         const lines = BUILT_IN_PROFILES.map(
-          (t) => `  ${pc5.bold(t.name)} \u2014 ${t.label}: ${pc5.dim(t.description)}`
+          (t) => `  ${pc6.bold(t.name)} \u2014 ${t.label}: ${pc6.dim(t.description)}`
         );
         return {
           handled: true,
@@ -6359,33 +6586,33 @@ ${pc5.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path17.join(profilesDir, slug);
-      if (fs17.existsSync(profileDir)) {
-        return { handled: true, output: pc5.yellow(`Profile already exists: ${slug}`) };
+      const profileDir = path18.join(profilesDir, slug);
+      if (fs18.existsSync(profileDir)) {
+        return { handled: true, output: pc6.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
       if (builtIn) {
         const err = installProfileTemplate(slug);
-        if (err) return { handled: true, output: pc5.red(err) };
+        if (err) return { handled: true, output: pc6.red(err) };
         return {
           handled: true,
-          output: pc5.green(`Profile installed: ${builtIn.label}`) + `
+          output: pc6.green(`Profile installed: ${builtIn.label}`) + `
   AI name: ${builtIn.core.match(/^# (.+)/m)?.[1] || slug}
-  ${pc5.dim(builtIn.description)}
+  ${pc6.dim(builtIn.description)}
 
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs17.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path17.join(os16.homedir(), ".acore", "core.md");
-      if (fs17.existsSync(globalCore)) {
-        let content = fs17.readFileSync(globalCore, "utf-8");
+      fs18.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path18.join(os17.homedir(), ".acore", "core.md");
+      if (fs18.existsSync(globalCore)) {
+        let content = fs18.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs17.writeFileSync(path17.join(profileDir, "core.md"), content, "utf-8");
+        fs18.writeFileSync(path18.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs17.writeFileSync(path17.join(profileDir, "core.md"), `# ${aiName}
+        fs18.writeFileSync(path18.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -6397,58 +6624,58 @@ ${pc5.dim("Edit with: /profile edit")}` };
       }
       return {
         handled: true,
-        output: pc5.green(`Profile created: ${slug}`) + `
-  Edit: ${path17.join(profileDir, "core.md")}
+        output: pc6.green(`Profile created: ${slug}`) + `
+  Edit: ${path18.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
-  ${pc5.dim("Add rules.md or skills.md for profile-specific overrides.")}`
+  ${pc6.dim("Add rules.md or skills.md for profile-specific overrides.")}`
       };
     }
     case "show": {
       const name = args[0];
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /profile show <name>") };
-      const profileDir = path17.join(profilesDir, name);
-      if (!fs17.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      const files = fs17.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /profile show <name>") };
+      const profileDir = path18.join(profilesDir, name);
+      if (!fs18.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      const files = fs18.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
-      return { handled: true, output: `Profile: ${pc5.bold(name)}
+      return { handled: true, output: `Profile: ${pc6.bold(name)}
 Files:
 ${lines.join("\n")}` };
     }
     case "delete": {
       const name = args[0];
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /profile delete <name>") };
-      const profileDir = path17.join(profilesDir, name);
-      if (!fs17.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      fs17.rmSync(profileDir, { recursive: true });
-      return { handled: true, output: pc5.dim(`Profile deleted: ${name}`) };
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /profile delete <name>") };
+      const profileDir = path18.join(profilesDir, name);
+      if (!fs18.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      fs18.rmSync(profileDir, { recursive: true });
+      return { handled: true, output: pc6.dim(`Profile deleted: ${name}`) };
     }
     case "help":
       return { handled: true, output: `Profile commands:
 
-  ${pc5.bold("Your profile:")}
+  ${pc6.bold("Your profile:")}
   /profile me           View your profile
   /profile edit         Edit your profile
   /profile setup        Re-run full profile setup
 
-  ${pc5.bold("Agent profiles:")}
+  ${pc6.bold("Agent profiles:")}
   /profile              List all profiles
   /profile create <n>   Create new agent profile
   /profile show <n>     Show agent profile files
   /profile delete <n>   Delete an agent profile
 
-  ${pc5.bold("Use agent profiles:")}
+  ${pc6.bold("Use agent profiles:")}
   aman-agent --profile <name>
   AMAN_PROFILE=<name> aman-agent` };
     default:
-      return { handled: true, output: pc5.yellow(`Unknown profile action: ${action}. Try /profile help`) };
+      return { handled: true, output: pc6.yellow(`Unknown profile action: ${action}. Try /profile help`) };
   }
 }
 function handlePlanCommand(action, args, ctx) {
   if (!action) {
     const active = getActivePlan();
     if (!active) {
-      return { handled: true, output: pc5.dim("No active plan. Create one with: /plan create <name> | <goal> | <step1>, <step2>, ...") };
+      return { handled: true, output: pc6.dim("No active plan. Create one with: /plan create <name> | <goal> | <step1>, <step2>, ...") };
     }
     return { handled: true, output: formatPlan(active) };
   }
@@ -6457,22 +6684,22 @@ function handlePlanCommand(action, args, ctx) {
       const fullArgs = args.join(" ");
       const parts = fullArgs.split("|").map((p4) => p4.trim());
       if (parts.length < 3) {
-        return { handled: true, output: pc5.yellow("Usage: /plan create <name> | <goal> | <step1>, <step2>, ...") };
+        return { handled: true, output: pc6.yellow("Usage: /plan create <name> | <goal> | <step1>, <step2>, ...") };
       }
       const name = parts[0];
       const goal = parts[1];
       const steps = parts[2].split(",").map((s) => s.trim()).filter(Boolean);
       if (steps.length === 0) {
-        return { handled: true, output: pc5.yellow("Need at least one step. Separate steps with commas.") };
+        return { handled: true, output: pc6.yellow("Need at least one step. Separate steps with commas.") };
       }
       const plan = createPlan(name, goal, steps);
-      return { handled: true, output: pc5.green(`Plan created!
+      return { handled: true, output: pc6.green(`Plan created!
 
 `) + formatPlan(plan) };
     }
     case "done": {
       const active = getActivePlan();
-      if (!active) return { handled: true, output: pc5.yellow("No active plan.") };
+      if (!active) return { handled: true, output: pc6.yellow("No active plan.") };
       const recordPlanMilestone = (stepIndex) => {
         if (ctx?.observationSession) {
           const step = active.steps[stepIndex];
@@ -6486,51 +6713,51 @@ function handlePlanCommand(action, args, ctx) {
       if (args.length > 0) {
         const stepNum = parseInt(args[0], 10);
         if (isNaN(stepNum) || stepNum < 1 || stepNum > active.steps.length) {
-          return { handled: true, output: pc5.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
+          return { handled: true, output: pc6.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
         }
         markStepDone(active, stepNum - 1);
         recordPlanMilestone(stepNum - 1);
-        return { handled: true, output: pc5.green(`Step ${stepNum} done!`) + "\n\n" + formatPlan(active) };
+        return { handled: true, output: pc6.green(`Step ${stepNum} done!`) + "\n\n" + formatPlan(active) };
       }
       const next = active.steps.findIndex((s) => !s.done);
-      if (next < 0) return { handled: true, output: pc5.green("All steps already complete!") };
+      if (next < 0) return { handled: true, output: pc6.green("All steps already complete!") };
       markStepDone(active, next);
       recordPlanMilestone(next);
-      return { handled: true, output: pc5.green(`Step ${next + 1} done!`) + "\n\n" + formatPlan(active) };
+      return { handled: true, output: pc6.green(`Step ${next + 1} done!`) + "\n\n" + formatPlan(active) };
     }
     case "undo": {
       const active = getActivePlan();
-      if (!active) return { handled: true, output: pc5.yellow("No active plan.") };
+      if (!active) return { handled: true, output: pc6.yellow("No active plan.") };
       const stepNum = parseInt(args[0], 10);
       if (isNaN(stepNum) || stepNum < 1 || stepNum > active.steps.length) {
-        return { handled: true, output: pc5.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
+        return { handled: true, output: pc6.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
       }
       markStepUndone(active, stepNum - 1);
-      return { handled: true, output: pc5.dim(`Step ${stepNum} unmarked.`) + "\n\n" + formatPlan(active) };
+      return { handled: true, output: pc6.dim(`Step ${stepNum} unmarked.`) + "\n\n" + formatPlan(active) };
     }
     case "list": {
       const plans = listPlans();
-      if (plans.length === 0) return { handled: true, output: pc5.dim("No plans yet.") };
+      if (plans.length === 0) return { handled: true, output: pc6.dim("No plans yet.") };
       const lines = plans.map((p4) => {
         const done = p4.steps.filter((s) => s.done).length;
         const total = p4.steps.length;
-        const status = p4.active ? pc5.green("active") : pc5.dim("inactive");
+        const status = p4.active ? pc6.green("active") : pc6.dim("inactive");
         return `  ${p4.name} \u2014 ${done}/${total} steps (${status})`;
       });
       return { handled: true, output: "Plans:\n" + lines.join("\n") };
     }
     case "switch": {
       const name = args.join(" ");
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /plan switch <name>") };
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /plan switch <name>") };
       const plan = setActivePlan(name);
-      if (!plan) return { handled: true, output: pc5.red(`Plan not found: ${name}`) };
-      return { handled: true, output: pc5.green(`Switched to: ${plan.name}`) + "\n\n" + formatPlan(plan) };
+      if (!plan) return { handled: true, output: pc6.red(`Plan not found: ${name}`) };
+      return { handled: true, output: pc6.green(`Switched to: ${plan.name}`) + "\n\n" + formatPlan(plan) };
     }
     case "show": {
       const name = args.join(" ");
-      if (!name) return { handled: true, output: pc5.yellow("Usage: /plan show <name>") };
+      if (!name) return { handled: true, output: pc6.yellow("Usage: /plan show <name>") };
       const plan = loadPlan(name);
-      if (!plan) return { handled: true, output: pc5.red(`Plan not found: ${name}`) };
+      if (!plan) return { handled: true, output: pc6.red(`Plan not found: ${name}`) };
       return { handled: true, output: formatPlan(plan) };
     }
     case "help":
@@ -6543,27 +6770,27 @@ function handlePlanCommand(action, args, ctx) {
   /plan switch <name> Switch active plan
   /plan show <name>   Show a specific plan` };
     default:
-      return { handled: true, output: pc5.yellow(`Unknown plan action: ${action}. Try /plan help`) };
+      return { handled: true, output: pc6.yellow(`Unknown plan action: ${action}. Try /plan help`) };
   }
 }
 async function handleReminderCommand(action, args) {
   if (!action || action === "list") {
     try {
       const reminders = reminderList();
-      if (reminders.length === 0) return { handled: true, output: pc5.dim("No reminders.") };
-      const lines = [pc5.bold(`Reminders (${reminders.length}):`), ""];
+      if (reminders.length === 0) return { handled: true, output: pc6.dim("No reminders.") };
+      const lines = [pc6.bold(`Reminders (${reminders.length}):`), ""];
       for (const r of reminders) {
-        const status = r.completed ? pc5.green("[done]") : pc5.yellow("[todo]");
-        const due = r.dueAt ? ` ${pc5.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
-        lines.push(`  ${status} ${r.content}${due} ${pc5.dim(`(${r.id.slice(0, 8)})`)}`);
+        const status = r.completed ? pc6.green("[done]") : pc6.yellow("[todo]");
+        const due = r.dueAt ? ` ${pc6.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
+        lines.push(`  ${status} ${r.content}${due} ${pc6.dim(`(${r.id.slice(0, 8)})`)}`);
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "set" || action === "add") {
-    if (args.length === 0) return { handled: true, output: pc5.yellow("Usage: /reminder set <text> [--due <time>]\n  Time formats: 1h, 2d, 1w, or ISO date (2026-04-10)") };
+    if (args.length === 0) return { handled: true, output: pc6.yellow("Usage: /reminder set <text> [--due <time>]\n  Time formats: 1h, 2d, 1w, or ISO date (2026-04-10)") };
     let dueAt;
     const dueIdx = args.indexOf("--due");
     let contentArgs = args;
@@ -6582,66 +6809,66 @@ async function handleReminderCommand(action, args) {
       }
     }
     const content = contentArgs.join(" ");
-    if (!content) return { handled: true, output: pc5.yellow("Usage: /reminder set <text> [--due <time>]") };
+    if (!content) return { handled: true, output: pc6.yellow("Usage: /reminder set <text> [--due <time>]") };
     try {
       const id = reminderSet(content, dueAt);
       const dueInfo = dueAt ? ` (due: ${new Date(dueAt).toLocaleDateString()})` : "";
-      return { handled: true, output: pc5.green(`Reminder set: "${content}"${dueInfo} (ID: ${id.slice(0, 8)})`) };
+      return { handled: true, output: pc6.green(`Reminder set: "${content}"${dueInfo} (ID: ${id.slice(0, 8)})`) };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "done" || action === "complete") {
-    if (!args[0]) return { handled: true, output: pc5.yellow("Usage: /reminder done <id>") };
+    if (!args[0]) return { handled: true, output: pc6.yellow("Usage: /reminder done <id>") };
     try {
       const result = reminderComplete(args[0]);
-      return { handled: true, output: result ? pc5.green("Reminder completed.") : pc5.yellow("Reminder not found.") };
+      return { handled: true, output: result ? pc6.green("Reminder completed.") : pc6.yellow("Reminder not found.") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "check") {
     try {
       const reminders = reminderCheck();
-      if (reminders.length === 0) return { handled: true, output: pc5.dim("No pending reminders.") };
-      const lines = [pc5.bold("Pending Reminders:"), ""];
+      if (reminders.length === 0) return { handled: true, output: pc6.dim("No pending reminders.") };
+      const lines = [pc6.bold("Pending Reminders:"), ""];
       for (const r of reminders) {
-        const icon = r.status === "overdue" ? pc5.red("!!!") : r.status === "today" ? pc5.yellow("(!)") : pc5.dim("( )");
-        const due = r.dueAt ? ` ${pc5.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
-        lines.push(`  ${icon} ${r.content}${due} ${pc5.dim(`[${r.status}]`)}`);
+        const icon = r.status === "overdue" ? pc6.red("!!!") : r.status === "today" ? pc6.yellow("(!)") : pc6.dim("( )");
+        const due = r.dueAt ? ` ${pc6.dim(`due: ${new Date(r.dueAt).toLocaleString()}`)}` : "";
+        lines.push(`  ${icon} ${r.content}${due} ${pc6.dim(`[${r.status}]`)}`);
       }
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Reminder error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "help") {
     return { handled: true, output: [
-      pc5.bold("Reminder commands:"),
-      `  ${pc5.cyan("/reminder")}                List all reminders`,
-      `  ${pc5.cyan("/reminder set")} <text>      Create a reminder [--due 1h|2d|1w|date]`,
-      `  ${pc5.cyan("/reminder check")}           Show overdue/upcoming`,
-      `  ${pc5.cyan("/reminder done")} <id>       Mark as completed`
+      pc6.bold("Reminder commands:"),
+      `  ${pc6.cyan("/reminder")}                List all reminders`,
+      `  ${pc6.cyan("/reminder set")} <text>      Create a reminder [--due 1h|2d|1w|date]`,
+      `  ${pc6.cyan("/reminder check")}           Show overdue/upcoming`,
+      `  ${pc6.cyan("/reminder done")} <id>       Mark as completed`
     ].join("\n") };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /reminder ${action}. Try /reminder --help`) };
+  return { handled: true, output: pc6.yellow(`Unknown action: /reminder ${action}. Try /reminder --help`) };
 }
 function handleShowcaseCommand(action, args) {
   const showcases = loadShowcaseManifest();
   if (showcases.length === 0) {
     return {
       handled: true,
-      output: pc5.dim("No showcase templates found.") + `
+      output: pc6.dim("No showcase templates found.") + `
 
   Install aman-showcase to get 13 pre-built companion personalities:
-  ${pc5.bold("npm install -g @aman_asmuei/aman-showcase")}
+  ${pc6.bold("npm install -g @aman_asmuei/aman-showcase")}
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path17.join(os16.homedir(), ".acore", "core.md");
+  const corePath = path18.join(os17.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs17.existsSync(corePath)) {
-    const content = fs17.readFileSync(corePath, "utf-8");
+  if (fs18.existsSync(corePath)) {
+    const content = fs18.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -6651,12 +6878,12 @@ function handleShowcaseCommand(action, args) {
   }
   if (!action || action === "list") {
     const lines = showcases.map((s) => {
-      const active = s.name === currentShowcase ? pc5.green(" \u2190 active") : "";
+      const active = s.name === currentShowcase ? pc6.green(" \u2190 active") : "";
       const langBadge = s.language === "ms" ? " [BM]" : s.language === "en+ms" ? " [EN/BM]" : "";
-      return `  ${pc5.bold(s.name.padEnd(12))} ${s.title}${langBadge}${active}`;
+      return `  ${pc6.bold(s.name.padEnd(12))} ${s.title}${langBadge}${active}`;
     });
     const currentLine = currentShowcase ? `
-Current: ${pc5.bold(currentShowcase)}
+Current: ${pc6.bold(currentShowcase)}
 ` : `
 No showcase active (using default personality)
 `;
@@ -6666,49 +6893,49 @@ No showcase active (using default personality)
 
 ${lines.join("\n")}
 ${currentLine}
-${pc5.dim("Switch with: /showcase install <name>")}`
+${pc6.dim("Switch with: /showcase install <name>")}`
     };
   }
   if (action === "install" || action === "switch" || action === "use") {
     const name = args[0];
     if (!name) {
-      return { handled: true, output: pc5.yellow("Usage: /showcase install <name>\n\nRun /showcase list to see available templates.") };
+      return { handled: true, output: pc6.yellow("Usage: /showcase install <name>\n\nRun /showcase list to see available templates.") };
     }
     const entry = showcases.find((s) => s.name === name);
     if (!entry) {
-      return { handled: true, output: pc5.red(`Showcase not found: ${name}`) + `
+      return { handled: true, output: pc6.red(`Showcase not found: ${name}`) + `
 
 Available: ${showcases.map((s) => s.name).join(", ")}` };
     }
     if (name === currentShowcase) {
-      return { handled: true, output: pc5.dim(`${entry.title} is already active.`) };
+      return { handled: true, output: pc6.dim(`${entry.title} is already active.`) };
     }
     try {
       const result = installShowcaseTemplate(name);
-      const lines = [pc5.green(`Installed ${pc5.bold(entry.title)}`)];
+      const lines = [pc6.green(`Installed ${pc6.bold(entry.title)}`)];
       for (const f of result.installed) {
-        lines.push(pc5.dim(`  ${f}`));
+        lines.push(pc6.dim(`  ${f}`));
       }
       if (result.backed_up.length > 0) {
-        lines.push(pc5.dim(`
+        lines.push(pc6.dim(`
   Backed up ${result.backed_up.length} existing file(s) (.bak)`));
       }
       lines.push("");
-      lines.push(pc5.yellow("Restart aman-agent to use the new personality."));
-      lines.push(pc5.dim("Your user profile (/profile me) is unchanged \u2014 only the AI personality switched."));
+      lines.push(pc6.yellow("Restart aman-agent to use the new personality."));
+      lines.push(pc6.dim("Your user profile (/profile me) is unchanged \u2014 only the AI personality switched."));
       return { handled: true, output: lines.join("\n") };
     } catch (err) {
-      return { handled: true, output: pc5.red(`Failed to install: ${err instanceof Error ? err.message : String(err)}`) };
+      return { handled: true, output: pc6.red(`Failed to install: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
   if (action === "current") {
     if (currentShowcase) {
       const entry = showcases.find((s) => s.name === currentShowcase);
-      return { handled: true, output: `Active showcase: ${pc5.bold(entry?.title || currentShowcase)}
-${pc5.dim(entry?.description || "")}` };
+      return { handled: true, output: `Active showcase: ${pc6.bold(entry?.title || currentShowcase)}
+${pc6.dim(entry?.description || "")}` };
     }
-    return { handled: true, output: pc5.dim("No showcase active \u2014 using default personality.") + `
-${pc5.dim("Install one with: /showcase install <name>")}` };
+    return { handled: true, output: pc6.dim("No showcase active \u2014 using default personality.") + `
+${pc6.dim("Install one with: /showcase install <name>")}` };
   }
   if (action === "help") {
     return { handled: true, output: `Showcase commands:
@@ -6717,70 +6944,70 @@ ${pc5.dim("Install one with: /showcase install <name>")}` };
   /showcase install <n>  Install/switch to a template
   /showcase current      Show active template
 
-${pc5.dim("Showcase templates replace your AI's personality, workflows, rules, and skills.")}
-${pc5.dim("Your user profile (/profile me) stays unchanged \u2014 only the AI personality switches.")}
-${pc5.dim("Existing files are backed up (.bak) before overwriting.")}` };
+${pc6.dim("Showcase templates replace your AI's personality, workflows, rules, and skills.")}
+${pc6.dim("Your user profile (/profile me) stays unchanged \u2014 only the AI personality switches.")}
+${pc6.dim("Existing files are backed up (.bak) before overwriting.")}` };
   }
-  return { handled: true, output: pc5.yellow(`Unknown action: /showcase ${action}. Try /showcase help`) };
+  return { handled: true, output: pc6.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`
+        pc6.bold("File commands:"),
+        `  ${pc6.cyan("/file read")} <path>               Read a text file (max 50 KB)`,
+        `  ${pc6.cyan("/file convert")} <path>            Attempt to read binary file as text`,
+        `  ${pc6.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>`) };
+      return { handled: true, output: pc6.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)`),
+        pc6.bold(`\u{1F4C4} ${result.path}`) + pc6.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.`));
+        lines.push("", pc6.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)}`) };
+      return { handled: true, output: pc6.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]`) };
+      return { handled: true, output: pc6.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)`),
+        pc6.bold(`\u{1F4C1} ${result.path}`) + pc6.dim(` (${result.total} items)`),
         ""
       ];
       for (const entry of result.entries) {
         if (entry.type === "dir") {
-          lines.push(`  ${pc5.cyan(entry.name + "/")}`);
+          lines.push(`  ${pc6.cyan(entry.name + "/")}`);
         } else {
-          const kb = entry.size > 0 ? pc5.dim(` ${(entry.size / 1024).toFixed(1)} KB`) : "";
+          const kb = entry.size > 0 ? pc6.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: pc6.red(`File error: ${err instanceof Error ? err.message : String(err)}`) };
     }
   }
-  return { handled: true, output: pc5.yellow(`Unknown /file subcommand: ${action}. Try /file for help.`) };
+  return { handled: true, output: pc6.yellow(`Unknown /file subcommand: ${action}. Try /file for help.`) };
 }
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
@@ -6820,16 +7047,16 @@ async function handleObserveCommand(action, ctx) {
   if (!ctx.observationSession) {
     return {
       handled: true,
-      output: pc5.dim("Observation is disabled. Enable with recordObservations: true in config.")
+      output: pc6.dim("Observation is disabled. Enable with recordObservations: true in config.")
     };
   }
   switch (action) {
     case "pause":
       pauseObservation(ctx.observationSession);
-      return { handled: true, output: pc5.dim("Observation paused. Use /observe resume to continue.") };
+      return { handled: true, output: pc6.dim("Observation paused. Use /observe resume to continue.") };
     case "resume":
       resumeObservation(ctx.observationSession);
-      return { handled: true, output: pc5.dim("Observation resumed.") };
+      return { handled: true, output: pc6.dim("Observation resumed.") };
     default:
       return { handled: true, output: getSessionStats(ctx.observationSession) };
   }
@@ -6838,13 +7065,13 @@ async function handlePostmortemCommand(action, args, ctx) {
   switch (action) {
     case "last": {
       const files = await listPostmortems();
-      if (files.length === 0) return { handled: true, output: pc5.dim("No post-mortems found.") };
+      if (files.length === 0) return { handled: true, output: pc6.dim("No post-mortems found.") };
       const content = await readPostmortem(files[0]);
-      return { handled: true, output: content ?? pc5.red("Could not read post-mortem.") };
+      return { handled: true, output: content ?? pc6.red("Could not read post-mortem.") };
     }
     case "list": {
       const files = await listPostmortems();
-      if (files.length === 0) return { handled: true, output: pc5.dim("No post-mortems found.") };
+      if (files.length === 0) return { handled: true, output: pc6.dim("No post-mortems found.") };
       return { handled: true, output: "Post-mortems:\n" + files.map((f) => `  ${f}`).join("\n") };
     }
     default: {
@@ -6854,15 +7081,15 @@ async function handlePostmortemCommand(action, args, ctx) {
         const daysStr = allArgs[sinceIdx + 1];
         const days = parseInt(daysStr.replace("d", ""), 10) || 7;
         if (!ctx.llmClient) {
-          return { handled: true, output: pc5.red("LLM client not available for analysis.") };
+          return { handled: true, output: pc6.red("LLM client not available for analysis.") };
         }
         const analysis = await analyzePostmortemRange(days, ctx.llmClient);
-        return { handled: true, output: analysis ?? pc5.red("Could not analyze post-mortems.") };
+        return { handled: true, output: analysis ?? pc6.red("Could not analyze post-mortems.") };
       }
       if (!ctx.observationSession || !ctx.llmClient || !ctx.messages) {
         return {
           handled: true,
-          output: pc5.dim("Cannot generate post-mortem: missing session context.")
+          output: pc6.dim("Cannot generate post-mortem: missing session context.")
         };
       }
       const report = await generatePostmortemReport(
@@ -6871,13 +7098,13 @@ async function handlePostmortemCommand(action, args, ctx) {
         ctx.observationSession,
         ctx.llmClient
       );
-      if (!report) return { handled: true, output: pc5.red("Could not generate post-mortem.") };
+      if (!report) return { handled: true, output: pc6.red("Could not generate post-mortem.") };
       const filePath = await savePostmortem(report);
       return {
         handled: true,
         output: formatPostmortemMarkdown(report) + `
 
-${pc5.dim(`Saved \u2192 ${filePath}`)}`
+${pc6.dim(`Saved \u2192 ${filePath}`)}`
       };
     }
   }
@@ -6895,9 +7122,9 @@ async function handleCommand(input, ctx) {
     case "help":
       return handleHelp();
     case "clear":
-      return { handled: true, output: pc5.dim("Conversation cleared."), clearHistory: true };
+      return { handled: true, output: pc6.dim("Conversation cleared."), clearHistory: true };
     case "model":
-      return { handled: true, output: ctx.model ? `Model: ${pc5.bold(ctx.model)}` : "Model: unknown" };
+      return { handled: true, output: ctx.model ? `Model: ${pc6.bold(ctx.model)}` : "Model: unknown" };
     case "identity":
       return handleIdentityCommand(action, args, ctx);
     case "rules":
@@ -7028,10 +7255,10 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import fsp from "fs/promises";
-import path18 from "path";
-import os17 from "os";
+import path19 from "path";
+import os18 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"],
@@ -7060,20 +7287,20 @@ async function loadRuntimeTriggers(skillsMdPath) {
     return /* @__PURE__ */ new Map();
   }
 }
-var LEVEL_FILE = path18.join(os17.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path19.join(os18.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs18.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs18.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs19.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs19.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path18.dirname(LEVEL_FILE);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path19.dirname(LEVEL_FILE);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -7300,7 +7527,7 @@ async function autoTriggerSkills(userInput, mcpManager) {
     const result = await mcpManager.callTool("skill_list", {});
     const skills = JSON.parse(result);
     const installed = skills.filter((s) => s.installed).map((s) => s.name);
-    const skillsMdPath = path18.join(os17.homedir(), ".askill", "skills.md");
+    const skillsMdPath = path19.join(os18.homedir(), ".askill", "skills.md");
     const runtimeTriggers = await loadRuntimeTriggers(skillsMdPath);
     if (installed.length === 0 && runtimeTriggers.size === 0) return "";
     const matched = matchSkillsSemantic(userInput, installed, runtimeTriggers);
@@ -7575,7 +7802,7 @@ function matchKnowledge(userInput) {
 }
 
 // src/memory-extractor.ts
-import { reflect as reflect2, isReflectionDue as isReflectionDue2 } from "@aman_asmuei/amem-core";
+import { reflect as reflect2, isReflectionDue as isReflectionDue2, autoRelateMemory } 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;
@@ -7703,6 +7930,10 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
         if (storeResult.action !== "private") {
           stored++;
           log.debug("extractor", "Stored " + candidate.type + ": " + candidate.content);
+          try {
+            autoRelateMemory(getDb(), storeResult.id);
+          } catch {
+          }
           if (candidate.type === "pattern" || candidate.type === "preference") {
             const skillMatch = matchPatternToSkill(candidate.content, candidate.tags);
             if (skillMatch) {
@@ -7729,147 +7960,6 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
   }
 }
 
-// src/background.ts
-import pc6 from "picocolors";
-var BACKGROUND_ELIGIBLE = /* @__PURE__ */ new Set([
-  "run_tests",
-  "npm_test",
-  "build",
-  "npm_build",
-  "file_search",
-  "code_search",
-  "grep_search",
-  "git_clone",
-  "docker_build",
-  "docker_run"
-]);
-var NEVER_BACKGROUND = /* @__PURE__ */ new Set([
-  "memory_recall",
-  "memory_store",
-  "memory_log",
-  "memory_context",
-  "memory_detail",
-  "identity_read",
-  "identity_summary",
-  "identity_update_session",
-  "identity_update_dynamics",
-  "rules_check",
-  "rules_list",
-  "workflow_list",
-  "workflow_get",
-  "skill_list",
-  "skill_search",
-  "eval_status",
-  "eval_log",
-  "reminder_check",
-  "reminder_set",
-  "file_read",
-  "doc_convert",
-  "file_list",
-  "avatar_prompt"
-]);
-function shouldRunInBackground(toolName) {
-  if (NEVER_BACKGROUND.has(toolName)) return false;
-  if (BACKGROUND_ELIGIBLE.has(toolName)) return true;
-  return false;
-}
-var BackgroundTaskManager = class {
-  tasks = /* @__PURE__ */ new Map();
-  taskCounter = 0;
-  /**
-   * Launch a tool call in the background.
-   */
-  launch(toolName, toolUseId, mcpManager, toolInput) {
-    const id = `bg-${++this.taskCounter}`;
-    const task = {
-      id,
-      toolName,
-      toolUseId,
-      startedAt: Date.now(),
-      done: false,
-      promise: mcpManager.callTool(toolName, toolInput).then(
-        (result) => {
-          task.result = result;
-          task.done = true;
-          return result;
-        },
-        (error) => {
-          task.error = error instanceof Error ? error.message : String(error);
-          task.done = true;
-          return `Error: ${task.error}`;
-        }
-      )
-    };
-    this.tasks.set(id, task);
-    process.stdout.write(pc6.dim(`  [${toolName} running in background (${id})...]
-`));
-    return task;
-  }
-  /**
-   * Check for completed background tasks and return their results.
-   */
-  collectCompleted() {
-    const completed = [];
-    for (const [id, task] of this.tasks) {
-      if (task.done) {
-        completed.push(task);
-        this.tasks.delete(id);
-      }
-    }
-    return completed;
-  }
-  /**
-   * Display completed background task results to the user.
-   */
-  displayCompleted() {
-    const completed = this.collectCompleted();
-    const outputs = [];
-    for (const task of completed) {
-      const elapsed = ((Date.now() - task.startedAt) / 1e3).toFixed(1);
-      if (task.error) {
-        process.stdout.write(pc6.yellow(`
-  [${task.id}] ${task.toolName} failed after ${elapsed}s: ${task.error}
-`));
-        outputs.push(`[Background task ${task.toolName} failed: ${task.error}]`);
-      } else {
-        process.stdout.write(pc6.green(`
-  [${task.id}] ${task.toolName} completed in ${elapsed}s
-`));
-        const preview = (task.result || "").slice(0, 200);
-        if (preview) {
-          process.stdout.write(pc6.dim(`  ${preview}${(task.result || "").length > 200 ? "..." : ""}
-`));
-        }
-        outputs.push(`[Background task ${task.toolName} completed: ${task.result}]`);
-      }
-    }
-    return outputs;
-  }
-  /**
-   * Wait for all pending background tasks to complete.
-   */
-  async waitAll() {
-    const pending = [...this.tasks.values()].filter((t) => !t.done);
-    if (pending.length === 0) return;
-    process.stdout.write(pc6.dim(`
-  Waiting for ${pending.length} background task(s)...
-`));
-    await Promise.allSettled(pending.map((t) => t.promise));
-  }
-  /**
-   * Number of currently running tasks.
-   */
-  get pendingCount() {
-    return [...this.tasks.values()].filter((t) => !t.done).length;
-  }
-  /**
-   * Check if any tasks have completed (non-blocking).
-   */
-  get hasCompleted() {
-    return [...this.tasks.values()].some((t) => t.done);
-  }
-};
-
 // src/errors.ts
 var ERROR_MAPPINGS = [
   { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
@@ -7891,9 +7981,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs19 from "fs";
-import path19 from "path";
-import os18 from "os";
+import fs20 from "fs";
+import path20 from "path";
+import os19 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -7931,11 +8021,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path19.join(os18.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path20.join(os19.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs19.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs19.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs20.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs20.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -7944,9 +8034,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path19.dirname(HINTS_FILE);
-    fs19.mkdirSync(dir, { recursive: true });
-    fs19.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path20.dirname(HINTS_FILE);
+    fs20.mkdirSync(dir, { recursive: true });
+    fs20.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -8213,9 +8303,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path20.join(os19.homedir(), ".aman-agent", "exports");
-          fs20.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path20.join(exportDir, `${sessionId}.md`);
+          const exportDir = path21.join(os20.homedir(), ".aman-agent", "exports");
+          fs21.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path21.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -8229,7 +8319,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs20.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs21.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -8355,25 +8445,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path20.join(os19.homedir(), filePath.slice(2));
+        filePath = path21.join(os20.homedir(), filePath.slice(2));
       }
-      if (!fs20.existsSync(filePath) || !fs20.statSync(filePath).isFile()) continue;
-      const ext = path20.extname(filePath).toLowerCase();
+      if (!fs21.existsSync(filePath) || !fs21.statSync(filePath).isFile()) continue;
+      const ext = path21.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs20.statSync(filePath);
+          const stat = fs21.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path20.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path21.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs20.readFileSync(filePath).toString("base64");
+          const data = fs21.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: ${path20.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path21.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -8381,7 +8471,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs20.readFileSync(filePath, "utf-8");
+          const content = fs21.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -8391,7 +8481,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path20.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path21.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -8400,7 +8490,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path20.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path21.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -8409,7 +8499,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path20.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path21.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -8421,7 +8511,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path20.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path21.basename(filePath)}]
 `));
           }
         } else {
@@ -8645,6 +8735,20 @@ ${preemptive.join("\n")}
             }
             if (toolUse.name === "delegate_task" && mcpManager) {
               const input2 = toolUse.input;
+              const confirmed = await new Promise((resolve) => {
+                rl.question(
+                  pc7.cyan(`  Delegate to ${pc7.bold(input2.profile)}? `) + pc7.dim(`"${input2.task.slice(0, 80)}${input2.task.length > 80 ? "..." : ""}" (y/N) `),
+                  (answer) => resolve(answer.toLowerCase() === "y")
+                );
+              });
+              if (!confirmed) {
+                return {
+                  type: "tool_result",
+                  tool_use_id: toolUse.id,
+                  content: "User declined delegation.",
+                  is_error: true
+                };
+              }
               process.stdout.write(pc7.dim(`
   [delegating to ${input2.profile}...]
 
@@ -8661,6 +8765,20 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
             }
             if (toolUse.name === "team_run" && mcpManager) {
               const input2 = toolUse.input;
+              const confirmed = await new Promise((resolve) => {
+                rl.question(
+                  pc7.cyan(`  Run team ${pc7.bold(input2.team)}? `) + pc7.dim(`"${input2.task.slice(0, 80)}${input2.task.length > 80 ? "..." : ""}" (y/N) `),
+                  (answer) => resolve(answer.toLowerCase() === "y")
+                );
+              });
+              if (!confirmed) {
+                return {
+                  type: "tool_result",
+                  tool_use_id: toolUse.id,
+                  content: "User declined team execution.",
+                  is_error: true
+                };
+              }
               const team = loadTeam(input2.team);
               if (!team) {
                 return {
@@ -8785,7 +8903,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs20.existsSync(path20.join(os19.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs21.existsSync(path21.join(os20.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -8831,9 +8949,9 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs21 from "fs";
-import path21 from "path";
-import os20 from "os";
+import fs22 from "fs";
+import path22 from "path";
+import os21 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -8942,9 +9060,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path21.join(os20.homedir(), ".aman-agent", ".reconfig");
-  if (fs21.existsSync(reconfigMarker)) {
-    fs21.unlinkSync(reconfigMarker);
+  const reconfigMarker = path22.join(os21.homedir(), ".aman-agent", ".reconfig");
+  if (fs22.existsSync(reconfigMarker)) {
+    fs22.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -8973,11 +9091,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os20.homedir();
-  const corePath = path21.join(home2, ".acore", "core.md");
-  if (fs21.existsSync(corePath)) return false;
-  fs21.mkdirSync(path21.join(home2, ".acore"), { recursive: true });
-  fs21.writeFileSync(corePath, [
+  const home2 = os21.homedir();
+  const corePath = path22.join(home2, ".acore", "core.md");
+  if (fs22.existsSync(corePath)) return false;
+  fs22.mkdirSync(path22.join(home2, ".acore"), { recursive: true });
+  fs22.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -8989,11 +9107,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path21.join(home2, ".arules");
-  const rulesPath = path21.join(rulesDir, "rules.md");
-  if (!fs21.existsSync(rulesPath)) {
-    fs21.mkdirSync(rulesDir, { recursive: true });
-    fs21.writeFileSync(rulesPath, [
+  const rulesDir = path22.join(home2, ".arules");
+  const rulesPath = path22.join(rulesDir, "rules.md");
+  if (!fs22.existsSync(rulesPath)) {
+    fs22.mkdirSync(rulesDir, { recursive: true });
+    fs22.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -9005,22 +9123,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowDir = path21.join(home2, ".aflow");
-  const flowPath = path21.join(flowDir, "flow.md");
-  if (!fs21.existsSync(flowPath)) {
-    fs21.mkdirSync(flowDir, { recursive: true });
-    fs21.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowDir = path22.join(home2, ".aflow");
+  const flowPath = path22.join(flowDir, "flow.md");
+  if (!fs22.existsSync(flowPath)) {
+    fs22.mkdirSync(flowDir, { recursive: true });
+    fs22.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillDir = path21.join(home2, ".askill");
-  const skillPath = path21.join(skillDir, "skills.md");
-  if (!fs21.existsSync(skillPath)) {
-    fs21.mkdirSync(skillDir, { recursive: true });
-    fs21.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillDir = path22.join(home2, ".askill");
+  const skillPath = path22.join(skillDir, "skills.md");
+  if (!fs22.existsSync(skillPath)) {
+    fs22.mkdirSync(skillDir, { recursive: true });
+    fs22.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.28.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.30.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) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -9372,19 +9490,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 = os20.homedir();
-  fs21.mkdirSync(path21.join(home2, ".acore"), { recursive: true });
-  fs21.writeFileSync(path21.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os21.homedir();
+  fs22.mkdirSync(path22.join(home2, ".acore"), { recursive: true });
+  fs22.writeFileSync(path22.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) {
-    fs21.mkdirSync(path21.join(home2, ".arules"), { recursive: true });
-    fs21.writeFileSync(path21.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs22.mkdirSync(path22.join(home2, ".arules"), { recursive: true });
+    fs22.writeFileSync(path22.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) {
-    fs21.mkdirSync(path21.join(home2, ".aflow"), { recursive: true });
-    fs21.writeFileSync(path21.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs22.mkdirSync(path22.join(home2, ".aflow"), { recursive: true });
+    fs22.writeFileSync(path22.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`);
   }