@keepgoingdev/mcp-server 0.5.7 → 0.6.1

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 {
@@ -1146,7 +1447,7 @@ function tryDetectDecision(opts) {
 
 // ../../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";
@@ -1168,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() {
@@ -1429,7 +1730,7 @@ var KeepGoingReader = class {
 // ../../packages/shared/src/setup.ts
 import fs5 from "fs";
 import os2 from "os";
-import path6 from "path";
+import path7 from "path";
 var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
 var SESSION_START_HOOK = {
   matcher: "",
@@ -1474,19 +1775,19 @@ function hasKeepGoingHook(hookEntries) {
 }
 function resolveScopePaths(scope, workspacePath) {
   if (scope === "user") {
-    const claudeDir2 = path6.join(os2.homedir(), ".claude");
+    const claudeDir2 = path7.join(os2.homedir(), ".claude");
     return {
       claudeDir: claudeDir2,
-      settingsPath: path6.join(claudeDir2, "settings.json"),
-      claudeMdPath: path6.join(claudeDir2, "CLAUDE.md")
+      settingsPath: path7.join(claudeDir2, "settings.json"),
+      claudeMdPath: path7.join(claudeDir2, "CLAUDE.md")
     };
   }
-  const claudeDir = path6.join(workspacePath, ".claude");
-  const dotClaudeMdPath = path6.join(workspacePath, ".claude", "CLAUDE.md");
-  const rootClaudeMdPath = path6.join(workspacePath, "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: path6.join(claudeDir, "settings.json"),
+    settingsPath: path7.join(claudeDir, "settings.json"),
     claudeMdPath: fs5.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath
   };
 }
@@ -1543,7 +1844,6 @@ function setupProject(options) {
     scope = "project",
     sessionHooks = true,
     claudeMd = true,
-    hasProLicense = false,
     statusline
   } = options;
   const messages = [];
@@ -1568,7 +1868,7 @@ function setupProject(options) {
       messages.push(`Warning: ${conflict}`);
     }
   }
-  if (scope === "project" && hasProLicense) {
+  if (scope === "project") {
     const needsUpdate = settings.statusLine?.command && statusline?.isLegacy?.(settings.statusLine.command);
     if (!settings.statusLine || needsUpdate) {
       settings.statusLine = {
@@ -1599,7 +1899,7 @@ function setupProject(options) {
       messages.push(`CLAUDE.md: KeepGoing section already present in ${mdLabel}, skipped`);
     } else {
       const updated = existing + CLAUDE_MD_SECTION;
-      const mdDir = path6.dirname(claudeMdPath);
+      const mdDir = path7.dirname(claudeMdPath);
       if (!fs5.existsSync(mdDir)) {
         fs5.mkdirSync(mdDir, { recursive: true });
       }
@@ -1701,12 +2001,16 @@ async function deactivateLicense(licenseKey, instanceId) {
 }
 
 // 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.",
-    {},
-    async () => {
+    "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: [
@@ -1717,6 +2021,46 @@ function registerGetMomentum(server, reader, workspacePath) {
           ]
         };
       }
+      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) {
@@ -1785,14 +2129,14 @@ function registerGetMomentum(server, reader, workspacePath) {
 }
 
 // src/tools/getSessionHistory.ts
-import { z } from "zod";
+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: 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.')
+      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()) {
@@ -1846,12 +2190,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: [
@@ -1868,13 +2216,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: [
@@ -1885,55 +2245,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 path7 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 = path7.basename(resolveStorageRoot(workspacePath));
+      const projectName = path8.basename(resolveStorageRoot(workspacePath));
       const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
       const checkpoint = createCheckpoint({
         summary,
@@ -1980,14 +2316,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()) {
@@ -2145,18 +2481,18 @@ function registerGetCurrentTask(server, reader) {
 }
 
 // src/tools/setupProject.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/cli/migrate.ts
 import fs6 from "fs";
 import os3 from "os";
-import path8 from "path";
+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 = path8.join(wsPath, ".claude", "settings.json");
+  const settingsPath = path9.join(wsPath, ".claude", "settings.json");
   if (!fs6.existsSync(settingsPath)) return void 0;
   try {
     const settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
@@ -2174,7 +2510,7 @@ function migrateStatusline(wsPath) {
   }
 }
 function cleanupLegacyScript() {
-  const legacyScript = path8.join(os3.homedir(), ".claude", "keepgoing-statusline.sh");
+  const legacyScript = path9.join(os3.homedir(), ".claude", "keepgoing-statusline.sh");
   if (fs6.existsSync(legacyScript)) {
     try {
       fs6.unlinkSync(legacyScript);
@@ -2189,18 +2525,16 @@ function registerSetupProject(server, workspacePath) {
     "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 hasProLicense = process.env.KEEPGOING_PRO_BYPASS === "1" || !!getLicenseForFeature("session-awareness");
       const result = setupProject({
         workspacePath,
         scope,
         sessionHooks,
         claudeMd,
-        hasProLicense,
         statusline: {
           isLegacy: isLegacyStatusline,
           cleanup: cleanupLegacyScript
@@ -2217,12 +2551,12 @@ function registerSetupProject(server, workspacePath) {
 }
 
 // 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(
@@ -2296,13 +2630,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();
@@ -2368,6 +2702,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(
@@ -2533,7 +2909,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);
@@ -2561,9 +2937,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,
@@ -2604,6 +2980,126 @@ async function handleSaveCheckpoint() {
   process.exit(0);
 }
 
+// src/cli/transcriptUtils.ts
+import fs7 from "fs";
+var TAIL_READ_BYTES = 8192;
+var TOOL_VERB_MAP = {
+  Edit: "editing",
+  MultiEdit: "editing",
+  Write: "editing",
+  Read: "researching",
+  Glob: "researching",
+  Grep: "researching",
+  Bash: "running",
+  Agent: "delegating",
+  WebFetch: "browsing",
+  WebSearch: "browsing",
+  TodoWrite: "planning"
+};
+function truncateAtWord(text, max) {
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max);
+  const lastSpace = cut.lastIndexOf(" ");
+  return (lastSpace > max / 2 ? cut.slice(0, lastSpace) : cut.slice(0, max - 1)) + "\u2026";
+}
+var FILLER_PREFIX_RE = /^(i want to|can you|please|let['']?s|could you|help me|i need to|i['']d like to|implement the following plan[:\s]*|implement this plan[:\s]*)\s*/i;
+var MARKDOWN_HEADING_RE = /^#+\s+/;
+function extractTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let text = "";
+  for (const part of content) {
+    if (part.type === "text" && typeof part.text === "string") {
+      text += part.text + " ";
+    }
+  }
+  return text.trim();
+}
+function isUserEntry(entry) {
+  return entry.type === "user" && entry.message?.role === "user";
+}
+function getToolUseFromEntry(entry) {
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return null;
+  for (const part of content.slice().reverse()) {
+    if (part.type === "tool_use" && typeof part.name === "string") {
+      return part.name;
+    }
+  }
+  return null;
+}
+function isAssistantEntry(entry) {
+  return entry.message?.role === "assistant";
+}
+function extractSessionLabel(transcriptPath) {
+  if (!transcriptPath || !fs7.existsSync(transcriptPath)) return null;
+  try {
+    const raw = fs7.readFileSync(transcriptPath, "utf-8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isUserEntry(entry)) continue;
+      let text = extractTextFromContent(entry.message?.content);
+      if (!text) continue;
+      if (text.startsWith("[") || /^<[a-z][\w-]*>/.test(text)) continue;
+      text = text.replace(/@[\w./\-]+/g, "").trim();
+      text = text.replace(FILLER_PREFIX_RE, "").trim();
+      text = text.replace(MARKDOWN_HEADING_RE, "").trim();
+      text = text.replace(/\s+/g, " ").trim();
+      if (text.length < 20) continue;
+      if (text.length > 80) {
+        text = text.slice(0, 80);
+      }
+      return text;
+    }
+  } catch {
+  }
+  return null;
+}
+function extractCurrentAction(transcriptPath) {
+  if (!transcriptPath || !fs7.existsSync(transcriptPath)) return null;
+  try {
+    const stat = fs7.statSync(transcriptPath);
+    const fileSize = stat.size;
+    if (fileSize === 0) return null;
+    const readSize = Math.min(fileSize, TAIL_READ_BYTES);
+    const offset = fileSize - readSize;
+    const buf = Buffer.alloc(readSize);
+    const fd = fs7.openSync(transcriptPath, "r");
+    try {
+      fs7.readSync(fd, buf, 0, readSize, offset);
+    } finally {
+      fs7.closeSync(fd);
+    }
+    const tail = buf.toString("utf-8");
+    const lines = tail.split("\n").reverse();
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isAssistantEntry(entry)) continue;
+      const toolName = getToolUseFromEntry(entry);
+      if (toolName) {
+        return TOOL_VERB_MAP[toolName] ?? "working";
+      }
+      return "done";
+    }
+  } catch {
+  }
+  return null;
+}
+
 // src/cli/updateTask.ts
 async function handleUpdateTask() {
   const args = process.argv.slice(2);
@@ -2655,7 +3151,8 @@ async function handleUpdateTaskFromHook() {
       const writer = new KeepGoingWriter(wsPath);
       const existing = writer.readCurrentTasks();
       const sessionIdFromHook = hookData.session_id;
-      const cachedBranch = sessionIdFromHook ? existing.find((t) => t.sessionId === sessionIdFromHook)?.branch : void 0;
+      const existingSession = sessionIdFromHook ? existing.find((t) => t.sessionId === sessionIdFromHook) : void 0;
+      const cachedBranch = existingSession?.branch;
       const branch = cachedBranch ?? getCurrentBranch(wsPath) ?? void 0;
       const task = {
         taskSummary: fileName ? `${toolName} ${fileName}` : `Used ${toolName}`,
@@ -2667,6 +3164,10 @@ async function handleUpdateTaskFromHook() {
       };
       const sessionId = hookData.session_id || generateSessionId({ ...task, workspaceRoot: wsPath });
       task.sessionId = sessionId;
+      if (!existingSession?.sessionLabel && hookData.transcript_path) {
+        const label = extractSessionLabel(hookData.transcript_path);
+        if (label) task.sessionLabel = label;
+      }
       writer.upsertSession(task);
     } catch {
     }
@@ -2676,8 +3177,8 @@ async function handleUpdateTaskFromHook() {
 }
 
 // src/cli/statusline.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 var STDIN_TIMEOUT_MS2 = 3e3;
 async function handleStatusline() {
   const chunks = [];
@@ -2691,36 +3192,43 @@ async function handleStatusline() {
     clearTimeout(timeout);
     try {
       const raw = Buffer.concat(chunks).toString("utf-8").trim();
-      if (!raw) {
-        process.exit(0);
-      }
+      if (!raw) process.exit(0);
       const input = JSON.parse(raw);
       const dir = input.workspace?.current_dir ?? input.cwd;
-      if (!dir) {
-        process.exit(0);
-      }
-      const gitRoot = findGitRoot(dir);
-      const tasksFile = path10.join(gitRoot, ".keepgoing", "current-tasks.json");
-      if (!fs7.existsSync(tasksFile)) {
-        process.exit(0);
-      }
-      const data = JSON.parse(fs7.readFileSync(tasksFile, "utf-8"));
-      const branch = getCurrentBranch(gitRoot) ?? "";
-      const active = pruneStaleTasks(data.tasks ?? []).filter((t) => t.sessionActive && t.branch === branch);
-      if (active.length === 0) {
-        process.exit(0);
+      if (!dir) process.exit(0);
+      const transcriptPath = input.transcript_path;
+      const sessionId = input.session_id;
+      let label = null;
+      if (input.agent?.name) {
+        label = input.agent.name;
+      }
+      if (!label) {
+        try {
+          const gitRoot = findGitRoot(dir);
+          const tasksFile = path11.join(gitRoot, ".keepgoing", "current-tasks.json");
+          if (fs8.existsSync(tasksFile)) {
+            const data = JSON.parse(fs8.readFileSync(tasksFile, "utf-8"));
+            const tasks = pruneStaleTasks(data.tasks ?? []);
+            const match = sessionId ? tasks.find((t) => t.sessionId === sessionId) : void 0;
+            if (match?.sessionLabel) {
+              label = match.sessionLabel;
+            }
+          }
+        } catch {
+        }
       }
-      active.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
-      const task = active[active.length - 1];
-      const summary = task.taskSummary;
-      if (!summary) {
-        process.exit(0);
+      if (!label && transcriptPath) {
+        label = extractSessionLabel(transcriptPath);
       }
-      if (branch) {
-        process.stdout.write(`[KG] ${branch}: ${summary}
+      if (!label) process.exit(0);
+      const action = transcriptPath ? extractCurrentAction(transcriptPath) : null;
+      const budget = action ? 40 : 55;
+      const displayLabel = truncateAtWord(label, budget);
+      if (action) {
+        process.stdout.write(`[KG] ${displayLabel} \xB7 ${action}
 `);
       } else {
-        process.stdout.write(`[KG] ${summary}
+        process.stdout.write(`[KG] ${displayLabel}
 `);
       }
     } catch {
@@ -2730,6 +3238,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,
@@ -2737,7 +3261,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) {
@@ -2755,6 +3280,7 @@ if (flag) {
   registerGetDecisions(server, reader);
   registerGetCurrentTask(server, reader);
   registerSaveCheckpoint(server, reader, workspacePath);
+  registerContinueOn(server, reader, workspacePath);
   registerSetupProject(server, workspacePath);
   registerActivateLicense(server);
   registerDeactivateLicense(server);