@keepgoingdev/mcp-server 0.7.2 → 0.9.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) {
@@ -326,7 +339,8 @@ function generateEnrichedBriefing(opts) {
       timestamp: s.timestamp,
       summary: s.summary || "",
       nextStep: s.nextStep || "",
-      branch: s.gitBranch
+      branch: s.gitBranch,
+      sessionPhase: s.sessionPhase
     }));
   }
   if (opts.recentCommits && opts.recentCommits.length > 0) {
@@ -359,10 +373,13 @@ function buildCurrentFocus(lastSession, projectState, gitBranch) {
 function buildRecentActivity(lastSession, recentSessions, recentCommitMessages) {
   const parts = [];
   const sessionCount = recentSessions.length;
+  const planCount = recentSessions.filter((s) => s.sessionPhase === "planning").length;
   if (sessionCount > 1) {
-    parts.push(`${sessionCount} recent sessions`);
+    const planSuffix = planCount > 0 ? ` (${planCount} plan-only)` : "";
+    parts.push(`${sessionCount} recent sessions${planSuffix}`);
   } else if (sessionCount === 1) {
-    parts.push("1 recent session");
+    const planSuffix = planCount === 1 ? " (plan-only)" : "";
+    parts.push(`1 recent session${planSuffix}`);
   }
   if (lastSession.summary) {
     const brief = lastSession.summary.length > 120 ? lastSession.summary.slice(0, 117) + "..." : lastSession.summary;
@@ -561,7 +578,8 @@ function formatEnrichedBriefing(briefing) {
     for (const s of briefing.sessionHistory) {
       const relTime = formatRelativeTime(s.timestamp);
       const branch = s.branch ? ` (${s.branch})` : "";
-      lines.push(`- **${relTime}${branch}:** ${s.summary || "No summary"}. Next: ${s.nextStep || "Not specified"}`);
+      const planTag = s.sessionPhase === "planning" ? " (plan)" : "";
+      lines.push(`- **${relTime}${branch}${planTag}:** ${s.summary || "No summary"}. Next: ${s.nextStep || "Not specified"}`);
     }
   }
   if (briefing.recentCommits && briefing.recentCommits.length > 0) {
@@ -706,22 +724,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;
       }
@@ -731,18 +887,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;
@@ -781,23 +937,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 {
@@ -815,13 +971,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);
@@ -829,8 +985,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 = {
@@ -846,7 +1002,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
@@ -854,8 +1031,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);
       }
@@ -876,6 +1053,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);
@@ -910,8 +1089,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 {
@@ -923,7 +1102,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) {
@@ -939,57 +1118,337 @@ 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) {
-    if (NOISE_PATTERNS.some((p) => file.includes(p))) {
-      continue;
-    }
+  /**
+   * 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;
+    }
     const parts = file.split("/").filter(Boolean);
     let area;
     if (parts.length >= 2 && (parts[0] === "apps" || parts[0] === "packages")) {
@@ -1101,131 +1560,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) {
@@ -1238,31 +1788,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 {
@@ -1272,7 +1822,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
@@ -1448,366 +1998,84 @@ function classifyCommit(commit) {
     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;
-  }
-  /**
-   * 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);
+  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 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);
+  if (parsed.breaking) {
+    confidence += 0.4;
+    reasons.push("breaking change indicated by ! marker");
   }
-  /**
-   * 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)` };
+  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 { 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 };
+  if (matchedPaths.length > 0) {
+    confidence += bestTier === "infra" ? 0.4 : 0.2;
+    reasons.push(`commit touched: ${matchedPaths.slice(0, 3).join(", ")}`);
   }
-  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) => NEGATIVE_PATH_PATTERNS.some((p) => p.test(f)))) {
+    confidence -= 0.5;
+    reasons.push("all changed files are low-signal (lock files, generated code, dist)");
   }
-  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) => /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/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: "",
@@ -1836,6 +2104,15 @@ var POST_TOOL_USE_HOOK = {
     }
   ]
 };
+var PLAN_MODE_HOOK = {
+  matcher: "Read|Grep|Glob|Bash|WebSearch",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --heartbeat"
+    }
+  ]
+};
 var SESSION_END_HOOK = {
   matcher: "",
   hooks: [
@@ -1845,7 +2122,7 @@ var SESSION_END_HOOK = {
     }
   ]
 };
-var KEEPGOING_RULES_VERSION = 2;
+var KEEPGOING_RULES_VERSION = 3;
 var KEEPGOING_RULES_CONTENT = `<!-- @keepgoingdev/mcp-server v${KEEPGOING_RULES_VERSION} -->
 ## KeepGoing
 
@@ -1855,6 +2132,8 @@ After completing a task or meaningful piece of work, call the \`save_checkpoint\
 - \`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)
+
+When working in plan mode (investigating, designing, iterating on an approach before any edits), call \`save_checkpoint\` when you reach a significant milestone or conclusion. Use the summary to capture what was investigated and decided. This preserves planning context for future sessions.
 `;
 function getRulesFileVersion(content) {
   const match = content.match(/<!-- @keepgoingdev\/mcp-server v(\d+) -->/);
@@ -1862,7 +2141,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(
@@ -1874,19 +2153,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) {
@@ -1915,6 +2194,13 @@ function writeHooksToSettings(settings) {
     settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
     changed = true;
   }
+  const hasHeartbeat = settings.hooks.PostToolUse.some(
+    (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes("--heartbeat"))
+  );
+  if (!hasHeartbeat) {
+    settings.hooks.PostToolUse.push(PLAN_MODE_HOOK);
+    changed = true;
+  }
   if (!Array.isArray(settings.hooks.SessionEnd)) {
     settings.hooks.SessionEnd = [];
   }
@@ -1926,11 +2212,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);
@@ -1959,10 +2245,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) {
@@ -1993,36 +2279,36 @@ function setupProject(options) {
     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";
@@ -2458,7 +2744,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(
@@ -2470,12 +2756,19 @@ 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 writer = new KeepGoingWriter(workspacePath);
       const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
+      const existingTasks = writer.readCurrentTasks();
+      const existingSession = existingTasks.find((t) => t.sessionId === sessionId);
+      const sessionPhase = existingSession?.sessionPhase;
       const checkpoint = createCheckpoint({
         summary,
         nextStep: nextStep || "",
@@ -2485,10 +2778,19 @@ function registerSaveCheckpoint(server, reader, workspacePath) {
         commitHashes,
         workspaceRoot: workspacePath,
         source: "manual",
-        sessionId
+        sessionId,
+        ...sessionPhase ? { sessionPhase } : {},
+        ...sessionPhase === "planning" ? { tags: ["plan"] } : {}
       });
-      const writer = new KeepGoingWriter(workspacePath);
       writer.saveCheckpoint(checkpoint, projectName);
+      writer.upsertSession({
+        sessionId,
+        sessionActive: true,
+        branch: gitBranch ?? void 0,
+        updatedAt: checkpoint.timestamp,
+        taskSummary: summary,
+        nextStep: nextStep || void 0
+      });
       const lines = [
         `Checkpoint saved.`,
         `- **ID:** ${checkpoint.id}`,
@@ -2641,8 +2943,9 @@ function registerGetCurrentTask(server, reader) {
         lines.push("");
       }
       for (const task of [...activeTasks, ...finishedTasks]) {
+        const phaseLabel = task.sessionPhase === "planning" ? "Planning" : void 0;
         const statusIcon = task.sessionActive ? "\u{1F7E2}" : "\u2705";
-        const statusLabel = task.sessionActive ? "Active" : "Finished";
+        const statusLabel = task.sessionActive ? phaseLabel || "Active" : "Finished";
         const sessionLabel = task.sessionLabel || task.agentLabel || task.sessionId || "Session";
         lines.push(`### ${statusIcon} ${sessionLabel} (${statusLabel})`);
         lines.push(`- **Updated:** ${formatRelativeTime(task.updatedAt)}`);
@@ -2692,25 +2995,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 {
@@ -2718,10 +3021,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 {
     }
   }
@@ -2954,6 +3257,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(
@@ -3119,10 +3503,11 @@ 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);
+  const writer = new KeepGoingWriter(wsPath);
   const { session: lastSession } = reader.getScopedLastSession();
   if (lastSession?.timestamp) {
     const ageMs = Date.now() - new Date(lastSession.timestamp).getTime();
@@ -3132,10 +3517,40 @@ async function handleSaveCheckpoint() {
   }
   const touchedFiles = getTouchedFiles(wsPath);
   const commitHashes = getCommitsSince(wsPath, lastSession?.timestamp);
-  if (touchedFiles.length === 0 && commitHashes.length === 0) {
+  const gitBranch = getCurrentBranch(wsPath);
+  const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
+  const existingTasks = writer.readCurrentTasks();
+  const existingSession = existingTasks.find((t) => t.sessionId === sessionId);
+  const isPlanning = existingSession?.sessionPhase === "planning";
+  if (touchedFiles.length === 0 && commitHashes.length === 0 && !isPlanning) {
+    process.exit(0);
+  }
+  const projectName = path12.basename(resolveStorageRoot(wsPath));
+  if (touchedFiles.length === 0 && commitHashes.length === 0 && isPlanning) {
+    const summary2 = existingSession?.sessionLabel || existingSession?.taskSummary || "Planning session";
+    const checkpoint2 = createCheckpoint({
+      summary: summary2,
+      nextStep: existingSession?.nextStep || "",
+      gitBranch,
+      touchedFiles: [],
+      commitHashes: [],
+      workspaceRoot: wsPath,
+      source: "auto",
+      sessionId,
+      sessionPhase: "planning",
+      tags: ["plan"]
+    });
+    writer.saveCheckpoint(checkpoint2, projectName);
+    writer.upsertSession({
+      sessionId,
+      sessionActive: false,
+      nextStep: checkpoint2.nextStep || void 0,
+      branch: gitBranch ?? void 0,
+      updatedAt: checkpoint2.timestamp
+    });
+    console.log(`[KeepGoing] Plan checkpoint saved: ${summary2}`);
     process.exit(0);
   }
-  const gitBranch = getCurrentBranch(wsPath);
   const commitMessages = getCommitMessagesSince(wsPath, lastSession?.timestamp);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const events = buildSessionEvents({
@@ -3147,10 +3562,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 sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
+  const sessionPhase = existingSession?.sessionPhase;
   const checkpoint = createCheckpoint({
     summary,
     nextStep,
@@ -3159,9 +3573,10 @@ async function handleSaveCheckpoint() {
     commitHashes,
     workspaceRoot: wsPath,
     source: "auto",
-    sessionId
+    sessionId,
+    ...sessionPhase ? { sessionPhase } : {},
+    ...sessionPhase === "planning" ? { tags: ["plan"] } : {}
   });
-  const writer = new KeepGoingWriter(wsPath);
   writer.saveCheckpoint(checkpoint, projectName);
   writer.upsertSession({
     sessionId,
@@ -3194,7 +3609,7 @@ async function handleSaveCheckpoint() {
 }
 
 // src/cli/transcriptUtils.ts
-import fs8 from "fs";
+import fs9 from "fs";
 var TAIL_READ_BYTES = 32768;
 var LATEST_LABEL_READ_BYTES = 65536;
 var TOOL_VERB_MAP = {
@@ -3251,9 +3666,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;
@@ -3266,7 +3681,9 @@ 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();
@@ -3282,19 +3699,19 @@ function extractSessionLabel(transcriptPath) {
   return null;
 }
 function extractLatestUserLabel(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, LATEST_LABEL_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();
@@ -3310,7 +3727,9 @@ function extractLatestUserLabel(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();
@@ -3326,19 +3745,19 @@ function extractLatestUserLabel(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();
@@ -3373,6 +3792,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 = {
@@ -3423,7 +3844,8 @@ async function handleUpdateTaskFromHook() {
         branch,
         worktreePath: wsPath,
         sessionActive: true,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionPhase: "active"
       };
       const sessionId = hookData.session_id || generateSessionId({ ...task, workspaceRoot: wsPath });
       task.sessionId = sessionId;
@@ -3440,8 +3862,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 = [];
@@ -3471,9 +3893,9 @@ async function handleStatusline() {
       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) {
@@ -3570,6 +3992,59 @@ async function handleDetectDecisions() {
   process.exit(0);
 }
 
+// src/cli/heartbeat.ts
+var STDIN_TIMEOUT_MS3 = 3e3;
+var THROTTLE_MS = 3e4;
+async function handleHeartbeat() {
+  const wsPath = resolveWsPath();
+  const chunks = [];
+  const timeout = setTimeout(() => process.exit(0), STDIN_TIMEOUT_MS3);
+  process.stdin.on("error", () => {
+    clearTimeout(timeout);
+    process.exit(0);
+  });
+  process.stdin.on("data", (chunk) => chunks.push(chunk));
+  process.stdin.on("end", () => {
+    clearTimeout(timeout);
+    try {
+      const raw = Buffer.concat(chunks).toString("utf-8").trim();
+      if (!raw) {
+        process.exit(0);
+      }
+      const hookData = JSON.parse(raw);
+      const writer = new KeepGoingWriter(wsPath);
+      const existing = writer.readCurrentTasks();
+      const sessionIdFromHook = hookData.session_id;
+      const sessionId = sessionIdFromHook || generateSessionId({ workspaceRoot: wsPath, worktreePath: wsPath, branch: getCurrentBranch(wsPath) ?? void 0 });
+      const existingSession = existing.find((t) => t.sessionId === sessionId);
+      if (existingSession?.updatedAt) {
+        const ageMs = Date.now() - new Date(existingSession.updatedAt).getTime();
+        if (ageMs < THROTTLE_MS) {
+          process.exit(0);
+        }
+      }
+      const sessionPhase = existingSession?.sessionPhase === "active" ? "active" : "planning";
+      const branch = existingSession?.branch ?? getCurrentBranch(wsPath) ?? void 0;
+      const task = {
+        sessionId,
+        sessionActive: true,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionPhase,
+        worktreePath: wsPath,
+        branch
+      };
+      if (!existingSession?.sessionLabel && hookData.transcript_path) {
+        const label = extractSessionLabel(hookData.transcript_path);
+        if (label) task.sessionLabel = label;
+      }
+      writer.upsertSession(task);
+    } catch {
+    }
+    process.exit(0);
+  });
+  process.stdin.resume();
+}
+
 // src/index.ts
 var CLI_HANDLERS = {
   "--print-momentum": handlePrintMomentum,
@@ -3579,7 +4054,8 @@ var CLI_HANDLERS = {
   "--print-current": handlePrintCurrent,
   "--statusline": handleStatusline,
   "--continue-on": handleContinueOn,
-  "--detect-decisions": handleDetectDecisions
+  "--detect-decisions": handleDetectDecisions,
+  "--heartbeat": handleHeartbeat
 };
 var flag = process.argv.slice(2).find((a) => a in CLI_HANDLERS);
 if (flag) {
@@ -3598,6 +4074,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);