@keepgoingdev/mcp-server 0.5.6 → 0.6.0

package/dist/index.js

@@ -189,6 +189,62 @@ function getTouchedFiles(workspacePath) {
   }
 }
 
+// ../../packages/shared/src/briefingTier.ts
+var MODEL_TIERS = {
+  // Standard: small/fast models (compact is only reachable via explicit tier or context window)
+  "claude-3-haiku": "standard",
+  "claude-3.5-haiku": "standard",
+  "claude-haiku-4-5": "standard",
+  "gpt-4o-mini": "standard",
+  "gemini-flash": "standard",
+  // Detailed: mid-tier models
+  "claude-3.5-sonnet": "detailed",
+  "claude-sonnet-4": "detailed",
+  "claude-sonnet-4-5": "detailed",
+  "claude-sonnet-4-6": "detailed",
+  "gpt-4o": "detailed",
+  "gemini-pro": "detailed",
+  // Full: large context models
+  "claude-opus-4": "full",
+  "claude-opus-4-5": "full",
+  "claude-opus-4-6": "full",
+  "o1": "full",
+  "o3": "full",
+  "gemini-ultra": "full"
+};
+function resolveTier(opts) {
+  if (opts?.tier) {
+    return opts.tier;
+  }
+  if (opts?.model) {
+    const fromModel = tierFromModelName(opts.model);
+    if (fromModel) return fromModel;
+  }
+  if (opts?.contextWindow !== void 0) {
+    return tierFromContextWindow(opts.contextWindow);
+  }
+  return "standard";
+}
+function tierFromModelName(model) {
+  const normalized = model.toLowerCase().trim();
+  if (MODEL_TIERS[normalized]) {
+    return MODEL_TIERS[normalized];
+  }
+  const entries = Object.entries(MODEL_TIERS).sort((a, b) => b[0].length - a[0].length);
+  for (const [key, tier] of entries) {
+    if (normalized.startsWith(key)) {
+      return tier;
+    }
+  }
+  return void 0;
+}
+function tierFromContextWindow(tokens) {
+  if (tokens < 16e3) return "compact";
+  if (tokens < 64e3) return "standard";
+  if (tokens < 2e5) return "detailed";
+  return "full";
+}
+
 // ../../packages/shared/src/reentry.ts
 var RECENT_SESSION_COUNT = 5;
 function generateBriefing(lastSession, recentSessions, projectState, gitBranch, recentCommitMessages) {
@@ -214,6 +270,61 @@ function generateBriefing(lastSession, recentSessions, projectState, gitBranch,
 function getRecentSessions(allSessions, count = RECENT_SESSION_COUNT) {
   return allSessions.slice(-count).reverse();
 }
+function generateEnrichedBriefing(opts) {
+  const tier = resolveTier({
+    tier: opts.tier,
+    model: opts.model,
+    contextWindow: opts.contextWindow
+  });
+  const core = generateBriefing(
+    opts.lastSession,
+    opts.recentSessions,
+    opts.projectState,
+    opts.gitBranch,
+    opts.recentCommits
+  );
+  if (!core) return void 0;
+  const enriched = { tier, core };
+  if (tier === "compact") {
+    return enriched;
+  }
+  enriched.blocker = opts.lastSession?.blocker;
+  enriched.gitBranch = opts.gitBranch;
+  enriched.isWorktree = opts.isWorktree;
+  if (tier === "standard") {
+    return enriched;
+  }
+  if (opts.decisions && opts.decisions.length > 0) {
+    enriched.decisions = opts.decisions.slice(0, tier === "detailed" ? 3 : 10);
+  }
+  if (opts.allTouchedFiles && opts.allTouchedFiles.length > 0) {
+    enriched.touchedFiles = tier === "detailed" ? opts.allTouchedFiles.slice(0, 10) : opts.allTouchedFiles;
+  } else if (opts.lastSession?.touchedFiles && opts.lastSession.touchedFiles.length > 0) {
+    enriched.touchedFiles = tier === "detailed" ? opts.lastSession.touchedFiles.slice(0, 10) : opts.lastSession.touchedFiles;
+  }
+  if (tier === "detailed") {
+    return enriched;
+  }
+  if (opts.allSessions && opts.allSessions.length > 0) {
+    const recent = opts.allSessions.slice(-5).reverse();
+    enriched.sessionHistory = recent.map((s) => ({
+      timestamp: s.timestamp,
+      summary: s.summary || "",
+      nextStep: s.nextStep || "",
+      branch: s.gitBranch
+    }));
+  }
+  if (opts.recentCommits && opts.recentCommits.length > 0) {
+    enriched.recentCommits = opts.recentCommits;
+  }
+  if (opts.fileConflicts && opts.fileConflicts.length > 0) {
+    enriched.fileConflicts = opts.fileConflicts;
+  }
+  if (opts.branchOverlaps && opts.branchOverlaps.length > 0) {
+    enriched.branchOverlaps = opts.branchOverlaps;
+  }
+  return enriched;
+}
 function buildCurrentFocus(lastSession, projectState, gitBranch) {
   if (projectState.derivedCurrentFocus) {
     return projectState.derivedCurrentFocus;
@@ -389,9 +500,199 @@ function inferFocusFromFiles(files) {
   return names.join(", ");
 }
 
+// ../../packages/shared/src/briefingFormatter.ts
+function formatEnrichedBriefing(briefing) {
+  const { tier, core } = briefing;
+  const lines = [];
+  lines.push("## Re-entry Briefing");
+  lines.push("");
+  if (briefing.isWorktree && briefing.gitBranch) {
+    lines.push(`**Worktree context:** Scoped to branch \`${briefing.gitBranch}\``);
+    lines.push("");
+  }
+  if (tier === "compact") {
+    lines.push(`**Last worked:** ${core.lastWorked}`);
+    lines.push(`**Focus:** ${core.currentFocus}`);
+    lines.push(`**Quick start:** ${core.smallNextStep}`);
+    return lines.join("\n");
+  }
+  lines.push(`**Last worked:** ${core.lastWorked}`);
+  lines.push(`**Current focus:** ${core.currentFocus}`);
+  lines.push(`**Recent activity:** ${core.recentActivity}`);
+  lines.push(`**Suggested next:** ${core.suggestedNext}`);
+  lines.push(`**Quick start:** ${core.smallNextStep}`);
+  if (briefing.blocker) {
+    lines.push(`**Blocker:** ${briefing.blocker}`);
+  }
+  if (briefing.decisions && briefing.decisions.length > 0) {
+    lines.push("");
+    lines.push("### Recent decisions");
+    for (const d of briefing.decisions) {
+      const rationale = d.rationale ? ` - ${d.rationale}` : "";
+      lines.push(`- **${d.classification.category}:** ${d.commitMessage}${rationale}`);
+    }
+  }
+  if (briefing.touchedFiles && briefing.touchedFiles.length > 0) {
+    lines.push("");
+    lines.push(`### Files touched (${briefing.touchedFiles.length})`);
+    for (const f of briefing.touchedFiles) {
+      lines.push(`- ${f}`);
+    }
+  }
+  if (briefing.sessionHistory && briefing.sessionHistory.length > 0) {
+    lines.push("");
+    lines.push("### Session history");
+    for (const s of briefing.sessionHistory) {
+      const relTime = formatRelativeTime(s.timestamp);
+      const branch = s.branch ? ` (${s.branch})` : "";
+      lines.push(`- **${relTime}${branch}:** ${s.summary || "No summary"}. Next: ${s.nextStep || "Not specified"}`);
+    }
+  }
+  if (briefing.recentCommits && briefing.recentCommits.length > 0) {
+    lines.push("");
+    lines.push("### Recent commits");
+    for (const msg of briefing.recentCommits.slice(0, 10)) {
+      lines.push(`- ${msg}`);
+    }
+  }
+  if (briefing.fileConflicts && briefing.fileConflicts.length > 0) {
+    lines.push("");
+    lines.push("### File conflicts");
+    lines.push("Multiple sessions are editing the same files:");
+    for (const c of briefing.fileConflicts) {
+      const sessionLabels = c.sessions.map((s) => s.agentLabel || s.sessionId).join(", ");
+      lines.push(`- \`${c.file}\`: ${sessionLabels}`);
+    }
+  }
+  if (briefing.branchOverlaps && briefing.branchOverlaps.length > 0) {
+    lines.push("");
+    lines.push("### Branch overlaps");
+    lines.push("Multiple sessions on the same branch:");
+    for (const o of briefing.branchOverlaps) {
+      const sessionLabels = o.sessions.map((s) => s.agentLabel || s.sessionId).join(", ");
+      lines.push(`- \`${o.branch}\`: ${sessionLabels}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// ../../packages/shared/src/continueOn.ts
+import path2 from "path";
+function gatherContinueOnContext(reader, workspacePath) {
+  const projectName = path2.basename(workspacePath);
+  const gitBranch = reader.getCurrentBranch();
+  if (!reader.exists()) {
+    return {
+      projectName,
+      gitBranch,
+      recentCheckpoints: [],
+      recentDecisions: [],
+      currentTasks: [],
+      recentCommitMessages: []
+    };
+  }
+  const { session: lastCheckpoint } = reader.getScopedLastSession();
+  const recentCheckpoints = reader.getScopedRecentSessions(5);
+  const recentDecisions = reader.getScopedRecentDecisions(3);
+  const currentTasks = reader.getCurrentTasks();
+  const state = reader.getState() ?? {};
+  const sinceTimestamp = lastCheckpoint?.timestamp;
+  const recentCommitMessages = sinceTimestamp ? getCommitMessagesSince(workspacePath, sinceTimestamp) : [];
+  const briefing = generateBriefing(
+    lastCheckpoint,
+    recentCheckpoints,
+    state,
+    gitBranch,
+    recentCommitMessages
+  );
+  return {
+    projectName,
+    gitBranch,
+    briefing,
+    lastCheckpoint,
+    recentCheckpoints,
+    recentDecisions,
+    currentTasks,
+    recentCommitMessages
+  };
+}
+function formatContinueOnPrompt(context, options) {
+  const opts = { includeCommits: true, includeFiles: true, ...options };
+  const lines = [];
+  lines.push(`# Project Context: ${context.projectName}`);
+  lines.push("");
+  lines.push("I'm continuing work on a project. Here is my development context from KeepGoing.");
+  lines.push("");
+  lines.push("## Current Status");
+  if (context.gitBranch) {
+    lines.push(`- **Branch:** ${context.gitBranch}`);
+  }
+  if (context.briefing) {
+    lines.push(`- **Last worked:** ${context.briefing.lastWorked}`);
+    lines.push(`- **Focus:** ${context.briefing.currentFocus}`);
+  } else if (context.lastCheckpoint) {
+    lines.push(`- **Last worked:** ${formatRelativeTime(context.lastCheckpoint.timestamp)}`);
+    if (context.lastCheckpoint.summary) {
+      lines.push(`- **Focus:** ${context.lastCheckpoint.summary}`);
+    }
+  }
+  if (context.lastCheckpoint) {
+    lines.push("");
+    lines.push("## Last Session");
+    if (context.lastCheckpoint.summary) {
+      lines.push(`- **Summary:** ${context.lastCheckpoint.summary}`);
+    }
+    if (context.lastCheckpoint.nextStep) {
+      lines.push(`- **Next step:** ${context.lastCheckpoint.nextStep}`);
+    }
+    if (context.lastCheckpoint.blocker) {
+      lines.push(`- **Blocker:** ${context.lastCheckpoint.blocker}`);
+    }
+    if (opts.includeFiles && context.lastCheckpoint.touchedFiles.length > 0) {
+      const files = context.lastCheckpoint.touchedFiles.slice(0, 10).join(", ");
+      const extra = context.lastCheckpoint.touchedFiles.length > 10 ? ` (+${context.lastCheckpoint.touchedFiles.length - 10} more)` : "";
+      lines.push(`- **Files touched:** ${files}${extra}`);
+    }
+  }
+  const activeTasks = context.currentTasks.filter((t) => t.sessionActive);
+  if (activeTasks.length > 0) {
+    lines.push("");
+    lines.push("## Active Sessions");
+    for (const task of activeTasks) {
+      const label = task.agentLabel || "Unknown agent";
+      const branch = task.branch ? ` on \`${task.branch}\`` : "";
+      lines.push(`- **${label}**${branch}: ${task.taskSummary || "Working"}`);
+    }
+  }
+  if (context.recentDecisions.length > 0) {
+    lines.push("");
+    lines.push("## Recent Decisions");
+    for (const d of context.recentDecisions) {
+      lines.push(`- ${d.classification.category}: ${d.commitMessage}`);
+    }
+  }
+  if (opts.includeCommits && context.recentCommitMessages.length > 0) {
+    lines.push("");
+    lines.push("## Recent Commits");
+    const commits = context.recentCommitMessages.slice(0, 10);
+    for (const msg of commits) {
+      lines.push(`- ${msg}`);
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  const nextStep = context.lastCheckpoint?.nextStep || context.briefing?.suggestedNext || "continue where I left off";
+  lines.push(`Please help me continue this work. My next step is: ${nextStep}.`);
+  let result = lines.join("\n");
+  if (opts.maxLength && result.length > opts.maxLength) {
+    result = result.slice(0, opts.maxLength - 3) + "...";
+  }
+  return result;
+}
+
 // ../../packages/shared/src/storage.ts
 import fs from "fs";
-import path2 from "path";
+import path3 from "path";
 import { randomUUID as randomUUID2, createHash } from "crypto";
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
@@ -414,11 +715,11 @@ var KeepGoingWriter = class {
   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);
+    this.storagePath = path3.join(mainRoot, STORAGE_DIR);
+    this.sessionsFilePath = path3.join(this.storagePath, SESSIONS_FILE);
+    this.stateFilePath = path3.join(this.storagePath, STATE_FILE);
+    this.metaFilePath = path3.join(this.storagePath, META_FILE);
+    this.currentTasksFilePath = path3.join(this.storagePath, CURRENT_TASKS_FILE);
   }
   ensureDir() {
     if (!fs.existsSync(this.storagePath)) {
@@ -732,24 +1033,24 @@ function capitalize(s) {
 
 // ../../packages/shared/src/decisionStorage.ts
 import fs3 from "fs";
-import path4 from "path";
+import path5 from "path";
 
 // ../../packages/shared/src/license.ts
 import crypto from "crypto";
 import fs2 from "fs";
 import os from "os";
-import path3 from "path";
+import path4 from "path";
 var LICENSE_FILE = "license.json";
 var DEVICE_ID_FILE = "device-id";
 function getGlobalLicenseDir() {
-  return path3.join(os.homedir(), ".keepgoing");
+  return path4.join(os.homedir(), ".keepgoing");
 }
 function getGlobalLicensePath() {
-  return path3.join(getGlobalLicenseDir(), LICENSE_FILE);
+  return path4.join(getGlobalLicenseDir(), LICENSE_FILE);
 }
 function getDeviceId() {
   const dir = getGlobalLicenseDir();
-  const filePath = path3.join(dir, DEVICE_ID_FILE);
+  const filePath = path4.join(dir, DEVICE_ID_FILE);
   try {
     const existing = fs2.readFileSync(filePath, "utf-8").trim();
     if (existing) return existing;
@@ -816,7 +1117,7 @@ function writeLicenseStore(store) {
   if (!fs2.existsSync(dirPath)) {
     fs2.mkdirSync(dirPath, { recursive: true });
   }
-  const licensePath = path3.join(dirPath, LICENSE_FILE);
+  const licensePath = path4.join(dirPath, LICENSE_FILE);
   fs2.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
   _cachedStore = store;
   _cacheTimestamp = Date.now();
@@ -868,8 +1169,8 @@ var DecisionStorage = class {
   decisionsFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
-    this.storagePath = path4.join(mainRoot, STORAGE_DIR2);
-    this.decisionsFilePath = path4.join(this.storagePath, DECISIONS_FILE);
+    this.storagePath = path5.join(mainRoot, STORAGE_DIR2);
+    this.decisionsFilePath = path5.join(this.storagePath, DECISIONS_FILE);
   }
   ensureStorageDir() {
     if (!fs3.existsSync(this.storagePath)) {
@@ -877,7 +1178,7 @@ var DecisionStorage = class {
     }
   }
   getProjectName() {
-    return path4.basename(path4.dirname(this.storagePath));
+    return path5.basename(path5.dirname(this.storagePath));
   }
   load() {
     try {
@@ -1144,98 +1445,9 @@ function tryDetectDecision(opts) {
   };
 }
 
-// ../../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 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.";
-  }
-  return void 0;
-}
-async function safeJson(res) {
-  try {
-    const text = await res.text();
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-async function activateLicense(licenseKey, instanceName, options) {
-  try {
-    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 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,
-      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";
-    return { valid: false, error: message };
-  }
-}
-async function deactivateLicense(licenseKey, instanceId) {
-  try {
-    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 safeJson(res);
-    if (!res.ok || !data?.deactivated) {
-      return { deactivated: false, error: data?.error || `Deactivation failed (${res.status})` };
-    }
-    return { deactivated: true };
-  } 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";
-    return { deactivated: false, error: message };
-  }
-}
-
-// src/storage.ts
+// ../../packages/shared/src/reader.ts
 import fs4 from "fs";
-import path5 from "path";
+import path6 from "path";
 var STORAGE_DIR3 = ".keepgoing";
 var META_FILE2 = "meta.json";
 var SESSIONS_FILE2 = "sessions.json";
@@ -1257,12 +1469,12 @@ var KeepGoingReader = class {
     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);
+    this.storagePath = path6.join(mainRoot, STORAGE_DIR3);
+    this.metaFilePath = path6.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path6.join(this.storagePath, SESSIONS_FILE2);
+    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE2);
+    this.stateFilePath = path6.join(this.storagePath, STATE_FILE2);
+    this.currentTasksFilePath = path6.join(this.storagePath, CURRENT_TASKS_FILE2);
   }
   /** Check if .keepgoing/ directory exists. */
   exists() {
@@ -1515,105 +1727,423 @@ var KeepGoingReader = class {
   }
 };
 
-// src/tools/getMomentum.ts
-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 (!reader.exists()) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No KeepGoing data found. The developer has not saved any checkpoints yet."
-            }
-          ]
-        };
-      }
-      const { session: lastSession, isFallback } = reader.getScopedLastSession();
-      const currentBranch = reader.getCurrentBranch();
-      if (!lastSession) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "KeepGoing is set up but no session checkpoints exist yet."
-            }
-          ]
-        };
-      }
-      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}`);
-      }
-      if (lastSession.projectIntent) {
-        lines.push(`**Project intent:** ${lastSession.projectIntent}`);
-      }
-      lines.push("");
-      if (currentBranch) {
-        lines.push(`**Current branch:** ${currentBranch}`);
-      }
-      if (branchChanged && !reader.isWorktree) {
-        lines.push(
-          `**Note:** Branch changed since last checkpoint (was \`${lastSession.gitBranch}\`, now \`${currentBranch}\`)`
-        );
-      }
-      if (lastSession.touchedFiles.length > 0) {
-        lines.push("");
-        lines.push(
-          `**Files touched (${lastSession.touchedFiles.length}):** ${lastSession.touchedFiles.slice(0, 10).join(", ")}`
-        );
-        if (lastSession.touchedFiles.length > 10) {
-          lines.push(
-            `  ...and ${lastSession.touchedFiles.length - 10} more`
-          );
-        }
-      }
-      if (state?.derivedCurrentFocus) {
-        lines.push("");
-        lines.push(`**Derived focus:** ${state.derivedCurrentFocus}`);
-      }
-      return {
-        content: [{ type: "text", text: lines.join("\n") }]
-      };
+// ../../packages/shared/src/setup.ts
+import fs5 from "fs";
+import os2 from "os";
+import path7 from "path";
+var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
+var SESSION_START_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --print-momentum"
     }
-  );
-}
-
-// src/tools/getSessionHistory.ts
-import { z } from "zod";
-function registerGetSessionHistory(server, reader) {
-  server.tool(
-    "get_session_history",
-    "Get recent session checkpoints. Returns a chronological list of what the developer worked on.",
+  ]
+};
+var STOP_HOOK = {
+  matcher: "",
+  hooks: [
     {
-      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: [
-            {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --save-checkpoint"
+    }
+  ]
+};
+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
+
+After completing a task or meaningful piece of work, call the \`save_checkpoint\` MCP tool with:
+- \`summary\`: What you accomplished
+- \`nextStep\`: What should be done next
+- \`blocker\`: Any blocker (if applicable)
+`;
+var STATUSLINE_CMD = "npx -y @keepgoingdev/mcp-server --statusline";
+function hasKeepGoingHook(hookEntries) {
+  return hookEntries.some(
+    (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
+  );
+}
+function resolveScopePaths(scope, workspacePath) {
+  if (scope === "user") {
+    const claudeDir2 = path7.join(os2.homedir(), ".claude");
+    return {
+      claudeDir: claudeDir2,
+      settingsPath: path7.join(claudeDir2, "settings.json"),
+      claudeMdPath: path7.join(claudeDir2, "CLAUDE.md")
+    };
+  }
+  const claudeDir = path7.join(workspacePath, ".claude");
+  const dotClaudeMdPath = path7.join(workspacePath, ".claude", "CLAUDE.md");
+  const rootClaudeMdPath = path7.join(workspacePath, "CLAUDE.md");
+  return {
+    claudeDir,
+    settingsPath: path7.join(claudeDir, "settings.json"),
+    claudeMdPath: fs5.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath
+  };
+}
+function writeHooksToSettings(settings) {
+  let changed = false;
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart.push(SESSION_START_HOOK);
+    changed = true;
+  }
+  if (!Array.isArray(settings.hooks.Stop)) {
+    settings.hooks.Stop = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.Stop)) {
+    settings.hooks.Stop.push(STOP_HOOK);
+    changed = true;
+  }
+  if (!Array.isArray(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
+    changed = true;
+  }
+  return changed;
+}
+function checkHookConflict(scope, workspacePath) {
+  const otherPaths = resolveScopePaths(scope === "user" ? "project" : "user", workspacePath);
+  if (!fs5.existsSync(otherPaths.settingsPath)) {
+    return null;
+  }
+  try {
+    const otherSettings = JSON.parse(fs5.readFileSync(otherPaths.settingsPath, "utf-8"));
+    const hooks = otherSettings?.hooks;
+    if (!hooks) return null;
+    const hasConflict = Array.isArray(hooks.SessionStart) && hasKeepGoingHook(hooks.SessionStart) || Array.isArray(hooks.Stop) && hasKeepGoingHook(hooks.Stop);
+    if (hasConflict) {
+      const otherScope = scope === "user" ? "project" : "user";
+      const otherFile = otherPaths.settingsPath;
+      return `KeepGoing hooks are also configured at ${otherScope} scope (${otherFile}). Having hooks at both scopes may cause them to fire twice. Consider removing the ${otherScope}-level hooks if you want to use ${scope}-level only.`;
+    }
+  } catch {
+  }
+  return null;
+}
+function setupProject(options) {
+  const {
+    workspacePath,
+    scope = "project",
+    sessionHooks = true,
+    claudeMd = true,
+    hasProLicense = false,
+    statusline
+  } = options;
+  const messages = [];
+  let changed = false;
+  const { claudeDir, settingsPath, claudeMdPath } = resolveScopePaths(scope, workspacePath);
+  const scopeLabel = scope === "user" ? "~/.claude/settings.json" : ".claude/settings.json";
+  let settings = {};
+  if (fs5.existsSync(settingsPath)) {
+    settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+  }
+  let settingsChanged = false;
+  if (sessionHooks) {
+    const hooksChanged = writeHooksToSettings(settings);
+    settingsChanged = hooksChanged;
+    if (hooksChanged) {
+      messages.push(`Session hooks: Added to ${scopeLabel}`);
+    } else {
+      messages.push("Session hooks: Already present, skipped");
+    }
+    const conflict = checkHookConflict(scope, workspacePath);
+    if (conflict) {
+      messages.push(`Warning: ${conflict}`);
+    }
+  }
+  if (scope === "project" && hasProLicense) {
+    const needsUpdate = settings.statusLine?.command && statusline?.isLegacy?.(settings.statusLine.command);
+    if (!settings.statusLine || needsUpdate) {
+      settings.statusLine = {
+        type: "command",
+        command: STATUSLINE_CMD
+      };
+      settingsChanged = true;
+      messages.push(needsUpdate ? "Statusline: Migrated to auto-updating npx command" : "Statusline: Added to .claude/settings.json");
+    } else {
+      messages.push("Statusline: Already configured in settings, skipped");
+    }
+    statusline?.cleanup?.();
+  }
+  if (settingsChanged) {
+    if (!fs5.existsSync(claudeDir)) {
+      fs5.mkdirSync(claudeDir, { recursive: true });
+    }
+    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    changed = true;
+  }
+  if (claudeMd) {
+    let existing = "";
+    if (fs5.existsSync(claudeMdPath)) {
+      existing = fs5.readFileSync(claudeMdPath, "utf-8");
+    }
+    const mdLabel = scope === "user" ? "~/.claude/CLAUDE.md" : "CLAUDE.md";
+    if (existing.includes("## KeepGoing")) {
+      messages.push(`CLAUDE.md: KeepGoing section already present in ${mdLabel}, skipped`);
+    } else {
+      const updated = existing + CLAUDE_MD_SECTION;
+      const mdDir = path7.dirname(claudeMdPath);
+      if (!fs5.existsSync(mdDir)) {
+        fs5.mkdirSync(mdDir, { recursive: true });
+      }
+      fs5.writeFileSync(claudeMdPath, updated);
+      changed = true;
+      messages.push(`CLAUDE.md: Added KeepGoing section to ${mdLabel}`);
+    }
+  }
+  return { messages, changed };
+}
+
+// ../../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 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.";
+  }
+  return void 0;
+}
+async function safeJson(res) {
+  try {
+    const text = await res.text();
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function activateLicense(licenseKey, instanceName, options) {
+  try {
+    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 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,
+      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";
+    return { valid: false, error: message };
+  }
+}
+async function deactivateLicense(licenseKey, instanceId) {
+  try {
+    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 safeJson(res);
+    if (!res.ok || !data?.deactivated) {
+      return { deactivated: false, error: data?.error || `Deactivation failed (${res.status})` };
+    }
+    return { deactivated: true };
+  } 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";
+    return { deactivated: false, error: message };
+  }
+}
+
+// src/tools/getMomentum.ts
+import { z } from "zod";
+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. Pass tier or model to control detail level.",
+    {
+      tier: z.enum(["compact", "standard", "detailed", "full"]).optional().describe("Briefing detail level. compact (~150 tokens), standard (~400), detailed (~800), full (~1500). Default: standard."),
+      model: z.string().optional().describe('Model name (e.g. "claude-opus-4") to auto-resolve tier. Ignored if tier is set.')
+    },
+    async ({ tier, model }) => {
+      if (!reader.exists()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found. The developer has not saved any checkpoints yet."
+            }
+          ]
+        };
+      }
+      if (tier || model) {
+        const gitBranch = reader.getCurrentBranch();
+        const { session: lastSession2 } = reader.getScopedLastSession();
+        const recentSessions = reader.getScopedRecentSessions(5);
+        const state2 = reader.getState() ?? {};
+        const sinceTimestamp = lastSession2?.timestamp;
+        const recentCommits = sinceTimestamp ? getCommitMessagesSince(workspacePath, sinceTimestamp) : [];
+        const decisions = reader.getScopedRecentDecisions(10);
+        const allSessions = reader.getSessions();
+        const fileConflicts = reader.detectFileConflicts();
+        const branchOverlaps = reader.detectBranchOverlap();
+        const briefing = generateEnrichedBriefing({
+          tier,
+          model,
+          lastSession: lastSession2,
+          recentSessions,
+          projectState: state2,
+          gitBranch,
+          recentCommits,
+          decisions,
+          allTouchedFiles: lastSession2?.touchedFiles,
+          allSessions,
+          fileConflicts,
+          branchOverlaps,
+          isWorktree: reader.isWorktree
+        });
+        if (!briefing) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "KeepGoing is set up but no session checkpoints exist yet."
+              }
+            ]
+          };
+        }
+        return {
+          content: [{ type: "text", text: formatEnrichedBriefing(briefing) }]
+        };
+      }
+      const { session: lastSession, isFallback } = reader.getScopedLastSession();
+      const currentBranch = reader.getCurrentBranch();
+      if (!lastSession) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "KeepGoing is set up but no session checkpoints exist yet."
+            }
+          ]
+        };
+      }
+      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}`);
+      }
+      if (lastSession.projectIntent) {
+        lines.push(`**Project intent:** ${lastSession.projectIntent}`);
+      }
+      lines.push("");
+      if (currentBranch) {
+        lines.push(`**Current branch:** ${currentBranch}`);
+      }
+      if (branchChanged && !reader.isWorktree) {
+        lines.push(
+          `**Note:** Branch changed since last checkpoint (was \`${lastSession.gitBranch}\`, now \`${currentBranch}\`)`
+        );
+      }
+      if (lastSession.touchedFiles.length > 0) {
+        lines.push("");
+        lines.push(
+          `**Files touched (${lastSession.touchedFiles.length}):** ${lastSession.touchedFiles.slice(0, 10).join(", ")}`
+        );
+        if (lastSession.touchedFiles.length > 10) {
+          lines.push(
+            `  ...and ${lastSession.touchedFiles.length - 10} more`
+          );
+        }
+      }
+      if (state?.derivedCurrentFocus) {
+        lines.push("");
+        lines.push(`**Derived focus:** ${state.derivedCurrentFocus}`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/getSessionHistory.ts
+import { z as z2 } from "zod";
+function registerGetSessionHistory(server, reader) {
+  server.tool(
+    "get_session_history",
+    "Get recent session checkpoints. Returns a chronological list of what the developer worked on.",
+    {
+      limit: z2.number().min(1).max(50).default(5).describe("Number of recent sessions to return (1-50, default 5)"),
+      branch: z2.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: [
+            {
               type: "text",
               text: "No KeepGoing data found."
             }
@@ -1661,12 +2191,16 @@ function registerGetSessionHistory(server, reader) {
 }
 
 // src/tools/getReentryBriefing.ts
+import { z as z3 } from "zod";
 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 () => {
+    "Get a synthesized re-entry briefing that helps a developer understand where they left off. Includes focus, recent activity, and suggested next steps. Pass tier or model to control detail level.",
+    {
+      tier: z3.enum(["compact", "standard", "detailed", "full"]).optional().describe("Briefing detail level. compact (~150 tokens), standard (~400), detailed (~800), full (~1500). Default: standard."),
+      model: z3.string().optional().describe('Model name (e.g. "claude-opus-4") to auto-resolve tier. Ignored if tier is set.')
+    },
+    async ({ tier, model }) => {
       if (!reader.exists()) {
         return {
           content: [
@@ -1683,13 +2217,25 @@ function registerGetReentryBriefing(server, reader, workspacePath) {
       const state = reader.getState() ?? {};
       const sinceTimestamp = lastSession?.timestamp;
       const recentCommits = sinceTimestamp ? getCommitMessagesSince(workspacePath, sinceTimestamp) : [];
-      const briefing = generateBriefing(
+      const decisions = reader.getScopedRecentDecisions(10);
+      const allSessions = reader.getSessions();
+      const fileConflicts = reader.detectFileConflicts();
+      const branchOverlaps = reader.detectBranchOverlap();
+      const briefing = generateEnrichedBriefing({
+        tier,
+        model,
         lastSession,
         recentSessions,
-        state,
+        projectState: state,
         gitBranch,
-        recentCommits
-      );
+        recentCommits,
+        decisions,
+        allTouchedFiles: lastSession?.touchedFiles,
+        allSessions,
+        fileConflicts,
+        branchOverlaps,
+        isWorktree: reader.isWorktree
+      });
       if (!briefing) {
         return {
           content: [
@@ -1700,55 +2246,31 @@ function registerGetReentryBriefing(server, reader, workspacePath) {
           ]
         };
       }
-      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 = reader.getScopedRecentDecisions(3);
-      if (recentDecisions.length > 0) {
-        lines.push("");
-        lines.push("### Recent decisions");
-        for (const decision of recentDecisions) {
-          const rationale = decision.rationale ? ` - ${decision.rationale}` : "";
-          lines.push(`- **${decision.classification.category}:** ${decision.commitMessage}${rationale}`);
-        }
-      }
       return {
-        content: [{ type: "text", text: lines.join("\n") }]
+        content: [{ type: "text", text: formatEnrichedBriefing(briefing) }]
       };
     }
   );
 }
 
 // src/tools/saveCheckpoint.ts
-import path6 from "path";
-import { z as z2 } from "zod";
+import path8 from "path";
+import { z as z4 } from "zod";
 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.",
     {
-      summary: z2.string().describe("What was accomplished in this session"),
-      nextStep: z2.string().optional().describe("What to do next"),
-      blocker: z2.string().optional().describe("Any blocker preventing progress")
+      summary: z4.string().describe("What was accomplished in this session"),
+      nextStep: z4.string().optional().describe("What to do next"),
+      blocker: z4.string().optional().describe("Any blocker preventing progress")
     },
     async ({ summary, nextStep, blocker }) => {
       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 projectName = path8.basename(resolveStorageRoot(workspacePath));
       const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
       const checkpoint = createCheckpoint({
         summary,
@@ -1795,14 +2317,14 @@ function registerSaveCheckpoint(server, reader, workspacePath) {
 }
 
 // src/tools/getDecisions.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 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)"),
-      branch: z3.string().optional().describe('Filter to a specific branch name, or "all" to show all branches. Auto-detected from worktree context by default.')
+      limit: z5.number().min(1).max(50).default(10).describe("Number of recent decisions to return (1-50, default 10)"),
+      branch: z5.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()) {
@@ -1960,31 +2482,28 @@ function registerGetCurrentTask(server, reader) {
 }
 
 // src/tools/setupProject.ts
-import fs6 from "fs";
-import os3 from "os";
-import path8 from "path";
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/cli/migrate.ts
-import fs5 from "fs";
-import os2 from "os";
-import path7 from "path";
-var STATUSLINE_CMD = "npx -y @keepgoingdev/mcp-server --statusline";
+import fs6 from "fs";
+import os3 from "os";
+import path9 from "path";
+var STATUSLINE_CMD2 = "npx -y @keepgoingdev/mcp-server --statusline";
 function isLegacyStatusline(command) {
   return !command.includes("--statusline") && command.includes("keepgoing-statusline");
 }
 function migrateStatusline(wsPath) {
-  const settingsPath = path7.join(wsPath, ".claude", "settings.json");
-  if (!fs5.existsSync(settingsPath)) return void 0;
+  const settingsPath = path9.join(wsPath, ".claude", "settings.json");
+  if (!fs6.existsSync(settingsPath)) return void 0;
   try {
-    const settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
     const cmd = settings.statusLine?.command;
     if (!cmd || !isLegacyStatusline(cmd)) return void 0;
     settings.statusLine = {
       type: "command",
-      command: STATUSLINE_CMD
+      command: STATUSLINE_CMD2
     };
-    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     cleanupLegacyScript();
     return "[KeepGoing] Migrated statusline to auto-updating command (restart Claude Code to apply)";
   } catch {
@@ -1992,207 +2511,55 @@ function migrateStatusline(wsPath) {
   }
 }
 function cleanupLegacyScript() {
-  const legacyScript = path7.join(os2.homedir(), ".claude", "keepgoing-statusline.sh");
-  if (fs5.existsSync(legacyScript)) {
+  const legacyScript = path9.join(os3.homedir(), ".claude", "keepgoing-statusline.sh");
+  if (fs6.existsSync(legacyScript)) {
     try {
-      fs5.unlinkSync(legacyScript);
+      fs6.unlinkSync(legacyScript);
     } catch {
     }
   }
 }
 
 // src/tools/setupProject.ts
-var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
-var SESSION_START_HOOK = {
-  matcher: "",
-  hooks: [
-    {
-      type: "command",
-      command: "npx -y @keepgoingdev/mcp-server --print-momentum"
-    }
-  ]
-};
-var STOP_HOOK = {
-  matcher: "",
-  hooks: [
-    {
-      type: "command",
-      command: "npx -y @keepgoingdev/mcp-server --save-checkpoint"
-    }
-  ]
-};
-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
-
-After completing a task or meaningful piece of work, call the \`save_checkpoint\` MCP tool with:
-- \`summary\`: What you accomplished
-- \`nextStep\`: What should be done next
-- \`blocker\`: Any blocker (if applicable)
-`;
-function hasKeepGoingHook(hookEntries) {
-  return hookEntries.some(
-    (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
-  );
-}
-function resolveScopePaths(scope, workspacePath) {
-  if (scope === "user") {
-    const claudeDir2 = path8.join(os3.homedir(), ".claude");
-    return {
-      claudeDir: claudeDir2,
-      settingsPath: path8.join(claudeDir2, "settings.json"),
-      claudeMdPath: path8.join(claudeDir2, "CLAUDE.md")
-    };
-  }
-  const claudeDir = path8.join(workspacePath, ".claude");
-  const dotClaudeMdPath = path8.join(workspacePath, ".claude", "CLAUDE.md");
-  const rootClaudeMdPath = path8.join(workspacePath, "CLAUDE.md");
-  return {
-    claudeDir,
-    settingsPath: path8.join(claudeDir, "settings.json"),
-    claudeMdPath: fs6.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath
-  };
-}
-function writeHooksToSettings(settings) {
-  let changed = false;
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!Array.isArray(settings.hooks.SessionStart)) {
-    settings.hooks.SessionStart = [];
-  }
-  if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
-    settings.hooks.SessionStart.push(SESSION_START_HOOK);
-    changed = true;
-  }
-  if (!Array.isArray(settings.hooks.Stop)) {
-    settings.hooks.Stop = [];
-  }
-  if (!hasKeepGoingHook(settings.hooks.Stop)) {
-    settings.hooks.Stop.push(STOP_HOOK);
-    changed = true;
-  }
-  if (!Array.isArray(settings.hooks.PostToolUse)) {
-    settings.hooks.PostToolUse = [];
-  }
-  if (!hasKeepGoingHook(settings.hooks.PostToolUse)) {
-    settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
-    changed = true;
-  }
-  return changed;
-}
-function checkHookConflict(scope, workspacePath) {
-  const otherPaths = resolveScopePaths(scope === "user" ? "project" : "user", workspacePath);
-  if (!fs6.existsSync(otherPaths.settingsPath)) {
-    return null;
-  }
-  try {
-    const otherSettings = JSON.parse(fs6.readFileSync(otherPaths.settingsPath, "utf-8"));
-    const hooks = otherSettings?.hooks;
-    if (!hooks) return null;
-    const hasConflict = Array.isArray(hooks.SessionStart) && hasKeepGoingHook(hooks.SessionStart) || Array.isArray(hooks.Stop) && hasKeepGoingHook(hooks.Stop);
-    if (hasConflict) {
-      const otherScope = scope === "user" ? "project" : "user";
-      const otherFile = otherPaths.settingsPath;
-      return `**Warning:** KeepGoing hooks are also configured at ${otherScope} scope (\`${otherFile}\`). Having hooks at both scopes may cause them to fire twice. Consider removing the ${otherScope}-level hooks if you want to use ${scope}-level only.`;
-    }
-  } catch {
-  }
-  return null;
-}
 function registerSetupProject(server, workspacePath) {
   server.tool(
     "setup_project",
     'Set up KeepGoing hooks and instructions. Use scope "user" for global setup (all projects) or "project" for per-project setup.',
     {
-      sessionHooks: z4.boolean().optional().default(true).describe("Add session hooks to settings.json"),
-      claudeMd: z4.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md"),
-      scope: z4.enum(["project", "user"]).optional().default("project").describe('Where to write config: "user" for global (~/.claude/), "project" for per-project (.claude/)')
+      sessionHooks: z6.boolean().optional().default(true).describe("Add session hooks to settings.json"),
+      claudeMd: z6.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md"),
+      scope: z6.enum(["project", "user"]).optional().default("project").describe('Where to write config: "user" for global (~/.claude/), "project" for per-project (.claude/)')
     },
     async ({ sessionHooks, claudeMd, scope }) => {
-      const results = [];
-      const { claudeDir, settingsPath, claudeMdPath } = resolveScopePaths(scope, workspacePath);
-      const scopeLabel = scope === "user" ? "`~/.claude/settings.json`" : "`.claude/settings.json`";
-      let settings = {};
-      if (fs6.existsSync(settingsPath)) {
-        settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
-      }
-      let settingsChanged = false;
-      if (sessionHooks) {
-        const hooksChanged = writeHooksToSettings(settings);
-        settingsChanged = hooksChanged;
-        if (hooksChanged) {
-          results.push(`**Session hooks:** Added to ${scopeLabel}`);
-        } else {
-          results.push("**Session hooks:** Already present, skipped");
-        }
-        const conflict = checkHookConflict(scope, workspacePath);
-        if (conflict) {
-          results.push(conflict);
-        }
-      }
-      if (scope === "project") {
-        if (process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("session-awareness")) {
-          const needsUpdate = settings.statusLine?.command && isLegacyStatusline(settings.statusLine.command);
-          if (!settings.statusLine || needsUpdate) {
-            settings.statusLine = {
-              type: "command",
-              command: STATUSLINE_CMD
-            };
-            settingsChanged = true;
-            results.push(needsUpdate ? "**Statusline:** Migrated to auto-updating `npx` command" : "**Statusline:** Added to `.claude/settings.json`");
-          } else {
-            results.push("**Statusline:** `statusLine` already configured in settings, skipped");
-          }
-          cleanupLegacyScript();
-        }
-      }
-      if (settingsChanged) {
-        if (!fs6.existsSync(claudeDir)) {
-          fs6.mkdirSync(claudeDir, { recursive: true });
-        }
-        fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-      }
-      if (claudeMd) {
-        let existing = "";
-        if (fs6.existsSync(claudeMdPath)) {
-          existing = fs6.readFileSync(claudeMdPath, "utf-8");
-        }
-        const mdLabel = scope === "user" ? "`~/.claude/CLAUDE.md`" : "`CLAUDE.md`";
-        if (existing.includes("## KeepGoing")) {
-          results.push(`**CLAUDE.md:** KeepGoing section already present in ${mdLabel}, skipped`);
-        } else {
-          const updated = existing + CLAUDE_MD_SECTION;
-          const mdDir = path8.dirname(claudeMdPath);
-          if (!fs6.existsSync(mdDir)) {
-            fs6.mkdirSync(mdDir, { recursive: true });
-          }
-          fs6.writeFileSync(claudeMdPath, updated);
-          results.push(`**CLAUDE.md:** Added KeepGoing section to ${mdLabel}`);
+      const hasProLicense = process.env.KEEPGOING_PRO_BYPASS === "1" || !!getLicenseForFeature("session-awareness");
+      const result = setupProject({
+        workspacePath,
+        scope,
+        sessionHooks,
+        claudeMd,
+        hasProLicense,
+        statusline: {
+          isLegacy: isLegacyStatusline,
+          cleanup: cleanupLegacyScript
         }
-      }
+      });
+      const formatted = result.messages.map((msg) => {
+        return msg.replace(/^([^:]+:)/, "**$1**");
+      });
       return {
-        content: [{ type: "text", text: results.join("\n") }]
+        content: [{ type: "text", text: formatted.join("\n") }]
       };
     }
   );
 }
 
 // src/tools/activateLicense.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 function registerActivateLicense(server) {
   server.tool(
     "activate_license",
     "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") },
+    { license_key: z7.string().describe("Your KeepGoing Pro license key") },
     async ({ license_key }) => {
       const store = readLicenseStore();
       const existingForKey = store.licenses.find(
@@ -2266,13 +2633,13 @@ function registerActivateLicense(server) {
 }
 
 // src/tools/deactivateLicense.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function registerDeactivateLicense(server) {
   server.tool(
     "deactivate_license",
     "Deactivate the KeepGoing Pro license on this device.",
     {
-      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.")
+      license_key: z8.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();
@@ -2338,6 +2705,48 @@ function registerDeactivateLicense(server) {
   );
 }
 
+// src/tools/continueOn.ts
+import { z as z9 } from "zod";
+function registerContinueOn(server, reader, workspacePath) {
+  server.tool(
+    "continue_on",
+    "Export KeepGoing context as a formatted prompt for use in another AI tool (ChatGPT, Gemini, Copilot, etc.). Returns a markdown prompt with project status, last session, decisions, and recent commits.",
+    {
+      target: z9.enum(["chatgpt", "gemini", "copilot", "claude", "general"]).optional().describe("Target AI tool (currently used for future format tuning)"),
+      include_commits: z9.boolean().default(true).describe("Include recent commit messages in the prompt"),
+      include_files: z9.boolean().default(true).describe("Include touched file paths in the prompt")
+    },
+    async ({ target, include_commits, include_files }) => {
+      if (!reader.exists()) {
+        return {
+          content: [{
+            type: "text",
+            text: "No KeepGoing data found. Save a checkpoint first to use Continue On."
+          }]
+        };
+      }
+      const context = gatherContinueOnContext(reader, workspacePath);
+      if (!context.lastCheckpoint && !context.briefing) {
+        return {
+          content: [{
+            type: "text",
+            text: "No session data available. Save a checkpoint first."
+          }]
+        };
+      }
+      const formatOpts = {
+        target,
+        includeCommits: include_commits,
+        includeFiles: include_files
+      };
+      const prompt = formatContinueOnPrompt(context, formatOpts);
+      return {
+        content: [{ type: "text", text: prompt }]
+      };
+    }
+  );
+}
+
 // src/prompts/resume.ts
 function registerResumePrompt(server) {
   server.prompt(
@@ -2503,7 +2912,7 @@ async function handlePrintCurrent() {
 }
 
 // src/cli/saveCheckpoint.ts
-import path9 from "path";
+import path10 from "path";
 async function handleSaveCheckpoint() {
   const wsPath = resolveWsPath();
   const reader = new KeepGoingReader(wsPath);
@@ -2531,9 +2940,9 @@ async function handleSaveCheckpoint() {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path9.basename(f)).join(", ")}`;
+  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path10.basename(f)).join(", ")}`;
   const nextStep = buildSmartNextStep(events);
-  const projectName = path9.basename(resolveStorageRoot(wsPath));
+  const projectName = path10.basename(resolveStorageRoot(wsPath));
   const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
   const checkpoint = createCheckpoint({
     summary,
@@ -2647,7 +3056,7 @@ async function handleUpdateTaskFromHook() {
 
 // src/cli/statusline.ts
 import fs7 from "fs";
-import path10 from "path";
+import path11 from "path";
 var STDIN_TIMEOUT_MS2 = 3e3;
 async function handleStatusline() {
   const chunks = [];
@@ -2670,7 +3079,7 @@ async function handleStatusline() {
         process.exit(0);
       }
       const gitRoot = findGitRoot(dir);
-      const tasksFile = path10.join(gitRoot, ".keepgoing", "current-tasks.json");
+      const tasksFile = path11.join(gitRoot, ".keepgoing", "current-tasks.json");
       if (!fs7.existsSync(tasksFile)) {
         process.exit(0);
       }
@@ -2700,6 +3109,22 @@ async function handleStatusline() {
   process.stdin.resume();
 }
 
+// src/cli/continueOn.ts
+async function handleContinueOn() {
+  const wsPath = resolveWsPath();
+  const reader = new KeepGoingReader(wsPath);
+  if (!reader.exists()) {
+    process.exit(0);
+  }
+  const context = gatherContinueOnContext(reader, wsPath);
+  if (!context.lastCheckpoint && !context.briefing) {
+    process.exit(0);
+  }
+  const prompt = formatContinueOnPrompt(context);
+  console.log(prompt);
+  process.exit(0);
+}
+
 // src/index.ts
 var CLI_HANDLERS = {
   "--print-momentum": handlePrintMomentum,
@@ -2707,7 +3132,8 @@ var CLI_HANDLERS = {
   "--update-task": handleUpdateTask,
   "--update-task-from-hook": handleUpdateTaskFromHook,
   "--print-current": handlePrintCurrent,
-  "--statusline": handleStatusline
+  "--statusline": handleStatusline,
+  "--continue-on": handleContinueOn
 };
 var flag = process.argv.slice(2).find((a) => a in CLI_HANDLERS);
 if (flag) {
@@ -2725,6 +3151,7 @@ if (flag) {
   registerGetDecisions(server, reader);
   registerGetCurrentTask(server, reader);
   registerSaveCheckpoint(server, reader, workspacePath);
+  registerContinueOn(server, reader, workspacePath);
   registerSetupProject(server, workspacePath);
   registerActivateLicense(server);
   registerDeactivateLicense(server);