@keepgoingdev/mcp-server 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,14 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path8 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/storage.ts
-import fs4 from "fs";
-import path5 from "path";
-
 // ../../packages/shared/src/session.ts
 import { randomUUID } from "crypto";
 function generateCheckpointId() {
@@ -116,10 +111,10 @@ function resolveStorageRoot(startPath) {
     return startPath;
   }
 }
-function getCurrentBranch(workspacePath2) {
+function getCurrentBranch(workspacePath) {
   try {
     const result = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd: workspacePath2,
+      cwd: workspacePath,
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -128,14 +123,14 @@ function getCurrentBranch(workspacePath2) {
     return void 0;
   }
 }
-function getGitLogSince(workspacePath2, format, sinceTimestamp) {
+function getGitLogSince(workspacePath, format, sinceTimestamp) {
   try {
     const since = sinceTimestamp || new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
     const result = execFileSync(
       "git",
       ["log", `--since=${since}`, `--format=${format}`],
       {
-        cwd: workspacePath2,
+        cwd: workspacePath,
         encoding: "utf-8",
         timeout: 5e3
       }
@@ -148,16 +143,16 @@ function getGitLogSince(workspacePath2, format, sinceTimestamp) {
     return [];
   }
 }
-function getCommitsSince(workspacePath2, sinceTimestamp) {
-  return getGitLogSince(workspacePath2, "%H", sinceTimestamp);
+function getCommitsSince(workspacePath, sinceTimestamp) {
+  return getGitLogSince(workspacePath, "%H", sinceTimestamp);
 }
-function getCommitMessagesSince(workspacePath2, sinceTimestamp) {
-  return getGitLogSince(workspacePath2, "%s", sinceTimestamp);
+function getCommitMessagesSince(workspacePath, sinceTimestamp) {
+  return getGitLogSince(workspacePath, "%s", sinceTimestamp);
 }
-function getHeadCommitHash(workspacePath2) {
+function getHeadCommitHash(workspacePath) {
   try {
     const result = execFileSync("git", ["rev-parse", "HEAD"], {
-      cwd: workspacePath2,
+      cwd: workspacePath,
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -166,10 +161,10 @@ function getHeadCommitHash(workspacePath2) {
     return void 0;
   }
 }
-function getTouchedFiles(workspacePath2) {
+function getTouchedFiles(workspacePath) {
   try {
     const result = execFileSync("git", ["status", "--porcelain"], {
-      cwd: workspacePath2,
+      cwd: workspacePath,
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -385,22 +380,33 @@ function inferFocusFromFiles(files) {
 // ../../packages/shared/src/storage.ts
 import fs from "fs";
 import path2 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID2, createHash } from "crypto";
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
 var SESSIONS_FILE = "sessions.json";
 var STATE_FILE = "state.json";
+var CURRENT_TASKS_FILE = "current-tasks.json";
+var STALE_SESSION_MS = 2 * 60 * 60 * 1e3;
+function pruneStaleTasks(tasks) {
+  const now = Date.now();
+  return tasks.filter((t) => {
+    const updatedAt = new Date(t.updatedAt).getTime();
+    return !isNaN(updatedAt) && now - updatedAt < STALE_SESSION_MS;
+  });
+}
 var KeepGoingWriter = class {
   storagePath;
   sessionsFilePath;
   stateFilePath;
   metaFilePath;
-  constructor(workspacePath2) {
-    const mainRoot = resolveStorageRoot(workspacePath2);
+  currentTasksFilePath;
+  constructor(workspacePath) {
+    const mainRoot = resolveStorageRoot(workspacePath);
     this.storagePath = path2.join(mainRoot, STORAGE_DIR);
     this.sessionsFilePath = path2.join(this.storagePath, SESSIONS_FILE);
     this.stateFilePath = path2.join(this.storagePath, STATE_FILE);
     this.metaFilePath = path2.join(this.storagePath, META_FILE);
+    this.currentTasksFilePath = path2.join(this.storagePath, CURRENT_TASKS_FILE);
   }
   ensureDir() {
     if (!fs.existsSync(this.storagePath)) {
@@ -461,11 +467,212 @@ var KeepGoingWriter = class {
     }
     fs.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
   }
+  // ---------------------------------------------------------------------------
+  // Multi-session API
+  // ---------------------------------------------------------------------------
+  /** Read all current tasks from current-tasks.json. Auto-prunes stale sessions. */
+  readCurrentTasks() {
+    try {
+      if (fs.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+        const tasks = Array.isArray(raw) ? raw : raw.tasks ?? [];
+        return this.pruneStale(tasks);
+      }
+    } catch {
+    }
+    return [];
+  }
+  /**
+   * Upsert a session task by sessionId into current-tasks.json.
+   * If no sessionId is present on the task, generates one.
+   */
+  upsertSession(update) {
+    this.ensureDir();
+    this.upsertSessionCore(update);
+  }
+  /** Core upsert logic: merges the update into current-tasks.json and returns the pruned task list. */
+  upsertSessionCore(update) {
+    this.ensureDir();
+    const sessionId = update.sessionId || generateSessionId(update);
+    const tasks = this.readAllTasksRaw();
+    const existingIdx = tasks.findIndex((t) => t.sessionId === sessionId);
+    let merged;
+    if (existingIdx >= 0) {
+      const existing = tasks[existingIdx];
+      merged = { ...existing, ...update, sessionId };
+      tasks[existingIdx] = merged;
+    } else {
+      merged = { ...update, sessionId };
+      tasks.push(merged);
+    }
+    const pruned = this.pruneStale(tasks);
+    this.writeTasksFile(pruned);
+    return pruned;
+  }
+  /** Remove a specific session by ID. */
+  removeSession(sessionId) {
+    const tasks = this.readAllTasksRaw().filter((t) => t.sessionId !== sessionId);
+    this.writeTasksFile(tasks);
+  }
+  /** Get all active sessions (sessionActive=true and within stale threshold). */
+  getActiveSessions() {
+    return this.readCurrentTasks().filter((t) => t.sessionActive);
+  }
+  /** Get a specific session by ID. */
+  getSession(sessionId) {
+    return this.readCurrentTasks().find((t) => t.sessionId === sessionId);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  readAllTasksRaw() {
+    try {
+      if (fs.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+        return Array.isArray(raw) ? [...raw] : [...raw.tasks ?? []];
+      }
+    } catch {
+    }
+    return [];
+  }
+  pruneStale(tasks) {
+    return pruneStaleTasks(tasks);
+  }
+  writeTasksFile(tasks) {
+    const data = { version: 1, tasks };
+    fs.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
+  }
 };
+function generateSessionId(context) {
+  const parts = [
+    context.worktreePath || context.workspaceRoot || "",
+    context.agentLabel || "",
+    context.branch || ""
+  ].filter(Boolean);
+  if (parts.length === 0) {
+    return randomUUID2();
+  }
+  const hash = createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+  return `ses_${hash}`;
+}
 
 // ../../packages/shared/src/decisionStorage.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// ../../packages/shared/src/license.ts
+import crypto from "crypto";
 import fs2 from "fs";
+import os from "os";
 import path3 from "path";
+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 = fs2.readFileSync(filePath, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.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 (!fs2.existsSync(licensePath)) {
+      store = { version: 2, licenses: [] };
+    } else {
+      const raw = fs2.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 (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
+  }
+  const licensePath = path3.join(dirPath, LICENSE_FILE);
+  fs2.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);
+  });
+}
+var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 
 // ../../packages/shared/src/featureGate.ts
 var DefaultFeatureGate = class {
@@ -485,25 +692,25 @@ var MAX_DECISIONS = 100;
 var DecisionStorage = class {
   storagePath;
   decisionsFilePath;
-  constructor(workspacePath2) {
-    const mainRoot = resolveStorageRoot(workspacePath2);
-    this.storagePath = path3.join(mainRoot, STORAGE_DIR2);
-    this.decisionsFilePath = path3.join(this.storagePath, DECISIONS_FILE);
+  constructor(workspacePath) {
+    const mainRoot = resolveStorageRoot(workspacePath);
+    this.storagePath = path4.join(mainRoot, STORAGE_DIR2);
+    this.decisionsFilePath = path4.join(this.storagePath, DECISIONS_FILE);
   }
   ensureStorageDir() {
-    if (!fs2.existsSync(this.storagePath)) {
-      fs2.mkdirSync(this.storagePath, { recursive: true });
+    if (!fs3.existsSync(this.storagePath)) {
+      fs3.mkdirSync(this.storagePath, { recursive: true });
     }
   }
   getProjectName() {
-    return path3.basename(path3.dirname(this.storagePath));
+    return path4.basename(path4.dirname(this.storagePath));
   }
   load() {
     try {
-      if (!fs2.existsSync(this.decisionsFilePath)) {
+      if (!fs3.existsSync(this.decisionsFilePath)) {
         return createEmptyProjectDecisions(this.getProjectName());
       }
-      const raw = fs2.readFileSync(this.decisionsFilePath, "utf-8");
+      const raw = fs3.readFileSync(this.decisionsFilePath, "utf-8");
       const data = JSON.parse(raw);
       return data;
     } catch {
@@ -513,7 +720,7 @@ var DecisionStorage = class {
   save(decisions) {
     this.ensureStorageDir();
     const content = JSON.stringify(decisions, null, 2);
-    fs2.writeFileSync(this.decisionsFilePath, content, "utf-8");
+    fs3.writeFileSync(this.decisionsFilePath, content, "utf-8");
   }
   /**
    * Save a decision record as a draft. Always persists regardless of Pro
@@ -763,68 +970,6 @@ function tryDetectDecision(opts) {
   };
 }
 
-// ../../packages/shared/src/license.ts
-import crypto from "crypto";
-import fs3 from "fs";
-import os from "os";
-import path4 from "path";
-var LICENSE_FILE = "license.json";
-var DEVICE_ID_FILE = "device-id";
-function getGlobalLicenseDir() {
-  return path4.join(os.homedir(), ".keepgoing");
-}
-function getGlobalLicensePath() {
-  return path4.join(getGlobalLicenseDir(), LICENSE_FILE);
-}
-function getDeviceId() {
-  const dir = getGlobalLicenseDir();
-  const filePath = path4.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;
-}
-function readLicenseCache() {
-  const licensePath = getGlobalLicensePath();
-  try {
-    if (!fs3.existsSync(licensePath)) {
-      return void 0;
-    }
-    const raw = fs3.readFileSync(licensePath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-}
-function writeLicenseCache(cache) {
-  const dirPath = getGlobalLicenseDir();
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
-  }
-  const licensePath = path4.join(dirPath, LICENSE_FILE);
-  fs3.writeFileSync(licensePath, JSON.stringify(cache, null, 2), "utf-8");
-}
-function deleteLicenseCache() {
-  const licensePath = getGlobalLicensePath();
-  try {
-    if (fs3.existsSync(licensePath)) {
-      fs3.unlinkSync(licensePath);
-    }
-  } catch {
-  }
-}
-function isCachedLicenseValid(cache) {
-  return cache?.status === "active";
-}
-var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-
 // ../../packages/shared/src/licenseClient.ts
 var BASE_URL = "https://api.lemonsqueezy.com/v1/licenses";
 var REQUEST_TIMEOUT_MS = 15e3;
@@ -875,13 +1020,21 @@ async function activateLicense(licenseKey, instanceName, options) {
         }
         return { valid: false, error: productError };
       }
+      if (data.meta?.variant_id && !KNOWN_VARIANT_IDS.has(data.meta.variant_id)) {
+        if (data.license_key?.key && data.instance?.id) {
+          await deactivateLicense(data.license_key.key, data.instance.id);
+        }
+        return { valid: false, error: "This license key is for an unrecognized add-on variant. Please update KeepGoing or contact support." };
+      }
     }
     return {
       valid: true,
       licenseKey: data.license_key?.key,
       instanceId: data.instance?.id,
       customerName: data.meta?.customer_name,
-      productName: data.meta?.product_name
+      productName: data.meta?.product_name,
+      variantId: data.meta?.variant_id,
+      variantName: data.meta?.variant_name
     };
   } catch (err) {
     const message = err instanceof Error && err.name === "AbortError" ? "Request timed out. Please check your network connection and try again." : err instanceof Error ? err.message : "Network error";
@@ -907,11 +1060,14 @@ async function deactivateLicense(licenseKey, instanceId) {
 }
 
 // src/storage.ts
+import fs4 from "fs";
+import path5 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;
@@ -919,18 +1075,20 @@ var KeepGoingReader = class {
   sessionsFilePath;
   decisionsFilePath;
   stateFilePath;
+  currentTasksFilePath;
   _isWorktree;
   _cachedBranch = null;
   // null = not yet resolved
-  constructor(workspacePath2) {
-    this.workspacePath = workspacePath2;
-    const mainRoot = resolveStorageRoot(workspacePath2);
-    this._isWorktree = mainRoot !== workspacePath2;
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    const mainRoot = resolveStorageRoot(workspacePath);
+    this._isWorktree = mainRoot !== workspacePath;
     this.storagePath = path5.join(mainRoot, STORAGE_DIR3);
     this.metaFilePath = path5.join(this.storagePath, META_FILE2);
     this.sessionsFilePath = path5.join(this.storagePath, SESSIONS_FILE2);
     this.decisionsFilePath = path5.join(this.storagePath, DECISIONS_FILE2);
     this.stateFilePath = path5.join(this.storagePath, STATE_FILE2);
+    this.currentTasksFilePath = path5.join(this.storagePath, CURRENT_TASKS_FILE2);
   }
   /** Check if .keepgoing/ directory exists. */
   exists() {
@@ -992,9 +1150,81 @@ var KeepGoingReader = class {
     const all = this.getDecisions();
     return all.slice(-count).reverse();
   }
-  /** Read cached license data from the global `~/.keepgoing/license.json`. */
-  getLicenseCache() {
-    return readLicenseCache();
+  /** 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) {
@@ -1112,13 +1342,13 @@ var KeepGoingReader = class {
 };
 
 // src/tools/getMomentum.ts
-function registerGetMomentum(server2, reader2, workspacePath2) {
-  server2.tool(
+function registerGetMomentum(server, reader, workspacePath) {
+  server.tool(
     "get_momentum",
     "Get current developer momentum: last checkpoint, next step, blockers, and branch context. Use this to understand where the developer left off.",
     {},
     async () => {
-      if (!reader2.exists()) {
+      if (!reader.exists()) {
         return {
           content: [
             {
@@ -1128,8 +1358,8 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const { session: lastSession, isFallback } = reader2.getScopedLastSession();
-      const currentBranch = reader2.getCurrentBranch();
+      const { session: lastSession, isFallback } = reader.getScopedLastSession();
+      const currentBranch = reader.getCurrentBranch();
       if (!lastSession) {
         return {
           content: [
@@ -1140,13 +1370,13 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const state = reader2.getState();
+      const state = reader.getState();
       const branchChanged = lastSession.gitBranch && currentBranch && lastSession.gitBranch !== currentBranch;
       const lines = [
         `## Developer Momentum`,
         ""
       ];
-      if (reader2.isWorktree && currentBranch) {
+      if (reader.isWorktree && currentBranch) {
         lines.push(`**Worktree context:** Scoped to branch \`${currentBranch}\``);
         if (isFallback) {
           lines.push(`**Note:** No checkpoints found for branch \`${currentBranch}\`. Showing last global checkpoint.`);
@@ -1168,7 +1398,7 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
       if (currentBranch) {
         lines.push(`**Current branch:** ${currentBranch}`);
       }
-      if (branchChanged && !reader2.isWorktree) {
+      if (branchChanged && !reader.isWorktree) {
         lines.push(
           `**Note:** Branch changed since last checkpoint (was \`${lastSession.gitBranch}\`, now \`${currentBranch}\`)`
         );
@@ -1197,8 +1427,8 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
 
 // src/tools/getSessionHistory.ts
 import { z } from "zod";
-function registerGetSessionHistory(server2, reader2) {
-  server2.tool(
+function registerGetSessionHistory(server, reader) {
+  server.tool(
     "get_session_history",
     "Get recent session checkpoints. Returns a chronological list of what the developer worked on.",
     {
@@ -1206,7 +1436,7 @@ function registerGetSessionHistory(server2, reader2) {
       branch: z.string().optional().describe('Filter to a specific branch name, or "all" to show all branches. Auto-detected from worktree context by default.')
     },
     async ({ limit, branch }) => {
-      if (!reader2.exists()) {
+      if (!reader.exists()) {
         return {
           content: [
             {
@@ -1216,8 +1446,8 @@ function registerGetSessionHistory(server2, reader2) {
           ]
         };
       }
-      const { effectiveBranch, scopeLabel } = reader2.resolveBranchScope(branch);
-      const sessions = effectiveBranch ? reader2.getRecentSessionsForBranch(effectiveBranch, limit) : reader2.getRecentSessions(limit);
+      const { effectiveBranch, scopeLabel } = reader.resolveBranchScope(branch);
+      const sessions = effectiveBranch ? reader.getRecentSessionsForBranch(effectiveBranch, limit) : reader.getRecentSessions(limit);
       if (sessions.length === 0) {
         return {
           content: [
@@ -1257,13 +1487,13 @@ function registerGetSessionHistory(server2, reader2) {
 }
 
 // src/tools/getReentryBriefing.ts
-function registerGetReentryBriefing(server2, reader2, workspacePath2) {
-  server2.tool(
+function registerGetReentryBriefing(server, reader, workspacePath) {
+  server.tool(
     "get_reentry_briefing",
     "Get a synthesized re-entry briefing that helps a developer understand where they left off. Includes focus, recent activity, and suggested next steps.",
     {},
     async () => {
-      if (!reader2.exists()) {
+      if (!reader.exists()) {
         return {
           content: [
             {
@@ -1273,12 +1503,12 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const gitBranch = reader2.getCurrentBranch();
-      const { session: lastSession } = reader2.getScopedLastSession();
-      const recentSessions = reader2.getScopedRecentSessions(5);
-      const state = reader2.getState() ?? {};
+      const gitBranch = reader.getCurrentBranch();
+      const { session: lastSession } = reader.getScopedLastSession();
+      const recentSessions = reader.getScopedRecentSessions(5);
+      const state = reader.getState() ?? {};
       const sinceTimestamp = lastSession?.timestamp;
-      const recentCommits = sinceTimestamp ? getCommitMessagesSince(workspacePath2, sinceTimestamp) : [];
+      const recentCommits = sinceTimestamp ? getCommitMessagesSince(workspacePath, sinceTimestamp) : [];
       const briefing = generateBriefing(
         lastSession,
         recentSessions,
@@ -1300,7 +1530,7 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
         `## Re-entry Briefing`,
         ""
       ];
-      if (reader2.isWorktree && gitBranch) {
+      if (reader.isWorktree && gitBranch) {
         lines.push(`**Worktree context:** Scoped to branch \`${gitBranch}\``);
         lines.push("");
       }
@@ -1311,7 +1541,7 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
         `**Suggested next:** ${briefing.suggestedNext}`,
         `**Quick start:** ${briefing.smallNextStep}`
       );
-      const recentDecisions = reader2.getScopedRecentDecisions(3);
+      const recentDecisions = reader.getScopedRecentDecisions(3);
       if (recentDecisions.length > 0) {
         lines.push("");
         lines.push("### Recent decisions");
@@ -1330,8 +1560,8 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
 // src/tools/saveCheckpoint.ts
 import path6 from "path";
 import { z as z2 } from "zod";
-function registerSaveCheckpoint(server2, reader2, workspacePath2) {
-  server2.tool(
+function registerSaveCheckpoint(server, reader, workspacePath) {
+  server.tool(
     "save_checkpoint",
     "Save a development checkpoint. Call this after completing a task or meaningful piece of work, not just at end of session. Each checkpoint helps the next session (or developer) pick up exactly where you left off.",
     {
@@ -1340,11 +1570,12 @@ function registerSaveCheckpoint(server2, reader2, workspacePath2) {
       blocker: z2.string().optional().describe("Any blocker preventing progress")
     },
     async ({ summary, nextStep, blocker }) => {
-      const lastSession = reader2.getLastSession();
-      const gitBranch = getCurrentBranch(workspacePath2);
-      const touchedFiles = getTouchedFiles(workspacePath2);
-      const commitHashes = getCommitsSince(workspacePath2, lastSession?.timestamp);
-      const projectName = path6.basename(resolveStorageRoot(workspacePath2));
+      const lastSession = reader.getLastSession();
+      const gitBranch = getCurrentBranch(workspacePath);
+      const touchedFiles = getTouchedFiles(workspacePath);
+      const commitHashes = getCommitsSince(workspacePath, lastSession?.timestamp);
+      const projectName = path6.basename(resolveStorageRoot(workspacePath));
+      const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
       const checkpoint = createCheckpoint({
         summary,
         nextStep: nextStep || "",
@@ -1352,10 +1583,11 @@ function registerSaveCheckpoint(server2, reader2, workspacePath2) {
         gitBranch,
         touchedFiles,
         commitHashes,
-        workspaceRoot: workspacePath2,
-        source: "manual"
+        workspaceRoot: workspacePath,
+        source: "manual",
+        sessionId
       });
-      const writer = new KeepGoingWriter(workspacePath2);
+      const writer = new KeepGoingWriter(workspacePath);
       writer.saveCheckpoint(checkpoint, projectName);
       const lines = [
         `Checkpoint saved.`,
@@ -1365,11 +1597,11 @@ function registerSaveCheckpoint(server2, reader2, workspacePath2) {
         `- **Commits captured:** ${commitHashes.length}`
       ];
       if (commitHashes.length > 0) {
-        const commitMessages = getCommitMessagesSince(workspacePath2, lastSession?.timestamp);
-        const headHash = getHeadCommitHash(workspacePath2);
+        const commitMessages = getCommitMessagesSince(workspacePath, lastSession?.timestamp);
+        const headHash = getHeadCommitHash(workspacePath);
         if (commitMessages.length > 0 && headHash) {
           const detected = tryDetectDecision({
-            workspacePath: workspacePath2,
+            workspacePath,
             checkpointId: checkpoint.id,
             gitBranch,
             commitHash: headHash,
@@ -1390,8 +1622,8 @@ function registerSaveCheckpoint(server2, reader2, workspacePath2) {
 
 // src/tools/getDecisions.ts
 import { z as z3 } from "zod";
-function registerGetDecisions(server2, reader2) {
-  server2.tool(
+function registerGetDecisions(server, reader) {
+  server.tool(
     "get_decisions",
     "Get recent decision records. Returns detected high-signal commits with their category, confidence, and rationale.",
     {
@@ -1399,7 +1631,7 @@ function registerGetDecisions(server2, reader2) {
       branch: z3.string().optional().describe('Filter to a specific branch name, or "all" to show all branches. Auto-detected from worktree context by default.')
     },
     async ({ limit, branch }) => {
-      if (!reader2.exists()) {
+      if (!reader.exists()) {
         return {
           content: [
             {
@@ -1409,8 +1641,7 @@ function registerGetDecisions(server2, reader2) {
           ]
         };
       }
-      const licenseCache = reader2.getLicenseCache();
-      if (!isCachedLicenseValid(licenseCache)) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
         return {
           content: [
             {
@@ -1420,8 +1651,8 @@ function registerGetDecisions(server2, reader2) {
           ]
         };
       }
-      const { effectiveBranch, scopeLabel } = reader2.resolveBranchScope(branch);
-      const decisions = effectiveBranch ? reader2.getRecentDecisionsForBranch(effectiveBranch, limit) : reader2.getRecentDecisions(limit);
+      const { effectiveBranch, scopeLabel } = reader.resolveBranchScope(branch);
+      const decisions = effectiveBranch ? reader.getRecentDecisionsForBranch(effectiveBranch, limit) : reader.getRecentDecisions(limit);
       if (decisions.length === 0) {
         return {
           content: [
@@ -1459,8 +1690,104 @@ function registerGetDecisions(server2, reader2) {
   );
 }
 
+// src/tools/getCurrentTask.ts
+function registerGetCurrentTask(server, reader) {
+  server.tool(
+    "get_current_task",
+    "Get current live session tasks. Shows all active AI agent sessions, what each is doing, last files edited, and next steps. Supports multiple concurrent sessions.",
+    {},
+    async () => {
+      if (!reader.exists()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found."
+            }
+          ]
+        };
+      }
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Session Awareness requires a license. Use the activate_license tool, run `keepgoing activate <key>` in your terminal, or visit https://keepgoing.dev/add-ons to purchase."
+            }
+          ]
+        };
+      }
+      const tasks = reader.getCurrentTasks();
+      if (tasks.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No current task data found. The agent has not started writing session data yet."
+            }
+          ]
+        };
+      }
+      const activeTasks = tasks.filter((t) => t.sessionActive);
+      const finishedTasks = tasks.filter((t) => !t.sessionActive);
+      const lines = [];
+      const totalActive = activeTasks.length;
+      const totalFinished = finishedTasks.length;
+      if (totalActive > 0 || totalFinished > 0) {
+        const parts = [];
+        if (totalActive > 0) parts.push(`${totalActive} active`);
+        if (totalFinished > 0) parts.push(`${totalFinished} finished`);
+        lines.push(`## Live Sessions (${parts.join(", ")})`);
+        lines.push("");
+      }
+      for (const task of [...activeTasks, ...finishedTasks]) {
+        const statusIcon = task.sessionActive ? "\u{1F7E2}" : "\u2705";
+        const statusLabel = task.sessionActive ? "Active" : "Finished";
+        const sessionLabel = task.agentLabel || task.sessionId || "Session";
+        lines.push(`### ${statusIcon} ${sessionLabel} (${statusLabel})`);
+        lines.push(`- **Updated:** ${formatRelativeTime(task.updatedAt)}`);
+        if (task.branch) {
+          lines.push(`- **Branch:** ${task.branch}`);
+        }
+        if (task.taskSummary) {
+          lines.push(`- **Doing:** ${task.taskSummary}`);
+        }
+        if (task.lastFileEdited) {
+          lines.push(`- **Last file:** ${task.lastFileEdited}`);
+        }
+        if (task.nextStep) {
+          lines.push(`- **Next step:** ${task.nextStep}`);
+        }
+        lines.push("");
+      }
+      const conflicts = reader.detectFileConflicts();
+      if (conflicts.length > 0) {
+        lines.push("### \u26A0\uFE0F Potential Conflicts");
+        for (const conflict of conflicts) {
+          const sessionLabels = conflict.sessions.map((s) => s.agentLabel || s.sessionId || "unknown").join(", ");
+          lines.push(`- **${conflict.file}** is being edited by: ${sessionLabels}`);
+        }
+        lines.push("");
+      }
+      const overlaps = reader.detectBranchOverlap();
+      if (overlaps.length > 0) {
+        lines.push("### \u2139\uFE0F Branch Overlap");
+        for (const overlap of overlaps) {
+          const sessionLabels = overlap.sessions.map((s) => s.agentLabel || s.sessionId || "unknown").join(", ");
+          lines.push(`- **${overlap.branch}**: ${sessionLabels} (possible duplicate work)`);
+        }
+        lines.push("");
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
 // src/tools/setupProject.ts
 import fs5 from "fs";
+import os2 from "os";
 import path7 from "path";
 import { z as z4 } from "zod";
 var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
@@ -1482,6 +1809,15 @@ var STOP_HOOK = {
     }
   ]
 };
+var POST_TOOL_USE_HOOK = {
+  matcher: "Edit|Write|MultiEdit",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --update-task-from-hook"
+    }
+  ]
+};
 var CLAUDE_MD_SECTION = `
 ## KeepGoing
 
@@ -1495,8 +1831,8 @@ function hasKeepGoingHook(hookEntries) {
     (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
   );
 }
-function registerSetupProject(server2, workspacePath2) {
-  server2.tool(
+function registerSetupProject(server, workspacePath) {
+  server.tool(
     "setup_project",
     "Set up KeepGoing in the current project. Adds session hooks to .claude/settings.json and CLAUDE.md instructions so checkpoints are saved automatically.",
     {
@@ -1505,44 +1841,80 @@ function registerSetupProject(server2, workspacePath2) {
     },
     async ({ sessionHooks, claudeMd }) => {
       const results = [];
+      const claudeDir = path7.join(workspacePath, ".claude");
+      const settingsPath = path7.join(claudeDir, "settings.json");
+      let settings = {};
+      if (fs5.existsSync(settingsPath)) {
+        settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+      }
+      let settingsChanged = false;
       if (sessionHooks) {
-        const claudeDir = path7.join(workspacePath2, ".claude");
-        const settingsPath = path7.join(claudeDir, "settings.json");
-        let settings = {};
-        if (fs5.existsSync(settingsPath)) {
-          settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
-        }
         if (!settings.hooks) {
           settings.hooks = {};
         }
-        let hooksChanged = false;
         if (!Array.isArray(settings.hooks.SessionStart)) {
           settings.hooks.SessionStart = [];
         }
         if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
           settings.hooks.SessionStart.push(SESSION_START_HOOK);
-          hooksChanged = true;
+          settingsChanged = true;
         }
         if (!Array.isArray(settings.hooks.Stop)) {
           settings.hooks.Stop = [];
         }
         if (!hasKeepGoingHook(settings.hooks.Stop)) {
           settings.hooks.Stop.push(STOP_HOOK);
-          hooksChanged = true;
+          settingsChanged = true;
         }
-        if (hooksChanged) {
-          if (!fs5.existsSync(claudeDir)) {
-            fs5.mkdirSync(claudeDir, { recursive: true });
-          }
-          fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        if (!Array.isArray(settings.hooks.PostToolUse)) {
+          settings.hooks.PostToolUse = [];
+        }
+        if (!hasKeepGoingHook(settings.hooks.PostToolUse)) {
+          settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
+          settingsChanged = true;
+        }
+        if (settingsChanged) {
           results.push("**Session hooks:** Added to `.claude/settings.json`");
         } else {
           results.push("**Session hooks:** Already present, skipped");
         }
       }
+      if (process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("session-awareness")) {
+        const statuslineSrc = path7.resolve(
+          new URL(".", import.meta.url).pathname,
+          "statusline.sh"
+        );
+        const claudeHome = path7.join(os2.homedir(), ".claude");
+        const statuslineDest = path7.join(claudeHome, "keepgoing-statusline.sh");
+        if (fs5.existsSync(statuslineSrc)) {
+          if (!fs5.existsSync(claudeHome)) {
+            fs5.mkdirSync(claudeHome, { recursive: true });
+          }
+          fs5.copyFileSync(statuslineSrc, statuslineDest);
+          fs5.chmodSync(statuslineDest, 493);
+          if (!settings.statusLine) {
+            settings.statusLine = {
+              type: "command",
+              command: statuslineDest
+            };
+            settingsChanged = true;
+            results.push("**Statusline:** Installed `keepgoing-statusline.sh` and added to `.claude/settings.json`");
+          } else {
+            results.push("**Statusline:** `statusLine` already configured in settings, skipped");
+          }
+        } else {
+          results.push("**Statusline:** Script not found in package, skipped");
+        }
+      }
+      if (settingsChanged) {
+        if (!fs5.existsSync(claudeDir)) {
+          fs5.mkdirSync(claudeDir, { recursive: true });
+        }
+        fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      }
       if (claudeMd) {
-        const dotClaudeMdPath = path7.join(workspacePath2, ".claude", "CLAUDE.md");
-        const rootClaudeMdPath = path7.join(workspacePath2, "CLAUDE.md");
+        const dotClaudeMdPath = path7.join(workspacePath, ".claude", "CLAUDE.md");
+        const rootClaudeMdPath = path7.join(workspacePath, "CLAUDE.md");
         const claudeMdPath = fs5.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath;
         let existing = "";
         if (fs5.existsSync(claudeMdPath)) {
@@ -1565,20 +1937,24 @@ function registerSetupProject(server2, workspacePath2) {
 
 // src/tools/activateLicense.ts
 import { z as z5 } from "zod";
-function registerActivateLicense(server2) {
-  server2.tool(
+function registerActivateLicense(server) {
+  server.tool(
     "activate_license",
-    "Activate a KeepGoing Pro license on this device. Unlocks Decision Detection and future Pro features.",
+    "Activate a KeepGoing Pro license on this device. Unlocks add-ons like Decision Detection and Session Awareness.",
     { license_key: z5.string().describe("Your KeepGoing Pro license key") },
     async ({ license_key }) => {
-      const existing = readLicenseCache();
-      if (isCachedLicenseValid(existing)) {
-        const who2 = existing.customerName ? ` (${existing.customerName})` : "";
+      const store = readLicenseStore();
+      const existingForKey = store.licenses.find(
+        (l) => l.status === "active" && l.licenseKey === license_key
+      );
+      if (existingForKey) {
+        const label2 = getVariantLabel(existingForKey.variantId);
+        const who2 = existingForKey.customerName ? ` (${existingForKey.customerName})` : "";
         return {
           content: [
             {
               type: "text",
-              text: `Pro license is already active${who2}. No action needed.`
+              text: `${label2} is already active${who2}. No action needed.`
             }
           ]
         };
@@ -1594,22 +1970,43 @@ function registerActivateLicense(server2) {
           ]
         };
       }
+      const variantId = result.variantId;
+      const existingForVariant = store.licenses.find(
+        (l) => l.status === "active" && l.variantId === variantId
+      );
+      if (existingForVariant) {
+        const label2 = getVariantLabel(variantId);
+        const who2 = existingForVariant.customerName ? ` (${existingForVariant.customerName})` : "";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${label2} is already active${who2}. No action needed.`
+            }
+          ]
+        };
+      }
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      writeLicenseCache({
+      addLicenseEntry({
         licenseKey: result.licenseKey || license_key,
         instanceId: result.instanceId || getDeviceId(),
         status: "active",
         lastValidatedAt: now,
         activatedAt: now,
+        variantId,
         customerName: result.customerName,
-        productName: result.productName
+        productName: result.productName,
+        variantName: result.variantName
       });
+      const label = getVariantLabel(variantId);
+      const features = VARIANT_FEATURE_MAP[variantId];
+      const featureList = features ? features.join(", ") : "Pro features";
       const who = result.customerName ? ` Welcome, ${result.customerName}!` : "";
       return {
         content: [
           {
             type: "text",
-            text: `Pro license activated successfully.${who} Decision Detection is now enabled.`
+            text: `${label} activated successfully.${who} Enabled: ${featureList}.`
           }
         ]
       };
@@ -1618,14 +2015,18 @@ function registerActivateLicense(server2) {
 }
 
 // src/tools/deactivateLicense.ts
-function registerDeactivateLicense(server2) {
-  server2.tool(
+import { z as z6 } from "zod";
+function registerDeactivateLicense(server) {
+  server.tool(
     "deactivate_license",
     "Deactivate the KeepGoing Pro license on this device.",
-    {},
-    async () => {
-      const cache = readLicenseCache();
-      if (!cache) {
+    {
+      license_key: z6.string().optional().describe("Specific license key to deactivate. If omitted and only one license is active, deactivates it. If multiple are active, lists them.")
+    },
+    async ({ license_key }) => {
+      const store = readLicenseStore();
+      const activeLicenses = store.licenses.filter((l) => l.status === "active");
+      if (activeLicenses.length === 0) {
         return {
           content: [
             {
@@ -1635,14 +2036,41 @@ function registerDeactivateLicense(server2) {
           ]
         };
       }
-      const result = await deactivateLicense(cache.licenseKey, cache.instanceId);
-      deleteLicenseCache();
+      let target;
+      if (license_key) {
+        target = activeLicenses.find((l) => l.licenseKey === license_key);
+        if (!target) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No active license found with key "${license_key}".`
+              }
+            ]
+          };
+        }
+      } else if (activeLicenses.length === 1) {
+        target = activeLicenses[0];
+      } else {
+        const lines = ["Multiple active licenses found. Please specify which to deactivate using the license_key parameter:", ""];
+        for (const l of activeLicenses) {
+          const label2 = getVariantLabel(l.variantId);
+          const who = l.customerName ? ` (${l.customerName})` : "";
+          lines.push(`- ${label2}${who}: ${l.licenseKey}`);
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      }
+      const result = await deactivateLicense(target.licenseKey, target.instanceId);
+      removeLicenseEntry(target.licenseKey);
+      const label = getVariantLabel(target.variantId);
       if (!result.deactivated) {
         return {
           content: [
             {
               type: "text",
-              text: `License cleared locally, but remote deactivation failed: ${result.error ?? "unknown error"}`
+              text: `${label} license cleared locally, but remote deactivation failed: ${result.error ?? "unknown error"}`
             }
           ]
         };
@@ -1651,7 +2079,7 @@ function registerDeactivateLicense(server2) {
         content: [
           {
             type: "text",
-            text: "Pro license deactivated successfully. The activation slot has been freed."
+            text: `${label} license deactivated successfully. The activation slot has been freed.`
           }
         ]
       };
@@ -1660,8 +2088,8 @@ function registerDeactivateLicense(server2) {
 }
 
 // src/prompts/resume.ts
-function registerResumePrompt(server2) {
-  server2.prompt(
+function registerResumePrompt(server) {
+  server.prompt(
     "resume",
     "Check developer momentum and suggest what to work on next",
     async () => ({
@@ -1688,8 +2116,8 @@ function registerResumePrompt(server2) {
 }
 
 // src/prompts/decisions.ts
-function registerDecisionsPrompt(server2) {
-  server2.prompt(
+function registerDecisionsPrompt(server) {
+  server.prompt(
     "decisions",
     "Review recent architectural decisions and their rationale",
     async () => ({
@@ -1716,8 +2144,8 @@ function registerDecisionsPrompt(server2) {
 }
 
 // src/prompts/progress.ts
-function registerProgressPrompt(server2) {
-  server2.prompt(
+function registerProgressPrompt(server) {
+  server.prompt(
     "progress",
     "Summarize recent development progress across sessions",
     async () => ({
@@ -1743,14 +2171,20 @@ function registerProgressPrompt(server2) {
   );
 }
 
-// src/index.ts
-if (process.argv.includes("--print-momentum")) {
-  const wsPath = findGitRoot(process.argv.slice(2).find((a) => a !== "--print-momentum") || process.cwd());
-  const reader2 = new KeepGoingReader(wsPath);
-  if (!reader2.exists()) {
+// src/cli/util.ts
+function resolveWsPath(args = process.argv.slice(2)) {
+  const explicit = args.find((a) => !a.startsWith("--"));
+  return findGitRoot(explicit || process.cwd());
+}
+
+// src/cli/print.ts
+async function handlePrintMomentum() {
+  const wsPath = resolveWsPath();
+  const reader = new KeepGoingReader(wsPath);
+  if (!reader.exists()) {
     process.exit(0);
   }
-  const { session: lastSession } = reader2.getScopedLastSession();
+  const { session: lastSession } = reader.getScopedLastSession();
   if (!lastSession) {
     process.exit(0);
   }
@@ -1776,10 +2210,49 @@ if (process.argv.includes("--print-momentum")) {
   console.log(lines.join("\n"));
   process.exit(0);
 }
-if (process.argv.includes("--save-checkpoint")) {
-  const wsPath = findGitRoot(process.argv.slice(2).find((a) => !a.startsWith("--")) || process.cwd());
-  const reader2 = new KeepGoingReader(wsPath);
-  const { session: lastSession } = reader2.getScopedLastSession();
+async function handlePrintCurrent() {
+  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+    process.exit(0);
+  }
+  const wsPath = resolveWsPath();
+  const reader = new KeepGoingReader(wsPath);
+  const tasks = reader.getCurrentTasks();
+  if (tasks.length === 0) {
+    process.exit(0);
+  }
+  const activeTasks = tasks.filter((t) => t.sessionActive);
+  const finishedTasks = tasks.filter((t) => !t.sessionActive);
+  if (tasks.length > 1) {
+    const parts = [];
+    if (activeTasks.length > 0) parts.push(`${activeTasks.length} active`);
+    if (finishedTasks.length > 0) parts.push(`${finishedTasks.length} finished`);
+    console.log(`[KeepGoing] Sessions: ${parts.join(", ")}`);
+  }
+  for (const task of [...activeTasks, ...finishedTasks]) {
+    const prefix = task.sessionActive ? "[KeepGoing] Current task:" : "[KeepGoing] \u2705 Last task:";
+    const sessionLabel = task.agentLabel || task.sessionId || "";
+    const labelSuffix = sessionLabel ? ` (${sessionLabel})` : "";
+    const lines = [`${prefix} ${formatRelativeTime(task.updatedAt)}${labelSuffix}`];
+    if (task.branch) {
+      lines.push(`  Branch: ${task.branch}`);
+    }
+    if (task.taskSummary) {
+      lines.push(`  Doing: ${task.taskSummary}`);
+    }
+    if (task.nextStep) {
+      lines.push(`  Next: ${task.nextStep}`);
+    }
+    console.log(lines.join("\n"));
+  }
+  process.exit(0);
+}
+
+// src/cli/saveCheckpoint.ts
+import path8 from "path";
+async function handleSaveCheckpoint() {
+  const wsPath = resolveWsPath();
+  const reader = new KeepGoingReader(wsPath);
+  const { session: lastSession } = reader.getScopedLastSession();
   if (lastSession?.timestamp) {
     const ageMs = Date.now() - new Date(lastSession.timestamp).getTime();
     if (ageMs < 2 * 60 * 1e3) {
@@ -1804,6 +2277,7 @@ if (process.argv.includes("--save-checkpoint")) {
     }
   }
   const projectName = path8.basename(resolveStorageRoot(wsPath));
+  const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
   const checkpoint = createCheckpoint({
     summary,
     nextStep: "",
@@ -1811,12 +2285,19 @@ if (process.argv.includes("--save-checkpoint")) {
     touchedFiles,
     commitHashes,
     workspaceRoot: wsPath,
-    source: "auto"
+    source: "auto",
+    sessionId
   });
   const writer = new KeepGoingWriter(wsPath);
   writer.saveCheckpoint(checkpoint, projectName);
-  const licenseCache = readLicenseCache();
-  if (isCachedLicenseValid(licenseCache) && commitMessages.length > 0) {
+  writer.upsertSession({
+    sessionId,
+    sessionActive: false,
+    nextStep: checkpoint.nextStep || void 0,
+    branch: gitBranch ?? void 0,
+    updatedAt: checkpoint.timestamp
+  });
+  if ((process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("decisions")) && commitMessages.length > 0) {
     const headHash = getHeadCommitHash(wsPath) || commitHashes[0];
     if (headHash) {
       const detected = tryDetectDecision({
@@ -1835,24 +2316,109 @@ if (process.argv.includes("--save-checkpoint")) {
   console.log(`[KeepGoing] Auto-checkpoint saved: ${summary}`);
   process.exit(0);
 }
-var workspacePath = findGitRoot(process.argv[2] || process.cwd());
-var reader = new KeepGoingReader(workspacePath);
-var server = new McpServer({
-  name: "keepgoing",
-  version: "0.1.0"
-});
-registerGetMomentum(server, reader, workspacePath);
-registerGetSessionHistory(server, reader);
-registerGetReentryBriefing(server, reader, workspacePath);
-registerGetDecisions(server, reader);
-registerSaveCheckpoint(server, reader, workspacePath);
-registerSetupProject(server, workspacePath);
-registerActivateLicense(server);
-registerDeactivateLicense(server);
-registerResumePrompt(server);
-registerDecisionsPrompt(server);
-registerProgressPrompt(server);
-var transport = new StdioServerTransport();
-await server.connect(transport);
-console.error("KeepGoing MCP server started");
+
+// src/cli/updateTask.ts
+async function handleUpdateTask() {
+  const args = process.argv.slice(2);
+  const flagIndex = args.indexOf("--update-task");
+  const payloadStr = args[flagIndex + 1];
+  const wsArgs = args.filter((a, i) => !a.startsWith("--") && i !== flagIndex + 1);
+  const wsPath = resolveWsPath(wsArgs.length > 0 ? wsArgs : void 0);
+  if (payloadStr) {
+    try {
+      const payload = JSON.parse(payloadStr);
+      const writer = new KeepGoingWriter(wsPath);
+      const branch = payload.branch ?? getCurrentBranch(wsPath) ?? void 0;
+      const task = {
+        ...payload,
+        branch,
+        worktreePath: wsPath,
+        sessionActive: payload.sessionActive !== false,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const sessionId = payload.sessionId || generateSessionId({ ...task, workspaceRoot: wsPath });
+      task.sessionId = sessionId;
+      writer.upsertSession(task);
+    } catch {
+    }
+  }
+  process.exit(0);
+}
+var STDIN_TIMEOUT_MS = 5e3;
+async function handleUpdateTaskFromHook() {
+  const wsPath = resolveWsPath();
+  const chunks = [];
+  const timeout = setTimeout(() => process.exit(0), STDIN_TIMEOUT_MS);
+  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 toolName = hookData.tool_name ?? "Edit";
+      const filePath = hookData.tool_input?.file_path ?? hookData.tool_input?.path ?? "";
+      const fileName = filePath ? filePath.split("/").pop() ?? filePath : "";
+      const writer = new KeepGoingWriter(wsPath);
+      const existing = writer.readCurrentTasks();
+      const cachedBranch = existing.find((t) => t.sessionActive && t.worktreePath === wsPath)?.branch;
+      const branch = cachedBranch ?? getCurrentBranch(wsPath) ?? void 0;
+      const task = {
+        taskSummary: fileName ? `${toolName} ${fileName}` : `Used ${toolName}`,
+        lastFileEdited: filePath || void 0,
+        branch,
+        worktreePath: wsPath,
+        sessionActive: true,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const sessionId = hookData.session_id || generateSessionId({ ...task, workspaceRoot: wsPath });
+      task.sessionId = sessionId;
+      writer.upsertSession(task);
+    } catch {
+    }
+    process.exit(0);
+  });
+  process.stdin.resume();
+}
+
+// src/index.ts
+var CLI_HANDLERS = {
+  "--print-momentum": handlePrintMomentum,
+  "--save-checkpoint": handleSaveCheckpoint,
+  "--update-task": handleUpdateTask,
+  "--update-task-from-hook": handleUpdateTaskFromHook,
+  "--print-current": handlePrintCurrent
+};
+var flag = process.argv.slice(2).find((a) => a in CLI_HANDLERS);
+if (flag) {
+  await CLI_HANDLERS[flag]();
+} else {
+  const workspacePath = findGitRoot(process.argv[2] || process.cwd());
+  const reader = new KeepGoingReader(workspacePath);
+  const server = new McpServer({
+    name: "keepgoing",
+    version: "0.1.0"
+  });
+  registerGetMomentum(server, reader, workspacePath);
+  registerGetSessionHistory(server, reader);
+  registerGetReentryBriefing(server, reader, workspacePath);
+  registerGetDecisions(server, reader);
+  registerGetCurrentTask(server, reader);
+  registerSaveCheckpoint(server, reader, workspacePath);
+  registerSetupProject(server, workspacePath);
+  registerActivateLicense(server);
+  registerDeactivateLicense(server);
+  registerResumePrompt(server);
+  registerDecisionsPrompt(server);
+  registerProgressPrompt(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("KeepGoing MCP server started");
+}
 //# sourceMappingURL=index.js.map