@keepgoingdev/cli 1.0.0 → 1.1.1

package/dist/index.js

@@ -159,6 +159,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) {
@@ -184,6 +240,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;
@@ -359,9 +470,123 @@ function inferFocusFromFiles(files) {
   return names.join(", ");
 }
 
+// ../../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";
@@ -384,11 +609,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)) {
@@ -702,24 +927,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;
@@ -786,7 +1011,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();
@@ -828,7 +1053,7 @@ var currentGate = new DefaultFeatureGate();
 
 // ../../packages/shared/src/reader.ts
 import fs4 from "fs";
-import path5 from "path";
+import path6 from "path";
 var STORAGE_DIR2 = ".keepgoing";
 var META_FILE2 = "meta.json";
 var SESSIONS_FILE2 = "sessions.json";
@@ -850,12 +1075,12 @@ var KeepGoingReader = class {
     this.workspacePath = workspacePath;
     const mainRoot = resolveStorageRoot(workspacePath);
     this._isWorktree = mainRoot !== workspacePath;
-    this.storagePath = path5.join(mainRoot, STORAGE_DIR2);
-    this.metaFilePath = path5.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path5.join(this.storagePath, SESSIONS_FILE2);
-    this.decisionsFilePath = path5.join(this.storagePath, DECISIONS_FILE);
-    this.stateFilePath = path5.join(this.storagePath, STATE_FILE2);
-    this.currentTasksFilePath = path5.join(this.storagePath, CURRENT_TASKS_FILE2);
+    this.storagePath = path6.join(mainRoot, STORAGE_DIR2);
+    this.metaFilePath = path6.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path6.join(this.storagePath, SESSIONS_FILE2);
+    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE);
+    this.stateFilePath = path6.join(this.storagePath, STATE_FILE2);
+    this.currentTasksFilePath = path6.join(this.storagePath, CURRENT_TASKS_FILE2);
   }
   /** Check if .keepgoing/ directory exists. */
   exists() {
@@ -1111,7 +1336,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: "",
@@ -1156,19 +1381,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
   };
 }
@@ -1225,7 +1450,6 @@ function setupProject(options) {
     scope = "project",
     sessionHooks = true,
     claudeMd = true,
-    hasProLicense = false,
     statusline
   } = options;
   const messages = [];
@@ -1250,7 +1474,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 = {
@@ -1281,7 +1505,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 });
       }
@@ -1430,29 +1654,6 @@ function renderNoData() {
     `No KeepGoing data found. Run ${BOLD}keepgoing save${RESET} to save your first checkpoint.`
   );
 }
-function renderBriefing(briefing, decisions) {
-  const label = (s) => `${CYAN}${s}${RESET}`;
-  console.log(`
-${BOLD}KeepGoing Re-entry Briefing${RESET}
-`);
-  console.log(`  ${label("Last worked:")} ${briefing.lastWorked}`);
-  console.log(`  ${label("Focus:")}       ${briefing.currentFocus}`);
-  console.log(`  ${label("Activity:")}    ${briefing.recentActivity}`);
-  console.log(`  ${label("Next:")}        ${briefing.suggestedNext}`);
-  console.log(`  ${label("Quick start:")} ${briefing.smallNextStep}`);
-  if (decisions && decisions.length > 0) {
-    console.log(`
-  ${label("Recent decisions:")}`);
-    for (const d of decisions) {
-      const relTime = formatRelativeTime(d.timestamp);
-      console.log(`    ${d.classification.category}: ${d.commitMessage} ${DIM}(${relTime})${RESET}`);
-    }
-  }
-  console.log("");
-}
-function renderBriefingQuiet(briefing) {
-  console.log(`KeepGoing \xB7 ${briefing.lastWorked} \xB7 Focus: ${briefing.currentFocus} \xB7 Next: ${briefing.suggestedNext}`);
-}
 function renderMomentum(checkpoint, ctx) {
   const relTime = formatRelativeTime(checkpoint.timestamp);
   const label = (s) => `${CYAN}${s}${RESET}`;
@@ -1602,18 +1803,130 @@ function renderSessionGroupHeader(sessionId, count) {
   const shortId = sessionId.slice(0, 8);
   console.log(`${BOLD}Session ${shortId}${RESET} ${DIM}(${count} checkpoint${count !== 1 ? "s" : ""})${RESET}`);
 }
+function renderContinueOn(prompt, copied, target) {
+  console.log(`
+${BOLD}KeepGoing Continue On${RESET}
+`);
+  if (copied) {
+    console.log(`${GREEN}\u2714 Context copied to clipboard${RESET}`);
+  } else {
+    console.log(`${YELLOW}\u26A0 Could not copy to clipboard. Prompt printed below.${RESET}`);
+  }
+  if (target) {
+    console.log(`${DIM}Target: ${target}${RESET}`);
+  }
+  console.log("");
+  console.log(`${DIM}--- prompt start ---${RESET}`);
+  console.log(prompt);
+  console.log(`${DIM}--- prompt end ---${RESET}`);
+  console.log("");
+}
+function renderContinueOnQuiet(copied, target) {
+  const targetStr = target ? ` (${target})` : "";
+  if (copied) {
+    console.log(`KeepGoing \xB7 Context copied to clipboard${targetStr}`);
+  } else {
+    console.log(`KeepGoing \xB7 Failed to copy context to clipboard${targetStr}`);
+  }
+}
+function renderEnrichedBriefing(briefing) {
+  const { tier, core } = briefing;
+  const label = (s) => `${CYAN}${s}${RESET}`;
+  console.log(`
+${BOLD}KeepGoing Re-entry Briefing${RESET} ${DIM}(${tier})${RESET}
+`);
+  if (briefing.isWorktree && briefing.gitBranch) {
+    console.log(`  ${DIM}Worktree: scoped to ${briefing.gitBranch}${RESET}
+`);
+  }
+  if (tier === "compact") {
+    console.log(`  ${label("Last worked:")} ${core.lastWorked}`);
+    console.log(`  ${label("Focus:")}       ${core.currentFocus}`);
+    console.log(`  ${label("Quick start:")} ${core.smallNextStep}`);
+    console.log("");
+    return;
+  }
+  console.log(`  ${label("Last worked:")} ${core.lastWorked}`);
+  console.log(`  ${label("Focus:")}       ${core.currentFocus}`);
+  console.log(`  ${label("Activity:")}    ${core.recentActivity}`);
+  console.log(`  ${label("Next:")}        ${core.suggestedNext}`);
+  console.log(`  ${label("Quick start:")} ${core.smallNextStep}`);
+  if (briefing.blocker) {
+    console.log(`  ${label("Blocker:")}    ${YELLOW}${briefing.blocker}${RESET}`);
+  }
+  if (briefing.decisions && briefing.decisions.length > 0) {
+    console.log(`
+  ${label("Recent decisions:")}`);
+    for (const d of briefing.decisions) {
+      const relTime = formatRelativeTime(d.timestamp);
+      console.log(`    ${d.classification.category}: ${d.commitMessage} ${DIM}(${relTime})${RESET}`);
+    }
+  }
+  if (briefing.touchedFiles && briefing.touchedFiles.length > 0) {
+    console.log(`
+  ${label(`Files touched (${briefing.touchedFiles.length}):`)}`);
+    const MAX_FILES = tier === "full" ? 20 : 10;
+    const shown = briefing.touchedFiles.slice(0, MAX_FILES);
+    for (const f of shown) {
+      console.log(`    ${DIM}${f}${RESET}`);
+    }
+    if (briefing.touchedFiles.length > MAX_FILES) {
+      console.log(`    ${DIM}...and ${briefing.touchedFiles.length - MAX_FILES} more${RESET}`);
+    }
+  }
+  if (briefing.sessionHistory && briefing.sessionHistory.length > 0) {
+    console.log(`
+  ${label("Session history:")}`);
+    for (const s of briefing.sessionHistory) {
+      const relTime = formatRelativeTime(s.timestamp);
+      const branch = s.branch ? ` ${GREEN}(${s.branch})${RESET}` : "";
+      console.log(`    ${DIM}${relTime}${branch}${RESET} ${s.summary || "No summary"}`);
+      if (s.nextStep) {
+        console.log(`      ${CYAN}\u2192${RESET} ${s.nextStep}`);
+      }
+    }
+  }
+  if (briefing.recentCommits && briefing.recentCommits.length > 0) {
+    console.log(`
+  ${label("Recent commits:")}`);
+    for (const msg of briefing.recentCommits.slice(0, 10)) {
+      console.log(`    ${DIM}${msg}${RESET}`);
+    }
+  }
+  if (briefing.fileConflicts && briefing.fileConflicts.length > 0) {
+    console.log(`
+  ${YELLOW}File conflicts:${RESET}`);
+    for (const c of briefing.fileConflicts) {
+      const labels = c.sessions.map((s) => s.agentLabel || s.sessionId).join(", ");
+      console.log(`    ${c.file}: ${labels}`);
+    }
+  }
+  if (briefing.branchOverlaps && briefing.branchOverlaps.length > 0) {
+    console.log(`
+  ${YELLOW}Branch overlaps:${RESET}`);
+    for (const o of briefing.branchOverlaps) {
+      const labels = o.sessions.map((s) => s.agentLabel || s.sessionId).join(", ");
+      console.log(`    ${o.branch}: ${labels}`);
+    }
+  }
+  console.log("");
+}
+function renderEnrichedBriefingQuiet(briefing) {
+  const { core } = briefing;
+  console.log(`KeepGoing \xB7 ${core.lastWorked} \xB7 Focus: ${core.currentFocus} \xB7 Next: ${core.smallNextStep}`);
+}
 
 // src/updateCheck.ts
 import { spawn } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import path7 from "path";
+import path8 from "path";
 import os3 from "os";
-var CLI_VERSION = "1.0.0";
+var CLI_VERSION = "1.1.1";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@keepgoingdev/cli/latest";
 var FETCH_TIMEOUT_MS = 5e3;
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var CACHE_DIR = path7.join(os3.homedir(), ".keepgoing");
-var CACHE_PATH = path7.join(CACHE_DIR, "update-check.json");
+var CACHE_DIR = path8.join(os3.homedir(), ".keepgoing");
+var CACHE_PATH = path8.join(CACHE_DIR, "update-check.json");
 function isNewerVersion(current, latest) {
   const cur = current.split(".").map(Number);
   const lat = latest.split(".").map(Number);
@@ -1728,7 +2041,7 @@ async function statusCommand(opts) {
 }
 
 // src/commands/save.ts
-import path8 from "path";
+import path9 from "path";
 async function saveCommand(opts) {
   const { cwd, message, nextStepOverride, json, quiet, force } = opts;
   const isManual = !!message;
@@ -1757,9 +2070,9 @@ async function saveCommand(opts) {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path8.basename(f)).join(", ")}`;
+  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path9.basename(f)).join(", ")}`;
   const nextStep = nextStepOverride ?? buildSmartNextStep(events);
-  const projectName = path8.basename(resolveStorageRoot(cwd));
+  const projectName = path9.basename(resolveStorageRoot(cwd));
   const sessionId = generateSessionId({
     workspaceRoot: cwd,
     branch: gitBranch ?? void 0,
@@ -1793,7 +2106,7 @@ async function saveCommand(opts) {
 
 // src/commands/hook.ts
 import fs6 from "fs";
-import path9 from "path";
+import path10 from "path";
 import os4 from "os";
 import { execSync } from "child_process";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
@@ -1853,14 +2166,14 @@ function detectShellRcFile(shellOverride) {
     }
   }
   if (shell === "zsh") {
-    return { shell: "zsh", rcFile: path9.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path10.join(home, ".zshrc") };
   }
   if (shell === "bash") {
-    return { shell: "bash", rcFile: path9.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path10.join(home, ".bashrc") };
   }
   if (shell === "fish") {
-    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path9.join(home, ".config");
-    return { shell: "fish", rcFile: path9.join(xdgConfig, "fish", "config.fish") };
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path10.join(home, ".config");
+    return { shell: "fish", rcFile: path10.join(xdgConfig, "fish", "config.fish") };
   }
   return void 0;
 }
@@ -2030,30 +2343,43 @@ async function briefingCommand(opts) {
   const state = reader.getState() ?? {};
   const sinceTimestamp = lastSession?.timestamp;
   const recentCommits = sinceTimestamp ? getCommitMessagesSince(opts.cwd, sinceTimestamp) : [];
-  const briefing = generateBriefing(
+  const decisions = reader.getScopedRecentDecisions(10);
+  const allSessions = reader.getSessions();
+  const fileConflicts = reader.detectFileConflicts();
+  const branchOverlaps = reader.detectBranchOverlap();
+  const effectiveTier = opts.quiet ? "compact" : opts.tier;
+  const validTiers = ["compact", "standard", "detailed", "full"];
+  const tier = effectiveTier && validTiers.includes(effectiveTier) ? effectiveTier : void 0;
+  const briefing = generateEnrichedBriefing({
+    tier,
+    model: opts.model,
     lastSession,
     recentSessions,
-    state,
+    projectState: state,
     gitBranch,
-    recentCommits
-  );
+    recentCommits,
+    decisions,
+    allTouchedFiles: lastSession?.touchedFiles,
+    allSessions,
+    fileConflicts,
+    branchOverlaps,
+    isWorktree: reader.isWorktree
+  });
   if (!briefing) {
     if (!opts.quiet) {
       console.log("No session data available to generate a briefing.");
     }
     return;
   }
-  const decisions = reader.getScopedRecentDecisions(3);
   if (opts.json) {
-    const output = decisions.length > 0 ? { ...briefing, decisions } : briefing;
-    console.log(JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(briefing, null, 2));
     return;
   }
   if (opts.quiet) {
-    renderBriefingQuiet(briefing);
+    renderEnrichedBriefingQuiet(briefing);
     return;
   }
-  renderBriefing(briefing, decisions);
+  renderEnrichedBriefing(briefing);
 }
 
 // src/commands/init.ts
@@ -2065,11 +2391,9 @@ var CYAN2 = "\x1B[36m";
 var DIM3 = "\x1B[2m";
 function initCommand(options) {
   const scope = options.scope === "user" ? "user" : "project";
-  const hasProLicense = process.env.KEEPGOING_PRO_BYPASS === "1" || !!getLicenseForFeature("session-awareness");
   const result = setupProject({
     workspacePath: options.cwd,
-    scope,
-    hasProLicense
+    scope
   });
   console.log(`
 ${BOLD3}KeepGoing Init${RESET3} ${DIM3}(${scope} scope)${RESET3}
@@ -2415,6 +2739,83 @@ async function logCommand(opts) {
   }
 }
 
+// src/platform.ts
+import { execSync as execSync2, spawnSync } from "child_process";
+function copyToClipboard(text) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      execSync2("pbcopy", { input: text, stdio: ["pipe", "ignore", "ignore"] });
+    } else if (platform === "win32") {
+      execSync2("clip.exe", { input: text, stdio: ["pipe", "ignore", "ignore"] });
+    } else {
+      try {
+        execSync2("xclip -selection clipboard", { input: text, stdio: ["pipe", "ignore", "ignore"] });
+      } catch {
+        execSync2("xsel --clipboard --input", { input: text, stdio: ["pipe", "ignore", "ignore"] });
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openUrl(url) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      spawnSync("open", [url], { stdio: "ignore" });
+    } else if (platform === "win32") {
+      spawnSync("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    } else {
+      spawnSync("xdg-open", [url], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+
+// src/commands/continue.ts
+var TARGET_URLS = {
+  chatgpt: "https://chat.openai.com",
+  gemini: "https://gemini.google.com/app",
+  copilot: "https://github.com/copilot",
+  claude: "https://claude.ai/new"
+};
+async function continueCommand(opts) {
+  const reader = new KeepGoingReader(opts.cwd);
+  if (!reader.exists()) {
+    if (!opts.quiet) {
+      renderNoData();
+    }
+    return;
+  }
+  const context = gatherContinueOnContext(reader, opts.cwd);
+  if (!context.lastCheckpoint && !context.briefing) {
+    if (!opts.quiet) {
+      console.log("No session data available. Save a checkpoint first.");
+    }
+    return;
+  }
+  const formatOpts = {};
+  if (opts.target && opts.target in TARGET_URLS) {
+    formatOpts.target = opts.target;
+  }
+  const prompt = formatContinueOnPrompt(context, formatOpts);
+  if (opts.json) {
+    console.log(JSON.stringify({ prompt, context }, null, 2));
+    return;
+  }
+  const copied = copyToClipboard(prompt);
+  if (opts.quiet) {
+    renderContinueOnQuiet(copied, opts.target);
+    return;
+  }
+  renderContinueOn(prompt, copied, opts.target);
+  if (opts.open && opts.target && TARGET_URLS[opts.target]) {
+    openUrl(TARGET_URLS[opts.target]);
+  }
+}
+
 // src/index.ts
 var HELP_TEXT = `
 keepgoing: resume side projects without the mental friction
@@ -2428,6 +2829,7 @@ Commands:
   briefing            Get a re-entry briefing for this project
   decisions           View decision history (Pro)
   log                 Browse session checkpoints
+  continue            Export context for use in another AI tool
   save                Save a checkpoint (auto-generates from git)
   hook                Manage the shell hook (zsh, bash, fish)
   activate <key>      Activate a Pro license on this device
@@ -2487,6 +2889,8 @@ keepgoing briefing: Get a re-entry briefing for this project
 Usage: keepgoing briefing [options]
 
 Options:
+  --tier <tier>   Detail level: compact, standard (default), detailed, full
+  --model <name>  Auto-resolve tier from model name (e.g. "claude-opus-4")
   --json          Output raw JSON
   --quiet         Suppress output
   --cwd <path>    Override the working directory
@@ -2582,6 +2986,23 @@ Example:
 keepgoing deactivate: Deactivate the Pro license from this device
 
 Usage: keepgoing deactivate [<key>]
+`,
+  continue: `
+keepgoing continue: Export context for use in another AI tool
+
+Usage: keepgoing continue [options]
+
+Options:
+  --target <tool>  Target AI tool (chatgpt, gemini, copilot, claude, general)
+  --open           Auto-open the target tool's URL in your browser
+  --json           Output raw JSON (prompt + context)
+  --quiet          Suppress output (just copy to clipboard)
+  --cwd <path>     Override the working directory
+
+Examples:
+  keepgoing continue                          Copy context to clipboard
+  keepgoing continue --target chatgpt --open  Copy and open ChatGPT
+  keepgoing continue --json                   Output as JSON
 `
 };
 function parseArgs(argv) {
@@ -2611,6 +3032,10 @@ function parseArgs(argv) {
   let today = false;
   let week = false;
   let sessions = false;
+  let target = "";
+  let open = false;
+  let tier = "";
+  let model = "";
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--cwd" && i + 1 < args.length) {
@@ -2633,6 +3058,10 @@ function parseArgs(argv) {
       branch = args[++i];
     } else if (arg === "--limit" && i + 1 < args.length) {
       limit = parseInt(args[++i], 10) || 10;
+    } else if (arg === "--target" && i + 1 < args.length) {
+      target = args[++i];
+    } else if (arg === "--open") {
+      open = true;
     } else if (arg === "--json") {
       json = true;
     } else if (arg === "--quiet") {
@@ -2661,6 +3090,10 @@ function parseArgs(argv) {
       week = true;
     } else if (arg === "--sessions") {
       sessions = true;
+    } else if (arg === "--tier" && i + 1 < args.length) {
+      tier = args[++i];
+    } else if (arg === "--model" && i + 1 < args.length) {
+      model = args[++i];
     } else if (arg === "-v" || arg === "--version") {
       command = "version";
     } else if (arg === "-h" || arg === "--help") {
@@ -2697,7 +3130,11 @@ function parseArgs(argv) {
     blockerOnly,
     today,
     week,
-    sessions
+    sessions,
+    target,
+    open,
+    tier,
+    model
   };
 }
 async function main() {
@@ -2724,7 +3161,13 @@ async function main() {
       await momentumCommand({ cwd, json, quiet });
       break;
     case "briefing":
-      await briefingCommand({ cwd, json, quiet });
+      await briefingCommand({
+        cwd,
+        json,
+        quiet,
+        tier: parsed.tier || void 0,
+        model: parsed.model || void 0
+      });
       break;
     case "decisions":
       await decisionsCommand({ cwd, json, quiet, branch, limit });
@@ -2750,6 +3193,9 @@ async function main() {
         sessions: parsed.sessions
       });
       break;
+    case "continue":
+      await continueCommand({ cwd, json, quiet, target: parsed.target, open: parsed.open });
+      break;
     case "save":
       await saveCommand({
         cwd,
@@ -2770,7 +3216,7 @@ async function main() {
       }
       break;
     case "version":
-      console.log(`keepgoing v${"1.0.0"}`);
+      console.log(`keepgoing v${"1.1.1"}`);
       break;
     case "activate":
       await activateCommand({ licenseKey: subcommand });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepgoingdev/cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Terminal CLI for KeepGoing. Resume side projects without the mental friction.",
   "type": "module",
   "main": "./dist/index.js",