npm - @aman_asmuei/aman-agent - Versions diffs - 0.31.0 → 0.32.0 - Mend

@aman_asmuei/aman-agent 0.31.0 → 0.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.js CHANGED Viewed

@@ -9,22 +9,22 @@ var __export = (target, all) => {
 };
 // 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 +42,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 +50,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 +73,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 +109,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 +119,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 +386,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 +414,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 {
   }
 }
@@ -620,8 +620,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,9 +664,40 @@ function saveConfig(config) {
   );
 }
+// 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 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 { migrated };
+}
 // src/prompt.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import os3 from "os";
 // src/token-budget.ts
@@ -705,17 +754,16 @@ function buildBudgetedPrompt(components, maxTokens = 8e3) {
 }
 // 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 +794,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 +820,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 +882,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 +903,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 +911,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 +939,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 +961,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 +2024,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 +2033,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 +2079,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 +2121,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 +2288,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 +2384,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 +2479,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 +2495,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 +2511,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 +2555,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 +2569,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 +2588,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 +2910,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 +2943,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 +2968,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 +3001,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 +3197,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 +3214,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 +3250,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 +3283,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 +3317,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 +3539,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 +3556,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 +3566,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 +3613,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 +3779,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 +3803,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 +3825,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 +3866,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 +3885,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 +3920,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 +3937,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 +3947,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 +4261,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 +4282,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 +4386,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 +4416,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"
@@ -4658,43 +4706,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 +4751,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 +4979,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 +5021,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 +5063,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 +5177,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 +5218,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 +5232,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 +5383,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 +5471,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 +5718,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 +5740,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 +5800,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 +5817,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 +5840,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 +5854,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 +5895,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 +5910,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 +5918,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 +5978,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 +5990,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 +6551,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 +6579,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 +6604,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.32.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 +6624,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 +6644,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 +6928,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 +6996,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 +7013,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 +7035,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 +7044,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 +7055,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 +7275,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 +7676,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 +7708,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 +7948,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);
@@ -8358,8 +8402,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 +8442,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 +8455,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 +8724,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 +8740,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 +8866,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 +8892,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 +8902,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 +8911,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 +8920,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 +8932,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 {
@@ -9280,7 +9324,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 +9370,8 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 // src/index.ts
-import fs23 from "fs";
-import path23 from "path";
-import os22 from "os";
+import fs24 from "fs";
+import path24 from "path";
 // src/presets.ts
 var PRESETS = {
@@ -9542,9 +9585,12 @@ var Inbox = class {
 // package.json
 var package_default = {
   name: "@aman_asmuei/aman-agent",
-  version: "0.31.0",
+  version: "0.32.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 +9878,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 = path24.join(homeDir(), ".reconfig");
+  if (fs24.existsSync(reconfigMarker)) {
+    fs24.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -9863,11 +9909,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 = path24.join(identityDir(), "core.md");
+  if (fs24.existsSync(corePath)) return false;
+  fs24.mkdirSync(identityDir(), { recursive: true });
+  fs24.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -9879,11 +9924,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 = path24.join(rulesDir(), "rules.md");
+  if (!fs24.existsSync(rulesPath)) {
+    fs24.mkdirSync(rulesDir(), { recursive: true });
+    fs24.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -9895,22 +9939,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 = path24.join(workflowsDir(), "flow.md");
+  if (!fs24.existsSync(flowPath)) {
+    fs24.mkdirSync(workflowsDir(), { recursive: true });
+    fs24.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 = path24.join(skillsDir(), "skills.md");
+  if (!fs24.existsSync(skillPath)) {
+    fs24.mkdirSync(skillsDir(), { recursive: true });
+    fs24.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.32.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 +9964,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 +10181,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 +10307,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");
+  fs24.mkdirSync(identityDir(), { recursive: true });
+  fs24.writeFileSync(path24.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");
+    fs24.mkdirSync(rulesDir(), { recursive: true });
+    fs24.writeFileSync(path24.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");
+    fs24.mkdirSync(workflowsDir(), { recursive: true });
+    fs24.writeFileSync(path24.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 +10347,61 @@ program.command("serve").description("Run aman-agent as a local MCP server other
     process.exit(1);
   }
 });
+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 = path24.join(homeDir(), ".reconfig");
+  fs24.mkdirSync(homeDir(), { recursive: true });
+  fs24.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(path24.join(".aman-agent", "node"));
+  if (isVendored) {
+    const npmPath = path24.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) {
+    fs24.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;
+  }
+  fs24.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