@keepgoingdev/cli 1.2.2 → 1.3.1

package/dist/index.js

@@ -2,6 +2,16 @@
 
 // ../../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();
 }
@@ -9,7 +19,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
   };
 }
 
@@ -284,7 +297,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) {
@@ -317,10 +331,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;
@@ -588,22 +605,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;
       }
@@ -613,18 +768,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;
@@ -663,23 +818,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 {
@@ -697,13 +852,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);
@@ -711,8 +866,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 = {
@@ -728,7 +883,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
@@ -736,8 +912,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);
       }
@@ -758,6 +934,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);
@@ -792,8 +970,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 {
@@ -805,7 +983,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) {
@@ -821,376 +999,79 @@ 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 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")) {
-      area = parts[1];
-      if (parts[0] === "packages" && parts.length >= 4 && parts[2] === "src") {
-        const subFile = parts[3].replace(/\.\w+$/, "");
-        area = `${parts[1]} ${subFile}`;
-      }
-    } else if (parts.length >= 2) {
-      area = parts[0];
-    } else {
-      area = "root";
-    }
-    areas.set(area, (areas.get(area) ?? 0) + 1);
-  }
-  return [...areas.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name]) => name);
-}
-function buildSessionEvents(opts) {
-  const { wsPath, commitHashes, commitMessages, touchedFiles, currentBranch, sessionStartTime, lastActivityTime } = opts;
-  const commits = commitHashes.map((hash, i) => ({
-    hash,
-    message: commitMessages[i] ?? "",
-    filesChanged: getFilesChangedInCommit(wsPath, hash),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  }));
-  const committedFiles = new Set(commits.flatMap((c) => c.filesChanged));
-  return {
-    commits,
-    branchSwitches: [],
-    touchedFiles,
-    currentBranch,
-    sessionStartTime,
-    lastActivityTime,
-    // Normalize rename arrows ("old -> new") from git status --porcelain
-    // so they match the plain filenames from git diff-tree --name-only.
-    hasUncommittedChanges: touchedFiles.some((f) => {
-      const normalized = f.includes(" -> ") ? f.split(" -> ").pop() : f;
-      return !committedFiles.has(normalized);
-    })
-  };
-}
-function buildSmartSummary(events) {
-  const { commits, branchSwitches, touchedFiles, hasUncommittedChanges } = events;
-  if (commits.length === 0 && touchedFiles.length === 0 && branchSwitches.length === 0) {
-    return void 0;
-  }
-  const parts = [];
-  if (commits.length > 0) {
-    const messages = commits.map((c) => c.message);
-    const groups = categorizeCommits(messages);
-    const phrases = [];
-    for (const [prefix, bodies] of groups) {
-      const verb = PREFIX_VERBS[prefix] ?? (prefix === "other" ? "" : `${capitalize(prefix)}:`);
-      const items = bodies.slice(0, 2).join(" and ");
-      const overflow = bodies.length > 2 ? ` (+${bodies.length - 2} more)` : "";
-      if (verb) {
-        phrases.push(`${verb} ${items}${overflow}`);
-      } else {
-        phrases.push(`${items}${overflow}`);
-      }
-    }
-    parts.push(phrases.join(", "));
-  } else if (touchedFiles.length > 0) {
-    const areas = inferWorkAreas(touchedFiles);
-    const areaStr = areas.length > 0 ? areas.join(" and ") : `${touchedFiles.length} files`;
-    const suffix = hasUncommittedChanges ? " (uncommitted)" : "";
-    parts.push(`Worked on ${areaStr}${suffix}`);
-  }
-  if (branchSwitches.length > 0) {
-    const last = branchSwitches[branchSwitches.length - 1];
-    if (branchSwitches.length === 1) {
-      parts.push(`switched to ${last.toBranch}`);
-    } else {
-      parts.push(`switched branches ${branchSwitches.length} times, ended on ${last.toBranch}`);
-    }
-  }
-  const result = parts.join("; ");
-  return result || void 0;
-}
-function buildSmartNextStep(events) {
-  const { commits, touchedFiles, currentBranch, hasUncommittedChanges } = events;
-  if (hasUncommittedChanges && touchedFiles.length > 0) {
-    const areas = inferWorkAreas(touchedFiles);
-    const areaStr = areas.length > 0 ? areas.join(" and ") : "working tree";
-    return `Review and commit changes in ${areaStr}`;
-  }
-  if (commits.length > 0) {
-    const lastMsg = commits[commits.length - 1].message;
-    const wipMatch = lastMsg.match(/^(?:wip|work in progress|start(?:ed)?|begin|draft)[:\s]+(.+)/i);
-    if (wipMatch) {
-      return `Continue ${wipMatch[1].trim()}`;
-    }
-  }
-  if (currentBranch && !["main", "master", "develop", "HEAD"].includes(currentBranch)) {
-    const branchName = currentBranch.replace(/^(feat|feature|fix|bugfix|hotfix|chore|refactor)[/-]/i, "").replace(/[-_]/g, " ").trim();
-    if (branchName) {
-      return `Continue ${branchName}`;
-    }
-  }
-  if (touchedFiles.length > 0) {
-    const areas = inferWorkAreas(touchedFiles);
-    if (areas.length > 0) {
-      return `Review recent changes in ${areas.join(" and ")}`;
-    }
-  }
-  return "";
-}
-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);
-}
-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 {
-  }
-  const id = crypto.randomUUID();
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  fs3.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 (!fs3.existsSync(licensePath)) {
-      store = { version: 2, licenses: [] };
-    } 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: [] };
-      }
-    }
-  } catch {
-    store = { version: 2, licenses: [] };
-  }
-  _cachedStore = store;
-  _cacheTimestamp = now;
-  return store;
-}
-function writeLicenseStore(store) {
-  const dirPath = getGlobalLicenseDir();
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
-  }
-  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);
-  }
-  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/featureGate.ts
-var DefaultFeatureGate = class {
-  isEnabled(_feature) {
-    return true;
-  }
-};
-var currentGate = new DefaultFeatureGate();
-
-// ../../packages/shared/src/reader.ts
-import fs5 from "fs";
-import path7 from "path";
-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 = path7.join(mainRoot, STORAGE_DIR2);
-    this.metaFilePath = path7.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path7.join(this.storagePath, SESSIONS_FILE2);
-    this.decisionsFilePath = path7.join(this.storagePath, DECISIONS_FILE);
-    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];
+    return sessions[sessions.length - 1];
   }
   /**
    * Returns the last N sessions, newest first.
@@ -1302,106 +1183,492 @@ var KeepGoingReader = class {
   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);
+  /**
+   * 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")) {
+      area = parts[1];
+      if (parts[0] === "packages" && parts.length >= 4 && parts[2] === "src") {
+        const subFile = parts[3].replace(/\.\w+$/, "");
+        area = `${parts[1]} ${subFile}`;
+      }
+    } else if (parts.length >= 2) {
+      area = parts[0];
+    } else {
+      area = "root";
+    }
+    areas.set(area, (areas.get(area) ?? 0) + 1);
+  }
+  return [...areas.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name]) => name);
+}
+function buildSessionEvents(opts) {
+  const { wsPath, commitHashes, commitMessages, touchedFiles, currentBranch, sessionStartTime, lastActivityTime } = opts;
+  const commits = commitHashes.map((hash, i) => ({
+    hash,
+    message: commitMessages[i] ?? "",
+    filesChanged: getFilesChangedInCommit(wsPath, hash),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  const committedFiles = new Set(commits.flatMap((c) => c.filesChanged));
+  return {
+    commits,
+    branchSwitches: [],
+    touchedFiles,
+    currentBranch,
+    sessionStartTime,
+    lastActivityTime,
+    // Normalize rename arrows ("old -> new") from git status --porcelain
+    // so they match the plain filenames from git diff-tree --name-only.
+    hasUncommittedChanges: touchedFiles.some((f) => {
+      const normalized = f.includes(" -> ") ? f.split(" -> ").pop() : f;
+      return !committedFiles.has(normalized);
+    })
+  };
+}
+function buildSmartSummary(events) {
+  const { commits, branchSwitches, touchedFiles, hasUncommittedChanges } = events;
+  if (commits.length === 0 && touchedFiles.length === 0 && branchSwitches.length === 0) {
+    return void 0;
+  }
+  const parts = [];
+  if (commits.length > 0) {
+    const messages = commits.map((c) => c.message);
+    const groups = categorizeCommits(messages);
+    const phrases = [];
+    for (const [prefix, bodies] of groups) {
+      const verb = PREFIX_VERBS[prefix] ?? (prefix === "other" ? "" : `${capitalize(prefix)}:`);
+      const items = bodies.slice(0, 2).join(" and ");
+      const overflow = bodies.length > 2 ? ` (+${bodies.length - 2} more)` : "";
+      if (verb) {
+        phrases.push(`${verb} ${items}${overflow}`);
+      } else {
+        phrases.push(`${items}${overflow}`);
+      }
     }
-    return this._cachedBranch;
+    parts.push(phrases.join(", "));
+  } else if (touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    const areaStr = areas.length > 0 ? areas.join(" and ") : `${touchedFiles.length} files`;
+    const suffix = hasUncommittedChanges ? " (uncommitted)" : "";
+    parts.push(`Worked on ${areaStr}${suffix}`);
   }
-  /**
-   * 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 };
+  if (branchSwitches.length > 0) {
+    const last = branchSwitches[branchSwitches.length - 1];
+    if (branchSwitches.length === 1) {
+      parts.push(`switched to ${last.toBranch}`);
+    } else {
+      parts.push(`switched branches ${branchSwitches.length} times, ended on ${last.toBranch}`);
     }
-    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);
+  const result = parts.join("; ");
+  return result || void 0;
+}
+function buildSmartNextStep(events) {
+  const { commits, touchedFiles, currentBranch, hasUncommittedChanges } = events;
+  if (hasUncommittedChanges && touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    const areaStr = areas.length > 0 ? areas.join(" and ") : "working tree";
+    return `Review and commit changes in ${areaStr}`;
+  }
+  if (commits.length > 0) {
+    const lastMsg = commits[commits.length - 1].message;
+    const wipMatch = lastMsg.match(/^(?:wip|work in progress|start(?:ed)?|begin|draft)[:\s]+(.+)/i);
+    if (wipMatch) {
+      return `Continue ${wipMatch[1].trim()}`;
     }
-    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);
+  if (currentBranch && !["main", "master", "develop", "HEAD"].includes(currentBranch)) {
+    const branchName = currentBranch.replace(/^(feat|feature|fix|bugfix|hotfix|chore|refactor)[/-]/i, "").replace(/[-_]/g, " ").trim();
+    if (branchName) {
+      return `Continue ${branchName}`;
     }
-    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 (touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    if (areas.length > 0) {
+      return `Review recent changes in ${areas.join(" and ")}`;
     }
-    if (branch) {
-      return { effectiveBranch: branch, scopeLabel: `branch \`${branch}\`` };
+  }
+  return "";
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// ../../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 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";
+      }
     }
-    const currentBranch = this.getCurrentBranch();
-    if (this._isWorktree && currentBranch) {
-      return { effectiveBranch: currentBranch, scopeLabel: `branch \`${currentBranch}\` (worktree)` };
+    if (signals.recentCommitCount !== void 0 && signals.recentCommitCount >= 2) {
+      return "hot";
     }
-    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 };
+  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;
+  }
+  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;
+}
+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";
+}
+function buildWhere(checkpoint, branch) {
+  const effectiveBranch = branch ?? checkpoint?.gitBranch;
+  const parts = [];
+  if (effectiveBranch) {
+    parts.push(effectiveBranch);
+  }
+  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 {
+      area = parts[0];
     }
-    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+    areaCounts.set(area, (areaCounts.get(area) ?? 0) + 1);
   }
-  parseDecisions() {
-    const raw = this.readJsonFile(this.decisionsFilePath);
-    if (!raw) {
-      return { decisions: [] };
+  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);
     }
-    return { decisions: raw.decisions ?? [], lastDecisionId: raw.lastDecisionId };
   }
-  readJsonFile(filePath) {
+  if (topCount === 0) {
+    topCount = Math.max(...areaCounts.values());
+  }
+  const ratio = topCount / files.length;
+  if (ratio >= 0.6) return topArea;
+  return void 0;
+}
+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 {
-      if (!fs5.existsSync(filePath)) {
-        return void 0;
-      }
-      const raw = fs5.readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
+      resolvedRoot = fs5.realpathSync(entry.path);
     } catch {
-      return void 0;
-    }
+      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;
+  });
+  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) {
+    return true;
   }
 };
+var currentGate = new DefaultFeatureGate();
 
 // ../../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: "",
@@ -1430,6 +1697,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: [
@@ -1439,7 +1715,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
 
@@ -1449,6 +1725,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+) -->/);
@@ -1456,7 +1734,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(
@@ -1468,19 +1746,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) {
@@ -1509,6 +1787,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 = [];
   }
@@ -1520,11 +1805,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);
@@ -1553,10 +1838,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) {
@@ -1587,36 +1872,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";
@@ -2112,14 +2397,14 @@ function renderEnrichedBriefingQuiet(briefing) {
 // src/updateCheck.ts
 import { spawn } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import path9 from "path";
+import path10 from "path";
 import os4 from "os";
-var CLI_VERSION = "1.2.2";
+var CLI_VERSION = "1.3.1";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@keepgoingdev/cli/latest";
 var FETCH_TIMEOUT_MS = 5e3;
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var CACHE_DIR = path9.join(os4.homedir(), ".keepgoing");
-var CACHE_PATH = path9.join(CACHE_DIR, "update-check.json");
+var CACHE_DIR = path10.join(os4.homedir(), ".keepgoing");
+var CACHE_PATH = path10.join(CACHE_DIR, "update-check.json");
 function isNewerVersion(current, latest) {
   const cur = current.split(".").map(Number);
   const lat = latest.split(".").map(Number);
@@ -2234,7 +2519,7 @@ async function statusCommand(opts) {
 }
 
 // src/commands/save.ts
-import path10 from "path";
+import path11 from "path";
 async function saveCommand(opts) {
   const { cwd, message, nextStepOverride, json, quiet, force } = opts;
   const isManual = !!message;
@@ -2263,9 +2548,9 @@ async function saveCommand(opts) {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path10.basename(f)).join(", ")}`;
+  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path11.basename(f)).join(", ")}`;
   const nextStep = nextStepOverride ?? buildSmartNextStep(events);
-  const projectName = path10.basename(resolveStorageRoot(cwd));
+  const projectName = path11.basename(resolveStorageRoot(cwd));
   const sessionId = generateSessionId({
     workspaceRoot: cwd,
     branch: gitBranch ?? void 0,
@@ -2298,17 +2583,17 @@ async function saveCommand(opts) {
 }
 
 // src/commands/hook.ts
-import fs7 from "fs";
-import path11 from "path";
+import fs8 from "fs";
+import path12 from "path";
 import os5 from "os";
 import { execSync } from "child_process";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
 var HOOK_MARKER_END = "# keepgoing-hook-end";
 var POST_COMMIT_MARKER_START = "# keepgoing-post-commit-start";
 var POST_COMMIT_MARKER_END = "# keepgoing-post-commit-end";
-var KEEPGOING_HOOKS_DIR = path11.join(os5.homedir(), ".keepgoing", "hooks");
-var POST_COMMIT_HOOK_PATH = path11.join(KEEPGOING_HOOKS_DIR, "post-commit");
-var KEEPGOING_MANAGED_MARKER = path11.join(KEEPGOING_HOOKS_DIR, ".keepgoing-managed");
+var KEEPGOING_HOOKS_DIR = path12.join(os5.homedir(), ".keepgoing", "hooks");
+var POST_COMMIT_HOOK_PATH = path12.join(KEEPGOING_HOOKS_DIR, "post-commit");
+var KEEPGOING_MANAGED_MARKER = path12.join(KEEPGOING_HOOKS_DIR, ".keepgoing-managed");
 var POST_COMMIT_HOOK = `#!/bin/sh
 ${POST_COMMIT_MARKER_START}
 # Runs after every git commit. Detects high-signal decisions.
@@ -2322,7 +2607,7 @@ var ZSH_HOOK = `${HOOK_MARKER_START}
 if command -v keepgoing >/dev/null 2>&1; then
   function chpwd() {
     if [ -d ".keepgoing" ]; then
-      keepgoing status --quiet
+      keepgoing glance
     fi
   }
 fi
@@ -2333,7 +2618,7 @@ if command -v keepgoing >/dev/null 2>&1; then
   function cd() {
     builtin cd "$@" || return
     if [ -d ".keepgoing" ]; then
-      keepgoing status --quiet
+      keepgoing glance
     fi
   }
 fi
@@ -2343,7 +2628,7 @@ var FISH_HOOK = `${HOOK_MARKER_START}
 if command -v keepgoing >/dev/null 2>&1
   function __keepgoing_on_pwd_change --on-variable PWD
     if test -d .keepgoing
-      keepgoing status --quiet
+      keepgoing glance
     end
   end
 end
@@ -2372,14 +2657,14 @@ function detectShellRcFile(shellOverride) {
     }
   }
   if (shell === "zsh") {
-    return { shell: "zsh", rcFile: path11.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path12.join(home, ".zshrc") };
   }
   if (shell === "bash") {
-    return { shell: "bash", rcFile: path11.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path12.join(home, ".bashrc") };
   }
   if (shell === "fish") {
-    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path11.join(home, ".config");
-    return { shell: "fish", rcFile: path11.join(xdgConfig, "fish", "config.fish") };
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path12.join(home, ".config");
+    return { shell: "fish", rcFile: path12.join(xdgConfig, "fish", "config.fish") };
   }
   return void 0;
 }
@@ -2390,24 +2675,24 @@ function resolveGlobalGitignorePath() {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (configured) {
-      return configured.startsWith("~") ? path11.join(os5.homedir(), configured.slice(1)) : configured;
+      return configured.startsWith("~") ? path12.join(os5.homedir(), configured.slice(1)) : configured;
     }
   } catch {
   }
-  return path11.join(os5.homedir(), ".gitignore_global");
+  return path12.join(os5.homedir(), ".gitignore_global");
 }
 function installGlobalGitignore() {
   const ignorePath = resolveGlobalGitignorePath();
   let existing = "";
   try {
-    existing = fs7.readFileSync(ignorePath, "utf-8");
+    existing = fs8.readFileSync(ignorePath, "utf-8");
   } catch {
   }
   if (existing.split("\n").some((line) => line.trim() === ".keepgoing")) {
     console.log(`Global gitignore: .keepgoing already present in ${ignorePath}`);
   } else {
     const suffix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    fs7.appendFileSync(ignorePath, `${suffix}.keepgoing
+    fs8.appendFileSync(ignorePath, `${suffix}.keepgoing
 `, "utf-8");
     console.log(`Global gitignore: .keepgoing added to ${ignorePath}`);
   }
@@ -2426,21 +2711,21 @@ function uninstallGlobalGitignore() {
   const ignorePath = resolveGlobalGitignorePath();
   let existing = "";
   try {
-    existing = fs7.readFileSync(ignorePath, "utf-8");
+    existing = fs8.readFileSync(ignorePath, "utf-8");
   } catch {
     return;
   }
   const lines = existing.split("\n");
   const filtered = lines.filter((line) => line.trim() !== ".keepgoing");
   if (filtered.length !== lines.length) {
-    fs7.writeFileSync(ignorePath, filtered.join("\n"), "utf-8");
+    fs8.writeFileSync(ignorePath, filtered.join("\n"), "utf-8");
     console.log(`Global gitignore: .keepgoing removed from ${ignorePath}`);
   }
 }
 function installPostCommitHook() {
-  fs7.mkdirSync(KEEPGOING_HOOKS_DIR, { recursive: true });
-  if (fs7.existsSync(POST_COMMIT_HOOK_PATH)) {
-    const existing = fs7.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
+  fs8.mkdirSync(KEEPGOING_HOOKS_DIR, { recursive: true });
+  if (fs8.existsSync(POST_COMMIT_HOOK_PATH)) {
+    const existing = fs8.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
     if (existing.includes(POST_COMMIT_MARKER_START)) {
       console.log(`Git post-commit hook: already installed at ${POST_COMMIT_HOOK_PATH}`);
     } else {
@@ -2453,14 +2738,14 @@ if command -v keepgoing-mcp-server >/dev/null 2>&1; then
 fi
 ${POST_COMMIT_MARKER_END}
 `;
-      fs7.appendFileSync(POST_COMMIT_HOOK_PATH, block, "utf-8");
+      fs8.appendFileSync(POST_COMMIT_HOOK_PATH, block, "utf-8");
       console.log(`Git post-commit hook: appended to existing ${POST_COMMIT_HOOK_PATH}`);
     }
   } else {
-    fs7.writeFileSync(POST_COMMIT_HOOK_PATH, POST_COMMIT_HOOK, { mode: 493 });
+    fs8.writeFileSync(POST_COMMIT_HOOK_PATH, POST_COMMIT_HOOK, { mode: 493 });
     console.log(`Git post-commit hook: installed at ${POST_COMMIT_HOOK_PATH}`);
   }
-  fs7.chmodSync(POST_COMMIT_HOOK_PATH, 493);
+  fs8.chmodSync(POST_COMMIT_HOOK_PATH, 493);
   let currentHooksPath;
   try {
     currentHooksPath = execSync("git config --global core.hooksPath", {
@@ -2485,8 +2770,8 @@ ${POST_COMMIT_MARKER_END}
   }
 }
 function uninstallPostCommitHook() {
-  if (fs7.existsSync(POST_COMMIT_HOOK_PATH)) {
-    const existing = fs7.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
+  if (fs8.existsSync(POST_COMMIT_HOOK_PATH)) {
+    const existing = fs8.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
     if (existing.includes(POST_COMMIT_MARKER_START)) {
       const pattern = new RegExp(
         `
@@ -2496,10 +2781,10 @@ function uninstallPostCommitHook() {
       );
       const updated = existing.replace(pattern, "").trim();
       if (!updated || updated === "#!/bin/sh") {
-        fs7.unlinkSync(POST_COMMIT_HOOK_PATH);
+        fs8.unlinkSync(POST_COMMIT_HOOK_PATH);
         console.log(`Git post-commit hook: removed ${POST_COMMIT_HOOK_PATH}`);
       } else {
-        fs7.writeFileSync(POST_COMMIT_HOOK_PATH, updated + "\n", "utf-8");
+        fs8.writeFileSync(POST_COMMIT_HOOK_PATH, updated + "\n", "utf-8");
         console.log(`Git post-commit hook: KeepGoing block removed from ${POST_COMMIT_HOOK_PATH}`);
       }
     }
@@ -2517,8 +2802,8 @@ function uninstallPostCommitHook() {
     }
   } catch {
   }
-  if (fs7.existsSync(KEEPGOING_MANAGED_MARKER)) {
-    fs7.unlinkSync(KEEPGOING_MANAGED_MARKER);
+  if (fs8.existsSync(KEEPGOING_MANAGED_MARKER)) {
+    fs8.unlinkSync(KEEPGOING_MANAGED_MARKER);
   }
 }
 function hookInstallCommand(shellOverride) {
@@ -2533,7 +2818,7 @@ function hookInstallCommand(shellOverride) {
   const hookBlock = shell === "zsh" ? ZSH_HOOK : shell === "fish" ? FISH_HOOK : BASH_HOOK;
   let existing = "";
   try {
-    existing = fs7.readFileSync(rcFile, "utf-8");
+    existing = fs8.readFileSync(rcFile, "utf-8");
   } catch {
   }
   if (existing.includes(HOOK_MARKER_START)) {
@@ -2542,7 +2827,7 @@ function hookInstallCommand(shellOverride) {
     installPostCommitHook();
     return;
   }
-  fs7.appendFileSync(rcFile, `
+  fs8.appendFileSync(rcFile, `
 ${hookBlock}
 `, "utf-8");
   console.log(`KeepGoing hook installed in ${rcFile}.`);
@@ -2564,7 +2849,7 @@ function hookUninstallCommand(shellOverride) {
   const { rcFile } = detected;
   let existing = "";
   try {
-    existing = fs7.readFileSync(rcFile, "utf-8");
+    existing = fs8.readFileSync(rcFile, "utf-8");
   } catch {
     console.log(`${rcFile} not found \u2014 nothing to remove.`);
     return;
@@ -2580,7 +2865,7 @@ function hookUninstallCommand(shellOverride) {
     "g"
   );
   const updated = existing.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-  fs7.writeFileSync(rcFile, updated, "utf-8");
+  fs8.writeFileSync(rcFile, updated, "utf-8");
   console.log(`KeepGoing hook removed from ${rcFile}.`);
   uninstallGlobalGitignore();
   uninstallPostCommitHook();
@@ -2860,9 +3145,7 @@ async function decisionsCommand(opts) {
   renderDecisions(decisions, scopeLabel);
 }
 
-// src/commands/log.ts
-var RESET4 = "\x1B[0m";
-var DIM4 = "\x1B[2m";
+// src/commands/logUtils.ts
 function parseDate(input) {
   const lower = input.toLowerCase().trim();
   if (lower === "today") {
@@ -2980,6 +3263,10 @@ function filterDecisions(decisions, opts) {
   }
   return result;
 }
+
+// src/commands/log.ts
+var RESET4 = "\x1B[0m";
+var DIM4 = "\x1B[2m";
 function logSessions(reader, opts) {
   const { effectiveBranch } = reader.resolveBranchScope(opts.branch || void 0);
   let sessions = reader.getSessions();
@@ -3168,6 +3455,54 @@ async function continueCommand(opts) {
   }
 }
 
+// src/commands/glance.ts
+function glanceCommand(opts) {
+  const snapshot = generateContextSnapshot(opts.cwd);
+  if (!snapshot) {
+    if (opts.json) {
+      console.log("null");
+    }
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+  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}`;
+  }
+  console.log(line);
+}
+
+// src/commands/hot.ts
+function hotCommand(opts) {
+  const summary = generateCrossProjectSummary();
+  if (summary.projects.length === 0) {
+    if (opts.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log("No projects with activity found.");
+      console.log("Projects are registered automatically when you save checkpoints.");
+    }
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  for (const entry of summary.projects) {
+    console.log(formatCrossProjectLine(entry));
+  }
+}
+
 // src/index.ts
 var HELP_TEXT = `
 keepgoing: resume side projects without the mental friction
@@ -3181,6 +3516,8 @@ Commands:
   briefing            Get a re-entry briefing for this project
   decisions           View decision history (Pro)
   log                 Browse session checkpoints
+  glance              Quick context snapshot (single line, <50ms)
+  hot                 Cross-project activity summary, sorted by momentum
   continue            Export context for use in another AI tool
   save                Save a checkpoint (auto-generates from git)
   hook                Manage the shell hook (zsh, bash, fish)
@@ -3338,6 +3675,35 @@ Example:
 keepgoing deactivate: Deactivate the Pro license from this device
 
 Usage: keepgoing deactivate [<key>]
+`,
+  glance: `
+keepgoing glance: Quick context snapshot in a single line
+
+Usage: keepgoing glance [options]
+
+Outputs a single formatted line showing what you were doing, what's next,
+and when you last worked. Designed for shell prompts and status bars.
+Completes in <50ms. Outputs nothing if no data exists.
+
+Options:
+  --json          Output raw JSON
+  --cwd <path>    Override the working directory
+
+Format:
+  Hot:   \u26A1 {doing} \u2192 {next} ({when})
+  Warm:  \u{1F536} {doing} \u2192 {next} ({when})
+  Cold:  \u{1F4A4} {doing} \u2192 {next} ({when})
+`,
+  hot: `
+keepgoing hot: Cross-project activity summary, sorted by momentum
+
+Usage: keepgoing hot [options]
+
+Shows a one-line summary for each registered project, sorted by momentum
+(hot first, then warm, then cold). Projects with no data are excluded.
+
+Options:
+  --json          Output raw JSON
 `,
   continue: `
 keepgoing continue: Export context for use in another AI tool
@@ -3545,6 +3911,12 @@ async function main() {
         sessions: parsed.sessions
       });
       break;
+    case "glance":
+      glanceCommand({ cwd, json });
+      break;
+    case "hot":
+      hotCommand({ json });
+      break;
     case "continue":
       await continueCommand({ cwd, json, quiet, target: parsed.target, open: parsed.open });
       break;
@@ -3568,7 +3940,7 @@ async function main() {
       }
       break;
     case "version":
-      console.log(`keepgoing v${"1.2.2"}`);
+      console.log(`keepgoing v${"1.3.1"}`);
       break;
     case "activate":
       await activateCommand({ licenseKey: subcommand });