@aman_asmuei/aman-agent 0.25.0 → 0.26.0

package/dist/index.js

@@ -1387,18 +1387,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs18 from "fs";
-import path18 from "path";
-import os17 from "os";
+import fs19 from "fs";
+import path19 from "path";
+import os18 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs15 from "fs";
-import path15 from "path";
-import os14 from "os";
+import fs16 from "fs";
+import path16 from "path";
+import os15 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc5 from "picocolors";
 
@@ -2361,8 +2361,9 @@ import pc3 from "picocolors";
 // src/hooks.ts
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
+import os12 from "os";
 
 // src/personality.ts
 var FRUSTRATION_SIGNALS = [
@@ -2689,8 +2690,28 @@ Return ONLY valid JSON matching this schema (no markdown, no explanation):
   "decisions": ["key choices made with rationale"],
   "sentimentArc": "how mood evolved during session",
   "patterns": ["recurring behaviors worth remembering for future sessions"],
-  "recommendations": ["actionable suggestions for next session"]
-}`;
+  "recommendations": ["actionable suggestions for next session"],
+  "crystallizationCandidates": [
+    {
+      "name": "lowercase-kebab-name",
+      "description": "1-sentence description of when this would be useful",
+      "triggers": ["3-8", "trigger", "keywords"],
+      "approach": "1-paragraph context: when and why to use this procedure",
+      "steps": ["ordered step 1", "ordered step 2"],
+      "gotchas": ["common mistake 1"],
+      "confidence": 0.0
+    }
+  ]
+}
+
+CRYSTALLIZATION RULES:
+- Only suggest 0-2 candidates per session \u2014 if nothing qualifies, return an empty array
+- Only suggest REUSABLE procedures (not one-off tasks specific to today's work)
+- The user must have demonstrated the procedure in this session
+- Confidence < 0.6 \u2192 don't suggest at all
+- Skip vague things like "use library X" \u2014 that's not procedural knowledge
+- Prefer narrow specific procedures over broad generalizations
+- Trigger keywords should be highly specific (avoid generic words like "code", "fix", "the")`;
 async function generatePostmortemReport(sessionId, messages, session, client, obsDir) {
   try {
     const events = await readObservationEvents(sessionId, obsDir ?? defaultObservationsDir2());
@@ -2770,7 +2791,8 @@ ${obsSnapshot.join("\n")}`;
       topicProgression: [...new Set(topicProgression)],
       sentimentArc: parsed.sentimentArc ?? "",
       patterns: parsed.patterns ?? [],
-      recommendations: parsed.recommendations ?? []
+      recommendations: parsed.recommendations ?? [],
+      crystallizationCandidates: Array.isArray(parsed.crystallizationCandidates) ? parsed.crystallizationCandidates : void 0
     };
   } catch (err) {
     log.debug("postmortem", "Failed to generate post-mortem", err);
@@ -2841,6 +2863,14 @@ function formatPostmortemMarkdown(report) {
     report.recommendations.forEach((r) => lines.push(`- ${r}`));
     lines.push("");
   }
+  if (report.crystallizationCandidates && report.crystallizationCandidates.length > 0) {
+    lines.push("## Crystallization Candidates");
+    report.crystallizationCandidates.forEach((c) => {
+      lines.push(`- **${c.name}** (confidence ${c.confidence})`);
+      lines.push(`  ${c.description}`);
+    });
+    lines.push("");
+  }
   return lines.join("\n");
 }
 async function savePostmortem(report, dir) {
@@ -2851,6 +2881,12 @@ async function savePostmortem(report, dir) {
   const filePath = path11.join(pmDir, fileName);
   const markdown = formatPostmortemMarkdown(report);
   await fs11.writeFile(filePath, markdown, "utf-8");
+  const jsonPath = filePath.replace(/\.md$/, ".json");
+  try {
+    await fs11.writeFile(jsonPath, JSON.stringify(report, null, 2), "utf-8");
+  } catch (err) {
+    log.debug("postmortem", "JSON sidecar write failed", err);
+  }
   return filePath;
 }
 async function listPostmortems(dir) {
@@ -2911,6 +2947,259 @@ ${contents.join("\n\n---\n\n")}`
   }
 }
 
+// src/crystallization.ts
+import fs12 from "fs/promises";
+import path12 from "path";
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "is",
+  "to",
+  "of",
+  "a",
+  "in",
+  "for",
+  "on",
+  "with",
+  "this",
+  "that",
+  "it",
+  "as",
+  "be",
+  "by",
+  "or",
+  "at",
+  "an",
+  "from",
+  "code",
+  "fix",
+  "do",
+  "use",
+  "make",
+  "get",
+  "set",
+  "run",
+  "we",
+  "i"
+]);
+var MAX_REJECTIONS = 100;
+var MARKER_RE = /<!--\s*aman-auto\s+([^>]+?)\s*-->/;
+function sanitizeName(input) {
+  const cleaned = input.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (cleaned.length === 0) {
+    throw new Error(`Cannot sanitize name: "${input}" produced empty result`);
+  }
+  return cleaned;
+}
+function validateCandidate(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const c = raw;
+  if (typeof c.name !== "string" || c.name.trim() === "") return null;
+  if (typeof c.description !== "string") return null;
+  if (typeof c.approach !== "string") return null;
+  if (!Array.isArray(c.triggers) || c.triggers.length === 0) return null;
+  if (c.triggers.length > 10) return null;
+  if (!Array.isArray(c.steps)) return null;
+  if (typeof c.confidence !== "number") return null;
+  if (!Number.isFinite(c.confidence)) return null;
+  if (c.confidence < 0.6) return null;
+  const triggers = Array.from(
+    new Set(
+      c.triggers.filter((t) => typeof t === "string").map((t) => t.toLowerCase().trim()).filter((t) => t.length > 0 && !STOPWORDS.has(t))
+    )
+  );
+  if (triggers.length === 0) return null;
+  let name;
+  try {
+    name = sanitizeName(c.name);
+  } catch {
+    return null;
+  }
+  return {
+    name,
+    description: c.description,
+    triggers,
+    approach: c.approach,
+    steps: c.steps.filter((s) => typeof s === "string"),
+    gotchas: Array.isArray(c.gotchas) ? c.gotchas.filter((g) => typeof g === "string") : [],
+    confidence: Math.min(1, Math.max(0, c.confidence))
+  };
+}
+function toTitleCase(kebab) {
+  return kebab.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function formatSkillMarkdown(candidate, postmortemFilename) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const heading = toTitleCase(candidate.name);
+  const triggerStr = candidate.triggers.join(",");
+  const lines = [
+    `# ${heading}`,
+    `<!-- aman-auto source=postmortem date=${date} confidence=${candidate.confidence} triggers="${triggerStr}" -->`,
+    "",
+    "## When to use",
+    candidate.approach,
+    "",
+    "## Steps",
+    ...candidate.steps.map((s, i) => `${i + 1}. ${s}`),
+    ""
+  ];
+  if (candidate.gotchas.length > 0) {
+    lines.push("## Gotchas");
+    lines.push(...candidate.gotchas.map((g) => `- ${g}`));
+    lines.push("");
+  }
+  lines.push(`<!-- generated from ${postmortemFilename} -->`);
+  lines.push("");
+  return lines.join("\n");
+}
+function parseMarkerComment(line) {
+  const match = line.match(MARKER_RE);
+  if (!match) return null;
+  const attrs = {};
+  const attrRe = /(\w+)=(?:"([^"]*)"|(\S+))/g;
+  let m;
+  while ((m = attrRe.exec(match[1])) !== null) {
+    attrs[m[1]] = m[2] ?? m[3] ?? "";
+  }
+  if (!attrs.triggers) return null;
+  const triggers = attrs.triggers.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  if (triggers.length === 0) return null;
+  return {
+    source: attrs.source ?? "unknown",
+    date: attrs.date ?? "",
+    confidence: attrs.confidence ? Number(attrs.confidence) : 0,
+    triggers
+  };
+}
+function extractSkillsWithMarkers(skillsMdContent) {
+  const result = /* @__PURE__ */ new Map();
+  const lines = skillsMdContent.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("# ") && i + 1 < lines.length) {
+      const headingText = line.slice(2).trim();
+      const nextLine = lines[i + 1];
+      const marker = parseMarkerComment(nextLine);
+      if (marker) {
+        try {
+          const skillName = sanitizeName(headingText);
+          result.set(skillName, marker);
+        } catch {
+          log.debug("crystallization", `cannot sanitize heading: ${headingText}`);
+        }
+      }
+    }
+  }
+  return result;
+}
+function findCollision(name, triggers, existing) {
+  if (existing.has(name)) {
+    return { collides: true, collidesWith: name, reason: "exact name match" };
+  }
+  const triggerSet = new Set(triggers);
+  for (const [otherName, otherData] of existing) {
+    const otherTriggers = new Set(otherData.triggers);
+    const intersection = [...triggerSet].filter((t) => otherTriggers.has(t)).length;
+    const union = (/* @__PURE__ */ new Set([...triggerSet, ...otherTriggers])).size;
+    const overlap = union > 0 ? intersection / union : 0;
+    if (overlap >= 0.8) {
+      return {
+        collides: true,
+        collidesWith: otherName,
+        reason: `${Math.round(overlap * 100)}% trigger overlap`
+      };
+    }
+  }
+  return { collides: false };
+}
+async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
+  try {
+    await fs12.mkdir(path12.dirname(skillsMdPath), { recursive: true });
+    let existingContent = "";
+    try {
+      existingContent = await fs12.readFile(skillsMdPath, "utf-8");
+    } catch {
+      existingContent = "# Skills\n\n";
+    }
+    if (existingContent.trim() === "") {
+      existingContent = "# Skills\n\n";
+    }
+    const existingSkills = extractSkillsWithMarkers(existingContent);
+    const collision = findCollision(candidate.name, candidate.triggers, existingSkills);
+    if (collision.collides) {
+      log.debug("crystallization", `collision detected: ${collision.reason}`);
+      return {
+        written: false,
+        filePath: skillsMdPath,
+        skillName: candidate.name,
+        reason: `collision with "${collision.collidesWith}" (${collision.reason})`
+      };
+    }
+    const skillMarkdown = formatSkillMarkdown(candidate, postmortemFilename);
+    const separator = existingContent.endsWith("\n\n") ? "" : existingContent.endsWith("\n") ? "\n" : "\n\n";
+    await fs12.writeFile(
+      skillsMdPath,
+      existingContent + separator + skillMarkdown,
+      "utf-8"
+    );
+    return {
+      written: true,
+      filePath: skillsMdPath,
+      skillName: candidate.name
+    };
+  } catch (err) {
+    log.warn("crystallization", "writeSkillToFile failed", err);
+    return {
+      written: false,
+      filePath: skillsMdPath,
+      skillName: candidate.name,
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function appendCrystallizationLog(entry, logPath) {
+  try {
+    await fs12.mkdir(path12.dirname(logPath), { recursive: true });
+    let existing = [];
+    try {
+      const content = await fs12.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");
+  } catch (err) {
+    log.debug("crystallization", "appendCrystallizationLog failed", err);
+  }
+}
+async function appendRejection(candidate, postmortemFilename, rejectionsPath) {
+  try {
+    await fs12.mkdir(path12.dirname(rejectionsPath), { recursive: true });
+    let existing = [];
+    try {
+      const content = await fs12.readFile(rejectionsPath, "utf-8");
+      existing = JSON.parse(content);
+      if (!Array.isArray(existing)) existing = [];
+    } catch {
+      existing = [];
+    }
+    existing.push({
+      name: candidate.name,
+      rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fromPostmortem: postmortemFilename,
+      triggers: candidate.triggers
+    });
+    while (existing.length > MAX_REJECTIONS) {
+      existing.shift();
+    }
+    await fs12.writeFile(rejectionsPath, JSON.stringify(existing, null, 2), "utf-8");
+  } catch (err) {
+    log.debug("crystallization", "appendRejection failed", err);
+  }
+}
+
 // src/hooks.ts
 function getTimeContext() {
   const now = /* @__PURE__ */ new Date();
@@ -3179,10 +3468,10 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
       }
       console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path12.join(process.cwd(), ".acore", "context.md");
-    if (fs12.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path13.join(process.cwd(), ".acore", "context.md");
+    if (fs13.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs12.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs13.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -3200,7 +3489,7 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs12.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs13.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
@@ -3278,6 +3567,75 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
               } catch {
               }
             }
+            if (report.crystallizationCandidates && report.crystallizationCandidates.length > 0) {
+              const skillsMdPath = path13.join(os12.homedir(), ".askill", "skills.md");
+              const logPath = path13.join(
+                os12.homedir(),
+                ".aman-agent",
+                "crystallization-log.json"
+              );
+              const rejectionsPath = path13.join(
+                os12.homedir(),
+                ".aman-agent",
+                "crystallization-rejections.json"
+              );
+              const postmortemFilename = `${report.date}-${report.sessionId.slice(0, 4)}.md`;
+              console.log(
+                pc2.dim(`
+  Crystallization candidates: ${report.crystallizationCandidates.length}`)
+              );
+              let skipAll = false;
+              for (const rawCandidate of report.crystallizationCandidates) {
+                if (skipAll) break;
+                const candidate = validateCandidate(rawCandidate);
+                if (!candidate) {
+                  log.debug("hooks", "candidate failed validation");
+                  continue;
+                }
+                const choice = await p2.select({
+                  message: `Crystallize "${candidate.name}" as a reusable skill?`,
+                  options: [
+                    { value: "accept", label: "Yes \u2014 write to ~/.askill/skills.md" },
+                    { value: "reject", label: "No \u2014 skip this one" },
+                    { value: "skip-all", label: "Skip all crystallization for this session" }
+                  ],
+                  initialValue: "reject"
+                });
+                if (p2.isCancel(choice) || choice === "skip-all") {
+                  skipAll = true;
+                  break;
+                }
+                if (choice === "accept") {
+                  const result = await writeSkillToFile(
+                    candidate,
+                    skillsMdPath,
+                    postmortemFilename
+                  );
+                  if (result.written) {
+                    console.log(
+                      pc2.green(`  \u2713 Crystallized: ${candidate.name} \u2192 ${result.filePath}`)
+                    );
+                    console.log(pc2.dim(`    Triggers: ${candidate.triggers.join(", ")}`));
+                    console.log(pc2.dim(`    Will auto-activate next session.`));
+                    await appendCrystallizationLog(
+                      {
+                        name: candidate.name,
+                        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                        fromPostmortem: postmortemFilename,
+                        confidence: candidate.confidence,
+                        triggers: candidate.triggers
+                      },
+                      logPath
+                    );
+                  } else {
+                    console.log(pc2.yellow(`  \u2298 Could not crystallize: ${result.reason}`));
+                  }
+                } else {
+                  console.log(pc2.dim(`  Skipped: ${candidate.name}`));
+                  await appendRejection(candidate, postmortemFilename, rejectionsPath);
+                }
+              }
+            }
           }
         }
       } catch (err) {
@@ -3437,43 +3795,43 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 }
 
 // src/teams.ts
-import fs13 from "fs";
-import path13 from "path";
-import os12 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path13.join(os12.homedir(), ".acore", "teams");
+  return path14.join(os13.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path13.join(ensureTeamsDir(), `${slug}.json`);
+  return path14.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs13.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs14.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs13.existsSync(fp)) return null;
+  if (!fs14.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs13.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs14.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs13.existsSync(dir)) return [];
+  if (!fs14.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs13.readdirSync(dir)) {
+  for (const file of fs14.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs13.readFileSync(path13.join(dir, file), "utf-8");
+      const content = fs14.readFileSync(path14.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -3482,8 +3840,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs13.existsSync(fp)) return false;
-  fs13.unlinkSync(fp);
+  if (!fs14.existsSync(fp)) return false;
+  fs14.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -3709,23 +4067,23 @@ var BUILT_IN_TEAMS = [
 ];
 
 // src/plans.ts
-import fs14 from "fs";
-import path14 from "path";
-import os13 from "os";
+import fs15 from "fs";
+import path15 from "path";
+import os14 from "os";
 function getPlansDir() {
-  const localDir = path14.join(process.cwd(), ".acore", "plans");
-  const localAcore = path14.join(process.cwd(), ".acore");
-  if (fs14.existsSync(localAcore)) return localDir;
-  return path14.join(os13.homedir(), ".acore", "plans");
+  const localDir = path15.join(process.cwd(), ".acore", "plans");
+  const localAcore = path15.join(process.cwd(), ".acore");
+  if (fs15.existsSync(localAcore)) return localDir;
+  return path15.join(os14.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path14.join(ensurePlansDir(), `${slug}.md`);
+  return path15.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -3751,7 +4109,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() || path14.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path15.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -3793,22 +4151,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs14.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs15.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs14.existsSync(fp)) return null;
-  const content = fs14.readFileSync(fp, "utf-8");
+  if (!fs15.existsSync(fp)) return null;
+  const content = fs15.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs14.existsSync(dir)) return [];
+  if (!fs15.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs14.readdirSync(dir)) {
+  for (const file of fs15.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path14.join(dir, file);
-    const content = fs14.readFileSync(fp, "utf-8");
+    const fp = path15.join(dir, file);
+    const content = fs15.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -3917,10 +4275,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs15.existsSync(filePath)) {
+  if (!fs16.existsSync(filePath)) {
     return pc5.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs15.readFileSync(filePath, "utf-8").trim();
+  return fs16.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -4195,9 +4553,9 @@ ${result.violations.map((v) => `  - ${v}`).join("\n")}`)
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os14.homedir();
+  const home2 = os15.homedir();
   if (!action) {
-    const content = readEcosystemFile(path15.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path16.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -4219,7 +4577,7 @@ async function handleWorkflowsCommand(action, args, ctx) {
       return { handled: true, output: pc5.yellow("Usage: /workflows get <name>") };
     }
     const name = args.join(" ").toLowerCase();
-    const raw = readEcosystemFile(path15.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path16.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -4278,12 +4636,12 @@ async function handleToolsCommand(action, args, _ctx) {
       return { handled: true, output: pc5.yellow("Usage: /tools search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home2 = os14.homedir();
-    const toolsFile = path15.join(home2, ".akit", "tools.md");
-    if (!fs15.existsSync(toolsFile)) {
+    const home2 = os15.homedir();
+    const toolsFile = path16.join(home2, ".akit", "tools.md");
+    if (!fs16.existsSync(toolsFile)) {
       return { handled: true, output: pc5.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
     }
-    const raw = fs15.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs16.readFileSync(toolsFile, "utf-8").trim();
     const lines = raw.split("\n");
     const matches = lines.filter((l) => l.toLowerCase().includes(query));
     if (matches.length === 0) {
@@ -4294,9 +4652,9 @@ async function handleToolsCommand(action, args, _ctx) {
   return handleAkitCommand(action, args);
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os14.homedir();
+  const home2 = os15.homedir();
   if (!action) {
-    const content = readEcosystemFile(path15.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path16.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -4318,8 +4676,8 @@ async function handleSkillsCommand(action, args, ctx) {
       return { handled: true, output: pc5.yellow("Usage: /skills search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home3 = os14.homedir();
-    const raw = readEcosystemFile(path15.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const home3 = os15.homedir();
+    const raw = readEcosystemFile(path16.join(home3, ".askill", "skills.md"), "skills (askill)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -4330,21 +4688,111 @@ async function handleSkillsCommand(action, args, ctx) {
     }
     return { handled: true, output: [pc5.bold(`Skills matching "${query}":`), ...matches].join("\n") };
   }
+  if (action === "list") {
+    const autoOnly = args.includes("--auto");
+    if (autoOnly) {
+      const logPath = path16.join(os15.homedir(), ".aman-agent", "crystallization-log.json");
+      try {
+        const content2 = fs16.readFileSync(logPath, "utf-8");
+        const entries = JSON.parse(content2);
+        if (entries.length === 0) {
+          return { handled: true, output: pc5.dim("No crystallized skills yet.") };
+        }
+        const lines = [pc5.bold(`Crystallized skills (${entries.length}):`)];
+        for (const entry of entries) {
+          const date = entry.createdAt.slice(0, 10);
+          lines.push(`  ${pc5.cyan(entry.name)} (${date}, conf ${entry.confidence})`);
+          lines.push(pc5.dim(`    triggers: ${entry.triggers.join(", ")}`));
+        }
+        return { handled: true, output: lines.join("\n") };
+      } catch {
+        return { handled: true, output: pc5.dim("No crystallized skills yet.") };
+      }
+    }
+    const content = readEcosystemFile(path16.join(home2, ".askill", "skills.md"), "skills (askill)");
+    return { handled: true, output: content };
+  }
+  if (action === "crystallize") {
+    const pmDir = path16.join(os15.homedir(), ".acore", "postmortems");
+    try {
+      const files = fs16.readdirSync(pmDir);
+      const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
+      if (jsonFiles.length === 0) {
+        return {
+          handled: true,
+          output: pc5.dim("No post-mortems found. Run a session that triggers a post-mortem first.")
+        };
+      }
+      const latest = jsonFiles[0];
+      const content = fs16.readFileSync(path16.join(pmDir, latest), "utf-8");
+      const report = JSON.parse(content);
+      if (!report.crystallizationCandidates || report.crystallizationCandidates.length === 0) {
+        return {
+          handled: true,
+          output: pc5.dim(`No crystallization candidates in the most recent post-mortem (${latest}). Run a longer session or wait for the next auto-postmortem.`)
+        };
+      }
+      const skillsMdPath = path16.join(os15.homedir(), ".askill", "skills.md");
+      const logPath = path16.join(os15.homedir(), ".aman-agent", "crystallization-log.json");
+      const postmortemFilename = latest.replace(/\.json$/, ".md");
+      const lines = [
+        pc5.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
+      ];
+      let written = 0;
+      for (const raw of report.crystallizationCandidates) {
+        const candidate = validateCandidate(raw);
+        if (!candidate) {
+          const rawName = raw.name ?? "unknown";
+          lines.push(pc5.dim(`  \u2298 ${rawName} \u2014 failed validation`));
+          continue;
+        }
+        const result = await writeSkillToFile(candidate, skillsMdPath, postmortemFilename);
+        if (result.written) {
+          written++;
+          lines.push(pc5.green(`  \u2713 Crystallized: ${candidate.name}`));
+          await appendCrystallizationLog(
+            {
+              name: candidate.name,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              fromPostmortem: postmortemFilename,
+              confidence: candidate.confidence,
+              triggers: candidate.triggers
+            },
+            logPath
+          );
+        } else {
+          lines.push(pc5.yellow(`  \u2298 ${candidate.name} \u2014 ${result.reason}`));
+        }
+      }
+      if (written > 0) {
+        lines.push("");
+        lines.push(pc5.dim(`Crystallized skills will auto-activate in your next session.`));
+      }
+      return { handled: true, output: lines.join("\n") };
+    } catch (err) {
+      return {
+        handled: true,
+        output: pc5.red(`Failed to load post-mortems: ${err instanceof Error ? err.message : String(err)}`)
+      };
+    }
+  }
   if (action === "help") {
     return { handled: true, output: [
       pc5.bold("Skills commands:"),
-      `  ${pc5.cyan("/skills")}                    View installed skills`,
-      `  ${pc5.cyan("/skills install")} <name>      Install a skill`,
-      `  ${pc5.cyan("/skills uninstall")} <name>    Uninstall a skill`,
-      `  ${pc5.cyan("/skills search")} <query>       Search skills by name/description`
+      `  ${pc5.cyan("/skills")}                      View installed skills`,
+      `  ${pc5.cyan("/skills install")} <name>        Install a skill`,
+      `  ${pc5.cyan("/skills uninstall")} <name>      Uninstall a skill`,
+      `  ${pc5.cyan("/skills search")} <query>         Search skills by name/description`,
+      `  ${pc5.cyan("/skills crystallize")}            Crystallize skills from most recent post-mortem`,
+      `  ${pc5.cyan("/skills list --auto")}            List crystallized (auto-created) skills`
     ].join("\n") };
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os14.homedir();
+  const home2 = os15.homedir();
   if (!action) {
-    const content = readEcosystemFile(path15.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path16.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -4356,11 +4804,11 @@ async function handleEvalCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path15.join(home2, ".aeval", "eval.md");
-    if (!fs15.existsSync(evalFile)) {
+    const evalFile = path16.join(home2, ".aeval", "eval.md");
+    if (!fs16.existsSync(evalFile)) {
       return { handled: true, output: pc5.dim("No eval report found. Log milestones with /eval milestone <text>.") };
     }
-    const content = fs15.readFileSync(evalFile, "utf-8").trim();
+    const content = fs16.readFileSync(evalFile, "utf-8").trim();
     return { handled: true, output: [pc5.bold("Eval Report"), "", content].join("\n") };
   }
   return { handled: true, output: pc5.yellow(`Unknown action: /eval ${action}. Use /eval, /eval report, or /eval milestone <text>.`) };
@@ -4852,7 +5300,7 @@ function handleHelp() {
       `  ${pc5.cyan("/rules")}        View rules [add|remove|toggle ...]`,
       `  ${pc5.cyan("/workflows")}    View workflows [add|remove ...]`,
       `  ${pc5.cyan("/akit")}         Manage tools [add|remove <tool>]`,
-      `  ${pc5.cyan("/skills")}       View skills [install|uninstall ...]`,
+      `  ${pc5.cyan("/skills")}       View skills [install|uninstall|crystallize|list --auto]`,
       `  ${pc5.cyan("/eval")}         View evaluation [milestone ...]`,
       `  ${pc5.cyan("/memory")}       View recent memories [search|fts|since|stats|export|clear|timeline]`,
       `  ${pc5.cyan("/reminder")}     Manage reminders [set|check|done]`,
@@ -4884,10 +5332,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path15.join(os14.homedir(), ".aman-agent"),
-    memory: path15.join(os14.homedir(), ".amem"),
-    identity: path15.join(os14.homedir(), ".acore"),
-    rules: path15.join(os14.homedir(), ".arules")
+    config: path16.join(os15.homedir(), ".aman-agent"),
+    memory: path16.join(os15.homedir(), ".amem"),
+    identity: path16.join(os15.homedir(), ".acore"),
+    rules: path16.join(os15.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -4912,15 +5360,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs15.existsSync(dir)) {
-      fs15.rmSync(dir, { recursive: true, force: true });
+    if (fs16.existsSync(dir)) {
+      fs16.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir = dirs.config;
-    fs15.mkdirSync(configDir, { recursive: true });
-    fs15.writeFileSync(path15.join(configDir, ".reconfig"), "", "utf-8");
+    fs16.mkdirSync(configDir, { recursive: true });
+    fs16.writeFileSync(path16.join(configDir, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc5.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -4937,7 +5385,7 @@ function handleReset(action) {
 function handleUpdate() {
   try {
     const current = execFileSync3("npm", ["view", "@aman_asmuei/aman-agent", "version"], { encoding: "utf-8" }).trim();
-    const local = true ? "0.25.0" : "unknown";
+    const local = true ? "0.26.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -4981,11 +5429,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path15.join(os14.homedir(), ".aman-agent", "debug.log");
-  if (!fs15.existsSync(logPath)) {
+  const logPath = path16.join(os15.homedir(), ".aman-agent", "debug.log");
+  if (!fs16.existsSync(logPath)) {
     return { handled: true, output: pc5.dim("No debug log found.") };
   }
-  const content = fs15.readFileSync(logPath, "utf-8");
+  const content = fs16.readFileSync(logPath, "utf-8");
   const lines = content.trim().split("\n");
   const last20 = lines.slice(-20).join("\n");
   return { handled: true, output: pc5.bold("Debug Log (last 20 entries):\n") + pc5.dim(last20) };
@@ -5183,7 +5631,7 @@ ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path15.join(os14.homedir(), ".acore", "profiles");
+  const profilesDir = path16.join(os15.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -5251,8 +5699,8 @@ ${pc5.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path15.join(profilesDir, slug);
-      if (fs15.existsSync(profileDir)) {
+      const profileDir = path16.join(profilesDir, slug);
+      if (fs16.existsSync(profileDir)) {
         return { handled: true, output: pc5.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -5268,16 +5716,16 @@ ${pc5.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs15.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path15.join(os14.homedir(), ".acore", "core.md");
-      if (fs15.existsSync(globalCore)) {
-        let content = fs15.readFileSync(globalCore, "utf-8");
+      fs16.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path16.join(os15.homedir(), ".acore", "core.md");
+      if (fs16.existsSync(globalCore)) {
+        let content = fs16.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs15.writeFileSync(path15.join(profileDir, "core.md"), content, "utf-8");
+        fs16.writeFileSync(path16.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs15.writeFileSync(path15.join(profileDir, "core.md"), `# ${aiName}
+        fs16.writeFileSync(path16.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -5290,7 +5738,7 @@ ${pc5.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc5.green(`Profile created: ${slug}`) + `
-  Edit: ${path15.join(profileDir, "core.md")}
+  Edit: ${path16.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc5.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -5299,9 +5747,9 @@ ${pc5.dim("Edit with: /profile edit")}` };
     case "show": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile show <name>") };
-      const profileDir = path15.join(profilesDir, name);
-      if (!fs15.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      const files = fs15.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path16.join(profilesDir, name);
+      if (!fs16.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      const files = fs16.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc5.bold(name)}
 Files:
@@ -5310,9 +5758,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile delete <name>") };
-      const profileDir = path15.join(profilesDir, name);
-      if (!fs15.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      fs15.rmSync(profileDir, { recursive: true });
+      const profileDir = path16.join(profilesDir, name);
+      if (!fs16.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      fs16.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc5.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -5530,10 +5978,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path15.join(os14.homedir(), ".acore", "core.md");
+  const corePath = path16.join(os15.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs15.existsSync(corePath)) {
-    const content = fs15.readFileSync(corePath, "utf-8");
+  if (fs16.existsSync(corePath)) {
+    const content = fs16.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -5920,9 +6368,10 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs16 from "fs";
-import path16 from "path";
-import os15 from "os";
+import fs17 from "fs";
+import fsp from "fs/promises";
+import path17 from "path";
+import os16 from "os";
 var SKILL_TRIGGERS = {
   testing: ["test", "spec", "coverage", "tdd", "jest", "vitest", "mocha", "assert", "mock", "stub", "fixture", "e2e", "integration test", "unit test"],
   "api-design": ["api", "endpoint", "rest", "graphql", "route", "controller", "middleware", "http", "request", "response", "status code", "pagination"],
@@ -5937,20 +6386,34 @@ var SKILL_TRIGGERS = {
   typescript: ["typescript", "type", "interface", "generic", "infer", "utility type", "zod", "discriminated union", "type guard", "as const"],
   accessibility: ["accessibility", "a11y", "aria", "screen reader", "wcag", "semantic html", "tab order", "focus", "contrast"]
 };
-var LEVEL_FILE = path16.join(os15.homedir(), ".aman-agent", "skill-levels.json");
+async function loadRuntimeTriggers(skillsMdPath) {
+  try {
+    const content = await fsp.readFile(skillsMdPath, "utf-8");
+    const skills = extractSkillsWithMarkers(content);
+    const result = /* @__PURE__ */ new Map();
+    for (const [name, marker] of skills) {
+      result.set(name, marker.triggers);
+    }
+    return result;
+  } catch (err) {
+    log.debug("skill-engine", "loadRuntimeTriggers failed", err);
+    return /* @__PURE__ */ new Map();
+  }
+}
+var LEVEL_FILE = path17.join(os16.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs16.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs16.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs17.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs17.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path16.dirname(LEVEL_FILE);
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path17.dirname(LEVEL_FILE);
+  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  fs17.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -5969,20 +6432,28 @@ function recordActivation(skillName) {
   saveSkillLevels(levels);
   return computeLevel(levels[skillName].activations);
 }
-function matchSkills(userInput, installedSkillNames) {
+function matchSkills(userInput, installedSkillNames, runtimeTriggers = /* @__PURE__ */ new Map()) {
   const input = userInput.toLowerCase();
-  const matched = [];
+  const matched = /* @__PURE__ */ new Set();
   for (const skillName of installedSkillNames) {
     const triggers = SKILL_TRIGGERS[skillName];
     if (!triggers) continue;
     for (const trigger of triggers) {
       if (input.includes(trigger)) {
-        matched.push(skillName);
+        matched.add(skillName);
         break;
       }
     }
   }
-  return matched;
+  for (const [skillName, triggers] of runtimeTriggers) {
+    for (const trigger of triggers) {
+      if (input.includes(trigger)) {
+        matched.add(skillName);
+        break;
+      }
+    }
+  }
+  return Array.from(matched);
 }
 function formatSkillContext(skillName, skillContent, level) {
   let depthHint;
@@ -6006,8 +6477,10 @@ 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);
-    if (installed.length === 0) return "";
-    const matched = matchSkills(userInput, installed);
+    const skillsMdPath = path17.join(os16.homedir(), ".askill", "skills.md");
+    const runtimeTriggers = await loadRuntimeTriggers(skillsMdPath);
+    if (installed.length === 0 && runtimeTriggers.size === 0) return "";
+    const matched = matchSkills(userInput, installed, runtimeTriggers);
     if (matched.length === 0) return "";
     const blocks = [];
     for (const skillName of matched.slice(0, 2)) {
@@ -6563,9 +7036,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs17 from "fs";
-import path17 from "path";
-import os16 from "os";
+import fs18 from "fs";
+import path18 from "path";
+import os17 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -6603,11 +7076,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path17.join(os16.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path18.join(os17.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs17.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs17.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs18.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs18.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -6616,9 +7089,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path17.dirname(HINTS_FILE);
-    fs17.mkdirSync(dir, { recursive: true });
-    fs17.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path18.dirname(HINTS_FILE);
+    fs18.mkdirSync(dir, { recursive: true });
+    fs18.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -6885,9 +7358,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path18.join(os17.homedir(), ".aman-agent", "exports");
-          fs18.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path18.join(exportDir, `${sessionId}.md`);
+          const exportDir = path19.join(os18.homedir(), ".aman-agent", "exports");
+          fs19.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path19.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -6901,7 +7374,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs18.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs19.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -7027,25 +7500,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path18.join(os17.homedir(), filePath.slice(2));
+        filePath = path19.join(os18.homedir(), filePath.slice(2));
       }
-      if (!fs18.existsSync(filePath) || !fs18.statSync(filePath).isFile()) continue;
-      const ext = path18.extname(filePath).toLowerCase();
+      if (!fs19.existsSync(filePath) || !fs19.statSync(filePath).isFile()) continue;
+      const ext = path19.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs18.statSync(filePath);
+          const stat = fs19.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path18.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path19.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs18.readFileSync(filePath).toString("base64");
+          const data = fs19.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: ${path18.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path19.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -7053,7 +7526,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs18.readFileSync(filePath, "utf-8");
+          const content = fs19.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -7063,7 +7536,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path18.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path19.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -7072,7 +7545,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path18.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path19.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -7081,7 +7554,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path18.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path19.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -7093,7 +7566,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path18.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path19.basename(filePath)}]
 `));
           }
         } else {
@@ -7397,7 +7870,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs18.existsSync(path18.join(os17.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs19.existsSync(path19.join(os18.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -7443,9 +7916,9 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs19 from "fs";
-import path19 from "path";
-import os18 from "os";
+import fs20 from "fs";
+import path20 from "path";
+import os19 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -7554,9 +8027,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path19.join(os18.homedir(), ".aman-agent", ".reconfig");
-  if (fs19.existsSync(reconfigMarker)) {
-    fs19.unlinkSync(reconfigMarker);
+  const reconfigMarker = path20.join(os19.homedir(), ".aman-agent", ".reconfig");
+  if (fs20.existsSync(reconfigMarker)) {
+    fs20.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -7585,11 +8058,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os18.homedir();
-  const corePath = path19.join(home2, ".acore", "core.md");
-  if (fs19.existsSync(corePath)) return false;
-  fs19.mkdirSync(path19.join(home2, ".acore"), { recursive: true });
-  fs19.writeFileSync(corePath, [
+  const home2 = os19.homedir();
+  const corePath = path20.join(home2, ".acore", "core.md");
+  if (fs20.existsSync(corePath)) return false;
+  fs20.mkdirSync(path20.join(home2, ".acore"), { recursive: true });
+  fs20.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -7601,11 +8074,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path19.join(home2, ".arules");
-  const rulesPath = path19.join(rulesDir, "rules.md");
-  if (!fs19.existsSync(rulesPath)) {
-    fs19.mkdirSync(rulesDir, { recursive: true });
-    fs19.writeFileSync(rulesPath, [
+  const rulesDir = path20.join(home2, ".arules");
+  const rulesPath = path20.join(rulesDir, "rules.md");
+  if (!fs20.existsSync(rulesPath)) {
+    fs20.mkdirSync(rulesDir, { recursive: true });
+    fs20.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -7617,22 +8090,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowDir = path19.join(home2, ".aflow");
-  const flowPath = path19.join(flowDir, "flow.md");
-  if (!fs19.existsSync(flowPath)) {
-    fs19.mkdirSync(flowDir, { recursive: true });
-    fs19.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowDir = path20.join(home2, ".aflow");
+  const flowPath = path20.join(flowDir, "flow.md");
+  if (!fs20.existsSync(flowPath)) {
+    fs20.mkdirSync(flowDir, { recursive: true });
+    fs20.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillDir = path19.join(home2, ".askill");
-  const skillPath = path19.join(skillDir, "skills.md");
-  if (!fs19.existsSync(skillPath)) {
-    fs19.mkdirSync(skillDir, { recursive: true });
-    fs19.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillDir = path20.join(home2, ".askill");
+  const skillPath = path20.join(skillDir, "skills.md");
+  if (!fs20.existsSync(skillPath)) {
+    fs20.mkdirSync(skillDir, { recursive: true });
+    fs20.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.25.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.26.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -7984,19 +8457,19 @@ program.command("init").description("Set up your AI companion with a guided wiza
   });
   if (p3.isCancel(preset)) process.exit(0);
   const result = applyPreset(preset, name || "Aman");
-  const home2 = os18.homedir();
-  fs19.mkdirSync(path19.join(home2, ".acore"), { recursive: true });
-  fs19.writeFileSync(path19.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os19.homedir();
+  fs20.mkdirSync(path20.join(home2, ".acore"), { recursive: true });
+  fs20.writeFileSync(path20.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
   p3.log.success(`Identity created \u2014 ${PRESETS[preset].identity.personality.split(".")[0].toLowerCase()}`);
   if (result.rulesMd) {
-    fs19.mkdirSync(path19.join(home2, ".arules"), { recursive: true });
-    fs19.writeFileSync(path19.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs20.mkdirSync(path20.join(home2, ".arules"), { recursive: true });
+    fs20.writeFileSync(path20.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
     const ruleCount = (result.rulesMd.match(/^- /gm) || []).length;
     p3.log.success(`${ruleCount} rules set`);
   }
   if (result.flowMd) {
-    fs19.mkdirSync(path19.join(home2, ".aflow"), { recursive: true });
-    fs19.writeFileSync(path19.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs20.mkdirSync(path20.join(home2, ".aflow"), { recursive: true });
+    fs20.writeFileSync(path20.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
     const wfCount = (result.flowMd.match(/^## /gm) || []).length;
     p3.log.success(`${wfCount} workflow${wfCount > 1 ? "s" : ""} added`);
   }