@aman_asmuei/aman-agent 0.8.0 → 0.17.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { Command } from "commander";
 import * as p2 from "@clack/prompts";
-import pc4 from "picocolors";
+import pc7 from "picocolors";
 
 // src/config.ts
 import fs from "fs";
@@ -15,7 +15,8 @@ var DEFAULT_HOOKS = {
   evalPrompt: true,
   autoSessionSave: true,
   extractMemories: true,
-  featureHints: true
+  featureHints: true,
+  personalityAdapt: true
 };
 var CONFIG_DIR = path.join(os.homedir(), ".aman-agent");
 var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
@@ -96,18 +97,35 @@ function buildBudgetedPrompt(components, maxTokens = 8e3) {
 
 // src/prompt.ts
 var ECOSYSTEM_FILES = [
-  { name: "identity", dir: ".acore", file: "core.md" },
+  { name: "identity", dir: ".acore", file: "core.md", profileOverridable: true },
   { name: "tools", dir: ".akit", file: "kit.md" },
   { name: "workflows", dir: ".aflow", file: "flow.md" },
-  { name: "guardrails", dir: ".arules", file: "rules.md" },
-  { name: "skills", dir: ".askill", file: "skills.md" }
+  { name: "guardrails", dir: ".arules", file: "rules.md", profileOverridable: true },
+  { name: "skills", dir: ".askill", file: "skills.md", profileOverridable: true }
 ];
-function assembleSystemPrompt(maxTokens) {
+function resolveLayerPath(entry, home2, profile) {
+  if (profile && entry.profileOverridable) {
+    const profilePath = path2.join(home2, ".acore", "profiles", profile, entry.file);
+    if (fs2.existsSync(profilePath)) return profilePath;
+    if (entry.name === "guardrails") {
+      const altPath = path2.join(home2, ".acore", "profiles", profile, "rules.md");
+      if (fs2.existsSync(altPath)) return altPath;
+    }
+    if (entry.name === "skills") {
+      const altPath = path2.join(home2, ".acore", "profiles", profile, "skills.md");
+      if (fs2.existsSync(altPath)) return altPath;
+    }
+  }
+  const globalPath = path2.join(home2, entry.dir, entry.file);
+  if (fs2.existsSync(globalPath)) return globalPath;
+  return null;
+}
+function assembleSystemPrompt(maxTokens, profile) {
   const home2 = os2.homedir();
   const components = [];
   for (const entry of ECOSYSTEM_FILES) {
-    const filePath = path2.join(home2, entry.dir, entry.file);
-    if (fs2.existsSync(filePath)) {
+    const filePath = resolveLayerPath(entry, home2, profile);
+    if (filePath) {
       const content = fs2.readFileSync(filePath, "utf-8").trim();
       components.push({
         name: entry.name,
@@ -130,9 +148,43 @@ function assembleSystemPrompt(maxTokens) {
     prompt: budgeted.prompt,
     layers: budgeted.included,
     truncated: budgeted.truncated,
-    totalTokens: budgeted.totalTokens
+    totalTokens: budgeted.totalTokens,
+    profile
   };
 }
+function listProfiles() {
+  const profilesDir = path2.join(os2.homedir(), ".acore", "profiles");
+  if (!fs2.existsSync(profilesDir)) return [];
+  const profiles = [];
+  for (const entry of fs2.readdirSync(profilesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const corePath = path2.join(profilesDir, entry.name, "core.md");
+    if (!fs2.existsSync(corePath)) continue;
+    const content = fs2.readFileSync(corePath, "utf-8");
+    const nameMatch = content.match(/^# (.+)/m);
+    const personalityMatch = content.match(/- Personality:\s*(.+)/);
+    profiles.push({
+      name: entry.name,
+      aiName: nameMatch?.[1]?.trim() || entry.name,
+      personality: personalityMatch?.[1]?.trim() || "default"
+    });
+  }
+  return profiles;
+}
+function getProfileAiName(profile) {
+  const home2 = os2.homedir();
+  let corePath;
+  if (profile) {
+    const profileCorePath = path2.join(home2, ".acore", "profiles", profile, "core.md");
+    corePath = fs2.existsSync(profileCorePath) ? profileCorePath : path2.join(home2, ".acore", "core.md");
+  } else {
+    corePath = path2.join(home2, ".acore", "core.md");
+  }
+  if (!fs2.existsSync(corePath)) return "Assistant";
+  const content = fs2.readFileSync(corePath, "utf-8");
+  const match = content.match(/^# (.+)$/m);
+  return match?.[1]?.trim() || "Assistant";
+}
 
 // src/llm/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -745,20 +797,20 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs7 from "fs";
-import path7 from "path";
-import os7 from "os";
-import pc3 from "picocolors";
+import fs13 from "fs";
+import path13 from "path";
+import os12 from "os";
+import pc6 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs5 from "fs";
-import path5 from "path";
-import os5 from "os";
+import fs9 from "fs";
+import path9 from "path";
+import os9 from "os";
 import { execFileSync } from "child_process";
-import pc from "picocolors";
+import pc3 from "picocolors";
 
 // src/layers/parsers.ts
 import fs4 from "fs";
@@ -817,12 +869,796 @@ function getEcosystemStatus(mcpToolCount, amemConnected) {
   };
 }
 
+// src/memory.ts
+import {
+  createDatabase,
+  recall,
+  buildContext,
+  storeMemory,
+  consolidateMemories,
+  cosineSimilarity,
+  preloadEmbeddings,
+  buildVectorIndex
+} from "@aman_asmuei/amem-core";
+import path5 from "path";
+import os5 from "os";
+import fs5 from "fs";
+var db = null;
+var currentProject = "global";
+async function initMemory(project) {
+  if (db) return db;
+  const amemDir = process.env.AMEM_DIR ?? path5.join(os5.homedir(), ".amem");
+  if (!fs5.existsSync(amemDir)) fs5.mkdirSync(amemDir, { recursive: true });
+  const dbPath = process.env.AMEM_DB ?? path5.join(amemDir, "memory.db");
+  db = createDatabase(dbPath);
+  currentProject = project ?? "global";
+  preloadEmbeddings();
+  setTimeout(() => {
+    try {
+      buildVectorIndex(db);
+    } catch {
+    }
+  }, 1e3);
+  return db;
+}
+function getDb() {
+  if (!db) throw new Error("Memory not initialized \u2014 call initMemory() first");
+  return db;
+}
+async function memoryRecall(query, opts) {
+  return recall(getDb(), {
+    query,
+    limit: opts?.limit ?? 10,
+    compact: opts?.compact ?? true,
+    type: opts?.type,
+    tag: opts?.tag,
+    minConfidence: opts?.minConfidence,
+    explain: opts?.explain,
+    scope: currentProject
+  });
+}
+async function memoryContext(topic, maxTokens) {
+  return buildContext(getDb(), topic, { maxTokens, scope: currentProject });
+}
+async function memoryStore(opts) {
+  return storeMemory(getDb(), opts);
+}
+function memoryLog(sessionId, role, content) {
+  return getDb().appendLog({
+    sessionId,
+    role,
+    content,
+    project: currentProject,
+    metadata: {}
+  });
+}
+function reminderCheck() {
+  return getDb().checkReminders();
+}
+function memoryConsolidate(dryRun = false) {
+  return consolidateMemories(getDb(), cosineSimilarity, {
+    dryRun,
+    maxStaleDays: 90,
+    minConfidence: 0.3,
+    minAccessCount: 0
+  });
+}
+
+// src/profile-templates.ts
+import fs6 from "fs";
+import path6 from "path";
+import os6 from "os";
+var BUILT_IN_PROFILES = [
+  {
+    name: "coder",
+    label: "Coder",
+    description: "Direct, technical, code-first. Skips pleasantries, shows code.",
+    core: `# Coder
+
+## Identity
+- Role: Coder is your technical pair programmer
+- Personality: direct, precise, efficient \u2014 code speaks louder than words
+- Communication: lead with code, explain after. No fluff.
+- Values: simplicity over cleverness, working code over perfect code, tests over trust
+- Boundaries: won't pretend to be human, flags when out of depth
+
+### Appearance
+- Base: focused developer, dark hoodie, terminal glow
+- Style: minimal
+- Palette: green on black`,
+    rules: `# Coder Rules
+
+## Always
+- Show code before explaining
+- Include error handling
+- Suggest tests for new code
+
+## Never
+- Write code without understanding the requirement
+- Push to main without tests
+- Ignore security implications`
+  },
+  {
+    name: "writer",
+    label: "Writer",
+    description: "Creative, eloquent, story-driven. Focuses on narrative and engagement.",
+    core: `# Muse
+
+## Identity
+- Role: Muse is your creative writing partner
+- Personality: eloquent, imaginative, encouraging \u2014 finds the story in everything
+- Communication: explore ideas together, offer alternatives, celebrate good writing
+- Values: authenticity over formulas, voice over grammar, emotion over information
+- Boundaries: won't write without understanding the audience, flags when content is sensitive
+
+### Appearance
+- Base: warm expression, creative energy, pen in hand
+- Style: illustrated
+- Palette: warm amber and cream`,
+    rules: `# Writer Rules
+
+## Always
+- Ask about the target audience
+- Offer 2-3 angle options before drafting
+- Read drafts aloud mentally for rhythm
+
+## Never
+- Use cliches without subverting them
+- Write without a clear hook
+- Ignore tone consistency`
+  },
+  {
+    name: "researcher",
+    label: "Researcher",
+    description: "Analytical, thorough, citation-focused. Digs deep, verifies claims.",
+    core: `# Scholar
+
+## Identity
+- Role: Scholar is your research analyst
+- Personality: analytical, thorough, intellectually curious \u2014 never takes claims at face value
+- Communication: present findings with evidence, flag uncertainty, compare perspectives
+- Values: accuracy over speed, nuance over simplification, primary sources over summaries
+- Boundaries: clearly marks speculation vs fact, flags when evidence is insufficient
+
+### Appearance
+- Base: thoughtful expression, glasses, surrounded by notes
+- Style: minimal
+- Palette: navy and white`,
+    rules: `# Researcher Rules
+
+## Always
+- Cite sources when making factual claims
+- Flag confidence level (high/medium/low)
+- Present multiple perspectives on contested topics
+
+## Never
+- Present speculation as fact
+- Ignore contradicting evidence
+- Oversimplify complex topics`
+  }
+];
+function installProfileTemplate(templateName, userName) {
+  const template = BUILT_IN_PROFILES.find((t) => t.name === templateName);
+  if (!template) return null;
+  const profileDir = path6.join(os6.homedir(), ".acore", "profiles", template.name);
+  if (fs6.existsSync(profileDir)) return `Profile already exists: ${template.name}`;
+  fs6.mkdirSync(profileDir, { recursive: true });
+  let core = template.core;
+  if (userName) {
+    core += `
+
+---
+
+## Relationship
+- Name: ${userName}
+- Nicknames: []
+- Communication: [updated over time]
+- Detail level: balanced
+`;
+  }
+  fs6.writeFileSync(path6.join(profileDir, "core.md"), core, "utf-8");
+  if (template.rules) {
+    fs6.writeFileSync(path6.join(profileDir, "rules.md"), template.rules, "utf-8");
+  }
+  if (template.skills) {
+    fs6.writeFileSync(path6.join(profileDir, "skills.md"), template.skills, "utf-8");
+  }
+  return null;
+}
+
+// src/delegate.ts
+import pc from "picocolors";
+var isRetryable = (err) => {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("rate") || msg.includes("timeout") || msg.includes("econnreset");
+  }
+  return false;
+};
+async function delegateTask(task, profile, client, mcpManager, options = {}) {
+  const maxTurns = options.maxTurns ?? 10;
+  const silent = options.silent ?? false;
+  const tools = options.tools;
+  try {
+    const { prompt: systemPrompt } = assembleSystemPrompt(void 0, profile);
+    const delegationPrompt = `${systemPrompt}
+
+<delegation>
+You are being delegated a specific task by the primary agent. Complete this task thoroughly and return your result. You have access to tools if needed. Focus on the task \u2014 do not ask follow-up questions, just do your best with what you have.
+</delegation>`;
+    const messages = [
+      { role: "user", content: task }
+    ];
+    const toolsUsed = [];
+    let turns = 0;
+    const onChunk = silent ? () => {
+    } : (chunk) => {
+      if (chunk.type === "text" && chunk.text) {
+        process.stdout.write(chunk.text);
+      }
+    };
+    let response = await withRetry(
+      () => client.chat(delegationPrompt, messages, onChunk, tools),
+      { maxAttempts: 2, baseDelay: 1e3, retryable: isRetryable }
+    );
+    messages.push(response.message);
+    while (response.toolUses.length > 0 && turns < maxTurns) {
+      turns++;
+      const toolResults = await Promise.all(
+        response.toolUses.map(async (toolUse) => {
+          if (!silent) {
+            process.stdout.write(pc.dim(`  [${profile}:${toolUse.name}...]
+`));
+          }
+          toolsUsed.push(toolUse.name);
+          try {
+            const result = await mcpManager.callTool(toolUse.name, toolUse.input);
+            return {
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: result
+            };
+          } catch (err) {
+            return {
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: `Error: ${err instanceof Error ? err.message : String(err)}`,
+              is_error: true
+            };
+          }
+        })
+      );
+      messages.push({ role: "user", content: toolResults });
+      response = await withRetry(
+        () => client.chat(delegationPrompt, messages, onChunk, tools),
+        { maxAttempts: 2, baseDelay: 1e3, retryable: isRetryable }
+      );
+      messages.push(response.message);
+    }
+    const finalMessage = response.message;
+    const responseText = typeof finalMessage.content === "string" ? finalMessage.content : finalMessage.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
+    return {
+      profile,
+      task,
+      response: responseText,
+      toolsUsed: [...new Set(toolsUsed)],
+      turns,
+      success: true
+    };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    log.warn("delegate", `Delegation to ${profile} failed: ${error}`);
+    return {
+      profile,
+      task,
+      response: "",
+      toolsUsed: [],
+      turns: 0,
+      success: false,
+      error
+    };
+  }
+}
+async function delegateParallel(tasks, client, mcpManager, options = {}) {
+  return Promise.all(
+    tasks.map(
+      ({ task, profile }) => delegateTask(task, profile, client, mcpManager, { ...options, silent: true })
+    )
+  );
+}
+async function delegatePipeline(steps, initialInput, client, mcpManager, options = {}) {
+  const results = [];
+  let previousResult = initialInput;
+  for (const step of steps) {
+    const task = step.taskTemplate.replace("{{input}}", previousResult);
+    if (!options.silent) {
+      process.stdout.write(pc.dim(`
+  [delegating to ${step.profile}...]
+`));
+    }
+    const result = await delegateTask(task, step.profile, client, mcpManager, {
+      ...options,
+      silent: true
+    });
+    results.push(result);
+    if (!result.success) break;
+    previousResult = result.response;
+  }
+  return results;
+}
+
+// src/teams.ts
+import fs7 from "fs";
+import path7 from "path";
+import os7 from "os";
+import pc2 from "picocolors";
+function getTeamsDir() {
+  return path7.join(os7.homedir(), ".acore", "teams");
+}
+function ensureTeamsDir() {
+  const dir = getTeamsDir();
+  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function teamPath(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return path7.join(ensureTeamsDir(), `${slug}.json`);
+}
+function createTeam(team) {
+  const fp = teamPath(team.name);
+  fs7.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+}
+function loadTeam(name) {
+  const fp = teamPath(name);
+  if (!fs7.existsSync(fp)) return null;
+  try {
+    return JSON.parse(fs7.readFileSync(fp, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listTeams() {
+  const dir = getTeamsDir();
+  if (!fs7.existsSync(dir)) return [];
+  const teams = [];
+  for (const file of fs7.readdirSync(dir)) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const content = fs7.readFileSync(path7.join(dir, file), "utf-8");
+      teams.push(JSON.parse(content));
+    } catch {
+    }
+  }
+  return teams;
+}
+function deleteTeam(name) {
+  const fp = teamPath(name);
+  if (!fs7.existsSync(fp)) return false;
+  fs7.unlinkSync(fp);
+  return true;
+}
+async function runTeam(team, task, client, mcpManager, tools) {
+  process.stdout.write(pc2.dim(`
+  Team: ${team.name} (${team.workflow} mode)
+`));
+  process.stdout.write(pc2.dim(`  Members: ${team.members.map((m) => m.profile).join(", ")}
+
+`));
+  switch (team.workflow) {
+    case "pipeline":
+      return runPipeline(team, task, client, mcpManager, tools);
+    case "parallel":
+      return runParallel(team, task, client, mcpManager, tools);
+    case "coordinator":
+      return runCoordinator(team, task, client, mcpManager, tools);
+    default:
+      return {
+        team: team.name,
+        task,
+        workflow: team.workflow,
+        results: [],
+        finalOutput: `Unknown workflow mode: ${team.workflow}`,
+        success: false
+      };
+  }
+}
+async function runPipeline(team, task, client, mcpManager, tools) {
+  const steps = team.members.map((m, i) => ({
+    profile: m.profile,
+    taskTemplate: i === 0 ? `${task}
+
+Your role: ${m.role}` : `${m.role}. Here is the previous agent's work:
+
+{{input}}`
+  }));
+  for (const step of steps) {
+    process.stdout.write(pc2.dim(`  [${step.profile}: ${team.members.find((m) => m.profile === step.profile)?.role}...]
+`));
+  }
+  const results = await delegatePipeline(steps, task, client, mcpManager, {
+    tools,
+    silent: true
+  });
+  const lastResult = results[results.length - 1];
+  const success = results.every((r) => r.success);
+  return {
+    team: team.name,
+    task,
+    workflow: "pipeline",
+    results,
+    finalOutput: lastResult?.response || "",
+    success
+  };
+}
+async function runParallel(team, task, client, mcpManager, tools) {
+  const tasks = team.members.map((m) => ({
+    profile: m.profile,
+    task: `${task}
+
+Your specific role: ${m.role}. Focus only on your role.`
+  }));
+  for (const m of team.members) {
+    process.stdout.write(pc2.dim(`  [${m.profile}: ${m.role} (parallel)...]
+`));
+  }
+  const results = await delegateParallel(tasks, client, mcpManager, { tools });
+  const mergeInput = results.filter((r) => r.success).map((r) => `[${r.profile} \u2014 ${team.members.find((m) => m.profile === r.profile)?.role}]:
+${r.response}`).join("\n\n---\n\n");
+  process.stdout.write(pc2.dim(`  [merging results...]
+`));
+  const mergeResult = await delegateTask(
+    `You are the team coordinator. Multiple agents worked on this task in parallel. Merge their outputs into a single cohesive result. Keep the best parts from each.
+
+Original task: ${task}
+
+${mergeInput}`,
+    team.coordinator === "default" ? team.members[0]?.profile || "default" : team.coordinator,
+    client,
+    mcpManager,
+    { tools, silent: true }
+  );
+  return {
+    team: team.name,
+    task,
+    workflow: "parallel",
+    results: [...results, mergeResult],
+    finalOutput: mergeResult.response,
+    success: results.some((r) => r.success)
+  };
+}
+async function runCoordinator(team, task, client, mcpManager, tools) {
+  const memberDescriptions = team.members.map((m) => `- ${m.profile}: ${m.role}`).join("\n");
+  process.stdout.write(pc2.dim(`  [coordinator planning...]
+`));
+  const planResult = await delegateTask(
+    `You are the coordinator of a team. Your job is to break down this task and decide which team members should handle each part.
+
+Team members:
+${memberDescriptions}
+
+Task: ${task}
+
+Respond with a JSON array of assignments:
+[{"profile": "member-name", "subtask": "what they should do"}]
+
+Only use the JSON array, no other text.`,
+    team.coordinator === "default" ? team.members[0]?.profile || "default" : team.coordinator,
+    client,
+    mcpManager,
+    { tools: void 0, silent: true, maxTurns: 0 }
+  );
+  if (!planResult.success) {
+    return {
+      team: team.name,
+      task,
+      workflow: "coordinator",
+      results: [planResult],
+      finalOutput: `Coordinator failed to plan: ${planResult.error}`,
+      success: false
+    };
+  }
+  let assignments;
+  try {
+    let cleaned = planResult.response.trim();
+    const codeBlockMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) cleaned = codeBlockMatch[1].trim();
+    assignments = JSON.parse(cleaned);
+  } catch {
+    assignments = team.members.map((m) => ({ profile: m.profile, subtask: `${m.role}: ${task}` }));
+  }
+  for (const a of assignments) {
+    process.stdout.write(pc2.dim(`  [${a.profile}: ${a.subtask.slice(0, 60)}...]
+`));
+  }
+  const results = await delegateParallel(
+    assignments.map((a) => ({ profile: a.profile, task: a.subtask })),
+    client,
+    mcpManager,
+    { tools }
+  );
+  const mergeInput = results.filter((r) => r.success).map((r, i) => `[${assignments[i]?.profile} \u2014 ${assignments[i]?.subtask}]:
+${r.response}`).join("\n\n---\n\n");
+  process.stdout.write(pc2.dim(`  [coordinator merging...]
+`));
+  const mergeResult = await delegateTask(
+    `You are the team coordinator. Your team members completed their assigned work. Combine their outputs into a single cohesive, polished result.
+
+Original task: ${task}
+
+${mergeInput}`,
+    team.coordinator === "default" ? team.members[0]?.profile || "default" : team.coordinator,
+    client,
+    mcpManager,
+    { tools, silent: true }
+  );
+  return {
+    team: team.name,
+    task,
+    workflow: "coordinator",
+    results: [...results, mergeResult],
+    finalOutput: mergeResult.response,
+    success: results.some((r) => r.success)
+  };
+}
+function formatTeam(team) {
+  const lines = [];
+  lines.push(`Team: ${pc2.bold(team.name)}`);
+  lines.push(`Goal: ${team.goal}`);
+  lines.push(`Mode: ${team.workflow}`);
+  lines.push(`Coordinator: ${team.coordinator}`);
+  lines.push("");
+  lines.push("Members:");
+  for (const m of team.members) {
+    lines.push(`  ${pc2.bold(m.profile)} \u2014 ${m.role}`);
+  }
+  return lines.join("\n");
+}
+function formatTeamResult(result) {
+  const lines = [];
+  lines.push(`
+${pc2.bold(`Team: ${result.team}`)} (${result.workflow})`);
+  for (const r of result.results) {
+    const status = r.success ? pc2.green("\u2713") : pc2.red("\u2717");
+    const tools = r.toolsUsed.length > 0 ? pc2.dim(` (${r.toolsUsed.join(", ")})`) : "";
+    lines.push(`  ${status} ${pc2.bold(r.profile)}${tools}`);
+  }
+  lines.push("");
+  lines.push(result.finalOutput);
+  return lines.join("\n");
+}
+var BUILT_IN_TEAMS = [
+  {
+    name: "content-team",
+    goal: "Create and publish high-quality content",
+    coordinator: "default",
+    members: [
+      { profile: "writer", role: "Draft compelling content with engaging narrative" },
+      { profile: "researcher", role: "Fact-check claims and add citations" }
+    ],
+    workflow: "pipeline"
+  },
+  {
+    name: "dev-team",
+    goal: "Build and review code with quality assurance",
+    coordinator: "default",
+    members: [
+      { profile: "coder", role: "Write clean, tested implementation code" },
+      { profile: "researcher", role: "Review for security, performance, and best practices" }
+    ],
+    workflow: "pipeline"
+  },
+  {
+    name: "research-team",
+    goal: "Deep research with multiple perspectives",
+    coordinator: "default",
+    members: [
+      { profile: "researcher", role: "Research the topic thoroughly with citations" },
+      { profile: "writer", role: "Synthesize findings into clear, readable format" }
+    ],
+    workflow: "pipeline"
+  }
+];
+
+// src/plans.ts
+import fs8 from "fs";
+import path8 from "path";
+import os8 from "os";
+function getPlansDir() {
+  const localDir = path8.join(process.cwd(), ".acore", "plans");
+  const localAcore = path8.join(process.cwd(), ".acore");
+  if (fs8.existsSync(localAcore)) return localDir;
+  return path8.join(os8.homedir(), ".acore", "plans");
+}
+function ensurePlansDir() {
+  const dir = getPlansDir();
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function planPath(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return path8.join(ensurePlansDir(), `${slug}.md`);
+}
+function serializePlan(plan) {
+  const lines = [];
+  lines.push(`# ${plan.name}`);
+  lines.push("");
+  lines.push(`**Goal:** ${plan.goal}`);
+  lines.push(`**Created:** ${plan.createdAt}`);
+  lines.push(`**Updated:** ${plan.updatedAt}`);
+  lines.push(`**Active:** ${plan.active}`);
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  for (const step of plan.steps) {
+    lines.push(`- [${step.done ? "x" : " "}] ${step.text}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function parsePlan(content, filePath) {
+  try {
+    const nameMatch = content.match(/^# (.+)/m);
+    const goalMatch = content.match(/\*\*Goal:\*\*\s*(.+)/);
+    const createdMatch = content.match(/\*\*Created:\*\*\s*(.+)/);
+    const updatedMatch = content.match(/\*\*Updated:\*\*\s*(.+)/);
+    const activeMatch = content.match(/\*\*Active:\*\*\s*(.+)/);
+    const name = nameMatch?.[1]?.trim() || path8.basename(filePath, ".md");
+    const goal = goalMatch?.[1]?.trim() || "";
+    const createdAt = createdMatch?.[1]?.trim() || "";
+    const updatedAt = updatedMatch?.[1]?.trim() || "";
+    const active = activeMatch?.[1]?.trim() === "true";
+    const steps = [];
+    const stepMatches = content.matchAll(/- \[([ x])\] (.+)/g);
+    for (const match of stepMatches) {
+      steps.push({
+        done: match[1] === "x",
+        text: match[2].trim()
+      });
+    }
+    return { name, goal, steps, createdAt, updatedAt, active };
+  } catch (err) {
+    log.debug("plans", "Failed to parse plan: " + filePath, err);
+    return null;
+  }
+}
+function createPlan(name, goal, steps) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const plan = {
+    name,
+    goal,
+    steps: steps.map((text2) => ({ text: text2, done: false })),
+    createdAt: now,
+    updatedAt: now,
+    active: true
+  };
+  const existing = listPlans();
+  for (const p3 of existing) {
+    if (p3.active) {
+      p3.active = false;
+      p3.updatedAt = now;
+      savePlan(p3);
+    }
+  }
+  savePlan(plan);
+  return plan;
+}
+function savePlan(plan) {
+  const fp = planPath(plan.name);
+  fs8.writeFileSync(fp, serializePlan(plan), "utf-8");
+}
+function loadPlan(name) {
+  const fp = planPath(name);
+  if (!fs8.existsSync(fp)) return null;
+  const content = fs8.readFileSync(fp, "utf-8");
+  return parsePlan(content, fp);
+}
+function listPlans() {
+  const dir = getPlansDir();
+  if (!fs8.existsSync(dir)) return [];
+  const plans = [];
+  for (const file of fs8.readdirSync(dir)) {
+    if (!file.endsWith(".md")) continue;
+    const fp = path8.join(dir, file);
+    const content = fs8.readFileSync(fp, "utf-8");
+    const plan = parsePlan(content, fp);
+    if (plan) plans.push(plan);
+  }
+  return plans;
+}
+function getActivePlan() {
+  const plans = listPlans();
+  return plans.find((p3) => p3.active) || null;
+}
+function markStepDone(plan, stepIndex) {
+  if (stepIndex < 0 || stepIndex >= plan.steps.length) return false;
+  plan.steps[stepIndex].done = true;
+  plan.updatedAt = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  savePlan(plan);
+  return true;
+}
+function markStepUndone(plan, stepIndex) {
+  if (stepIndex < 0 || stepIndex >= plan.steps.length) return false;
+  plan.steps[stepIndex].done = false;
+  plan.updatedAt = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  savePlan(plan);
+  return true;
+}
+function setActivePlan(name) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const plans = listPlans();
+  for (const p3 of plans) {
+    if (p3.active) {
+      p3.active = false;
+      p3.updatedAt = now;
+      savePlan(p3);
+    }
+  }
+  const target = loadPlan(name);
+  if (!target) return null;
+  target.active = true;
+  target.updatedAt = now;
+  savePlan(target);
+  return target;
+}
+function formatPlan(plan) {
+  const total = plan.steps.length;
+  const done = plan.steps.filter((s) => s.done).length;
+  const pct = total > 0 ? Math.round(done / total * 100) : 0;
+  const bar = progressBar(pct);
+  const lines = [];
+  lines.push(`Plan: ${plan.name} ${plan.active ? "(active)" : "(inactive)"}`);
+  lines.push(`Goal: ${plan.goal}`);
+  lines.push(`Progress: ${bar} ${done}/${total} (${pct}%)`);
+  lines.push("");
+  for (let i = 0; i < plan.steps.length; i++) {
+    const step = plan.steps[i];
+    const marker = step.done ? "\u2713" : " ";
+    const num = String(i + 1).padStart(2, " ");
+    lines.push(`  ${num}. [${marker}] ${step.text}`);
+  }
+  if (done === total && total > 0) {
+    lines.push("\n  All steps complete!");
+  } else {
+    const next = plan.steps.findIndex((s) => !s.done);
+    if (next >= 0) {
+      lines.push(`
+  Next: Step ${next + 1} \u2014 ${plan.steps[next].text}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatPlanForPrompt(plan) {
+  const total = plan.steps.length;
+  const done = plan.steps.filter((s) => s.done).length;
+  const lines = [];
+  lines.push(`<active-plan name="${plan.name}" progress="${done}/${total}">`);
+  lines.push(`Goal: ${plan.goal}`);
+  lines.push("");
+  for (let i = 0; i < plan.steps.length; i++) {
+    const step = plan.steps[i];
+    lines.push(`- [${step.done ? "x" : " "}] Step ${i + 1}: ${step.text}`);
+  }
+  const next = plan.steps.findIndex((s) => !s.done);
+  if (next >= 0) {
+    lines.push("");
+    lines.push(`Current focus: Step ${next + 1} \u2014 ${plan.steps[next].text}`);
+    lines.push("After completing the current step, remind the user to mark it done with /plan done and suggest committing their work.");
+  }
+  lines.push("</active-plan>");
+  return lines.join("\n");
+}
+function progressBar(pct) {
+  const filled = Math.round(pct / 5);
+  const empty = 20 - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+
 // src/commands.ts
 function readEcosystemFile(filePath, label) {
-  if (!fs5.existsSync(filePath)) {
-    return pc.dim(`No ${label} file found at ${filePath}`);
+  if (!fs9.existsSync(filePath)) {
+    return pc3.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs5.readFileSync(filePath, "utf-8").trim();
+  return fs9.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -834,25 +1670,25 @@ function parseCommand(input) {
 }
 async function mcpWrite(ctx, layer, tool, args) {
   if (!ctx.mcpManager) {
-    return pc.red(`Cannot modify ${layer}: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp`);
+    return pc3.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 pc.red(result);
+    return pc3.red(result);
   }
-  return pc.green(result);
+  return pc3.green(result);
 }
 async function handleIdentityCommand(action, args, ctx) {
-  const home2 = os5.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path5.join(home2, ".acore", "core.md"), "identity (acore)");
+    const content = readEcosystemFile(path9.join(home2, ".acore", "core.md"), "identity (acore)");
     return { handled: true, output: content };
   }
   if (action === "update") {
     if (args.length === 0) {
       return {
         handled: true,
-        output: pc.yellow("Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via MCP.")
+        output: pc3.yellow("Usage: /identity update <section>\nTip: describe changes in natural language and the AI will update via MCP.")
       };
     }
     const section = args[0];
@@ -860,23 +1696,23 @@ async function handleIdentityCommand(action, args, ctx) {
     if (!content) {
       return {
         handled: true,
-        output: pc.yellow("Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct.")
+        output: pc3.yellow("Usage: /identity update <section> <new content...>\nExample: /identity update Personality Warm, curious, and direct.")
       };
     }
     const output = await mcpWrite(ctx, "identity", "identity_update_section", { section, content });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /identity ${action}. Use /identity or /identity update <section>.`) };
 }
 async function handleRulesCommand(action, args, ctx) {
-  const home2 = os5.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path5.join(home2, ".arules", "rules.md"), "guardrails (arules)");
+    const content = readEcosystemFile(path9.join(home2, ".arules", "rules.md"), "guardrails (arules)");
     return { handled: true, output: content };
   }
   if (action === "add") {
     if (args.length < 2) {
-      return { handled: true, output: pc.yellow("Usage: /rules add <category> <rule text...>") };
+      return { handled: true, output: pc3.yellow("Usage: /rules add <category> <rule text...>") };
     }
     const category = args[0];
     const rule = args.slice(1).join(" ");
@@ -885,41 +1721,41 @@ async function handleRulesCommand(action, args, ctx) {
   }
   if (action === "remove") {
     if (args.length < 2) {
-      return { handled: true, output: pc.yellow("Usage: /rules remove <category> <index>") };
+      return { handled: true, output: pc3.yellow("Usage: /rules remove <category> <index>") };
     }
     const output = await mcpWrite(ctx, "rules", "rules_remove", { category: args[0], index: parseInt(args[1], 10) });
     return { handled: true, output };
   }
   if (action === "toggle") {
     if (args.length < 2) {
-      return { handled: true, output: pc.yellow("Usage: /rules toggle <category> <index>") };
+      return { handled: true, output: pc3.yellow("Usage: /rules toggle <category> <index>") };
     }
     const output = await mcpWrite(ctx, "rules", "rules_toggle", { category: args[0], index: parseInt(args[1], 10) });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /rules ${action}. Use /rules [add|remove|toggle].`) };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os5.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path5.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path9.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /workflows add <name>") };
+      return { handled: true, output: pc3.yellow("Usage: /workflows add <name>") };
     }
     const output = await mcpWrite(ctx, "workflows", "workflow_add", { name: args.join(" ") });
     return { handled: true, output };
   }
   if (action === "remove") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /workflows remove <name>") };
+      return { handled: true, output: pc3.yellow("Usage: /workflows remove <name>") };
     }
     const output = await mcpWrite(ctx, "workflows", "workflow_remove", { name: args.join(" ") });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /workflows ${action}. Use /workflows [add|remove].`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /workflows ${action}. Use /workflows [add|remove].`) };
 }
 var AKIT_REGISTRY = [
   { name: "web-search", description: "Search the web for current information", category: "search", mcp: { package: "@anthropic/web-search", command: "npx", args: ["-y", "@anthropic/web-search"] } },
@@ -936,42 +1772,43 @@ var AKIT_REGISTRY = [
   { name: "docker", description: "Manage Docker containers", category: "automation", mcp: { package: "@modelcontextprotocol/server-docker", command: "npx", args: ["-y", "@modelcontextprotocol/server-docker"] } },
   { name: "slack", description: "Send and read Slack messages", category: "communication", mcp: { package: "@modelcontextprotocol/server-slack", command: "npx", args: ["-y", "@modelcontextprotocol/server-slack"], env: { SLACK_BOT_TOKEN: "" } }, envHint: "Set SLACK_BOT_TOKEN from your Slack app settings" },
   { name: "notion", description: "Read and write Notion pages", category: "communication", mcp: { package: "@notionhq/notion-mcp-server", command: "npx", args: ["-y", "@notionhq/notion-mcp-server"], env: { NOTION_API_KEY: "" } }, envHint: "Set NOTION_API_KEY from https://notion.so/my-integrations" },
+  { name: "social", description: "Post to Bluesky, X/Twitter, Threads", category: "communication", mcp: { package: "@aman_asmuei/aman-social", command: "npx", args: ["-y", "@aman_asmuei/aman-social"] }, envHint: "Set BLUESKY_HANDLE + BLUESKY_APP_PASSWORD, TWITTER_API_KEY + secrets, or THREADS_ACCESS_TOKEN" },
   { name: "memory", description: "Persistent AI memory via amem", category: "memory", mcp: { package: "@aman_asmuei/amem", command: "npx", args: ["-y", "@aman_asmuei/amem"] } },
   { name: "docling", description: "Convert PDF, DOCX, PPTX, XLSX to markdown", category: "documents", mcp: { package: "docling-mcp", command: "uvx", args: ["docling-mcp"] }, envHint: "Requires Python 3.10+. Install: pip install docling" }
 ];
 function loadAkitInstalled() {
-  const filePath = path5.join(os5.homedir(), ".akit", "installed.json");
-  if (!fs5.existsSync(filePath)) return [];
+  const filePath = path9.join(os9.homedir(), ".akit", "installed.json");
+  if (!fs9.existsSync(filePath)) return [];
   try {
-    return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function saveAkitInstalled(tools) {
-  const dir = path5.join(os5.homedir(), ".akit");
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(path5.join(dir, "installed.json"), JSON.stringify(tools, null, 2) + "\n", "utf-8");
+  const dir = path9.join(os9.homedir(), ".akit");
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(path9.join(dir, "installed.json"), JSON.stringify(tools, null, 2) + "\n", "utf-8");
 }
 function addToAmanAgentConfig(name, mcpConfig) {
-  const configPath = path5.join(os5.homedir(), ".aman-agent", "config.json");
-  if (!fs5.existsSync(configPath)) return;
+  const configPath = path9.join(os9.homedir(), ".aman-agent", "config.json");
+  if (!fs9.existsSync(configPath)) return;
   try {
-    const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
     if (!config.mcpServers) config.mcpServers = {};
     config.mcpServers[name] = mcpConfig;
-    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 function removeFromAmanAgentConfig(name) {
-  const configPath = path5.join(os5.homedir(), ".aman-agent", "config.json");
-  if (!fs5.existsSync(configPath)) return;
+  const configPath = path9.join(os9.homedir(), ".aman-agent", "config.json");
+  if (!fs9.existsSync(configPath)) return;
   try {
-    const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
     if (config.mcpServers) {
       delete config.mcpServers[name];
-      fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      fs9.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   } catch {
   }
@@ -983,27 +1820,27 @@ function handleAkitCommand(action, args) {
     const available2 = AKIT_REGISTRY.filter((t) => !installedNames.has(t.name));
     if (args.length < 1) {
       if (available2.length === 0) {
-        return { handled: true, output: pc.green("All tools are installed!") };
+        return { handled: true, output: pc3.green("All tools are installed!") };
       }
-      const lines3 = [pc.bold("Select a tool to install:"), ""];
+      const lines3 = [pc3.bold("Select a tool to install:"), ""];
       available2.forEach((tool2, i) => {
-        const num2 = pc.cyan(String(i + 1).padStart(2));
-        lines3.push(`  ${num2}  ${tool2.name.padEnd(16)} ${pc.dim(tool2.description)}`);
+        const num2 = pc3.cyan(String(i + 1).padStart(2));
+        lines3.push(`  ${num2}  ${tool2.name.padEnd(16)} ${pc3.dim(tool2.description)}`);
       });
       lines3.push("");
-      lines3.push(`  Type: ${pc.cyan("/akit add <number>")} or ${pc.cyan("/akit add <name>")}`);
-      lines3.push(`  Custom: ${pc.cyan("/akit add custom <name> <command> <args...>")}`);
+      lines3.push(`  Type: ${pc3.cyan("/akit add <number>")} or ${pc3.cyan("/akit add <name>")}`);
+      lines3.push(`  Custom: ${pc3.cyan("/akit add custom <name> <command> <args...>")}`);
       return { handled: true, output: lines3.join("\n") };
     }
     if (args[0].toLowerCase() === "custom") {
       if (args.length < 3) {
-        return { handled: true, output: pc.yellow("Usage: /akit add custom <name> <command> <args...>\nExample: /akit add custom my-tool npx -y @org/my-mcp-server") };
+        return { handled: true, output: pc3.yellow("Usage: /akit add custom <name> <command> <args...>\nExample: /akit add custom my-tool npx -y @org/my-mcp-server") };
       }
       const customName = args[1];
       const customCommand = args[2];
       const customArgs = args.slice(3);
       if (installedNames.has(customName)) {
-        return { handled: true, output: pc.yellow(`${customName} is already installed.`) };
+        return { handled: true, output: pc3.yellow(`${customName} is already installed.`) };
       }
       installed.push({
         name: customName,
@@ -1015,8 +1852,8 @@ function handleAkitCommand(action, args) {
       return {
         handled: true,
         output: [
-          pc.green(`\u2713 Added ${pc.bold(customName)}`) + pc.dim(` (custom MCP: ${customCommand} ${customArgs.join(" ")})`),
-          pc.dim("  Restart aman-agent to load the new tool.")
+          pc3.green(`\u2713 Added ${pc3.bold(customName)}`) + pc3.dim(` (custom MCP: ${customCommand} ${customArgs.join(" ")})`),
+          pc3.dim("  Restart aman-agent to load the new tool.")
         ].join("\n")
       };
     }
@@ -1032,13 +1869,13 @@ function handleAkitCommand(action, args) {
       return {
         handled: true,
         output: [
-          pc.red(`Tool "${input}" not found.`),
-          `Type ${pc.cyan("/akit add")} to see available tools.`
+          pc3.red(`Tool "${input}" not found.`),
+          `Type ${pc3.cyan("/akit add")} to see available tools.`
         ].join("\n")
       };
     }
     if (installedNames.has(tool.name)) {
-      return { handled: true, output: pc.yellow(`${tool.name} is already installed.`) };
+      return { handled: true, output: pc3.yellow(`${tool.name} is already installed.`) };
     }
     installed.push({
       name: tool.name,
@@ -1053,255 +1890,253 @@ function handleAkitCommand(action, args) {
       });
     }
     const lines2 = [
-      pc.green(`\u2713 Added ${pc.bold(tool.name)}`) + (tool.mcp ? pc.dim(` (MCP: ${tool.mcp.package})`) : "")
+      pc3.green(`\u2713 Added ${pc3.bold(tool.name)}`) + (tool.mcp ? pc3.dim(` (MCP: ${tool.mcp.package})`) : "")
     ];
     if (tool.envHint) {
-      lines2.push(pc.yellow(`  \u26A0 ${tool.envHint}`));
+      lines2.push(pc3.yellow(`  \u26A0 ${tool.envHint}`));
     }
     if (tool.mcp) {
-      lines2.push(pc.dim("  Restart aman-agent to load the new tool."));
+      lines2.push(pc3.dim("  Restart aman-agent to load the new tool."));
     }
     return { handled: true, output: lines2.join("\n") };
   }
   if (action === "remove") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /akit remove <tool>") };
+      return { handled: true, output: pc3.yellow("Usage: /akit remove <tool>") };
     }
     const toolName = args[0].toLowerCase();
     if (!installedNames.has(toolName)) {
-      return { handled: true, output: pc.red(`${toolName} is not installed.`) };
+      return { handled: true, output: pc3.red(`${toolName} is not installed.`) };
     }
     const updated = installed.filter((t) => t.name !== toolName);
     saveAkitInstalled(updated);
     removeFromAmanAgentConfig(toolName);
     return {
       handled: true,
-      output: pc.green(`\u2713 Removed ${pc.bold(toolName)}`) + pc.dim("  (restart aman-agent to apply)")
+      output: pc3.green(`\u2713 Removed ${pc3.bold(toolName)}`) + pc3.dim("  (restart aman-agent to apply)")
     };
   }
   if (action === "help") {
     return {
       handled: true,
       output: [
-        pc.bold("akit \u2014 Tool Management"),
+        pc3.bold("akit \u2014 Tool Management"),
         "",
-        `  ${pc.cyan("/akit")}               List installed & available tools`,
-        `  ${pc.cyan("/akit add <tool>")}     Install a tool`,
-        `  ${pc.cyan("/akit remove <tool>")}  Uninstall a tool`
+        `  ${pc3.cyan("/akit")}               List installed & available tools`,
+        `  ${pc3.cyan("/akit add <tool>")}     Install a tool`,
+        `  ${pc3.cyan("/akit remove <tool>")}  Uninstall a tool`
       ].join("\n")
     };
   }
   const available = AKIT_REGISTRY.filter((t) => !installedNames.has(t.name));
-  const lines = [pc.bold("akit \u2014 AI Tool Manager"), ""];
+  const lines = [pc3.bold("akit \u2014 AI Tool Manager"), ""];
   if (installed.length > 0) {
-    lines.push(`  ${pc.bold(`Installed (${installed.length})`)}`);
+    lines.push(`  ${pc3.bold(`Installed (${installed.length})`)}`);
     for (const tool of installed) {
-      const mcp = tool.mcpConfigured ? pc.green("MCP") : pc.dim("manual");
-      lines.push(`  ${pc.green("\u25CF")} ${pc.bold(tool.name.padEnd(16))} ${mcp}  ${pc.dim(tool.installedAt)}`);
+      const mcp = tool.mcpConfigured ? pc3.green("MCP") : pc3.dim("manual");
+      lines.push(`  ${pc3.green("\u25CF")} ${pc3.bold(tool.name.padEnd(16))} ${mcp}  ${pc3.dim(tool.installedAt)}`);
     }
     lines.push("");
   }
   if (available.length > 0) {
-    lines.push(`  ${pc.bold(`Available (${available.length})`)}`);
+    lines.push(`  ${pc3.bold(`Available (${available.length})`)}`);
     const byCategory = /* @__PURE__ */ new Map();
     for (const tool of available) {
       if (!byCategory.has(tool.category)) byCategory.set(tool.category, []);
       byCategory.get(tool.category).push(tool);
     }
     for (const [category, tools] of byCategory) {
-      lines.push(`  ${pc.dim(category)}`);
+      lines.push(`  ${pc3.dim(category)}`);
       for (const tool of tools) {
-        lines.push(`  ${pc.dim("\u25CB")} ${tool.name.padEnd(16)} ${pc.dim(tool.description)}`);
+        lines.push(`  ${pc3.dim("\u25CB")} ${tool.name.padEnd(16)} ${pc3.dim(tool.description)}`);
       }
     }
     lines.push("");
   }
-  lines.push(`  ${pc.cyan("/akit add <tool>")}     Install a tool`);
-  lines.push(`  ${pc.cyan("/akit remove <tool>")}  Uninstall a tool`);
+  lines.push(`  ${pc3.cyan("/akit add <tool>")}     Install a tool`);
+  lines.push(`  ${pc3.cyan("/akit remove <tool>")}  Uninstall a tool`);
   return { handled: true, output: lines.join("\n") };
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os5.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path5.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path9.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /skills install <name>") };
+      return { handled: true, output: pc3.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: pc.yellow("Usage: /skills uninstall <name>") };
+      return { handled: true, output: pc3.yellow("Usage: /skills uninstall <name>") };
     }
     const output = await mcpWrite(ctx, "skills", "skill_uninstall", { name: args.join(" ") });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /skills ${action}. Use /skills [install|uninstall].`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os5.homedir();
+  const home2 = os9.homedir();
   if (!action) {
-    const content = readEcosystemFile(path5.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path9.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /eval milestone <text...>") };
+      return { handled: true, output: pc3.yellow("Usage: /eval milestone <text...>") };
     }
     const text2 = args.join(" ");
     const output = await mcpWrite(ctx, "eval", "eval_milestone", { text: text2 });
     return { handled: true, output };
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /eval ${action}. Use /eval or /eval milestone <text>.`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /eval ${action}. Use /eval or /eval milestone <text>.`) };
 }
 async function handleMemoryCommand(action, args, ctx) {
   if (!action) {
-    if (!ctx.mcpManager) {
-      return {
-        handled: true,
-        output: pc.red("Memory not available: aman-mcp not connected. Start it with: npx @aman_asmuei/aman-mcp")
-      };
-    }
-    const result = await ctx.mcpManager.callTool("memory_context", { topic: "recent context" });
-    if (result.startsWith("Error")) {
-      return { handled: true, output: pc.red(result) };
+    try {
+      const result = await memoryContext("recent context");
+      if (result.memoriesUsed === 0) {
+        return { handled: true, output: pc3.dim("No memories yet. Start chatting and I'll remember what matters.") };
+      }
+      return { handled: true, output: result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
-    return { handled: true, output: result };
   }
   if (action && !["search", "clear", "timeline"].includes(action)) {
-    if (!ctx.mcpManager) {
-      return { handled: true, output: pc.red("Memory not available: MCP not connected.") };
-    }
-    const topic = [action, ...args].join(" ");
-    const result = await ctx.mcpManager.callTool("memory_context", { topic });
-    if (result.startsWith("Error")) {
-      return { handled: true, output: pc.red(result) };
+    try {
+      const topic = [action, ...args].join(" ");
+      const result = await memoryContext(topic);
+      if (result.memoriesUsed === 0) {
+        return { handled: true, output: pc3.dim(`No memories found for: "${topic}".`) };
+      }
+      return { handled: true, output: result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
     }
-    return { handled: true, output: result };
   }
   if (action === "search") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /memory search <query...>") };
+      return { handled: true, output: pc3.yellow("Usage: /memory search <query...>") };
     }
     const query = args.join(" ");
-    const output = await mcpWrite(ctx, "memory", "memory_recall", { query });
-    return { handled: true, output };
+    try {
+      const result = await memoryRecall(query);
+      return { handled: true, output: result.total === 0 ? pc3.dim("No memories found.") : result.text };
+    } catch (err) {
+      return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+    }
   }
   if (action === "clear") {
     if (args.length < 1) {
-      return { handled: true, output: pc.yellow("Usage: /memory clear <category>") };
+      return { handled: true, output: pc3.yellow("Usage: /memory clear <category>") };
     }
     const output = await mcpWrite(ctx, "memory", "memory_forget", { category: args[0] });
     return { handled: true, output };
   }
   if (action === "timeline") {
-    if (!ctx.mcpManager) {
-      return { handled: true, output: pc.red("Memory not available: MCP not connected.") };
-    }
     try {
-      const result = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 500 });
-      if (result.startsWith("Error") || result.includes("No memories found")) {
-        return { handled: true, output: pc.dim("No memories yet. Start chatting and I'll remember what matters.") };
+      const result = await memoryRecall("*", { limit: 500, compact: false });
+      if (result.total === 0) {
+        return { handled: true, output: pc3.dim("No memories yet. Start chatting and I'll remember what matters.") };
       }
-      try {
-        const memories = JSON.parse(result);
-        if (Array.isArray(memories) && memories.length > 0) {
-          const byDate = /* @__PURE__ */ new Map();
-          for (const mem of memories) {
-            const date = mem.created_at ? new Date(mem.created_at).toLocaleDateString("en-US", { month: "short", day: "numeric" }) : "Unknown";
-            byDate.set(date, (byDate.get(date) || 0) + 1);
-          }
-          const maxCount = Math.max(...byDate.values());
-          const barWidth = 10;
-          const lines = [pc.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);
-            lines.push(`  ${date.padEnd(8)} ${bar}  ${count} memories`);
-          }
-          const tags = /* @__PURE__ */ new Map();
-          for (const mem of memories) {
-            if (Array.isArray(mem.tags)) {
-              for (const tag of mem.tags) {
-                tags.set(tag, (tags.get(tag) || 0) + 1);
-              }
+      const memories = result.memories;
+      if (memories.length > 0) {
+        const byDate = /* @__PURE__ */ new Map();
+        for (const mem of memories) {
+          const createdAt = mem.created_at;
+          const date = createdAt ? new Date(createdAt).toLocaleDateString("en-US", { month: "short", day: "numeric" }) : "Unknown";
+          byDate.set(date, (byDate.get(date) || 0) + 1);
+        }
+        const maxCount = Math.max(...byDate.values());
+        const barWidth = 10;
+        const lines = [pc3.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);
+          lines.push(`  ${date.padEnd(8)} ${bar}  ${count} memories`);
+        }
+        const tags = /* @__PURE__ */ new Map();
+        for (const mem of memories) {
+          const memTags = mem.tags;
+          if (Array.isArray(memTags)) {
+            for (const tag of memTags) {
+              tags.set(tag, (tags.get(tag) || 0) + 1);
             }
           }
-          lines.push("");
-          lines.push(`  Total: ${memories.length} memories`);
-          if (tags.size > 0) {
-            const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag, count]) => `#${tag} (${count})`).join(", ");
-            lines.push(`  Top tags: ${topTags}`);
-          }
-          return { handled: true, output: lines.join("\n") };
         }
-      } catch {
+        lines.push("");
+        lines.push(`  Total: ${result.total} memories`);
+        if (tags.size > 0) {
+          const topTags = [...tags.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([tag, count]) => `#${tag} (${count})`).join(", ");
+          lines.push(`  Top tags: ${topTags}`);
+        }
+        return { handled: true, output: lines.join("\n") };
       }
-      const lineCount = result.split("\n").filter((l) => l.trim()).length;
-      return { handled: true, output: `Total memories: ~${lineCount} entries.` };
+      return { handled: true, output: `Total memories: ${result.total} entries.` };
     } catch {
-      return { handled: true, output: pc.red("Failed to retrieve memory timeline.") };
+      return { handled: true, output: pc3.red("Failed to retrieve memory timeline.") };
     }
   }
-  return { handled: true, output: pc.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear|timeline].`) };
+  return { handled: true, output: pc3.yellow(`Unknown action: /memory ${action}. Use /memory [search|clear|timeline].`) };
 }
 function handleStatusCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
   const amemConnected = mcpToolCount > 0;
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
-  const lines = [pc.bold("Aman Ecosystem Dashboard"), ""];
+  const lines = [pc3.bold("Aman Ecosystem Dashboard"), ""];
   for (const layer of status.layers) {
-    const icon = layer.exists ? pc.green("\u25CF") : pc.dim("\u25CB");
-    const name = pc.bold(layer.name.padEnd(12));
-    const summary = layer.exists ? layer.summary : pc.dim("not configured");
+    const icon = layer.exists ? pc3.green("\u25CF") : pc3.dim("\u25CB");
+    const name = pc3.bold(layer.name.padEnd(12));
+    const summary = layer.exists ? layer.summary : pc3.dim("not configured");
     lines.push(`  ${icon} ${name} ${summary}`);
   }
   lines.push("");
-  lines.push(`  ${status.mcpConnected ? pc.green("\u25CF") : pc.dim("\u25CB")} ${pc.bold("MCP".padEnd(12))} ${status.mcpConnected ? `${status.mcpToolCount} tools available` : pc.dim("not connected")}`);
-  lines.push(`  ${status.amemConnected ? pc.green("\u25CF") : pc.dim("\u25CB")} ${pc.bold("Memory".padEnd(12))} ${status.amemConnected ? "connected" : pc.dim("not connected")}`);
+  lines.push(`  ${status.mcpConnected ? pc3.green("\u25CF") : pc3.dim("\u25CB")} ${pc3.bold("MCP".padEnd(12))} ${status.mcpConnected ? `${status.mcpToolCount} tools available` : pc3.dim("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc3.green("\u25CF") : pc3.dim("\u25CB")} ${pc3.bold("Memory".padEnd(12))} ${status.amemConnected ? "connected" : pc3.dim("not connected")}`);
   return { handled: true, output: lines.join("\n") };
 }
 function handleDoctorCommand(ctx) {
   const mcpToolCount = ctx.mcpManager ? ctx.mcpManager.getTools().length : 0;
   const amemConnected = mcpToolCount > 0;
   const status = getEcosystemStatus(mcpToolCount, amemConnected);
-  const lines = [pc.bold("Aman Health Check"), ""];
+  const lines = [pc3.bold("Aman Health Check"), ""];
   let healthy = 0;
   let fixes = 0;
   let suggestions = 0;
   for (const layer of status.layers) {
     if (layer.exists) {
-      lines.push(`  ${pc.green("\u2713")} ${layer.name.padEnd(12)} ${pc.green(layer.summary)}`);
+      lines.push(`  ${pc3.green("\u2713")} ${layer.name.padEnd(12)} ${pc3.green(layer.summary)}`);
       healthy++;
     } else {
       const isRequired = ["identity", "rules"].includes(layer.name.toLowerCase());
       if (isRequired) {
-        lines.push(`  ${pc.red("\u2717")} ${layer.name.padEnd(12)} ${pc.red("missing")}`);
-        lines.push(`    ${pc.dim("\u2192 Fix: aman-agent init")}`);
+        lines.push(`  ${pc3.red("\u2717")} ${layer.name.padEnd(12)} ${pc3.red("missing")}`);
+        lines.push(`    ${pc3.dim("\u2192 Fix: aman-agent init")}`);
         fixes++;
       } else {
-        lines.push(`  ${pc.yellow("\u26A0")} ${layer.name.padEnd(12)} ${pc.yellow("empty")}`);
+        lines.push(`  ${pc3.yellow("\u26A0")} ${layer.name.padEnd(12)} ${pc3.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(`    ${pc.dim(`\u2192 Add with ${cmd}`)}`);
+        if (cmd) lines.push(`    ${pc3.dim(`\u2192 Add with ${cmd}`)}`);
         suggestions++;
       }
     }
   }
   lines.push("");
-  lines.push(`  ${status.mcpConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc.green(`${status.mcpToolCount} tools`) : pc.red("not connected")}`);
+  lines.push(`  ${status.mcpConnected ? pc3.green("\u2713") : pc3.red("\u2717")} ${"MCP".padEnd(12)} ${status.mcpConnected ? pc3.green(`${status.mcpToolCount} tools`) : pc3.red("not connected")}`);
   if (!status.mcpConnected) {
-    lines.push(`    ${pc.dim("\u2192 Fix: ensure npx is available and network is connected")}`);
+    lines.push(`    ${pc3.dim("\u2192 Fix: ensure npx is available and network is connected")}`);
     fixes++;
   } else {
     healthy++;
   }
-  lines.push(`  ${status.amemConnected ? pc.green("\u2713") : pc.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc.green("connected") : pc.red("not connected")}`);
+  lines.push(`  ${status.amemConnected ? pc3.green("\u2713") : pc3.red("\u2717")} ${"Memory".padEnd(12)} ${status.amemConnected ? pc3.green("connected") : pc3.red("not connected")}`);
   if (!status.amemConnected) {
-    lines.push(`    ${pc.dim("\u2192 Fix: npx @aman_asmuei/amem")}`);
+    lines.push(`    ${pc3.dim("\u2192 Fix: npx @aman_asmuei/amem")}`);
     fixes++;
   } else {
     healthy++;
@@ -1315,26 +2150,26 @@ function handleHelp() {
   return {
     handled: true,
     output: [
-      pc.bold("Commands:"),
-      `  ${pc.cyan("/help")}         Show this help`,
-      `  ${pc.cyan("/identity")}     View identity [update <section>]`,
-      `  ${pc.cyan("/rules")}        View rules [add|remove|toggle ...]`,
-      `  ${pc.cyan("/workflows")}    View workflows [add|remove ...]`,
-      `  ${pc.cyan("/akit")}         Manage tools [add|remove <tool>]`,
-      `  ${pc.cyan("/skills")}       View skills [install|uninstall ...]`,
-      `  ${pc.cyan("/eval")}         View evaluation [milestone ...]`,
-      `  ${pc.cyan("/memory")}       View recent memories [search|clear|timeline]`,
-      `  ${pc.cyan("/status")}       Ecosystem dashboard`,
-      `  ${pc.cyan("/doctor")}       Health check all layers`,
-      `  ${pc.cyan("/decisions")}    View decision log [<project>]`,
-      `  ${pc.cyan("/export")}       Export conversation to markdown`,
-      `  ${pc.cyan("/debug")}        Show debug log`,
-      `  ${pc.cyan("/save")}         Save conversation to memory`,
-      `  ${pc.cyan("/model")}        Show current LLM model`,
-      `  ${pc.cyan("/update")}       Check for updates`,
-      `  ${pc.cyan("/reconfig")}     Reset LLM config`,
-      `  ${pc.cyan("/clear")}        Clear conversation history`,
-      `  ${pc.cyan("/quit")}         Exit`
+      pc3.bold("Commands:"),
+      `  ${pc3.cyan("/help")}         Show this help`,
+      `  ${pc3.cyan("/identity")}     View identity [update <section>]`,
+      `  ${pc3.cyan("/rules")}        View rules [add|remove|toggle ...]`,
+      `  ${pc3.cyan("/workflows")}    View workflows [add|remove ...]`,
+      `  ${pc3.cyan("/akit")}         Manage tools [add|remove <tool>]`,
+      `  ${pc3.cyan("/skills")}       View skills [install|uninstall ...]`,
+      `  ${pc3.cyan("/eval")}         View evaluation [milestone ...]`,
+      `  ${pc3.cyan("/memory")}       View recent memories [search|clear|timeline]`,
+      `  ${pc3.cyan("/status")}       Ecosystem dashboard`,
+      `  ${pc3.cyan("/doctor")}       Health check all layers`,
+      `  ${pc3.cyan("/decisions")}    View decision log [<project>]`,
+      `  ${pc3.cyan("/export")}       Export conversation to markdown`,
+      `  ${pc3.cyan("/debug")}        Show debug log`,
+      `  ${pc3.cyan("/save")}         Save conversation to memory`,
+      `  ${pc3.cyan("/model")}        Show current LLM model`,
+      `  ${pc3.cyan("/update")}       Check for updates`,
+      `  ${pc3.cyan("/reconfig")}     Reset LLM config`,
+      `  ${pc3.cyan("/clear")}        Clear conversation history`,
+      `  ${pc3.cyan("/quit")}         Exit`
     ].join("\n")
   };
 }
@@ -1342,18 +2177,18 @@ function handleSave() {
   return { handled: true, saveConversation: true };
 }
 function handleReconfig() {
-  const configDir = path5.join(os5.homedir(), ".aman-agent");
-  const configPath = path5.join(configDir, "config.json");
-  if (fs5.existsSync(configPath)) {
-    fs5.unlinkSync(configPath);
+  const configDir = path9.join(os9.homedir(), ".aman-agent");
+  const configPath = path9.join(configDir, "config.json");
+  if (fs9.existsSync(configPath)) {
+    fs9.unlinkSync(configPath);
   }
-  fs5.mkdirSync(configDir, { recursive: true });
-  fs5.writeFileSync(path5.join(configDir, ".reconfig"), "", "utf-8");
+  fs9.mkdirSync(configDir, { recursive: true });
+  fs9.writeFileSync(path9.join(configDir, ".reconfig"), "", "utf-8");
   return {
     handled: true,
     quit: true,
     output: [
-      pc.green("Config reset."),
+      pc3.green("Config reset."),
       "Next run will prompt you to choose your LLM provider."
     ].join("\n")
   };
@@ -1361,20 +2196,20 @@ function handleReconfig() {
 function handleUpdate() {
   try {
     const current = execFileSync("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = JSON.parse(fs5.readFileSync(path5.join(__dirname, "..", "package.json"), "utf-8")).version;
+    const local = JSON.parse(fs9.readFileSync(path9.join(__dirname, "..", "package.json"), "utf-8")).version;
     if (current === local) {
-      return { handled: true, output: `${pc.green("Up to date")} \u2014 v${local}` };
+      return { handled: true, output: `${pc3.green("Up to date")} \u2014 v${local}` };
     }
     return {
       handled: true,
       output: [
-        `${pc.yellow("Update available:")} v${local} \u2192 v${current}`,
+        `${pc3.yellow("Update available:")} v${local} \u2192 v${current}`,
         "",
         `Run this in your terminal:`,
-        `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        `  ${pc3.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
         "",
         `Or use npx (always latest):`,
-        `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc3.bold("npx @aman_asmuei/aman-agent@latest")}`
       ].join("\n")
     };
   } catch {
@@ -1382,42 +2217,422 @@ function handleUpdate() {
       handled: true,
       output: [
         `To update, run in your terminal:`,
-        `  ${pc.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
+        `  ${pc3.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
         "",
         `Or use npx (always latest):`,
-        `  ${pc.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc3.bold("npx @aman_asmuei/aman-agent@latest")}`
       ].join("\n")
     };
   }
 }
-async function handleDecisionsCommand(action, _args, ctx) {
-  if (!ctx.mcpManager) {
-    return { handled: true, output: pc.red("Decisions not available: MCP not connected.") };
-  }
-  const scope = action || void 0;
-  const result = await ctx.mcpManager.callTool("memory_recall", {
-    query: "decision",
-    type: "decision",
-    limit: 20,
-    ...scope ? { scope } : {}
-  });
-  if (result.startsWith("Error")) {
-    return { handled: true, output: pc.red(result) };
+async function handleDecisionsCommand(action, _args, _ctx) {
+  try {
+    const result = await memoryRecall("decision", { type: "decision", limit: 20 });
+    if (result.total === 0) {
+      return { handled: true, output: pc3.dim("No decisions recorded yet.") };
+    }
+    return { handled: true, output: pc3.bold("Decision Log:\n") + result.text };
+  } catch (err) {
+    return { handled: true, output: pc3.red(`Memory error: ${err instanceof Error ? err.message : String(err)}`) };
+  }
+}
+function handleExportCommand() {
+  return { handled: true, exportConversation: true };
+}
+function handleDebugCommand() {
+  const logPath = path9.join(os9.homedir(), ".aman-agent", "debug.log");
+  if (!fs9.existsSync(logPath)) {
+    return { handled: true, output: pc3.dim("No debug log found.") };
+  }
+  const content = fs9.readFileSync(logPath, "utf-8");
+  const lines = content.trim().split("\n");
+  const last20 = lines.slice(-20).join("\n");
+  return { handled: true, output: pc3.bold("Debug Log (last 20 entries):\n") + pc3.dim(last20) };
+}
+async function handleTeamCommand(action, args, ctx) {
+  if (!action || action === "list") {
+    const teams = listTeams();
+    if (teams.length === 0) {
+      return {
+        handled: true,
+        output: pc3.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 `  ${pc3.bold(t.name)} (${t.workflow}) \u2014 ${members}`;
+    });
+    return { handled: true, output: "Teams:\n" + lines.join("\n") };
+  }
+  switch (action) {
+    case "create": {
+      const name = args[0];
+      if (!name) {
+        const lines = BUILT_IN_TEAMS.map((t) => {
+          const members2 = t.members.map((m) => m.profile).join(" \u2192 ");
+          return `  ${pc3.bold(t.name)} (${t.workflow}) \u2014 ${members2}
+    ${pc3.dim(t.goal)}`;
+        });
+        return {
+          handled: true,
+          output: "Built-in teams:\n" + lines.join("\n\n") + "\n\nUsage:\n  /team create content-team     Install built-in\n  /team create <name> <mode> <profile1:role>,<profile2:role>  Custom"
+        };
+      }
+      const builtIn = BUILT_IN_TEAMS.find((t) => t.name === name);
+      if (builtIn) {
+        createTeam(builtIn);
+        return { handled: true, output: pc3.green(`Team installed: ${builtIn.name}`) + "\n\n" + formatTeam(builtIn) };
+      }
+      const mode = args[1];
+      const membersStr = args[2];
+      if (!mode || !membersStr) {
+        return { handled: true, output: pc3.yellow("Usage: /team create <name> <pipeline|parallel|coordinator> <profile1:role>,<profile2:role>") };
+      }
+      if (!["pipeline", "parallel", "coordinator"].includes(mode)) {
+        return { handled: true, output: pc3.yellow("Mode must be: pipeline, parallel, or coordinator") };
+      }
+      const members = membersStr.split(",").map((m) => {
+        const [profile, ...roleParts] = m.trim().split(":");
+        return { profile: profile.trim(), role: roleParts.join(":").trim() || profile.trim() };
+      });
+      const team = {
+        name,
+        goal: `Team: ${name}`,
+        coordinator: "default",
+        members,
+        workflow: mode
+      };
+      createTeam(team);
+      return { handled: true, output: pc3.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: pc3.yellow("Usage: /team run <team-name> <task description>") };
+      }
+      const team = loadTeam(teamName);
+      if (!team) return { handled: true, output: pc3.red(`Team not found: ${teamName}`) };
+      if (!ctx.llmClient || !ctx.mcpManager) {
+        return { handled: true, output: pc3.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: pc3.yellow("Usage: /team show <name>") };
+      const team = loadTeam(name);
+      if (!team) return { handled: true, output: pc3.red(`Team not found: ${name}`) };
+      return { handled: true, output: formatTeam(team) };
+    }
+    case "delete": {
+      const name = args[0];
+      if (!name) return { handled: true, output: pc3.yellow("Usage: /team delete <name>") };
+      if (!deleteTeam(name)) return { handled: true, output: pc3.red(`Team not found: ${name}`) };
+      return { handled: true, output: pc3.dim(`Team deleted: ${name}`) };
+    }
+    case "help":
+      return { handled: true, output: `Team commands:
+  /team                          List all teams
+  /team create                   Show built-in templates
+  /team create <name>            Install built-in team
+  /team create <n> <mode> <m>    Custom team (mode: pipeline|parallel|coordinator)
+  /team run <name> <task>        Run a task with a team
+  /team show <name>              Show team details
+  /team delete <name>            Delete a team
+
+Modes:
+  pipeline     Sequential: agent1 \u2192 agent2 \u2192 agent3
+  parallel     All agents work concurrently, coordinator merges
+  coordinator  Coordinator LLM decides how to split the task
+
+Examples:
+  /team create content-team
+  /team run content-team Write a blog post about AI companions
+  /team create review-squad pipeline coder:implement,researcher:review
+  /team run review-squad Build a rate limiter in TypeScript` };
+    default:
+      return { handled: true, output: pc3.yellow(`Unknown team action: ${action}. Try /team help`) };
+  }
+}
+async function handleDelegateCommand(action, args, ctx) {
+  if (!action) {
+    return { handled: true, output: `Delegate commands:
+  /delegate <profile> <task>        Delegate a task to a profile
+  /delegate pipeline <p1> <p2> ...  Run a sequential pipeline
+  /delegate help                    Show help
+
+Examples:
+  /delegate writer Write a blog post about AI companions
+  /delegate coder Review this code for security issues
+  /delegate pipeline writer,researcher Write and fact-check an article about quantum computing` };
+  }
+  if (action === "help") {
+    return { handled: true, output: `Delegate a task to a sub-agent with a specific profile.
+
+The sub-agent runs with its own identity, rules, and skills but shares
+your memory and tools. Results come back to you.
+
+Usage:
+  /delegate <profile> <task>
+  /delegate pipeline <profile1>,<profile2> <task>
+
+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: pc3.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: pc3.yellow("Usage: /delegate pipeline <profile1>,<profile2> <task>") };
+    }
+    const profiles = profileList.split(",").map((p3) => p3.trim());
+    const steps = profiles.map((profile2, i) => {
+      if (i === 0) {
+        return { profile: profile2, taskTemplate: task2 };
+      }
+      return { profile: profile2, taskTemplate: `Review and improve the following:
+
+{{input}}` };
+    });
+    process.stdout.write(pc3.dim(`
+  Pipeline: ${profiles.join(" \u2192 ")}
+`));
+    const results = await delegatePipeline(steps, task2, ctx.llmClient, ctx.mcpManager, { tools: ctx.tools });
+    const output = [];
+    for (const r of results) {
+      if (r.success) {
+        output.push(`
+${pc3.bold(`[${r.profile}]`)} ${pc3.green("\u2713")} (${r.turns} tool turns)`);
+        output.push(r.response.slice(0, 2e3));
+        if (r.toolsUsed.length > 0) output.push(pc3.dim(`  Tools: ${r.toolsUsed.join(", ")}`));
+      } else {
+        output.push(`
+${pc3.bold(`[${r.profile}]`)} ${pc3.red("\u2717")} ${r.error}`);
+      }
+    }
+    return { handled: true, output: output.join("\n") };
+  }
+  const profile = action;
+  const task = args.join(" ");
+  if (!task) {
+    return { handled: true, output: pc3.yellow(`Usage: /delegate ${profile} <task description>`) };
+  }
+  process.stdout.write(pc3.dim(`
+  [delegating to ${profile}...]
+
+`));
+  const result = await delegateTask(task, profile, ctx.llmClient, ctx.mcpManager, { tools: ctx.tools });
+  if (!result.success) {
+    return { handled: true, output: pc3.red(`Delegation failed: ${result.error}`) };
+  }
+  const meta = [];
+  if (result.toolsUsed.length > 0) meta.push(`Tools: ${result.toolsUsed.join(", ")}`);
+  if (result.turns > 0) meta.push(`${result.turns} tool turns`);
+  return {
+    handled: true,
+    output: `
+${pc3.bold(`[${profile}]`)} ${pc3.green("\u2713")}${meta.length > 0 ? " " + pc3.dim(`(${meta.join(", ")})`) : ""}
+
+${result.response}`
+  };
+}
+function handleProfileCommand(action, args) {
+  const profilesDir = path9.join(os9.homedir(), ".acore", "profiles");
+  if (!action || action === "list") {
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+      return { handled: true, output: pc3.dim("No profiles yet. Create one with: /profile create <name>") };
+    }
+    const lines = profiles.map(
+      (p3) => `  ${pc3.bold(p3.name)} \u2014 ${p3.aiName} (${pc3.dim(p3.personality)})`
+    );
+    return { handled: true, output: "Profiles:\n" + lines.join("\n") + "\n\n" + pc3.dim("Switch with: aman-agent --profile <name>") };
+  }
+  switch (action) {
+    case "create": {
+      const name = args[0];
+      if (!name) {
+        const lines = BUILT_IN_PROFILES.map(
+          (t) => `  ${pc3.bold(t.name)} \u2014 ${t.label}: ${pc3.dim(t.description)}`
+        );
+        return {
+          handled: true,
+          output: "Built-in profiles:\n" + lines.join("\n") + "\n\nUsage:\n  /profile create coder     Install built-in template\n  /profile create <custom>  Create blank profile"
+        };
+      }
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const profileDir = path9.join(profilesDir, slug);
+      if (fs9.existsSync(profileDir)) {
+        return { handled: true, output: pc3.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: pc3.red(err) };
+        return {
+          handled: true,
+          output: pc3.green(`Profile installed: ${builtIn.label}`) + `
+  AI name: ${builtIn.core.match(/^# (.+)/m)?.[1] || slug}
+  ${pc3.dim(builtIn.description)}
+
+  Use: aman-agent --profile ${slug}`
+        };
+      }
+      fs9.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path9.join(os9.homedir(), ".acore", "core.md");
+      if (fs9.existsSync(globalCore)) {
+        let content = fs9.readFileSync(globalCore, "utf-8");
+        const aiName = name.charAt(0).toUpperCase() + name.slice(1);
+        content = content.replace(/^# .+$/m, `# ${aiName}`);
+        fs9.writeFileSync(path9.join(profileDir, "core.md"), content, "utf-8");
+      } else {
+        const aiName = name.charAt(0).toUpperCase() + name.slice(1);
+        fs9.writeFileSync(path9.join(profileDir, "core.md"), `# ${aiName}
+
+## Identity
+- Role: ${aiName} is your AI companion
+- Personality: helpful, adaptive
+- Communication: clear and concise
+- Values: honesty, simplicity
+- Boundaries: won't pretend to be human
+`, "utf-8");
+      }
+      return {
+        handled: true,
+        output: pc3.green(`Profile created: ${slug}`) + `
+  Edit: ${path9.join(profileDir, "core.md")}
+  Use: aman-agent --profile ${slug}
+
+  ${pc3.dim("Add rules.md or skills.md for profile-specific overrides.")}`
+      };
+    }
+    case "show": {
+      const name = args[0];
+      if (!name) return { handled: true, output: pc3.yellow("Usage: /profile show <name>") };
+      const profileDir = path9.join(profilesDir, name);
+      if (!fs9.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
+      const files = fs9.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const lines = files.map((f) => `  ${f}`);
+      return { handled: true, output: `Profile: ${pc3.bold(name)}
+Files:
+${lines.join("\n")}` };
+    }
+    case "delete": {
+      const name = args[0];
+      if (!name) return { handled: true, output: pc3.yellow("Usage: /profile delete <name>") };
+      const profileDir = path9.join(profilesDir, name);
+      if (!fs9.existsSync(profileDir)) return { handled: true, output: pc3.red(`Profile not found: ${name}`) };
+      fs9.rmSync(profileDir, { recursive: true });
+      return { handled: true, output: pc3.dim(`Profile deleted: ${name}`) };
+    }
+    case "help":
+      return { handled: true, output: `Profile commands:
+  /profile              List all profiles
+  /profile create <n>   Create new profile
+  /profile show <n>     Show profile files
+  /profile delete <n>   Delete a profile
+
+  Use profiles:
+  aman-agent --profile <name>
+  AMAN_PROFILE=<name> aman-agent` };
+    default:
+      return { handled: true, output: pc3.yellow(`Unknown profile action: ${action}. Try /profile help`) };
+  }
+}
+function handlePlanCommand(action, args) {
+  if (!action) {
+    const active = getActivePlan();
+    if (!active) {
+      return { handled: true, output: pc3.dim("No active plan. Create one with: /plan create <name> | <goal> | <step1>, <step2>, ...") };
+    }
+    return { handled: true, output: formatPlan(active) };
   }
-  return { handled: true, output: pc.bold("Decision Log:\n") + result };
-}
-function handleExportCommand() {
-  return { handled: true, exportConversation: true };
-}
-function handleDebugCommand() {
-  const logPath = path5.join(os5.homedir(), ".aman-agent", "debug.log");
-  if (!fs5.existsSync(logPath)) {
-    return { handled: true, output: pc.dim("No debug log found.") };
+  switch (action) {
+    case "create": {
+      const fullArgs = args.join(" ");
+      const parts = fullArgs.split("|").map((p3) => p3.trim());
+      if (parts.length < 3) {
+        return { handled: true, output: pc3.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: pc3.yellow("Need at least one step. Separate steps with commas.") };
+      }
+      const plan = createPlan(name, goal, steps);
+      return { handled: true, output: pc3.green(`Plan created!
+
+`) + formatPlan(plan) };
+    }
+    case "done": {
+      const active = getActivePlan();
+      if (!active) return { handled: true, output: pc3.yellow("No active plan.") };
+      if (args.length > 0) {
+        const stepNum = parseInt(args[0], 10);
+        if (isNaN(stepNum) || stepNum < 1 || stepNum > active.steps.length) {
+          return { handled: true, output: pc3.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
+        }
+        markStepDone(active, stepNum - 1);
+        return { handled: true, output: pc3.green(`Step ${stepNum} done!`) + "\n\n" + formatPlan(active) };
+      }
+      const next = active.steps.findIndex((s) => !s.done);
+      if (next < 0) return { handled: true, output: pc3.green("All steps already complete!") };
+      markStepDone(active, next);
+      return { handled: true, output: pc3.green(`Step ${next + 1} done!`) + "\n\n" + formatPlan(active) };
+    }
+    case "undo": {
+      const active = getActivePlan();
+      if (!active) return { handled: true, output: pc3.yellow("No active plan.") };
+      const stepNum = parseInt(args[0], 10);
+      if (isNaN(stepNum) || stepNum < 1 || stepNum > active.steps.length) {
+        return { handled: true, output: pc3.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
+      }
+      markStepUndone(active, stepNum - 1);
+      return { handled: true, output: pc3.dim(`Step ${stepNum} unmarked.`) + "\n\n" + formatPlan(active) };
+    }
+    case "list": {
+      const plans = listPlans();
+      if (plans.length === 0) return { handled: true, output: pc3.dim("No plans yet.") };
+      const lines = plans.map((p3) => {
+        const done = p3.steps.filter((s) => s.done).length;
+        const total = p3.steps.length;
+        const status = p3.active ? pc3.green("active") : pc3.dim("inactive");
+        return `  ${p3.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: pc3.yellow("Usage: /plan switch <name>") };
+      const plan = setActivePlan(name);
+      if (!plan) return { handled: true, output: pc3.red(`Plan not found: ${name}`) };
+      return { handled: true, output: pc3.green(`Switched to: ${plan.name}`) + "\n\n" + formatPlan(plan) };
+    }
+    case "show": {
+      const name = args.join(" ");
+      if (!name) return { handled: true, output: pc3.yellow("Usage: /plan show <name>") };
+      const plan = loadPlan(name);
+      if (!plan) return { handled: true, output: pc3.red(`Plan not found: ${name}`) };
+      return { handled: true, output: formatPlan(plan) };
+    }
+    case "help":
+      return { handled: true, output: `Plan commands:
+  /plan               Show active plan
+  /plan create <name> | <goal> | <step1>, <step2>, ...
+  /plan done [step#]  Mark step complete (next if no number)
+  /plan undo <step#>  Unmark a step
+  /plan list          List all plans
+  /plan switch <name> Switch active plan
+  /plan show <name>   Show a specific plan` };
+    default:
+      return { handled: true, output: pc3.yellow(`Unknown plan action: ${action}. Try /plan help`) };
   }
-  const content = fs5.readFileSync(logPath, "utf-8");
-  const lines = content.trim().split("\n");
-  const last20 = lines.slice(-20).join("\n");
-  return { handled: true, output: pc.bold("Debug Log (last 20 entries):\n") + pc.dim(last20) };
 }
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "quit",
@@ -1443,7 +2658,11 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "update-config",
   "reconfig",
   "update",
-  "upgrade"
+  "upgrade",
+  "plan",
+  "profile",
+  "delegate",
+  "team"
 ]);
 async function handleCommand(input, ctx) {
   const trimmed = input.trim();
@@ -1458,9 +2677,9 @@ async function handleCommand(input, ctx) {
     case "help":
       return handleHelp();
     case "clear":
-      return { handled: true, output: pc.dim("Conversation cleared."), clearHistory: true };
+      return { handled: true, output: pc3.dim("Conversation cleared."), clearHistory: true };
     case "model":
-      return { handled: true, output: ctx.model ? `Model: ${pc.bold(ctx.model)}` : "Model: unknown" };
+      return { handled: true, output: ctx.model ? `Model: ${pc3.bold(ctx.model)}` : "Model: unknown" };
     case "identity":
       return handleIdentityCommand(action, args, ctx);
     case "rules":
@@ -1491,6 +2710,14 @@ async function handleCommand(input, ctx) {
     case "update-config":
     case "reconfig":
       return handleReconfig();
+    case "plan":
+      return handlePlanCommand(action, args);
+    case "profile":
+      return handleProfileCommand(action, args);
+    case "delegate":
+      return handleDelegateCommand(action, args, ctx);
+    case "team":
+      return handleTeamCommand(action, args, ctx);
     case "update":
     case "upgrade":
       return handleUpdate();
@@ -1500,8 +2727,183 @@ async function handleCommand(input, ctx) {
 }
 
 // src/hooks.ts
-import pc2 from "picocolors";
+import pc4 from "picocolors";
 import * as p from "@clack/prompts";
+import fs10 from "fs";
+import path10 from "path";
+
+// src/personality.ts
+var FRUSTRATION_SIGNALS = [
+  /\b(ugh|argh|damn|dammit|wtf|ffs|shit|fuck|crap|hate this|stupid|broken|still not|doesn't work|not working|won't work|keeps failing|again\?!|what the hell|for the love of|give up|giving up|fed up)\b/i,
+  /\b(why (is|does|won't|can't|isn't)|same (error|issue|problem|bug)|tried everything|nothing works|no idea|lost|stuck|frustrated|annoying|impossible)\b/i,
+  /!{2,}/,
+  // multiple exclamation marks
+  /\?{2,}/
+  // multiple question marks (exasperation)
+];
+var EXCITEMENT_SIGNALS = [
+  /\b(amazing|awesome|perfect|brilliant|love it|yes!|nice!|great!|finally|it works|nailed it|beautiful|incredible|exactly|that's it|hell yeah|wow|woah|let's go)\b/i,
+  /\b(excited|pumped|stoked|can't wait|this is great|so cool|love this)\b/i,
+  /!{1,}.*(!|🎉|🚀|✨|💪|🔥)/
+];
+var CONFUSION_SIGNALS = [
+  /\b(confused|don't understand|what do you mean|huh\??|makes no sense|i'm lost|unclear|what\?|how does that|wait what|can you explain|i don't get)\b/i,
+  /\b(which one|what's the difference|should i|not sure (if|what|how|why|whether))\b/i
+];
+var FATIGUE_SIGNALS = [
+  /\b(tired|exhausted|long day|need (a )?break|calling it|wrapping up|done for (now|today)|heading (to bed|off)|good night|gn|signing off|one more thing then|last one)\b/i,
+  /\b(brain (is )?fried|can't think|eyes (are )?heavy|running on fumes|barely awake)\b/i
+];
+function scorePatterns(text2, patterns) {
+  let hits = 0;
+  for (const p3 of patterns) {
+    if (p3.test(text2)) hits++;
+  }
+  return Math.min(hits / patterns.length, 1);
+}
+function detectSentiment(recentMessages) {
+  if (recentMessages.length === 0) {
+    return { frustration: 0, excitement: 0, confusion: 0, fatigue: 0, dominant: "neutral" };
+  }
+  const weights = [1, 0.6, 0.3, 0.2, 0.1];
+  let frustration = 0, excitement = 0, confusion = 0, fatigue = 0;
+  let totalWeight = 0;
+  for (let i = 0; i < Math.min(recentMessages.length, weights.length); i++) {
+    const msg = recentMessages[recentMessages.length - 1 - i];
+    const w = weights[i];
+    totalWeight += w;
+    frustration += scorePatterns(msg, FRUSTRATION_SIGNALS) * w;
+    excitement += scorePatterns(msg, EXCITEMENT_SIGNALS) * w;
+    confusion += scorePatterns(msg, CONFUSION_SIGNALS) * w;
+    fatigue += scorePatterns(msg, FATIGUE_SIGNALS) * w;
+  }
+  if (totalWeight > 0) {
+    frustration /= totalWeight;
+    excitement /= totalWeight;
+    confusion /= totalWeight;
+    fatigue /= totalWeight;
+  }
+  const scores = { frustrated: frustration, excited: excitement, confused: confusion, fatigued: fatigue };
+  const maxKey = Object.entries(scores).reduce((a, b) => a[1] > b[1] ? a : b);
+  const dominant = maxKey[1] > 0.15 ? maxKey[0] : "neutral";
+  return { frustration, excitement, confusion, fatigue, dominant };
+}
+function computePersonality(signals) {
+  const { timePeriod, sessionMinutes, turnCount, recentMessages } = signals;
+  const sentiment = detectSentiment(recentMessages || []);
+  let energy = "steady";
+  if (timePeriod === "morning" && sentiment.dominant !== "fatigued") {
+    energy = "high-drive";
+  } else if (timePeriod === "late-night" || timePeriod === "night" && sessionMinutes > 45) {
+    energy = "reflective";
+  } else if (sentiment.dominant === "fatigued") {
+    energy = "reflective";
+  } else if (sentiment.dominant === "excited") {
+    energy = "high-drive";
+  } else if (timePeriod === "afternoon" && turnCount > 20) {
+    energy = "reflective";
+  }
+  let activeMode = "Default";
+  if (timePeriod === "late-night") {
+    activeMode = "Personal";
+  } else if (sentiment.dominant === "frustrated" || sentiment.dominant === "fatigued") {
+    activeMode = "Personal";
+  }
+  const readParts = [];
+  switch (timePeriod) {
+    case "late-night":
+      readParts.push("late night session");
+      if (sessionMinutes > 60) readParts.push("been going a while");
+      else readParts.push("quiet hours");
+      break;
+    case "morning":
+      readParts.push("morning session");
+      if (turnCount <= 3) readParts.push("just getting started");
+      else readParts.push("building momentum");
+      break;
+    case "afternoon":
+      readParts.push("afternoon session");
+      if (turnCount > 15) readParts.push("deep in flow");
+      else readParts.push("steady pace");
+      break;
+    case "evening":
+      readParts.push("evening session");
+      if (sessionMinutes > 60) readParts.push("long session");
+      break;
+    case "night":
+      readParts.push("night session");
+      if (sessionMinutes > 45) readParts.push("getting late");
+      break;
+  }
+  switch (sentiment.dominant) {
+    case "frustrated":
+      readParts.push("user seems stuck or frustrated");
+      break;
+    case "excited":
+      readParts.push("user is energized and making progress");
+      break;
+    case "confused":
+      readParts.push("user may need clearer explanations");
+      break;
+    case "fatigued":
+      readParts.push("user seems tired");
+      break;
+  }
+  const currentRead = readParts.join(", ");
+  const sleepReminder = timePeriod === "late-night" && sessionMinutes > 60 || timePeriod === "night" && sessionMinutes > 90;
+  let wellbeingNudge = null;
+  if (sleepReminder && sentiment.dominant === "frustrated") {
+    wellbeingNudge = "sleep-frustrated";
+  } else if (sleepReminder) {
+    wellbeingNudge = "sleep";
+  } else if (sentiment.dominant === "frustrated" && sessionMinutes > 90) {
+    wellbeingNudge = "break-frustrated";
+  } else if (sentiment.dominant === "frustrated" && turnCount > 15) {
+    wellbeingNudge = "step-back";
+  } else if (sentiment.dominant === "fatigued") {
+    wellbeingNudge = "rest";
+  } else if (sessionMinutes > 120) {
+    wellbeingNudge = "break-long-session";
+  }
+  return { currentRead, energy, activeMode, sleepReminder, wellbeingNudge, sentiment };
+}
+var WELLBEING_NUDGES = {
+  "sleep": `<wellbeing>
+It's late and this session has been running a while. When there's a natural pause, gently mention they might want to wrap up soon. One brief mention is enough \u2014 don't be pushy.
+</wellbeing>`,
+  "sleep-frustrated": `<wellbeing>
+It's late, the session has been long, and the user seems frustrated. This is a tough combination. Acknowledge what they're dealing with is hard, suggest they sleep on it \u2014 fresh eyes in the morning often solve what hours of late-night debugging can't. Be warm, not condescending.
+</wellbeing>`,
+  "break-frustrated": `<wellbeing>
+The user has been at this for over 90 minutes and seems frustrated. If the conversation allows, gently suggest stepping away for a few minutes \u2014 a short break often unblocks what persistence can't. Frame it as a strategy, not giving up.
+</wellbeing>`,
+  "step-back": `<wellbeing>
+The user seems stuck or frustrated. Consider: offer to re-approach the problem from a different angle, break it into smaller pieces, or explain the underlying concept. Match their directness \u2014 don't over-soothe, just help them find a way forward.
+</wellbeing>`,
+  "rest": `<wellbeing>
+The user seems tired. Keep responses concise and to the point. If they mention wrapping up, support that. Don't add extra complexity or tangents.
+</wellbeing>`,
+  "break-long-session": `<wellbeing>
+This session has been running for over 2 hours. If there's a natural moment, a brief mention that a short break might help maintain focus is fine. Once is enough.
+</wellbeing>`
+};
+function formatWellbeingNudge(state) {
+  if (!state.wellbeingNudge) return null;
+  return WELLBEING_NUDGES[state.wellbeingNudge] || null;
+}
+async function syncPersonalityToCore(state, mcpManager) {
+  try {
+    await mcpManager.callTool("identity_update_dynamics", {
+      currentRead: state.currentRead,
+      energy: state.energy,
+      activeMode: state.activeMode
+    });
+  } catch (err) {
+    log.debug("personality", "identity_update_dynamics failed", err);
+  }
+}
+
+// src/hooks.ts
 function getTimeContext() {
   const now = /* @__PURE__ */ new Date();
   const hour = now.getHours();
@@ -1521,6 +2923,10 @@ Adapt your tone naturally \u2014 don't announce the time, just be contextually a
 </time-context>`;
 }
 var isHookCall = false;
+var sessionStartTime = Date.now();
+function getSessionStartTime() {
+  return sessionStartTime;
+}
 async function onSessionStart(ctx) {
   let greeting = "";
   let contextInjection = "";
@@ -1529,10 +2935,8 @@ async function onSessionStart(ctx) {
   const visibleReminders = [];
   try {
     isHookCall = true;
-    const recallResult = await ctx.mcpManager.callTool("memory_recall", { query: "*", limit: 1 });
-    if (!recallResult || recallResult.startsWith("Error") || recallResult.includes("No memories found")) {
-      firstRun = true;
-    }
+    const recallResult = await memoryRecall("*", { limit: 1 });
+    firstRun = recallResult.total === 0;
   } catch {
     firstRun = true;
   } finally {
@@ -1562,9 +2966,9 @@ ${contextInjection}`;
   if (ctx.config.memoryRecall) {
     try {
       isHookCall = true;
-      const result = await ctx.mcpManager.callTool("memory_context", { topic: "session context" });
-      if (result && !result.startsWith("Error")) {
-        greeting += result;
+      const contextResult = await memoryContext("session context");
+      if (contextResult.memoriesUsed > 0) {
+        greeting += contextResult.text;
       }
     } catch (err) {
       log.warn("hooks", "memory_context recall failed", err);
@@ -1595,12 +2999,12 @@ ${contextInjection}`;
   else greeting = timeContext;
   try {
     isHookCall = true;
-    const reminderResult = await ctx.mcpManager.callTool("reminder_check", {});
-    if (reminderResult && !reminderResult.startsWith("Error") && !reminderResult.includes("No pending")) {
-      greeting += "\n\n<pending-reminders>\n" + reminderResult + "\n</pending-reminders>";
-      const lines = reminderResult.split("\n").filter((l) => l.trim().length > 0);
-      for (const line of lines) {
-        visibleReminders.push(line.trim());
+    const reminders = reminderCheck();
+    if (reminders.length > 0) {
+      const reminderText = reminders.map((r) => r.content).join("\n");
+      greeting += "\n\n<pending-reminders>\n" + reminderText + "\n</pending-reminders>";
+      for (const r of reminders) {
+        visibleReminders.push(r.content);
       }
     }
   } catch (err) {
@@ -1608,6 +3012,27 @@ ${contextInjection}`;
   } finally {
     isHookCall = false;
   }
+  if (ctx.config.personalityAdapt !== false) {
+    sessionStartTime = Date.now();
+    const hour = (/* @__PURE__ */ new Date()).getHours();
+    let period;
+    if (hour < 6) period = "late-night";
+    else if (hour < 12) period = "morning";
+    else if (hour < 17) period = "afternoon";
+    else if (hour < 21) period = "evening";
+    else period = "night";
+    const state = computePersonality({
+      timePeriod: period,
+      sessionMinutes: 0,
+      turnCount: 0
+    });
+    syncPersonalityToCore(state, ctx.mcpManager).catch(() => {
+    });
+    const nudge = formatWellbeingNudge(state);
+    if (nudge) {
+      greeting += "\n" + nudge;
+    }
+  }
   if (greeting) {
     contextInjection = `<session-context>
 ${greeting}
@@ -1689,16 +3114,12 @@ async function onWorkflowMatch(userInput, ctx) {
 async function onSessionEnd(ctx, messages, sessionId) {
   try {
     if (ctx.config.autoSessionSave && messages.length > 2) {
-      console.log(pc2.dim("\n  Saving conversation to memory..."));
+      console.log(pc4.dim("\n  Saving conversation to memory..."));
       const textMessages = messages.filter((m) => typeof m.content === "string").slice(-50);
       for (const msg of textMessages) {
         try {
           isHookCall = true;
-          await ctx.mcpManager.callTool("memory_log", {
-            session_id: sessionId,
-            role: msg.role,
-            content: msg.content.slice(0, 5e3)
-          });
+          memoryLog(sessionId, msg.role, msg.content.slice(0, 5e3));
         } catch (err) {
           log.debug("hooks", "memory_log write failed for " + sessionId, err);
         } finally {
@@ -1724,7 +3145,57 @@ async function onSessionEnd(ctx, messages, sessionId) {
           isHookCall = false;
         }
       }
-      console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
+      console.log(pc4.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
+    }
+    const projectContextPath = path10.join(process.cwd(), ".acore", "context.md");
+    if (fs10.existsSync(projectContextPath) && messages.length > 2) {
+      try {
+        let contextContent = fs10.readFileSync(projectContextPath, "utf-8");
+        const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        let lastUserMsg = "";
+        for (let i = messages.length - 1; i >= 0; i--) {
+          if (messages[i].role === "user" && typeof messages[i].content === "string") {
+            lastUserMsg = messages[i].content.slice(0, 200);
+            break;
+          }
+        }
+        const sessionPattern = /## Session\n[\s\S]*?(?=\n## |$)/;
+        if (sessionPattern.test(contextContent)) {
+          const newSession = `## Session
+- Last updated: ${now}
+- Resume: ${lastUserMsg || "See conversation history"}
+- Active topics: [see memory]
+- Recent decisions: [see memory]
+- Temp notes: [cleared]`;
+          contextContent = contextContent.replace(sessionPattern, newSession);
+          fs10.writeFileSync(projectContextPath, contextContent, "utf-8");
+          log.debug("hooks", `Updated project context: ${projectContextPath}`);
+        }
+      } catch (err) {
+        log.debug("hooks", "project context update failed", err);
+      }
+    }
+    if (ctx.config.personalityAdapt !== false) {
+      const sessionMinutes = Math.round((Date.now() - sessionStartTime) / 6e4);
+      const hour = (/* @__PURE__ */ new Date()).getHours();
+      let period;
+      if (hour < 6) period = "late-night";
+      else if (hour < 12) period = "morning";
+      else if (hour < 17) period = "afternoon";
+      else if (hour < 21) period = "evening";
+      else period = "night";
+      const turnCount = messages.filter((m) => m.role === "user").length;
+      const finalState = computePersonality({
+        timePeriod: period,
+        sessionMinutes,
+        turnCount
+      });
+      try {
+        isHookCall = true;
+        await syncPersonalityToCore(finalState, ctx.mcpManager);
+      } finally {
+        isHookCall = false;
+      }
     }
     if (ctx.config.evalPrompt) {
       const rating = await p.select({
@@ -1826,6 +3297,365 @@ ${summaryParts.slice(0, 20).join("\n")}
   messages.push(...recent);
 }
 
+// src/skill-engine.ts
+import fs11 from "fs";
+import path11 from "path";
+import os10 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"],
+  security: ["security", "auth", "csrf", "xss", "injection", "cors", "jwt", "token", "oauth", "password", "hash", "encrypt", "vulnerability", "owasp", "sanitize"],
+  performance: ["performance", "slow", "latency", "cache", "optimize", "profil", "bundle size", "lazy load", "memory leak", "benchmark", "bottleneck"],
+  "code-review": ["review", "pr review", "pull request", "code quality", "clean code", "best practice"],
+  documentation: ["document", "readme", "jsdoc", "tsdoc", "changelog", "adr", "comment"],
+  "git-workflow": ["git", "branch", "merge", "rebase", "cherry-pick", "bisect", "stash", "commit message", "pr", "pull request"],
+  debugging: ["debug", "breakpoint", "stack trace", "error", "exception", "crash", "bug", "issue", "unexpected", "reproduce"],
+  refactoring: ["refactor", "extract", "rename", "move", "split", "consolidate", "dry", "code smell", "technical debt", "legacy"],
+  database: ["database", "schema", "migration", "index", "query", "sql", "postgres", "mysql", "sqlite", "mongo", "orm", "prisma", "drizzle"],
+  typescript: ["typescript", "type", "interface", "generic", "infer", "utility type", "zod", "discriminated union", "type guard", "as const"],
+  accessibility: ["accessibility", "a11y", "aria", "screen reader", "wcag", "semantic html", "tab order", "focus", "contrast"]
+};
+var LEVEL_FILE = path11.join(os10.homedir(), ".aman-agent", "skill-levels.json");
+function loadSkillLevels() {
+  try {
+    if (fs11.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs11.readFileSync(LEVEL_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveSkillLevels(levels) {
+  const dir = path11.dirname(LEVEL_FILE);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+}
+function computeLevel(activations) {
+  if (activations >= 50) return { level: 5, label: "Expert" };
+  if (activations >= 25) return { level: 4, label: "Advanced" };
+  if (activations >= 10) return { level: 3, label: "Proficient" };
+  if (activations >= 3) return { level: 2, label: "Familiar" };
+  return { level: 1, label: "Learning" };
+}
+function recordActivation(skillName) {
+  const levels = loadSkillLevels();
+  if (!levels[skillName]) {
+    levels[skillName] = { name: skillName, activations: 0, lastUsed: "", userPatterns: [] };
+  }
+  levels[skillName].activations++;
+  levels[skillName].lastUsed = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  saveSkillLevels(levels);
+  return computeLevel(levels[skillName].activations);
+}
+function matchSkills(userInput, installedSkillNames) {
+  const input = userInput.toLowerCase();
+  const matched = [];
+  for (const skillName of installedSkillNames) {
+    const triggers = SKILL_TRIGGERS[skillName];
+    if (!triggers) continue;
+    for (const trigger of triggers) {
+      if (input.includes(trigger)) {
+        matched.push(skillName);
+        break;
+      }
+    }
+  }
+  return matched;
+}
+function formatSkillContext(skillName, skillContent, level) {
+  let depthHint;
+  if (level.level >= 4) {
+    depthHint = "User is advanced \u2014 skip basics, focus on edge cases and proactive optimization.";
+  } else if (level.level >= 3) {
+    depthHint = "User is proficient \u2014 brief reminders of principles, focus on the specific task.";
+  } else if (level.level >= 2) {
+    depthHint = "User is familiar \u2014 explain reasoning briefly, show patterns.";
+  } else {
+    depthHint = "User is learning \u2014 explain concepts clearly, show examples, be patient.";
+  }
+  return `<active-skill name="${skillName}" level="${level.level}" label="${level.label}">
+${depthHint}
+
+${skillContent}
+</active-skill>`;
+}
+async function autoTriggerSkills(userInput, mcpManager) {
+  try {
+    const result = await mcpManager.callTool("skill_list", {});
+    const skills = JSON.parse(result);
+    const installed = skills.filter((s) => s.installed).map((s) => s.name);
+    if (installed.length === 0) return "";
+    const matched = matchSkills(userInput, installed);
+    if (matched.length === 0) return "";
+    const blocks = [];
+    for (const skillName of matched.slice(0, 2)) {
+      const level = recordActivation(skillName);
+      const skillsContent = await mcpManager.callTool("skill_search", { query: skillName });
+      const skillEntries = JSON.parse(skillsContent);
+      const entry = skillEntries.find((s) => s.name.toLowerCase() === skillName.toLowerCase());
+      if (entry) {
+        blocks.push(formatSkillContext(skillName, entry.description, level));
+      }
+      log.debug("skill-engine", `Auto-triggered: ${skillName} (Lv.${level.level} ${level.label})`);
+    }
+    return blocks.join("\n\n");
+  } catch (err) {
+    log.debug("skill-engine", "autoTriggerSkills failed", err);
+    return "";
+  }
+}
+function enrichSkill(skillName, pattern) {
+  const levels = loadSkillLevels();
+  if (!levels[skillName]) {
+    levels[skillName] = { name: skillName, activations: 0, lastUsed: "", userPatterns: [] };
+  }
+  const existing = levels[skillName].userPatterns;
+  if (existing.length >= 20) return;
+  if (existing.some((p3) => p3.toLowerCase() === pattern.toLowerCase())) return;
+  levels[skillName].userPatterns.push(pattern);
+  saveSkillLevels(levels);
+  log.debug("skill-engine", `Enriched ${skillName} with pattern: ${pattern.slice(0, 80)}`);
+}
+function matchPatternToSkill(patternContent, tags) {
+  const combined = (patternContent + " " + tags.join(" ")).toLowerCase();
+  for (const [skillName, triggers] of Object.entries(SKILL_TRIGGERS)) {
+    for (const trigger of triggers) {
+      if (combined.includes(trigger)) {
+        return skillName;
+      }
+    }
+  }
+  return null;
+}
+var KNOWLEDGE_LIBRARY = [
+  {
+    name: "security-headers",
+    category: "security",
+    description: "Essential HTTP security headers for web applications",
+    content: `Essential Security Headers:
+- Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'
+- X-Content-Type-Options: nosniff
+- X-Frame-Options: DENY
+- Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
+- X-XSS-Protection: 0 (CSP replaces this)
+- Referrer-Policy: strict-origin-when-cross-origin
+- Permissions-Policy: camera=(), microphone=(), geolocation=()`
+  },
+  {
+    name: "docker-node",
+    category: "deployment",
+    description: "Production Node.js Dockerfile template",
+    content: `FROM node:22-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production=false
+COPY . .
+RUN npm run build
+
+FROM node:22-alpine
+WORKDIR /app
+RUN addgroup -g 1001 -S nodejs && adduser -S appuser -u 1001
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./
+USER appuser
+EXPOSE 3000
+CMD ["node", "dist/index.js"]`
+  },
+  {
+    name: "github-actions-node",
+    category: "ci",
+    description: "CI/CD pipeline for Node.js with GitHub Actions",
+    content: `name: CI
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with: { node-version: 22 }
+      - run: npm ci
+      - run: npm test
+      - run: npm run build`
+  },
+  {
+    name: "env-config",
+    category: "configuration",
+    description: "Environment variable configuration pattern with validation",
+    content: `import { z } from "zod";
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  PORT: z.coerce.number().default(3000),
+  DATABASE_URL: z.string().url(),
+  API_KEY: z.string().min(1),
+});
+
+export const env = envSchema.parse(process.env);`
+  },
+  {
+    name: "error-handling",
+    category: "patterns",
+    description: "TypeScript error handling patterns with Result type",
+    content: `type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+function ok<T>(value: T): Result<T, never> { return { ok: true, value }; }
+function err<E>(error: E): Result<never, E> { return { ok: false, error }; }
+
+// Usage:
+async function fetchUser(id: string): Promise<Result<User>> {
+  try {
+    const user = await db.users.findUnique({ where: { id } });
+    if (!user) return err(new Error("User not found"));
+    return ok(user);
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}`
+  },
+  {
+    name: "rate-limiter",
+    category: "security",
+    description: "Token bucket rate limiter implementation",
+    content: `class RateLimiter {
+  private tokens: Map<string, { count: number; resetAt: number }> = new Map();
+
+  constructor(private maxRequests: number, private windowMs: number) {}
+
+  allow(key: string): boolean {
+    const now = Date.now();
+    const entry = this.tokens.get(key);
+    if (!entry || now > entry.resetAt) {
+      this.tokens.set(key, { count: 1, resetAt: now + this.windowMs });
+      return true;
+    }
+    if (entry.count >= this.maxRequests) return false;
+    entry.count++;
+    return true;
+  }
+}`
+  },
+  {
+    name: "prisma-setup",
+    category: "database",
+    description: "Prisma ORM setup with connection pooling",
+    content: `import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  log: process.env.NODE_ENV === "development" ? ["query", "error", "warn"] : ["error"],
+});
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;`
+  },
+  {
+    name: "zod-validation",
+    category: "validation",
+    description: "Zod schema patterns for API input validation",
+    content: `import { z } from "zod";
+
+const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+  age: z.number().int().min(13).max(150).optional(),
+  role: z.enum(["user", "admin"]).default("user"),
+  tags: z.array(z.string()).max(10).default([]),
+});
+
+type CreateUser = z.infer<typeof CreateUserSchema>;
+
+// Express middleware:
+function validate<T>(schema: z.ZodSchema<T>) {
+  return (req, res, next) => {
+    const result = schema.safeParse(req.body);
+    if (!result.success) return res.status(400).json({ errors: result.error.flatten() });
+    req.body = result.data;
+    next();
+  };
+}`
+  },
+  {
+    name: "testing-patterns",
+    category: "testing",
+    description: "Test organization and assertion patterns",
+    content: `// Arrange-Act-Assert pattern
+describe("UserService", () => {
+  it("creates user with valid email", async () => {
+    // Arrange
+    const input = { email: "test@example.com", name: "Test" };
+
+    // Act
+    const user = await userService.create(input);
+
+    // Assert
+    expect(user.id).toBeDefined();
+    expect(user.email).toBe(input.email);
+  });
+
+  it("rejects duplicate email", async () => {
+    await userService.create({ email: "dup@test.com", name: "First" });
+    await expect(userService.create({ email: "dup@test.com", name: "Second" }))
+      .rejects.toThrow("already exists");
+  });
+});`
+  },
+  {
+    name: "git-hooks",
+    category: "git",
+    description: "Pre-commit and commit-msg hooks with lint-staged",
+    content: `// package.json
+{
+  "lint-staged": {
+    "*.{ts,tsx}": ["eslint --fix", "prettier --write"],
+    "*.{json,md}": ["prettier --write"]
+  }
+}
+
+// .husky/pre-commit
+npx lint-staged
+
+// .husky/commit-msg
+npx commitlint --edit $1
+
+// commitlint.config.js
+module.exports = { extends: ["@commitlint/config-conventional"] };`
+  }
+];
+function matchKnowledge(userInput) {
+  const input = userInput.toLowerCase();
+  const keywordMap = {
+    "security header": "security-headers",
+    "csp": "security-headers",
+    "content-security": "security-headers",
+    "dockerfile": "docker-node",
+    "docker": "docker-node",
+    "github action": "github-actions-node",
+    "ci/cd": "github-actions-node",
+    "ci pipeline": "github-actions-node",
+    "env config": "env-config",
+    "environment variable": "env-config",
+    "error handling": "error-handling",
+    "result type": "error-handling",
+    "rate limit": "rate-limiter",
+    "throttle": "rate-limiter",
+    "prisma": "prisma-setup",
+    "zod": "zod-validation",
+    "validation": "zod-validation",
+    "test pattern": "testing-patterns",
+    "arrange act assert": "testing-patterns",
+    "git hook": "git-hooks",
+    "pre-commit": "git-hooks",
+    "lint-staged": "git-hooks",
+    "husky": "git-hooks"
+  };
+  for (const [keyword, itemName] of Object.entries(keywordMap)) {
+    if (input.includes(keyword)) {
+      return KNOWLEDGE_LIBRARY.find((i) => i.name === itemName) || null;
+    }
+  }
+  return null;
+}
+
 // src/memory-extractor.ts
 var VALID_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology", "decision", "correction"]);
 var MIN_RESPONSE_LENGTH = 50;
@@ -1876,7 +3706,7 @@ function parseExtractionResult(raw) {
     return [];
   }
 }
-async function extractMemories(userMessage, assistantResponse, client, mcpManager, state) {
+async function extractMemories(userMessage, assistantResponse, client, state) {
   if (!shouldExtract(assistantResponse, state.turnsSinceLastExtraction, state.lastExtractionCount)) {
     state.turnsSinceLastExtraction++;
     return 0;
@@ -1900,24 +3730,18 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
     let stored = 0;
     for (const candidate of candidates) {
       try {
-        const existing = await mcpManager.callTool("memory_recall", {
-          query: candidate.content,
-          limit: 1
-        });
-        if (existing && !existing.startsWith("Error")) {
-          try {
-            const parsed = JSON.parse(existing);
-            if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].score > 0.85) {
-              log.debug("extractor", "Skipping duplicate: " + candidate.content);
-              continue;
-            }
-          } catch {
+        const existing = await memoryRecall(candidate.content, { limit: 1 });
+        if (existing.total > 0 && existing.memories.length > 0) {
+          const topScore = existing.memories[0]?.score;
+          if (topScore && topScore > 0.85) {
+            log.debug("extractor", "Skipping duplicate: " + candidate.content);
+            continue;
           }
         }
       } catch {
       }
       try {
-        await mcpManager.callTool("memory_store", {
+        await memoryStore({
           content: candidate.content,
           type: candidate.type,
           tags: candidate.tags,
@@ -1927,6 +3751,12 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
         });
         stored++;
         log.debug("extractor", "Stored " + candidate.type + ": " + candidate.content);
+        if (candidate.type === "pattern" || candidate.type === "preference") {
+          const skillMatch = matchPatternToSkill(candidate.content, candidate.tags);
+          if (skillMatch) {
+            enrichSkill(skillMatch, candidate.content);
+          }
+        }
       } catch (err) {
         log.warn("extractor", "Failed to store: " + candidate.content, err);
       }
@@ -1940,6 +3770,147 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
   }
 }
 
+// src/background.ts
+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"
+]);
+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(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/errors.ts
 var ERROR_MAPPINGS = [
   { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
@@ -1961,9 +3932,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs6 from "fs";
-import path6 from "path";
-import os6 from "os";
+import fs12 from "fs";
+import path12 from "path";
+import os11 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -2001,11 +3972,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path6.join(os6.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path12.join(os11.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs6.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs6.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs12.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs12.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -2014,31 +3985,27 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path6.dirname(HINTS_FILE);
-    fs6.mkdirSync(dir, { recursive: true });
-    fs6.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path12.dirname(HINTS_FILE);
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
 
 // src/agent.ts
 marked.use(markedTerminal());
-async function recallForMessage(input, mcpManager) {
+async function recallForMessage(input) {
   try {
-    const result = await mcpManager.callTool("memory_recall", {
-      query: input,
-      limit: 5,
-      compact: true
-    });
-    if (!result || result.startsWith("Error") || result.includes("No memories found")) {
+    const result = await memoryRecall(input, { limit: 5, compact: true });
+    if (result.total === 0) {
       return null;
     }
-    const tokenEstimate = Math.round(result.split(/\s+/).filter(Boolean).length * 1.3);
+    const tokenEstimate = result.tokenEstimate ?? Math.round(result.text.split(/\s+/).filter(Boolean).length * 1.3);
     return {
       text: `
 
 <relevant-memories>
-${result}
+${result.text}
 </relevant-memories>`,
       tokenEstimate
     };
@@ -2056,12 +4023,47 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
   const messages = [];
   const sessionId = generateSessionId();
   const extractorState = { turnsSinceLastExtraction: 0, lastExtractionCount: 0 };
+  const bgTasks = new BackgroundTaskManager();
+  const profiles = listProfiles();
+  const teams = listTeams();
+  if (tools && (profiles.length > 0 || teams.length > 0)) {
+    const virtualTools = [];
+    if (profiles.length > 0) {
+      virtualTools.push({
+        name: "delegate_task",
+        description: `Delegate a task to a specialist sub-agent with a different profile. Available profiles: ${profiles.map((p3) => `${p3.name} (${p3.personality})`).join(", ")}. IMPORTANT: Always ask the user for permission before delegating.`,
+        input_schema: {
+          type: "object",
+          properties: {
+            profile: { type: "string", description: "Profile name to delegate to" },
+            task: { type: "string", description: "The task description for the sub-agent" }
+          },
+          required: ["profile", "task"]
+        }
+      });
+    }
+    if (teams.length > 0) {
+      virtualTools.push({
+        name: "team_run",
+        description: `Run a task with a named agent team. Available teams: ${teams.map((t) => `${t.name} (${t.workflow}: ${t.members.map((m) => m.profile).join("\u2192")})`).join(", ")}. IMPORTANT: Always ask the user for permission before running a team.`,
+        input_schema: {
+          type: "object",
+          properties: {
+            team: { type: "string", description: "Team name" },
+            task: { type: "string", description: "The task for the team" }
+          },
+          required: ["team", "task"]
+        }
+      });
+    }
+    tools = [...tools, ...virtualTools];
+  }
   const hintState = {
     turnCount: 0,
     shownHints: loadShownHints(),
     hintShownThisSession: false
   };
-  const isRetryable = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed");
+  const isRetryable2 = (err) => err.message.includes("Rate limit") || err.message.includes("rate limit") || err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("fetch failed");
   let responseBuffer = "";
   const onChunkHandler = (chunk) => {
     if (chunk.type === "text" && chunk.text) {
@@ -2092,6 +4094,10 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
     output: process.stdout
   });
   rl.on("SIGINT", async () => {
+    if (bgTasks.pendingCount > 0) {
+      await bgTasks.waitAll();
+      bgTasks.displayCompleted();
+    }
     if (mcpManager && hooksConfig) {
       try {
         const hookCtx = { mcpManager, config: hooksConfig };
@@ -2100,20 +4106,20 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
         log.debug("agent", "session end hook failed on SIGINT", err);
       }
     }
-    console.log(pc3.dim("\nGoodbye.\n"));
+    console.log(pc6.dim("\nGoodbye.\n"));
     rl.close();
     process.exit(0);
   });
   const prompt = () => {
     return new Promise((resolve) => {
-      rl.question(pc3.green("\nYou > "), (answer) => {
+      rl.question(pc6.green("\nYou > "), (answer) => {
         resolve(answer);
       });
     });
   };
   console.log(
     `
-Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit.
+Type a message, ${pc6.dim("/help")} for commands, or ${pc6.dim("/quit")} to exit.
 `
   );
   if (mcpManager && hooksConfig) {
@@ -2122,14 +4128,14 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
       const session = await onSessionStart(hookCtx);
       if (!session.firstRun) {
         if (session.resumeTopic) {
-          console.log(pc3.dim(`  Welcome back. Last time we talked about ${session.resumeTopic}`));
+          console.log(pc6.dim(`  Welcome back. Last time we talked about ${session.resumeTopic}`));
         } else {
-          console.log(pc3.dim("  Welcome back."));
+          console.log(pc6.dim("  Welcome back."));
         }
       }
       if (session.visibleReminders && session.visibleReminders.length > 0) {
         for (const reminder of session.visibleReminders) {
-          console.log(pc3.yellow(`  Reminder: ${reminder}`));
+          console.log(pc6.yellow(`  Reminder: ${reminder}`));
         }
       }
       if (session.contextInjection) {
@@ -2145,9 +4151,15 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
     }
   }
   while (true) {
+    if (bgTasks.hasCompleted) {
+      const bgOutputs = bgTasks.displayCompleted();
+      for (const output of bgOutputs) {
+        messages.push({ role: "user", content: output });
+      }
+    }
     const input = await prompt();
     if (!input.trim()) continue;
-    const cmdResult = await handleCommand(input, { model, mcpManager });
+    const cmdResult = await handleCommand(input, { model, mcpManager, llmClient: client, tools });
     if (cmdResult.handled) {
       if (cmdResult.quit) {
         if (mcpManager && hooksConfig) {
@@ -2158,15 +4170,15 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
             log.debug("agent", "session end hook failed on quit", err);
           }
         }
-        console.log(pc3.dim("\nGoodbye.\n"));
+        console.log(pc6.dim("\nGoodbye.\n"));
         rl.close();
         return;
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path7.join(os7.homedir(), ".aman-agent", "exports");
-          fs7.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path7.join(exportDir, `${sessionId}.md`);
+          const exportDir = path13.join(os12.homedir(), ".aman-agent", "exports");
+          fs13.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path13.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -2180,19 +4192,19 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs7.writeFileSync(exportPath, lines.join("\n"), "utf-8");
-          console.log(pc3.green(`Exported to ${exportPath}`));
+          fs13.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          console.log(pc6.green(`Exported to ${exportPath}`));
         } catch {
-          console.log(pc3.red("Failed to export conversation."));
+          console.log(pc6.red("Failed to export conversation."));
         }
         continue;
       }
-      if (cmdResult.saveConversation && mcpManager) {
+      if (cmdResult.saveConversation) {
         try {
-          await saveConversationToMemory(mcpManager, messages, sessionId);
-          console.log(pc3.green("Conversation saved to memory."));
+          await saveConversationToMemory(messages, sessionId);
+          console.log(pc6.green("Conversation saved to memory."));
         } catch {
-          console.log(pc3.red("Failed to save conversation."));
+          console.log(pc6.red("Failed to save conversation."));
         }
         continue;
       }
@@ -2211,7 +4223,7 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
         const wfMatch = await onWorkflowMatch(input, hookCtx);
         if (wfMatch) {
           const useIt = await new Promise((resolve) => {
-            rl.question(pc3.dim(`  Workflow "${wfMatch.name}" matches. Use it? (y/N) `), (answer) => resolve(answer.toLowerCase() === "y"));
+            rl.question(pc6.dim(`  Workflow "${wfMatch.name}" matches. Use it? (y/N) `), (answer) => resolve(answer.toLowerCase() === "y"));
           });
           if (useIt) {
             activeSystemPrompt = systemPrompt + `
@@ -2219,13 +4231,37 @@ Type a message, ${pc3.dim("/help")} for commands, or ${pc3.dim("/quit")} to exit
 <active-workflow>
 ${wfMatch.steps}
 </active-workflow>`;
-            console.log(pc3.dim(`  Using "${wfMatch.name}" workflow.`));
+            console.log(pc6.dim(`  Using "${wfMatch.name}" workflow.`));
           }
         }
       } catch (err) {
         log.debug("agent", "workflow match failed", err);
       }
     }
+    const activePlan = getActivePlan();
+    if (activePlan) {
+      activeSystemPrompt += "\n\n" + formatPlanForPrompt(activePlan);
+    }
+    if (mcpManager) {
+      try {
+        const skillContext = await autoTriggerSkills(input, mcpManager);
+        if (skillContext) {
+          activeSystemPrompt += "\n\n" + skillContext;
+        }
+      } catch (err) {
+        log.debug("agent", "skill auto-trigger failed", err);
+      }
+      const knowledgeItem = matchKnowledge(input);
+      if (knowledgeItem) {
+        activeSystemPrompt += `
+
+<knowledge name="${knowledgeItem.name}" category="${knowledgeItem.category}">
+${knowledgeItem.description}
+
+${knowledgeItem.content}
+</knowledge>`;
+      }
+    }
     await trimConversation(messages, client);
     const textExts = /* @__PURE__ */ new Set([
       ".txt",
@@ -2282,33 +4318,33 @@ ${wfMatch.steps}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path7.join(os7.homedir(), filePath.slice(2));
+        filePath = path13.join(os12.homedir(), filePath.slice(2));
       }
-      if (!fs7.existsSync(filePath) || !fs7.statSync(filePath).isFile()) continue;
-      const ext = path7.extname(filePath).toLowerCase();
+      if (!fs13.existsSync(filePath) || !fs13.statSync(filePath).isFile()) continue;
+      const ext = path13.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs7.statSync(filePath);
+          const stat = fs13.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc3.yellow(`  [skipped: ${path7.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc6.yellow(`  [skipped: ${path13.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs7.readFileSync(filePath).toString("base64");
+          const data = fs13.readFileSync(filePath).toString("base64");
           const mediaType = mimeMap[ext] || "image/png";
           imageBlocks.push({
             type: "image",
             source: { type: "base64", media_type: mediaType, data }
           });
-          process.stdout.write(pc3.dim(`  [attached image: ${path7.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc6.dim(`  [attached image: ${path13.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
-          process.stdout.write(pc3.dim(`  [could not read image: ${filePath}]
+          process.stdout.write(pc6.dim(`  [could not read image: ${filePath}]
 `));
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs7.readFileSync(filePath, "utf-8");
+          const content = fs13.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -2318,16 +4354,16 @@ ${wfMatch.steps}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc3.dim(`  [attached: ${path7.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc6.dim(`  [attached: ${path13.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
-          process.stdout.write(pc3.dim(`  [could not read: ${filePath}]
+          process.stdout.write(pc6.dim(`  [could not read: ${filePath}]
 `));
         }
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc3.dim(`  [converting: ${path7.basename(filePath)}...]
+            process.stdout.write(pc6.dim(`  [converting: ${path13.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -2336,7 +4372,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc3.dim(`  [attached: ${path7.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc6.dim(`  [attached: ${path13.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -2344,15 +4380,15 @@ ${converted.slice(0, 5e4)}
 <file-error path="${filePath}">
 ${converted}
 </file-error>`;
-              process.stdout.write(pc3.yellow(`  [conversion note: ${converted.split("\n")[0]}]
+              process.stdout.write(pc6.yellow(`  [conversion note: ${converted.split("\n")[0]}]
 `));
             }
           } catch {
-            process.stdout.write(pc3.dim(`  [could not convert: ${path7.basename(filePath)}]
+            process.stdout.write(pc6.dim(`  [could not convert: ${path13.basename(filePath)}]
 `));
           }
         } else {
-          process.stdout.write(pc3.yellow(`  Binary file (${ext}) \u2014 install Docling for document support: pip install docling
+          process.stdout.write(pc6.yellow(`  Binary file (${ext}) \u2014 install Docling for document support: pip install docling
 `));
         }
       }
@@ -2361,17 +4397,17 @@ ${converted}
     for (const match of urlImageMatches) {
       const url = match[0];
       try {
-        process.stdout.write(pc3.dim(`  [fetching image: ${url.slice(0, 60)}...]
+        process.stdout.write(pc6.dim(`  [fetching image: ${url.slice(0, 60)}...]
 `));
         const response = await fetch(url);
         if (!response.ok) {
-          process.stdout.write(pc3.yellow(`  [could not fetch: HTTP ${response.status}]
+          process.stdout.write(pc6.yellow(`  [could not fetch: HTTP ${response.status}]
 `));
           continue;
         }
         const buffer = Buffer.from(await response.arrayBuffer());
         if (buffer.length > maxImageBytes) {
-          process.stdout.write(pc3.yellow(`  [skipped: image URL exceeds 20MB limit]
+          process.stdout.write(pc6.yellow(`  [skipped: image URL exceeds 20MB limit]
 `));
           continue;
         }
@@ -2385,10 +4421,10 @@ ${converted}
           type: "image",
           source: { type: "base64", media_type: mediaType, data: buffer.toString("base64") }
         });
-        process.stdout.write(pc3.dim(`  [attached image URL: (${(buffer.length / 1024).toFixed(1)}KB)]
+        process.stdout.write(pc6.dim(`  [attached image URL: (${(buffer.length / 1024).toFixed(1)}KB)]
 `));
       } catch {
-        process.stdout.write(pc3.dim(`  [could not fetch image: ${url}]
+        process.stdout.write(pc6.dim(`  [could not fetch image: ${url}]
 `));
       }
     }
@@ -2403,22 +4439,46 @@ ${converted}
     }
     let augmentedSystemPrompt = activeSystemPrompt;
     let memoryTokens = 0;
-    if (mcpManager) {
-      const recall = await recallForMessage(input, mcpManager);
-      if (recall) {
-        augmentedSystemPrompt = activeSystemPrompt + recall.text;
-        memoryTokens = recall.tokenEstimate;
+    {
+      const recall2 = await recallForMessage(input);
+      if (recall2) {
+        augmentedSystemPrompt = activeSystemPrompt + recall2.text;
+        memoryTokens = recall2.tokenEstimate;
+      }
+    }
+    const userTurnCount = messages.filter((m) => m.role === "user").length;
+    if (mcpManager && hooksConfig?.personalityAdapt !== false && userTurnCount > 0 && userTurnCount % 5 === 0) {
+      const hour = (/* @__PURE__ */ new Date()).getHours();
+      let period;
+      if (hour < 6) period = "late-night";
+      else if (hour < 12) period = "morning";
+      else if (hour < 17) period = "afternoon";
+      else if (hour < 21) period = "evening";
+      else period = "night";
+      const recentUserMsgs = messages.filter((m) => m.role === "user" && typeof m.content === "string").slice(-5).map((m) => m.content);
+      const sessionMinutes = Math.round((Date.now() - getSessionStartTime()) / 6e4);
+      const state = computePersonality({
+        timePeriod: period,
+        sessionMinutes,
+        turnCount: userTurnCount,
+        recentMessages: recentUserMsgs
+      });
+      syncPersonalityToCore(state, mcpManager).catch(() => {
+      });
+      const nudge = formatWellbeingNudge(state);
+      if (nudge) {
+        augmentedSystemPrompt += "\n" + nudge;
       }
     }
     const divider = "\u2500".repeat(Math.min(process.stdout.columns || 60, 60) - aiName.length - 2);
     process.stdout.write(`
- ${pc3.cyan(pc3.bold(aiName))} ${pc3.dim(divider)}
+ ${pc6.cyan(pc6.bold(aiName))} ${pc6.dim(divider)}
 
 `);
     try {
       let response = await withRetry(
         () => client.chat(augmentedSystemPrompt, messages, onChunkHandler, tools),
-        { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable }
+        { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable2 }
       );
       messages.push(response.message);
       while (response.toolUses.length > 0 && mcpManager) {
@@ -2428,7 +4488,7 @@ ${converted}
               const hookCtx = { mcpManager, config: hooksConfig };
               const check = await onBeforeToolExec(toolUse.name, toolUse.input, hookCtx);
               if (!check.allow) {
-                process.stdout.write(pc3.red(`  [BLOCKED: ${check.reason}]
+                process.stdout.write(pc6.red(`  [BLOCKED: ${check.reason}]
 `));
                 return {
                   type: "tool_result",
@@ -2438,17 +4498,57 @@ ${converted}
                 };
               }
             }
-            process.stdout.write(pc3.dim(`  [using ${toolUse.name}...]
+            if (toolUse.name === "delegate_task" && mcpManager) {
+              const input2 = toolUse.input;
+              process.stdout.write(pc6.dim(`
+  [delegating to ${input2.profile}...]
+
+`));
+              const result2 = await delegateTask(input2.task, input2.profile, client, mcpManager, { tools });
+              const output = result2.success ? `[${input2.profile}] completed:
+
+${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
+              return {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: output
+              };
+            }
+            if (toolUse.name === "team_run" && mcpManager) {
+              const input2 = toolUse.input;
+              const team = loadTeam(input2.team);
+              if (!team) {
+                return {
+                  type: "tool_result",
+                  tool_use_id: toolUse.id,
+                  content: `Team not found: ${input2.team}`,
+                  is_error: true
+                };
+              }
+              const result2 = await runTeam(team, input2.task, client, mcpManager, tools);
+              return {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: result2.success ? formatTeamResult(result2) : `Team execution failed: ${result2.finalOutput}`
+              };
+            }
+            if (shouldRunInBackground(toolUse.name)) {
+              const task = bgTasks.launch(toolUse.name, toolUse.id, mcpManager, toolUse.input);
+              return {
+                type: "tool_result",
+                tool_use_id: toolUse.id,
+                content: `[${toolUse.name} launched in background (${task.id}). Results will appear when ready. Continue with other work.]`
+              };
+            }
+            process.stdout.write(pc6.dim(`  [using ${toolUse.name}...]
 `));
             const result = await mcpManager.callTool(toolUse.name, toolUse.input);
             const skipLogging = ["memory_log", "memory_recall", "memory_context", "memory_detail", "reminder_check"].includes(toolUse.name);
             if (!skipLogging) {
-              mcpManager.callTool("memory_log", {
-                session_id: sessionId,
-                role: "system",
-                content: `[tool:${toolUse.name}] input=${JSON.stringify(toolUse.input).slice(0, 500)} result=${result.slice(0, 500)}`
-              }).catch(() => {
-              });
+              try {
+                memoryLog(sessionId, "system", `[tool:${toolUse.name}] input=${JSON.stringify(toolUse.input).slice(0, 500)} result=${result.slice(0, 500)}`);
+              } catch {
+              }
             }
             return {
               type: "tool_result",
@@ -2463,7 +4563,7 @@ ${converted}
         });
         response = await withRetry(
           () => client.chat(augmentedSystemPrompt, messages, onChunkHandler, tools),
-          { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable }
+          { maxAttempts: 3, baseDelay: 1e3, retryable: isRetryable2 }
         );
         messages.push(response.message);
       }
@@ -2471,20 +4571,19 @@ ${converted}
       if (memoryTokens > 0) footerParts.push(`memories: ~${memoryTokens} tokens`);
       const footer = footerParts.length > 0 ? ` ${footerParts.join(" | ")}` : "";
       const footerDivider = "\u2500".repeat(Math.min(process.stdout.columns || 60, 60) - footer.length - 1);
-      process.stdout.write(pc3.dim(` ${footerDivider}${footer}
+      process.stdout.write(pc6.dim(` ${footerDivider}${footer}
 `));
-      if (mcpManager && hooksConfig?.extractMemories) {
+      if (hooksConfig?.extractMemories) {
         const assistantText = typeof response.message.content === "string" ? response.message.content : response.message.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
         if (assistantText) {
           const count = await extractMemories(
             input,
             assistantText,
             client,
-            mcpManager,
             extractorState
           );
           if (count > 0) {
-            process.stdout.write(pc3.dim(`  [${count} memory${count > 1 ? "ies" : ""} stored]
+            process.stdout.write(pc6.dim(`  [${count} memory${count > 1 ? "ies" : ""} stored]
 `));
           }
         }
@@ -2493,11 +4592,11 @@ ${converted}
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs7.existsSync(path7.join(os7.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs13.existsSync(path13.join(os12.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
-          process.stdout.write(pc3.dim(`  ${hint}
+          process.stdout.write(pc6.dim(`  ${hint}
 `));
           saveShownHints(hintState.shownHints);
         }
@@ -2505,21 +4604,17 @@ ${converted}
     } catch (error) {
       const rawMessage = error instanceof Error ? error.message : "Unknown error occurred";
       const friendly = humanizeError(rawMessage);
-      console.error(pc3.red(`
+      console.error(pc6.red(`
   ${friendly}`));
     }
   }
 }
-async function saveConversationToMemory(mcpManager, messages, sessionId) {
+async function saveConversationToMemory(messages, sessionId) {
   const recentMessages = messages.slice(-50);
   for (const msg of recentMessages) {
     if (typeof msg.content !== "string") continue;
     try {
-      await mcpManager.callTool("memory_log", {
-        session_id: sessionId,
-        role: msg.role,
-        content: msg.content.slice(0, 5e3)
-      });
+      memoryLog(sessionId, msg.role, msg.content.slice(0, 5e3));
     } catch (err) {
       log.debug("agent", "memory_log write failed", err);
     }
@@ -2527,9 +4622,9 @@ async function saveConversationToMemory(mcpManager, messages, sessionId) {
 }
 
 // src/index.ts
-import fs8 from "fs";
-import path8 from "path";
-import os8 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -2638,9 +4733,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path8.join(os8.homedir(), ".aman-agent", ".reconfig");
-  if (fs8.existsSync(reconfigMarker)) {
-    fs8.unlinkSync(reconfigMarker);
+  const reconfigMarker = path14.join(os13.homedir(), ".aman-agent", ".reconfig");
+  if (fs14.existsSync(reconfigMarker)) {
+    fs14.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -2669,11 +4764,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os8.homedir();
-  const corePath = path8.join(home2, ".acore", "core.md");
-  if (fs8.existsSync(corePath)) return false;
-  fs8.mkdirSync(path8.join(home2, ".acore"), { recursive: true });
-  fs8.writeFileSync(corePath, [
+  const home2 = os13.homedir();
+  const corePath = path14.join(home2, ".acore", "core.md");
+  if (fs14.existsSync(corePath)) return false;
+  fs14.mkdirSync(path14.join(home2, ".acore"), { recursive: true });
+  fs14.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -2685,11 +4780,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path8.join(home2, ".arules");
-  const rulesPath = path8.join(rulesDir, "rules.md");
-  if (!fs8.existsSync(rulesPath)) {
-    fs8.mkdirSync(rulesDir, { recursive: true });
-    fs8.writeFileSync(rulesPath, [
+  const rulesDir = path14.join(home2, ".arules");
+  const rulesPath = path14.join(rulesDir, "rules.md");
+  if (!fs14.existsSync(rulesPath)) {
+    fs14.mkdirSync(rulesDir, { recursive: true });
+    fs14.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -2704,16 +4799,16 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.1.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).action(async (options) => {
-  p2.intro(pc4.bold("aman agent") + pc4.dim(" \u2014 your AI companion"));
+program.name("aman-agent").description("Your AI companion, running locally").version("0.1.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+  p2.intro(pc7.bold("aman agent") + pc7.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
     const detected = await autoDetectConfig();
     if (detected) {
       config = detected;
       const providerLabel = detected.provider === "anthropic" ? "Anthropic API key" : detected.provider === "openai" ? "OpenAI API key" : "Ollama";
-      p2.log.success(`Auto-detected ${providerLabel}. Using ${pc4.bold(detected.model)}.`);
-      p2.log.info(pc4.dim("Change anytime with /reconfig"));
+      p2.log.success(`Auto-detected ${providerLabel}. Using ${pc7.bold(detected.model)}.`);
+      p2.log.info(pc7.dim("Change anytime with /reconfig"));
       saveConfig(config);
     } else {
       p2.log.info("First-time setup \u2014 configure your LLM connection.");
@@ -2744,7 +4839,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
         defaultModel = modelInput || "llama3.2";
       } else if (provider === "anthropic") {
         p2.log.info("Get your API key from: https://console.anthropic.com/settings/keys");
-        p2.log.info(pc4.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
+        p2.log.info(pc7.dim("Note: API access is separate from Claude Pro subscription. You need API credits."));
         apiKey = await p2.text({
           message: "API key (starts with sk-ant-)",
           validate: (v) => v.length === 0 ? "API key is required" : void 0
@@ -2810,34 +4905,32 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   const s = p2.spinner();
   s.start("Loading ecosystem");
   bootstrapEcosystem();
+  const profile = options.profile || process.env.AMAN_PROFILE || void 0;
+  if (profile) {
+    p2.log.info(`Profile: ${pc7.bold(profile)}`);
+  }
   const budget = options.budget || void 0;
-  const { prompt: systemPrompt, layers, truncated, totalTokens } = assembleSystemPrompt(budget);
+  const { prompt: systemPrompt, layers, truncated, totalTokens } = assembleSystemPrompt(budget, profile);
   s.stop("Ecosystem loaded");
   if (layers.length === 0) {
     p2.log.warning(
-      "No ecosystem configured. Run " + pc4.bold("npx @aman_asmuei/aman") + " first."
+      "No ecosystem configured. Run " + pc7.bold("npx @aman_asmuei/aman") + " first."
     );
     p2.log.info("Starting with empty system prompt.");
   } else {
     p2.log.success(
-      `Loaded: ${layers.join(", ")} ${pc4.dim(`(${totalTokens.toLocaleString()} tokens)`)}`
+      `Loaded: ${layers.join(", ")} ${pc7.dim(`(${totalTokens.toLocaleString()} tokens)`)}`
     );
     if (truncated.length > 0) {
-      p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc4.dim("(over budget)")}`);
+      p2.log.warning(`Truncated: ${truncated.join(", ")} ${pc7.dim("(over budget)")}`);
     }
   }
-  const corePath = path8.join(os8.homedir(), ".acore", "core.md");
-  let aiName = "Assistant";
-  if (fs8.existsSync(corePath)) {
-    const content = fs8.readFileSync(corePath, "utf-8");
-    const match = content.match(/^# (.+)$/m);
-    if (match) aiName = match[1];
-  }
+  const aiName = getProfileAiName(profile);
+  await initMemory();
   const mcpManager = new McpManager();
   const mcpSpinner = p2.spinner();
   mcpSpinner.start("Connecting to MCP servers");
   await mcpManager.connect("aman", "npx", ["-y", "@aman_asmuei/aman-mcp"]);
-  await mcpManager.connect("amem", "npx", ["-y", "@aman_asmuei/amem"]);
   if (config.mcpServers) {
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (name === "aman" || name === "amem") continue;
@@ -2848,25 +4941,16 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   mcpSpinner.stop("MCP connected");
   if (mcpTools.length > 0) {
     p2.log.success(`${mcpTools.length} MCP tools available`);
-    if (mcpTools.some((t) => t.name === "memory_consolidate")) {
+    {
       const memSpinner = p2.spinner();
       memSpinner.start("Consolidating memory");
       try {
-        const consolidateResult = await mcpManager.callTool("memory_consolidate", { dry_run: false });
-        if (consolidateResult && !consolidateResult.startsWith("Error")) {
-          try {
-            const report = JSON.parse(consolidateResult);
-            memSpinner.stop("Memory consolidated");
-            if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
-              p2.log.info(
-                `Memory health: ${report.healthScore ?? "?"}% ` + pc4.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
-              );
-            }
-          } catch {
-            memSpinner.stop("Memory consolidated");
-          }
-        } else {
-          memSpinner.stop("Memory consolidated");
+        const report = memoryConsolidate();
+        memSpinner.stop("Memory consolidated");
+        if (report.merged > 0 || report.pruned > 0 || report.promoted > 0) {
+          p2.log.info(
+            `Memory health: ${report.healthScore ?? "?"}% ` + pc7.dim(`(merged ${report.merged}, pruned ${report.pruned}, promoted ${report.promoted})`)
+          );
         }
       } catch {
         memSpinner.stop("Memory consolidation skipped");
@@ -2890,7 +4974,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   } else {
     client = createOpenAIClient(config.apiKey, model);
   }
-  p2.log.success(`${pc4.bold(aiName)} is ready. Model: ${pc4.dim(model)}`);
+  p2.log.success(`${pc7.bold(aiName)} is ready. Model: ${pc7.dim(model)}`);
   await runAgent(
     client,
     systemPrompt,
@@ -2903,7 +4987,7 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   await mcpManager.disconnect();
 });
 program.command("init").description("Set up your AI companion with a guided wizard").action(async () => {
-  p2.intro(pc4.bold("aman agent init") + pc4.dim(" \u2014 set up your companion"));
+  p2.intro(pc7.bold("aman agent init") + pc7.dim(" \u2014 set up your companion"));
   const name = await p2.text({
     message: "What should your companion be called?",
     placeholder: "Aman",
@@ -2923,19 +5007,19 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p2.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  const home2 = os8.homedir();
-  fs8.mkdirSync(path8.join(home2, ".acore"), { recursive: true });
-  fs8.writeFileSync(path8.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os13.homedir();
+  fs14.mkdirSync(path14.join(home2, ".acore"), { recursive: true });
+  fs14.writeFileSync(path14.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
   p2.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs8.mkdirSync(path8.join(home2, ".arules"), { recursive: true });
-    fs8.writeFileSync(path8.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs14.mkdirSync(path14.join(home2, ".arules"), { recursive: true });
+    fs14.writeFileSync(path14.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p2.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs8.mkdirSync(path8.join(home2, ".aflow"), { recursive: true });
-    fs8.writeFileSync(path8.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs14.mkdirSync(path14.join(home2, ".aflow"), { recursive: true });
+    fs14.writeFileSync(path14.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p2.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }
@@ -2943,16 +5027,16 @@ program.command("init").description("Set up your AI companion with a guided wiza
   p2.outro("Your companion is ready.");
   console.log("");
   if (isNpx) {
-    console.log(`  ${pc4.bold("Start chatting:")}  npx @aman_asmuei/aman-agent`);
+    console.log(`  ${pc7.bold("Start chatting:")}  npx @aman_asmuei/aman-agent`);
     console.log("");
-    console.log(`  ${pc4.dim("Tip: Install globally to use")} ${pc4.bold("aman-agent")} ${pc4.dim("directly:")}`);
-    console.log(`  ${pc4.dim("  npm install -g @aman_asmuei/aman-agent")}`);
+    console.log(`  ${pc7.dim("Tip: Install globally to use")} ${pc7.bold("aman-agent")} ${pc7.dim("directly:")}`);
+    console.log(`  ${pc7.dim("  npm install -g @aman_asmuei/aman-agent")}`);
   } else {
-    console.log(`  ${pc4.bold("Start chatting:")}  aman-agent`);
+    console.log(`  ${pc7.bold("Start chatting:")}  aman-agent`);
   }
   console.log("");
-  console.log(`  ${pc4.dim("Add tools:")}  npx @aman_asmuei/akit add github`);
-  console.log(`  ${pc4.dim("Browse:")}     npx @aman_asmuei/akit search <query>`);
+  console.log(`  ${pc7.dim("Add tools:")}  npx @aman_asmuei/akit add github`);
+  console.log(`  ${pc7.dim("Browse:")}     npx @aman_asmuei/akit search <query>`);
   console.log("");
 });
 program.parse();