@aman_asmuei/aman-agent 0.31.0 → 0.33.0

package/dist/index.js

@@ -8,23 +8,82 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/token-budget.ts
+function estimateTokens(text3) {
+  return Math.round(text3.split(/\s+/).filter(Boolean).length * 1.3);
+}
+function buildBudgetedPrompt(components, maxTokens = 8e3) {
+  const included = [];
+  const truncated = [];
+  const parts = [];
+  let totalTokens = 0;
+  const sorted = [...components].sort((a, b) => {
+    const aPri = PRIORITIES.indexOf(a.name);
+    const bPri = PRIORITIES.indexOf(b.name);
+    return (aPri === -1 ? 99 : aPri) - (bPri === -1 ? 99 : bPri);
+  });
+  for (const comp of sorted) {
+    if (totalTokens + comp.tokens <= maxTokens) {
+      parts.push(comp.content);
+      included.push(comp.name);
+      totalTokens += comp.tokens;
+    } else {
+      const halfContent = comp.content.slice(0, Math.floor(comp.content.length / 2));
+      const halfTokens = estimateTokens(halfContent);
+      if (totalTokens + halfTokens <= maxTokens) {
+        parts.push(halfContent + "\n\n[... truncated for context budget ...]");
+        included.push(comp.name + " (partial)");
+        totalTokens += halfTokens;
+      } else {
+        truncated.push(comp.name);
+      }
+    }
+  }
+  return {
+    prompt: parts.join("\n\n---\n\n"),
+    included,
+    truncated,
+    totalTokens
+  };
+}
+var PRIORITIES;
+var init_token_budget = __esm({
+  "src/token-budget.ts"() {
+    "use strict";
+    PRIORITIES = [
+      "identity",
+      // core.md — always include
+      "user",
+      // user.md — user profile, always include
+      "guardrails",
+      // rules.md — safety critical
+      "workflows",
+      // flow.md — behavioral
+      "tools",
+      // kit.md — capabilities
+      "skills"
+      // skills.md — can be truncated
+    ];
+  }
+});
+
 // src/logger.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import os4 from "os";
 function ensureDir() {
-  if (!fs4.existsSync(LOG_DIR)) {
-    fs4.mkdirSync(LOG_DIR, { recursive: true });
+  if (!fs5.existsSync(LOG_DIR)) {
+    fs5.mkdirSync(LOG_DIR, { recursive: true });
   }
 }
 function maybeRotate() {
   try {
-    if (!fs4.existsSync(LOG_PATH)) return;
-    const stat = fs4.statSync(LOG_PATH);
+    if (!fs5.existsSync(LOG_PATH)) return;
+    const stat = fs5.statSync(LOG_PATH);
     if (stat.size >= MAX_LOG_SIZE) {
       const backupPath = LOG_PATH + ".1";
-      if (fs4.existsSync(backupPath)) fs4.unlinkSync(backupPath);
-      fs4.renameSync(LOG_PATH, backupPath);
+      if (fs5.existsSync(backupPath)) fs5.unlinkSync(backupPath);
+      fs5.renameSync(LOG_PATH, backupPath);
     }
   } catch {
   }
@@ -42,7 +101,7 @@ function write(level, module, message, data) {
     if (data !== void 0) {
       entry.data = data instanceof Error ? data.message : String(data);
     }
-    fs4.appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
+    fs5.appendFileSync(LOG_PATH, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -50,8 +109,8 @@ var LOG_DIR, LOG_PATH, MAX_LOG_SIZE, log;
 var init_logger = __esm({
   "src/logger.ts"() {
     "use strict";
-    LOG_DIR = path4.join(os4.homedir(), ".aman-agent");
-    LOG_PATH = path4.join(LOG_DIR, "debug.log");
+    LOG_DIR = path5.join(os4.homedir(), ".aman-agent");
+    LOG_PATH = path5.join(LOG_DIR, "debug.log");
     MAX_LOG_SIZE = 1048576;
     log = {
       debug: (module, message, data) => write("debug", module, message, data),
@@ -73,11 +132,11 @@ __export(user_model_exports, {
   predictBurnout: () => predictBurnout,
   saveUserModel: () => saveUserModel
 });
-import fs13 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path14 from "path";
 import os12 from "os";
 function defaultModelPath() {
-  return path13.join(os12.homedir(), ".acore", "user-model.json");
+  return path14.join(os12.homedir(), ".acore", "user-model.json");
 }
 function createEmptyModel() {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -109,7 +168,7 @@ function emptyProfile() {
 async function loadUserModel(filePath) {
   const fp = filePath ?? defaultModelPath();
   try {
-    const raw = await fs13.readFile(fp, "utf-8");
+    const raw = await fs14.readFile(fp, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1) return null;
     return parsed;
@@ -119,11 +178,11 @@ async function loadUserModel(filePath) {
 }
 async function saveUserModel(model, filePath) {
   const fp = filePath ?? defaultModelPath();
-  const dir = path13.dirname(fp);
-  await fs13.mkdir(dir, { recursive: true });
+  const dir = path14.dirname(fp);
+  await fs14.mkdir(dir, { recursive: true });
   const tmp = fp + `.tmp-${Date.now()}`;
-  await fs13.writeFile(tmp, JSON.stringify(model, null, 2), "utf-8");
-  await fs13.rename(tmp, fp);
+  await fs14.writeFile(tmp, JSON.stringify(model, null, 2), "utf-8");
+  await fs14.rename(tmp, fp);
 }
 function aggregateSession(model, snapshot) {
   const sessions = [...model.sessions, snapshot];
@@ -386,21 +445,21 @@ var init_user_model = __esm({
 });
 
 // src/server/registry.ts
-import fs15 from "fs/promises";
-import path15 from "path";
+import fs16 from "fs/promises";
+import path16 from "path";
 import os14 from "os";
 function amanAgentHome() {
-  return process.env.AMAN_AGENT_HOME || path15.join(os14.homedir(), ".aman-agent");
+  return process.env.AMAN_AGENT_HOME || path16.join(os14.homedir(), ".aman-agent");
 }
 function registryPath() {
-  return path15.join(amanAgentHome(), "registry.json");
+  return path16.join(amanAgentHome(), "registry.json");
 }
 async function ensureHome() {
-  await fs15.mkdir(amanAgentHome(), { recursive: true });
+  await fs16.mkdir(amanAgentHome(), { recursive: true });
 }
 async function readRaw() {
   try {
-    const buf = await fs15.readFile(registryPath(), "utf-8");
+    const buf = await fs16.readFile(registryPath(), "utf-8");
     const parsed = JSON.parse(buf);
     return Array.isArray(parsed) ? parsed : [];
   } catch (err) {
@@ -414,10 +473,10 @@ async function readRaw() {
 async function writeAtomic(entries) {
   await ensureHome();
   const tmp = registryPath() + ".tmp";
-  await fs15.writeFile(tmp, JSON.stringify(entries, null, 2), { mode: 384 });
-  await fs15.rename(tmp, registryPath());
+  await fs16.writeFile(tmp, JSON.stringify(entries, null, 2), { mode: 384 });
+  await fs16.rename(tmp, registryPath());
   try {
-    await fs15.chmod(registryPath(), 384);
+    await fs16.chmod(registryPath(), 384);
   } catch {
   }
 }
@@ -600,6 +659,473 @@ var init_delegate_remote = __esm({
   }
 });
 
+// src/dev/stack-detector.ts
+var stack_detector_exports = {};
+__export(stack_detector_exports, {
+  scanStack: () => scanStack
+});
+import fs24 from "fs";
+import path24 from "path";
+function scanStack(projectPath) {
+  const languages = [];
+  const frameworks = [];
+  const databases = [];
+  const infra = [];
+  let isMonorepo = false;
+  let projectName = path24.basename(projectPath);
+  const goModPath = path24.join(projectPath, "go.mod");
+  if (fs24.existsSync(goModPath)) {
+    languages.push("go");
+    const content = fs24.readFileSync(goModPath, "utf-8");
+    const moduleMatch = content.match(/^module\s+(.+)$/m);
+    if (moduleMatch) {
+      const parts = moduleMatch[1].trim().split("/");
+      projectName = parts[parts.length - 1];
+    }
+    if (content.includes("gofiber/fiber")) frameworks.push("fiber");
+    if (content.includes("gin-gonic/gin")) frameworks.push("gin");
+    if (content.includes("go-chi/chi")) frameworks.push("chi");
+    if (content.includes("labstack/echo")) frameworks.push("echo");
+  }
+  const pkgPath = path24.join(projectPath, "package.json");
+  const hasTsConfig = fs24.existsSync(path24.join(projectPath, "tsconfig.json"));
+  if (fs24.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) projectName = pkg.name;
+      if (hasTsConfig) {
+        languages.push("typescript");
+      } else {
+        languages.push("javascript");
+      }
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const [dep, fwName] of Object.entries(FRAMEWORK_MAP)) {
+        if (allDeps?.[dep]) frameworks.push(fwName);
+      }
+      if (pkg.workspaces) isMonorepo = true;
+    } catch {
+      if (hasTsConfig) languages.push("typescript");
+    }
+  } else if (hasTsConfig) {
+    languages.push("typescript");
+  }
+  const cargoPath = path24.join(projectPath, "Cargo.toml");
+  if (fs24.existsSync(cargoPath)) {
+    languages.push("rust");
+    const content = fs24.readFileSync(cargoPath, "utf-8");
+    if (content.includes("[workspace]")) isMonorepo = true;
+    const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    if (nameMatch && !isMonorepo) projectName = nameMatch[1];
+  }
+  const pyprojectPath = path24.join(projectPath, "pyproject.toml");
+  if (fs24.existsSync(pyprojectPath)) {
+    languages.push("python");
+    const content = fs24.readFileSync(pyprojectPath, "utf-8");
+    if (content.includes("django")) frameworks.push("django");
+    if (content.includes("fastapi")) frameworks.push("fastapi");
+    if (content.includes("flask")) frameworks.push("flask");
+  }
+  if (fs24.existsSync(path24.join(projectPath, "pubspec.yaml"))) {
+    languages.push("dart");
+    frameworks.push("flutter");
+  }
+  if (fs24.existsSync(path24.join(projectPath, "Dockerfile"))) {
+    infra.push("docker");
+  }
+  const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const name of composeNames) {
+    const composePath = path24.join(projectPath, name);
+    if (fs24.existsSync(composePath)) {
+      if (!infra.includes("docker")) infra.push("docker");
+      const content = fs24.readFileSync(composePath, "utf-8");
+      for (const [pattern, dbName] of Object.entries(DB_IMAGE_MAP)) {
+        if (content.includes(pattern) && !databases.includes(dbName)) {
+          databases.push(dbName);
+        }
+      }
+      break;
+    }
+  }
+  if (fs24.existsSync(path24.join(projectPath, ".github", "workflows"))) {
+    infra.push("github-actions");
+  }
+  for (const dir of ["k3s", "k8s", "deploy"]) {
+    if (fs24.existsSync(path24.join(projectPath, dir))) {
+      infra.push("kubernetes");
+      break;
+    }
+  }
+  if (fs24.existsSync(path24.join(projectPath, "Makefile"))) {
+    infra.push("make");
+  }
+  return {
+    projectName,
+    languages,
+    frameworks,
+    databases,
+    infra,
+    isMonorepo,
+    detectedAt: Date.now()
+  };
+}
+var FRAMEWORK_MAP, DB_IMAGE_MAP;
+var init_stack_detector = __esm({
+  "src/dev/stack-detector.ts"() {
+    "use strict";
+    FRAMEWORK_MAP = {
+      next: "next",
+      react: "react",
+      remix: "remix",
+      express: "express",
+      fastify: "fastify",
+      hono: "hono",
+      "@nestjs/core": "nestjs",
+      vue: "vue",
+      svelte: "svelte",
+      nuxt: "nuxt"
+    };
+    DB_IMAGE_MAP = {
+      postgres: "postgresql",
+      mysql: "mysql",
+      mariadb: "mariadb",
+      mongo: "mongodb",
+      redis: "redis",
+      timescaledb: "timescaledb"
+    };
+  }
+});
+
+// src/dev/context-builder.ts
+import path25 from "path";
+import os22 from "os";
+import { createDatabase as createDatabase2, recall as recall2 } from "@aman_asmuei/amem-core";
+import {
+  getIdentity as acoreGetIdentity2
+} from "@aman_asmuei/acore-core";
+import {
+  listRuleCategories as arulesListCategories2
+} from "@aman_asmuei/arules-core";
+function trimToTokenBudget(items, maxTokens) {
+  const result = [];
+  let total = 0;
+  for (const item of items) {
+    const tokens = estimateTokens(item);
+    if (total + tokens > maxTokens) break;
+    result.push(item);
+    total += tokens;
+  }
+  return result;
+}
+async function buildContext2(stack, opts) {
+  const conventions = [];
+  const decisions = [];
+  const corrections = [];
+  const preferences = [];
+  const rules = [];
+  let memoriesUsed = 0;
+  try {
+    const amemDir = process.env.AMEM_DIR ?? path25.join(os22.homedir(), ".amem");
+    const dbPath = process.env.AMEM_DB ?? path25.join(amemDir, "memory.db");
+    const db2 = createDatabase2(dbPath);
+    const query = [stack.projectName, ...stack.languages, ...stack.frameworks].join(" ");
+    const result = await recall2(db2, { query, limit: 20 });
+    for (const mem of result.memories) {
+      switch (mem.type) {
+        case "pattern":
+          conventions.push(mem.content);
+          break;
+        case "decision":
+          decisions.push(mem.content);
+          break;
+        case "correction":
+          corrections.push(mem.content);
+          break;
+        case "preference":
+          preferences.push(mem.content);
+          break;
+      }
+      memoriesUsed++;
+    }
+  } catch {
+  }
+  try {
+    const identity = await acoreGetIdentity2(AGENT_SCOPE2);
+    if (identity?.content) {
+      const lines = identity.content.split("\n").filter(
+        (l) => l.startsWith("- ") && (l.toLowerCase().includes("prefer") || l.toLowerCase().includes("style") || l.toLowerCase().includes("convention"))
+      );
+      for (const line of lines) {
+        const text3 = line.replace(/^-\s*/, "").trim();
+        if (text3 && !preferences.includes(text3)) preferences.push(text3);
+      }
+    }
+  } catch {
+  }
+  try {
+    const categories = await arulesListCategories2(AGENT_SCOPE2);
+    for (const cat of categories) {
+      for (const ruleText of cat.rules) {
+        rules.push(ruleText);
+      }
+    }
+  } catch {
+  }
+  if (opts?.smart && opts.llmClient) {
+    try {
+      const client = opts.llmClient;
+      const rawData = [
+        `Project: ${stack.projectName}`,
+        `Stack: ${stack.languages.join(", ")} + ${stack.frameworks.join(", ")}`,
+        `Databases: ${stack.databases.join(", ") || "none detected"}`,
+        "",
+        conventions.length > 0 ? `Conventions:
+${conventions.map((c) => `- ${c}`).join("\n")}` : "",
+        decisions.length > 0 ? `Decisions:
+${decisions.map((d) => `- ${d}`).join("\n")}` : "",
+        corrections.length > 0 ? `Corrections:
+${corrections.map((c) => `- ${c}`).join("\n")}` : "",
+        preferences.length > 0 ? `Preferences:
+${preferences.map((p5) => `- ${p5}`).join("\n")}` : "",
+        rules.length > 0 ? `Rules:
+${rules.map((r) => `- ${r}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n\n");
+      const response = await client.chat(
+        "You are a developer context assembler. Given raw developer history, output a merged, deduplicated set of conventions and decisions as markdown bullet lists. Group by: Conventions, Decisions, Corrections, Preferences, Rules. Be specific, not generic. Max 3000 tokens.",
+        [{ role: "user", content: rawData }],
+        () => {
+        }
+      );
+      const text3 = typeof response.message.content === "string" ? response.message.content : response.message.content.map((b) => b.text ?? "").join("");
+      const extractSection = (sectionName) => {
+        const regex = new RegExp(`##?\\s*${sectionName}[\\s\\S]*?(?=##|$)`, "i");
+        const match = text3.match(regex);
+        if (!match) return [];
+        return match[0].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim());
+      };
+      const smartConventions = extractSection("Conventions");
+      const smartDecisions = extractSection("Decisions");
+      const smartCorrections = extractSection("Corrections");
+      const smartPreferences = extractSection("Preferences");
+      const smartRules = extractSection("Rules");
+      return {
+        stack,
+        conventions: trimToTokenBudget(smartConventions.length > 0 ? smartConventions : conventions, TOKEN_LIMITS.conventions),
+        decisions: trimToTokenBudget(smartDecisions.length > 0 ? smartDecisions : decisions, TOKEN_LIMITS.decisions),
+        corrections: trimToTokenBudget(smartCorrections.length > 0 ? smartCorrections : corrections, TOKEN_LIMITS.corrections),
+        preferences: trimToTokenBudget(smartPreferences.length > 0 ? smartPreferences : preferences, TOKEN_LIMITS.preferences),
+        rules: trimToTokenBudget(smartRules.length > 0 ? smartRules : rules, TOKEN_LIMITS.rules),
+        metadata: {
+          generatedAt: Date.now(),
+          mode: "smart",
+          memoriesUsed
+        }
+      };
+    } catch {
+    }
+  }
+  return {
+    stack,
+    conventions: trimToTokenBudget(conventions, TOKEN_LIMITS.conventions),
+    decisions: trimToTokenBudget(decisions, TOKEN_LIMITS.decisions),
+    corrections: trimToTokenBudget(corrections, TOKEN_LIMITS.corrections),
+    preferences: trimToTokenBudget(preferences, TOKEN_LIMITS.preferences),
+    rules: trimToTokenBudget(rules, TOKEN_LIMITS.rules),
+    metadata: {
+      generatedAt: Date.now(),
+      mode: "template",
+      memoriesUsed
+    }
+  };
+}
+var AGENT_SCOPE2, TOKEN_LIMITS;
+var init_context_builder = __esm({
+  "src/dev/context-builder.ts"() {
+    "use strict";
+    init_token_budget();
+    AGENT_SCOPE2 = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
+    TOKEN_LIMITS = {
+      conventions: 1500,
+      decisions: 1200,
+      corrections: 800,
+      preferences: 500,
+      rules: 800
+    };
+  }
+});
+
+// src/dev/claude-md-writer.ts
+import fs25 from "fs";
+import path26 from "path";
+function formatStack(stack) {
+  const parts = [];
+  const goFrameworks = ["fiber", "gin", "chi", "echo"];
+  const jsFrameworks = ["next", "react", "remix", "express", "fastify", "hono", "nestjs", "vue", "svelte", "nuxt"];
+  const pyFrameworks = ["django", "fastapi", "flask"];
+  for (const lang of stack.languages) {
+    const fw = stack.frameworks.filter((f) => {
+      if (lang === "go" && goFrameworks.includes(f)) return true;
+      if ((lang === "typescript" || lang === "javascript") && jsFrameworks.includes(f)) return true;
+      if (lang === "python" && pyFrameworks.includes(f)) return true;
+      if (lang === "dart" && f === "flutter") return true;
+      return false;
+    });
+    const name = lang.charAt(0).toUpperCase() + lang.slice(1);
+    if (fw.length > 0) {
+      parts.push(`${name} (${fw.map((f) => f.charAt(0).toUpperCase() + f.slice(1)).join(", ")})`);
+    } else {
+      parts.push(name);
+    }
+  }
+  if (stack.databases.length > 0) {
+    parts.push(...stack.databases.map((d) => d.charAt(0).toUpperCase() + d.slice(1)));
+  }
+  return parts.join(" + ");
+}
+function renderToString(ctx) {
+  const lines = [];
+  const ts = new Date(ctx.metadata.generatedAt).toISOString();
+  lines.push(`# Project: ${ctx.stack.projectName}`);
+  lines.push(`<!-- aman-agent:dev generated=${ts} memories=${ctx.metadata.memoriesUsed} mode=${ctx.metadata.mode} -->`);
+  lines.push("");
+  const stackLine = formatStack(ctx.stack);
+  if (stackLine || ctx.stack.infra.length > 0) {
+    lines.push("## Stack");
+    if (stackLine) lines.push(`- ${stackLine}`);
+    if (ctx.stack.infra.length > 0) {
+      lines.push(`- Infra: ${ctx.stack.infra.join(", ")}`);
+    }
+    if (ctx.stack.isMonorepo) {
+      lines.push("- Monorepo");
+    }
+    lines.push("");
+  }
+  if (ctx.conventions.length > 0) {
+    lines.push("## Conventions");
+    for (const c of ctx.conventions) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  if (ctx.decisions.length > 0) {
+    lines.push("## Past Decisions");
+    for (const d of ctx.decisions) lines.push(`- ${d}`);
+    lines.push("");
+  }
+  if (ctx.corrections.length > 0) {
+    lines.push("## Corrections");
+    for (const c of ctx.corrections) lines.push(`- ${c}`);
+    lines.push("");
+  }
+  if (ctx.preferences.length > 0) {
+    lines.push("## Developer Preferences");
+    for (const p5 of ctx.preferences) lines.push(`- ${p5}`);
+    lines.push("");
+  }
+  if (ctx.rules.length > 0) {
+    lines.push("## Rules");
+    for (const r of ctx.rules) lines.push(`- ${r}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function parseMarker(content) {
+  const match = content.match(
+    /<!--\s*aman-agent:dev\s+generated=(\S+)\s+memories=(\d+)\s+mode=(\S+)\s*-->/
+  );
+  if (!match) return null;
+  return {
+    generatedAt: new Date(match[1]),
+    memories: parseInt(match[2], 10),
+    mode: match[3]
+  };
+}
+function checkStaleness(projectPath) {
+  const claudeMdPath = path26.join(projectPath, "CLAUDE.md");
+  if (!fs25.existsSync(claudeMdPath)) {
+    return { status: "missing" };
+  }
+  const content = fs25.readFileSync(claudeMdPath, "utf-8");
+  const marker = parseMarker(content);
+  if (!marker) {
+    return { status: "no-marker" };
+  }
+  return { status: "fresh", generatedAt: marker.generatedAt };
+}
+function writeClaudeMd(ctx, projectPath) {
+  const claudeMdPath = path26.join(projectPath, "CLAUDE.md");
+  let backedUp = false;
+  if (fs25.existsSync(claudeMdPath)) {
+    const content = fs25.readFileSync(claudeMdPath, "utf-8");
+    const marker = parseMarker(content);
+    if (!marker) {
+      fs25.copyFileSync(claudeMdPath, `${claudeMdPath}.bak`);
+      backedUp = true;
+    }
+  }
+  const md = renderToString(ctx);
+  fs25.writeFileSync(claudeMdPath, md, "utf-8");
+  return { written: true, backedUp, path: claudeMdPath };
+}
+var init_claude_md_writer = __esm({
+  "src/dev/claude-md-writer.ts"() {
+    "use strict";
+  }
+});
+
+// src/dev/dev-command.ts
+var dev_command_exports = {};
+__export(dev_command_exports, {
+  runDev: () => runDev
+});
+import fs26 from "fs";
+import path27 from "path";
+function ensureGitignore(projectPath) {
+  const gitignorePath = path27.join(projectPath, ".gitignore");
+  if (!fs26.existsSync(gitignorePath)) return;
+  const content = fs26.readFileSync(gitignorePath, "utf-8");
+  if (content.includes("CLAUDE.md")) return;
+  fs26.appendFileSync(gitignorePath, "\n# Generated by aman-agent dev\nCLAUDE.md\n");
+}
+async function runDev(projectPath, flags = {}, precomputedStack) {
+  const resolved = path27.resolve(projectPath);
+  if (!fs26.existsSync(resolved)) {
+    return { success: false, generated: false, error: `Directory not found: ${resolved}` };
+  }
+  const stack = precomputedStack ?? scanStack(resolved);
+  if (flags.diff) {
+    const ctx2 = await buildContext2(stack, { smart: flags.smart });
+    const newContent = renderToString(ctx2);
+    const existingPath = path27.join(resolved, "CLAUDE.md");
+    const existing = fs26.existsSync(existingPath) ? fs26.readFileSync(existingPath, "utf-8") : "";
+    return {
+      success: true,
+      generated: false,
+      diff: existing === newContent ? "(no changes)" : newContent,
+      context: ctx2
+    };
+  }
+  if (!flags.force) {
+    const staleness = checkStaleness(resolved);
+    if (staleness.status === "fresh") {
+      return { success: true, generated: false, skippedReason: "fresh" };
+    }
+  }
+  const ctx = await buildContext2(stack, { smart: flags.smart });
+  const writeResult = writeClaudeMd(ctx, resolved);
+  ensureGitignore(resolved);
+  return {
+    success: true,
+    generated: writeResult.written,
+    context: ctx
+  };
+}
+var init_dev_command = __esm({
+  "src/dev/dev-command.ts"() {
+    "use strict";
+    init_stack_detector();
+    init_context_builder();
+    init_claude_md_writer();
+  }
+});
+
 // src/index.ts
 import { Command } from "commander";
 import * as p4 from "@clack/prompts";
@@ -620,8 +1146,26 @@ var DEFAULT_HOOKS = {
   featureHints: true,
   personalityAdapt: true
 };
+function homeDir() {
+  return process.env.AMAN_HOME || process.env.AMAN_AGENT_HOME || path.join(os.homedir(), ".aman-agent");
+}
+function identityDir() {
+  return path.join(homeDir(), "identity");
+}
+function rulesDir() {
+  return path.join(homeDir(), "rules");
+}
+function memoryDir() {
+  return path.join(homeDir(), "memory");
+}
+function workflowsDir() {
+  return path.join(homeDir(), "workflows");
+}
+function skillsDir() {
+  return path.join(homeDir(), "skills");
+}
 function configDir() {
-  return process.env.AMAN_AGENT_HOME || path.join(os.homedir(), ".aman-agent");
+  return homeDir();
 }
 function configPath() {
   return path.join(configDir(), "config.json");
@@ -646,76 +1190,54 @@ function saveConfig(config) {
   );
 }
 
-// src/prompt.ts
-import fs3 from "fs";
-import path3 from "path";
-import os3 from "os";
-
-// src/token-budget.ts
-function estimateTokens(text3) {
-  return Math.round(text3.split(/\s+/).filter(Boolean).length * 1.3);
-}
-var PRIORITIES = [
-  "identity",
-  // core.md — always include
-  "user",
-  // user.md — user profile, always include
-  "guardrails",
-  // rules.md — safety critical
-  "workflows",
-  // flow.md — behavioral
-  "tools",
-  // kit.md — capabilities
-  "skills"
-  // skills.md — can be truncated
+// src/migrate.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+var MIGRATION_MAP = [
+  { oldName: ".acore", newSubdir: "identity" },
+  { oldName: ".arules", newSubdir: "rules" },
+  { oldName: ".aflow", newSubdir: "workflows" },
+  { oldName: ".askill", newSubdir: "skills" },
+  { oldName: ".amem", newSubdir: "memory" },
+  { oldName: ".aeval", newSubdir: "eval" }
 ];
-function buildBudgetedPrompt(components, maxTokens = 8e3) {
-  const included = [];
-  const truncated = [];
-  const parts = [];
-  let totalTokens = 0;
-  const sorted = [...components].sort((a, b) => {
-    const aPri = PRIORITIES.indexOf(a.name);
-    const bPri = PRIORITIES.indexOf(b.name);
-    return (aPri === -1 ? 99 : aPri) - (bPri === -1 ? 99 : bPri);
-  });
-  for (const comp of sorted) {
-    if (totalTokens + comp.tokens <= maxTokens) {
-      parts.push(comp.content);
-      included.push(comp.name);
-      totalTokens += comp.tokens;
-    } else {
-      const halfContent = comp.content.slice(0, Math.floor(comp.content.length / 2));
-      const halfTokens = estimateTokens(halfContent);
-      if (totalTokens + halfTokens <= maxTokens) {
-        parts.push(halfContent + "\n\n[... truncated for context budget ...]");
-        included.push(comp.name + " (partial)");
-        totalTokens += halfTokens;
-      } else {
-        truncated.push(comp.name);
-      }
+function migrateIfNeeded() {
+  const home2 = os2.homedir();
+  const target = homeDir();
+  const migrated = [];
+  for (const { oldName, newSubdir } of MIGRATION_MAP) {
+    const oldDir = path2.join(home2, oldName);
+    const newDir = path2.join(target, newSubdir);
+    if (!fs2.existsSync(oldDir)) continue;
+    if (fs2.existsSync(newDir) && fs2.readdirSync(newDir).length > 0) continue;
+    fs2.mkdirSync(newDir, { recursive: true });
+    for (const entry of fs2.readdirSync(oldDir)) {
+      fs2.renameSync(path2.join(oldDir, entry), path2.join(newDir, entry));
     }
+    fs2.rmSync(oldDir, { recursive: true, force: true });
+    migrated.push(newSubdir);
   }
-  return {
-    prompt: parts.join("\n\n---\n\n"),
-    included,
-    truncated,
-    totalTokens
-  };
+  return { migrated };
 }
 
+// src/prompt.ts
+init_token_budget();
+import fs4 from "fs";
+import path4 from "path";
+import os3 from "os";
+
 // src/user-identity.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
-var USER_FILE = path2.join(os2.homedir(), ".acore", "user.md");
+import fs3 from "fs";
+import path3 from "path";
+var USER_FILE = path3.join(identityDir(), "user.md");
 function hasUserIdentity() {
-  return fs2.existsSync(USER_FILE);
+  return fs3.existsSync(USER_FILE);
 }
 function loadUserIdentity() {
-  if (!fs2.existsSync(USER_FILE)) return null;
+  if (!fs3.existsSync(USER_FILE)) return null;
   try {
-    const content = fs2.readFileSync(USER_FILE, "utf-8");
+    const content = fs3.readFileSync(USER_FILE, "utf-8");
     const get = (key) => {
       const match = content.match(new RegExp(`^- ${key}:\\s*(.+)$`, "m"));
       return match?.[1]?.trim() ?? "";
@@ -746,8 +1268,8 @@ function loadUserIdentity() {
   }
 }
 function saveUserIdentity(user) {
-  const dir = path2.dirname(USER_FILE);
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+  const dir = path3.dirname(USER_FILE);
+  if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
   const lines = [
     "# User Profile",
     "",
@@ -772,7 +1294,7 @@ function saveUserIdentity(user) {
     `- Created: ${user.createdAt}`,
     `- Updated: ${user.updatedAt}`
   );
-  fs2.writeFileSync(USER_FILE, lines.join("\n") + "\n", "utf-8");
+  fs3.writeFileSync(USER_FILE, lines.join("\n") + "\n", "utf-8");
 }
 function formatUserContext(user) {
   const parts = [
@@ -834,19 +1356,19 @@ var ECOSYSTEM_FILES = [
 ];
 function resolveLayerPath(entry, home2, profile) {
   if (profile && entry.profileOverridable) {
-    const profilePath = path3.join(home2, ".acore", "profiles", profile, entry.file);
-    if (fs3.existsSync(profilePath)) return profilePath;
+    const profilePath = path4.join(home2, ".acore", "profiles", profile, entry.file);
+    if (fs4.existsSync(profilePath)) return profilePath;
     if (entry.name === "guardrails") {
-      const altPath = path3.join(home2, ".acore", "profiles", profile, "rules.md");
-      if (fs3.existsSync(altPath)) return altPath;
+      const altPath = path4.join(home2, ".acore", "profiles", profile, "rules.md");
+      if (fs4.existsSync(altPath)) return altPath;
     }
     if (entry.name === "skills") {
-      const altPath = path3.join(home2, ".acore", "profiles", profile, "skills.md");
-      if (fs3.existsSync(altPath)) return altPath;
+      const altPath = path4.join(home2, ".acore", "profiles", profile, "skills.md");
+      if (fs4.existsSync(altPath)) return altPath;
     }
   }
-  const globalPath = path3.join(home2, entry.dir, entry.file);
-  if (fs3.existsSync(globalPath)) return globalPath;
+  const globalPath = path4.join(home2, entry.dir, entry.file);
+  if (fs4.existsSync(globalPath)) return globalPath;
   return null;
 }
 function assembleSystemPrompt(maxTokens, profile) {
@@ -855,7 +1377,7 @@ function assembleSystemPrompt(maxTokens, profile) {
   for (const entry of ECOSYSTEM_FILES) {
     const filePath = resolveLayerPath(entry, home2, profile);
     if (filePath) {
-      const content = fs3.readFileSync(filePath, "utf-8").trim();
+      const content = fs4.readFileSync(filePath, "utf-8").trim();
       components.push({
         name: entry.name,
         content,
@@ -863,9 +1385,9 @@ function assembleSystemPrompt(maxTokens, profile) {
       });
     }
   }
-  const contextPath = path3.join(process.cwd(), ".acore", "context.md");
-  if (fs3.existsSync(contextPath)) {
-    const content = fs3.readFileSync(contextPath, "utf-8").trim();
+  const contextPath = path4.join(process.cwd(), ".acore", "context.md");
+  if (fs4.existsSync(contextPath)) {
+    const content = fs4.readFileSync(contextPath, "utf-8").trim();
     components.push({
       name: "context",
       content,
@@ -891,14 +1413,14 @@ function assembleSystemPrompt(maxTokens, profile) {
   };
 }
 function listProfiles() {
-  const profilesDir = path3.join(os3.homedir(), ".acore", "profiles");
-  if (!fs3.existsSync(profilesDir)) return [];
+  const profilesDir = path4.join(os3.homedir(), ".acore", "profiles");
+  if (!fs4.existsSync(profilesDir)) return [];
   const profiles = [];
-  for (const entry of fs3.readdirSync(profilesDir, { withFileTypes: true })) {
+  for (const entry of fs4.readdirSync(profilesDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const corePath = path3.join(profilesDir, entry.name, "core.md");
-    if (!fs3.existsSync(corePath)) continue;
-    const content = fs3.readFileSync(corePath, "utf-8");
+    const corePath = path4.join(profilesDir, entry.name, "core.md");
+    if (!fs4.existsSync(corePath)) continue;
+    const content = fs4.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     const personalityMatch = content.match(/- Personality:\s*(.+)/);
     profiles.push({
@@ -913,13 +1435,13 @@ function getProfileAiName(profile) {
   const home2 = os3.homedir();
   let corePath;
   if (profile) {
-    const profileCorePath = path3.join(home2, ".acore", "profiles", profile, "core.md");
-    corePath = fs3.existsSync(profileCorePath) ? profileCorePath : path3.join(home2, ".acore", "core.md");
+    const profileCorePath = path4.join(home2, ".acore", "profiles", profile, "core.md");
+    corePath = fs4.existsSync(profileCorePath) ? profileCorePath : path4.join(home2, ".acore", "core.md");
   } else {
-    corePath = path3.join(home2, ".acore", "core.md");
+    corePath = path4.join(home2, ".acore", "core.md");
   }
-  if (!fs3.existsSync(corePath)) return "Assistant";
-  const content = fs3.readFileSync(corePath, "utf-8");
+  if (!fs4.existsSync(corePath)) return "Assistant";
+  const content = fs4.readFileSync(corePath, "utf-8");
   const match = content.match(/^# (.+)$/m);
   return match?.[1]?.trim() || "Assistant";
 }
@@ -1976,8 +2498,8 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs22 from "fs";
-import path22 from "path";
+import fs23 from "fs";
+import path23 from "path";
 import os21 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
@@ -1985,15 +2507,15 @@ import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs19 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path20 from "path";
 import os18 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc6 from "picocolors";
 
 // src/layers/parsers.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import os5 from "os";
 var home = os5.homedir();
 var LAYER_FILES = [
@@ -2031,11 +2553,11 @@ function getLayerSummary(name, content) {
 }
 function getEcosystemStatus(mcpToolCount, amemConnected) {
   const layers = LAYER_FILES.map((entry) => {
-    const filePath = path5.join(home, entry.dir, entry.file);
-    const exists = fs5.existsSync(filePath);
+    const filePath = path6.join(home, entry.dir, entry.file);
+    const exists = fs6.existsSync(filePath);
     let summary = "not configured";
     if (exists) {
-      const content = fs5.readFileSync(filePath, "utf-8");
+      const content = fs6.readFileSync(filePath, "utf-8");
       summary = getLayerSummary(entry.name, content);
     }
     return { name: entry.name, exists, path: filePath, summary };
@@ -2073,25 +2595,25 @@ import {
   importFromTeam,
   syncToCopilot
 } from "@aman_asmuei/amem-core";
-import path6 from "path";
+import path7 from "path";
 import os6 from "os";
-import fs6 from "fs";
+import fs7 from "fs";
 var db = null;
 var currentProject = "global";
 async function initMemory(project) {
   if (db) return db;
-  const amemDir = process.env.AMEM_DIR ?? path6.join(os6.homedir(), ".amem");
-  if (!fs6.existsSync(amemDir)) fs6.mkdirSync(amemDir, { recursive: true });
-  const dbPath = process.env.AMEM_DB ?? path6.join(amemDir, "memory.db");
+  const amemDir = process.env.AMEM_DIR ?? path7.join(os6.homedir(), ".amem");
+  if (!fs7.existsSync(amemDir)) fs7.mkdirSync(amemDir, { recursive: true });
+  const dbPath = process.env.AMEM_DB ?? path7.join(amemDir, "memory.db");
   try {
     db = createDatabase(dbPath);
   } catch (err) {
     const backupPath = `${dbPath}.corrupt.${Date.now()}`;
     try {
-      if (fs6.existsSync(dbPath)) {
-        fs6.renameSync(dbPath, backupPath);
-        if (fs6.existsSync(`${dbPath}-wal`)) fs6.unlinkSync(`${dbPath}-wal`);
-        if (fs6.existsSync(`${dbPath}-shm`)) fs6.unlinkSync(`${dbPath}-shm`);
+      if (fs7.existsSync(dbPath)) {
+        fs7.renameSync(dbPath, backupPath);
+        if (fs7.existsSync(`${dbPath}-wal`)) fs7.unlinkSync(`${dbPath}-wal`);
+        if (fs7.existsSync(`${dbPath}-shm`)) fs7.unlinkSync(`${dbPath}-shm`);
         console.error(`[amem] Database corrupted \u2014 backed up to ${backupPath}`);
         console.error("[amem] Creating fresh database. Previous memories are in the backup file.");
         db = createDatabase(dbPath);
@@ -2240,7 +2762,7 @@ async function memoryRepair(opts = {}) {
       actions: diag.issues.map((issue) => `Would fix: ${issue.suggestion}`)
     };
   }
-  const dbPath = process.env.AMEM_DB ?? path6.join(os6.homedir(), ".amem", "memory.db");
+  const dbPath = process.env.AMEM_DB ?? path7.join(os6.homedir(), ".amem", "memory.db");
   const result = repairDatabase(dbPath);
   return {
     dryRun: false,
@@ -2336,8 +2858,8 @@ async function memorySync(action, opts = {}) {
 }
 
 // src/profile-templates.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import os7 from "os";
 var BUILT_IN_PROFILES = [
   {
@@ -2431,9 +2953,9 @@ var BUILT_IN_PROFILES = [
 function installProfileTemplate(templateName, userName) {
   const template = BUILT_IN_PROFILES.find((t) => t.name === templateName);
   if (!template) return null;
-  const profileDir = path7.join(os7.homedir(), ".acore", "profiles", template.name);
-  if (fs7.existsSync(profileDir)) return `Profile already exists: ${template.name}`;
-  fs7.mkdirSync(profileDir, { recursive: true });
+  const profileDir = path8.join(os7.homedir(), ".acore", "profiles", template.name);
+  if (fs8.existsSync(profileDir)) return `Profile already exists: ${template.name}`;
+  fs8.mkdirSync(profileDir, { recursive: true });
   let core = template.core;
   if (userName) {
     core += `
@@ -2447,12 +2969,12 @@ function installProfileTemplate(templateName, userName) {
 - Detail level: balanced
 `;
   }
-  fs7.writeFileSync(path7.join(profileDir, "core.md"), core, "utf-8");
+  fs8.writeFileSync(path8.join(profileDir, "core.md"), core, "utf-8");
   if (template.rules) {
-    fs7.writeFileSync(path7.join(profileDir, "rules.md"), template.rules, "utf-8");
+    fs8.writeFileSync(path8.join(profileDir, "rules.md"), template.rules, "utf-8");
   }
   if (template.skills) {
-    fs7.writeFileSync(path7.join(profileDir, "skills.md"), template.skills, "utf-8");
+    fs8.writeFileSync(path8.join(profileDir, "skills.md"), template.skills, "utf-8");
   }
   return null;
 }
@@ -2463,21 +2985,21 @@ import pc from "picocolors";
 
 // src/showcase-bridge.ts
 init_logger();
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 import os8 from "os";
 var cachedManifest = null;
 var cachedShowcaseRoot = null;
 function findShowcaseRoot() {
   const candidates = [
     // Sibling in monorepo
-    path8.join(os8.homedir(), "project-aman", "aman-showcase"),
-    path8.join(process.cwd(), "..", "aman-showcase"),
+    path9.join(os8.homedir(), "project-aman", "aman-showcase"),
+    path9.join(process.cwd(), "..", "aman-showcase"),
     // npm global install
-    path8.join(process.cwd(), "node_modules", "@aman_asmuei", "aman-showcase")
+    path9.join(process.cwd(), "node_modules", "@aman_asmuei", "aman-showcase")
   ];
   for (const candidate of candidates) {
-    if (fs8.existsSync(path8.join(candidate, "src", "manifest.ts")) || fs8.existsSync(path8.join(candidate, "dist", "index.js"))) {
+    if (fs9.existsSync(path9.join(candidate, "src", "manifest.ts")) || fs9.existsSync(path9.join(candidate, "dist", "index.js"))) {
       return candidate;
     }
   }
@@ -2507,10 +3029,10 @@ function loadShowcaseManifest() {
     return cachedManifest;
   }
   cachedShowcaseRoot = root;
-  const manifestSrc = path8.join(root, "src", "manifest.ts");
-  if (fs8.existsSync(manifestSrc)) {
+  const manifestSrc = path9.join(root, "src", "manifest.ts");
+  if (fs9.existsSync(manifestSrc)) {
     try {
-      const content = fs8.readFileSync(manifestSrc, "utf-8");
+      const content = fs9.readFileSync(manifestSrc, "utf-8");
       const parsed = parseManifestSource(content);
       if (parsed.length > 0) {
         cachedManifest = parsed;
@@ -2521,7 +3043,7 @@ function loadShowcaseManifest() {
     }
   }
   try {
-    const dirs = fs8.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !["node_modules", "dist", "src", "bin", "docs"].includes(d.name)).filter((d) => fs8.existsSync(path8.join(root, d.name, "identity")));
+    const dirs = fs9.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && !["node_modules", "dist", "src", "bin", "docs"].includes(d.name)).filter((d) => fs9.existsSync(path9.join(root, d.name, "identity")));
     cachedManifest = dirs.map((d) => ({
       name: d.name,
       title: d.name.charAt(0).toUpperCase() + d.name.slice(1),
@@ -2540,69 +3062,69 @@ function installShowcaseTemplate(name) {
   if (!root) {
     throw new Error("aman-showcase package not found. Install it or check the path.");
   }
-  const showcaseDir = path8.join(root, name);
-  if (!fs8.existsSync(showcaseDir) || !fs8.existsSync(path8.join(showcaseDir, "identity"))) {
+  const showcaseDir = path9.join(root, name);
+  if (!fs9.existsSync(showcaseDir) || !fs9.existsSync(path9.join(showcaseDir, "identity"))) {
     throw new Error(`Showcase "${name}" not found in ${root}`);
   }
   const result = { installed: [], backed_up: [], env_example: "" };
   const home2 = os8.homedir();
   const copies = [
     {
-      src: path8.join(showcaseDir, "identity", "core.md"),
-      dest: path8.join(home2, ".acore", "core.md"),
+      src: path9.join(showcaseDir, "identity", "core.md"),
+      dest: path9.join(home2, ".acore", "core.md"),
       label: "~/.acore/core.md (identity)"
     },
     {
-      src: path8.join(showcaseDir, "workflows", "flow.md"),
-      dest: path8.join(home2, ".aflow", "flow.md"),
+      src: path9.join(showcaseDir, "workflows", "flow.md"),
+      dest: path9.join(home2, ".aflow", "flow.md"),
       label: "~/.aflow/flow.md (workflows)"
     },
     {
-      src: path8.join(showcaseDir, "rules", "rules.md"),
-      dest: path8.join(home2, ".arules", "rules.md"),
+      src: path9.join(showcaseDir, "rules", "rules.md"),
+      dest: path9.join(home2, ".arules", "rules.md"),
       label: "~/.arules/rules.md (guardrails)"
     }
   ];
-  const skillsSrc = path8.join(showcaseDir, "skills");
-  if (fs8.existsSync(skillsSrc)) {
-    const skillFiles = fs8.readdirSync(skillsSrc).filter((f) => f.endsWith(".md"));
+  const skillsSrc = path9.join(showcaseDir, "skills");
+  if (fs9.existsSync(skillsSrc)) {
+    const skillFiles = fs9.readdirSync(skillsSrc).filter((f) => f.endsWith(".md"));
     if (skillFiles.length > 0) {
       const skillParts = [];
       for (const skillFile of skillFiles) {
-        const content = fs8.readFileSync(path8.join(skillsSrc, skillFile), "utf-8").trim();
+        const content = fs9.readFileSync(path9.join(skillsSrc, skillFile), "utf-8").trim();
         if (content) skillParts.push(content);
       }
       if (skillParts.length > 0) {
-        const skillsDest = path8.join(home2, ".askill", "skills.md");
+        const skillsDest = path9.join(home2, ".askill", "skills.md");
         const consolidated = `# Skills
 
 ${skillParts.join("\n\n---\n\n")}
 `;
-        if (fs8.existsSync(skillsDest)) {
-          fs8.copyFileSync(skillsDest, `${skillsDest}.bak`);
+        if (fs9.existsSync(skillsDest)) {
+          fs9.copyFileSync(skillsDest, `${skillsDest}.bak`);
           result.backed_up.push("~/.askill/skills.md (skills)");
         }
-        fs8.mkdirSync(path8.dirname(skillsDest), { recursive: true });
-        fs8.writeFileSync(skillsDest, consolidated, "utf-8");
+        fs9.mkdirSync(path9.dirname(skillsDest), { recursive: true });
+        fs9.writeFileSync(skillsDest, consolidated, "utf-8");
         result.installed.push(`~/.askill/skills.md (${skillFiles.length} skill${skillFiles.length > 1 ? "s" : ""} consolidated)`);
       }
     }
   }
   for (const { src, dest, label } of copies) {
-    if (!fs8.existsSync(src)) continue;
-    if (fs8.existsSync(dest)) {
+    if (!fs9.existsSync(src)) continue;
+    if (fs9.existsSync(dest)) {
       const backup = `${dest}.bak`;
-      fs8.copyFileSync(dest, backup);
+      fs9.copyFileSync(dest, backup);
       result.backed_up.push(label);
     }
-    fs8.mkdirSync(path8.dirname(dest), { recursive: true });
-    fs8.copyFileSync(src, dest);
+    fs9.mkdirSync(path9.dirname(dest), { recursive: true });
+    fs9.copyFileSync(src, dest);
     result.installed.push(label);
   }
-  const envExample = path8.join(showcaseDir, "config", "telegram.env.example");
-  if (fs8.existsSync(envExample)) {
-    const destEnv = path8.join(process.cwd(), ".env.example");
-    fs8.copyFileSync(envExample, destEnv);
+  const envExample = path9.join(showcaseDir, "config", "telegram.env.example");
+  if (fs9.existsSync(envExample)) {
+    const destEnv = path9.join(process.cwd(), ".env.example");
+    fs9.copyFileSync(envExample, destEnv);
     result.env_example = destEnv;
   }
   log.debug("showcase", `Installed showcase: ${name} (${result.installed.length} files)`);
@@ -2862,31 +3384,31 @@ async function editProfile(current) {
 }
 
 // src/files.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 import os9 from "os";
 var MAX_READ_BYTES = 5e4;
-var HOME = fs9.realpathSync(os9.homedir());
-var TMPDIR = fs9.realpathSync(os9.tmpdir());
-var CWD = fs9.realpathSync(process.cwd());
+var HOME = fs10.realpathSync(os9.homedir());
+var TMPDIR = fs10.realpathSync(os9.tmpdir());
+var CWD = fs10.realpathSync(process.cwd());
 function realOrBest(p5) {
-  const parts = p5.split(path9.sep);
+  const parts = p5.split(path10.sep);
   for (let i = parts.length; i > 0; i--) {
-    const candidate = parts.slice(0, i).join(path9.sep) || path9.sep;
+    const candidate = parts.slice(0, i).join(path10.sep) || path10.sep;
     try {
-      const real = fs9.realpathSync(candidate);
-      const remainder = parts.slice(i).join(path9.sep);
-      return remainder ? `${real}${path9.sep}${remainder}` : real;
+      const real = fs10.realpathSync(candidate);
+      const remainder = parts.slice(i).join(path10.sep);
+      return remainder ? `${real}${path10.sep}${remainder}` : real;
     } catch {
     }
   }
   return p5;
 }
 function isUnderDir(real, dir) {
-  return real === dir || real.startsWith(dir + path9.sep);
+  return real === dir || real.startsWith(dir + path10.sep);
 }
 function assertSafePath(filePath) {
-  const resolved = path9.resolve(filePath);
+  const resolved = path10.resolve(filePath);
   const real = realOrBest(resolved);
   if (!isUnderDir(real, HOME) && !isUnderDir(real, CWD) && !isUnderDir(real, TMPDIR)) {
     throw new Error(`Path is outside allowed directories (home or cwd): ${real}`);
@@ -2895,20 +3417,20 @@ function assertSafePath(filePath) {
 }
 async function readFile(filePath) {
   const resolved = assertSafePath(filePath);
-  if (!fs9.existsSync(resolved)) {
+  if (!fs10.existsSync(resolved)) {
     throw new Error(`File not found: ${resolved}`);
   }
-  const stat = fs9.statSync(resolved);
+  const stat = fs10.statSync(resolved);
   if (stat.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${resolved}. Use /file list instead.`);
   }
   const size = stat.size;
   const buf = Buffer.alloc(Math.min(size, MAX_READ_BYTES));
-  const fd = fs9.openSync(resolved, "r");
+  const fd = fs10.openSync(resolved, "r");
   try {
-    fs9.readSync(fd, buf, 0, buf.length, 0);
+    fs10.readSync(fd, buf, 0, buf.length, 0);
   } finally {
-    fs9.closeSync(fd);
+    fs10.closeSync(fd);
   }
   return {
     path: resolved,
@@ -2920,23 +3442,23 @@ async function readFile(filePath) {
 }
 async function listFiles(dirPath, opts = {}) {
   const resolved = assertSafePath(dirPath);
-  if (!fs9.existsSync(resolved)) {
+  if (!fs10.existsSync(resolved)) {
     throw new Error(`Directory not found: ${resolved}`);
   }
-  const stat = fs9.statSync(resolved);
+  const stat = fs10.statSync(resolved);
   if (!stat.isDirectory()) {
     throw new Error(`Path is a file, not a directory: ${resolved}. Use /file read instead.`);
   }
   const entries = [];
   function walk(dir, prefix) {
-    const items = fs9.readdirSync(dir, { withFileTypes: true });
+    const items = fs10.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
       const rel = prefix ? `${prefix}/${item.name}` : item.name;
       if (item.isDirectory()) {
         entries.push({ name: rel, type: "dir", size: 0 });
-        if (opts.recursive) walk(path9.join(dir, item.name), rel);
+        if (opts.recursive) walk(path10.join(dir, item.name), rel);
       } else {
-        const s = fs9.statSync(path9.join(dir, item.name));
+        const s = fs10.statSync(path10.join(dir, item.name));
         entries.push({ name: rel, type: "file", size: s.size });
       }
     }
@@ -2953,8 +3475,8 @@ init_logger();
 init_logger();
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 import os13 from "os";
 
 // src/personality.ts
@@ -3149,13 +3671,13 @@ async function syncPersonalityToCore(state, mcpManager, modelMetrics) {
 }
 
 // src/postmortem.ts
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 import os11 from "os";
 
 // src/observation.ts
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 import os10 from "os";
 var STAT_MAP = {
   tool_call: "toolCalls",
@@ -3166,7 +3688,7 @@ var STAT_MAP = {
   file_change: "fileChanges"
 };
 function defaultObservationsDir() {
-  return path10.join(os10.homedir(), ".acore", "observations");
+  return path11.join(os10.homedir(), ".acore", "observations");
 }
 function createObservationSession(sessionId) {
   return {
@@ -3202,17 +3724,17 @@ function resumeObservation(session) {
 async function flushEvents(session, dir) {
   if (session.events.length === 0) return;
   const obsDir = dir ?? defaultObservationsDir();
-  await fs10.mkdir(obsDir, { recursive: true });
-  const filePath = path10.join(obsDir, `${session.sessionId}.jsonl`);
+  await fs11.mkdir(obsDir, { recursive: true });
+  const filePath = path11.join(obsDir, `${session.sessionId}.jsonl`);
   const lines = session.events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  await fs10.appendFile(filePath, lines, "utf-8");
+  await fs11.appendFile(filePath, lines, "utf-8");
   session.events.length = 0;
 }
 async function readObservationEvents(sessionId, dir) {
   const obsDir = dir ?? defaultObservationsDir();
-  const filePath = path10.join(obsDir, `${sessionId}.jsonl`);
+  const filePath = path11.join(obsDir, `${sessionId}.jsonl`);
   try {
-    const content = await fs10.readFile(filePath, "utf-8");
+    const content = await fs11.readFile(filePath, "utf-8");
     return content.trim().split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
   } catch {
     return [];
@@ -3235,14 +3757,14 @@ function getSessionStats(session) {
 async function cleanupOldObservations(dir, maxAgeDays = 30) {
   const obsDir = dir ?? defaultObservationsDir();
   try {
-    const files = await fs10.readdir(obsDir);
+    const files = await fs11.readdir(obsDir);
     const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = path10.join(obsDir, file);
-      const stat = await fs10.stat(filePath);
+      const filePath = path11.join(obsDir, file);
+      const stat = await fs11.stat(filePath);
       if (stat.mtimeMs < cutoff) {
-        await fs10.unlink(filePath);
+        await fs11.unlink(filePath);
       }
     }
   } catch {
@@ -3269,10 +3791,10 @@ function detectTopicShift(recentMessages, previousMessages) {
 // src/postmortem.ts
 init_logger();
 function defaultPostmortemsDir() {
-  return path11.join(os11.homedir(), ".acore", "postmortems");
+  return path12.join(os11.homedir(), ".acore", "postmortems");
 }
 function defaultObservationsDir2() {
-  return path11.join(os11.homedir(), ".acore", "observations");
+  return path12.join(os11.homedir(), ".acore", "observations");
 }
 function shouldAutoPostmortem(session, messages) {
   if (messages.length < 6) return false;
@@ -3491,15 +4013,15 @@ function formatPostmortemMarkdown(report) {
 }
 async function savePostmortem(report, dir) {
   const pmDir = dir ?? defaultPostmortemsDir();
-  await fs11.mkdir(pmDir, { recursive: true });
+  await fs12.mkdir(pmDir, { recursive: true });
   const shortId = report.sessionId.slice(0, 4);
   const fileName = `${report.date}-${shortId}.md`;
-  const filePath = path11.join(pmDir, fileName);
+  const filePath = path12.join(pmDir, fileName);
   const markdown = formatPostmortemMarkdown(report);
-  await fs11.writeFile(filePath, markdown, "utf-8");
+  await fs12.writeFile(filePath, markdown, "utf-8");
   const jsonPath = filePath.replace(/\.md$/, ".json");
   try {
-    await fs11.writeFile(jsonPath, JSON.stringify(report, null, 2), "utf-8");
+    await fs12.writeFile(jsonPath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err) {
     log.debug("postmortem", "JSON sidecar write failed", err);
   }
@@ -3508,7 +4030,7 @@ async function savePostmortem(report, dir) {
 async function listPostmortems(dir) {
   const pmDir = dir ?? defaultPostmortemsDir();
   try {
-    const files = await fs11.readdir(pmDir);
+    const files = await fs12.readdir(pmDir);
     return files.filter((f) => f.endsWith(".md")).sort().reverse();
   } catch {
     return [];
@@ -3518,7 +4040,7 @@ async function readPostmortem(name, dir) {
   const pmDir = dir ?? defaultPostmortemsDir();
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
   try {
-    return await fs11.readFile(path11.join(pmDir, fileName), "utf-8");
+    return await fs12.readFile(path12.join(pmDir, fileName), "utf-8");
   } catch {
     return null;
   }
@@ -3565,8 +4087,8 @@ ${contents.join("\n\n---\n\n")}`
 
 // src/crystallization.ts
 init_logger();
-import fs12 from "fs/promises";
-import path12 from "path";
+import fs13 from "fs/promises";
+import path13 from "path";
 var STOPWORDS = /* @__PURE__ */ new Set([
   "the",
   "and",
@@ -3731,10 +4253,10 @@ function findCollision(name, triggers, existing) {
 }
 async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
   try {
-    await fs12.mkdir(path12.dirname(skillsMdPath), { recursive: true });
+    await fs13.mkdir(path13.dirname(skillsMdPath), { recursive: true });
     let existingContent = "";
     try {
-      existingContent = await fs12.readFile(skillsMdPath, "utf-8");
+      existingContent = await fs13.readFile(skillsMdPath, "utf-8");
     } catch {
       existingContent = "# Skills\n\n";
     }
@@ -3755,7 +4277,7 @@ async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
     }
     const skillMarkdown = formatSkillMarkdown(candidate, postmortemFilename);
     const separator = existingContent.endsWith("\n\n") ? "" : existingContent.endsWith("\n") ? "\n" : "\n\n";
-    await fs12.writeFile(
+    await fs13.writeFile(
       skillsMdPath,
       existingContent + separator + skillMarkdown,
       "utf-8"
@@ -3777,7 +4299,7 @@ async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
 }
 async function mergeSkillInFile(candidate, existingName, skillsMdPath, postmortemFilename) {
   try {
-    const content = await fs12.readFile(skillsMdPath, "utf-8");
+    const content = await fs13.readFile(skillsMdPath, "utf-8");
     const lines = content.split("\n");
     const heading = toTitleCase(existingName);
     let startIdx = -1;
@@ -3818,7 +4340,7 @@ async function mergeSkillInFile(candidate, existingName, skillsMdPath, postmorte
     const before = lines.slice(0, startIdx);
     const after = lines.slice(endIdx);
     const merged = [...before, ...oldBlock, "", newSkillMarkdown, ...after].join("\n");
-    await fs12.writeFile(skillsMdPath, merged, "utf-8");
+    await fs13.writeFile(skillsMdPath, merged, "utf-8");
     return {
       written: true,
       filePath: skillsMdPath,
@@ -3837,27 +4359,27 @@ async function mergeSkillInFile(candidate, existingName, skillsMdPath, postmorte
 }
 async function appendCrystallizationLog(entry, logPath) {
   try {
-    await fs12.mkdir(path12.dirname(logPath), { recursive: true });
+    await fs13.mkdir(path13.dirname(logPath), { recursive: true });
     let existing = [];
     try {
-      const content = await fs12.readFile(logPath, "utf-8");
+      const content = await fs13.readFile(logPath, "utf-8");
       existing = JSON.parse(content);
       if (!Array.isArray(existing)) existing = [];
     } catch {
       existing = [];
     }
     existing.push(entry);
-    await fs12.writeFile(logPath, JSON.stringify(existing, null, 2), "utf-8");
+    await fs13.writeFile(logPath, JSON.stringify(existing, null, 2), "utf-8");
   } catch (err) {
     log.debug("crystallization", "appendCrystallizationLog failed", err);
   }
 }
 async function appendRejection(candidate, postmortemFilename, rejectionsPath) {
   try {
-    await fs12.mkdir(path12.dirname(rejectionsPath), { recursive: true });
+    await fs13.mkdir(path13.dirname(rejectionsPath), { recursive: true });
     let existing = [];
     try {
-      const content = await fs12.readFile(rejectionsPath, "utf-8");
+      const content = await fs13.readFile(rejectionsPath, "utf-8");
       existing = JSON.parse(content);
       if (!Array.isArray(existing)) existing = [];
     } catch {
@@ -3872,14 +4394,14 @@ async function appendRejection(candidate, postmortemFilename, rejectionsPath) {
     while (existing.length > MAX_REJECTIONS) {
       existing.shift();
     }
-    await fs12.writeFile(rejectionsPath, JSON.stringify(existing, null, 2), "utf-8");
+    await fs13.writeFile(rejectionsPath, JSON.stringify(existing, null, 2), "utf-8");
   } catch (err) {
     log.debug("crystallization", "appendRejection failed", err);
   }
 }
 async function loadRejectedNames(rejectionsPath) {
   try {
-    const content = await fs12.readFile(rejectionsPath, "utf-8");
+    const content = await fs13.readFile(rejectionsPath, "utf-8");
     const entries = JSON.parse(content);
     if (!Array.isArray(entries)) return [];
     return [...new Set(entries.map((e) => e.name))];
@@ -3889,7 +4411,7 @@ async function loadRejectedNames(rejectionsPath) {
 }
 async function loadSuggestionCounts(suggestionsPath) {
   try {
-    const content = await fs12.readFile(suggestionsPath, "utf-8");
+    const content = await fs13.readFile(suggestionsPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
     return parsed;
@@ -3899,10 +4421,10 @@ async function loadSuggestionCounts(suggestionsPath) {
 }
 async function incrementSuggestionCount(name, suggestionsPath) {
   try {
-    await fs12.mkdir(path12.dirname(suggestionsPath), { recursive: true });
+    await fs13.mkdir(path13.dirname(suggestionsPath), { recursive: true });
     const counts = await loadSuggestionCounts(suggestionsPath);
     counts[name] = (counts[name] || 0) + 1;
-    await fs12.writeFile(suggestionsPath, JSON.stringify(counts, null, 2), "utf-8");
+    await fs13.writeFile(suggestionsPath, JSON.stringify(counts, null, 2), "utf-8");
     return counts[name];
   } catch (err) {
     log.debug("crystallization", "incrementSuggestionCount failed", err);
@@ -4213,10 +4735,10 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
       }
       console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path14.join(process.cwd(), ".acore", "context.md");
-    if (fs14.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path15.join(process.cwd(), ".acore", "context.md");
+    if (fs15.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs14.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs15.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -4234,7 +4756,7 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs14.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs15.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
@@ -4338,7 +4860,7 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
       try {
         const client = ctx.llmClient;
         if (client) {
-          const rejectionsPath = path14.join(
+          const rejectionsPath = path15.join(
             os13.homedir(),
             ".aman-agent",
             "crystallization-rejections.json"
@@ -4368,18 +4890,18 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
               }
             }
             if (report.crystallizationCandidates && report.crystallizationCandidates.length > 0) {
-              const skillsMdPath = path14.join(os13.homedir(), ".askill", "skills.md");
-              const logPath = path14.join(
+              const skillsMdPath = path15.join(os13.homedir(), ".askill", "skills.md");
+              const logPath = path15.join(
                 os13.homedir(),
                 ".aman-agent",
                 "crystallization-log.json"
               );
-              const rejectionsPath2 = path14.join(
+              const rejectionsPath2 = path15.join(
                 os13.homedir(),
                 ".aman-agent",
                 "crystallization-rejections.json"
               );
-              const suggestionsPath = path14.join(
+              const suggestionsPath = path15.join(
                 os13.homedir(),
                 ".aman-agent",
                 "crystallization-suggestions.json"
@@ -4526,12 +5048,12 @@ You are being delegated a specific task by the primary agent. Complete this task
 </delegation>`;
     let finalDelegationPrompt = delegationPrompt;
     try {
-      const recall2 = await memoryRecall(task, { limit: 3, compact: true });
-      if (recall2.total > 0) {
+      const recall3 = await memoryRecall(task, { limit: 3, compact: true });
+      if (recall3.total > 0) {
         finalDelegationPrompt += `
 
 <relevant-memories>
-${recall2.text}
+${recall3.text}
 </relevant-memories>`;
       }
     } catch {
@@ -4658,43 +5180,43 @@ import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from
 import { Client as Client3 } from "@modelcontextprotocol/sdk/client/index.js";
 
 // src/teams.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs17 from "fs";
+import path17 from "path";
 import os15 from "os";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path16.join(os15.homedir(), ".acore", "teams");
+  return path17.join(os15.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path16.join(ensureTeamsDir(), `${slug}.json`);
+  return path17.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs16.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs17.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs16.existsSync(fp)) return null;
+  if (!fs17.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs16.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs17.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs16.existsSync(dir)) return [];
+  if (!fs17.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs16.readdirSync(dir)) {
+  for (const file of fs17.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs16.readFileSync(path16.join(dir, file), "utf-8");
+      const content = fs17.readFileSync(path17.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -4703,8 +5225,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs16.existsSync(fp)) return false;
-  fs16.unlinkSync(fp);
+  if (!fs17.existsSync(fp)) return false;
+  fs17.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -4931,23 +5453,23 @@ var BUILT_IN_TEAMS = [
 
 // src/plans.ts
 init_logger();
-import fs17 from "fs";
-import path17 from "path";
+import fs18 from "fs";
+import path18 from "path";
 import os16 from "os";
 function getPlansDir() {
-  const localDir = path17.join(process.cwd(), ".acore", "plans");
-  const localAcore = path17.join(process.cwd(), ".acore");
-  if (fs17.existsSync(localAcore)) return localDir;
-  return path17.join(os16.homedir(), ".acore", "plans");
+  const localDir = path18.join(process.cwd(), ".acore", "plans");
+  const localAcore = path18.join(process.cwd(), ".acore");
+  if (fs18.existsSync(localAcore)) return localDir;
+  return path18.join(os16.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path17.join(ensurePlansDir(), `${slug}.md`);
+  return path18.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -4973,7 +5495,7 @@ function parsePlan(content, filePath) {
     const createdMatch = content.match(/\*\*Created:\*\*\s*(.+)/);
     const updatedMatch = content.match(/\*\*Updated:\*\*\s*(.+)/);
     const activeMatch = content.match(/\*\*Active:\*\*\s*(.+)/);
-    const name = nameMatch?.[1]?.trim() || path17.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path18.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -5015,22 +5537,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs17.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs18.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs17.existsSync(fp)) return null;
-  const content = fs17.readFileSync(fp, "utf-8");
+  if (!fs18.existsSync(fp)) return null;
+  const content = fs18.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs17.existsSync(dir)) return [];
+  if (!fs18.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs17.readdirSync(dir)) {
+  for (const file of fs18.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path17.join(dir, file);
-    const content = fs17.readFileSync(fp, "utf-8");
+    const fp = path18.join(dir, file);
+    const content = fs18.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -5129,8 +5651,8 @@ init_user_model();
 
 // src/background.ts
 init_logger();
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 import os17 from "os";
 import pc5 from "picocolors";
 var BACKGROUND_ELIGIBLE = /* @__PURE__ */ new Set([
@@ -5170,13 +5692,13 @@ var NEVER_BACKGROUND = /* @__PURE__ */ new Set([
   "file_list",
   "avatar_prompt"
 ]);
-var TASK_LOG_DIR = path18.join(os17.homedir(), ".aman-agent");
-var TASK_LOG_FILE = path18.join(TASK_LOG_DIR, "bg-tasks.json");
+var TASK_LOG_DIR = path19.join(os17.homedir(), ".aman-agent");
+var TASK_LOG_FILE = path19.join(TASK_LOG_DIR, "bg-tasks.json");
 var MAX_LOG_ENTRIES = 50;
 function loadTaskLog() {
   try {
-    if (!fs18.existsSync(TASK_LOG_FILE)) return [];
-    const raw = fs18.readFileSync(TASK_LOG_FILE, "utf-8");
+    if (!fs19.existsSync(TASK_LOG_FILE)) return [];
+    const raw = fs19.readFileSync(TASK_LOG_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -5184,9 +5706,9 @@ function loadTaskLog() {
 }
 function saveTaskLog(entries) {
   try {
-    if (!fs18.existsSync(TASK_LOG_DIR)) fs18.mkdirSync(TASK_LOG_DIR, { recursive: true });
+    if (!fs19.existsSync(TASK_LOG_DIR)) fs19.mkdirSync(TASK_LOG_DIR, { recursive: true });
     const trimmed = entries.slice(-MAX_LOG_ENTRIES);
-    fs18.writeFileSync(TASK_LOG_FILE, JSON.stringify(trimmed, null, 2));
+    fs19.writeFileSync(TASK_LOG_FILE, JSON.stringify(trimmed, null, 2));
   } catch (err) {
     log.debug("background", "Failed to save task log", err);
   }
@@ -5335,10 +5857,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs19.existsSync(filePath)) {
+  if (!fs20.existsSync(filePath)) {
     return pc6.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs19.readFileSync(filePath, "utf-8").trim();
+  return fs20.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -5423,8 +5945,8 @@ async function handleIdentityCommand(action, args, _ctx) {
     }
     if (args.includes("--reset")) {
       const modelPath = defaultModelPath();
-      if (fs19.existsSync(modelPath)) {
-        fs19.unlinkSync(modelPath);
+      if (fs20.existsSync(modelPath)) {
+        fs20.unlinkSync(modelPath);
         return { handled: true, output: pc6.green("User model reset. Starting fresh.") };
       }
       return { handled: true, output: pc6.dim("No user model to reset.") };
@@ -5670,7 +6192,7 @@ ${result.violations.map((v) => `  - ${v}`).join("\n")}`)
 async function handleWorkflowsCommand(action, args, ctx) {
   const home2 = os18.homedir();
   if (!action) {
-    const content = readEcosystemFile(path19.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path20.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -5692,7 +6214,7 @@ async function handleWorkflowsCommand(action, args, ctx) {
       return { handled: true, output: pc6.yellow("Usage: /workflows get <name>") };
     }
     const name = args.join(" ").toLowerCase();
-    const raw = readEcosystemFile(path19.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path20.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -5752,11 +6274,11 @@ async function handleToolsCommand(action, args, _ctx) {
     }
     const query = args.join(" ").toLowerCase();
     const home2 = os18.homedir();
-    const toolsFile = path19.join(home2, ".akit", "tools.md");
-    if (!fs19.existsSync(toolsFile)) {
+    const toolsFile = path20.join(home2, ".akit", "tools.md");
+    if (!fs20.existsSync(toolsFile)) {
       return { handled: true, output: pc6.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
     }
-    const raw = fs19.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs20.readFileSync(toolsFile, "utf-8").trim();
     const lines = raw.split("\n");
     const matches = lines.filter((l) => l.toLowerCase().includes(query));
     if (matches.length === 0) {
@@ -5769,7 +6291,7 @@ async function handleToolsCommand(action, args, _ctx) {
 async function handleSkillsCommand(action, args, ctx) {
   const home2 = os18.homedir();
   if (!action) {
-    const content = readEcosystemFile(path19.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path20.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -5792,7 +6314,7 @@ async function handleSkillsCommand(action, args, ctx) {
     }
     const query = args.join(" ").toLowerCase();
     const home3 = os18.homedir();
-    const raw = readEcosystemFile(path19.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const raw = readEcosystemFile(path20.join(home3, ".askill", "skills.md"), "skills (askill)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -5806,23 +6328,23 @@ async function handleSkillsCommand(action, args, ctx) {
   if (action === "list") {
     const autoOnly = args.includes("--auto");
     if (autoOnly) {
-      const logPath = path19.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
+      const logPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
       try {
-        const content2 = fs19.readFileSync(logPath, "utf-8");
+        const content2 = fs20.readFileSync(logPath, "utf-8");
         const entries = JSON.parse(content2);
         if (entries.length === 0) {
           return { handled: true, output: pc6.dim("No crystallized skills yet.") };
         }
-        const suggestionsPath = path19.join(os18.homedir(), ".aman-agent", "crystallization-suggestions.json");
+        const suggestionsPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-suggestions.json");
         let sugCounts = {};
         try {
-          const sc = fs19.readFileSync(suggestionsPath, "utf-8");
+          const sc = fs20.readFileSync(suggestionsPath, "utf-8");
           sugCounts = JSON.parse(sc);
         } catch {
         }
         let versionCounts = {};
         try {
-          const skillsContent = fs19.readFileSync(path19.join(os18.homedir(), ".askill", "skills.md"), "utf-8");
+          const skillsContent = fs20.readFileSync(path20.join(os18.homedir(), ".askill", "skills.md"), "utf-8");
           const versionRe = /^# (.+)\.v(\d+)$/gm;
           let vMatch;
           while ((vMatch = versionRe.exec(skillsContent)) !== null) {
@@ -5847,13 +6369,13 @@ async function handleSkillsCommand(action, args, ctx) {
         return { handled: true, output: pc6.dim("No crystallized skills yet.") };
       }
     }
-    const content = readEcosystemFile(path19.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path20.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "crystallize") {
-    const pmDir = path19.join(os18.homedir(), ".acore", "postmortems");
+    const pmDir = path20.join(os18.homedir(), ".acore", "postmortems");
     try {
-      const files = fs19.readdirSync(pmDir);
+      const files = fs20.readdirSync(pmDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
       if (jsonFiles.length === 0) {
         return {
@@ -5862,7 +6384,7 @@ async function handleSkillsCommand(action, args, ctx) {
         };
       }
       const latest = jsonFiles[0];
-      const content = fs19.readFileSync(path19.join(pmDir, latest), "utf-8");
+      const content = fs20.readFileSync(path20.join(pmDir, latest), "utf-8");
       const report = JSON.parse(content);
       if (!report.crystallizationCandidates || report.crystallizationCandidates.length === 0) {
         return {
@@ -5870,8 +6392,8 @@ async function handleSkillsCommand(action, args, ctx) {
           output: pc6.dim(`No crystallization candidates in the most recent post-mortem (${latest}). Run a longer session or wait for the next auto-postmortem.`)
         };
       }
-      const skillsMdPath = path19.join(os18.homedir(), ".askill", "skills.md");
-      const logPath = path19.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
+      const skillsMdPath = path20.join(os18.homedir(), ".askill", "skills.md");
+      const logPath = path20.join(os18.homedir(), ".aman-agent", "crystallization-log.json");
       const postmortemFilename = latest.replace(/\.json$/, ".md");
       const lines = [
         pc6.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
@@ -5930,7 +6452,7 @@ async function handleSkillsCommand(action, args, ctx) {
 async function handleEvalCommand(action, args, ctx) {
   const home2 = os18.homedir();
   if (!action) {
-    const content = readEcosystemFile(path19.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path20.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -5942,10 +6464,10 @@ async function handleEvalCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path19.join(home2, ".aeval", "eval.md");
+    const evalFile = path20.join(home2, ".aeval", "eval.md");
     const lines = [pc6.bold("\u{1F4CA} Eval Report")];
-    if (fs19.existsSync(evalFile)) {
-      lines.push("", fs19.readFileSync(evalFile, "utf-8").trim());
+    if (fs20.existsSync(evalFile)) {
+      lines.push("", fs20.readFileSync(evalFile, "utf-8").trim());
     } else {
       lines.push("", pc6.dim("No eval log yet. Use /eval milestone <text> to start."));
     }
@@ -6503,10 +7025,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path19.join(os18.homedir(), ".aman-agent"),
-    memory: path19.join(os18.homedir(), ".amem"),
-    identity: path19.join(os18.homedir(), ".acore"),
-    rules: path19.join(os18.homedir(), ".arules")
+    config: path20.join(os18.homedir(), ".aman-agent"),
+    memory: path20.join(os18.homedir(), ".amem"),
+    identity: path20.join(os18.homedir(), ".acore"),
+    rules: path20.join(os18.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -6531,15 +7053,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs19.existsSync(dir)) {
-      fs19.rmSync(dir, { recursive: true, force: true });
+    if (fs20.existsSync(dir)) {
+      fs20.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir2 = dirs.config;
-    fs19.mkdirSync(configDir2, { recursive: true });
-    fs19.writeFileSync(path19.join(configDir2, ".reconfig"), "", "utf-8");
+    fs20.mkdirSync(configDir2, { recursive: true });
+    fs20.writeFileSync(path20.join(configDir2, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc6.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -6556,20 +7078,19 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.31.0" : "unknown";
+    const local = true ? "0.33.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc6.green("Up to date")} \u2014 v${local}` };
     }
+    const isVendored = process.execPath.includes(path20.join(".aman-agent", "node"));
+    const updateCmd = isVendored ? "aman-agent update" : "npm install -g @aman_asmuei/aman-agent@latest";
     return {
       handled: true,
       output: [
         `${pc6.yellow("Update available:")} v${local} \u2192 v${current}`,
         "",
         `Run this in your terminal:`,
-        `  ${pc6.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
-        "",
-        `Or use npx (always latest):`,
-        `  ${pc6.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc6.bold(updateCmd)}`
       ].join("\n")
     };
   } catch {
@@ -6577,10 +7098,7 @@ function handleUpdate() {
       handled: true,
       output: [
         `To update, run in your terminal:`,
-        `  ${pc6.bold("npm install -g @aman_asmuei/aman-agent@latest")}`,
-        "",
-        `Or use npx (always latest):`,
-        `  ${pc6.bold("npx @aman_asmuei/aman-agent@latest")}`
+        `  ${pc6.bold("npm install -g @aman_asmuei/aman-agent@latest")}`
       ].join("\n")
     };
   }
@@ -6600,11 +7118,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path19.join(os18.homedir(), ".aman-agent", "debug.log");
-  if (!fs19.existsSync(logPath)) {
+  const logPath = path20.join(os18.homedir(), ".aman-agent", "debug.log");
+  if (!fs20.existsSync(logPath)) {
     return { handled: true, output: pc6.dim("No debug log found.") };
   }
-  const content = fs19.readFileSync(logPath, "utf-8");
+  const content = fs20.readFileSync(logPath, "utf-8");
   const lines = content.trim().split("\n");
   const last20 = lines.slice(-20).join("\n");
   return { handled: true, output: pc6.bold("Debug Log (last 20 entries):\n") + pc6.dim(last20) };
@@ -6884,7 +7402,7 @@ ${text3}` };
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path19.join(os18.homedir(), ".acore", "profiles");
+  const profilesDir = path20.join(os18.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -6952,8 +7470,8 @@ ${pc6.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path19.join(profilesDir, slug);
-      if (fs19.existsSync(profileDir)) {
+      const profileDir = path20.join(profilesDir, slug);
+      if (fs20.existsSync(profileDir)) {
         return { handled: true, output: pc6.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -6969,16 +7487,16 @@ ${pc6.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs19.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path19.join(os18.homedir(), ".acore", "core.md");
-      if (fs19.existsSync(globalCore)) {
-        let content = fs19.readFileSync(globalCore, "utf-8");
+      fs20.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path20.join(os18.homedir(), ".acore", "core.md");
+      if (fs20.existsSync(globalCore)) {
+        let content = fs20.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs19.writeFileSync(path19.join(profileDir, "core.md"), content, "utf-8");
+        fs20.writeFileSync(path20.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs19.writeFileSync(path19.join(profileDir, "core.md"), `# ${aiName}
+        fs20.writeFileSync(path20.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -6991,7 +7509,7 @@ ${pc6.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc6.green(`Profile created: ${slug}`) + `
-  Edit: ${path19.join(profileDir, "core.md")}
+  Edit: ${path20.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc6.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -7000,9 +7518,9 @@ ${pc6.dim("Edit with: /profile edit")}` };
     case "show": {
       const name = args[0];
       if (!name) return { handled: true, output: pc6.yellow("Usage: /profile show <name>") };
-      const profileDir = path19.join(profilesDir, name);
-      if (!fs19.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
-      const files = fs19.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path20.join(profilesDir, name);
+      if (!fs20.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      const files = fs20.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc6.bold(name)}
 Files:
@@ -7011,9 +7529,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc6.yellow("Usage: /profile delete <name>") };
-      const profileDir = path19.join(profilesDir, name);
-      if (!fs19.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
-      fs19.rmSync(profileDir, { recursive: true });
+      const profileDir = path20.join(profilesDir, name);
+      if (!fs20.existsSync(profileDir)) return { handled: true, output: pc6.red(`Profile not found: ${name}`) };
+      fs20.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc6.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -7231,10 +7749,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path19.join(os18.homedir(), ".acore", "core.md");
+  const corePath = path20.join(os18.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs19.existsSync(corePath)) {
-    const content = fs19.readFileSync(corePath, "utf-8");
+  if (fs20.existsSync(corePath)) {
+    const content = fs20.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -7632,9 +8150,9 @@ init_logger();
 
 // src/skill-engine.ts
 init_logger();
-import fs20 from "fs";
+import fs21 from "fs";
 import fsp from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import os19 from "os";
 var SKILL_TRIGGERS = {
   testing: ["test", "spec", "coverage", "tdd", "jest", "vitest", "mocha", "assert", "mock", "stub", "fixture", "e2e", "integration test", "unit test"],
@@ -7664,20 +8182,20 @@ async function loadRuntimeTriggers(skillsMdPath) {
     return /* @__PURE__ */ new Map();
   }
 }
-var LEVEL_FILE = path20.join(os19.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path21.join(os19.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs20.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs20.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs21.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs21.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path20.dirname(LEVEL_FILE);
-  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-  fs20.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path21.dirname(LEVEL_FILE);
+  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
+  fs21.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -7904,7 +8422,7 @@ async function autoTriggerSkills(userInput, mcpManager) {
     const result = await mcpManager.callTool("skill_list", {});
     const skills = JSON.parse(result);
     const installed = skills.filter((s) => s.installed).map((s) => s.name);
-    const skillsMdPath = path20.join(os19.homedir(), ".askill", "skills.md");
+    const skillsMdPath = path21.join(os19.homedir(), ".askill", "skills.md");
     const runtimeTriggers = await loadRuntimeTriggers(skillsMdPath);
     if (installed.length === 0 && runtimeTriggers.size === 0) return "";
     const matched = matchSkillsSemantic(userInput, installed, runtimeTriggers);
@@ -8337,6 +8855,9 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
   }
 }
 
+// src/agent.ts
+init_token_budget();
+
 // src/errors.ts
 var ERROR_MAPPINGS = [
   { pattern: /rate.?limit|429/i, message: "Rate limited. I'll retry automatically." },
@@ -8358,8 +8879,8 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs21 from "fs";
-import path21 from "path";
+import fs22 from "fs";
+import path22 from "path";
 import os20 from "os";
 var HINTS = [
   {
@@ -8398,11 +8919,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path21.join(os20.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path22.join(os20.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs21.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs21.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs22.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs22.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -8411,9 +8932,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path21.dirname(HINTS_FILE);
-    fs21.mkdirSync(dir, { recursive: true });
-    fs21.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path22.dirname(HINTS_FILE);
+    fs22.mkdirSync(dir, { recursive: true });
+    fs22.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -8680,9 +9201,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path22.join(os21.homedir(), ".aman-agent", "exports");
-          fs22.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path22.join(exportDir, `${sessionId}.md`);
+          const exportDir = path23.join(os21.homedir(), ".aman-agent", "exports");
+          fs23.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path23.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -8696,7 +9217,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs22.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs23.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -8822,25 +9343,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path22.join(os21.homedir(), filePath.slice(2));
+        filePath = path23.join(os21.homedir(), filePath.slice(2));
       }
-      if (!fs22.existsSync(filePath) || !fs22.statSync(filePath).isFile()) continue;
-      const ext = path22.extname(filePath).toLowerCase();
+      if (!fs23.existsSync(filePath) || !fs23.statSync(filePath).isFile()) continue;
+      const ext = path23.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs22.statSync(filePath);
+          const stat = fs23.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path22.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path23.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs22.readFileSync(filePath).toString("base64");
+          const data = fs23.readFileSync(filePath).toString("base64");
           const mediaType = mimeMap[ext] || "image/png";
           imageBlocks.push({
             type: "image",
             source: { type: "base64", media_type: mediaType, data }
           });
-          process.stdout.write(pc7.dim(`  [attached image: ${path22.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path23.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -8848,7 +9369,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs22.readFileSync(filePath, "utf-8");
+          const content = fs23.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -8858,7 +9379,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path22.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path23.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -8867,7 +9388,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path22.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path23.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -8876,7 +9397,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path22.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path23.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -8888,7 +9409,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path22.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path23.basename(filePath)}]
 `));
           }
         } else {
@@ -8944,10 +9465,10 @@ ${converted}
     let augmentedSystemPrompt = activeSystemPrompt;
     let memoryTokens = 0;
     {
-      const recall2 = await recallForMessage(input);
-      if (recall2) {
-        augmentedSystemPrompt = activeSystemPrompt + recall2.text;
-        memoryTokens = recall2.tokenEstimate;
+      const recall3 = await recallForMessage(input);
+      if (recall3) {
+        augmentedSystemPrompt = activeSystemPrompt + recall3.text;
+        memoryTokens = recall3.tokenEstimate;
       }
     }
     const userTurnCount = messages.filter((m) => m.role === "user").length;
@@ -9280,7 +9801,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs22.existsSync(path22.join(os21.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs23.existsSync(path23.join(os21.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -9326,9 +9847,8 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs23 from "fs";
-import path23 from "path";
-import os22 from "os";
+import fs27 from "fs";
+import path28 from "path";
 
 // src/presets.ts
 var PRESETS = {
@@ -9542,9 +10062,12 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.31.0",
+  version: "0.33.0",
   description: "Your AI companion, running locally \u2014 powered by the aman ecosystem",
   type: "module",
+  engines: {
+    node: ">=18.0.0"
+  },
   bin: {
     "aman-agent": "./bin/aman-agent.js"
   },
@@ -9832,9 +10355,9 @@ async function runServe(opts) {
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path23.join(os22.homedir(), ".aman-agent", ".reconfig");
-  if (fs23.existsSync(reconfigMarker)) {
-    fs23.unlinkSync(reconfigMarker);
+  const reconfigMarker = path28.join(homeDir(), ".reconfig");
+  if (fs27.existsSync(reconfigMarker)) {
+    fs27.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -9863,11 +10386,10 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os22.homedir();
-  const corePath = path23.join(home2, ".acore", "core.md");
-  if (fs23.existsSync(corePath)) return false;
-  fs23.mkdirSync(path23.join(home2, ".acore"), { recursive: true });
-  fs23.writeFileSync(corePath, [
+  const corePath = path28.join(identityDir(), "core.md");
+  if (fs27.existsSync(corePath)) return false;
+  fs27.mkdirSync(identityDir(), { recursive: true });
+  fs27.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -9879,11 +10401,10 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path23.join(home2, ".arules");
-  const rulesPath = path23.join(rulesDir, "rules.md");
-  if (!fs23.existsSync(rulesPath)) {
-    fs23.mkdirSync(rulesDir, { recursive: true });
-    fs23.writeFileSync(rulesPath, [
+  const rulesPath = path28.join(rulesDir(), "rules.md");
+  if (!fs27.existsSync(rulesPath)) {
+    fs27.mkdirSync(rulesDir(), { recursive: true });
+    fs27.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -9895,22 +10416,20 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowDir = path23.join(home2, ".aflow");
-  const flowPath = path23.join(flowDir, "flow.md");
-  if (!fs23.existsSync(flowPath)) {
-    fs23.mkdirSync(flowDir, { recursive: true });
-    fs23.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowPath = path28.join(workflowsDir(), "flow.md");
+  if (!fs27.existsSync(flowPath)) {
+    fs27.mkdirSync(workflowsDir(), { recursive: true });
+    fs27.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillDir = path23.join(home2, ".askill");
-  const skillPath = path23.join(skillDir, "skills.md");
-  if (!fs23.existsSync(skillPath)) {
-    fs23.mkdirSync(skillDir, { recursive: true });
-    fs23.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillPath = path28.join(skillsDir(), "skills.md");
+  if (!fs27.existsSync(skillPath)) {
+    fs27.mkdirSync(skillsDir(), { recursive: true });
+    fs27.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
   }
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.31.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.33.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) => {
   p4.intro(pc9.bold("aman agent") + pc9.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -9922,6 +10441,11 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
       p4.log.info(pc9.dim("Change anytime with /reset config"));
       saveConfig(config);
     } else {
+      if (!process.stdin.isTTY) {
+        console.error("Error: No LLM provider configured.");
+        console.error("Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run interactively: aman-agent");
+        process.exit(1);
+      }
       p4.log.info("First-time setup \u2014 configure your LLM connection.");
       const provider = await p4.select({
         message: "LLM provider",
@@ -10134,6 +10658,15 @@ program.name("aman-agent").description("Your AI companion, running locally").ver
   const model = options.model || config.model;
   const s = p4.spinner();
   s.start("Loading ecosystem");
+  const migration = migrateIfNeeded();
+  if (migration.migrated.length > 0) {
+    for (const dir of migration.migrated) {
+      p4.log.info(`Migrated \u2192 ~/.aman-agent/${dir}/`);
+    }
+  }
+  process.env.ACORE_HOME = identityDir();
+  process.env.ARULES_HOME = rulesDir();
+  process.env.AMEM_DIR = memoryDir();
   const isFirstRun = bootstrapEcosystem();
   if (!hasUserIdentity()) {
     s.stop("Ecosystem loaded");
@@ -10251,19 +10784,18 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p4.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  const home2 = os22.homedir();
-  fs23.mkdirSync(path23.join(home2, ".acore"), { recursive: true });
-  fs23.writeFileSync(path23.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  fs27.mkdirSync(identityDir(), { recursive: true });
+  fs27.writeFileSync(path28.join(identityDir(), "core.md"), result.coreMd, "utf-8");
   p4.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs23.mkdirSync(path23.join(home2, ".arules"), { recursive: true });
-    fs23.writeFileSync(path23.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs27.mkdirSync(rulesDir(), { recursive: true });
+    fs27.writeFileSync(path28.join(rulesDir(), "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p4.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs23.mkdirSync(path23.join(home2, ".aflow"), { recursive: true });
-    fs23.writeFileSync(path23.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs27.mkdirSync(workflowsDir(), { recursive: true });
+    fs27.writeFileSync(path28.join(workflowsDir(), "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p4.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }
@@ -10292,5 +10824,121 @@ program.command("serve").description("Run aman-agent as a local MCP server other
     process.exit(1);
   }
 });
+program.command("dev [path]").description("Set up project context and start Claude Code").option("--smart", "Use LLM to generate CLAUDE.md").option("--no-launch", "Generate CLAUDE.md only, don't start claude").option("--force", "Regenerate even if CLAUDE.md is fresh").option("--diff", "Show what would change without writing").action(async (projectPath, opts) => {
+  const { runDev: runDev2 } = await Promise.resolve().then(() => (init_dev_command(), dev_command_exports));
+  const { scanStack: scanStack2 } = await Promise.resolve().then(() => (init_stack_detector(), stack_detector_exports));
+  const targetPath = projectPath ?? process.cwd();
+  const stack = scanStack2(targetPath);
+  const stackParts = stack.languages.map((l) => l.charAt(0).toUpperCase() + l.slice(1));
+  if (stack.frameworks.length > 0) {
+    stackParts.push(`(${stack.frameworks.map((f) => f.charAt(0).toUpperCase() + f.slice(1)).join(", ")})`);
+  }
+  if (stack.databases.length > 0) {
+    stackParts.push(...stack.databases.map((d) => d.charAt(0).toUpperCase() + d.slice(1)));
+  }
+  if (stack.infra.length > 0) {
+    stackParts.push(...stack.infra.map((i) => i.charAt(0).toUpperCase() + i.slice(1)));
+  }
+  if (stack.languages.length > 0) {
+    console.log(`
+  ${pc9.cyan("Detected:")} ${stackParts.join(" + ")}`);
+  } else {
+    console.log(`
+  ${pc9.dim("No stack detected \u2014 generating minimal CLAUDE.md")}`);
+  }
+  const result = await runDev2(targetPath, {
+    smart: opts.smart,
+    noLaunch: opts.launch === false,
+    force: opts.force,
+    diff: opts.diff
+  }, stack);
+  if (!result.success) {
+    console.error(`  ${pc9.red("Error:")} ${result.error}`);
+    process.exit(1);
+  }
+  if (result.diff) {
+    console.log(`
+${result.diff}`);
+    return;
+  }
+  if (result.generated) {
+    const mode = opts.smart ? "smart" : "template";
+    const memCount = result.context?.metadata.memoriesUsed ?? 0;
+    console.log(`  ${pc9.cyan("Recalled:")} ${memCount} memories`);
+    console.log(`  ${pc9.green("\u2713")} CLAUDE.md written (${mode} mode)
+`);
+  } else if (result.skippedReason === "fresh") {
+    console.log(`  ${pc9.green("\u2713")} CLAUDE.md is up to date
+`);
+  }
+  if (opts.launch !== false && !opts.diff) {
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    try {
+      execFileSync4("which", ["claude"], { stdio: "ignore" });
+    } catch {
+      console.log(`  ${pc9.yellow("Claude Code not found.")} Install: npm install -g @anthropic-ai/claude-code`);
+      process.exit(1);
+    }
+    console.log(`  ${pc9.cyan("Launching Claude Code...")}
+`);
+    execFileSync4("claude", [], { cwd: targetPath, stdio: "inherit" });
+  }
+});
+program.command("setup").description("Run the full configuration wizard (provider, identity, presets)").action(async () => {
+  p4.intro(pc9.bold("aman agent setup") + pc9.dim(" \u2014 full configuration wizard"));
+  const reconfigPath = path28.join(homeDir(), ".reconfig");
+  fs27.mkdirSync(homeDir(), { recursive: true });
+  fs27.writeFileSync(reconfigPath, "", "utf-8");
+  p4.log.info("Configuration reset. Restart aman-agent to complete setup.");
+});
+program.command("update").description("Update aman-agent to the latest version").action(async () => {
+  const { execFileSync: execFileSync4 } = await import("child_process");
+  const isVendored = process.execPath.includes(path28.join(".aman-agent", "node"));
+  if (isVendored) {
+    const npmPath = path28.join(homeDir(), "node", "bin", "npm");
+    console.log("Updating aman-agent...");
+    try {
+      execFileSync4(npmPath, ["install", "-g", "@aman_asmuei/aman-agent@latest"], {
+        stdio: "inherit",
+        env: { ...process.env, PREFIX: homeDir() }
+      });
+      console.log("\u2713 Updated successfully.");
+    } catch {
+      console.error("Update failed. Try manually: npm install -g @aman_asmuei/aman-agent@latest");
+      process.exit(1);
+    }
+  } else {
+    console.log("Updating via npm...");
+    try {
+      execFileSync4("npm", ["install", "-g", "@aman_asmuei/aman-agent@latest"], {
+        stdio: "inherit"
+      });
+      console.log("\u2713 Updated successfully.");
+    } catch {
+      console.error("Update failed. Try manually: npm install -g @aman_asmuei/aman-agent@latest");
+      process.exit(1);
+    }
+  }
+});
+program.command("uninstall").description("Remove aman-agent and all its data").action(async () => {
+  const home2 = homeDir();
+  if (!process.stdin.isTTY) {
+    fs27.rmSync(home2, { recursive: true, force: true });
+    console.log("\u2713 Removed " + home2);
+    return;
+  }
+  const confirm3 = await p4.confirm({
+    message: `This will delete ${home2} and all your data (memory, identity, config). Continue?`
+  });
+  if (!confirm3 || p4.isCancel(confirm3)) {
+    console.log("Cancelled.");
+    return;
+  }
+  fs27.rmSync(home2, { recursive: true, force: true });
+  console.log("\u2713 Removed " + home2);
+  console.log("");
+  console.log("To complete uninstall, remove the PATH line from your shell config:");
+  console.log('  Remove: export PATH="$HOME/.aman-agent/bin:$PATH"');
+});
 program.parse();
 //# sourceMappingURL=index.js.map