@aman_asmuei/aman-agent 0.24.3 → 0.25.0

package/dist/index.js

@@ -1387,18 +1387,18 @@ var McpManager = class {
 
 // src/agent.ts
 import * as readline from "readline";
-import fs16 from "fs";
-import path16 from "path";
-import os15 from "os";
+import fs18 from "fs";
+import path18 from "path";
+import os17 from "os";
 import pc7 from "picocolors";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import logUpdate from "log-update";
 
 // src/commands.ts
-import fs13 from "fs";
-import path13 from "path";
-import os12 from "os";
+import fs15 from "fs";
+import path15 from "path";
+import os14 from "os";
 import { execFileSync as execFileSync3 } from "child_process";
 import pc5 from "picocolors";
 
@@ -2361,8 +2361,8 @@ import pc3 from "picocolors";
 // src/hooks.ts
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
-import fs10 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path12 from "path";
 
 // src/personality.ts
 var FRUSTRATION_SIGNALS = [
@@ -2535,6 +2535,382 @@ async function syncPersonalityToCore(state, mcpManager) {
   }
 }
 
+// src/postmortem.ts
+import fs11 from "fs/promises";
+import path11 from "path";
+import os11 from "os";
+
+// src/observation.ts
+import fs10 from "fs/promises";
+import path10 from "path";
+import os10 from "os";
+var STAT_MAP = {
+  tool_call: "toolCalls",
+  tool_error: "toolErrors",
+  topic_shift: "topicShifts",
+  blocker: "blockers",
+  milestone: "milestones",
+  file_change: "fileChanges"
+};
+function defaultObservationsDir() {
+  return path10.join(os10.homedir(), ".acore", "observations");
+}
+function createObservationSession(sessionId) {
+  return {
+    sessionId,
+    startedAt: Date.now(),
+    events: [],
+    paused: false,
+    stats: {
+      toolCalls: 0,
+      toolErrors: 0,
+      topicShifts: 0,
+      blockers: 0,
+      milestones: 0,
+      fileChanges: 0
+    }
+  };
+}
+function recordEvent(session, event) {
+  if (session.paused) return;
+  const full = { ...event, timestamp: Date.now() };
+  session.events.push(full);
+  const statKey = STAT_MAP[event.type];
+  if (statKey) {
+    session.stats[statKey]++;
+  }
+}
+function pauseObservation(session) {
+  session.paused = true;
+}
+function resumeObservation(session) {
+  session.paused = false;
+}
+async function flushEvents(session, dir) {
+  if (session.events.length === 0) return;
+  const obsDir = dir ?? defaultObservationsDir();
+  await fs10.mkdir(obsDir, { recursive: true });
+  const filePath = path10.join(obsDir, `${session.sessionId}.jsonl`);
+  const lines = session.events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  await fs10.appendFile(filePath, lines, "utf-8");
+  session.events.length = 0;
+}
+async function readObservationEvents(sessionId, dir) {
+  const obsDir = dir ?? defaultObservationsDir();
+  const filePath = path10.join(obsDir, `${sessionId}.jsonl`);
+  try {
+    const content = await fs10.readFile(filePath, "utf-8");
+    return content.trim().split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+function getSessionStats(session) {
+  const elapsed = Math.round((Date.now() - session.startedAt) / 6e4);
+  const s = session.stats;
+  const parts = [
+    `Session: ${elapsed} min`,
+    `Tools: ${s.toolCalls} calls (${s.toolErrors} error${s.toolErrors !== 1 ? "s" : ""})`,
+    `Files: ${s.fileChanges} changed`,
+    `Blockers: ${s.blockers}`,
+    `Milestones: ${s.milestones}`
+  ];
+  if (s.topicShifts > 0) parts.push(`Topic shifts: ${s.topicShifts}`);
+  if (session.paused) parts.push("(paused)");
+  return parts.join(" | ");
+}
+async function cleanupOldObservations(dir, maxAgeDays = 30) {
+  const obsDir = dir ?? defaultObservationsDir();
+  try {
+    const files = await fs10.readdir(obsDir);
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const filePath = path10.join(obsDir, file);
+      const stat = await fs10.stat(filePath);
+      if (stat.mtimeMs < cutoff) {
+        await fs10.unlink(filePath);
+      }
+    }
+  } catch {
+  }
+}
+function detectTopicShift(recentMessages, previousMessages) {
+  const extractKeywords = (msgs) => {
+    const words = msgs.join(" ").toLowerCase().split(/\W+/).filter((w) => w.length > 3);
+    return new Set(words);
+  };
+  const recent = extractKeywords(recentMessages);
+  const previous = extractKeywords(previousMessages);
+  if (previous.size === 0) return { shifted: false, newTopics: [] };
+  let overlap = 0;
+  for (const word of recent) {
+    if (previous.has(word)) overlap++;
+  }
+  const overlapRatio = previous.size > 0 ? overlap / previous.size : 1;
+  const shifted = overlapRatio < 0.3;
+  const newTopics = shifted ? [...recent].filter((w) => !previous.has(w)).slice(0, 5) : [];
+  return { shifted, newTopics };
+}
+
+// src/postmortem.ts
+function defaultPostmortemsDir() {
+  return path11.join(os11.homedir(), ".acore", "postmortems");
+}
+function defaultObservationsDir2() {
+  return path11.join(os11.homedir(), ".acore", "observations");
+}
+function shouldAutoPostmortem(session, messages) {
+  if (messages.length < 6) return false;
+  const durationMs = Date.now() - session.startedAt;
+  return session.stats.toolErrors >= 3 || session.stats.blockers >= 2 || durationMs > 60 * 6e4 || hasAbandonedPlanSteps(messages) || hasSustainedFrustration(session, 5);
+}
+function hasAbandonedPlanSteps(messages) {
+  const text3 = messages.map((m) => typeof m.content === "string" ? m.content : "").join("\n");
+  const unchecked = (text3.match(/- \[ \]/g) ?? []).length;
+  const checked = (text3.match(/- \[x\]/g) ?? []).length;
+  return checked > 0 && unchecked > 0 && unchecked >= checked;
+}
+function hasSustainedFrustration(session, threshold) {
+  return session.stats.blockers >= threshold;
+}
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
+}
+var POSTMORTEM_PROMPT = `Analyze this session and generate a structured post-mortem report.
+Return ONLY valid JSON matching this schema (no markdown, no explanation):
+
+{
+  "summary": "2-3 sentence overview",
+  "goals": ["what the user tried to accomplish"],
+  "completed": ["what actually got done"],
+  "blockers": ["what caused friction"],
+  "decisions": ["key choices made with rationale"],
+  "sentimentArc": "how mood evolved during session",
+  "patterns": ["recurring behaviors worth remembering for future sessions"],
+  "recommendations": ["actionable suggestions for next session"]
+}`;
+async function generatePostmortemReport(sessionId, messages, session, client, obsDir) {
+  try {
+    const events = await readObservationEvents(sessionId, obsDir ?? defaultObservationsDir2());
+    const toolMap = /* @__PURE__ */ new Map();
+    const fileChanges = [];
+    const topicProgression = [];
+    for (const event of events) {
+      if (event.type === "tool_call") {
+        const name = event.data.tool ?? "unknown";
+        const entry = toolMap.get(name) ?? { calls: 0, errors: 0 };
+        entry.calls++;
+        toolMap.set(name, entry);
+      } else if (event.type === "tool_error") {
+        const name = event.data.tool ?? "unknown";
+        const entry = toolMap.get(name) ?? { calls: 0, errors: 0 };
+        entry.errors++;
+        toolMap.set(name, entry);
+      } else if (event.type === "file_change") {
+        const p4 = event.data.path ?? "unknown";
+        if (!fileChanges.includes(p4)) fileChanges.push(p4);
+      } else if (event.type === "topic_shift") {
+        const topics = event.data.newTopics ?? [];
+        topicProgression.push(...topics);
+      }
+    }
+    const toolUsage = [...toolMap.entries()].map(([name, { calls, errors }]) => ({
+      name,
+      count: calls,
+      errorRate: calls > 0 ? Math.round(errors / calls * 100) / 100 : 0
+    }));
+    const recentMessages = messages.slice(-20).map((m) => {
+      const text4 = messageContentToText(m.content);
+      return `${m.role}: ${text4.slice(0, 200)}`;
+    });
+    const obsSnapshot = events.slice(-30).map((e) => `[${e.type}] ${e.summary}`);
+    const durationMin = Math.round((Date.now() - session.startedAt) / 6e4);
+    const prompt = `${POSTMORTEM_PROMPT}
+
+Session ID: ${sessionId}
+Duration: ${durationMin} minutes
+Turns: ${messages.length}
+Tool calls: ${session.stats.toolCalls} (${session.stats.toolErrors} errors)
+Blockers: ${session.stats.blockers}
+Milestones: ${session.stats.milestones}
+
+Recent messages:
+${recentMessages.join("\n")}
+
+Observations:
+${obsSnapshot.join("\n")}`;
+    const response = await client.chat(
+      "You are a session analyst. Output only valid JSON.",
+      [{ role: "user", content: prompt }],
+      () => {
+      }
+      // no-op onChunk — postmortem runs silently
+    );
+    const text3 = messageContentToText(response.message.content);
+    const jsonMatch = text3.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      log.debug("postmortem", "LLM returned non-JSON response");
+      return null;
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      sessionId,
+      date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      duration: durationMin,
+      turnCount: messages.length,
+      summary: parsed.summary ?? "",
+      goals: parsed.goals ?? [],
+      completed: parsed.completed ?? [],
+      blockers: parsed.blockers ?? [],
+      decisions: parsed.decisions ?? [],
+      toolUsage,
+      fileChanges,
+      topicProgression: [...new Set(topicProgression)],
+      sentimentArc: parsed.sentimentArc ?? "",
+      patterns: parsed.patterns ?? [],
+      recommendations: parsed.recommendations ?? []
+    };
+  } catch (err) {
+    log.debug("postmortem", "Failed to generate post-mortem", err);
+    return null;
+  }
+}
+function formatPostmortemMarkdown(report) {
+  const lines = [
+    `# Post-Mortem: ${report.date}`,
+    "",
+    `**Session:** ${report.sessionId} | **Duration:** ${report.duration} min | **Turns:** ${report.turnCount}`,
+    "",
+    "## Summary",
+    report.summary,
+    ""
+  ];
+  if (report.goals.length > 0) {
+    lines.push("## Goals");
+    report.goals.forEach((g) => lines.push(`- ${g}`));
+    lines.push("");
+  }
+  if (report.completed.length > 0) {
+    lines.push("## Completed");
+    report.completed.forEach((c) => lines.push(`- [x] ${c}`));
+    lines.push("");
+  }
+  if (report.blockers.length > 0) {
+    lines.push("## Blockers");
+    report.blockers.forEach((b) => lines.push(`- ${b}`));
+    lines.push("");
+  }
+  if (report.decisions.length > 0) {
+    lines.push("## Decisions");
+    report.decisions.forEach((d) => lines.push(`- ${d}`));
+    lines.push("");
+  }
+  if (report.toolUsage.length > 0) {
+    lines.push("## Tool Usage");
+    lines.push("| Tool | Calls | Error Rate |");
+    lines.push("|------|-------|------------|");
+    report.toolUsage.forEach(
+      (t) => lines.push(`| ${t.name} | ${t.count} | ${Math.round(t.errorRate * 100)}% |`)
+    );
+    lines.push("");
+  }
+  if (report.fileChanges.length > 0) {
+    lines.push("## Files Changed");
+    report.fileChanges.forEach((f) => lines.push(`- \`${f}\``));
+    lines.push("");
+  }
+  if (report.topicProgression.length > 0) {
+    lines.push(`## Topics`);
+    lines.push(report.topicProgression.join(" \u2192 "));
+    lines.push("");
+  }
+  if (report.sentimentArc) {
+    lines.push("## Sentiment Arc");
+    lines.push(report.sentimentArc);
+    lines.push("");
+  }
+  if (report.patterns.length > 0) {
+    lines.push("## Patterns");
+    report.patterns.forEach((p4) => lines.push(`- ${p4}`));
+    lines.push("");
+  }
+  if (report.recommendations.length > 0) {
+    lines.push("## Recommendations");
+    report.recommendations.forEach((r) => lines.push(`- ${r}`));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function savePostmortem(report, dir) {
+  const pmDir = dir ?? defaultPostmortemsDir();
+  await fs11.mkdir(pmDir, { recursive: true });
+  const shortId = report.sessionId.slice(0, 4);
+  const fileName = `${report.date}-${shortId}.md`;
+  const filePath = path11.join(pmDir, fileName);
+  const markdown = formatPostmortemMarkdown(report);
+  await fs11.writeFile(filePath, markdown, "utf-8");
+  return filePath;
+}
+async function listPostmortems(dir) {
+  const pmDir = dir ?? defaultPostmortemsDir();
+  try {
+    const files = await fs11.readdir(pmDir);
+    return files.filter((f) => f.endsWith(".md")).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+async function readPostmortem(name, dir) {
+  const pmDir = dir ?? defaultPostmortemsDir();
+  const fileName = name.endsWith(".md") ? name : `${name}.md`;
+  try {
+    return await fs11.readFile(path11.join(pmDir, fileName), "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function analyzePostmortemRange(sinceDays, client, dir) {
+  const pmDir = dir ?? defaultPostmortemsDir();
+  try {
+    const files = await listPostmortems(pmDir);
+    const cutoffDate = new Date(Date.now() - sinceDays * 24 * 60 * 60 * 1e3).toISOString().slice(0, 10);
+    const recentFiles = files.filter((f) => f >= cutoffDate);
+    if (recentFiles.length === 0) return "No post-mortems found in the specified range.";
+    const contents = [];
+    for (const f of recentFiles.slice(0, 10)) {
+      const content = await readPostmortem(f, pmDir);
+      if (content) contents.push(content);
+    }
+    const response = await client.chat(
+      "You are a session analyst. Analyze these post-mortems and identify trends.",
+      [
+        {
+          role: "user",
+          content: `Analyze these ${contents.length} post-mortem reports from the last ${sinceDays} days. Identify:
+1. Recurring blockers
+2. Productivity patterns
+3. Tool reliability issues
+4. Topic continuity across sessions
+5. Actionable recommendations
+
+Reports:
+${contents.join("\n\n---\n\n")}`
+        }
+      ],
+      () => {
+      }
+      // no-op onChunk
+    );
+    const text3 = messageContentToText(response.message.content);
+    return text3 || null;
+  } catch (err) {
+    log.debug("postmortem", "Failed to analyze range", err);
+    return null;
+  }
+}
+
 // src/hooks.ts
 function getTimeContext() {
   const now = /* @__PURE__ */ new Date();
@@ -2767,7 +3143,7 @@ async function onWorkflowMatch(userInput, ctx) {
     isHookCall = false;
   }
 }
-async function onSessionEnd(ctx, messages, sessionId) {
+async function onSessionEnd(ctx, messages, sessionId, observationSession) {
   try {
     if (ctx.config.autoSessionSave && messages.length > 2) {
       console.log(pc2.dim("\n  Saving conversation to memory..."));
@@ -2803,10 +3179,10 @@ async function onSessionEnd(ctx, messages, sessionId) {
       }
       console.log(pc2.dim(`  Saved ${textMessages.length} messages (session: ${sessionId})`));
     }
-    const projectContextPath = path10.join(process.cwd(), ".acore", "context.md");
-    if (fs10.existsSync(projectContextPath) && messages.length > 2) {
+    const projectContextPath = path12.join(process.cwd(), ".acore", "context.md");
+    if (fs12.existsSync(projectContextPath) && messages.length > 2) {
       try {
-        let contextContent = fs10.readFileSync(projectContextPath, "utf-8");
+        let contextContent = fs12.readFileSync(projectContextPath, "utf-8");
         const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         let lastUserMsg = "";
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -2824,7 +3200,7 @@ async function onSessionEnd(ctx, messages, sessionId) {
 - Recent decisions: [see memory]
 - Temp notes: [cleared]`;
           contextContent = contextContent.replace(sessionPattern, newSession);
-          fs10.writeFileSync(projectContextPath, contextContent, "utf-8");
+          fs12.writeFileSync(projectContextPath, contextContent, "utf-8");
           log.debug("hooks", `Updated project context: ${projectContextPath}`);
         }
       } catch (err) {
@@ -2877,6 +3253,37 @@ async function onSessionEnd(ctx, messages, sessionId) {
         }
       }
     }
+    if (ctx.config.autoPostmortem !== false && observationSession && shouldAutoPostmortem(observationSession, messages)) {
+      try {
+        const client = ctx.llmClient;
+        if (client) {
+          const report = await generatePostmortemReport(
+            sessionId,
+            messages,
+            observationSession,
+            client
+          );
+          if (report) {
+            const filePath = await savePostmortem(report);
+            console.log(pc2.dim(`
+  Post-mortem saved \u2192 ${filePath}`));
+            for (const pattern of report.patterns) {
+              try {
+                await memoryStore({
+                  content: pattern,
+                  type: "pattern",
+                  tags: ["postmortem", "auto"],
+                  confidence: 0.7
+                });
+              } catch {
+              }
+            }
+          }
+        }
+      } catch (err) {
+        log.debug("hooks", "auto post-mortem failed", err);
+      }
+    }
   } catch (err) {
     log.warn("hooks", "session end hook failed", err);
   }
@@ -3030,43 +3437,43 @@ async function delegatePipeline(steps, initialInput, client, mcpManager, options
 }
 
 // src/teams.ts
-import fs11 from "fs";
-import path11 from "path";
-import os10 from "os";
+import fs13 from "fs";
+import path13 from "path";
+import os12 from "os";
 import pc4 from "picocolors";
 function getTeamsDir() {
-  return path11.join(os10.homedir(), ".acore", "teams");
+  return path13.join(os12.homedir(), ".acore", "teams");
 }
 function ensureTeamsDir() {
   const dir = getTeamsDir();
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function teamPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  return path11.join(ensureTeamsDir(), `${slug}.json`);
+  return path13.join(ensureTeamsDir(), `${slug}.json`);
 }
 function createTeam(team) {
   const fp = teamPath(team.name);
-  fs11.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
+  fs13.writeFileSync(fp, JSON.stringify(team, null, 2), "utf-8");
 }
 function loadTeam(name) {
   const fp = teamPath(name);
-  if (!fs11.existsSync(fp)) return null;
+  if (!fs13.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs11.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs13.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function listTeams() {
   const dir = getTeamsDir();
-  if (!fs11.existsSync(dir)) return [];
+  if (!fs13.existsSync(dir)) return [];
   const teams = [];
-  for (const file of fs11.readdirSync(dir)) {
+  for (const file of fs13.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      const content = fs11.readFileSync(path11.join(dir, file), "utf-8");
+      const content = fs13.readFileSync(path13.join(dir, file), "utf-8");
       teams.push(JSON.parse(content));
     } catch {
     }
@@ -3075,8 +3482,8 @@ function listTeams() {
 }
 function deleteTeam(name) {
   const fp = teamPath(name);
-  if (!fs11.existsSync(fp)) return false;
-  fs11.unlinkSync(fp);
+  if (!fs13.existsSync(fp)) return false;
+  fs13.unlinkSync(fp);
   return true;
 }
 async function runTeam(team, task, client, mcpManager, tools) {
@@ -3302,23 +3709,23 @@ var BUILT_IN_TEAMS = [
 ];
 
 // src/plans.ts
-import fs12 from "fs";
-import path12 from "path";
-import os11 from "os";
+import fs14 from "fs";
+import path14 from "path";
+import os13 from "os";
 function getPlansDir() {
-  const localDir = path12.join(process.cwd(), ".acore", "plans");
-  const localAcore = path12.join(process.cwd(), ".acore");
-  if (fs12.existsSync(localAcore)) return localDir;
-  return path12.join(os11.homedir(), ".acore", "plans");
+  const localDir = path14.join(process.cwd(), ".acore", "plans");
+  const localAcore = path14.join(process.cwd(), ".acore");
+  if (fs14.existsSync(localAcore)) return localDir;
+  return path14.join(os13.homedir(), ".acore", "plans");
 }
 function ensurePlansDir() {
   const dir = getPlansDir();
-  if (!fs12.existsSync(dir)) fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function planPath(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return path12.join(ensurePlansDir(), `${slug}.md`);
+  return path14.join(ensurePlansDir(), `${slug}.md`);
 }
 function serializePlan(plan) {
   const lines = [];
@@ -3344,7 +3751,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() || path12.basename(filePath, ".md");
+    const name = nameMatch?.[1]?.trim() || path14.basename(filePath, ".md");
     const goal = goalMatch?.[1]?.trim() || "";
     const createdAt = createdMatch?.[1]?.trim() || "";
     const updatedAt = updatedMatch?.[1]?.trim() || "";
@@ -3386,22 +3793,22 @@ function createPlan(name, goal, steps) {
 }
 function savePlan(plan) {
   const fp = planPath(plan.name);
-  fs12.writeFileSync(fp, serializePlan(plan), "utf-8");
+  fs14.writeFileSync(fp, serializePlan(plan), "utf-8");
 }
 function loadPlan(name) {
   const fp = planPath(name);
-  if (!fs12.existsSync(fp)) return null;
-  const content = fs12.readFileSync(fp, "utf-8");
+  if (!fs14.existsSync(fp)) return null;
+  const content = fs14.readFileSync(fp, "utf-8");
   return parsePlan(content, fp);
 }
 function listPlans() {
   const dir = getPlansDir();
-  if (!fs12.existsSync(dir)) return [];
+  if (!fs14.existsSync(dir)) return [];
   const plans = [];
-  for (const file of fs12.readdirSync(dir)) {
+  for (const file of fs14.readdirSync(dir)) {
     if (!file.endsWith(".md")) continue;
-    const fp = path12.join(dir, file);
-    const content = fs12.readFileSync(fp, "utf-8");
+    const fp = path14.join(dir, file);
+    const content = fs14.readFileSync(fp, "utf-8");
     const plan = parsePlan(content, fp);
     if (plan) plans.push(plan);
   }
@@ -3510,10 +3917,10 @@ import {
 } from "@aman_asmuei/arules-core";
 var AGENT_SCOPE = process.env.AMAN_AGENT_SCOPE ?? "dev:agent";
 function readEcosystemFile(filePath, label) {
-  if (!fs13.existsSync(filePath)) {
+  if (!fs15.existsSync(filePath)) {
     return pc5.dim(`No ${label} file found at ${filePath}`);
   }
-  return fs13.readFileSync(filePath, "utf-8").trim();
+  return fs15.readFileSync(filePath, "utf-8").trim();
 }
 function parseCommand(input) {
   const trimmed = input.trim();
@@ -3788,9 +4195,9 @@ ${result.violations.map((v) => `  - ${v}`).join("\n")}`)
   };
 }
 async function handleWorkflowsCommand(action, args, ctx) {
-  const home2 = os12.homedir();
+  const home2 = os14.homedir();
   if (!action) {
-    const content = readEcosystemFile(path13.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const content = readEcosystemFile(path15.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     return { handled: true, output: content };
   }
   if (action === "add") {
@@ -3812,7 +4219,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(path13.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
+    const raw = readEcosystemFile(path15.join(home2, ".aflow", "flow.md"), "workflows (aflow)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -3871,12 +4278,12 @@ async function handleToolsCommand(action, args, _ctx) {
       return { handled: true, output: pc5.yellow("Usage: /tools search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home2 = os12.homedir();
-    const toolsFile = path13.join(home2, ".akit", "tools.md");
-    if (!fs13.existsSync(toolsFile)) {
+    const home2 = os14.homedir();
+    const toolsFile = path15.join(home2, ".akit", "tools.md");
+    if (!fs15.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 = fs13.readFileSync(toolsFile, "utf-8").trim();
+    const raw = fs15.readFileSync(toolsFile, "utf-8").trim();
     const lines = raw.split("\n");
     const matches = lines.filter((l) => l.toLowerCase().includes(query));
     if (matches.length === 0) {
@@ -3887,9 +4294,9 @@ async function handleToolsCommand(action, args, _ctx) {
   return handleAkitCommand(action, args);
 }
 async function handleSkillsCommand(action, args, ctx) {
-  const home2 = os12.homedir();
+  const home2 = os14.homedir();
   if (!action) {
-    const content = readEcosystemFile(path13.join(home2, ".askill", "skills.md"), "skills (askill)");
+    const content = readEcosystemFile(path15.join(home2, ".askill", "skills.md"), "skills (askill)");
     return { handled: true, output: content };
   }
   if (action === "install") {
@@ -3911,8 +4318,8 @@ async function handleSkillsCommand(action, args, ctx) {
       return { handled: true, output: pc5.yellow("Usage: /skills search <query...>") };
     }
     const query = args.join(" ").toLowerCase();
-    const home3 = os12.homedir();
-    const raw = readEcosystemFile(path13.join(home3, ".askill", "skills.md"), "skills (askill)");
+    const home3 = os14.homedir();
+    const raw = readEcosystemFile(path15.join(home3, ".askill", "skills.md"), "skills (askill)");
     if (raw.startsWith("No ")) {
       return { handled: true, output: raw };
     }
@@ -3935,9 +4342,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 = os12.homedir();
+  const home2 = os14.homedir();
   if (!action) {
-    const content = readEcosystemFile(path13.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
+    const content = readEcosystemFile(path15.join(home2, ".aeval", "eval.md"), "evaluation (aeval)");
     return { handled: true, output: content };
   }
   if (action === "milestone") {
@@ -3949,11 +4356,11 @@ async function handleEvalCommand(action, args, ctx) {
     return { handled: true, output };
   }
   if (action === "report") {
-    const evalFile = path13.join(home2, ".aeval", "eval.md");
-    if (!fs13.existsSync(evalFile)) {
+    const evalFile = path15.join(home2, ".aeval", "eval.md");
+    if (!fs15.existsSync(evalFile)) {
       return { handled: true, output: pc5.dim("No eval report found. Log milestones with /eval milestone <text>.") };
     }
-    const content = fs13.readFileSync(evalFile, "utf-8").trim();
+    const content = fs15.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>.`) };
@@ -4463,6 +4870,8 @@ function handleHelp() {
       `  ${pc5.cyan("/showcase")}     Browse & switch companion templates`,
       `  ${pc5.cyan("/delegate")}     Delegate tasks to sub-agents`,
       `  ${pc5.cyan("/team")}         Manage agent teams`,
+      `  ${pc5.cyan("/observe")}      Session observation dashboard [pause|resume]`,
+      `  ${pc5.cyan("/postmortem")}   Generate post-mortem [last|list|--since 7d]`,
       `  ${pc5.cyan("/update")}       Check for updates`,
       `  ${pc5.cyan("/reset")}       Full reset [all|memory|config|identity|rules]`,
       `  ${pc5.cyan("/clear")}        Clear conversation history`,
@@ -4475,10 +4884,10 @@ function handleSave() {
 }
 function handleReset(action) {
   const dirs = {
-    config: path13.join(os12.homedir(), ".aman-agent"),
-    memory: path13.join(os12.homedir(), ".amem"),
-    identity: path13.join(os12.homedir(), ".acore"),
-    rules: path13.join(os12.homedir(), ".arules")
+    config: path15.join(os14.homedir(), ".aman-agent"),
+    memory: path15.join(os14.homedir(), ".amem"),
+    identity: path15.join(os14.homedir(), ".acore"),
+    rules: path15.join(os14.homedir(), ".arules")
   };
   if (action === "help" || !action) {
     return {
@@ -4503,15 +4912,15 @@ function handleReset(action) {
   const removed = [];
   for (const target of targets) {
     const dir = dirs[target];
-    if (fs13.existsSync(dir)) {
-      fs13.rmSync(dir, { recursive: true, force: true });
+    if (fs15.existsSync(dir)) {
+      fs15.rmSync(dir, { recursive: true, force: true });
       removed.push(target);
     }
   }
   if (targets.includes("config")) {
     const configDir = dirs.config;
-    fs13.mkdirSync(configDir, { recursive: true });
-    fs13.writeFileSync(path13.join(configDir, ".reconfig"), "", "utf-8");
+    fs15.mkdirSync(configDir, { recursive: true });
+    fs15.writeFileSync(path15.join(configDir, ".reconfig"), "", "utf-8");
   }
   if (removed.length === 0) {
     return { handled: true, output: pc5.dim("Nothing to reset \u2014 directories don't exist.") };
@@ -4528,7 +4937,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.24.3" : "unknown";
+    const local = true ? "0.25.0" : "unknown";
     if (current === local) {
       return { handled: true, output: `${pc5.green("Up to date")} \u2014 v${local}` };
     }
@@ -4572,11 +4981,11 @@ function handleExportCommand() {
   return { handled: true, exportConversation: true };
 }
 function handleDebugCommand() {
-  const logPath = path13.join(os12.homedir(), ".aman-agent", "debug.log");
-  if (!fs13.existsSync(logPath)) {
+  const logPath = path15.join(os14.homedir(), ".aman-agent", "debug.log");
+  if (!fs15.existsSync(logPath)) {
     return { handled: true, output: pc5.dim("No debug log found.") };
   }
-  const content = fs13.readFileSync(logPath, "utf-8");
+  const content = fs15.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) };
@@ -4774,7 +5183,7 @@ ${result.response}`
   };
 }
 function handleProfileCommand(action, args) {
-  const profilesDir = path13.join(os12.homedir(), ".acore", "profiles");
+  const profilesDir = path15.join(os14.homedir(), ".acore", "profiles");
   if (action === "me") {
     const user = loadUserIdentity();
     if (!user) {
@@ -4842,8 +5251,8 @@ ${pc5.dim("Edit with: /profile edit")}` };
         };
       }
       const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-      const profileDir = path13.join(profilesDir, slug);
-      if (fs13.existsSync(profileDir)) {
+      const profileDir = path15.join(profilesDir, slug);
+      if (fs15.existsSync(profileDir)) {
         return { handled: true, output: pc5.yellow(`Profile already exists: ${slug}`) };
       }
       const builtIn = BUILT_IN_PROFILES.find((t) => t.name === slug);
@@ -4859,16 +5268,16 @@ ${pc5.dim("Edit with: /profile edit")}` };
   Use: aman-agent --profile ${slug}`
         };
       }
-      fs13.mkdirSync(profileDir, { recursive: true });
-      const globalCore = path13.join(os12.homedir(), ".acore", "core.md");
-      if (fs13.existsSync(globalCore)) {
-        let content = fs13.readFileSync(globalCore, "utf-8");
+      fs15.mkdirSync(profileDir, { recursive: true });
+      const globalCore = path15.join(os14.homedir(), ".acore", "core.md");
+      if (fs15.existsSync(globalCore)) {
+        let content = fs15.readFileSync(globalCore, "utf-8");
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
         content = content.replace(/^# .+$/m, `# ${aiName}`);
-        fs13.writeFileSync(path13.join(profileDir, "core.md"), content, "utf-8");
+        fs15.writeFileSync(path15.join(profileDir, "core.md"), content, "utf-8");
       } else {
         const aiName = name.charAt(0).toUpperCase() + name.slice(1);
-        fs13.writeFileSync(path13.join(profileDir, "core.md"), `# ${aiName}
+        fs15.writeFileSync(path15.join(profileDir, "core.md"), `# ${aiName}
 
 ## Identity
 - Role: ${aiName} is your AI companion
@@ -4881,7 +5290,7 @@ ${pc5.dim("Edit with: /profile edit")}` };
       return {
         handled: true,
         output: pc5.green(`Profile created: ${slug}`) + `
-  Edit: ${path13.join(profileDir, "core.md")}
+  Edit: ${path15.join(profileDir, "core.md")}
   Use: aman-agent --profile ${slug}
 
   ${pc5.dim("Add rules.md or skills.md for profile-specific overrides.")}`
@@ -4890,9 +5299,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 = path13.join(profilesDir, name);
-      if (!fs13.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      const files = fs13.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+      const profileDir = path15.join(profilesDir, name);
+      if (!fs15.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      const files = fs15.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
       const lines = files.map((f) => `  ${f}`);
       return { handled: true, output: `Profile: ${pc5.bold(name)}
 Files:
@@ -4901,9 +5310,9 @@ ${lines.join("\n")}` };
     case "delete": {
       const name = args[0];
       if (!name) return { handled: true, output: pc5.yellow("Usage: /profile delete <name>") };
-      const profileDir = path13.join(profilesDir, name);
-      if (!fs13.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
-      fs13.rmSync(profileDir, { recursive: true });
+      const profileDir = path15.join(profilesDir, name);
+      if (!fs15.existsSync(profileDir)) return { handled: true, output: pc5.red(`Profile not found: ${name}`) };
+      fs15.rmSync(profileDir, { recursive: true });
       return { handled: true, output: pc5.dim(`Profile deleted: ${name}`) };
     }
     case "help":
@@ -4927,7 +5336,7 @@ ${lines.join("\n")}` };
       return { handled: true, output: pc5.yellow(`Unknown profile action: ${action}. Try /profile help`) };
   }
 }
-function handlePlanCommand(action, args) {
+function handlePlanCommand(action, args, ctx) {
   if (!action) {
     const active = getActivePlan();
     if (!active) {
@@ -4956,17 +5365,29 @@ function handlePlanCommand(action, args) {
     case "done": {
       const active = getActivePlan();
       if (!active) return { handled: true, output: pc5.yellow("No active plan.") };
+      const recordPlanMilestone = (stepIndex) => {
+        if (ctx?.observationSession) {
+          const step = active.steps[stepIndex];
+          recordEvent(ctx.observationSession, {
+            type: "milestone",
+            summary: `Plan step done: ${step.text}`,
+            data: { plan: active.name, stepIndex, stepText: step.text }
+          });
+        }
+      };
       if (args.length > 0) {
         const stepNum = parseInt(args[0], 10);
         if (isNaN(stepNum) || stepNum < 1 || stepNum > active.steps.length) {
           return { handled: true, output: pc5.yellow(`Invalid step number. Range: 1-${active.steps.length}`) };
         }
         markStepDone(active, stepNum - 1);
+        recordPlanMilestone(stepNum - 1);
         return { handled: true, output: pc5.green(`Step ${stepNum} done!`) + "\n\n" + formatPlan(active) };
       }
       const next = active.steps.findIndex((s) => !s.done);
       if (next < 0) return { handled: true, output: pc5.green("All steps already complete!") };
       markStepDone(active, next);
+      recordPlanMilestone(next);
       return { handled: true, output: pc5.green(`Step ${next + 1} done!`) + "\n\n" + formatPlan(active) };
     }
     case "undo": {
@@ -5109,10 +5530,10 @@ function handleShowcaseCommand(action, args) {
   Or place it as a sibling directory to aman-agent.`
     };
   }
-  const corePath = path13.join(os12.homedir(), ".acore", "core.md");
+  const corePath = path15.join(os14.homedir(), ".acore", "core.md");
   let currentShowcase = null;
-  if (fs13.existsSync(corePath)) {
-    const content = fs13.readFileSync(corePath, "utf-8");
+  if (fs15.existsSync(corePath)) {
+    const content = fs15.readFileSync(corePath, "utf-8");
     const nameMatch = content.match(/^# (.+)/m);
     if (nameMatch) {
       const coreName = nameMatch[1].trim().toLowerCase();
@@ -5283,8 +5704,76 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "delegate",
   "team",
   "showcase",
-  "file"
+  "file",
+  "observe",
+  "postmortem"
 ]);
+async function handleObserveCommand(action, ctx) {
+  if (!ctx.observationSession) {
+    return {
+      handled: true,
+      output: pc5.dim("Observation is disabled. Enable with recordObservations: true in config.")
+    };
+  }
+  switch (action) {
+    case "pause":
+      pauseObservation(ctx.observationSession);
+      return { handled: true, output: pc5.dim("Observation paused. Use /observe resume to continue.") };
+    case "resume":
+      resumeObservation(ctx.observationSession);
+      return { handled: true, output: pc5.dim("Observation resumed.") };
+    default:
+      return { handled: true, output: getSessionStats(ctx.observationSession) };
+  }
+}
+async function handlePostmortemCommand(action, args, ctx) {
+  switch (action) {
+    case "last": {
+      const files = await listPostmortems();
+      if (files.length === 0) return { handled: true, output: pc5.dim("No post-mortems found.") };
+      const content = await readPostmortem(files[0]);
+      return { handled: true, output: content ?? pc5.red("Could not read post-mortem.") };
+    }
+    case "list": {
+      const files = await listPostmortems();
+      if (files.length === 0) return { handled: true, output: pc5.dim("No post-mortems found.") };
+      return { handled: true, output: "Post-mortems:\n" + files.map((f) => `  ${f}`).join("\n") };
+    }
+    default: {
+      const allArgs = action ? [action, ...args] : args;
+      const sinceIdx = allArgs.indexOf("--since");
+      if (sinceIdx !== -1 && allArgs[sinceIdx + 1]) {
+        const daysStr = allArgs[sinceIdx + 1];
+        const days = parseInt(daysStr.replace("d", ""), 10) || 7;
+        if (!ctx.llmClient) {
+          return { handled: true, output: pc5.red("LLM client not available for analysis.") };
+        }
+        const analysis = await analyzePostmortemRange(days, ctx.llmClient);
+        return { handled: true, output: analysis ?? pc5.red("Could not analyze post-mortems.") };
+      }
+      if (!ctx.observationSession || !ctx.llmClient || !ctx.messages) {
+        return {
+          handled: true,
+          output: pc5.dim("Cannot generate post-mortem: missing session context.")
+        };
+      }
+      const report = await generatePostmortemReport(
+        ctx.observationSession.sessionId,
+        ctx.messages,
+        ctx.observationSession,
+        ctx.llmClient
+      );
+      if (!report) return { handled: true, output: pc5.red("Could not generate post-mortem.") };
+      const filePath = await savePostmortem(report);
+      return {
+        handled: true,
+        output: formatPostmortemMarkdown(report) + `
+
+${pc5.dim(`Saved \u2192 ${filePath}`)}`
+      };
+    }
+  }
+}
 async function handleCommand(input, ctx) {
   const trimmed = input.trim();
   if (!trimmed.startsWith("/")) return { handled: false };
@@ -5332,7 +5821,7 @@ async function handleCommand(input, ctx) {
     case "reset":
       return handleReset(action);
     case "plan":
-      return handlePlanCommand(action, args);
+      return handlePlanCommand(action, args, ctx);
     case "profile":
       return handleProfileCommand(action, args);
     case "delegate":
@@ -5348,6 +5837,10 @@ async function handleCommand(input, ctx) {
     case "update":
     case "upgrade":
       return handleUpdate();
+    case "observe":
+      return handleObserveCommand(action, ctx);
+    case "postmortem":
+      return handlePostmortemCommand(action, args, ctx);
     default:
       return { handled: false };
   }
@@ -5427,9 +5920,9 @@ ${summaryParts.slice(0, 20).join("\n")}
 }
 
 // src/skill-engine.ts
-import fs14 from "fs";
-import path14 from "path";
-import os13 from "os";
+import fs16 from "fs";
+import path16 from "path";
+import os15 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"],
@@ -5444,20 +5937,20 @@ var SKILL_TRIGGERS = {
   typescript: ["typescript", "type", "interface", "generic", "infer", "utility type", "zod", "discriminated union", "type guard", "as const"],
   accessibility: ["accessibility", "a11y", "aria", "screen reader", "wcag", "semantic html", "tab order", "focus", "contrast"]
 };
-var LEVEL_FILE = path14.join(os13.homedir(), ".aman-agent", "skill-levels.json");
+var LEVEL_FILE = path16.join(os15.homedir(), ".aman-agent", "skill-levels.json");
 function loadSkillLevels() {
   try {
-    if (fs14.existsSync(LEVEL_FILE)) {
-      return JSON.parse(fs14.readFileSync(LEVEL_FILE, "utf-8"));
+    if (fs16.existsSync(LEVEL_FILE)) {
+      return JSON.parse(fs16.readFileSync(LEVEL_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function saveSkillLevels(levels) {
-  const dir = path14.dirname(LEVEL_FILE);
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-  fs14.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
+  const dir = path16.dirname(LEVEL_FILE);
+  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+  fs16.writeFileSync(LEVEL_FILE, JSON.stringify(levels, null, 2), "utf-8");
 }
 function computeLevel(activations) {
   if (activations >= 50) return { level: 5, label: "Expert" };
@@ -6070,9 +6563,9 @@ function humanizeError(message) {
 }
 
 // src/hints.ts
-import fs15 from "fs";
-import path15 from "path";
-import os14 from "os";
+import fs17 from "fs";
+import path17 from "path";
+import os16 from "os";
 var HINTS = [
   {
     id: "eval",
@@ -6110,11 +6603,11 @@ function getHint(state, ctx) {
   }
   return null;
 }
-var HINTS_FILE = path15.join(os14.homedir(), ".aman-agent", "hints-seen.json");
+var HINTS_FILE = path17.join(os16.homedir(), ".aman-agent", "hints-seen.json");
 function loadShownHints() {
   try {
-    if (fs15.existsSync(HINTS_FILE)) {
-      const data = JSON.parse(fs15.readFileSync(HINTS_FILE, "utf-8"));
+    if (fs17.existsSync(HINTS_FILE)) {
+      const data = JSON.parse(fs17.readFileSync(HINTS_FILE, "utf-8"));
       return new Set(Array.isArray(data) ? data : []);
     }
   } catch {
@@ -6123,9 +6616,9 @@ function loadShownHints() {
 }
 function saveShownHints(shown) {
   try {
-    const dir = path15.dirname(HINTS_FILE);
-    fs15.mkdirSync(dir, { recursive: true });
-    fs15.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
+    const dir = path17.dirname(HINTS_FILE);
+    fs17.mkdirSync(dir, { recursive: true });
+    fs17.writeFileSync(HINTS_FILE, JSON.stringify([...shown]), "utf-8");
   } catch {
   }
 }
@@ -6262,10 +6755,14 @@ async function runAgent(client, systemPrompt, aiName, model, tools, mcpManager,
       await bgTasks.waitAll();
       bgTasks.displayCompleted();
     }
+    if (observationSession) {
+      await flushEvents(observationSession).catch(() => {
+      });
+    }
     if (mcpManager && hooksConfig) {
       try {
-        const hookCtx = { mcpManager, config: hooksConfig };
-        await onSessionEnd(hookCtx, messages, sessionId);
+        const hookCtx = { mcpManager, config: hooksConfig, llmClient: client };
+        await onSessionEnd(hookCtx, messages, sessionId, observationSession);
       } catch (err) {
         log.debug("agent", "session end hook failed on SIGINT", err);
       }
@@ -6314,6 +6811,13 @@ Type a message, ${pc7.dim("/help")} for commands, or ${pc7.dim("/quit")} to exit
       log.warn("agent", "session start hook failed", err);
     }
   }
+  let observationSession;
+  let prevSentiment;
+  if (hooksConfig?.recordObservations !== false) {
+    observationSession = createObservationSession(sessionId);
+    cleanupOldObservations().catch(() => {
+    });
+  }
   while (true) {
     if (bgTasks.hasCompleted) {
       const completed = bgTasks.collectCompleted();
@@ -6353,13 +6857,24 @@ ${task.result}`
     }
     const input = await prompt();
     if (!input.trim()) continue;
-    const cmdResult = await handleCommand(input, { model, mcpManager, llmClient: client, tools });
+    const cmdResult = await handleCommand(input, {
+      model,
+      mcpManager,
+      llmClient: client,
+      tools,
+      observationSession,
+      messages
+    });
     if (cmdResult.handled) {
       if (cmdResult.quit) {
+        if (observationSession) {
+          await flushEvents(observationSession).catch(() => {
+          });
+        }
         if (mcpManager && hooksConfig) {
           try {
-            const hookCtx = { mcpManager, config: hooksConfig };
-            await onSessionEnd(hookCtx, messages, sessionId);
+            const hookCtx = { mcpManager, config: hooksConfig, llmClient: client };
+            await onSessionEnd(hookCtx, messages, sessionId, observationSession);
           } catch (err) {
             log.debug("agent", "session end hook failed on quit", err);
           }
@@ -6370,9 +6885,9 @@ ${task.result}`
       }
       if (cmdResult.exportConversation) {
         try {
-          const exportDir = path16.join(os15.homedir(), ".aman-agent", "exports");
-          fs16.mkdirSync(exportDir, { recursive: true });
-          const exportPath = path16.join(exportDir, `${sessionId}.md`);
+          const exportDir = path18.join(os17.homedir(), ".aman-agent", "exports");
+          fs18.mkdirSync(exportDir, { recursive: true });
+          const exportPath = path18.join(exportDir, `${sessionId}.md`);
           const lines = [
             `# Conversation \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
             `**Model:** ${model}`,
@@ -6386,7 +6901,7 @@ ${task.result}`
               lines.push(`${label} ${msg.content}`, "");
             }
           }
-          fs16.writeFileSync(exportPath, lines.join("\n"), "utf-8");
+          fs18.writeFileSync(exportPath, lines.join("\n"), "utf-8");
           console.log(pc7.green(`Exported to ${exportPath}`));
         } catch {
           console.log(pc7.red("Failed to export conversation."));
@@ -6512,25 +7027,25 @@ ${knowledgeItem.content}
     for (const match of filePathMatches) {
       let filePath = match[1];
       if (filePath.startsWith("~/")) {
-        filePath = path16.join(os15.homedir(), filePath.slice(2));
+        filePath = path18.join(os17.homedir(), filePath.slice(2));
       }
-      if (!fs16.existsSync(filePath) || !fs16.statSync(filePath).isFile()) continue;
-      const ext = path16.extname(filePath).toLowerCase();
+      if (!fs18.existsSync(filePath) || !fs18.statSync(filePath).isFile()) continue;
+      const ext = path18.extname(filePath).toLowerCase();
       if (imageExts.has(ext)) {
         try {
-          const stat = fs16.statSync(filePath);
+          const stat = fs18.statSync(filePath);
           if (stat.size > maxImageBytes) {
-            process.stdout.write(pc7.yellow(`  [skipped: ${path16.basename(filePath)} \u2014 exceeds 20MB limit]
+            process.stdout.write(pc7.yellow(`  [skipped: ${path18.basename(filePath)} \u2014 exceeds 20MB limit]
 `));
             continue;
           }
-          const data = fs16.readFileSync(filePath).toString("base64");
+          const data = fs18.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: ${path16.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached image: ${path18.basename(filePath)} (${(stat.size / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read image: ${filePath}]
@@ -6538,7 +7053,7 @@ ${knowledgeItem.content}
         }
       } else if (textExts.has(ext) || ext === "") {
         try {
-          const content = fs16.readFileSync(filePath, "utf-8");
+          const content = fs18.readFileSync(filePath, "utf-8");
           const maxChars = 5e4;
           const trimmed = content.length > maxChars ? content.slice(0, maxChars) + `
 
@@ -6548,7 +7063,7 @@ ${knowledgeItem.content}
 <file path="${filePath}" size="${content.length} chars">
 ${trimmed}
 </file>`;
-          process.stdout.write(pc7.dim(`  [attached: ${path16.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
+          process.stdout.write(pc7.dim(`  [attached: ${path18.basename(filePath)} (${(content.length / 1024).toFixed(1)}KB)]
 `));
         } catch {
           process.stdout.write(pc7.dim(`  [could not read: ${filePath}]
@@ -6557,7 +7072,7 @@ ${trimmed}
       } else if (docExts.has(ext)) {
         if (mcpManager) {
           try {
-            process.stdout.write(pc7.dim(`  [converting: ${path16.basename(filePath)}...]
+            process.stdout.write(pc7.dim(`  [converting: ${path18.basename(filePath)}...]
 `));
             const converted = await mcpManager.callTool("doc_convert", { path: filePath });
             if (converted && !converted.startsWith("Error") && !converted.includes("Could not convert")) {
@@ -6566,7 +7081,7 @@ ${trimmed}
 <file path="${filePath}" format="${ext}">
 ${converted.slice(0, 5e4)}
 </file>`;
-              process.stdout.write(pc7.dim(`  [attached: ${path16.basename(filePath)} (converted from ${ext})]
+              process.stdout.write(pc7.dim(`  [attached: ${path18.basename(filePath)} (converted from ${ext})]
 `));
             } else {
               textContent += `
@@ -6578,7 +7093,7 @@ ${converted}
 `));
             }
           } catch {
-            process.stdout.write(pc7.dim(`  [could not convert: ${path16.basename(filePath)}]
+            process.stdout.write(pc7.dim(`  [could not convert: ${path18.basename(filePath)}]
 `));
           }
         } else {
@@ -6659,6 +7174,33 @@ ${converted}
       });
       syncPersonalityToCore(state, mcpManager).catch(() => {
       });
+      if (observationSession && prevSentiment !== state.sentiment.dominant) {
+        recordEvent(observationSession, {
+          type: "sentiment_shift",
+          summary: `${prevSentiment ?? "neutral"} \u2192 ${state.sentiment.dominant}`,
+          data: { from: prevSentiment ?? "neutral", to: state.sentiment.dominant }
+        });
+        prevSentiment = state.sentiment.dominant;
+      }
+      if (observationSession && state.sentiment.frustration > 0.6) {
+        recordEvent(observationSession, {
+          type: "blocker",
+          summary: "User expressing frustration",
+          data: { frustrationLevel: state.sentiment.frustration }
+        });
+      }
+      if (observationSession && recentUserMsgs.length >= 6) {
+        const recent = recentUserMsgs.slice(-3);
+        const previous = recentUserMsgs.slice(-6, -3);
+        const shift = detectTopicShift(recent, previous);
+        if (shift.shifted) {
+          recordEvent(observationSession, {
+            type: "topic_shift",
+            summary: `Topics: ${shift.newTopics.join(", ")}`,
+            data: { newTopics: shift.newTopics }
+          });
+        }
+      }
       const nudge = formatWellbeingNudge(state);
       if (nudge) {
         augmentedSystemPrompt += "\n" + nudge;
@@ -6757,7 +7299,38 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
             }
             process.stdout.write(pc7.dim(`  [using ${toolUse.name}...]
 `));
-            const result = await mcpManager.callTool(toolUse.name, toolUse.input);
+            const toolStartMs = Date.now();
+            let result;
+            try {
+              result = await mcpManager.callTool(toolUse.name, toolUse.input);
+            } catch (toolErr) {
+              const errMsg = toolErr instanceof Error ? toolErr.message : String(toolErr);
+              if (observationSession) {
+                recordEvent(observationSession, {
+                  type: "tool_error",
+                  summary: `${toolUse.name}: ${errMsg}`,
+                  data: { tool: toolUse.name, error: errMsg }
+                });
+              }
+              throw toolErr;
+            }
+            if (observationSession) {
+              const durationMs = Date.now() - toolStartMs;
+              recordEvent(observationSession, {
+                type: "tool_call",
+                summary: `${toolUse.name} (${durationMs}ms)`,
+                data: { tool: toolUse.name, durationMs, success: true }
+              });
+              const FILE_TOOLS = /* @__PURE__ */ new Set(["file_write", "file_edit", "file_create", "file_delete"]);
+              if (FILE_TOOLS.has(toolUse.name)) {
+                const filePath = toolUse.input?.path ?? "unknown";
+                recordEvent(observationSession, {
+                  type: "file_change",
+                  summary: `${toolUse.name}: ${String(filePath)}`,
+                  data: { tool: toolUse.name, path: filePath }
+                });
+              }
+            }
             const skipLogging = ["memory_log", "memory_recall", "memory_context", "memory_detail", "reminder_check"].includes(toolUse.name);
             if (!skipLogging) {
               try {
@@ -6799,6 +7372,10 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
         });
         log.debug("agent", `checkpoint saved at turn ${currentTurn}`);
       }
+      if (observationSession && observationSession.events.length >= 5) {
+        flushEvents(observationSession).catch(() => {
+        });
+      }
       if (hooksConfig?.extractMemories) {
         const assistantText = typeof response.message.content === "string" ? response.message.content : response.message.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("");
         if (assistantText) {
@@ -6820,7 +7397,7 @@ ${result2.response}` : `[${input2.profile}] failed: ${result2.error}`;
       }
       if (hooksConfig?.featureHints) {
         hintState.turnCount++;
-        const hasWorkflows = fs16.existsSync(path16.join(os15.homedir(), ".aflow", "flow.md"));
+        const hasWorkflows = fs18.existsSync(path18.join(os17.homedir(), ".aflow", "flow.md"));
         const memoryCount = memoryTokens > 0 ? Math.floor(memoryTokens / 5) : 0;
         const hint = getHint(hintState, { hasWorkflows, memoryCount });
         if (hint) {
@@ -6866,9 +7443,9 @@ async function saveConversationToMemory(messages, sessionId) {
 }
 
 // src/index.ts
-import fs17 from "fs";
-import path17 from "path";
-import os16 from "os";
+import fs19 from "fs";
+import path19 from "path";
+import os18 from "os";
 
 // src/presets.ts
 var PRESETS = {
@@ -6977,9 +7554,9 @@ ${wfSections}`;
 
 // src/index.ts
 async function autoDetectConfig() {
-  const reconfigMarker = path17.join(os16.homedir(), ".aman-agent", ".reconfig");
-  if (fs17.existsSync(reconfigMarker)) {
-    fs17.unlinkSync(reconfigMarker);
+  const reconfigMarker = path19.join(os18.homedir(), ".aman-agent", ".reconfig");
+  if (fs19.existsSync(reconfigMarker)) {
+    fs19.unlinkSync(reconfigMarker);
     return null;
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -7008,11 +7585,11 @@ async function autoDetectConfig() {
   return null;
 }
 function bootstrapEcosystem() {
-  const home2 = os16.homedir();
-  const corePath = path17.join(home2, ".acore", "core.md");
-  if (fs17.existsSync(corePath)) return false;
-  fs17.mkdirSync(path17.join(home2, ".acore"), { recursive: true });
-  fs17.writeFileSync(corePath, [
+  const home2 = os18.homedir();
+  const corePath = path19.join(home2, ".acore", "core.md");
+  if (fs19.existsSync(corePath)) return false;
+  fs19.mkdirSync(path19.join(home2, ".acore"), { recursive: true });
+  fs19.writeFileSync(corePath, [
     "# Aman",
     "",
     "## Personality",
@@ -7024,11 +7601,11 @@ function bootstrapEcosystem() {
     "## Session",
     "_New companion \u2014 no prior sessions._"
   ].join("\n"), "utf-8");
-  const rulesDir = path17.join(home2, ".arules");
-  const rulesPath = path17.join(rulesDir, "rules.md");
-  if (!fs17.existsSync(rulesPath)) {
-    fs17.mkdirSync(rulesDir, { recursive: true });
-    fs17.writeFileSync(rulesPath, [
+  const rulesDir = path19.join(home2, ".arules");
+  const rulesPath = path19.join(rulesDir, "rules.md");
+  if (!fs19.existsSync(rulesPath)) {
+    fs19.mkdirSync(rulesDir, { recursive: true });
+    fs19.writeFileSync(rulesPath, [
       "# Guardrails",
       "",
       "## safety",
@@ -7040,22 +7617,22 @@ function bootstrapEcosystem() {
       "- Respect the user's preferences stored in memory"
     ].join("\n"), "utf-8");
   }
-  const flowDir = path17.join(home2, ".aflow");
-  const flowPath = path17.join(flowDir, "flow.md");
-  if (!fs17.existsSync(flowPath)) {
-    fs17.mkdirSync(flowDir, { recursive: true });
-    fs17.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
+  const flowDir = path19.join(home2, ".aflow");
+  const flowPath = path19.join(flowDir, "flow.md");
+  if (!fs19.existsSync(flowPath)) {
+    fs19.mkdirSync(flowDir, { recursive: true });
+    fs19.writeFileSync(flowPath, "# Workflows\n\n_No workflows defined yet. Use /workflows add to create one._\n", "utf-8");
   }
-  const skillDir = path17.join(home2, ".askill");
-  const skillPath = path17.join(skillDir, "skills.md");
-  if (!fs17.existsSync(skillPath)) {
-    fs17.mkdirSync(skillDir, { recursive: true });
-    fs17.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
+  const skillDir = path19.join(home2, ".askill");
+  const skillPath = path19.join(skillDir, "skills.md");
+  if (!fs19.existsSync(skillPath)) {
+    fs19.mkdirSync(skillDir, { recursive: true });
+    fs19.writeFileSync(skillPath, "# Skills\n\n_No skills installed yet. Use /skills install to add domain expertise._\n", "utf-8");
   }
   return true;
 }
 var program = new Command();
-program.name("aman-agent").description("Your AI companion, running locally").version("0.24.3").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.25.0").option("--model <model>", "Override LLM model").option("--budget <tokens>", "Token budget for system prompt (default: 8000)", parseInt).option("--profile <name>", "Use a specific agent profile (e.g., coder, writer, researcher)").action(async (options) => {
   p3.intro(pc8.bold("aman agent") + pc8.dim(" \u2014 your AI companion"));
   let config = loadConfig();
   if (!config) {
@@ -7407,19 +7984,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 = os16.homedir();
-  fs17.mkdirSync(path17.join(home2, ".acore"), { recursive: true });
-  fs17.writeFileSync(path17.join(home2, ".acore", "core.md"), result.coreMd, "utf-8");
+  const home2 = os18.homedir();
+  fs19.mkdirSync(path19.join(home2, ".acore"), { recursive: true });
+  fs19.writeFileSync(path19.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) {
-    fs17.mkdirSync(path17.join(home2, ".arules"), { recursive: true });
-    fs17.writeFileSync(path17.join(home2, ".arules", "rules.md"), result.rulesMd, "utf-8");
+    fs19.mkdirSync(path19.join(home2, ".arules"), { recursive: true });
+    fs19.writeFileSync(path19.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) {
-    fs17.mkdirSync(path17.join(home2, ".aflow"), { recursive: true });
-    fs17.writeFileSync(path17.join(home2, ".aflow", "flow.md"), result.flowMd, "utf-8");
+    fs19.mkdirSync(path19.join(home2, ".aflow"), { recursive: true });
+    fs19.writeFileSync(path19.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`);
   }