@aman_asmuei/aman-agent 0.27.0 → 0.28.0

package/dist/index.js

@@ -1,3 +1,337 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/user-model.ts
+var user_model_exports = {};
+__export(user_model_exports, {
+  aggregateSession: () => aggregateSession,
+  computeProfile: () => computeProfile,
+  createEmptyModel: () => createEmptyModel,
+  defaultModelPath: () => defaultModelPath,
+  feedForward: () => feedForward,
+  loadUserModel: () => loadUserModel,
+  predictBurnout: () => predictBurnout,
+  saveUserModel: () => saveUserModel
+});
+import fs13 from "fs/promises";
+import path13 from "path";
+import os12 from "os";
+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 predictBurnout(sessions, currentSession) {
+  const recent = sessions.slice(-7);
+  if (recent.length < 3) {
+    return { risk: 0, factors: [] };
+  }
+  const factors = [];
+  let risk = 0;
+  const mid = Math.floor(recent.length / 2);
+  const firstHalf = recent.slice(0, mid);
+  const secondHalf = recent.slice(mid);
+  const avgFrustFirst = avg(firstHalf.map((s) => s.avgFrustration));
+  const avgFrustSecond = avg(secondHalf.map((s) => s.avgFrustration));
+  if (avgFrustSecond > avgFrustFirst + 0.1 && avgFrustSecond > 0.4) {
+    risk += 0.25;
+    factors.push("rising frustration trend");
+  }
+  const ratings = recent.filter((s) => s.rating).map((s) => ratingSignal(s));
+  if (ratings.length >= 3) {
+    const lastThree = ratings.slice(-3);
+    const avgLast3 = avg(lastThree);
+    if (avgLast3 < 0.5) {
+      risk += 0.2;
+      factors.push("low recent ratings");
+    }
+  }
+  const avgMins = avg(recent.map((s) => s.durationMinutes));
+  if (avgMins > 90) {
+    risk += 0.15;
+    factors.push("consistently long sessions");
+  }
+  const lateNightCount = recent.filter((s) => s.timePeriod === "late-night" || s.timePeriod === "night").length;
+  if (lateNightCount / recent.length > 0.5) {
+    risk += 0.15;
+    factors.push("frequent late-night sessions");
+  }
+  const avgBlockers = avg(recent.map((s) => s.blockers));
+  if (avgBlockers > 1) {
+    risk += 0.15;
+    factors.push("frequent blockers");
+  }
+  if (currentSession) {
+    if (currentSession.minutes > 120 && currentSession.frustration > 0.5) {
+      risk += 0.1;
+      factors.push("current session: long + frustrated");
+    }
+  }
+  risk = clamp(risk, 0, 1);
+  let recommendation;
+  if (risk > 0.7) {
+    recommendation = "Consider taking a longer break. You've been pushing hard \u2014 rest is productive too.";
+  } else if (risk > 0.5) {
+    recommendation = "Watch for signs of fatigue. A change of pace or shorter sessions might help.";
+  }
+  return { risk, factors, recommendation };
+}
+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;
+}
+var MAX_SESSIONS, TRUST_ALPHA, MIN_SESSIONS_FOR_FEED_FORWARD, MIN_SESSIONS_FOR_CORRELATIONS;
+var init_user_model = __esm({
+  "src/user-model.ts"() {
+    "use strict";
+    MAX_SESSIONS = 30;
+    TRUST_ALPHA = 0.3;
+    MIN_SESSIONS_FOR_FEED_FORWARD = 5;
+    MIN_SESSIONS_FOR_CORRELATIONS = 10;
+  }
+});
+
 // src/index.ts
 import { Command } from "commander";
 import * as p3 from "@clack/prompts";
@@ -2518,12 +2852,25 @@ The user seems tired. Keep responses concise and to the point. If they mention w
 </wellbeing>`,
   "break-long-session": `<wellbeing>
 This session has been running for over 2 hours. If there's a natural moment, a brief mention that a short break might help maintain focus is fine. Once is enough.
+</wellbeing>`,
+  "burnout-warning": `<wellbeing>
+Recent patterns suggest the user may be approaching burnout \u2014 rising frustration, declining satisfaction, long or late sessions. Be extra mindful: keep responses concise, celebrate small wins, gently suggest breaks or scope reduction. Don't mention burnout directly unless they bring it up.
 </wellbeing>`
 };
 function formatWellbeingNudge(state) {
   if (!state.wellbeingNudge) return null;
   return WELLBEING_NUDGES[state.wellbeingNudge] || null;
 }
+function shouldFireNudge(nudgeType, profile) {
+  if (!profile) return true;
+  const stats = profile.nudgeStats[nudgeType];
+  if (!stats || stats.fired < 5) return true;
+  if (stats.sessionRatingAfter < 0.4) {
+    log.debug("personality", `suppressing nudge "${nudgeType}" \u2014 low avg rating ${stats.sessionRatingAfter.toFixed(2)} after ${stats.fired} fires`);
+    return false;
+  }
+  return true;
+}
 async function syncPersonalityToCore(state, mcpManager, modelMetrics) {
   try {
     const payload = {
@@ -2718,7 +3065,7 @@ CRYSTALLIZATION RULES:
 - 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) {
+async function generatePostmortemReport(sessionId, messages, session, client, obsDir, rejectedSkillNames) {
   try {
     const events = await readObservationEvents(sessionId, obsDir ?? defaultObservationsDir2());
     const toolMap = /* @__PURE__ */ new Map();
@@ -2754,7 +3101,10 @@ async function generatePostmortemReport(sessionId, messages, session, client, ob
     });
     const obsSnapshot = events.slice(-30).map((e) => `[${e.type}] ${e.summary}`);
     const durationMin = Math.round((Date.now() - session.startedAt) / 6e4);
-    const prompt = `${POSTMORTEM_PROMPT}
+    const prompt = `${POSTMORTEM_PROMPT}${rejectedSkillNames && rejectedSkillNames.length > 0 ? `
+
+PREVIOUSLY REJECTED SKILLS (do NOT suggest these again):
+${rejectedSkillNames.map((n) => `- ${n}`).join("\n")}` : ""}
 
 Session ID: ${sessionId}
 Duration: ${durationMin} minutes
@@ -3138,7 +3488,8 @@ async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
         written: false,
         filePath: skillsMdPath,
         skillName: candidate.name,
-        reason: `collision with "${collision.collidesWith}" (${collision.reason})`
+        reason: `collision with "${collision.collidesWith}" (${collision.reason})`,
+        collidesWith: collision.collidesWith
       };
     }
     const skillMarkdown = formatSkillMarkdown(candidate, postmortemFilename);
@@ -3163,302 +3514,143 @@ async function writeSkillToFile(candidate, skillsMdPath, postmortemFilename) {
     };
   }
 }
-async function appendCrystallizationLog(entry, logPath) {
+async function mergeSkillInFile(candidate, existingName, skillsMdPath, postmortemFilename) {
   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 = [];
+    const content = await fs12.readFile(skillsMdPath, "utf-8");
+    const lines = content.split("\n");
+    const heading = toTitleCase(existingName);
+    let startIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("# ") && lines[i].slice(2).trim() === heading) {
+        startIdx = i;
+        break;
+      }
     }
-    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 = [];
+    if (startIdx === -1) {
+      return writeSkillToFile(candidate, skillsMdPath, postmortemFilename);
     }
-    existing.push({
-      name: candidate.name,
-      rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fromPostmortem: postmortemFilename,
-      triggers: candidate.triggers
-    });
-    while (existing.length > MAX_REJECTIONS) {
-      existing.shift();
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+      if (lines[i].startsWith("# ") && !lines[i].startsWith("## ")) {
+        endIdx = i;
+        break;
+      }
     }
-    await fs12.writeFile(rejectionsPath, JSON.stringify(existing, null, 2), "utf-8");
+    const versionPattern = new RegExp(`^# ${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.v\\d+`);
+    let maxVersion = 0;
+    for (const line of lines) {
+      if (versionPattern.test(line)) {
+        const vMatch = line.match(/\.v(\d+)/);
+        if (vMatch) maxVersion = Math.max(maxVersion, parseInt(vMatch[1], 10));
+      }
+    }
+    const archiveVersion = maxVersion + 1;
+    const oldBlock = lines.slice(startIdx, endIdx);
+    oldBlock[0] = `# ${heading}.v${archiveVersion}`;
+    const archiveMarker = `<!-- aman-archived version=${archiveVersion} archived-at=${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)} -->`;
+    if (oldBlock.length > 1 && oldBlock[1].includes("aman-auto")) {
+      oldBlock.splice(2, 0, archiveMarker);
+    } else {
+      oldBlock.splice(1, 0, archiveMarker);
+    }
+    const newSkillMarkdown = formatSkillMarkdown(candidate, postmortemFilename);
+    const before = lines.slice(0, startIdx);
+    const after = lines.slice(endIdx);
+    const merged = [...before, ...oldBlock, "", newSkillMarkdown, ...after].join("\n");
+    await fs12.writeFile(skillsMdPath, merged, "utf-8");
+    return {
+      written: true,
+      filePath: skillsMdPath,
+      skillName: candidate.name,
+      reason: `merged with "${existingName}" (archived as .v${archiveVersion})`
+    };
   } catch (err) {
-    log.debug("crystallization", "appendRejection failed", err);
-  }
-}
-
-// 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();
+    log.warn("crystallization", "mergeSkillInFile failed", err);
+    return {
+      written: false,
+      filePath: skillsMdPath,
+      skillName: candidate.name,
+      reason: err instanceof Error ? err.message : String(err)
+    };
   }
-  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;
+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);
   }
-  for (const key of Object.keys(nudgeStats)) {
-    if (nudgeStats[key].fired > 0) {
-      nudgeStats[key].sessionRatingAfter /= nudgeStats[key].fired;
+}
+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);
   }
-  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;
+async function loadRejectedNames(rejectionsPath) {
+  try {
+    const content = await fs12.readFile(rejectionsPath, "utf-8");
+    const entries = JSON.parse(content);
+    if (!Array.isArray(entries)) return [];
+    return [...new Set(entries.map((e) => e.name))];
+  } catch {
+    return [];
   }
-  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;
+async function loadSuggestionCounts(suggestionsPath) {
+  try {
+    const content = await fs12.readFile(suggestionsPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
   }
-  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;
+async function incrementSuggestionCount(name, suggestionsPath) {
+  try {
+    await fs12.mkdir(path12.dirname(suggestionsPath), { recursive: true });
+    const counts = await loadSuggestionCounts(suggestionsPath);
+    counts[name] = (counts[name] || 0) + 1;
+    await fs12.writeFile(suggestionsPath, JSON.stringify(counts, null, 2), "utf-8");
+    return counts[name];
+  } catch (err) {
+    log.debug("crystallization", "incrementSuggestionCount failed", err);
+    return 0;
   }
-  const denom = n * sumX2 - sumX * sumX;
-  if (denom === 0) return 0;
-  return (n * sumXY - sumX * sumY) / denom;
 }
 
 // src/hooks.ts
+init_user_model();
 function getTimeContext() {
   const now = /* @__PURE__ */ new Date();
   const hour = now.getHours();
@@ -3631,8 +3823,19 @@ ${contextInjection}`;
     syncPersonalityToCore(state, ctx.mcpManager).catch(() => {
     });
     const nudge = formatWellbeingNudge(state);
-    if (nudge) {
-      greeting += "\n" + nudge;
+    if (nudge && state.wellbeingNudge) {
+      let fireNudge = true;
+      try {
+        const model = await loadUserModel();
+        if (model && model.sessions.length >= 5) {
+          const profile = computeProfile(model.sessions, model.sessions.length);
+          fireNudge = shouldFireNudge(state.wellbeingNudge, profile);
+        }
+      } catch {
+      }
+      if (fireNudge) {
+        greeting += "\n" + nudge;
+      }
     }
   }
   if (greeting) {
@@ -3874,11 +4077,19 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
       try {
         const client = ctx.llmClient;
         if (client) {
+          const rejectionsPath = path14.join(
+            os13.homedir(),
+            ".aman-agent",
+            "crystallization-rejections.json"
+          );
+          const rejectedNames = await loadRejectedNames(rejectionsPath);
           const report = await generatePostmortemReport(
             sessionId,
             messages,
             observationSession,
-            client
+            client,
+            void 0,
+            rejectedNames
           );
           if (report) {
             const filePath = await savePostmortem(report);
@@ -3902,11 +4113,16 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
                 ".aman-agent",
                 "crystallization-log.json"
               );
-              const rejectionsPath = path14.join(
+              const rejectionsPath2 = path14.join(
                 os13.homedir(),
                 ".aman-agent",
                 "crystallization-rejections.json"
               );
+              const suggestionsPath = path14.join(
+                os13.homedir(),
+                ".aman-agent",
+                "crystallization-suggestions.json"
+              );
               const postmortemFilename = `${report.date}-${report.sessionId.slice(0, 4)}.md`;
               console.log(
                 pc2.dim(`
@@ -3920,14 +4136,17 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
                   log.debug("hooks", "candidate failed validation");
                   continue;
                 }
+                const suggestCount = await incrementSuggestionCount(candidate.name, suggestionsPath);
+                const reinforced = suggestCount >= 3;
+                const message = reinforced ? `Crystallize "${candidate.name}"? (suggested ${suggestCount}\xD7 across sessions \u2014 high confidence)` : `Crystallize "${candidate.name}" as a reusable skill?`;
                 const choice = await p2.select({
-                  message: `Crystallize "${candidate.name}" as a reusable skill?`,
+                  message,
                   options: [
-                    { value: "accept", label: "Yes \u2014 write to ~/.askill/skills.md" },
+                    { value: "accept", label: reinforced ? "Yes \u2014 recommended (seen multiple times)" : "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"
+                  initialValue: reinforced ? "accept" : "reject"
                 });
                 if (p2.isCancel(choice) || choice === "skip-all") {
                   skipAll = true;
@@ -3955,12 +4174,46 @@ async function onSessionEnd(ctx, messages, sessionId, observationSession) {
                       },
                       logPath
                     );
+                  } else if (result.collidesWith) {
+                    const mergeChoice = await p2.select({
+                      message: `"${candidate.name}" collides with existing "${result.collidesWith}". Merge?`,
+                      options: [
+                        { value: "merge", label: `Yes \u2014 replace "${result.collidesWith}" with updated version` },
+                        { value: "skip", label: "No \u2014 keep existing" }
+                      ],
+                      initialValue: "merge"
+                    });
+                    if (!p2.isCancel(mergeChoice) && mergeChoice === "merge") {
+                      const mergeResult = await mergeSkillInFile(
+                        candidate,
+                        result.collidesWith,
+                        skillsMdPath,
+                        postmortemFilename
+                      );
+                      if (mergeResult.written) {
+                        console.log(pc2.green(`  \u2713 Merged: ${candidate.name} (replaced "${result.collidesWith}")`));
+                        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 Merge failed: ${mergeResult.reason}`));
+                      }
+                    } else {
+                      console.log(pc2.dim(`  Kept existing: ${result.collidesWith}`));
+                    }
                   } else {
                     console.log(pc2.yellow(`  \u2298 Could not crystallize: ${result.reason}`));
                   }
                 } else {
                   console.log(pc2.dim(`  Skipped: ${candidate.name}`));
-                  await appendRejection(candidate, postmortemFilename, rejectionsPath);
+                  await appendRejection(candidate, postmortemFilename, rejectionsPath2);
                 }
               }
             }
@@ -4589,6 +4842,7 @@ function progressBar(pct) {
 }
 
 // src/commands.ts
+init_user_model();
 import {
   getIdentity as acoreGetIdentity,
   updateSection as acoreUpdateSection,
@@ -5081,10 +5335,33 @@ async function handleSkillsCommand(action, args, ctx) {
         if (entries.length === 0) {
           return { handled: true, output: pc5.dim("No crystallized skills yet.") };
         }
+        const suggestionsPath = path17.join(os16.homedir(), ".aman-agent", "crystallization-suggestions.json");
+        let sugCounts = {};
+        try {
+          const sc = fs17.readFileSync(suggestionsPath, "utf-8");
+          sugCounts = JSON.parse(sc);
+        } catch {
+        }
+        let versionCounts = {};
+        try {
+          const skillsContent = fs17.readFileSync(path17.join(os16.homedir(), ".askill", "skills.md"), "utf-8");
+          const versionRe = /^# (.+)\.v(\d+)$/gm;
+          let vMatch;
+          while ((vMatch = versionRe.exec(skillsContent)) !== null) {
+            const skillHeading = vMatch[1].toLowerCase().replace(/ /g, "-");
+            const ver = parseInt(vMatch[2], 10);
+            versionCounts[skillHeading] = Math.max(versionCounts[skillHeading] || 0, ver);
+          }
+        } catch {
+        }
         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})`);
+          const count = sugCounts[entry.name];
+          const reinforced = count && count >= 3 ? pc5.green(` \u2605 reinforced (${count}\xD7)`) : "";
+          const versions = versionCounts[entry.name];
+          const versionLabel = versions ? pc5.dim(` [v${versions + 1}]`) : "";
+          lines.push(`  ${pc5.cyan(entry.name)} (${date}, conf ${entry.confidence})${reinforced}${versionLabel}`);
           lines.push(pc5.dim(`    triggers: ${entry.triggers.join(", ")}`));
         }
         return { handled: true, output: lines.join("\n") };
@@ -5768,7 +6045,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.27.0" : "unknown";
+    const local = true ? "0.28.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -6838,6 +7115,169 @@ function matchSkills(userInput, installedSkillNames, runtimeTriggers = /* @__PUR
   }
   return Array.from(matched);
 }
+var SEMANTIC_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "each",
+  "every",
+  "all",
+  "any",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "only",
+  "own",
+  "same",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "if",
+  "when",
+  "while",
+  "how",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "me",
+  "my",
+  "we",
+  "us",
+  "our",
+  "you",
+  "your",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their"
+]);
+function tokenize(text3) {
+  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !SEMANTIC_STOPWORDS.has(w));
+}
+function termFrequency(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    tf.set(t, (tf.get(t) || 0) + 1);
+  }
+  for (const [k, v] of tf) {
+    tf.set(k, v / tokens.length);
+  }
+  return tf;
+}
+function cosineSimilarity2(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (const [k, v] of a) {
+    normA += v * v;
+    const bv = b.get(k);
+    if (bv !== void 0) dot += v * bv;
+  }
+  for (const [, v] of b) {
+    normB += v * v;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function semanticSimilarity(userInput, triggers) {
+  const inputTokens = tokenize(userInput);
+  if (inputTokens.length === 0) return 0;
+  const triggerTokens = triggers.flatMap((t) => tokenize(t));
+  if (triggerTokens.length === 0) return 0;
+  const inputTf = termFrequency(inputTokens);
+  const triggerTf = termFrequency(triggerTokens);
+  return cosineSimilarity2(inputTf, triggerTf);
+}
+var SEMANTIC_THRESHOLD = 0.15;
+function matchSkillsSemantic(userInput, installedSkillNames, runtimeTriggers = /* @__PURE__ */ new Map()) {
+  const exact = matchSkills(userInput, installedSkillNames, runtimeTriggers);
+  const matched = new Set(exact);
+  for (const skillName of installedSkillNames) {
+    if (matched.has(skillName)) continue;
+    const triggers = SKILL_TRIGGERS[skillName];
+    if (!triggers) continue;
+    const sim = semanticSimilarity(userInput, triggers);
+    if (sim >= SEMANTIC_THRESHOLD) {
+      matched.add(skillName);
+    }
+  }
+  for (const [skillName, triggers] of runtimeTriggers) {
+    if (matched.has(skillName)) continue;
+    const sim = semanticSimilarity(userInput, triggers);
+    if (sim >= SEMANTIC_THRESHOLD) {
+      matched.add(skillName);
+    }
+  }
+  return Array.from(matched);
+}
 function formatSkillContext(skillName, skillContent, level) {
   let depthHint;
   if (level.level >= 4) {
@@ -6863,7 +7303,7 @@ async function autoTriggerSkills(userInput, mcpManager) {
     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);
+    const matched = matchSkillsSemantic(userInput, installed, runtimeTriggers);
     if (matched.length === 0) return "";
     const blocks = [];
     for (const skillName of matched.slice(0, 2)) {
@@ -7139,16 +7579,23 @@ import { reflect as reflect2, isReflectionDue as isReflectionDue2 } from "@aman_
 var VALID_TYPES = /* @__PURE__ */ new Set(["preference", "fact", "pattern", "topology", "decision", "correction"]);
 var MIN_RESPONSE_LENGTH = 50;
 var MIN_TURNS_BETWEEN_EMPTY = 3;
-var EXTRACTION_PROMPT = `Analyze this conversation turn. Extract any information worth remembering long-term.
+var EXTRACTION_PROMPT = `Analyze this conversation turn. Extract any information worth remembering long-term, and assess the user's emotional tone.
 
-Return a JSON array (empty [] if nothing worth storing):
-[{
-  "content": "what to remember \u2014 be specific and self-contained",
-  "type": "preference|fact|pattern|decision|correction|topology",
-  "tags": ["relevant", "tags"],
-  "confidence": 0.0-1.0,
-  "scope": "global"
-}]
+Return a JSON object with two fields:
+{
+  "memories": [{
+    "content": "what to remember \u2014 be specific and self-contained",
+    "type": "preference|fact|pattern|decision|correction|topology",
+    "tags": ["relevant", "tags"],
+    "confidence": 0.0-1.0,
+    "scope": "global"
+  }],
+  "sentiment": {
+    "tone": "neutral|positive|frustrated|confused|excited|fatigued",
+    "confidence": 0.0-1.0,
+    "context": "brief reason for sentiment read"
+  }
+}
 
 Type guide:
 - "preference" = user likes/dislikes/preferences
@@ -7162,7 +7609,8 @@ Rules:
 - Only extract genuinely useful LONG-TERM information
 - Skip ephemeral things ("user asked about X" is NOT useful)
 - Be conservative \u2014 90% of turns produce nothing worth storing
-- Return ONLY the JSON array, no other text`;
+- Sentiment should reflect the USER's tone, not the assistant's
+- Return ONLY the JSON object, no other text`;
 function shouldExtract(assistantResponse, turnsSinceLastExtraction, lastExtractionCount) {
   if (assistantResponse.length < MIN_RESPONSE_LENGTH) return false;
   if (lastExtractionCount > 0 && turnsSinceLastExtraction >= 1) return true;
@@ -7177,12 +7625,32 @@ function parseExtractionResult(raw) {
       cleaned = codeBlockMatch[1].trim();
     }
     const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(
-      (item) => typeof item.content === "string" && item.content.length > 0 && typeof item.type === "string" && VALID_TYPES.has(item.type)
-    );
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "memories" in parsed) {
+      const memories = Array.isArray(parsed.memories) ? parsed.memories.filter(
+        (item) => typeof item.content === "string" && item.content.length > 0 && typeof item.type === "string" && VALID_TYPES.has(item.type)
+      ) : [];
+      let sentiment;
+      if (parsed.sentiment && typeof parsed.sentiment === "object") {
+        const s = parsed.sentiment;
+        if (typeof s.tone === "string" && typeof s.confidence === "number") {
+          sentiment = {
+            tone: s.tone,
+            confidence: s.confidence,
+            context: typeof s.context === "string" ? s.context : void 0
+          };
+        }
+      }
+      return { memories, sentiment };
+    }
+    if (Array.isArray(parsed)) {
+      const memories = parsed.filter(
+        (item) => typeof item.content === "string" && item.content.length > 0 && typeof item.type === "string" && VALID_TYPES.has(item.type)
+      );
+      return { memories };
+    }
+    return { memories: [] };
   } catch {
-    return [];
+    return { memories: [] };
   }
 }
 async function extractMemories(userMessage, assistantResponse, client, state) {
@@ -7202,12 +7670,16 @@ Assistant: ${assistantResponse.slice(0, 2e3)}`;
         if (chunk.type === "text" && chunk.text) fullText += chunk.text;
       }
     );
-    const candidates = parseExtractionResult(fullText);
+    const result = parseExtractionResult(fullText);
     state.turnsSinceLastExtraction = 0;
-    state.lastExtractionCount = candidates.length;
-    if (candidates.length === 0) return 0;
+    state.lastExtractionCount = result.memories.length;
+    if (result.sentiment) {
+      state.lastLlmSentiment = result.sentiment;
+      log.debug("extractor", `LLM sentiment: ${result.sentiment.tone} (${result.sentiment.confidence})`);
+    }
+    if (result.memories.length === 0) return 0;
     let stored = 0;
-    for (const candidate of candidates) {
+    for (const candidate of result.memories) {
       try {
         const existing = await memoryRecall(candidate.content, { limit: 1 });
         if (existing.total > 0 && existing.memories.length > 0) {
@@ -8058,8 +8530,68 @@ ${converted}
         }
       }
       const nudge = formatWellbeingNudge(state);
-      if (nudge) {
-        augmentedSystemPrompt += "\n" + nudge;
+      if (nudge && state.wellbeingNudge) {
+        let fireNudge = true;
+        try {
+          const { loadUserModel: loadUserModel2, computeProfile: computeProfile2 } = await Promise.resolve().then(() => (init_user_model(), user_model_exports));
+          const model2 = await loadUserModel2();
+          if (model2 && model2.sessions.length >= 5) {
+            const profile = computeProfile2(model2.sessions, model2.sessions.length);
+            fireNudge = shouldFireNudge(state.wellbeingNudge, profile);
+          }
+        } catch {
+        }
+        if (fireNudge) {
+          augmentedSystemPrompt += "\n" + nudge;
+        }
+      }
+      try {
+        const { loadUserModel: loadUserModel2, computeProfile: computeProfile2 } = await Promise.resolve().then(() => (init_user_model(), user_model_exports));
+        const model2 = await loadUserModel2();
+        if (model2 && model2.sessions.length >= 10) {
+          const profile = computeProfile2(model2.sessions, model2.sessions.length);
+          const preemptive = [];
+          const hour2 = (/* @__PURE__ */ new Date()).getHours();
+          const isLate = hour2 >= 21 || hour2 < 6;
+          if (isLate && profile.frustrationCorrelations.lateNight > 0.4) {
+            preemptive.push(
+              "Based on past patterns, late-night sessions tend to increase frustration for this user. Be extra concise, proactive about blockers, and gently suggest wrapping up if frustration rises."
+            );
+          }
+          const sessionMins = Math.round((Date.now() - getSessionStartTime()) / 6e4);
+          if (sessionMins > 60 && profile.frustrationCorrelations.longSessions > 0.4) {
+            preemptive.push(
+              "This session is getting long and past patterns show long sessions correlate with frustration. Proactively suggest natural breakpoints."
+            );
+          }
+          if (preemptive.length > 0) {
+            augmentedSystemPrompt += `
+<feed-forward-v2>
+${preemptive.join("\n")}
+</feed-forward-v2>`;
+          }
+        }
+      } catch {
+      }
+      try {
+        const { loadUserModel: loadUserModel2, predictBurnout: predictBurnout2 } = await Promise.resolve().then(() => (init_user_model(), user_model_exports));
+        const model2 = await loadUserModel2();
+        if (model2 && model2.sessions.length >= 5) {
+          const sessionMins = Math.round((Date.now() - getSessionStartTime()) / 6e4);
+          const burnout = predictBurnout2(model2.sessions, {
+            minutes: sessionMins,
+            frustration: state.sentiment.frustration,
+            timePeriod: period
+          });
+          if (burnout.risk > 0.7) {
+            const burnoutState = { ...state, wellbeingNudge: "burnout-warning" };
+            const burnoutNudge = formatWellbeingNudge(burnoutState);
+            if (burnoutNudge) {
+              augmentedSystemPrompt += "\n" + burnoutNudge;
+            }
+          }
+        }
+      } catch {
       }
     }
     const MAX_SYSTEM_TOKENS = 16e3;
@@ -8488,7 +9020,7 @@ function bootstrapEcosystem() {
   return true;
 }
 var program = new Command();
-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) => {
+program.name("aman-agent").description("Your AI companion, running locally").version("0.28.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) {