@aman_asmuei/aman-agent 0.26.0 → 0.27.0

package/dist/index.js

@@ -1387,18 +1387,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs19 from "fs";
-import path19 from "path";
-import os18 from "os";
+import fs20 from "fs";
+import path20 from "path";
+import os19 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs16 from "fs";
-import path16 from "path";
-import os15 from "os";
+import fs17 from "fs";
+import path17 from "path";
+import os16 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc5 from "picocolors";
 
@@ -2361,9 +2361,9 @@ import pc3 from "picocolors";
 // src/hooks.ts
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
-import fs13 from "fs";
-import path13 from "path";
-import os12 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 
 // src/personality.ts
 var FRUSTRATION_SIGNALS = [
@@ -2524,13 +2524,19 @@ function formatWellbeingNudge(state) {
   if (!state.wellbeingNudge) return null;
   return WELLBEING_NUDGES[state.wellbeingNudge] || null;
 }
-async function syncPersonalityToCore(state, mcpManager) {
+async function syncPersonalityToCore(state, mcpManager, modelMetrics) {
   try {
-    await mcpManager.callTool("identity_update_dynamics", {
+    const payload = {
       currentRead: state.currentRead,
       energy: state.energy,
       activeMode: state.activeMode
-    });
+    };
+    if (modelMetrics) {
+      payload.trust = `${(modelMetrics.trustScore * 100).toFixed(0)}%`;
+      payload.sessions = modelMetrics.totalSessions;
+      payload.sentimentTrend = modelMetrics.sentimentTrend;
+    }
+    await mcpManager.callTool("identity_update_dynamics", payload);
   } catch (err) {
     log.debug("personality", "identity_update_dynamics failed", err);
   }
@@ -3200,6 +3206,258 @@ async function appendRejection(candidate, postmortemFilename, rejectionsPath) {
   }
 }
 
+// src/user-model.ts
+import fs13 from "fs/promises";
+import path13 from "path";
+import os12 from "os";
+var MAX_SESSIONS = 30;
+var TRUST_ALPHA = 0.3;
+var MIN_SESSIONS_FOR_FEED_FORWARD = 5;
+var MIN_SESSIONS_FOR_CORRELATIONS = 10;
+function defaultModelPath() {
+  return path13.join(os12.homedir(), ".acore", "user-model.json");
+}
+function createEmptyModel() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    sessions: [],
+    profile: emptyProfile(),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function emptyProfile() {
+  return {
+    trustScore: 0.5,
+    trustTrajectory: "stable",
+    totalSessions: 0,
+    preferredTimePeriod: "afternoon",
+    energyDistribution: {},
+    avgSessionMinutes: 0,
+    baselineFrustration: 0,
+    baselineExcitement: 0,
+    sentimentTrend: "stable",
+    frustrationCorrelations: { toolErrors: 0, longSessions: 0, lateNight: 0 },
+    avgTurnsPerSession: 0,
+    engagementTrend: "stable",
+    nudgeStats: {}
+  };
+}
+async function loadUserModel(filePath) {
+  const fp = filePath ?? defaultModelPath();
+  try {
+    const raw = await fs13.readFile(fp, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveUserModel(model, filePath) {
+  const fp = filePath ?? defaultModelPath();
+  const dir = path13.dirname(fp);
+  await fs13.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);
+}
+function aggregateSession(model, snapshot) {
+  const sessions = [...model.sessions, snapshot];
+  while (sessions.length > MAX_SESSIONS) {
+    sessions.shift();
+  }
+  const totalSessions = model.profile.totalSessions + 1;
+  const profile = computeProfile(sessions, totalSessions);
+  return {
+    ...model,
+    sessions,
+    profile,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function computeProfile(sessions, totalSessions) {
+  if (sessions.length === 0) return { ...emptyProfile(), totalSessions };
+  const n = sessions.length;
+  let trustScore = 0.5;
+  for (const s of sessions) {
+    trustScore = TRUST_ALPHA * ratingSignal(s) + (1 - TRUST_ALPHA) * trustScore;
+  }
+  const trustTrajectory = computeTrustTrajectory(sessions);
+  const baselineFrustration = avg(sessions.map((s) => s.avgFrustration));
+  const baselineExcitement = avg(sessions.map((s) => s.avgExcitement));
+  const sentimentTrend = computeSentimentTrend(sessions);
+  const energyDistribution = {};
+  for (const s of sessions) {
+    energyDistribution[s.timePeriod] = (energyDistribution[s.timePeriod] || 0) + 1;
+  }
+  const preferredTimePeriod = Object.entries(energyDistribution).sort(
+    (a, b) => b[1] - a[1]
+  )[0]?.[0] ?? "afternoon";
+  const avgSessionMinutes = avg(sessions.map((s) => s.durationMinutes));
+  const avgTurnsPerSession = avg(sessions.map((s) => s.turnCount));
+  const engagementTrend = computeLinearTrend(sessions.map((s) => s.turnCount));
+  const frustrationCorrelations = n >= MIN_SESSIONS_FOR_CORRELATIONS ? {
+    toolErrors: pearsonR(
+      sessions.map((s) => s.avgFrustration),
+      sessions.map((s) => s.toolErrors)
+    ),
+    longSessions: pearsonR(
+      sessions.map((s) => s.avgFrustration),
+      sessions.map((s) => s.durationMinutes)
+    ),
+    lateNight: pearsonR(
+      sessions.map((s) => s.avgFrustration),
+      sessions.map((s) => s.timePeriod === "late-night" || s.timePeriod === "night" ? 1 : 0)
+    )
+  } : { toolErrors: 0, longSessions: 0, lateNight: 0 };
+  const nudgeStats = {};
+  for (const s of sessions) {
+    const ratingVal = ratingToNumber(s.rating);
+    for (const nudge of s.wellbeingNudges) {
+      if (!nudgeStats[nudge]) nudgeStats[nudge] = { fired: 0, sessionRatingAfter: 0 };
+      nudgeStats[nudge].fired++;
+      nudgeStats[nudge].sessionRatingAfter += ratingVal;
+    }
+  }
+  for (const key of Object.keys(nudgeStats)) {
+    if (nudgeStats[key].fired > 0) {
+      nudgeStats[key].sessionRatingAfter /= nudgeStats[key].fired;
+    }
+  }
+  return {
+    trustScore,
+    trustTrajectory,
+    totalSessions,
+    preferredTimePeriod,
+    energyDistribution,
+    avgSessionMinutes,
+    baselineFrustration,
+    baselineExcitement,
+    sentimentTrend,
+    frustrationCorrelations,
+    avgTurnsPerSession,
+    engagementTrend,
+    nudgeStats
+  };
+}
+function feedForward(model) {
+  if (model.profile.totalSessions < MIN_SESSIONS_FOR_FEED_FORWARD) return null;
+  const p4 = model.profile;
+  const overrides = {
+    compactGreeting: false,
+    frustrationNudgeThreshold: 0.6,
+    defaultToPersonalMode: false
+  };
+  const nightSessions = (p4.energyDistribution["late-night"] || 0) + (p4.energyDistribution["night"] || 0);
+  const totalInWindow = model.sessions.length;
+  if (totalInWindow > 0 && nightSessions / totalInWindow >= 0.7 && p4.baselineFrustration < 0.3) {
+    overrides.energyOverride = "steady";
+  }
+  if (p4.trustScore > 0.8) {
+    overrides.compactGreeting = true;
+  }
+  if (p4.frustrationCorrelations.toolErrors > 0.4) {
+    overrides.frustrationNudgeThreshold = 0.4;
+  }
+  if (p4.sentimentTrend === "worsening") {
+    overrides.defaultToPersonalMode = true;
+  }
+  return overrides;
+}
+function clamp(val, min, max) {
+  return Math.max(min, Math.min(max, val));
+}
+function avg(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+function ratingSignal(session) {
+  if (session.rating === "great") return 1;
+  if (session.rating === "good") return 0.75;
+  if (session.rating === "okay") return 0.5;
+  if (session.rating === "frustrating") return 0.25;
+  let implicit = 1;
+  implicit -= session.avgFrustration * 0.4;
+  implicit -= session.toolErrors > 3 ? 0.2 : 0;
+  implicit -= session.blockers > 2 ? 0.2 : 0;
+  implicit += session.milestones > 0 ? 0.1 : 0;
+  return clamp(implicit, 0, 1);
+}
+function ratingToNumber(rating) {
+  if (rating === "great") return 1;
+  if (rating === "good") return 0.75;
+  if (rating === "okay") return 0.5;
+  if (rating === "frustrating") return 0.25;
+  return 0.5;
+}
+function pearsonR(x, y) {
+  const n = x.length;
+  if (n < 3) return 0;
+  const mx = avg(x);
+  const my = avg(y);
+  let num = 0;
+  let dx2 = 0;
+  let dy2 = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - mx;
+    const dy = y[i] - my;
+    num += dx * dy;
+    dx2 += dx * dx;
+    dy2 += dy * dy;
+  }
+  const denom = Math.sqrt(dx2 * dy2);
+  if (denom === 0) return 0;
+  return num / denom;
+}
+function computeTrustTrajectory(sessions) {
+  if (sessions.length < 10) return "stable";
+  const recent5 = sessions.slice(-5).map(ratingSignal);
+  const prev5 = sessions.slice(-10, -5).map(ratingSignal);
+  const recentAvg = avg(recent5);
+  const prevAvg = avg(prev5);
+  const delta = recentAvg - prevAvg;
+  if (delta > 0.1) return "ascending";
+  if (delta < -0.1) return "declining";
+  return "stable";
+}
+function computeSentimentTrend(sessions) {
+  if (sessions.length < 5) return "stable";
+  const frustrations = sessions.slice(-10).map((s) => s.avgFrustration);
+  const slope = linearSlope(frustrations);
+  if (slope > 0.02) return "worsening";
+  if (slope < -0.02) return "improving";
+  return "stable";
+}
+function computeLinearTrend(values) {
+  if (values.length < 5) return "stable";
+  const recent = values.slice(-10);
+  const slope = linearSlope(recent);
+  const mean = avg(recent);
+  const relativeSlope = mean > 0 ? slope / mean : slope;
+  if (relativeSlope > 0.03) return "increasing";
+  if (relativeSlope < -0.03) return "decreasing";
+  return "stable";
+}
+function linearSlope(values) {
+  const n = values.length;
+  if (n < 2) return 0;
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += i;
+    sumY += values[i];
+    sumXY += i * values[i];
+    sumX2 += i * i;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0) return 0;
+  return (n * sumXY - sumX * sumY) / denom;
+}
+
 // src/hooks.ts
 function getTimeContext() {
   const now = /* @__PURE__ */ new Date();
@@ -3347,6 +3605,29 @@ ${contextInjection}`;
       sessionMinutes: 0,
       turnCount: 0
     });
+    try {
+      const model = await loadUserModel();
+      if (model) {
+        const overrides = feedForward(model);
+        if (overrides) {
+          log.debug("hooks", `Feed-forward active (trust=${model.profile.trustScore.toFixed(2)}, sessions=${model.profile.totalSessions})`);
+          if (overrides.energyOverride && (period === "late-night" || period === "night")) {
+            state.energy = overrides.energyOverride;
+          }
+          if (overrides.defaultToPersonalMode && state.activeMode === "Default") {
+            state.activeMode = "Personal";
+          }
+          if (overrides.compactGreeting) {
+            greeting += "\n<user-model-context>High trust user (score: " + model.profile.trustScore.toFixed(2) + ", " + model.profile.totalSessions + " sessions). Keep greeting compact \u2014 they know you well.</user-model-context>";
+          }
+          if (model.profile.sentimentTrend === "worsening") {
+            greeting += "\n<user-model-context>Sentiment trend is worsening across recent sessions. Be more attentive and patient.</user-model-context>";
+          }
+        }
+      }
+    } catch (err) {
+      log.debug("hooks", "user model feed-forward failed", err);
+    }
     syncPersonalityToCore(state, ctx.mcpManager).catch(() => {
     });
     const nudge = formatWellbeingNudge(state);
@@ -3468,10 +3749,10 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
       }
       console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path13.join(process.cwd(), ".acore", "context.md");
-    if (fs13.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path14.join(process.cwd(), ".acore", "context.md");
+    if (fs14.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs13.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs14.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -3489,28 +3770,28 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs13.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs14.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
         log.debug("hooks", "project context update failed", err);
       }
     }
+    const sessionMinutes = Math.round((Date.now() - sessionStartTime) / 6e4);
+    const hour = (/* @__PURE__ */ new Date()).getHours();
+    let period;
+    if (hour < 6) period = "late-night";
+    else if (hour < 12) period = "morning";
+    else if (hour < 17) period = "afternoon";
+    else if (hour < 21) period = "evening";
+    else period = "night";
+    const turnCount = messages.filter((m) => m.role === "user").length;
+    const finalState = computePersonality({
+      timePeriod: period,
+      sessionMinutes,
+      turnCount
+    });
     if (ctx.config.personalityAdapt !== false) {
-      const sessionMinutes = Math.round((Date.now() - sessionStartTime) / 6e4);
-      const hour = (/* @__PURE__ */ new Date()).getHours();
-      let period;
-      if (hour < 6) period = "late-night";
-      else if (hour < 12) period = "morning";
-      else if (hour < 17) period = "afternoon";
-      else if (hour < 21) period = "evening";
-      else period = "night";
-      const turnCount = messages.filter((m) => m.role === "user").length;
-      const finalState = computePersonality({
-        timePeriod: period,
-        sessionMinutes,
-        turnCount
-      });
       try {
         isHookCall = true;
         await syncPersonalityToCore(finalState, ctx.mcpManager);
@@ -3518,6 +3799,7 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
         isHookCall = false;
       }
     }
+    let sessionRating;
     if (ctx.config.evalPrompt) {
       const rating = await p2.select({
         message: "Quick rating for this session?",
@@ -3530,10 +3812,11 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
         initialValue: "skip"
       });
       if (!p2.isCancel(rating) && rating !== "skip") {
+        sessionRating = rating;
         try {
           isHookCall = true;
           await ctx.mcpManager.callTool("eval_log", {
-            rating,
+            rating: sessionRating,
             highlights: "Quick session rating",
             improvements: ""
           });
@@ -3542,6 +3825,51 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
         }
       }
     }
+    if (turnCount >= 2 && sessionMinutes >= 1) {
+      try {
+        const snapshot = {
+          sessionId,
+          date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          durationMinutes: sessionMinutes,
+          turnCount,
+          dominantSentiment: finalState.sentiment.dominant,
+          avgFrustration: finalState.sentiment.frustration,
+          avgExcitement: finalState.sentiment.excitement,
+          avgConfusion: finalState.sentiment.confusion,
+          avgFatigue: finalState.sentiment.fatigue,
+          toolCalls: observationSession?.stats.toolCalls ?? 0,
+          toolErrors: observationSession?.stats.toolErrors ?? 0,
+          blockers: observationSession?.stats.blockers ?? 0,
+          milestones: observationSession?.stats.milestones ?? 0,
+          topicShifts: observationSession?.stats.topicShifts ?? 0,
+          peakEnergy: finalState.energy,
+          primaryMode: finalState.activeMode,
+          timePeriod: period,
+          rating: sessionRating,
+          hadPostmortem: false,
+          // updated below if postmortem is generated
+          wellbeingNudges: finalState.wellbeingNudge ? [finalState.wellbeingNudge] : []
+        };
+        const model = await loadUserModel() ?? createEmptyModel();
+        const updated = aggregateSession(model, snapshot);
+        await saveUserModel(updated);
+        log.debug("hooks", `User model updated (session ${updated.profile.totalSessions})`);
+        if (ctx.config.personalityAdapt !== false) {
+          try {
+            isHookCall = true;
+            await syncPersonalityToCore(finalState, ctx.mcpManager, {
+              trustScore: updated.profile.trustScore,
+              totalSessions: updated.profile.totalSessions,
+              sentimentTrend: updated.profile.sentimentTrend
+            });
+          } finally {
+            isHookCall = false;
+          }
+        }
+      } catch (err) {
+        log.debug("hooks", "user model aggregation failed", err);
+      }
+    }
     if (ctx.config.autoPostmortem !== false && observationSession && shouldAutoPostmortem(observationSession, messages)) {
       try {
         const client = ctx.llmClient;
@@ -3568,14 +3896,14 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
               }
             }
             if (report.crystallizationCandidates && report.crystallizationCandidates.length > 0) {
-              const skillsMdPath = path13.join(os12.homedir(), ".askill", "skills.md");
-              const logPath = path13.join(
-                os12.homedir(),
+              const skillsMdPath = path14.join(os13.homedir(), ".askill", "skills.md");
+              const logPath = path14.join(
+                os13.homedir(),
                 ".aman-agent",
                 "crystallization-log.json"
               );
-              const rejectionsPath = path13.join(
-                os12.homedir(),
+              const rejectionsPath = path14.join(
+                os13.homedir(),
                 ".aman-agent",
                 "crystallization-rejections.json"
               );
@@ -3795,43 +4123,43 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 }
 
 // src/teams.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";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path14.join(os13.homedir(), ".acore", "teams");
+  return path15.join(os14.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path14.join(ensureTeamsDir(), `${slug}.json`);
+  return path15.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs14.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs15.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs14.existsSync(fp)) return null;
+  if (!fs15.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs14.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs15.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs14.existsSync(dir)) return [];
+  if (!fs15.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs14.readdirSync(dir)) {
+  for (const file of fs15.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs14.readFileSync(path14.join(dir, file), "utf-8");
+      const content = fs15.readFileSync(path15.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -3840,8 +4168,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs14.existsSync(fp)) return false;
-  fs14.unlinkSync(fp);
+  if (!fs15.existsSync(fp)) return false;
+  fs15.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -4067,23 +4395,23 @@ var BUILT_IN_TEAMS = [
 ];
 
 // src/plans.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";
 function getPlansDir() {
-  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");
+  const localDir = path16.join(process.cwd(), ".acore", "plans");
+  const localAcore = path16.join(process.cwd(), ".acore");
+  if (fs16.existsSync(localAcore)) return localDir;
+  return path16.join(os15.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
+  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path15.join(ensurePlansDir(), `${slug}.md`);
+  return path16.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -4109,7 +4437,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() || path15.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path16.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -4151,22 +4479,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs15.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs16.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs15.existsSync(fp)) return null;
-  const content = fs15.readFileSync(fp, "utf-8");
+  if (!fs16.existsSync(fp)) return null;
+  const content = fs16.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs15.existsSync(dir)) return [];
+  if (!fs16.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs15.readdirSync(dir)) {
+  for (const file of fs16.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path15.join(dir, file);
-    const content = fs15.readFileSync(fp, "utf-8");
+    const fp = path16.join(dir, file);
+    const content = fs16.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -4275,10 +4603,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs16.existsSync(filePath)) {
+  if (!fs17.existsSync(filePath)) {
     return pc5.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs16.readFileSync(filePath, "utf-8").trim();
+  return fs17.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -4356,24 +4684,76 @@ async function handleIdentityCommand(action, args, _ctx) {
     }
   }
   if (action === "dynamics") {
+    if (args.includes("--json")) {
+      const model2 = await loadUserModel();
+      if (!model2) return { handled: true, output: pc5.dim("No user model yet. Complete a few sessions first.") };
+      return { handled: true, output: JSON.stringify(model2, null, 2) };
+    }
+    if (args.includes("--reset")) {
+      const modelPath = defaultModelPath();
+      if (fs17.existsSync(modelPath)) {
+        fs17.unlinkSync(modelPath);
+        return { handled: true, output: pc5.green("User model reset. Starting fresh.") };
+      }
+      return { handled: true, output: pc5.dim("No user model to reset.") };
+    }
     const updates = {};
     for (const arg of args) {
       const eq = arg.indexOf("=");
       if (eq > 0) updates[arg.slice(0, eq)] = arg.slice(eq + 1);
     }
-    if (!Object.keys(updates).length) {
-      return { handled: true, output: pc5.yellow("Usage: /identity dynamics energy=high mode=focused read='Book Title'") };
+    if (Object.keys(updates).length > 0) {
+      try {
+        await acoreUpdateDynamics({
+          energy: updates.energy,
+          activeMode: updates.mode,
+          currentRead: updates.read
+        }, AGENT_SCOPE);
+        return { handled: true, output: `Dynamics updated: ${Object.entries(updates).map(([k, v]) => `${k}=${v}`).join(", ")}` };
+      } catch (err) {
+        return { handled: true, output: pc5.red(`Dynamics error: ${err instanceof Error ? err.message : String(err)}`) };
+      }
     }
-    try {
-      await acoreUpdateDynamics({
-        energy: updates.energy,
-        activeMode: updates.mode,
-        currentRead: updates.read
-      }, AGENT_SCOPE);
-      return { handled: true, output: `Dynamics updated: ${Object.entries(updates).map(([k, v]) => `${k}=${v}`).join(", ")}` };
-    } catch (err) {
-      return { handled: true, output: pc5.red(`Dynamics error: ${err instanceof Error ? err.message : String(err)}`) };
+    const model = await loadUserModel();
+    if (!model) {
+      return { handled: true, output: pc5.dim("No user model yet. Complete a few sessions to start building your profile.") };
+    }
+    const p4 = model.profile;
+    const trustBar = "\u2588".repeat(Math.round(p4.trustScore * 10)) + "\u2591".repeat(10 - Math.round(p4.trustScore * 10));
+    const frustBar = "\u2588".repeat(Math.round(p4.baselineFrustration * 10)) + "\u2591".repeat(10 - Math.round(p4.baselineFrustration * 10));
+    const lines = [
+      pc5.bold("  Dynamic User Model"),
+      "",
+      `  ${pc5.cyan("Trust")}        ${trustBar} ${(p4.trustScore * 100).toFixed(0)}%  ${p4.trustTrajectory === "ascending" ? pc5.green("\u2191") : p4.trustTrajectory === "declining" ? pc5.red("\u2193") : "\u2192"}`,
+      `  ${pc5.cyan("Sessions")}     ${p4.totalSessions} total (${model.sessions.length} in window)`,
+      `  ${pc5.cyan("Sentiment")}    ${frustBar} frustration baseline  ${p4.sentimentTrend === "improving" ? pc5.green("improving") : p4.sentimentTrend === "worsening" ? pc5.red("worsening") : "stable"}`,
+      "",
+      `  ${pc5.cyan("Preferred")}    ${p4.preferredTimePeriod} (${Object.entries(p4.energyDistribution).map(([k, v]) => `${k}: ${v}`).join(", ")})`,
+      `  ${pc5.cyan("Avg session")}  ${p4.avgSessionMinutes.toFixed(0)} min, ${p4.avgTurnsPerSession.toFixed(0)} turns  ${p4.engagementTrend === "increasing" ? pc5.green("\u2191") : p4.engagementTrend === "decreasing" ? pc5.red("\u2193") : "\u2192"}`
+    ];
+    if (p4.totalSessions >= 10) {
+      const corrs = [];
+      if (Math.abs(p4.frustrationCorrelations.toolErrors) > 0.3) {
+        corrs.push(`tool errors (${p4.frustrationCorrelations.toolErrors.toFixed(2)})`);
+      }
+      if (Math.abs(p4.frustrationCorrelations.longSessions) > 0.3) {
+        corrs.push(`long sessions (${p4.frustrationCorrelations.longSessions.toFixed(2)})`);
+      }
+      if (Math.abs(p4.frustrationCorrelations.lateNight) > 0.3) {
+        corrs.push(`late night (${p4.frustrationCorrelations.lateNight.toFixed(2)})`);
+      }
+      if (corrs.length > 0) {
+        lines.push(`  ${pc5.cyan("Frustration")}  correlates with: ${corrs.join(", ")}`);
+      }
+    }
+    const nudgeKeys = Object.keys(p4.nudgeStats);
+    if (nudgeKeys.length > 0) {
+      lines.push("");
+      lines.push(`  ${pc5.cyan("Nudges")}       ${nudgeKeys.map((k) => `${k}: ${p4.nudgeStats[k].fired}\xD7`).join(", ")}`);
     }
+    lines.push("");
+    lines.push(pc5.dim(`  Use --json for raw data, --reset to start fresh`));
+    return { handled: true, output: lines.join("\n") };
   }
   if (action === "summary") {
     try {
@@ -4397,7 +4777,10 @@ async function handleIdentityCommand(action, args, _ctx) {
         pc5.bold("Identity commands:"),
         `  ${pc5.cyan("/identity")}                  View current identity`,
         `  ${pc5.cyan("/identity update")} <section>  Update a section`,
+        `  ${pc5.cyan("/identity dynamics")}           View user model (trust, sentiment, patterns)`,
         `  ${pc5.cyan("/identity dynamics")} key=val   Update dynamic fields (energy, mode, read)`,
+        `  ${pc5.cyan("/identity dynamics")} --json    Raw JSON user model`,
+        `  ${pc5.cyan("/identity dynamics")} --reset   Reset user model`,
         `  ${pc5.cyan("/identity summary")}            Show structured identity summary`
       ].join("\n")
     };
@@ -4553,9 +4936,9 @@ ${result.violations.map((v) => `  - ${v}`).join("\n")}`)
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os15.homedir();
+  const home2 = os16.homedir();
   if (!action) {
-    const content = readEcosystemFile(path16.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path17.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -4577,7 +4960,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(path16.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path17.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -4636,12 +5019,12 @@ async function handleToolsCommand(action, args, _ctx) {
       return { handled: true, output: pc5.yellow("Usage: /tools search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home2 = os15.homedir();
-    const toolsFile = path16.join(home2, ".akit", "tools.md");
-    if (!fs16.existsSync(toolsFile)) {
+    const home2 = os16.homedir();
+    const toolsFile = path17.join(home2, ".akit", "tools.md");
+    if (!fs17.existsSync(toolsFile)) {
       return { handled: true, output: pc5.dim(`No tools file found. Use 'npx @aman_asmuei/akit search ${args.join(" ")}' to search the registry.`) };
     }
-    const raw = fs16.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs17.readFileSync(toolsFile, "utf-8").trim();
     const lines = raw.split("\n");
     const matches = lines.filter((l) => l.toLowerCase().includes(query));
     if (matches.length === 0) {
@@ -4652,9 +5035,9 @@ async function handleToolsCommand(action, args, _ctx) {
   return handleAkitCommand(action, args);
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os15.homedir();
+  const home2 = os16.homedir();
   if (!action) {
-    const content = readEcosystemFile(path16.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path17.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -4676,8 +5059,8 @@ async function handleSkillsCommand(action, args, ctx) {
       return { handled: true, output: pc5.yellow("Usage: /skills search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home3 = os15.homedir();
-    const raw = readEcosystemFile(path16.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const home3 = os16.homedir();
+    const raw = readEcosystemFile(path17.join(home3, ".askill", "skills.md"), "skills (askill)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -4691,9 +5074,9 @@ async function handleSkillsCommand(action, args, ctx) {
   if (action === "list") {
     const autoOnly = args.includes("--auto");
     if (autoOnly) {
-      const logPath = path16.join(os15.homedir(), ".aman-agent", "crystallization-log.json");
+      const logPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-log.json");
       try {
-        const content2 = fs16.readFileSync(logPath, "utf-8");
+        const content2 = fs17.readFileSync(logPath, "utf-8");
         const entries = JSON.parse(content2);
         if (entries.length === 0) {
           return { handled: true, output: pc5.dim("No crystallized skills yet.") };
@@ -4709,13 +5092,13 @@ async function handleSkillsCommand(action, args, ctx) {
         return { handled: true, output: pc5.dim("No crystallized skills yet.") };
       }
     }
-    const content = readEcosystemFile(path16.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path17.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "crystallize") {
-    const pmDir = path16.join(os15.homedir(), ".acore", "postmortems");
+    const pmDir = path17.join(os16.homedir(), ".acore", "postmortems");
     try {
-      const files = fs16.readdirSync(pmDir);
+      const files = fs17.readdirSync(pmDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
       if (jsonFiles.length === 0) {
         return {
@@ -4724,7 +5107,7 @@ async function handleSkillsCommand(action, args, ctx) {
         };
       }
       const latest = jsonFiles[0];
-      const content = fs16.readFileSync(path16.join(pmDir, latest), "utf-8");
+      const content = fs17.readFileSync(path17.join(pmDir, latest), "utf-8");
       const report = JSON.parse(content);
       if (!report.crystallizationCandidates || report.crystallizationCandidates.length === 0) {
         return {
@@ -4732,8 +5115,8 @@ async function handleSkillsCommand(action, args, ctx) {
           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 skillsMdPath = path17.join(os16.homedir(), ".askill", "skills.md");
+      const logPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-log.json");
       const postmortemFilename = latest.replace(/\.json$/, ".md");
       const lines = [
         pc5.bold(`Found ${report.crystallizationCandidates.length} candidate(s) in ${latest}:`)
@@ -4790,9 +5173,9 @@ async function handleSkillsCommand(action, args, ctx) {
   return { handled: true, output: pc5.yellow(`Unknown action: /skills ${action}. Try /skills --help`) };
 }
 async function handleEvalCommand(action, args, ctx) {
-  const home2 = os15.homedir();
+  const home2 = os16.homedir();
   if (!action) {
-    const content = readEcosystemFile(path16.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path17.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -4804,11 +5187,11 @@ async function handleEvalCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path16.join(home2, ".aeval", "eval.md");
-    if (!fs16.existsSync(evalFile)) {
+    const evalFile = path17.join(home2, ".aeval", "eval.md");
+    if (!fs17.existsSync(evalFile)) {
       return { handled: true, output: pc5.dim("No eval report found. Log milestones with /eval milestone <text>.") };
     }
-    const content = fs16.readFileSync(evalFile, "utf-8").trim();
+    const content = fs17.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>.`) };
@@ -5332,10 +5715,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    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")
+    config: path17.join(os16.homedir(), ".aman-agent"),
+    memory: path17.join(os16.homedir(), ".amem"),
+    identity: path17.join(os16.homedir(), ".acore"),
+    rules: path17.join(os16.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -5360,15 +5743,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs16.existsSync(dir)) {
-      fs16.rmSync(dir, { recursive: true, force: true });
+    if (fs17.existsSync(dir)) {
+      fs17.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir = dirs.config;
-    fs16.mkdirSync(configDir, { recursive: true });
-    fs16.writeFileSync(path16.join(configDir, ".reconfig"), "", "utf-8");
+    fs17.mkdirSync(configDir, { recursive: true });
+    fs17.writeFileSync(path17.join(configDir, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc5.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -5385,7 +5768,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.26.0" : "unknown";
+    const local = true ? "0.27.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -5429,11 +5812,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path16.join(os15.homedir(), ".aman-agent", "debug.log");
-  if (!fs16.existsSync(logPath)) {
+  const logPath = path17.join(os16.homedir(), ".aman-agent", "debug.log");
+  if (!fs17.existsSync(logPath)) {
     return { handled: true, output: pc5.dim("No debug log found.") };
   }
-  const content = fs16.readFileSync(logPath, "utf-8");
+  const content = fs17.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) };
@@ -5631,7 +6014,7 @@ ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path16.join(os15.homedir(), ".acore", "profiles");
+  const profilesDir = path17.join(os16.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -5699,8 +6082,8 @@ ${pc5.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path16.join(profilesDir, slug);
-      if (fs16.existsSync(profileDir)) {
+      const profileDir = path17.join(profilesDir, slug);
+      if (fs17.existsSync(profileDir)) {
         return { handled: true, output: pc5.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -5716,16 +6099,16 @@ ${pc5.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      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");
+      fs17.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path17.join(os16.homedir(), ".acore", "core.md");
+      if (fs17.existsSync(globalCore)) {
+        let content = fs17.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs16.writeFileSync(path16.join(profileDir, "core.md"), content, "utf-8");
+        fs17.writeFileSync(path17.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs16.writeFileSync(path16.join(profileDir, "core.md"), `# ${aiName}
+        fs17.writeFileSync(path17.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -5738,7 +6121,7 @@ ${pc5.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc5.green(`Profile created: ${slug}`) + `
-  Edit: ${path16.join(profileDir, "core.md")}
+  Edit: ${path17.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc5.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -5747,9 +6130,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 = 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 profileDir = path17.join(profilesDir, name);
+      if (!fs17.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      const files = fs17.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc5.bold(name)}
 Files:
@@ -5758,9 +6141,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile delete <name>") };
-      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 });
+      const profileDir = path17.join(profilesDir, name);
+      if (!fs17.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      fs17.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc5.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -5978,10 +6361,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path16.join(os15.homedir(), ".acore", "core.md");
+  const corePath = path17.join(os16.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs16.existsSync(corePath)) {
-    const content = fs16.readFileSync(corePath, "utf-8");
+  if (fs17.existsSync(corePath)) {
+    const content = fs17.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -6368,10 +6751,10 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import fsp from "fs/promises";
-import path17 from "path";
-import os16 from "os";
+import path18 from "path";
+import os17 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"],
@@ -6400,20 +6783,20 @@ async function loadRuntimeTriggers(skillsMdPath) {
     return /* @__PURE__ */ new Map();
   }
 }
-var LEVEL_FILE = path17.join(os16.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path18.join(os17.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs17.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs17.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs18.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs18.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  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");
+  const dir = path18.dirname(LEVEL_FILE);
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -6477,7 +6860,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 = path17.join(os16.homedir(), ".askill", "skills.md");
+    const skillsMdPath = path18.join(os17.homedir(), ".askill", "skills.md");
     const runtimeTriggers = await loadRuntimeTriggers(skillsMdPath);
     if (installed.length === 0 && runtimeTriggers.size === 0) return "";
     const matched = matchSkills(userInput, installed, runtimeTriggers);
@@ -7036,9 +7419,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs18 from "fs";
-import path18 from "path";
-import os17 from "os";
+import fs19 from "fs";
+import path19 from "path";
+import os18 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -7076,11 +7459,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path18.join(os17.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path19.join(os18.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs18.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs18.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs19.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs19.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -7089,9 +7472,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path18.dirname(HINTS_FILE);
-    fs18.mkdirSync(dir, { recursive: true });
-    fs18.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path19.dirname(HINTS_FILE);
+    fs19.mkdirSync(dir, { recursive: true });
+    fs19.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -7358,9 +7741,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path19.join(os18.homedir(), ".aman-agent", "exports");
-          fs19.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path19.join(exportDir, `${sessionId}.md`);
+          const exportDir = path20.join(os19.homedir(), ".aman-agent", "exports");
+          fs20.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path20.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -7374,7 +7757,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs19.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs20.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -7500,25 +7883,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path19.join(os18.homedir(), filePath.slice(2));
+        filePath = path20.join(os19.homedir(), filePath.slice(2));
       }
-      if (!fs19.existsSync(filePath) || !fs19.statSync(filePath).isFile()) continue;
-      const ext = path19.extname(filePath).toLowerCase();
+      if (!fs20.existsSync(filePath) || !fs20.statSync(filePath).isFile()) continue;
+      const ext = path20.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs19.statSync(filePath);
+          const stat = fs20.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path19.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path20.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs19.readFileSync(filePath).toString("base64");
+          const data = fs20.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: ${path19.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path20.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -7526,7 +7909,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs19.readFileSync(filePath, "utf-8");
+          const content = fs20.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -7536,7 +7919,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path19.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path20.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -7545,7 +7928,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path19.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path20.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -7554,7 +7937,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path19.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path20.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -7566,7 +7949,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path19.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path20.basename(filePath)}]
 `));
           }
         } else {
@@ -7870,7 +8253,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs19.existsSync(path19.join(os18.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs20.existsSync(path20.join(os19.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -7916,9 +8299,9 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs20 from "fs";
-import path20 from "path";
-import os19 from "os";
+import fs21 from "fs";
+import path21 from "path";
+import os20 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -8027,9 +8410,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path20.join(os19.homedir(), ".aman-agent", ".reconfig");
-  if (fs20.existsSync(reconfigMarker)) {
-    fs20.unlinkSync(reconfigMarker);
+  const reconfigMarker = path21.join(os20.homedir(), ".aman-agent", ".reconfig");
+  if (fs21.existsSync(reconfigMarker)) {
+    fs21.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -8058,11 +8441,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  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, [
+  const home2 = os20.homedir();
+  const corePath = path21.join(home2, ".acore", "core.md");
+  if (fs21.existsSync(corePath)) return false;
+  fs21.mkdirSync(path21.join(home2, ".acore"), { recursive: true });
+  fs21.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -8074,11 +8457,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  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, [
+  const rulesDir = path21.join(home2, ".arules");
+  const rulesPath = path21.join(rulesDir, "rules.md");
+  if (!fs21.existsSync(rulesPath)) {
+    fs21.mkdirSync(rulesDir, { recursive: true });
+    fs21.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -8090,22 +8473,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\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 flowDir = path21.join(home2, ".aflow");
+  const flowPath = path21.join(flowDir, "flow.md");
+  if (!fs21.existsSync(flowPath)) {
+    fs21.mkdirSync(flowDir, { recursive: true });
+    fs21.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const 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");
+  const skillDir = path21.join(home2, ".askill");
+  const skillPath = path21.join(skillDir, "skills.md");
+  if (!fs21.existsSync(skillPath)) {
+    fs21.mkdirSync(skillDir, { recursive: true });
+    fs21.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
   }
   return true;
 }
 var program = new Command();
-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) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.27.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) {
@@ -8457,19 +8840,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 = os19.homedir();
-  fs20.mkdirSync(path20.join(home2, ".acore"), { recursive: true });
-  fs20.writeFileSync(path20.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os20.homedir();
+  fs21.mkdirSync(path21.join(home2, ".acore"), { recursive: true });
+  fs21.writeFileSync(path21.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) {
-    fs20.mkdirSync(path20.join(home2, ".arules"), { recursive: true });
-    fs20.writeFileSync(path20.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs21.mkdirSync(path21.join(home2, ".arules"), { recursive: true });
+    fs21.writeFileSync(path21.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) {
-    fs20.mkdirSync(path20.join(home2, ".aflow"), { recursive: true });
-    fs20.writeFileSync(path20.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs21.mkdirSync(path21.join(home2, ".aflow"), { recursive: true });
+    fs21.writeFileSync(path21.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`);
   }