@keepgoingdev/mcp-server 0.3.1 → 0.5.0

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() {
@@ -80,14 +75,12 @@ import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function findGitRoot(startPath) {
   try {
-    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+    const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: startPath,
       encoding: "utf-8",
       timeout: 5e3
     }).trim();
-    if (!gitCommonDir) return startPath;
-    const absoluteGitDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(startPath, gitCommonDir);
-    return path.dirname(absoluteGitDir);
+    return toplevel || startPath;
   } catch {
     return startPath;
   }
@@ -118,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
     });
@@ -130,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
       }
@@ -150,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
     });
@@ -168,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
     });
@@ -387,22 +380,34 @@ 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) => {
+    if (t.sessionActive) return true;
+    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)) {
@@ -463,11 +468,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 {
@@ -487,25 +693,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 {
@@ -515,15 +721,14 @@ 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. Returns true if saved, false if gated or error.
+   * Save a decision record as a draft. Always persists regardless of Pro
+   * status so decisions are captured at the correct time. Returns true if
+   * saved, false on I/O error.
    */
   saveDecision(decision) {
-    if (!isDecisionsEnabled()) {
-      return false;
-    }
     const data = this.load();
     data.decisions.push(decision);
     data.lastDecisionId = decision.id;
@@ -766,128 +971,125 @@ 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;
-  }
+// ../../packages/shared/src/licenseClient.ts
+var BASE_URL = "https://api.lemonsqueezy.com/v1/licenses";
+var REQUEST_TIMEOUT_MS = 15e3;
+var EXPECTED_STORE_ID = 301555;
+var EXPECTED_PRODUCT_ID = 864311;
+function fetchWithTimeout(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timer));
 }
-function writeLicenseCache(cache) {
-  const dirPath = getGlobalLicenseDir();
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
+function validateProductIdentity(meta) {
+  if (!meta) return "License response missing product metadata.";
+  if (meta.store_id !== EXPECTED_STORE_ID || meta.product_id !== EXPECTED_PRODUCT_ID) {
+    return "This license key does not belong to KeepGoing.";
   }
-  const licensePath = path4.join(dirPath, LICENSE_FILE);
-  fs3.writeFileSync(licensePath, JSON.stringify(cache, null, 2), "utf-8");
+  return void 0;
 }
-function deleteLicenseCache() {
-  const licensePath = getGlobalLicensePath();
+async function safeJson(res) {
   try {
-    if (fs3.existsSync(licensePath)) {
-      fs3.unlinkSync(licensePath);
-    }
+    const text = await res.text();
+    return JSON.parse(text);
   } catch {
+    return null;
   }
 }
-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";
-async function activateLicense(licenseKey, instanceName) {
+async function activateLicense(licenseKey, instanceName, options) {
   try {
-    const res = await fetch(`${BASE_URL}/activate`, {
+    const res = await fetchWithTimeout(`${BASE_URL}/activate`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({ license_key: licenseKey, instance_name: instanceName })
     });
-    const data = await res.json();
-    if (!res.ok || !data.activated) {
-      return { valid: false, error: data.error || `Activation failed (${res.status})` };
+    const data = await safeJson(res);
+    if (!res.ok || !data?.activated) {
+      return { valid: false, error: data?.error || `Activation failed (${res.status})` };
+    }
+    if (!options?.allowTestMode && data.license_key?.test_mode) {
+      if (data.license_key?.key && data.instance?.id) {
+        await deactivateLicense(data.license_key.key, data.instance.id);
+      }
+      return { valid: false, error: "This is a test license key. Please use a production license key from your purchase confirmation." };
+    }
+    if (!options?.allowTestMode) {
+      const productError = validateProductIdentity(data.meta);
+      if (productError) {
+        if (data.license_key?.key && data.instance?.id) {
+          await deactivateLicense(data.license_key.key, data.instance.id);
+        }
+        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) {
-    return { valid: false, error: err instanceof Error ? err.message : "Network error" };
+    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";
+    return { valid: false, error: message };
   }
 }
 async function deactivateLicense(licenseKey, instanceId) {
   try {
-    const res = await fetch(`${BASE_URL}/deactivate`, {
+    const res = await fetchWithTimeout(`${BASE_URL}/deactivate`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({ license_key: licenseKey, instance_id: instanceId })
     });
-    const data = await res.json();
-    if (!res.ok || !data.deactivated) {
-      return { deactivated: false, error: data.error || `Deactivation failed (${res.status})` };
+    const data = await safeJson(res);
+    if (!res.ok || !data?.deactivated) {
+      return { deactivated: false, error: data?.error || `Deactivation failed (${res.status})` };
     }
     return { deactivated: true };
   } catch (err) {
-    return { deactivated: false, error: err instanceof Error ? err.message : "Network error" };
+    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";
+    return { deactivated: false, error: message };
   }
 }
 
 // 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;
   metaFilePath;
   sessionsFilePath;
   decisionsFilePath;
   stateFilePath;
-  constructor(workspacePath2) {
-    const mainRoot = resolveStorageRoot(workspacePath2);
+  currentTasksFilePath;
+  _isWorktree;
+  _cachedBranch = null;
+  // null = not yet resolved
+  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() {
@@ -949,9 +1151,160 @@ 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) {
+    const sessions = this.getSessions().filter((s) => s.gitBranch === branch);
+    return sessions.length > 0 ? sessions[sessions.length - 1] : void 0;
+  }
+  /** Returns the last N sessions for a specific branch, newest first. */
+  getRecentSessionsForBranch(branch, count) {
+    const filtered = this.getSessions().filter((s) => s.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Returns the last N decisions for a specific branch, newest first. */
+  getRecentDecisionsForBranch(branch, count) {
+    const filtered = this.getDecisions().filter((d) => d.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Whether the workspace is inside a git worktree. */
+  get isWorktree() {
+    return this._isWorktree;
+  }
+  /**
+   * Returns the current git branch for this workspace.
+   * Lazily cached: the branch is resolved once per KeepGoingReader instance.
+   */
+  getCurrentBranch() {
+    if (this._cachedBranch === null) {
+      this._cachedBranch = getCurrentBranch(this.workspacePath);
+    }
+    return this._cachedBranch;
+  }
+  /**
+   * Worktree-aware last session lookup.
+   * In a worktree, scopes to the current branch with fallback to global.
+   * Returns the session and whether it fell back to global.
+   */
+  getScopedLastSession() {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      const scoped = this.getLastSessionForBranch(branch);
+      if (scoped) return { session: scoped, isFallback: false };
+      return { session: this.getLastSession(), isFallback: true };
+    }
+    return { session: this.getLastSession(), isFallback: false };
+  }
+  /** Worktree-aware recent sessions. Scopes to current branch in a worktree. */
+  getScopedRecentSessions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentSessionsForBranch(branch, count);
+    }
+    return this.getRecentSessions(count);
+  }
+  /** Worktree-aware recent decisions. Scopes to current branch in a worktree. */
+  getScopedRecentDecisions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentDecisionsForBranch(branch, count);
+    }
+    return this.getRecentDecisions(count);
+  }
+  /**
+   * Resolves branch scope from an explicit `branch` parameter.
+   * Used by tools that accept a `branch` argument (e.g. get_session_history, get_decisions).
+   * - `"all"` returns no filter.
+   * - An explicit branch name uses that.
+   * - `undefined` auto-scopes to the current branch in a worktree, or all branches otherwise.
+   */
+  resolveBranchScope(branch) {
+    if (branch === "all") {
+      return { effectiveBranch: void 0, scopeLabel: "all branches" };
+    }
+    if (branch) {
+      return { effectiveBranch: branch, scopeLabel: `branch \`${branch}\`` };
+    }
+    const currentBranch = this.getCurrentBranch();
+    if (this._isWorktree && currentBranch) {
+      return { effectiveBranch: currentBranch, scopeLabel: `branch \`${currentBranch}\` (worktree)` };
+    }
+    return { effectiveBranch: void 0, scopeLabel: "all branches" };
   }
   /**
    * Parses sessions.json once, returning both the session list
@@ -990,13 +1343,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: [
             {
@@ -1006,7 +1359,8 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const lastSession = reader2.getLastSession();
+      const { session: lastSession, isFallback } = reader.getScopedLastSession();
+      const currentBranch = reader.getCurrentBranch();
       if (!lastSession) {
         return {
           content: [
@@ -1017,16 +1371,24 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const state = reader2.getState();
-      const currentBranch = getCurrentBranch(workspacePath2);
+      const state = reader.getState();
       const branchChanged = lastSession.gitBranch && currentBranch && lastSession.gitBranch !== currentBranch;
       const lines = [
         `## Developer Momentum`,
-        "",
+        ""
+      ];
+      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.`);
+        }
+        lines.push("");
+      }
+      lines.push(
         `**Last checkpoint:** ${formatRelativeTime(lastSession.timestamp)}`,
         `**Summary:** ${lastSession.summary || "No summary"}`,
         `**Next step:** ${lastSession.nextStep || "Not specified"}`
-      ];
+      );
       if (lastSession.blocker) {
         lines.push(`**Blocker:** ${lastSession.blocker}`);
       }
@@ -1037,7 +1399,7 @@ function registerGetMomentum(server2, reader2, workspacePath2) {
       if (currentBranch) {
         lines.push(`**Current branch:** ${currentBranch}`);
       }
-      if (branchChanged) {
+      if (branchChanged && !reader.isWorktree) {
         lines.push(
           `**Note:** Branch changed since last checkpoint (was \`${lastSession.gitBranch}\`, now \`${currentBranch}\`)`
         );
@@ -1066,13 +1428,16 @@ 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.",
-    { limit: z.number().min(1).max(50).default(5).describe("Number of recent sessions to return (1-50, default 5)") },
-    async ({ limit }) => {
-      if (!reader2.exists()) {
+    {
+      limit: z.number().min(1).max(50).default(5).describe("Number of recent sessions to return (1-50, default 5)"),
+      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 (!reader.exists()) {
         return {
           content: [
             {
@@ -1082,19 +1447,20 @@ function registerGetSessionHistory(server2, reader2) {
           ]
         };
       }
-      const sessions = 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: [
             {
               type: "text",
-              text: "No session checkpoints found."
+              text: effectiveBranch ? `No session checkpoints found for branch \`${effectiveBranch}\`. Use branch: "all" to see all branches.` : "No session checkpoints found."
             }
           ]
         };
       }
       const lines = [
-        `## Session History (last ${sessions.length})`,
+        `## Session History (last ${sessions.length}, ${scopeLabel})`,
         ""
       ];
       for (const session of sessions) {
@@ -1122,13 +1488,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: [
             {
@@ -1138,12 +1504,12 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
           ]
         };
       }
-      const lastSession = reader2.getLastSession();
-      const recentSessions = reader2.getRecentSessions(5);
-      const state = reader2.getState() ?? {};
-      const gitBranch = getCurrentBranch(workspacePath2);
+      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,
@@ -1163,14 +1529,20 @@ function registerGetReentryBriefing(server2, reader2, workspacePath2) {
       }
       const lines = [
         `## Re-entry Briefing`,
-        "",
+        ""
+      ];
+      if (reader.isWorktree && gitBranch) {
+        lines.push(`**Worktree context:** Scoped to branch \`${gitBranch}\``);
+        lines.push("");
+      }
+      lines.push(
         `**Last worked:** ${briefing.lastWorked}`,
         `**Current focus:** ${briefing.currentFocus}`,
         `**Recent activity:** ${briefing.recentActivity}`,
         `**Suggested next:** ${briefing.suggestedNext}`,
         `**Quick start:** ${briefing.smallNextStep}`
-      ];
-      const recentDecisions = reader2.getRecentDecisions(3);
+      );
+      const recentDecisions = reader.getScopedRecentDecisions(3);
       if (recentDecisions.length > 0) {
         lines.push("");
         lines.push("### Recent decisions");
@@ -1189,8 +1561,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.",
     {
@@ -1199,11 +1571,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 || "",
@@ -1211,10 +1584,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.`,
@@ -1224,11 +1598,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,
@@ -1249,13 +1623,16 @@ 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.",
-    { limit: z3.number().min(1).max(50).default(10).describe("Number of recent decisions to return (1-50, default 10)") },
-    async ({ limit }) => {
-      if (!reader2.exists()) {
+    {
+      limit: z3.number().min(1).max(50).default(10).describe("Number of recent decisions to return (1-50, default 10)"),
+      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 (!reader.exists()) {
         return {
           content: [
             {
@@ -1265,8 +1642,7 @@ function registerGetDecisions(server2, reader2) {
           ]
         };
       }
-      const licenseCache = reader2.getLicenseCache();
-      if (!isCachedLicenseValid(licenseCache)) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
         return {
           content: [
             {
@@ -1276,19 +1652,20 @@ function registerGetDecisions(server2, reader2) {
           ]
         };
       }
-      const decisions = 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: [
             {
               type: "text",
-              text: "No decision records found."
+              text: effectiveBranch ? `No decision records found for branch \`${effectiveBranch}\`. Use branch: "all" to see all branches.` : "No decision records found."
             }
           ]
         };
       }
       const lines = [
-        `## Decisions (last ${decisions.length})`,
+        `## Decisions (last ${decisions.length}, ${scopeLabel})`,
         ""
       ];
       for (const decision of decisions) {
@@ -1314,8 +1691,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";
@@ -1337,6 +1810,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
 
@@ -1350,8 +1832,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.",
     {
@@ -1360,44 +1842,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)) {
@@ -1420,20 +1938,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.`
             }
           ]
         };
@@ -1449,22 +1971,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}.`
           }
         ]
       };
@@ -1473,14 +2016,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: [
             {
@@ -1490,14 +2037,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"}`
             }
           ]
         };
@@ -1506,7 +2080,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.`
           }
         ]
       };
@@ -1515,8 +2089,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 () => ({
@@ -1542,14 +2116,76 @@ function registerResumePrompt(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/prompts/decisions.ts
+function registerDecisionsPrompt(server) {
+  server.prompt(
+    "decisions",
+    "Review recent architectural decisions and their rationale",
+    async () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "I want to review recent architectural decisions in this project.",
+              "",
+              "Please use the KeepGoing tools to:",
+              "1. Fetch recent decision records (get_decisions)",
+              "2. Get my current branch context (get_momentum)",
+              "3. Summarize the decisions, highlighting any that were made on the current branch",
+              "",
+              "Keep your response brief and organized."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/prompts/progress.ts
+function registerProgressPrompt(server) {
+  server.prompt(
+    "progress",
+    "Summarize recent development progress across sessions",
+    async () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "I need a summary of recent development progress for this project.",
+              "",
+              "Please use the KeepGoing tools to:",
+              "1. Fetch session history with a higher limit for broader coverage (get_session_history, limit: 20)",
+              "2. Get my current branch context (get_momentum)",
+              "3. Synthesize a progress summary grouped by branch or feature, highlighting the current branch",
+              "",
+              "Format the summary so it can be used in a standup or sprint review."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+
+// 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 lastSession = reader2.getLastSession();
+  const { session: lastSession } = reader.getScopedLastSession();
   if (!lastSession) {
     process.exit(0);
   }
@@ -1575,10 +2211,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 lastSession = reader2.getLastSession();
+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) {
@@ -1603,6 +2278,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: "",
@@ -1610,12 +2286,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({
@@ -1634,22 +2317,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);
-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