@keepgoingdev/mcp-server 0.7.1 → 0.8.0

package/dist/index.js

@@ -6,6 +6,16 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // ../../packages/shared/src/session.ts
 import { randomUUID } from "crypto";
+
+// ../../packages/shared/src/sanitize.ts
+var AGENT_TAG_PATTERN = /<\/?(?:teammate-message|system-reminder|command-name|tool_use)\b[^>]*>/g;
+function stripAgentTags(text) {
+  if (!text) return "";
+  const stripped = text.replace(AGENT_TAG_PATTERN, "");
+  return stripped.trim();
+}
+
+// ../../packages/shared/src/session.ts
 function generateCheckpointId() {
   return randomUUID();
 }
@@ -13,7 +23,10 @@ function createCheckpoint(fields) {
   return {
     id: generateCheckpointId(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    ...fields
+    ...fields,
+    summary: stripAgentTags(fields.summary),
+    nextStep: stripAgentTags(fields.nextStep),
+    blocker: fields.blocker ? stripAgentTags(fields.blocker) : fields.blocker
   };
 }
 function createDecisionRecord(fields) {
@@ -78,7 +91,8 @@ function findGitRoot(startPath) {
     const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: startPath,
       encoding: "utf-8",
-      timeout: 5e3
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     return toplevel || startPath;
   } catch {
@@ -95,12 +109,14 @@ function resolveStorageRoot(startPath) {
     const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: startPath,
       encoding: "utf-8",
-      timeout: 5e3
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
       cwd: startPath,
       encoding: "utf-8",
-      timeout: 5e3
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const absoluteCommonDir = path.resolve(toplevel, commonDir);
     const mainRoot = path.dirname(absoluteCommonDir);
@@ -703,22 +719,160 @@ function formatContinueOnPrompt(context, options) {
   return result;
 }
 
-// ../../packages/shared/src/storage.ts
-import fs2 from "fs";
-import path4 from "path";
-import { randomUUID as randomUUID2, createHash } from "crypto";
+// ../../packages/shared/src/reader.ts
+import fs4 from "fs";
+import path6 from "path";
 
-// ../../packages/shared/src/registry.ts
+// ../../packages/shared/src/license.ts
+import crypto from "crypto";
 import fs from "fs";
 import os from "os";
 import path3 from "path";
-var KEEPGOING_DIR = path3.join(os.homedir(), ".keepgoing");
-var KNOWN_PROJECTS_FILE = path3.join(KEEPGOING_DIR, "known-projects.json");
+var LICENSE_FILE = "license.json";
+var DEVICE_ID_FILE = "device-id";
+function getGlobalLicenseDir() {
+  return path3.join(os.homedir(), ".keepgoing");
+}
+function getGlobalLicensePath() {
+  return path3.join(getGlobalLicenseDir(), LICENSE_FILE);
+}
+function getDeviceId() {
+  const dir = getGlobalLicenseDir();
+  const filePath = path3.join(dir, DEVICE_ID_FILE);
+  try {
+    const existing = fs.readFileSync(filePath, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, id, "utf-8");
+  return id;
+}
+var DECISION_DETECTION_VARIANT_ID = 1361527;
+var SESSION_AWARENESS_VARIANT_ID = 1366510;
+var TEST_DECISION_DETECTION_VARIANT_ID = 1345647;
+var TEST_SESSION_AWARENESS_VARIANT_ID = 1365992;
+var VARIANT_FEATURE_MAP = {
+  [DECISION_DETECTION_VARIANT_ID]: ["decisions"],
+  [SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"],
+  [TEST_DECISION_DETECTION_VARIANT_ID]: ["decisions"],
+  [TEST_SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"]
+  // Future bundle: [BUNDLE_VARIANT_ID]: ['decisions', 'session-awareness'],
+};
+var KNOWN_VARIANT_IDS = new Set(Object.keys(VARIANT_FEATURE_MAP).map(Number));
+function getVariantLabel(variantId) {
+  const features = VARIANT_FEATURE_MAP[variantId];
+  if (!features) return "Unknown Add-on";
+  if (features.includes("decisions") && features.includes("session-awareness")) return "Pro Bundle";
+  if (features.includes("decisions")) return "Decision Detection";
+  if (features.includes("session-awareness")) return "Session Awareness";
+  return "Pro Add-on";
+}
+var _cachedStore;
+var _cacheTimestamp = 0;
+var LICENSE_CACHE_TTL_MS = 2e3;
+function readLicenseStore() {
+  const now = Date.now();
+  if (_cachedStore && now - _cacheTimestamp < LICENSE_CACHE_TTL_MS) {
+    return _cachedStore;
+  }
+  const licensePath = getGlobalLicensePath();
+  let store;
+  try {
+    if (!fs.existsSync(licensePath)) {
+      store = { version: 2, licenses: [] };
+    } else {
+      const raw = fs.readFileSync(licensePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data?.version === 2 && Array.isArray(data.licenses)) {
+        store = data;
+      } else {
+        store = { version: 2, licenses: [] };
+      }
+    }
+  } catch {
+    store = { version: 2, licenses: [] };
+  }
+  _cachedStore = store;
+  _cacheTimestamp = now;
+  return store;
+}
+function writeLicenseStore(store) {
+  const dirPath = getGlobalLicenseDir();
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  const licensePath = path3.join(dirPath, LICENSE_FILE);
+  fs.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
+  _cachedStore = store;
+  _cacheTimestamp = Date.now();
+}
+function addLicenseEntry(entry) {
+  const store = readLicenseStore();
+  const idx = store.licenses.findIndex((l) => l.licenseKey === entry.licenseKey);
+  if (idx >= 0) {
+    store.licenses[idx] = entry;
+  } else {
+    store.licenses.push(entry);
+  }
+  writeLicenseStore(store);
+}
+function removeLicenseEntry(licenseKey) {
+  const store = readLicenseStore();
+  store.licenses = store.licenses.filter((l) => l.licenseKey !== licenseKey);
+  writeLicenseStore(store);
+}
+function getActiveLicenses() {
+  return readLicenseStore().licenses.filter((l) => l.status === "active");
+}
+function getLicenseForFeature(feature) {
+  const active = getActiveLicenses();
+  return active.find((l) => {
+    const features = VARIANT_FEATURE_MAP[l.variantId];
+    return features?.includes(feature);
+  });
+}
+function getAllLicensesNeedingRevalidation() {
+  return getActiveLicenses().filter((l) => needsRevalidation(l));
+}
+var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function needsRevalidation(entry) {
+  const lastValidated = new Date(entry.lastValidatedAt).getTime();
+  return Date.now() - lastValidated > REVALIDATION_THRESHOLD_MS;
+}
+
+// ../../packages/shared/src/storage.ts
+import fs3 from "fs";
+import path5 from "path";
+import { randomUUID as randomUUID2, createHash } from "crypto";
+
+// ../../packages/shared/src/registry.ts
+import fs2 from "fs";
+import os2 from "os";
+import path4 from "path";
+var KEEPGOING_DIR = path4.join(os2.homedir(), ".keepgoing");
+var KNOWN_PROJECTS_FILE = path4.join(KEEPGOING_DIR, "known-projects.json");
+var TRAY_CONFIG_FILE = path4.join(KEEPGOING_DIR, "tray-config.json");
 var STALE_PROJECT_MS = 90 * 24 * 60 * 60 * 1e3;
+function readTrayConfigProjects() {
+  try {
+    if (fs2.existsSync(TRAY_CONFIG_FILE)) {
+      const raw = JSON.parse(fs2.readFileSync(TRAY_CONFIG_FILE, "utf-8"));
+      if (raw && Array.isArray(raw.projects)) {
+        return raw.projects.filter((p) => typeof p === "string");
+      }
+    }
+  } catch {
+  }
+  return [];
+}
 function readKnownProjects() {
   try {
-    if (fs.existsSync(KNOWN_PROJECTS_FILE)) {
-      const raw = JSON.parse(fs.readFileSync(KNOWN_PROJECTS_FILE, "utf-8"));
+    if (fs2.existsSync(KNOWN_PROJECTS_FILE)) {
+      const raw = JSON.parse(fs2.readFileSync(KNOWN_PROJECTS_FILE, "utf-8"));
       if (raw && Array.isArray(raw.projects)) {
         return raw;
       }
@@ -728,18 +882,18 @@ function readKnownProjects() {
   return { version: 1, projects: [] };
 }
 function writeKnownProjects(data) {
-  if (!fs.existsSync(KEEPGOING_DIR)) {
-    fs.mkdirSync(KEEPGOING_DIR, { recursive: true });
+  if (!fs2.existsSync(KEEPGOING_DIR)) {
+    fs2.mkdirSync(KEEPGOING_DIR, { recursive: true });
   }
   const tmpFile = KNOWN_PROJECTS_FILE + ".tmp";
-  fs.writeFileSync(tmpFile, JSON.stringify(data, null, 2) + "\n", "utf-8");
-  fs.renameSync(tmpFile, KNOWN_PROJECTS_FILE);
+  fs2.writeFileSync(tmpFile, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  fs2.renameSync(tmpFile, KNOWN_PROJECTS_FILE);
 }
 function registerProject(projectPath, projectName) {
   try {
     const data = readKnownProjects();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const name = projectName || path3.basename(projectPath);
+    const name = projectName || path4.basename(projectPath);
     const existingIdx = data.projects.findIndex((p) => p.path === projectPath);
     if (existingIdx >= 0) {
       data.projects[existingIdx].lastSeen = now;
@@ -778,23 +932,23 @@ var KeepGoingWriter = class {
   currentTasksFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
-    this.storagePath = path4.join(mainRoot, STORAGE_DIR);
-    this.sessionsFilePath = path4.join(this.storagePath, SESSIONS_FILE);
-    this.stateFilePath = path4.join(this.storagePath, STATE_FILE);
-    this.metaFilePath = path4.join(this.storagePath, META_FILE);
-    this.currentTasksFilePath = path4.join(this.storagePath, CURRENT_TASKS_FILE);
+    this.storagePath = path5.join(mainRoot, STORAGE_DIR);
+    this.sessionsFilePath = path5.join(this.storagePath, SESSIONS_FILE);
+    this.stateFilePath = path5.join(this.storagePath, STATE_FILE);
+    this.metaFilePath = path5.join(this.storagePath, META_FILE);
+    this.currentTasksFilePath = path5.join(this.storagePath, CURRENT_TASKS_FILE);
   }
   ensureDir() {
-    if (!fs2.existsSync(this.storagePath)) {
-      fs2.mkdirSync(this.storagePath, { recursive: true });
+    if (!fs3.existsSync(this.storagePath)) {
+      fs3.mkdirSync(this.storagePath, { recursive: true });
     }
   }
   saveCheckpoint(checkpoint, projectName) {
     this.ensureDir();
     let sessionsData;
     try {
-      if (fs2.existsSync(this.sessionsFilePath)) {
-        const raw = JSON.parse(fs2.readFileSync(this.sessionsFilePath, "utf-8"));
+      if (fs3.existsSync(this.sessionsFilePath)) {
+        const raw = JSON.parse(fs3.readFileSync(this.sessionsFilePath, "utf-8"));
         if (Array.isArray(raw)) {
           sessionsData = { version: 1, project: projectName, sessions: raw };
         } else {
@@ -812,13 +966,13 @@ var KeepGoingWriter = class {
     if (sessionsData.sessions.length > MAX_SESSIONS) {
       sessionsData.sessions = sessionsData.sessions.slice(-MAX_SESSIONS);
     }
-    fs2.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
+    fs3.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
     const state = {
       lastSessionId: checkpoint.id,
       lastKnownBranch: checkpoint.gitBranch,
       lastActivityAt: checkpoint.timestamp
     };
-    fs2.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+    fs3.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
     this.updateMeta(checkpoint.timestamp);
     const mainRoot = resolveStorageRoot(this.storagePath);
     registerProject(mainRoot, projectName);
@@ -826,8 +980,8 @@ var KeepGoingWriter = class {
   updateMeta(timestamp) {
     let meta;
     try {
-      if (fs2.existsSync(this.metaFilePath)) {
-        meta = JSON.parse(fs2.readFileSync(this.metaFilePath, "utf-8"));
+      if (fs3.existsSync(this.metaFilePath)) {
+        meta = JSON.parse(fs3.readFileSync(this.metaFilePath, "utf-8"));
         meta.lastUpdated = timestamp;
       } else {
         meta = {
@@ -843,7 +997,28 @@ var KeepGoingWriter = class {
         lastUpdated: timestamp
       };
     }
-    fs2.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+    fs3.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+  }
+  // ---------------------------------------------------------------------------
+  // Activity signals API
+  // ---------------------------------------------------------------------------
+  /**
+   * Writes activity signals to state.json for momentum computation.
+   * Performs a shallow merge: provided fields overwrite existing ones,
+   * fields not provided are preserved.
+   */
+  writeActivitySignal(signal) {
+    this.ensureDir();
+    let state = {};
+    try {
+      if (fs3.existsSync(this.stateFilePath)) {
+        state = JSON.parse(fs3.readFileSync(this.stateFilePath, "utf-8"));
+      }
+    } catch {
+      state = {};
+    }
+    state.activitySignals = { ...state.activitySignals, ...signal };
+    fs3.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
   }
   // ---------------------------------------------------------------------------
   // Multi-session API
@@ -851,8 +1026,8 @@ var KeepGoingWriter = class {
   /** Read all current tasks from current-tasks.json. Auto-prunes stale sessions. */
   readCurrentTasks() {
     try {
-      if (fs2.existsSync(this.currentTasksFilePath)) {
-        const raw = JSON.parse(fs2.readFileSync(this.currentTasksFilePath, "utf-8"));
+      if (fs3.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs3.readFileSync(this.currentTasksFilePath, "utf-8"));
         const tasks = Array.isArray(raw) ? raw : raw.tasks ?? [];
         return this.pruneStale(tasks);
       }
@@ -873,6 +1048,8 @@ var KeepGoingWriter = class {
   /** Core upsert logic: merges the update into current-tasks.json and returns the pruned task list. */
   upsertSessionCore(update) {
     this.ensureDir();
+    if (update.taskSummary) update.taskSummary = stripAgentTags(update.taskSummary);
+    if (update.sessionLabel) update.sessionLabel = stripAgentTags(update.sessionLabel);
     const sessionId = update.sessionId || generateSessionId(update);
     const tasks = this.readAllTasksRaw();
     const existingIdx = tasks.findIndex((t) => t.sessionId === sessionId);
@@ -907,8 +1084,8 @@ var KeepGoingWriter = class {
   // ---------------------------------------------------------------------------
   readAllTasksRaw() {
     try {
-      if (fs2.existsSync(this.currentTasksFilePath)) {
-        const raw = JSON.parse(fs2.readFileSync(this.currentTasksFilePath, "utf-8"));
+      if (fs3.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs3.readFileSync(this.currentTasksFilePath, "utf-8"));
         return Array.isArray(raw) ? [...raw] : [...raw.tasks ?? []];
       }
     } catch {
@@ -920,7 +1097,7 @@ var KeepGoingWriter = class {
   }
   writeTasksFile(tasks) {
     const data = { version: 1, tasks };
-    fs2.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
+    fs3.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
   }
 };
 function generateSessionId(context) {
@@ -936,54 +1113,334 @@ function generateSessionId(context) {
   return `ses_${hash}`;
 }
 
-// ../../packages/shared/src/smartSummary.ts
-var PREFIX_VERBS = {
-  feat: "Added",
-  fix: "Fixed",
-  refactor: "Refactored",
-  docs: "Updated docs for",
-  test: "Added tests for",
-  chore: "Updated",
-  style: "Styled",
-  perf: "Optimized",
-  ci: "Updated CI for",
-  build: "Updated build for",
-  revert: "Reverted"
-};
-var NOISE_PATTERNS = [
-  "node_modules",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  ".gitignore",
-  ".DS_Store",
-  "dist/",
-  "out/",
-  "build/"
-];
-function categorizeCommits(messages) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const msg of messages) {
-    const match = msg.match(/^(\w+)(?:\([^)]*\))?[!]?:\s*(.+)/);
-    if (match) {
-      const prefix = match[1].toLowerCase();
-      const body = match[2].trim();
-      if (!groups.has(prefix)) {
-        groups.set(prefix, []);
+// ../../packages/shared/src/reader.ts
+var STORAGE_DIR2 = ".keepgoing";
+var META_FILE2 = "meta.json";
+var SESSIONS_FILE2 = "sessions.json";
+var DECISIONS_FILE = "decisions.json";
+var STATE_FILE2 = "state.json";
+var CURRENT_TASKS_FILE2 = "current-tasks.json";
+var KeepGoingReader = class {
+  workspacePath;
+  storagePath;
+  metaFilePath;
+  sessionsFilePath;
+  decisionsFilePath;
+  stateFilePath;
+  currentTasksFilePath;
+  _isWorktree;
+  _cachedBranch = null;
+  // null = not yet resolved
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    const mainRoot = resolveStorageRoot(workspacePath);
+    this._isWorktree = mainRoot !== workspacePath;
+    this.storagePath = path6.join(mainRoot, STORAGE_DIR2);
+    this.metaFilePath = path6.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path6.join(this.storagePath, SESSIONS_FILE2);
+    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE);
+    this.stateFilePath = path6.join(this.storagePath, STATE_FILE2);
+    this.currentTasksFilePath = path6.join(this.storagePath, CURRENT_TASKS_FILE2);
+  }
+  /** Check if .keepgoing/ directory exists. */
+  exists() {
+    return fs4.existsSync(this.storagePath);
+  }
+  /** Read state.json, returns undefined if missing or corrupt. */
+  getState() {
+    return this.readJsonFile(this.stateFilePath);
+  }
+  /** Read meta.json, returns undefined if missing or corrupt. */
+  getMeta() {
+    return this.readJsonFile(this.metaFilePath);
+  }
+  /**
+   * Read sessions from sessions.json.
+   * Handles both formats:
+   * - Flat array: SessionCheckpoint[] (from ProjectStorage)
+   * - Wrapper object: ProjectSessions (from SessionStorage)
+   */
+  getSessions() {
+    return this.parseSessions().sessions;
+  }
+  /**
+   * Get the most recent session checkpoint.
+   * Uses state.lastSessionId if available, falls back to last in array.
+   */
+  getLastSession() {
+    const { sessions, wrapperLastSessionId } = this.parseSessions();
+    if (sessions.length === 0) {
+      return void 0;
+    }
+    const state = this.getState();
+    if (state?.lastSessionId) {
+      const found = sessions.find((s) => s.id === state.lastSessionId);
+      if (found) {
+        return found;
       }
-      groups.get(prefix).push(body);
-    } else {
-      if (!groups.has("other")) {
-        groups.set("other", []);
+    }
+    if (wrapperLastSessionId) {
+      const found = sessions.find((s) => s.id === wrapperLastSessionId);
+      if (found) {
+        return found;
       }
-      groups.get("other").push(msg.trim());
     }
+    return sessions[sessions.length - 1];
   }
-  return groups;
-}
-function inferWorkAreas(files) {
-  const areas = /* @__PURE__ */ new Map();
-  for (const file of files) {
+  /**
+   * Returns the last N sessions, newest first.
+   */
+  getRecentSessions(count) {
+    return getRecentSessions(this.getSessions(), count);
+  }
+  /** Read all decisions from decisions.json. */
+  getDecisions() {
+    return this.parseDecisions().decisions;
+  }
+  /** Returns the last N decisions, newest first. */
+  getRecentDecisions(count) {
+    const all = this.getDecisions();
+    return all.slice(-count).reverse();
+  }
+  /** Read the multi-license store from `~/.keepgoing/license.json`. */
+  getLicenseStore() {
+    return readLicenseStore();
+  }
+  /**
+   * Read all current tasks from current-tasks.json.
+   * Automatically filters out stale finished sessions (> 2 hours).
+   */
+  getCurrentTasks() {
+    const multiRaw = this.readJsonFile(this.currentTasksFilePath);
+    if (multiRaw) {
+      const tasks = Array.isArray(multiRaw) ? multiRaw : multiRaw.tasks ?? [];
+      return this.pruneStale(tasks);
+    }
+    return [];
+  }
+  /** Get only active sessions (sessionActive=true and within stale threshold). */
+  getActiveTasks() {
+    return this.getCurrentTasks().filter((t) => t.sessionActive);
+  }
+  /** Get a specific session by ID. */
+  getTaskBySessionId(sessionId) {
+    return this.getCurrentTasks().find((t) => t.sessionId === sessionId);
+  }
+  /**
+   * Detect files being edited by multiple sessions simultaneously.
+   * Returns pairs of session IDs and the conflicting file paths.
+   */
+  detectFileConflicts() {
+    const activeTasks = this.getActiveTasks();
+    if (activeTasks.length < 2) return [];
+    const fileToSessions = /* @__PURE__ */ new Map();
+    for (const task of activeTasks) {
+      if (task.lastFileEdited && task.sessionId) {
+        const existing = fileToSessions.get(task.lastFileEdited) ?? [];
+        existing.push({
+          sessionId: task.sessionId,
+          agentLabel: task.agentLabel,
+          branch: task.branch
+        });
+        fileToSessions.set(task.lastFileEdited, existing);
+      }
+    }
+    const conflicts = [];
+    for (const [file, sessions] of fileToSessions) {
+      if (sessions.length > 1) {
+        conflicts.push({ file, sessions });
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Detect sessions on the same branch (possible duplicate work).
+   */
+  detectBranchOverlap() {
+    const activeTasks = this.getActiveTasks();
+    if (activeTasks.length < 2) return [];
+    const branchToSessions = /* @__PURE__ */ new Map();
+    for (const task of activeTasks) {
+      if (task.branch && task.sessionId) {
+        const existing = branchToSessions.get(task.branch) ?? [];
+        existing.push({ sessionId: task.sessionId, agentLabel: task.agentLabel });
+        branchToSessions.set(task.branch, existing);
+      }
+    }
+    const overlaps = [];
+    for (const [branch, sessions] of branchToSessions) {
+      if (sessions.length > 1) {
+        overlaps.push({ branch, sessions });
+      }
+    }
+    return overlaps;
+  }
+  pruneStale(tasks) {
+    return pruneStaleTasks(tasks);
+  }
+  /** Get the last session checkpoint for a specific branch. */
+  getLastSessionForBranch(branch) {
+    const sessions = this.getSessions().filter((s) => s.gitBranch === branch);
+    return sessions.length > 0 ? sessions[sessions.length - 1] : void 0;
+  }
+  /** Returns the last N sessions for a specific branch, newest first. */
+  getRecentSessionsForBranch(branch, count) {
+    const filtered = this.getSessions().filter((s) => s.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Returns the last N decisions for a specific branch, newest first. */
+  getRecentDecisionsForBranch(branch, count) {
+    const filtered = this.getDecisions().filter((d) => d.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Whether the workspace is inside a git worktree. */
+  get isWorktree() {
+    return this._isWorktree;
+  }
+  /**
+   * Returns the current git branch for this workspace.
+   * Lazily cached: the branch is resolved once per KeepGoingReader instance.
+   */
+  getCurrentBranch() {
+    if (this._cachedBranch === null) {
+      this._cachedBranch = getCurrentBranch(this.workspacePath);
+    }
+    return this._cachedBranch;
+  }
+  /**
+   * Worktree-aware last session lookup.
+   * In a worktree, scopes to the current branch with fallback to global.
+   * Returns the session and whether it fell back to global.
+   */
+  getScopedLastSession() {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      const scoped = this.getLastSessionForBranch(branch);
+      if (scoped) return { session: scoped, isFallback: false };
+      return { session: this.getLastSession(), isFallback: true };
+    }
+    return { session: this.getLastSession(), isFallback: false };
+  }
+  /** Worktree-aware recent sessions. Scopes to current branch in a worktree. */
+  getScopedRecentSessions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentSessionsForBranch(branch, count);
+    }
+    return this.getRecentSessions(count);
+  }
+  /** Worktree-aware recent decisions. Scopes to current branch in a worktree. */
+  getScopedRecentDecisions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentDecisionsForBranch(branch, count);
+    }
+    return this.getRecentDecisions(count);
+  }
+  /**
+   * Resolves branch scope from an explicit `branch` parameter.
+   * Used by tools that accept a `branch` argument (e.g. get_session_history, get_decisions).
+   * - `"all"` returns no filter.
+   * - An explicit branch name uses that.
+   * - `undefined` auto-scopes to the current branch in a worktree, or all branches otherwise.
+   */
+  resolveBranchScope(branch) {
+    if (branch === "all") {
+      return { effectiveBranch: void 0, scopeLabel: "all branches" };
+    }
+    if (branch) {
+      return { effectiveBranch: branch, scopeLabel: `branch \`${branch}\`` };
+    }
+    const currentBranch = this.getCurrentBranch();
+    if (this._isWorktree && currentBranch) {
+      return { effectiveBranch: currentBranch, scopeLabel: `branch \`${currentBranch}\` (worktree)` };
+    }
+    return { effectiveBranch: void 0, scopeLabel: "all branches" };
+  }
+  /**
+   * Parses sessions.json once, returning both the session list
+   * and the optional lastSessionId from a ProjectSessions wrapper.
+   */
+  parseSessions() {
+    const raw = this.readJsonFile(
+      this.sessionsFilePath
+    );
+    if (!raw) {
+      return { sessions: [] };
+    }
+    if (Array.isArray(raw)) {
+      return { sessions: raw };
+    }
+    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+  }
+  parseDecisions() {
+    const raw = this.readJsonFile(this.decisionsFilePath);
+    if (!raw) {
+      return { decisions: [] };
+    }
+    return { decisions: raw.decisions ?? [], lastDecisionId: raw.lastDecisionId };
+  }
+  readJsonFile(filePath) {
+    try {
+      if (!fs4.existsSync(filePath)) {
+        return void 0;
+      }
+      const raw = fs4.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// ../../packages/shared/src/smartSummary.ts
+var PREFIX_VERBS = {
+  feat: "Added",
+  fix: "Fixed",
+  refactor: "Refactored",
+  docs: "Updated docs for",
+  test: "Added tests for",
+  chore: "Updated",
+  style: "Styled",
+  perf: "Optimized",
+  ci: "Updated CI for",
+  build: "Updated build for",
+  revert: "Reverted"
+};
+var NOISE_PATTERNS = [
+  "node_modules",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  ".gitignore",
+  ".DS_Store",
+  "dist/",
+  "out/",
+  "build/"
+];
+function categorizeCommits(messages) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const match = msg.match(/^(\w+)(?:\([^)]*\))?[!]?:\s*(.+)/);
+    if (match) {
+      const prefix = match[1].toLowerCase();
+      const body = match[2].trim();
+      if (!groups.has(prefix)) {
+        groups.set(prefix, []);
+      }
+      groups.get(prefix).push(body);
+    } else {
+      if (!groups.has("other")) {
+        groups.set("other", []);
+      }
+      groups.get("other").push(msg.trim());
+    }
+  }
+  return groups;
+}
+function inferWorkAreas(files) {
+  const areas = /* @__PURE__ */ new Map();
+  for (const file of files) {
     if (NOISE_PATTERNS.some((p) => file.includes(p))) {
       continue;
     }
@@ -1098,131 +1555,222 @@ function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
-// ../../packages/shared/src/decisionStorage.ts
-import fs4 from "fs";
-import path6 from "path";
-
-// ../../packages/shared/src/license.ts
-import crypto from "crypto";
-import fs3 from "fs";
-import os2 from "os";
-import path5 from "path";
-var LICENSE_FILE = "license.json";
-var DEVICE_ID_FILE = "device-id";
-function getGlobalLicenseDir() {
-  return path5.join(os2.homedir(), ".keepgoing");
-}
-function getGlobalLicensePath() {
-  return path5.join(getGlobalLicenseDir(), LICENSE_FILE);
+// ../../packages/shared/src/contextSnapshot.ts
+import fs5 from "fs";
+import path7 from "path";
+function formatCompactRelativeTime(date) {
+  const diffMs = Date.now() - date.getTime();
+  if (isNaN(diffMs)) return "?";
+  if (diffMs < 0) return "now";
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  if (seconds < 60) return "now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 7) return `${days}d ago`;
+  return `${weeks}w ago`;
 }
-function getDeviceId() {
-  const dir = getGlobalLicenseDir();
-  const filePath = path5.join(dir, DEVICE_ID_FILE);
-  try {
-    const existing = fs3.readFileSync(filePath, "utf-8").trim();
-    if (existing) return existing;
-  } catch {
+function computeMomentum(timestamp, signals) {
+  if (signals) {
+    if (signals.lastGitOpAt) {
+      const gitOpDiffMs = Date.now() - new Date(signals.lastGitOpAt).getTime();
+      if (!isNaN(gitOpDiffMs) && gitOpDiffMs >= 0 && gitOpDiffMs < 30 * 60 * 1e3) {
+        return "hot";
+      }
+    }
+    if (signals.recentCommitCount !== void 0 && signals.recentCommitCount >= 2) {
+      return "hot";
+    }
   }
-  const id = crypto.randomUUID();
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  if (isNaN(diffMs) || diffMs < 0) return "hot";
+  const minutes = diffMs / (1e3 * 60);
+  if (minutes < 30) return "hot";
+  if (minutes < 240) return "warm";
+  return "cold";
+}
+function inferFocusFromBranch2(branch) {
+  if (!branch || branch === "main" || branch === "master" || branch === "develop" || branch === "HEAD") {
+    return void 0;
   }
-  fs3.writeFileSync(filePath, id, "utf-8");
-  return id;
+  const prefixPattern = /^(?:feature|feat|fix|bugfix|hotfix|chore|refactor|docs|test|ci)\//i;
+  const isFix = /^(?:fix|bugfix|hotfix)\//i.test(branch);
+  const stripped = branch.replace(prefixPattern, "");
+  const cleaned = stripped.replace(/[-_/]/g, " ").replace(/^\d+\s*/, "").trim();
+  if (!cleaned) return void 0;
+  return isFix ? `${cleaned} fix` : cleaned;
 }
-var DECISION_DETECTION_VARIANT_ID = 1361527;
-var SESSION_AWARENESS_VARIANT_ID = 1366510;
-var TEST_DECISION_DETECTION_VARIANT_ID = 1345647;
-var TEST_SESSION_AWARENESS_VARIANT_ID = 1365992;
-var VARIANT_FEATURE_MAP = {
-  [DECISION_DETECTION_VARIANT_ID]: ["decisions"],
-  [SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"],
-  [TEST_DECISION_DETECTION_VARIANT_ID]: ["decisions"],
-  [TEST_SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"]
-  // Future bundle: [BUNDLE_VARIANT_ID]: ['decisions', 'session-awareness'],
-};
-var KNOWN_VARIANT_IDS = new Set(Object.keys(VARIANT_FEATURE_MAP).map(Number));
-function getVariantLabel(variantId) {
-  const features = VARIANT_FEATURE_MAP[variantId];
-  if (!features) return "Unknown Add-on";
-  if (features.includes("decisions") && features.includes("session-awareness")) return "Pro Bundle";
-  if (features.includes("decisions")) return "Decision Detection";
-  if (features.includes("session-awareness")) return "Session Awareness";
-  return "Pro Add-on";
+function cleanCommitMessage(message, maxLen = 60) {
+  if (!message) return "";
+  const match = message.match(/^(?:\w+)(?:\([^)]*\))?[!]?:\s*(.+)/);
+  const body = match ? match[1].trim() : message.trim();
+  if (!body) return "";
+  const capitalized = body.charAt(0).toUpperCase() + body.slice(1);
+  if (capitalized.length <= maxLen) return capitalized;
+  return capitalized.slice(0, maxLen - 3) + "...";
+}
+function buildDoing(checkpoint, branch, recentCommitMessages) {
+  if (checkpoint?.summary) return checkpoint.summary;
+  const branchFocus = inferFocusFromBranch2(branch ?? checkpoint?.gitBranch);
+  if (branchFocus) return branchFocus;
+  if (recentCommitMessages && recentCommitMessages.length > 0) {
+    const cleaned = cleanCommitMessage(recentCommitMessages[0]);
+    if (cleaned) return cleaned;
+  }
+  return "Unknown";
 }
-var _cachedStore;
-var _cacheTimestamp = 0;
-var LICENSE_CACHE_TTL_MS = 2e3;
-function readLicenseStore() {
-  const now = Date.now();
-  if (_cachedStore && now - _cacheTimestamp < LICENSE_CACHE_TTL_MS) {
-    return _cachedStore;
+function buildWhere(checkpoint, branch) {
+  const effectiveBranch = branch ?? checkpoint?.gitBranch;
+  const parts = [];
+  if (effectiveBranch) {
+    parts.push(effectiveBranch);
   }
-  const licensePath = getGlobalLicensePath();
-  let store;
-  try {
-    if (!fs3.existsSync(licensePath)) {
-      store = { version: 2, licenses: [] };
+  if (checkpoint?.touchedFiles && checkpoint.touchedFiles.length > 0) {
+    const fileNames = checkpoint.touchedFiles.slice(0, 2).map((f) => {
+      const segments = f.replace(/\\/g, "/").split("/");
+      return segments[segments.length - 1];
+    });
+    parts.push(fileNames.join(", "));
+  }
+  return parts.join(" \xB7 ") || "unknown";
+}
+function detectFocusArea(files) {
+  if (!files || files.length === 0) return void 0;
+  const areas = inferWorkAreas(files);
+  if (areas.length === 0) return void 0;
+  if (areas.length === 1) return areas[0];
+  const topArea = areas[0];
+  const areaCounts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parts = file.split("/").filter(Boolean);
+    let area;
+    if (parts.length <= 1) {
+      area = "root";
+    } else if (parts[0] === "apps" || parts[0] === "packages") {
+      area = parts.length > 1 ? parts[1] : parts[0];
+    } else if (parts[0] === "src") {
+      area = parts.length > 1 ? parts[1] : "src";
     } else {
-      const raw = fs3.readFileSync(licensePath, "utf-8");
-      const data = JSON.parse(raw);
-      if (data?.version === 2 && Array.isArray(data.licenses)) {
-        store = data;
-      } else {
-        store = { version: 2, licenses: [] };
-      }
+      area = parts[0];
     }
-  } catch {
-    store = { version: 2, licenses: [] };
+    areaCounts.set(area, (areaCounts.get(area) ?? 0) + 1);
   }
-  _cachedStore = store;
-  _cacheTimestamp = now;
-  return store;
-}
-function writeLicenseStore(store) {
-  const dirPath = getGlobalLicenseDir();
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
+  let topCount = 0;
+  for (const [areaKey, count] of areaCounts) {
+    if (topArea.toLowerCase().includes(areaKey.toLowerCase()) || areaKey.toLowerCase().includes(topArea.toLowerCase().split(" ")[0])) {
+      topCount = Math.max(topCount, count);
+    }
   }
-  const licensePath = path5.join(dirPath, LICENSE_FILE);
-  fs3.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
-  _cachedStore = store;
-  _cacheTimestamp = Date.now();
-}
-function addLicenseEntry(entry) {
-  const store = readLicenseStore();
-  const idx = store.licenses.findIndex((l) => l.licenseKey === entry.licenseKey);
-  if (idx >= 0) {
-    store.licenses[idx] = entry;
-  } else {
-    store.licenses.push(entry);
+  if (topCount === 0) {
+    topCount = Math.max(...areaCounts.values());
   }
-  writeLicenseStore(store);
-}
-function removeLicenseEntry(licenseKey) {
-  const store = readLicenseStore();
-  store.licenses = store.licenses.filter((l) => l.licenseKey !== licenseKey);
-  writeLicenseStore(store);
-}
-function getActiveLicenses() {
-  return readLicenseStore().licenses.filter((l) => l.status === "active");
+  const ratio = topCount / files.length;
+  if (ratio >= 0.6) return topArea;
+  return void 0;
 }
-function getLicenseForFeature(feature) {
-  const active = getActiveLicenses();
-  return active.find((l) => {
-    const features = VARIANT_FEATURE_MAP[l.variantId];
-    return features?.includes(feature);
+function generateContextSnapshot(projectRoot) {
+  const reader = new KeepGoingReader(projectRoot);
+  if (!reader.exists()) return null;
+  const lastSession = reader.getLastSession();
+  const state = reader.getState();
+  if (!lastSession && !state) return null;
+  const timestamp = state?.lastActivityAt ?? lastSession?.timestamp;
+  if (!timestamp) return null;
+  const branch = state?.lastKnownBranch ?? lastSession?.gitBranch;
+  let activeAgents = 0;
+  try {
+    const activeTasks = reader.getActiveTasks();
+    activeAgents = activeTasks.length;
+  } catch {
+  }
+  const doing = buildDoing(lastSession, branch);
+  const next = lastSession?.nextStep ?? "";
+  const where = buildWhere(lastSession, branch);
+  const when = formatCompactRelativeTime(new Date(timestamp));
+  const momentum = computeMomentum(timestamp, state?.activitySignals);
+  const blocker = lastSession?.blocker;
+  const snapshot = {
+    doing,
+    next,
+    where,
+    when,
+    momentum,
+    lastActivityAt: timestamp
+  };
+  if (blocker) snapshot.blocker = blocker;
+  if (activeAgents > 0) snapshot.activeAgents = activeAgents;
+  const focusArea = detectFocusArea(lastSession?.touchedFiles ?? []);
+  if (focusArea) snapshot.focusArea = focusArea;
+  return snapshot;
+}
+function formatCrossProjectLine(entry) {
+  const s = entry.snapshot;
+  const icon = s.momentum === "hot" ? "\u26A1" : s.momentum === "warm" ? "\u{1F536}" : "\u{1F4A4}";
+  const parts = [];
+  parts.push(`${icon} ${entry.name}: ${s.doing}`);
+  if (s.next) {
+    parts.push(`\u2192 ${s.next}`);
+  }
+  let line = parts.join(" ");
+  line += ` (${s.when})`;
+  if (s.blocker) {
+    line += ` \u26D4 ${s.blocker}`;
+  }
+  return line;
+}
+var MOMENTUM_RANK = { hot: 0, warm: 1, cold: 2 };
+function generateCrossProjectSummary() {
+  const registry = readKnownProjects();
+  const trayPaths = readTrayConfigProjects();
+  const seenPaths = new Set(registry.projects.map((p) => p.path));
+  const allEntries = [...registry.projects];
+  for (const tp of trayPaths) {
+    if (!seenPaths.has(tp)) {
+      seenPaths.add(tp);
+      allEntries.push({ path: tp, name: path7.basename(tp) });
+    }
+  }
+  const projects = [];
+  const seenRoots = /* @__PURE__ */ new Set();
+  for (const entry of allEntries) {
+    if (!fs5.existsSync(entry.path)) continue;
+    const snapshot = generateContextSnapshot(entry.path);
+    if (!snapshot) continue;
+    let resolvedRoot;
+    try {
+      resolvedRoot = fs5.realpathSync(entry.path);
+    } catch {
+      resolvedRoot = entry.path;
+    }
+    if (seenRoots.has(resolvedRoot)) continue;
+    seenRoots.add(resolvedRoot);
+    projects.push({
+      name: entry.name,
+      path: entry.path,
+      snapshot
+    });
+  }
+  projects.sort((a, b) => {
+    const rankA = MOMENTUM_RANK[a.snapshot.momentum ?? "cold"];
+    const rankB = MOMENTUM_RANK[b.snapshot.momentum ?? "cold"];
+    if (rankA !== rankB) return rankA - rankB;
+    const timeA = a.snapshot.lastActivityAt ? new Date(a.snapshot.lastActivityAt).getTime() : 0;
+    const timeB = b.snapshot.lastActivityAt ? new Date(b.snapshot.lastActivityAt).getTime() : 0;
+    return timeB - timeA;
   });
-}
-function getAllLicensesNeedingRevalidation() {
-  return getActiveLicenses().filter((l) => needsRevalidation(l));
-}
-var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-function needsRevalidation(entry) {
-  const lastValidated = new Date(entry.lastValidatedAt).getTime();
-  return Date.now() - lastValidated > REVALIDATION_THRESHOLD_MS;
+  return {
+    projects,
+    generated: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
 
+// ../../packages/shared/src/decisionStorage.ts
+import fs6 from "fs";
+import path8 from "path";
+
 // ../../packages/shared/src/featureGate.ts
 var DefaultFeatureGate = class {
   isEnabled(_feature) {
@@ -1235,31 +1783,31 @@ function isDecisionsEnabled() {
 }
 
 // ../../packages/shared/src/decisionStorage.ts
-var STORAGE_DIR2 = ".keepgoing";
-var DECISIONS_FILE = "decisions.json";
+var STORAGE_DIR3 = ".keepgoing";
+var DECISIONS_FILE2 = "decisions.json";
 var MAX_DECISIONS = 100;
 var DecisionStorage = class {
   storagePath;
   decisionsFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
-    this.storagePath = path6.join(mainRoot, STORAGE_DIR2);
-    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE);
+    this.storagePath = path8.join(mainRoot, STORAGE_DIR3);
+    this.decisionsFilePath = path8.join(this.storagePath, DECISIONS_FILE2);
   }
   ensureStorageDir() {
-    if (!fs4.existsSync(this.storagePath)) {
-      fs4.mkdirSync(this.storagePath, { recursive: true });
+    if (!fs6.existsSync(this.storagePath)) {
+      fs6.mkdirSync(this.storagePath, { recursive: true });
     }
   }
   getProjectName() {
-    return path6.basename(path6.dirname(this.storagePath));
+    return path8.basename(path8.dirname(this.storagePath));
   }
   load() {
     try {
-      if (!fs4.existsSync(this.decisionsFilePath)) {
+      if (!fs6.existsSync(this.decisionsFilePath)) {
         return createEmptyProjectDecisions(this.getProjectName());
       }
-      const raw = fs4.readFileSync(this.decisionsFilePath, "utf-8");
+      const raw = fs6.readFileSync(this.decisionsFilePath, "utf-8");
       const data = JSON.parse(raw);
       return data;
     } catch {
@@ -1269,7 +1817,7 @@ var DecisionStorage = class {
   save(decisions) {
     this.ensureStorageDir();
     const content = JSON.stringify(decisions, null, 2);
-    fs4.writeFileSync(this.decisionsFilePath, content, "utf-8");
+    fs6.writeFileSync(this.decisionsFilePath, content, "utf-8");
   }
   /**
    * Save a decision record as a draft. Always persists regardless of Pro
@@ -1442,369 +1990,87 @@ function classifyCommit(commit) {
   const matchedTypes = [];
   if (type && HIGH_SIGNAL_TYPES.has(type)) {
     matchedTypes.push(`type:${type}`);
-    confidence += 0.35;
-    reasons.push(`conventional commit type '${type}' is high-signal`);
-  }
-  if (scope && HIGH_SIGNAL_TYPES.has(scope)) {
-    matchedTypes.push(`scope:${scope}`);
-    confidence += 0.25;
-    reasons.push(`conventional commit scope '${scope}' is high-signal`);
-  }
-  if (parsed.breaking) {
-    confidence += 0.4;
-    reasons.push("breaking change indicated by ! marker");
-  }
-  const matchedPaths = [];
-  let bestTier = null;
-  for (const file of filesChanged) {
-    const pm = matchHighSignalPath(file);
-    if (pm && !matchedPaths.includes(pm.label)) {
-      matchedPaths.push(pm.label);
-      if (bestTier !== "infra") {
-        bestTier = pm.tier;
-      }
-    }
-  }
-  if (matchedPaths.length > 0) {
-    confidence += bestTier === "infra" ? 0.4 : 0.2;
-    reasons.push(`commit touched: ${matchedPaths.slice(0, 3).join(", ")}`);
-  }
-  if (filesChanged.length > 0 && filesChanged.every((f) => NEGATIVE_PATH_PATTERNS.some((p) => p.test(f)))) {
-    confidence -= 0.5;
-    reasons.push("all changed files are low-signal (lock files, generated code, dist)");
-  }
-  if (filesChanged.length > 0 && filesChanged.every((f) => /favicon/i.test(f) || /\.(svg|png|ico)$/i.test(f))) {
-    confidence -= 0.5;
-    reasons.push("all changed files are UI assets (favicon, SVG, PNG)");
-  }
-  if (filesChanged.length > 0 && filesChanged.every((f) => /\.css$/i.test(f)) && /tailwind/i.test(messageLower)) {
-    confidence -= 0.5;
-    reasons.push("Tailwind generated CSS change (low signal)");
-  }
-  const isDecisionCandidate = confidence >= 0.4;
-  const keywordLabels = matchedKeywords.map((kw) => kw.source.replace(/\\b/g, ""));
-  const category = isDecisionCandidate ? inferCategory(keywordLabels, matchedTypes, matchedPaths) : "unknown";
-  return {
-    isDecisionCandidate,
-    confidence: Math.max(0, Math.min(1, confidence)),
-    reasons,
-    category
-  };
-}
-function tryDetectDecision(opts) {
-  if (!isDecisionsEnabled()) {
-    return void 0;
-  }
-  const classification = classifyCommit({
-    message: opts.commitMessage,
-    filesChanged: opts.filesChanged
-  });
-  if (!classification.isDecisionCandidate) {
-    return void 0;
-  }
-  const decision = createDecisionRecord({
-    checkpointId: opts.checkpointId,
-    gitBranch: opts.gitBranch,
-    commitHash: opts.commitHash,
-    commitMessage: opts.commitMessage,
-    filesChanged: opts.filesChanged,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    classification
-  });
-  const storage = new DecisionStorage(opts.workspacePath);
-  storage.saveDecision(decision);
-  return {
-    category: classification.category,
-    confidence: classification.confidence
-  };
-}
-
-// ../../packages/shared/src/reader.ts
-import fs5 from "fs";
-import path7 from "path";
-var STORAGE_DIR3 = ".keepgoing";
-var META_FILE2 = "meta.json";
-var SESSIONS_FILE2 = "sessions.json";
-var DECISIONS_FILE2 = "decisions.json";
-var STATE_FILE2 = "state.json";
-var CURRENT_TASKS_FILE2 = "current-tasks.json";
-var KeepGoingReader = class {
-  workspacePath;
-  storagePath;
-  metaFilePath;
-  sessionsFilePath;
-  decisionsFilePath;
-  stateFilePath;
-  currentTasksFilePath;
-  _isWorktree;
-  _cachedBranch = null;
-  // null = not yet resolved
-  constructor(workspacePath) {
-    this.workspacePath = workspacePath;
-    const mainRoot = resolveStorageRoot(workspacePath);
-    this._isWorktree = mainRoot !== workspacePath;
-    this.storagePath = path7.join(mainRoot, STORAGE_DIR3);
-    this.metaFilePath = path7.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path7.join(this.storagePath, SESSIONS_FILE2);
-    this.decisionsFilePath = path7.join(this.storagePath, DECISIONS_FILE2);
-    this.stateFilePath = path7.join(this.storagePath, STATE_FILE2);
-    this.currentTasksFilePath = path7.join(this.storagePath, CURRENT_TASKS_FILE2);
-  }
-  /** Check if .keepgoing/ directory exists. */
-  exists() {
-    return fs5.existsSync(this.storagePath);
-  }
-  /** Read state.json, returns undefined if missing or corrupt. */
-  getState() {
-    return this.readJsonFile(this.stateFilePath);
-  }
-  /** Read meta.json, returns undefined if missing or corrupt. */
-  getMeta() {
-    return this.readJsonFile(this.metaFilePath);
-  }
-  /**
-   * Read sessions from sessions.json.
-   * Handles both formats:
-   * - Flat array: SessionCheckpoint[] (from ProjectStorage)
-   * - Wrapper object: ProjectSessions (from SessionStorage)
-   */
-  getSessions() {
-    return this.parseSessions().sessions;
-  }
-  /**
-   * Get the most recent session checkpoint.
-   * Uses state.lastSessionId if available, falls back to last in array.
-   */
-  getLastSession() {
-    const { sessions, wrapperLastSessionId } = this.parseSessions();
-    if (sessions.length === 0) {
-      return void 0;
-    }
-    const state = this.getState();
-    if (state?.lastSessionId) {
-      const found = sessions.find((s) => s.id === state.lastSessionId);
-      if (found) {
-        return found;
-      }
-    }
-    if (wrapperLastSessionId) {
-      const found = sessions.find((s) => s.id === wrapperLastSessionId);
-      if (found) {
-        return found;
-      }
-    }
-    return sessions[sessions.length - 1];
-  }
-  /**
-   * Returns the last N sessions, newest first.
-   */
-  getRecentSessions(count) {
-    return getRecentSessions(this.getSessions(), count);
-  }
-  /** Read all decisions from decisions.json. */
-  getDecisions() {
-    return this.parseDecisions().decisions;
-  }
-  /** Returns the last N decisions, newest first. */
-  getRecentDecisions(count) {
-    const all = this.getDecisions();
-    return all.slice(-count).reverse();
-  }
-  /** Read the multi-license store from `~/.keepgoing/license.json`. */
-  getLicenseStore() {
-    return readLicenseStore();
-  }
-  /**
-   * Read all current tasks from current-tasks.json.
-   * Automatically filters out stale finished sessions (> 2 hours).
-   */
-  getCurrentTasks() {
-    const multiRaw = this.readJsonFile(this.currentTasksFilePath);
-    if (multiRaw) {
-      const tasks = Array.isArray(multiRaw) ? multiRaw : multiRaw.tasks ?? [];
-      return this.pruneStale(tasks);
-    }
-    return [];
-  }
-  /** Get only active sessions (sessionActive=true and within stale threshold). */
-  getActiveTasks() {
-    return this.getCurrentTasks().filter((t) => t.sessionActive);
-  }
-  /** Get a specific session by ID. */
-  getTaskBySessionId(sessionId) {
-    return this.getCurrentTasks().find((t) => t.sessionId === sessionId);
-  }
-  /**
-   * Detect files being edited by multiple sessions simultaneously.
-   * Returns pairs of session IDs and the conflicting file paths.
-   */
-  detectFileConflicts() {
-    const activeTasks = this.getActiveTasks();
-    if (activeTasks.length < 2) return [];
-    const fileToSessions = /* @__PURE__ */ new Map();
-    for (const task of activeTasks) {
-      if (task.lastFileEdited && task.sessionId) {
-        const existing = fileToSessions.get(task.lastFileEdited) ?? [];
-        existing.push({
-          sessionId: task.sessionId,
-          agentLabel: task.agentLabel,
-          branch: task.branch
-        });
-        fileToSessions.set(task.lastFileEdited, existing);
-      }
-    }
-    const conflicts = [];
-    for (const [file, sessions] of fileToSessions) {
-      if (sessions.length > 1) {
-        conflicts.push({ file, sessions });
-      }
-    }
-    return conflicts;
-  }
-  /**
-   * Detect sessions on the same branch (possible duplicate work).
-   */
-  detectBranchOverlap() {
-    const activeTasks = this.getActiveTasks();
-    if (activeTasks.length < 2) return [];
-    const branchToSessions = /* @__PURE__ */ new Map();
-    for (const task of activeTasks) {
-      if (task.branch && task.sessionId) {
-        const existing = branchToSessions.get(task.branch) ?? [];
-        existing.push({ sessionId: task.sessionId, agentLabel: task.agentLabel });
-        branchToSessions.set(task.branch, existing);
-      }
-    }
-    const overlaps = [];
-    for (const [branch, sessions] of branchToSessions) {
-      if (sessions.length > 1) {
-        overlaps.push({ branch, sessions });
-      }
-    }
-    return overlaps;
-  }
-  pruneStale(tasks) {
-    return pruneStaleTasks(tasks);
-  }
-  /** Get the last session checkpoint for a specific branch. */
-  getLastSessionForBranch(branch) {
-    const sessions = this.getSessions().filter((s) => s.gitBranch === branch);
-    return sessions.length > 0 ? sessions[sessions.length - 1] : void 0;
-  }
-  /** Returns the last N sessions for a specific branch, newest first. */
-  getRecentSessionsForBranch(branch, count) {
-    const filtered = this.getSessions().filter((s) => s.gitBranch === branch);
-    return filtered.slice(-count).reverse();
-  }
-  /** Returns the last N decisions for a specific branch, newest first. */
-  getRecentDecisionsForBranch(branch, count) {
-    const filtered = this.getDecisions().filter((d) => d.gitBranch === branch);
-    return filtered.slice(-count).reverse();
-  }
-  /** Whether the workspace is inside a git worktree. */
-  get isWorktree() {
-    return this._isWorktree;
-  }
-  /**
-   * Returns the current git branch for this workspace.
-   * Lazily cached: the branch is resolved once per KeepGoingReader instance.
-   */
-  getCurrentBranch() {
-    if (this._cachedBranch === null) {
-      this._cachedBranch = getCurrentBranch(this.workspacePath);
-    }
-    return this._cachedBranch;
+    confidence += 0.35;
+    reasons.push(`conventional commit type '${type}' is high-signal`);
   }
-  /**
-   * Worktree-aware last session lookup.
-   * In a worktree, scopes to the current branch with fallback to global.
-   * Returns the session and whether it fell back to global.
-   */
-  getScopedLastSession() {
-    const branch = this.getCurrentBranch();
-    if (this._isWorktree && branch) {
-      const scoped = this.getLastSessionForBranch(branch);
-      if (scoped) return { session: scoped, isFallback: false };
-      return { session: this.getLastSession(), isFallback: true };
-    }
-    return { session: this.getLastSession(), isFallback: false };
+  if (scope && HIGH_SIGNAL_TYPES.has(scope)) {
+    matchedTypes.push(`scope:${scope}`);
+    confidence += 0.25;
+    reasons.push(`conventional commit scope '${scope}' is high-signal`);
   }
-  /** Worktree-aware recent sessions. Scopes to current branch in a worktree. */
-  getScopedRecentSessions(count) {
-    const branch = this.getCurrentBranch();
-    if (this._isWorktree && branch) {
-      return this.getRecentSessionsForBranch(branch, count);
-    }
-    return this.getRecentSessions(count);
+  if (parsed.breaking) {
+    confidence += 0.4;
+    reasons.push("breaking change indicated by ! marker");
   }
-  /** Worktree-aware recent decisions. Scopes to current branch in a worktree. */
-  getScopedRecentDecisions(count) {
-    const branch = this.getCurrentBranch();
-    if (this._isWorktree && branch) {
-      return this.getRecentDecisionsForBranch(branch, count);
+  const matchedPaths = [];
+  let bestTier = null;
+  for (const file of filesChanged) {
+    const pm = matchHighSignalPath(file);
+    if (pm && !matchedPaths.includes(pm.label)) {
+      matchedPaths.push(pm.label);
+      if (bestTier !== "infra") {
+        bestTier = pm.tier;
+      }
     }
-    return this.getRecentDecisions(count);
   }
-  /**
-   * Resolves branch scope from an explicit `branch` parameter.
-   * Used by tools that accept a `branch` argument (e.g. get_session_history, get_decisions).
-   * - `"all"` returns no filter.
-   * - An explicit branch name uses that.
-   * - `undefined` auto-scopes to the current branch in a worktree, or all branches otherwise.
-   */
-  resolveBranchScope(branch) {
-    if (branch === "all") {
-      return { effectiveBranch: void 0, scopeLabel: "all branches" };
-    }
-    if (branch) {
-      return { effectiveBranch: branch, scopeLabel: `branch \`${branch}\`` };
-    }
-    const currentBranch = this.getCurrentBranch();
-    if (this._isWorktree && currentBranch) {
-      return { effectiveBranch: currentBranch, scopeLabel: `branch \`${currentBranch}\` (worktree)` };
-    }
-    return { effectiveBranch: void 0, scopeLabel: "all branches" };
+  if (matchedPaths.length > 0) {
+    confidence += bestTier === "infra" ? 0.4 : 0.2;
+    reasons.push(`commit touched: ${matchedPaths.slice(0, 3).join(", ")}`);
   }
-  /**
-   * Parses sessions.json once, returning both the session list
-   * and the optional lastSessionId from a ProjectSessions wrapper.
-   */
-  parseSessions() {
-    const raw = this.readJsonFile(
-      this.sessionsFilePath
-    );
-    if (!raw) {
-      return { sessions: [] };
-    }
-    if (Array.isArray(raw)) {
-      return { sessions: raw };
-    }
-    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+  if (filesChanged.length > 0 && filesChanged.every((f) => NEGATIVE_PATH_PATTERNS.some((p) => p.test(f)))) {
+    confidence -= 0.5;
+    reasons.push("all changed files are low-signal (lock files, generated code, dist)");
   }
-  parseDecisions() {
-    const raw = this.readJsonFile(this.decisionsFilePath);
-    if (!raw) {
-      return { decisions: [] };
-    }
-    return { decisions: raw.decisions ?? [], lastDecisionId: raw.lastDecisionId };
+  if (filesChanged.length > 0 && filesChanged.every((f) => /favicon/i.test(f) || /\.(svg|png|ico)$/i.test(f))) {
+    confidence -= 0.5;
+    reasons.push("all changed files are UI assets (favicon, SVG, PNG)");
   }
-  readJsonFile(filePath) {
-    try {
-      if (!fs5.existsSync(filePath)) {
-        return void 0;
-      }
-      const raw = fs5.readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
+  if (filesChanged.length > 0 && filesChanged.every((f) => /\.css$/i.test(f)) && /tailwind/i.test(messageLower)) {
+    confidence -= 0.5;
+    reasons.push("Tailwind generated CSS change (low signal)");
   }
-};
+  const isDecisionCandidate = confidence >= 0.4;
+  const keywordLabels = matchedKeywords.map((kw) => kw.source.replace(/\\b/g, ""));
+  const category = isDecisionCandidate ? inferCategory(keywordLabels, matchedTypes, matchedPaths) : "unknown";
+  return {
+    isDecisionCandidate,
+    confidence: Math.max(0, Math.min(1, confidence)),
+    reasons,
+    category
+  };
+}
+function tryDetectDecision(opts) {
+  if (!isDecisionsEnabled()) {
+    return void 0;
+  }
+  const classification = classifyCommit({
+    message: opts.commitMessage,
+    filesChanged: opts.filesChanged
+  });
+  if (!classification.isDecisionCandidate) {
+    return void 0;
+  }
+  const decision = createDecisionRecord({
+    checkpointId: opts.checkpointId,
+    gitBranch: opts.gitBranch,
+    commitHash: opts.commitHash,
+    commitMessage: opts.commitMessage,
+    filesChanged: opts.filesChanged,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    classification
+  });
+  const storage = new DecisionStorage(opts.workspacePath);
+  storage.saveDecision(decision);
+  return {
+    category: classification.category,
+    confidence: classification.confidence
+  };
+}
 
 // ../../packages/shared/src/setup.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import os3 from "os";
-import path8 from "path";
+import path9 from "path";
 var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
 var SESSION_START_HOOK = {
   matcher: "",
@@ -1842,12 +2108,14 @@ var SESSION_END_HOOK = {
     }
   ]
 };
-var KEEPGOING_RULES_VERSION = 1;
+var KEEPGOING_RULES_VERSION = 2;
 var KEEPGOING_RULES_CONTENT = `<!-- @keepgoingdev/mcp-server v${KEEPGOING_RULES_VERSION} -->
 ## KeepGoing
 
+When you see KeepGoing momentum data in your session context (from a SessionStart hook), share a brief welcome with the user that includes: what was last worked on, the suggested next step, and any blockers.
+
 After completing a task or meaningful piece of work, call the \`save_checkpoint\` MCP tool with:
-- \`summary\`: 1-2 sentences. What changed and why \u2014 no file paths, no implementation details (those are captured from git).
+- \`summary\`: 1-2 sentences. What changed and why, no file paths, no implementation details (those are captured from git).
 - \`nextStep\`: What to do next
 - \`blocker\`: Any blocker (if applicable)
 `;
@@ -1857,7 +2125,7 @@ function getRulesFileVersion(content) {
 }
 var STATUSLINE_CMD = "npx -y @keepgoingdev/mcp-server --statusline";
 function detectClaudeDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path8.join(os3.homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || path9.join(os3.homedir(), ".claude");
 }
 function hasKeepGoingHook(hookEntries) {
   return hookEntries.some(
@@ -1869,19 +2137,19 @@ function resolveScopePaths(scope, workspacePath, overrideClaudeDir) {
     const claudeDir2 = overrideClaudeDir || detectClaudeDir();
     return {
       claudeDir: claudeDir2,
-      settingsPath: path8.join(claudeDir2, "settings.json"),
-      claudeMdPath: path8.join(claudeDir2, "CLAUDE.md"),
-      rulesPath: path8.join(claudeDir2, "rules", "keepgoing.md")
+      settingsPath: path9.join(claudeDir2, "settings.json"),
+      claudeMdPath: path9.join(claudeDir2, "CLAUDE.md"),
+      rulesPath: path9.join(claudeDir2, "rules", "keepgoing.md")
     };
   }
-  const claudeDir = path8.join(workspacePath, ".claude");
-  const dotClaudeMdPath = path8.join(workspacePath, ".claude", "CLAUDE.md");
-  const rootClaudeMdPath = path8.join(workspacePath, "CLAUDE.md");
+  const claudeDir = path9.join(workspacePath, ".claude");
+  const dotClaudeMdPath = path9.join(workspacePath, ".claude", "CLAUDE.md");
+  const rootClaudeMdPath = path9.join(workspacePath, "CLAUDE.md");
   return {
     claudeDir,
-    settingsPath: path8.join(claudeDir, "settings.json"),
-    claudeMdPath: fs6.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath,
-    rulesPath: path8.join(workspacePath, ".claude", "rules", "keepgoing.md")
+    settingsPath: path9.join(claudeDir, "settings.json"),
+    claudeMdPath: fs7.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath,
+    rulesPath: path9.join(workspacePath, ".claude", "rules", "keepgoing.md")
   };
 }
 function writeHooksToSettings(settings) {
@@ -1921,11 +2189,11 @@ function writeHooksToSettings(settings) {
 }
 function checkHookConflict(scope, workspacePath) {
   const otherPaths = resolveScopePaths(scope === "user" ? "project" : "user", workspacePath);
-  if (!fs6.existsSync(otherPaths.settingsPath)) {
+  if (!fs7.existsSync(otherPaths.settingsPath)) {
     return null;
   }
   try {
-    const otherSettings = JSON.parse(fs6.readFileSync(otherPaths.settingsPath, "utf-8"));
+    const otherSettings = JSON.parse(fs7.readFileSync(otherPaths.settingsPath, "utf-8"));
     const hooks = otherSettings?.hooks;
     if (!hooks) return null;
     const hasConflict = Array.isArray(hooks.SessionStart) && hasKeepGoingHook(hooks.SessionStart) || Array.isArray(hooks.Stop) && hasKeepGoingHook(hooks.Stop);
@@ -1954,10 +2222,10 @@ function setupProject(options) {
     workspacePath,
     claudeDirOverride
   );
-  const scopeLabel = scope === "user" ? path8.join("~", path8.relative(os3.homedir(), claudeDir), "settings.json").replace(/\\/g, "/") : ".claude/settings.json";
+  const scopeLabel = scope === "user" ? path9.join("~", path9.relative(os3.homedir(), claudeDir), "settings.json").replace(/\\/g, "/") : ".claude/settings.json";
   let settings = {};
-  if (fs6.existsSync(settingsPath)) {
-    settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+  if (fs7.existsSync(settingsPath)) {
+    settings = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
   }
   let settingsChanged = false;
   if (sessionHooks) {
@@ -1973,7 +2241,7 @@ function setupProject(options) {
       messages.push(`Warning: ${conflict}`);
     }
   }
-  if (scope === "project") {
+  {
     const needsUpdate = settings.statusLine?.command && statusline?.isLegacy?.(settings.statusLine.command);
     if (!settings.statusLine || needsUpdate) {
       settings.statusLine = {
@@ -1981,43 +2249,43 @@ function setupProject(options) {
         command: STATUSLINE_CMD
       };
       settingsChanged = true;
-      messages.push(needsUpdate ? "Statusline: Migrated to auto-updating npx command" : "Statusline: Added to .claude/settings.json");
+      messages.push(needsUpdate ? "Statusline: Migrated to auto-updating npx command" : `Statusline: Added to ${scopeLabel}`);
     } else {
       messages.push("Statusline: Already configured in settings, skipped");
     }
     statusline?.cleanup?.();
   }
   if (settingsChanged) {
-    if (!fs6.existsSync(claudeDir)) {
-      fs6.mkdirSync(claudeDir, { recursive: true });
+    if (!fs7.existsSync(claudeDir)) {
+      fs7.mkdirSync(claudeDir, { recursive: true });
     }
-    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     changed = true;
   }
   if (claudeMd) {
-    const rulesDir = path8.dirname(rulesPath);
-    const rulesLabel = scope === "user" ? path8.join(path8.relative(os3.homedir(), path8.dirname(rulesPath)), "keepgoing.md").replace(/\\/g, "/") : ".claude/rules/keepgoing.md";
-    if (fs6.existsSync(rulesPath)) {
-      const existing = fs6.readFileSync(rulesPath, "utf-8");
+    const rulesDir = path9.dirname(rulesPath);
+    const rulesLabel = scope === "user" ? path9.join(path9.relative(os3.homedir(), path9.dirname(rulesPath)), "keepgoing.md").replace(/\\/g, "/") : ".claude/rules/keepgoing.md";
+    if (fs7.existsSync(rulesPath)) {
+      const existing = fs7.readFileSync(rulesPath, "utf-8");
       const existingVersion = getRulesFileVersion(existing);
       if (existingVersion === null) {
         messages.push(`Rules file: Custom file found at ${rulesLabel}, skipping`);
       } else if (existingVersion >= KEEPGOING_RULES_VERSION) {
         messages.push(`Rules file: Already up to date (v${existingVersion}), skipped`);
       } else {
-        if (!fs6.existsSync(rulesDir)) {
-          fs6.mkdirSync(rulesDir, { recursive: true });
+        if (!fs7.existsSync(rulesDir)) {
+          fs7.mkdirSync(rulesDir, { recursive: true });
         }
-        fs6.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
+        fs7.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
         changed = true;
         messages.push(`Rules file: Updated v${existingVersion} \u2192 v${KEEPGOING_RULES_VERSION} at ${rulesLabel}`);
       }
     } else {
-      const existingClaudeMd = fs6.existsSync(claudeMdPath) ? fs6.readFileSync(claudeMdPath, "utf-8") : "";
-      if (!fs6.existsSync(rulesDir)) {
-        fs6.mkdirSync(rulesDir, { recursive: true });
+      const existingClaudeMd = fs7.existsSync(claudeMdPath) ? fs7.readFileSync(claudeMdPath, "utf-8") : "";
+      if (!fs7.existsSync(rulesDir)) {
+        fs7.mkdirSync(rulesDir, { recursive: true });
       }
-      fs6.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
+      fs7.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
       changed = true;
       if (existingClaudeMd.includes("## KeepGoing")) {
         const mdLabel = scope === "user" ? "~/.claude/CLAUDE.md" : "CLAUDE.md";
@@ -2453,7 +2721,7 @@ function registerGetReentryBriefing(server, reader, workspacePath) {
 }
 
 // src/tools/saveCheckpoint.ts
-import path9 from "path";
+import path10 from "path";
 import { z as z4 } from "zod";
 function registerSaveCheckpoint(server, reader, workspacePath) {
   server.tool(
@@ -2465,11 +2733,14 @@ function registerSaveCheckpoint(server, reader, workspacePath) {
       blocker: z4.string().optional().describe("Any blocker preventing progress")
     },
     async ({ summary, nextStep, blocker }) => {
+      summary = stripAgentTags(summary);
+      nextStep = nextStep ? stripAgentTags(nextStep) : nextStep;
+      blocker = blocker ? stripAgentTags(blocker) : blocker;
       const lastSession = reader.getLastSession();
       const gitBranch = getCurrentBranch(workspacePath);
       const touchedFiles = getTouchedFiles(workspacePath);
       const commitHashes = getCommitsSince(workspacePath, lastSession?.timestamp);
-      const projectName = path9.basename(resolveStorageRoot(workspacePath));
+      const projectName = path10.basename(resolveStorageRoot(workspacePath));
       const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
       const checkpoint = createCheckpoint({
         summary,
@@ -2687,25 +2958,25 @@ function registerGetCurrentTask(server, reader) {
 import { z as z6 } from "zod";
 
 // src/cli/migrate.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os4 from "os";
-import path10 from "path";
+import path11 from "path";
 var STATUSLINE_CMD2 = "npx -y @keepgoingdev/mcp-server --statusline";
 function isLegacyStatusline(command) {
   return !command.includes("--statusline") && command.includes("keepgoing-statusline");
 }
 function migrateStatusline(wsPath) {
-  const settingsPath = path10.join(wsPath, ".claude", "settings.json");
-  if (!fs7.existsSync(settingsPath)) return void 0;
+  const settingsPath = path11.join(wsPath, ".claude", "settings.json");
+  if (!fs8.existsSync(settingsPath)) return void 0;
   try {
-    const settings = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
     const cmd = settings.statusLine?.command;
     if (!cmd || !isLegacyStatusline(cmd)) return void 0;
     settings.statusLine = {
       type: "command",
       command: STATUSLINE_CMD2
     };
-    fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs8.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     cleanupLegacyScript();
     return "[KeepGoing] Migrated statusline to auto-updating command (restart Claude Code to apply)";
   } catch {
@@ -2713,10 +2984,10 @@ function migrateStatusline(wsPath) {
   }
 }
 function cleanupLegacyScript() {
-  const legacyScript = path10.join(os4.homedir(), ".claude", "keepgoing-statusline.sh");
-  if (fs7.existsSync(legacyScript)) {
+  const legacyScript = path11.join(os4.homedir(), ".claude", "keepgoing-statusline.sh");
+  if (fs8.existsSync(legacyScript)) {
     try {
-      fs7.unlinkSync(legacyScript);
+      fs8.unlinkSync(legacyScript);
     } catch {
     }
   }
@@ -2949,6 +3220,87 @@ function registerContinueOn(server, reader, workspacePath) {
   );
 }
 
+// src/tools/getContextSnapshot.ts
+import { z as z10 } from "zod";
+function registerGetContextSnapshot(server, reader, workspacePath) {
+  server.tool(
+    "get_context_snapshot",
+    "Get a compact context snapshot: what you were doing, what is next, and momentum. Use this for quick orientation without a full briefing.",
+    {
+      format: z10.enum(["text", "json"]).optional().describe('Output format. "text" (default) returns a formatted single line. "json" returns the structured snapshot object.')
+    },
+    async ({ format }) => {
+      const snapshot = generateContextSnapshot(workspacePath);
+      if (!snapshot) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found. The developer has not saved any checkpoints yet."
+            }
+          ]
+        };
+      }
+      if (format === "json") {
+        return {
+          content: [{ type: "text", text: JSON.stringify(snapshot, null, 2) }]
+        };
+      }
+      const icon = snapshot.momentum === "hot" ? "\u26A1" : snapshot.momentum === "warm" ? "\u{1F536}" : "\u{1F4A4}";
+      const parts = [];
+      parts.push(`${icon} ${snapshot.doing}`);
+      if (snapshot.next) {
+        parts.push(`\u2192 ${snapshot.next}`);
+      }
+      let line = parts.join(" ");
+      line += ` (${snapshot.when})`;
+      if (snapshot.blocker) {
+        line += ` \u26D4 ${snapshot.blocker}`;
+      }
+      if (snapshot.activeAgents && snapshot.activeAgents > 0) {
+        line += ` [${snapshot.activeAgents} active agent${snapshot.activeAgents > 1 ? "s" : ""}]`;
+      }
+      return {
+        content: [{ type: "text", text: line }]
+      };
+    }
+  );
+}
+
+// src/tools/getWhatsHot.ts
+import { z as z11 } from "zod";
+function registerGetWhatsHot(server) {
+  server.tool(
+    "get_whats_hot",
+    "Get a summary of activity across all registered projects, sorted by momentum. Shows what the developer is working on across their entire portfolio.",
+    {
+      format: z11.enum(["text", "json"]).optional().describe('Output format. "text" (default) returns formatted lines. "json" returns the structured summary object.')
+    },
+    async ({ format }) => {
+      const summary = generateCrossProjectSummary();
+      if (summary.projects.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No projects with activity found. Projects are registered automatically when checkpoints are saved."
+            }
+          ]
+        };
+      }
+      if (format === "json") {
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+        };
+      }
+      const lines = summary.projects.map((entry) => formatCrossProjectLine(entry));
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
 // src/prompts/resume.ts
 function registerResumePrompt(server) {
   server.prompt(
@@ -3114,7 +3466,7 @@ async function handlePrintCurrent() {
 }
 
 // src/cli/saveCheckpoint.ts
-import path11 from "path";
+import path12 from "path";
 async function handleSaveCheckpoint() {
   const wsPath = resolveWsPath();
   const reader = new KeepGoingReader(wsPath);
@@ -3142,9 +3494,9 @@ async function handleSaveCheckpoint() {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path11.basename(f)).join(", ")}`;
+  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path12.basename(f)).join(", ")}`;
   const nextStep = buildSmartNextStep(events);
-  const projectName = path11.basename(resolveStorageRoot(wsPath));
+  const projectName = path12.basename(resolveStorageRoot(wsPath));
   const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
   const checkpoint = createCheckpoint({
     summary,
@@ -3189,8 +3541,9 @@ async function handleSaveCheckpoint() {
 }
 
 // src/cli/transcriptUtils.ts
-import fs8 from "fs";
-var TAIL_READ_BYTES = 8192;
+import fs9 from "fs";
+var TAIL_READ_BYTES = 32768;
+var LATEST_LABEL_READ_BYTES = 65536;
 var TOOL_VERB_MAP = {
   Edit: "editing",
   MultiEdit: "editing",
@@ -3202,7 +3555,12 @@ var TOOL_VERB_MAP = {
   Agent: "delegating",
   WebFetch: "browsing",
   WebSearch: "browsing",
-  TodoWrite: "planning"
+  TodoWrite: "planning",
+  AskUserQuestion: "discussing",
+  EnterPlanMode: "planning",
+  ExitPlanMode: "planning",
+  TaskCreate: "planning",
+  TaskUpdate: "planning"
 };
 function truncateAtWord(text, max) {
   if (text.length <= max) return text;
@@ -3240,9 +3598,9 @@ function isAssistantEntry(entry) {
   return entry.message?.role === "assistant";
 }
 function extractSessionLabel(transcriptPath) {
-  if (!transcriptPath || !fs8.existsSync(transcriptPath)) return null;
+  if (!transcriptPath || !fs9.existsSync(transcriptPath)) return null;
   try {
-    const raw = fs8.readFileSync(transcriptPath, "utf-8");
+    const raw = fs9.readFileSync(transcriptPath, "utf-8");
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -3255,7 +3613,55 @@ function extractSessionLabel(transcriptPath) {
       if (!isUserEntry(entry)) continue;
       let text = extractTextFromContent(entry.message?.content);
       if (!text) continue;
-      if (text.startsWith("[") || /^<[a-z][\w-]*>/.test(text)) continue;
+      if (text.startsWith("[") || /^<[a-z][\w-]*[\s>]/.test(text)) continue;
+      text = stripAgentTags(text);
+      if (!text) continue;
+      text = text.replace(/@[\w./\-]+/g, "").trim();
+      text = text.replace(FILLER_PREFIX_RE, "").trim();
+      text = text.replace(MARKDOWN_HEADING_RE, "").trim();
+      text = text.replace(/\s+/g, " ").trim();
+      if (text.length < 20) continue;
+      if (text.length > 80) {
+        text = text.slice(0, 80);
+      }
+      return text;
+    }
+  } catch {
+  }
+  return null;
+}
+function extractLatestUserLabel(transcriptPath) {
+  if (!transcriptPath || !fs9.existsSync(transcriptPath)) return null;
+  try {
+    const stat = fs9.statSync(transcriptPath);
+    const fileSize = stat.size;
+    if (fileSize === 0) return null;
+    const readSize = Math.min(fileSize, LATEST_LABEL_READ_BYTES);
+    const offset = fileSize - readSize;
+    const buf = Buffer.alloc(readSize);
+    const fd = fs9.openSync(transcriptPath, "r");
+    try {
+      fs9.readSync(fd, buf, 0, readSize, offset);
+    } finally {
+      fs9.closeSync(fd);
+    }
+    const tail = buf.toString("utf-8");
+    const lines = tail.split("\n").reverse();
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isUserEntry(entry)) continue;
+      let text = extractTextFromContent(entry.message?.content);
+      if (!text) continue;
+      if (text.startsWith("[") || /^<[a-z][\w-]*[\s>]/.test(text)) continue;
+      text = stripAgentTags(text);
+      if (!text) continue;
       text = text.replace(/@[\w./\-]+/g, "").trim();
       text = text.replace(FILLER_PREFIX_RE, "").trim();
       text = text.replace(MARKDOWN_HEADING_RE, "").trim();
@@ -3271,19 +3677,19 @@ function extractSessionLabel(transcriptPath) {
   return null;
 }
 function extractCurrentAction(transcriptPath) {
-  if (!transcriptPath || !fs8.existsSync(transcriptPath)) return null;
+  if (!transcriptPath || !fs9.existsSync(transcriptPath)) return null;
   try {
-    const stat = fs8.statSync(transcriptPath);
+    const stat = fs9.statSync(transcriptPath);
     const fileSize = stat.size;
     if (fileSize === 0) return null;
     const readSize = Math.min(fileSize, TAIL_READ_BYTES);
     const offset = fileSize - readSize;
     const buf = Buffer.alloc(readSize);
-    const fd = fs8.openSync(transcriptPath, "r");
+    const fd = fs9.openSync(transcriptPath, "r");
     try {
-      fs8.readSync(fd, buf, 0, readSize, offset);
+      fs9.readSync(fd, buf, 0, readSize, offset);
     } finally {
-      fs8.closeSync(fd);
+      fs9.closeSync(fd);
     }
     const tail = buf.toString("utf-8");
     const lines = tail.split("\n").reverse();
@@ -3318,6 +3724,8 @@ async function handleUpdateTask() {
   if (payloadStr) {
     try {
       const payload = JSON.parse(payloadStr);
+      if (payload.taskSummary) payload.taskSummary = stripAgentTags(payload.taskSummary);
+      if (payload.sessionLabel) payload.sessionLabel = stripAgentTags(payload.sessionLabel);
       const writer = new KeepGoingWriter(wsPath);
       const branch = payload.branch ?? getCurrentBranch(wsPath) ?? void 0;
       const task = {
@@ -3385,8 +3793,8 @@ async function handleUpdateTaskFromHook() {
 }
 
 // src/cli/statusline.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 var STDIN_TIMEOUT_MS2 = 3e3;
 async function handleStatusline() {
   const chunks = [];
@@ -3410,12 +3818,15 @@ async function handleStatusline() {
       if (input.agent?.name) {
         label = input.agent.name;
       }
+      if (!label && transcriptPath) {
+        label = extractLatestUserLabel(transcriptPath);
+      }
       if (!label) {
         try {
           const gitRoot = findGitRoot(dir);
-          const tasksFile = path12.join(gitRoot, ".keepgoing", "current-tasks.json");
-          if (fs9.existsSync(tasksFile)) {
-            const data = JSON.parse(fs9.readFileSync(tasksFile, "utf-8"));
+          const tasksFile = path13.join(gitRoot, ".keepgoing", "current-tasks.json");
+          if (fs10.existsSync(tasksFile)) {
+            const data = JSON.parse(fs10.readFileSync(tasksFile, "utf-8"));
             const tasks = pruneStaleTasks(data.tasks ?? []);
             const match = sessionId ? tasks.find((t) => t.sessionId === sessionId) : void 0;
             if (match?.sessionLabel) {
@@ -3428,7 +3839,28 @@ async function handleStatusline() {
       if (!label && transcriptPath) {
         label = extractSessionLabel(transcriptPath);
       }
-      if (!label) process.exit(0);
+      if (!label) {
+        try {
+          const gitRoot = findGitRoot(dir);
+          const reader = new KeepGoingReader(gitRoot);
+          if (reader.exists()) {
+            const recent = reader.getScopedRecentSessions(10);
+            const last = recent.find((s) => s.source !== "auto") ?? recent[0];
+            if (last) {
+              const ago = formatRelativeTime(last.timestamp);
+              const summary = last.summary ? truncateAtWord(last.summary, 40) : null;
+              const next = last.nextStep ? truncateAtWord(last.nextStep, 30) : null;
+              const parts = [`[KG] ${ago}`];
+              if (summary) parts.push(summary);
+              if (next) parts.push(`\u2192 ${next}`);
+              process.stdout.write(`${parts.join(" \xB7 ")}
+`);
+            }
+          }
+        } catch {
+        }
+        process.exit(0);
+      }
       const action = transcriptPath ? extractCurrentAction(transcriptPath) : null;
       const budget = action ? 40 : 55;
       const displayLabel = truncateAtWord(label, budget);
@@ -3519,6 +3951,8 @@ if (flag) {
   registerGetCurrentTask(server, reader);
   registerSaveCheckpoint(server, reader, workspacePath);
   registerContinueOn(server, reader, workspacePath);
+  registerGetContextSnapshot(server, reader, workspacePath);
+  registerGetWhatsHot(server);
   registerSetupProject(server, workspacePath);
   registerActivateLicense(server);
   registerDeactivateLicense(server);