@keepgoingdev/cli 0.3.3 → 1.1.0

package/dist/index.js

@@ -105,6 +105,44 @@ function getCurrentBranch(workspacePath) {
     return void 0;
   }
 }
+function getGitLogSince(workspacePath, format, sinceTimestamp) {
+  try {
+    const since = sinceTimestamp || new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+    const result = execFileSync(
+      "git",
+      ["log", `--since=${since}`, `--format=${format}`],
+      {
+        cwd: workspacePath,
+        encoding: "utf-8",
+        timeout: 5e3
+      }
+    );
+    if (!result.trim()) {
+      return [];
+    }
+    return result.trim().split("\n").filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+function getCommitsSince(workspacePath, sinceTimestamp) {
+  return getGitLogSince(workspacePath, "%H", sinceTimestamp);
+}
+function getCommitMessagesSince(workspacePath, sinceTimestamp) {
+  return getGitLogSince(workspacePath, "%s", sinceTimestamp);
+}
+function getFilesChangedInCommit(workspacePath, commitHash) {
+  try {
+    const result = execFileSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    return result.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
 function getTouchedFiles(workspacePath) {
   try {
     const result = execFileSync("git", ["status", "--porcelain"], {
@@ -121,15 +159,434 @@ 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) {
+  if (!lastSession) {
+    return void 0;
+  }
+  return {
+    lastWorked: formatRelativeTime(lastSession.timestamp),
+    currentFocus: buildCurrentFocus(lastSession, projectState, gitBranch),
+    recentActivity: buildRecentActivity(
+      lastSession,
+      recentSessions,
+      recentCommitMessages
+    ),
+    suggestedNext: buildSuggestedNext(lastSession, gitBranch),
+    smallNextStep: buildSmallNextStep(
+      lastSession,
+      gitBranch,
+      recentCommitMessages
+    )
+  };
+}
 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;
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return branchFocus;
+  }
+  if (lastSession.summary) {
+    return lastSession.summary;
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    return inferFocusFromFiles(lastSession.touchedFiles);
+  }
+  return "Unknown, save a checkpoint to set context";
+}
+function buildRecentActivity(lastSession, recentSessions, recentCommitMessages) {
+  const parts = [];
+  const sessionCount = recentSessions.length;
+  if (sessionCount > 1) {
+    parts.push(`${sessionCount} recent sessions`);
+  } else if (sessionCount === 1) {
+    parts.push("1 recent session");
+  }
+  if (lastSession.summary) {
+    parts.push(`Last: ${lastSession.summary}`);
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    parts.push(`${lastSession.touchedFiles.length} files touched`);
+  }
+  if (recentCommitMessages && recentCommitMessages.length > 0) {
+    parts.push(`${recentCommitMessages.length} recent commits`);
+  }
+  return parts.length > 0 ? parts.join(". ") : "No recent activity recorded";
+}
+function buildSuggestedNext(lastSession, gitBranch) {
+  if (lastSession.nextStep) {
+    return lastSession.nextStep;
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return `Continue working on ${branchFocus}`;
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    return `Continue working on ${inferFocusFromFiles(lastSession.touchedFiles)}`;
+  }
+  return "Save a checkpoint to track your next step";
+}
+function buildSmallNextStep(lastSession, gitBranch, recentCommitMessages) {
+  const fallback = "Review last changed files to resume flow";
+  if (lastSession.nextStep) {
+    const distilled = distillToSmallStep(
+      lastSession.nextStep,
+      lastSession.touchedFiles
+    );
+    if (distilled) {
+      return distilled;
+    }
+  }
+  if (recentCommitMessages && recentCommitMessages.length > 0) {
+    const commitStep = deriveStepFromCommits(recentCommitMessages);
+    if (commitStep) {
+      return commitStep;
+    }
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    const fileStep = deriveStepFromFiles(lastSession.touchedFiles);
+    if (fileStep) {
+      return fileStep;
+    }
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return `Check git status for ${branchFocus}`;
+  }
+  return fallback;
+}
+function distillToSmallStep(nextStep, touchedFiles) {
+  if (!nextStep.trim()) {
+    return void 0;
+  }
+  const words = nextStep.trim().split(/\s+/);
+  if (words.length <= 12) {
+    if (touchedFiles.length > 0 && !mentionsFile(nextStep)) {
+      const primaryFile = getPrimaryFileName(touchedFiles);
+      const enhanced = `${nextStep.trim()} in ${primaryFile}`;
+      if (enhanced.split(/\s+/).length <= 12) {
+        return enhanced;
+      }
+    }
+    return nextStep.trim();
+  }
+  return words.slice(0, 12).join(" ");
+}
+function deriveStepFromCommits(commitMessages) {
+  const lastCommit = commitMessages[0];
+  if (!lastCommit || !lastCommit.trim()) {
+    return void 0;
+  }
+  const wipPattern = /^(?:wip|work in progress|started?|begin|draft)[:\s]/i;
+  if (wipPattern.test(lastCommit)) {
+    const topic = lastCommit.replace(wipPattern, "").trim();
+    if (topic) {
+      const words = topic.split(/\s+/).slice(0, 8).join(" ");
+      return `Continue ${words}`;
+    }
+  }
+  return void 0;
+}
+function deriveStepFromFiles(files) {
+  const primaryFile = getPrimaryFileName(files);
+  if (files.length > 1) {
+    return `Open ${primaryFile} and review ${files.length} changed files`;
+  }
+  return `Open ${primaryFile} and pick up where you left off`;
+}
+function getPrimaryFileName(files) {
+  const sourceFiles = files.filter((f) => {
+    const lower = f.toLowerCase();
+    return !lower.includes("test") && !lower.includes("spec") && !lower.includes(".config") && !lower.includes("package.json") && !lower.includes("tsconfig");
+  });
+  const target = sourceFiles.length > 0 ? sourceFiles[0] : files[0];
+  const parts = target.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1];
+}
+function mentionsFile(text) {
+  return /\w+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|css|scss|html|json|yaml|yml|md|sql|sh)\b/i.test(
+    text
+  );
+}
+function inferFocusFromBranch(branch) {
+  if (!branch || branch === "main" || branch === "master" || branch === "develop" || branch === "HEAD") {
+    return void 0;
+  }
+  const prefixPattern = /^(?:feature|feat|fix|bugfix|hotfix|chore|refactor|docs|test|ci)\//i;
+  const isFix = /^(?:fix|bugfix|hotfix)\//i.test(branch);
+  const stripped = branch.replace(prefixPattern, "");
+  const cleaned = stripped.replace(/[-_/]/g, " ").replace(/^\d+\s*/, "").trim();
+  if (!cleaned) {
+    return void 0;
+  }
+  return isFix ? `${cleaned} fix` : cleaned;
+}
+function inferFocusFromFiles(files) {
+  if (files.length === 0) {
+    return "unknown files";
+  }
+  const dirs = files.map((f) => {
+    const parts = f.replace(/\\/g, "/").split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+  }).filter((d) => d.length > 0);
+  if (dirs.length > 0) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const dir of dirs) {
+      counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    let topDir = "";
+    let topCount = 0;
+    for (const [dir, count] of counts) {
+      if (count > topCount) {
+        topDir = dir;
+        topCount = count;
+      }
+    }
+    if (topDir) {
+      return `files in ${topDir}`;
+    }
+  }
+  const names = files.slice(0, 3).map((f) => {
+    const parts = f.replace(/\\/g, "/").split("/");
+    return parts[parts.length - 1];
+  });
+  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";
@@ -152,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)) {
@@ -306,26 +763,188 @@ function generateSessionId(context) {
   return `ses_${hash}`;
 }
 
+// ../../packages/shared/src/smartSummary.ts
+var PREFIX_VERBS = {
+  feat: "Added",
+  fix: "Fixed",
+  refactor: "Refactored",
+  docs: "Updated docs for",
+  test: "Added tests for",
+  chore: "Updated",
+  style: "Styled",
+  perf: "Optimized",
+  ci: "Updated CI for",
+  build: "Updated build for",
+  revert: "Reverted"
+};
+var NOISE_PATTERNS = [
+  "node_modules",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  ".gitignore",
+  ".DS_Store",
+  "dist/",
+  "out/",
+  "build/"
+];
+function categorizeCommits(messages) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const match = msg.match(/^(\w+)(?:\([^)]*\))?[!]?:\s*(.+)/);
+    if (match) {
+      const prefix = match[1].toLowerCase();
+      const body = match[2].trim();
+      if (!groups.has(prefix)) {
+        groups.set(prefix, []);
+      }
+      groups.get(prefix).push(body);
+    } else {
+      if (!groups.has("other")) {
+        groups.set("other", []);
+      }
+      groups.get("other").push(msg.trim());
+    }
+  }
+  return groups;
+}
+function inferWorkAreas(files) {
+  const areas = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (NOISE_PATTERNS.some((p) => file.includes(p))) {
+      continue;
+    }
+    const parts = file.split("/").filter(Boolean);
+    let area;
+    if (parts.length >= 2 && (parts[0] === "apps" || parts[0] === "packages")) {
+      area = parts[1];
+      if (parts[0] === "packages" && parts.length >= 4 && parts[2] === "src") {
+        const subFile = parts[3].replace(/\.\w+$/, "");
+        area = `${parts[1]} ${subFile}`;
+      }
+    } else if (parts.length >= 2) {
+      area = parts[0];
+    } else {
+      area = "root";
+    }
+    areas.set(area, (areas.get(area) ?? 0) + 1);
+  }
+  return [...areas.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([name]) => name);
+}
+function buildSessionEvents(opts) {
+  const { wsPath, commitHashes, commitMessages, touchedFiles, currentBranch, sessionStartTime, lastActivityTime } = opts;
+  const commits = commitHashes.map((hash, i) => ({
+    hash,
+    message: commitMessages[i] ?? "",
+    filesChanged: getFilesChangedInCommit(wsPath, hash),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  const committedFiles = new Set(commits.flatMap((c) => c.filesChanged));
+  return {
+    commits,
+    branchSwitches: [],
+    touchedFiles,
+    currentBranch,
+    sessionStartTime,
+    lastActivityTime,
+    // Normalize rename arrows ("old -> new") from git status --porcelain
+    // so they match the plain filenames from git diff-tree --name-only.
+    hasUncommittedChanges: touchedFiles.some((f) => {
+      const normalized = f.includes(" -> ") ? f.split(" -> ").pop() : f;
+      return !committedFiles.has(normalized);
+    })
+  };
+}
+function buildSmartSummary(events) {
+  const { commits, branchSwitches, touchedFiles, hasUncommittedChanges } = events;
+  if (commits.length === 0 && touchedFiles.length === 0 && branchSwitches.length === 0) {
+    return void 0;
+  }
+  const parts = [];
+  if (commits.length > 0) {
+    const messages = commits.map((c) => c.message);
+    const groups = categorizeCommits(messages);
+    const phrases = [];
+    for (const [prefix, bodies] of groups) {
+      const verb = PREFIX_VERBS[prefix] ?? (prefix === "other" ? "" : `${capitalize(prefix)}:`);
+      const items = bodies.slice(0, 2).join(" and ");
+      const overflow = bodies.length > 2 ? ` (+${bodies.length - 2} more)` : "";
+      if (verb) {
+        phrases.push(`${verb} ${items}${overflow}`);
+      } else {
+        phrases.push(`${items}${overflow}`);
+      }
+    }
+    parts.push(phrases.join(", "));
+  } else if (touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    const areaStr = areas.length > 0 ? areas.join(" and ") : `${touchedFiles.length} files`;
+    const suffix = hasUncommittedChanges ? " (uncommitted)" : "";
+    parts.push(`Worked on ${areaStr}${suffix}`);
+  }
+  if (branchSwitches.length > 0) {
+    const last = branchSwitches[branchSwitches.length - 1];
+    if (branchSwitches.length === 1) {
+      parts.push(`switched to ${last.toBranch}`);
+    } else {
+      parts.push(`switched branches ${branchSwitches.length} times, ended on ${last.toBranch}`);
+    }
+  }
+  const result = parts.join("; ");
+  return result || void 0;
+}
+function buildSmartNextStep(events) {
+  const { commits, touchedFiles, currentBranch, hasUncommittedChanges } = events;
+  if (hasUncommittedChanges && touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    const areaStr = areas.length > 0 ? areas.join(" and ") : "working tree";
+    return `Review and commit changes in ${areaStr}`;
+  }
+  if (commits.length > 0) {
+    const lastMsg = commits[commits.length - 1].message;
+    const wipMatch = lastMsg.match(/^(?:wip|work in progress|start(?:ed)?|begin|draft)[:\s]+(.+)/i);
+    if (wipMatch) {
+      return `Continue ${wipMatch[1].trim()}`;
+    }
+  }
+  if (currentBranch && !["main", "master", "develop", "HEAD"].includes(currentBranch)) {
+    const branchName = currentBranch.replace(/^(feat|feature|fix|bugfix|hotfix|chore|refactor)[/-]/i, "").replace(/[-_]/g, " ").trim();
+    if (branchName) {
+      return `Continue ${branchName}`;
+    }
+  }
+  if (touchedFiles.length > 0) {
+    const areas = inferWorkAreas(touchedFiles);
+    if (areas.length > 0) {
+      return `Review recent changes in ${areas.join(" and ")}`;
+    }
+  }
+  return "";
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
 // ../../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;
@@ -392,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();
@@ -415,6 +1034,13 @@ function removeLicenseEntry(licenseKey) {
 function getActiveLicenses() {
   return readLicenseStore().licenses.filter((l) => l.status === "active");
 }
+function getLicenseForFeature(feature) {
+  const active = getActiveLicenses();
+  return active.find((l) => {
+    const features = VARIANT_FEATURE_MAP[l.variantId];
+    return features?.includes(feature);
+  });
+}
 var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 
 // ../../packages/shared/src/featureGate.ts
@@ -425,66 +1051,533 @@ var DefaultFeatureGate = class {
 };
 var currentGate = new DefaultFeatureGate();
 
-// ../../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.";
+// ../../packages/shared/src/reader.ts
+import fs4 from "fs";
+import path6 from "path";
+var STORAGE_DIR2 = ".keepgoing";
+var META_FILE2 = "meta.json";
+var SESSIONS_FILE2 = "sessions.json";
+var DECISIONS_FILE = "decisions.json";
+var STATE_FILE2 = "state.json";
+var CURRENT_TASKS_FILE2 = "current-tasks.json";
+var KeepGoingReader = class {
+  workspacePath;
+  storagePath;
+  metaFilePath;
+  sessionsFilePath;
+  decisionsFilePath;
+  stateFilePath;
+  currentTasksFilePath;
+  _isWorktree;
+  _cachedBranch = null;
+  // null = not yet resolved
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    const mainRoot = resolveStorageRoot(workspacePath);
+    this._isWorktree = mainRoot !== workspacePath;
+    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() {
+    return fs4.existsSync(this.storagePath);
   }
-  return void 0;
-}
-async function safeJson(res) {
-  try {
-    const text = await res.text();
-    return JSON.parse(text);
-  } catch {
-    return null;
+  /** Read state.json, returns undefined if missing or corrupt. */
+  getState() {
+    return this.readJsonFile(this.stateFilePath);
   }
-}
-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})` };
+  /** Read meta.json, returns undefined if missing or corrupt. */
+  getMeta() {
+    return this.readJsonFile(this.metaFilePath);
+  }
+  /**
+   * Read sessions from sessions.json.
+   * Handles both formats:
+   * - Flat array: SessionCheckpoint[] (from ProjectStorage)
+   * - Wrapper object: ProjectSessions (from SessionStorage)
+   */
+  getSessions() {
+    return this.parseSessions().sessions;
+  }
+  /**
+   * Get the most recent session checkpoint.
+   * Uses state.lastSessionId if available, falls back to last in array.
+   */
+  getLastSession() {
+    const { sessions, wrapperLastSessionId } = this.parseSessions();
+    if (sessions.length === 0) {
+      return void 0;
     }
-    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);
+    const state = this.getState();
+    if (state?.lastSessionId) {
+      const found = sessions.find((s) => s.id === state.lastSessionId);
+      if (found) {
+        return found;
       }
-      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." };
+    if (wrapperLastSessionId) {
+      const found = sessions.find((s) => s.id === wrapperLastSessionId);
+      if (found) {
+        return found;
       }
     }
-    return {
-      valid: true,
-      licenseKey: data.license_key?.key,
+    return sessions[sessions.length - 1];
+  }
+  /**
+   * Returns the last N sessions, newest first.
+   */
+  getRecentSessions(count) {
+    return getRecentSessions(this.getSessions(), count);
+  }
+  /** Read all decisions from decisions.json. */
+  getDecisions() {
+    return this.parseDecisions().decisions;
+  }
+  /** Returns the last N decisions, newest first. */
+  getRecentDecisions(count) {
+    const all = this.getDecisions();
+    return all.slice(-count).reverse();
+  }
+  /** Read the multi-license store from `~/.keepgoing/license.json`. */
+  getLicenseStore() {
+    return readLicenseStore();
+  }
+  /**
+   * Read all current tasks from current-tasks.json.
+   * Automatically filters out stale finished sessions (> 2 hours).
+   */
+  getCurrentTasks() {
+    const multiRaw = this.readJsonFile(this.currentTasksFilePath);
+    if (multiRaw) {
+      const tasks = Array.isArray(multiRaw) ? multiRaw : multiRaw.tasks ?? [];
+      return this.pruneStale(tasks);
+    }
+    return [];
+  }
+  /** Get only active sessions (sessionActive=true and within stale threshold). */
+  getActiveTasks() {
+    return this.getCurrentTasks().filter((t) => t.sessionActive);
+  }
+  /** Get a specific session by ID. */
+  getTaskBySessionId(sessionId) {
+    return this.getCurrentTasks().find((t) => t.sessionId === sessionId);
+  }
+  /**
+   * Detect files being edited by multiple sessions simultaneously.
+   * Returns pairs of session IDs and the conflicting file paths.
+   */
+  detectFileConflicts() {
+    const activeTasks = this.getActiveTasks();
+    if (activeTasks.length < 2) return [];
+    const fileToSessions = /* @__PURE__ */ new Map();
+    for (const task of activeTasks) {
+      if (task.lastFileEdited && task.sessionId) {
+        const existing = fileToSessions.get(task.lastFileEdited) ?? [];
+        existing.push({
+          sessionId: task.sessionId,
+          agentLabel: task.agentLabel,
+          branch: task.branch
+        });
+        fileToSessions.set(task.lastFileEdited, existing);
+      }
+    }
+    const conflicts = [];
+    for (const [file, sessions] of fileToSessions) {
+      if (sessions.length > 1) {
+        conflicts.push({ file, sessions });
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Detect sessions on the same branch (possible duplicate work).
+   */
+  detectBranchOverlap() {
+    const activeTasks = this.getActiveTasks();
+    if (activeTasks.length < 2) return [];
+    const branchToSessions = /* @__PURE__ */ new Map();
+    for (const task of activeTasks) {
+      if (task.branch && task.sessionId) {
+        const existing = branchToSessions.get(task.branch) ?? [];
+        existing.push({ sessionId: task.sessionId, agentLabel: task.agentLabel });
+        branchToSessions.set(task.branch, existing);
+      }
+    }
+    const overlaps = [];
+    for (const [branch, sessions] of branchToSessions) {
+      if (sessions.length > 1) {
+        overlaps.push({ branch, sessions });
+      }
+    }
+    return overlaps;
+  }
+  pruneStale(tasks) {
+    return pruneStaleTasks(tasks);
+  }
+  /** Get the last session checkpoint for a specific branch. */
+  getLastSessionForBranch(branch) {
+    const sessions = this.getSessions().filter((s) => s.gitBranch === branch);
+    return sessions.length > 0 ? sessions[sessions.length - 1] : void 0;
+  }
+  /** Returns the last N sessions for a specific branch, newest first. */
+  getRecentSessionsForBranch(branch, count) {
+    const filtered = this.getSessions().filter((s) => s.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Returns the last N decisions for a specific branch, newest first. */
+  getRecentDecisionsForBranch(branch, count) {
+    const filtered = this.getDecisions().filter((d) => d.gitBranch === branch);
+    return filtered.slice(-count).reverse();
+  }
+  /** Whether the workspace is inside a git worktree. */
+  get isWorktree() {
+    return this._isWorktree;
+  }
+  /**
+   * Returns the current git branch for this workspace.
+   * Lazily cached: the branch is resolved once per KeepGoingReader instance.
+   */
+  getCurrentBranch() {
+    if (this._cachedBranch === null) {
+      this._cachedBranch = getCurrentBranch(this.workspacePath);
+    }
+    return this._cachedBranch;
+  }
+  /**
+   * Worktree-aware last session lookup.
+   * In a worktree, scopes to the current branch with fallback to global.
+   * Returns the session and whether it fell back to global.
+   */
+  getScopedLastSession() {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      const scoped = this.getLastSessionForBranch(branch);
+      if (scoped) return { session: scoped, isFallback: false };
+      return { session: this.getLastSession(), isFallback: true };
+    }
+    return { session: this.getLastSession(), isFallback: false };
+  }
+  /** Worktree-aware recent sessions. Scopes to current branch in a worktree. */
+  getScopedRecentSessions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentSessionsForBranch(branch, count);
+    }
+    return this.getRecentSessions(count);
+  }
+  /** Worktree-aware recent decisions. Scopes to current branch in a worktree. */
+  getScopedRecentDecisions(count) {
+    const branch = this.getCurrentBranch();
+    if (this._isWorktree && branch) {
+      return this.getRecentDecisionsForBranch(branch, count);
+    }
+    return this.getRecentDecisions(count);
+  }
+  /**
+   * Resolves branch scope from an explicit `branch` parameter.
+   * Used by tools that accept a `branch` argument (e.g. get_session_history, get_decisions).
+   * - `"all"` returns no filter.
+   * - An explicit branch name uses that.
+   * - `undefined` auto-scopes to the current branch in a worktree, or all branches otherwise.
+   */
+  resolveBranchScope(branch) {
+    if (branch === "all") {
+      return { effectiveBranch: void 0, scopeLabel: "all branches" };
+    }
+    if (branch) {
+      return { effectiveBranch: branch, scopeLabel: `branch \`${branch}\`` };
+    }
+    const currentBranch = this.getCurrentBranch();
+    if (this._isWorktree && currentBranch) {
+      return { effectiveBranch: currentBranch, scopeLabel: `branch \`${currentBranch}\` (worktree)` };
+    }
+    return { effectiveBranch: void 0, scopeLabel: "all branches" };
+  }
+  /**
+   * Parses sessions.json once, returning both the session list
+   * and the optional lastSessionId from a ProjectSessions wrapper.
+   */
+  parseSessions() {
+    const raw = this.readJsonFile(
+      this.sessionsFilePath
+    );
+    if (!raw) {
+      return { sessions: [] };
+    }
+    if (Array.isArray(raw)) {
+      return { sessions: raw };
+    }
+    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+  }
+  parseDecisions() {
+    const raw = this.readJsonFile(this.decisionsFilePath);
+    if (!raw) {
+      return { decisions: [] };
+    }
+    return { decisions: raw.decisions ?? [], lastDecisionId: raw.lastDecisionId };
+  }
+  readJsonFile(filePath) {
+    try {
+      if (!fs4.existsSync(filePath)) {
+        return void 0;
+      }
+      const raw = fs4.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// ../../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"
+    }
+  ]
+};
+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)
+`;
+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,
@@ -514,78 +1607,14 @@ async function deactivateLicense(licenseKey, instanceId) {
   }
 }
 
-// src/storage.ts
-import fs4 from "fs";
-import path5 from "path";
-var STORAGE_DIR2 = ".keepgoing";
-var META_FILE2 = "meta.json";
-var SESSIONS_FILE2 = "sessions.json";
-var STATE_FILE2 = "state.json";
-var KeepGoingReader = class {
-  storagePath;
-  metaFilePath;
-  sessionsFilePath;
-  stateFilePath;
-  constructor(workspacePath) {
-    this.storagePath = path5.join(workspacePath, STORAGE_DIR2);
-    this.metaFilePath = path5.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path5.join(this.storagePath, SESSIONS_FILE2);
-    this.stateFilePath = path5.join(this.storagePath, STATE_FILE2);
-  }
-  exists() {
-    return fs4.existsSync(this.storagePath);
-  }
-  getState() {
-    return this.readJsonFile(this.stateFilePath);
-  }
-  getMeta() {
-    return this.readJsonFile(this.metaFilePath);
-  }
-  getSessions() {
-    return this.parseSessions().sessions;
-  }
-  getLastSession() {
-    const { sessions, wrapperLastSessionId } = this.parseSessions();
-    if (sessions.length === 0) {
-      return void 0;
-    }
-    const state = this.getState();
-    if (state?.lastSessionId) {
-      const found = sessions.find((s) => s.id === state.lastSessionId);
-      if (found) return found;
-    }
-    if (wrapperLastSessionId) {
-      const found = sessions.find((s) => s.id === wrapperLastSessionId);
-      if (found) return found;
-    }
-    return sessions[sessions.length - 1];
-  }
-  getRecentSessions(count) {
-    return getRecentSessions(this.getSessions(), count);
-  }
-  parseSessions() {
-    const raw = this.readJsonFile(this.sessionsFilePath);
-    if (!raw) return { sessions: [] };
-    if (Array.isArray(raw)) return { sessions: raw };
-    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
-  }
-  readJsonFile(filePath) {
-    try {
-      if (!fs4.existsSync(filePath)) return void 0;
-      const raw = fs4.readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-};
-
 // src/render.ts
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
 var CYAN = "\x1B[36m";
+var MAGENTA = "\x1B[35m";
 function renderCheckpoint(checkpoint, daysSince) {
   const relTime = formatRelativeTime(checkpoint.timestamp);
   if (daysSince !== void 0 && daysSince >= 7) {
@@ -626,18 +1655,279 @@ function renderNoData() {
     `No KeepGoing data found. Run ${BOLD}keepgoing save${RESET} to save your first checkpoint.`
   );
 }
+function renderMomentum(checkpoint, ctx) {
+  const relTime = formatRelativeTime(checkpoint.timestamp);
+  const label = (s) => `${CYAN}${s}${RESET}`;
+  console.log(`
+${BOLD}KeepGoing Momentum${RESET} \xB7 ${DIM}${relTime}${RESET}
+`);
+  if (ctx.isWorktree && ctx.currentBranch) {
+    console.log(`  ${DIM}Worktree: scoped to ${ctx.currentBranch}${RESET}`);
+    if (ctx.isFallback) {
+      console.log(`  ${YELLOW}No checkpoints for this branch, showing last global checkpoint${RESET}`);
+    }
+    console.log("");
+  }
+  if (checkpoint.summary) {
+    console.log(`  ${label("Summary:")}   ${checkpoint.summary}`);
+  }
+  if (checkpoint.nextStep) {
+    console.log(`  ${label("Next step:")} ${checkpoint.nextStep}`);
+  }
+  if (checkpoint.blocker) {
+    console.log(`  ${label("Blocker:")}   ${YELLOW}${checkpoint.blocker}${RESET}`);
+  }
+  if (checkpoint.projectIntent) {
+    console.log(`  ${label("Intent:")}    ${checkpoint.projectIntent}`);
+  }
+  if (ctx.currentBranch) {
+    console.log(`  ${label("Branch:")}    ${ctx.currentBranch}`);
+  }
+  if (ctx.branchChanged && !ctx.isWorktree) {
+    console.log(`  ${YELLOW}\u26A0 Branch changed since last checkpoint (was ${checkpoint.gitBranch})${RESET}`);
+  }
+  if (checkpoint.touchedFiles && checkpoint.touchedFiles.length > 0) {
+    const MAX_FILES = 5;
+    const shown = checkpoint.touchedFiles.slice(0, MAX_FILES).join(", ");
+    const extra = checkpoint.touchedFiles.length - MAX_FILES;
+    const filesStr = extra > 0 ? `${shown} (+${extra} more)` : shown;
+    console.log(`  ${label("Files:")}     ${filesStr}`);
+  }
+  if (ctx.derivedFocus) {
+    console.log(`  ${label("Focus:")}     ${ctx.derivedFocus}`);
+  }
+  console.log("");
+}
+function renderMomentumQuiet(checkpoint) {
+  const relTime = formatRelativeTime(checkpoint.timestamp);
+  const summary = checkpoint.summary || checkpoint.nextStep || "no momentum data";
+  console.log(`KeepGoing \xB7 ${relTime} \xB7 ${summary}`);
+}
+function renderSaveConfirmation(summary, fileCount, branch) {
+  const parts = [];
+  if (fileCount > 0) parts.push(`${fileCount} file${fileCount === 1 ? "" : "s"}`);
+  if (branch) parts.push(branch);
+  const meta = parts.length > 0 ? ` ${DIM}(${parts.join(", ")})${RESET}` : "";
+  console.log(`${GREEN}\u2714 Saved:${RESET} ${summary}${meta}`);
+}
+function renderDecisions(decisions, scopeLabel) {
+  const label = (s) => `${CYAN}${s}${RESET}`;
+  console.log(`
+${BOLD}KeepGoing Decisions${RESET} ${DIM}(last ${decisions.length}, ${scopeLabel})${RESET}
+`);
+  for (const d of decisions) {
+    const relTime = formatRelativeTime(d.timestamp);
+    const confidence = `${(d.classification.confidence * 100).toFixed(0)}%`;
+    console.log(`  ${label(d.classification.category + ":")} ${d.commitMessage}  ${DIM}${confidence} \xB7 ${relTime}${RESET}`);
+    if (d.classification.reasons.length > 0) {
+      console.log(`    ${DIM}Signals: ${d.classification.reasons.join("; ")}${RESET}`);
+    }
+  }
+  console.log("");
+}
+function renderDecisionsQuiet(decisions) {
+  const latest = decisions[0];
+  if (!latest) return;
+  const relTime = formatRelativeTime(latest.timestamp);
+  console.log(`KeepGoing \xB7 ${decisions.length} decision${decisions.length === 1 ? "" : "s"} \xB7 latest: ${latest.classification.category}: ${latest.commitMessage} (${relTime})`);
+}
+function formatDuration(minutes) {
+  if (minutes < 60) return `${minutes}m`;
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+function renderLogSession(session, showStat) {
+  const relTime = formatRelativeTime(session.timestamp);
+  const branch = session.gitBranch ? ` ${GREEN}(${session.gitBranch})${RESET}` : "";
+  const source = session.source ? `  ${DIM}[${session.source}]${RESET}` : "";
+  console.log(`${BOLD}\u25CF${RESET} ${DIM}${relTime}${RESET}${branch}${source}`);
+  if (session.summary) {
+    console.log(`  ${session.summary}`);
+  }
+  if (session.nextStep) {
+    console.log(`  ${CYAN}\u2192 Next:${RESET} ${session.nextStep}`);
+  }
+  const parts = [];
+  if (session.sessionDuration) {
+    parts.push(`\u23F1 ${formatDuration(session.sessionDuration)}`);
+  }
+  if (session.touchedFiles && session.touchedFiles.length > 0) {
+    parts.push(`${session.touchedFiles.length} file${session.touchedFiles.length !== 1 ? "s" : ""}`);
+  }
+  if (parts.length > 0) {
+    console.log(`  ${DIM}${parts.join(" \xB7 ")}${RESET}`);
+  }
+  if (session.blocker) {
+    console.log(`  ${YELLOW}\u26A0 Blocker: ${session.blocker}${RESET}`);
+  }
+  if (showStat && session.touchedFiles && session.touchedFiles.length > 0) {
+    for (const f of session.touchedFiles) {
+      console.log(`    ${DIM}${f}${RESET}`);
+    }
+  }
+}
+function renderLogSessionOneline(session) {
+  const id = session.id.slice(0, 7);
+  const relTime = formatRelativeTime(session.timestamp);
+  const branch = session.gitBranch ? `  ${GREEN}(${session.gitBranch})${RESET}` : "";
+  const summary = session.summary || session.nextStep || "checkpoint";
+  console.log(`${DIM}${id}${RESET} ${relTime}${branch} ${summary}`);
+}
+function renderLogDecision(decision, showStat) {
+  const relTime = formatRelativeTime(decision.timestamp);
+  const branch = decision.gitBranch ? ` ${GREEN}(${decision.gitBranch})${RESET}` : "";
+  const cat = decision.classification.category;
+  const conf = Math.round(decision.classification.confidence * 100);
+  const tag = `${MAGENTA}[${cat} \xB7 ${conf}%]${RESET}`;
+  console.log(`${BOLD}\u25C6${RESET} ${DIM}${relTime}${RESET}${branch}  ${tag}`);
+  console.log(`  ${decision.commitMessage}`);
+  if (decision.classification.reasons.length > 0) {
+    console.log(`  ${DIM}Signals: ${decision.classification.reasons.join("; ")}${RESET}`);
+  }
+  if (decision.filesChanged.length > 0) {
+    console.log(`  ${DIM}${decision.filesChanged.length} file${decision.filesChanged.length !== 1 ? "s" : ""} changed${RESET}`);
+  }
+  if (showStat && decision.filesChanged.length > 0) {
+    for (const f of decision.filesChanged) {
+      console.log(`    ${DIM}${f}${RESET}`);
+    }
+  }
+}
+function renderLogDecisionOneline(decision) {
+  const id = decision.id.slice(0, 7);
+  const relTime = formatRelativeTime(decision.timestamp);
+  const cat = decision.classification.category;
+  console.log(`${DIM}${id}${RESET} ${relTime}  ${MAGENTA}[${cat}]${RESET} ${decision.commitMessage}`);
+}
+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 path6 from "path";
-import os2 from "os";
-var CLI_VERSION = "0.3.3";
+import path8 from "path";
+import os3 from "os";
+var CLI_VERSION = "1.1.0";
 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 = path6.join(os2.homedir(), ".keepgoing");
-var CACHE_PATH = path6.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);
@@ -752,61 +2042,73 @@ async function statusCommand(opts) {
 }
 
 // src/commands/save.ts
-import readline from "readline";
-import path7 from "path";
-function prompt(rl, question) {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer.trim());
-    });
-  });
-}
+import path9 from "path";
 async function saveCommand(opts) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  let summary = "";
-  let nextStep = "";
-  let blocker = "";
-  try {
-    while (!summary) {
-      summary = await prompt(rl, "What did you work on? ");
-      if (!summary) {
-        console.log("  (This field is required)");
-      }
-    }
-    while (!nextStep) {
-      nextStep = await prompt(rl, "What's your next step? ");
-      if (!nextStep) {
-        console.log("  (This field is required)");
-      }
+  const { cwd, message, nextStepOverride, json, quiet, force } = opts;
+  const isManual = !!message;
+  const reader = new KeepGoingReader(cwd);
+  const { session: lastSession } = reader.getScopedLastSession();
+  if (!force && !isManual && lastSession?.timestamp) {
+    const ageMs = Date.now() - new Date(lastSession.timestamp).getTime();
+    if (ageMs < 2 * 60 * 1e3) {
+      return;
     }
-    blocker = await prompt(rl, "Any blockers? (leave empty to skip) ");
-  } finally {
-    rl.close();
   }
-  const gitBranch = getCurrentBranch(opts.cwd);
-  const touchedFiles = getTouchedFiles(opts.cwd);
+  const touchedFiles = getTouchedFiles(cwd);
+  const commitHashes = getCommitsSince(cwd, lastSession?.timestamp);
+  if (!force && !isManual && touchedFiles.length === 0 && commitHashes.length === 0) {
+    return;
+  }
+  const gitBranch = getCurrentBranch(cwd);
+  const commitMessages = getCommitMessagesSince(cwd, lastSession?.timestamp);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const events = buildSessionEvents({
+    wsPath: cwd,
+    commitHashes,
+    commitMessages,
+    touchedFiles,
+    currentBranch: gitBranch ?? void 0,
+    sessionStartTime: lastSession?.timestamp ?? now,
+    lastActivityTime: now
+  });
+  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path9.basename(f)).join(", ")}`;
+  const nextStep = nextStepOverride ?? buildSmartNextStep(events);
+  const projectName = path9.basename(resolveStorageRoot(cwd));
+  const sessionId = generateSessionId({
+    workspaceRoot: cwd,
+    branch: gitBranch ?? void 0,
+    worktreePath: cwd
+  });
   const checkpoint = createCheckpoint({
     summary,
     nextStep,
-    blocker: blocker || void 0,
     gitBranch,
     touchedFiles,
-    workspaceRoot: opts.cwd,
-    source: "manual"
+    commitHashes,
+    workspaceRoot: cwd,
+    source: isManual ? "manual" : "auto",
+    sessionId
   });
-  const projectName = path7.basename(opts.cwd);
-  const writer = new KeepGoingWriter(opts.cwd);
+  const writer = new KeepGoingWriter(cwd);
   writer.saveCheckpoint(checkpoint, projectName);
-  console.log("Checkpoint saved.");
+  writer.upsertSession({
+    sessionId,
+    sessionActive: false,
+    nextStep: checkpoint.nextStep || void 0,
+    branch: gitBranch ?? void 0,
+    updatedAt: checkpoint.timestamp
+  });
+  if (json) {
+    console.log(JSON.stringify(checkpoint, null, 2));
+  } else if (!quiet) {
+    renderSaveConfirmation(summary, touchedFiles.length, gitBranch ?? void 0);
+  }
 }
 
 // src/commands/hook.ts
-import fs5 from "fs";
-import path8 from "path";
-import os3 from "os";
+import fs6 from "fs";
+import path10 from "path";
+import os4 from "os";
 import { execSync } from "child_process";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
 var HOOK_MARKER_END = "# keepgoing-hook-end";
@@ -842,7 +2144,7 @@ if command -v keepgoing >/dev/null 2>&1
 end
 ${HOOK_MARKER_END}`;
 function detectShellRcFile(shellOverride) {
-  const home = os3.homedir();
+  const home = os4.homedir();
   let shell;
   if (shellOverride) {
     shell = shellOverride.toLowerCase();
@@ -865,14 +2167,14 @@ function detectShellRcFile(shellOverride) {
     }
   }
   if (shell === "zsh") {
-    return { shell: "zsh", rcFile: path8.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path10.join(home, ".zshrc") };
   }
   if (shell === "bash") {
-    return { shell: "bash", rcFile: path8.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path10.join(home, ".bashrc") };
   }
   if (shell === "fish") {
-    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path8.join(home, ".config");
-    return { shell: "fish", rcFile: path8.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;
 }
@@ -888,14 +2190,14 @@ function hookInstallCommand(shellOverride) {
   const hookBlock = shell === "zsh" ? ZSH_HOOK : shell === "fish" ? FISH_HOOK : BASH_HOOK;
   let existing = "";
   try {
-    existing = fs5.readFileSync(rcFile, "utf-8");
+    existing = fs6.readFileSync(rcFile, "utf-8");
   } catch {
   }
   if (existing.includes(HOOK_MARKER_START)) {
     console.log(`KeepGoing hook is already installed in ${rcFile}.`);
     return;
   }
-  fs5.appendFileSync(rcFile, `
+  fs6.appendFileSync(rcFile, `
 ${hookBlock}
 `, "utf-8");
   console.log(`KeepGoing hook installed in ${rcFile}.`);
@@ -914,7 +2216,7 @@ function hookUninstallCommand(shellOverride) {
   const { rcFile } = detected;
   let existing = "";
   try {
-    existing = fs5.readFileSync(rcFile, "utf-8");
+    existing = fs6.readFileSync(rcFile, "utf-8");
   } catch {
     console.log(`${rcFile} not found \u2014 nothing to remove.`);
     return;
@@ -930,7 +2232,7 @@ function hookUninstallCommand(shellOverride) {
     "g"
   );
   const updated = existing.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-  fs5.writeFileSync(rcFile, updated, "utf-8");
+  fs6.writeFileSync(rcFile, updated, "utf-8");
   console.log(`KeepGoing hook removed from ${rcFile}.`);
   console.log(`Reload your shell config to deactivate it:
 `);
@@ -1027,51 +2329,778 @@ async function deactivateCommand(opts) {
   }
 }
 
+// src/commands/briefing.ts
+async function briefingCommand(opts) {
+  const reader = new KeepGoingReader(opts.cwd);
+  if (!reader.exists()) {
+    if (!opts.quiet) {
+      renderNoData();
+    }
+    return;
+  }
+  const gitBranch = reader.getCurrentBranch();
+  const { session: lastSession } = reader.getScopedLastSession();
+  const recentSessions = reader.getScopedRecentSessions(5);
+  const state = reader.getState() ?? {};
+  const sinceTimestamp = lastSession?.timestamp;
+  const recentCommits = sinceTimestamp ? getCommitMessagesSince(opts.cwd, sinceTimestamp) : [];
+  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,
+    projectState: state,
+    gitBranch,
+    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;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(briefing, null, 2));
+    return;
+  }
+  if (opts.quiet) {
+    renderEnrichedBriefingQuiet(briefing);
+    return;
+  }
+  renderEnrichedBriefing(briefing);
+}
+
+// src/commands/init.ts
+var RESET3 = "\x1B[0m";
+var BOLD3 = "\x1B[1m";
+var GREEN2 = "\x1B[32m";
+var YELLOW2 = "\x1B[33m";
+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
+  });
+  console.log(`
+${BOLD3}KeepGoing Init${RESET3} ${DIM3}(${scope} scope)${RESET3}
+`);
+  for (const msg of result.messages) {
+    const colonIdx = msg.indexOf(":");
+    if (colonIdx === -1) {
+      console.log(`  ${msg}`);
+      continue;
+    }
+    const label = msg.slice(0, colonIdx + 1);
+    const body = msg.slice(colonIdx + 1);
+    if (label.startsWith("Warning")) {
+      console.log(`  ${YELLOW2}${label}${RESET3}${body}`);
+    } else if (body.includes("Added")) {
+      console.log(`  ${GREEN2}${label}${RESET3}${body}`);
+    } else {
+      console.log(`  ${CYAN2}${label}${RESET3}${body}`);
+    }
+  }
+  if (result.changed) {
+    console.log(`
+${GREEN2}Done!${RESET3} KeepGoing is set up for this project.
+`);
+  } else {
+    console.log(`
+Everything was already configured. No changes made.
+`);
+  }
+}
+
+// src/commands/momentum.ts
+async function momentumCommand(opts) {
+  const reader = new KeepGoingReader(opts.cwd);
+  if (!reader.exists()) {
+    if (!opts.quiet) {
+      renderNoData();
+    }
+    return;
+  }
+  const { session: lastSession, isFallback } = reader.getScopedLastSession();
+  const currentBranch = reader.getCurrentBranch();
+  if (!lastSession) {
+    if (!opts.quiet) {
+      console.log("KeepGoing is set up but no session checkpoints exist yet.");
+    }
+    return;
+  }
+  const state = reader.getState();
+  const branchChanged = lastSession.gitBranch && currentBranch && lastSession.gitBranch !== currentBranch;
+  if (opts.json) {
+    console.log(JSON.stringify({
+      lastCheckpoint: lastSession.timestamp,
+      summary: lastSession.summary,
+      nextStep: lastSession.nextStep,
+      blocker: lastSession.blocker || null,
+      projectIntent: lastSession.projectIntent || null,
+      branch: currentBranch || null,
+      branchChanged: branchChanged ? lastSession.gitBranch : null,
+      touchedFiles: lastSession.touchedFiles,
+      derivedFocus: state?.derivedCurrentFocus || null,
+      isWorktree: reader.isWorktree,
+      isFallback
+    }, null, 2));
+    return;
+  }
+  if (opts.quiet) {
+    renderMomentumQuiet(lastSession);
+    return;
+  }
+  renderMomentum(lastSession, {
+    currentBranch,
+    branchChanged: !!branchChanged,
+    isWorktree: reader.isWorktree,
+    isFallback,
+    derivedFocus: state?.derivedCurrentFocus
+  });
+}
+
+// src/commands/decisions.ts
+async function decisionsCommand(opts) {
+  const reader = new KeepGoingReader(opts.cwd);
+  if (!reader.exists()) {
+    if (!opts.quiet) {
+      renderNoData();
+    }
+    return;
+  }
+  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
+    console.error(
+      'Decision Detection requires a Pro license.\nRun "keepgoing activate <key>" or visit https://keepgoing.dev/add-ons to purchase.'
+    );
+    process.exit(1);
+  }
+  const { effectiveBranch, scopeLabel } = reader.resolveBranchScope(opts.branch || void 0);
+  const decisions = effectiveBranch ? reader.getRecentDecisionsForBranch(effectiveBranch, opts.limit) : reader.getRecentDecisions(opts.limit);
+  if (decisions.length === 0) {
+    if (!opts.quiet) {
+      const msg = effectiveBranch ? `No decisions found for branch \`${effectiveBranch}\`. Use --branch all to see all branches.` : "No decisions found.";
+      console.log(msg);
+    }
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
+  }
+  if (opts.quiet) {
+    renderDecisionsQuiet(decisions);
+    return;
+  }
+  renderDecisions(decisions, scopeLabel);
+}
+
+// src/commands/log.ts
+var RESET4 = "\x1B[0m";
+var DIM4 = "\x1B[2m";
+function parseDate(input) {
+  const lower = input.toLowerCase().trim();
+  if (lower === "today") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setHours(0, 0, 0, 0);
+    return d2;
+  }
+  if (lower === "yesterday") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() - 1);
+    d2.setHours(0, 0, 0, 0);
+    return d2;
+  }
+  if (lower === "last week") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() - 7);
+    d2.setHours(0, 0, 0, 0);
+    return d2;
+  }
+  const agoMatch = lower.match(/^(\d+)\s+(second|minute|hour|day|week|month)s?\s+ago$/);
+  if (agoMatch) {
+    const n = parseInt(agoMatch[1], 10);
+    const unit = agoMatch[2];
+    const now = /* @__PURE__ */ new Date();
+    const msPerUnit = {
+      second: 1e3,
+      minute: 60 * 1e3,
+      hour: 60 * 60 * 1e3,
+      day: 24 * 60 * 60 * 1e3,
+      week: 7 * 24 * 60 * 60 * 1e3,
+      month: 30 * 24 * 60 * 60 * 1e3
+    };
+    return new Date(now.getTime() - n * (msPerUnit[unit] ?? 0));
+  }
+  const d = new Date(input);
+  if (!isNaN(d.getTime())) return d;
+  return void 0;
+}
+function filterSessions(sessions, opts) {
+  let result = sessions;
+  let sinceDate;
+  if (opts.today) {
+    sinceDate = parseDate("today");
+  } else if (opts.week) {
+    sinceDate = parseDate("last week");
+  } else if (opts.since) {
+    sinceDate = parseDate(opts.since);
+  }
+  if (sinceDate) {
+    const ts = sinceDate.getTime();
+    result = result.filter((s) => new Date(s.timestamp).getTime() >= ts);
+  }
+  if (opts.until) {
+    const untilDate = parseDate(opts.until);
+    if (untilDate) {
+      const ts = untilDate.getTime();
+      result = result.filter((s) => new Date(s.timestamp).getTime() <= ts);
+    }
+  }
+  if (opts.source) {
+    const src = opts.source.toLowerCase();
+    result = result.filter((s) => s.source?.toLowerCase() === src);
+  }
+  if (opts.blockerOnly) {
+    result = result.filter((s) => s.blocker && s.blocker.trim().length > 0);
+  }
+  if (opts.follow) {
+    const file = opts.follow.toLowerCase();
+    result = result.filter(
+      (s) => s.touchedFiles?.some((f) => f.toLowerCase().includes(file))
+    );
+  }
+  if (opts.search) {
+    const term = opts.search.toLowerCase();
+    result = result.filter((s) => {
+      const haystack = [s.summary, s.nextStep, s.blocker].filter(Boolean).join(" ").toLowerCase();
+      return haystack.includes(term);
+    });
+  }
+  return result;
+}
+function filterDecisions(decisions, opts) {
+  let result = decisions;
+  let sinceDate;
+  if (opts.today) {
+    sinceDate = parseDate("today");
+  } else if (opts.week) {
+    sinceDate = parseDate("last week");
+  } else if (opts.since) {
+    sinceDate = parseDate(opts.since);
+  }
+  if (sinceDate) {
+    const ts = sinceDate.getTime();
+    result = result.filter((d) => new Date(d.timestamp).getTime() >= ts);
+  }
+  if (opts.until) {
+    const untilDate = parseDate(opts.until);
+    if (untilDate) {
+      const ts = untilDate.getTime();
+      result = result.filter((d) => new Date(d.timestamp).getTime() <= ts);
+    }
+  }
+  if (opts.follow) {
+    const file = opts.follow.toLowerCase();
+    result = result.filter(
+      (d) => d.filesChanged?.some((f) => f.toLowerCase().includes(file))
+    );
+  }
+  if (opts.search) {
+    const term = opts.search.toLowerCase();
+    result = result.filter((d) => {
+      const haystack = [d.commitMessage, d.rationale].filter(Boolean).join(" ").toLowerCase();
+      return haystack.includes(term);
+    });
+  }
+  return result;
+}
+function logSessions(reader, opts) {
+  const { effectiveBranch } = reader.resolveBranchScope(opts.branch || void 0);
+  let sessions = reader.getSessions();
+  if (effectiveBranch) {
+    sessions = sessions.filter((s) => s.gitBranch === effectiveBranch);
+  }
+  sessions.reverse();
+  sessions = filterSessions(sessions, opts);
+  const totalFiltered = sessions.length;
+  if (totalFiltered === 0) {
+    console.log(`${DIM4}No checkpoints match the given filters.${RESET4}`);
+    return;
+  }
+  const displayed = sessions.slice(0, opts.count);
+  if (opts.json) {
+    console.log(JSON.stringify(displayed, null, 2));
+    return;
+  }
+  if (opts.quiet) {
+    console.log(`${totalFiltered} checkpoint${totalFiltered !== 1 ? "s" : ""} found`);
+    return;
+  }
+  if (opts.sessions) {
+    renderGrouped(displayed, opts.stat);
+  } else if (opts.oneline) {
+    for (const s of displayed) {
+      renderLogSessionOneline(s);
+    }
+  } else {
+    for (const s of displayed) {
+      renderLogSession(s, opts.stat);
+    }
+  }
+  if (totalFiltered > opts.count) {
+    console.log(`${DIM4}(showing ${displayed.length} of ${totalFiltered} checkpoints)${RESET4}`);
+  }
+}
+function renderGrouped(sessions, showStat) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const key = s.sessionId || s.id;
+    const group = groups.get(key);
+    if (group) {
+      group.push(s);
+    } else {
+      groups.set(key, [s]);
+    }
+  }
+  let first = true;
+  for (const [sessionId, items] of groups) {
+    if (!first) console.log("");
+    first = false;
+    renderSessionGroupHeader(sessionId, items.length);
+    for (const s of items) {
+      renderLogSession(s, showStat);
+    }
+  }
+}
+function logDecisions(reader, opts) {
+  const license = getLicenseForFeature("decisions");
+  if (!license) {
+    console.log("Decision tracking requires a Pro license. Run: keepgoing activate <key>");
+    return;
+  }
+  const { effectiveBranch } = reader.resolveBranchScope(opts.branch || void 0);
+  let decisions = reader.getDecisions();
+  if (effectiveBranch) {
+    decisions = decisions.filter((d) => d.gitBranch === effectiveBranch);
+  }
+  decisions.reverse();
+  decisions = filterDecisions(decisions, opts);
+  const totalFiltered = decisions.length;
+  if (totalFiltered === 0) {
+    console.log(`${DIM4}No decisions match the given filters.${RESET4}`);
+    return;
+  }
+  const displayed = decisions.slice(0, opts.count);
+  if (opts.json) {
+    console.log(JSON.stringify(displayed, null, 2));
+    return;
+  }
+  if (opts.quiet) {
+    console.log(`${totalFiltered} decision${totalFiltered !== 1 ? "s" : ""} found`);
+    return;
+  }
+  if (opts.oneline) {
+    for (const d of displayed) {
+      renderLogDecisionOneline(d);
+    }
+  } else {
+    for (const d of displayed) {
+      renderLogDecision(d, opts.stat);
+    }
+  }
+  if (totalFiltered > opts.count) {
+    console.log(`${DIM4}(showing ${displayed.length} of ${totalFiltered} decisions)${RESET4}`);
+  }
+}
+async function logCommand(opts) {
+  const reader = new KeepGoingReader(opts.cwd);
+  if (!reader.exists()) {
+    renderNoData();
+    return;
+  }
+  if (opts.subcommand === "decisions") {
+    logDecisions(reader, opts);
+  } else {
+    logSessions(reader, 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
 
-Usage:
-  keepgoing status              Show the last checkpoint for this project
-  keepgoing save                Save a new checkpoint interactively
-  keepgoing hook                Manage the shell hook
-  keepgoing activate <key>      Activate a Pro license on this device
-  keepgoing deactivate          Deactivate the Pro license from this device
+Usage: keepgoing <command> [options]
 
-Options:
+Commands:
+  init                Set up KeepGoing hooks and CLAUDE.md in this project
+  status              Show the last checkpoint for this project
+  momentum            Show your current developer momentum
+  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
+  deactivate          Deactivate the Pro license from this device
+
+Global options:
   --cwd <path>    Override the working directory (default: current directory)
-  --json          Output raw JSON (status only)
-  --quiet         Output a single summary line (status only)
-  --shell <name>  Override shell detection (zsh, bash, fish) for hook commands
+  --json          Output raw JSON
+  --quiet         Suppress output
   -v, --version   Show the CLI version
-  -h, --help      Show this help text
+  -h, --help      Show help (use with a command for detailed options)
 
-Hook subcommands:
-  keepgoing hook install    Install the shell hook (zsh, bash, fish)
-  keepgoing hook uninstall  Remove the shell hook
+Run "keepgoing <command> --help" for detailed options on any command.
 `;
+var COMMAND_HELP = {
+  init: `
+keepgoing init: Set up KeepGoing hooks and CLAUDE.md in this project
+
+Usage: keepgoing init [options]
+
+Options:
+  --scope <s>     Scope: "project" (default) or "user" (global)
+  --cwd <path>    Override the working directory
+`,
+  setup: `
+keepgoing init: Set up KeepGoing hooks and CLAUDE.md in this project
+
+Usage: keepgoing init [options]
+
+Options:
+  --scope <s>     Scope: "project" (default) or "user" (global)
+  --cwd <path>    Override the working directory
+`,
+  status: `
+keepgoing status: Show the last checkpoint for this project
+
+Usage: keepgoing status [options]
+
+Options:
+  --json          Output raw JSON
+  --quiet         Suppress output
+  --cwd <path>    Override the working directory
+`,
+  momentum: `
+keepgoing momentum: Show your current developer momentum
+
+Usage: keepgoing momentum [options]
+
+Options:
+  --json          Output raw JSON
+  --quiet         Suppress output
+  --cwd <path>    Override the working directory
+`,
+  briefing: `
+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
+`,
+  decisions: `
+keepgoing decisions: View decision history (Pro)
+
+Usage: keepgoing decisions [options]
+
+Options:
+  --branch <name>  Filter by branch, or "all" for all branches
+  --limit <n>      Number of decisions to show (default: 10)
+  --json           Output raw JSON
+  --quiet          Suppress output
+  --cwd <path>     Override the working directory
+`,
+  log: `
+keepgoing log: Browse session checkpoints
+
+Usage:
+  keepgoing log [options]            Browse session checkpoints
+  keepgoing log decisions [options]  Browse decision records (Pro)
+
+Options:
+  -n <count>         Number of entries to show (default: 10)
+  --branch <name>    Filter by branch ("all" for all branches)
+  --since <date>     Show entries after date (ISO, "today", "yesterday", "N days ago")
+  --until <date>     Show entries before date
+  --source <type>    Filter by source (manual, auto)
+  --follow <file>    Filter by touched file path
+  --search <term>    Search in summary, next step, blocker
+  --oneline          Compact one-line format
+  --stat             Show touched file paths
+  --blocker          Only show entries with blockers
+  --today            Shorthand for --since today
+  --week             Shorthand for --since "last week"
+  --sessions         Group checkpoints by session
+  --json             Output raw JSON
+  --quiet            Suppress output
+  --cwd <path>       Override the working directory
+
+Examples:
+  keepgoing log --today              Show today's checkpoints
+  keepgoing log --week --oneline     This week's checkpoints, compact
+  keepgoing log --follow src/app.ts  Checkpoints that touched a file
+  keepgoing log --search "auth"      Search checkpoint summaries
+  keepgoing log --sessions           Group by session
+  keepgoing log decisions            Browse decision records (Pro)
+`,
+  save: `
+keepgoing save: Save a checkpoint (auto-generates from git)
+
+Usage: keepgoing save [options]
+
+Options:
+  -m, --message <text>   Use a custom summary instead of auto-generating
+  -n, --next <text>      Use a custom next step instead of auto-generating
+  --force                Save even if recent checkpoint exists or no changes
+  --json                 Output raw JSON
+  --quiet                Suppress output
+  --cwd <path>           Override the working directory
+
+Examples:
+  keepgoing save                           Auto-generate from git
+  keepgoing save -m "Finished auth flow"   Custom summary
+  keepgoing save --force                   Save even if no changes
+`,
+  hook: `
+keepgoing hook: Manage the shell hook
+
+The shell hook shows a quick status line when you cd into a KeepGoing project.
+
+Usage:
+  keepgoing hook install    Install the shell hook
+  keepgoing hook uninstall  Remove the shell hook
+
+Supported shells: zsh, bash, fish
+
+Options:
+  --shell <name>  Override shell detection (zsh, bash, fish)
+
+The hook auto-detects your current shell. Use --shell to override.
+`,
+  activate: `
+keepgoing activate: Activate a Pro license on this device
+
+Usage: keepgoing activate <key>
+
+Example:
+  keepgoing activate XXXX-XXXX-XXXX-XXXX
+`,
+  deactivate: `
+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) {
   const args = argv.slice(2);
   let command = "";
   let subcommand = "";
+  let help = false;
   let cwd = process.cwd();
   let json = false;
   let quiet = false;
   let shell = "";
+  let scope = "project";
+  let message = "";
+  let nextStepOverride = "";
+  let force = false;
+  let branch = "";
+  let limit = 10;
+  let count = 10;
+  let since = "";
+  let until = "";
+  let source = "";
+  let follow = "";
+  let search = "";
+  let oneline = false;
+  let stat = false;
+  let blockerOnly = false;
+  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) {
       cwd = args[++i];
     } else if (arg === "--shell" && i + 1 < args.length) {
       shell = args[++i];
+    } else if (arg === "--scope" && i + 1 < args.length) {
+      scope = args[++i];
+    } else if ((arg === "-m" || arg === "--message") && i + 1 < args.length) {
+      message = args[++i];
+    } else if (arg === "--next" && i + 1 < args.length) {
+      nextStepOverride = args[++i];
+    } else if (arg === "-n" && i + 1 < args.length) {
+      if (command === "log") {
+        count = parseInt(args[++i], 10) || 10;
+      } else {
+        nextStepOverride = args[++i];
+      }
+    } else if (arg === "--branch" && i + 1 < args.length) {
+      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") {
       quiet = true;
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--since" && i + 1 < args.length) {
+      since = args[++i];
+    } else if (arg === "--until" && i + 1 < args.length) {
+      until = args[++i];
+    } else if (arg === "--source" && i + 1 < args.length) {
+      source = args[++i];
+    } else if (arg === "--follow" && i + 1 < args.length) {
+      follow = args[++i];
+    } else if (arg === "--search" && i + 1 < args.length) {
+      search = args[++i];
+    } else if (arg === "--oneline") {
+      oneline = true;
+    } else if (arg === "--stat") {
+      stat = true;
+    } else if (arg === "--blocker") {
+      blockerOnly = true;
+    } else if (arg === "--today") {
+      today = true;
+    } else if (arg === "--week") {
+      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") {
-      command = "help";
+      help = true;
     } else if (!command) {
       command = arg;
     } else if (!subcommand) {
@@ -1079,16 +3108,106 @@ function parseArgs(argv) {
     }
   }
   cwd = findGitRoot(cwd);
-  return { command, subcommand, cwd, json, quiet, shell };
+  return {
+    command,
+    subcommand,
+    help,
+    cwd,
+    json,
+    quiet,
+    shell,
+    scope,
+    message,
+    nextStepOverride,
+    force,
+    branch,
+    limit,
+    count,
+    since,
+    until,
+    source,
+    follow,
+    search,
+    oneline,
+    stat,
+    blockerOnly,
+    today,
+    week,
+    sessions,
+    target,
+    open,
+    tier,
+    model
+  };
 }
 async function main() {
-  const { command, subcommand, cwd, json, quiet, shell } = parseArgs(process.argv);
+  const parsed = parseArgs(process.argv);
+  const { command, subcommand, cwd, json, quiet, shell, scope, message, nextStepOverride, force, branch, limit } = parsed;
+  if (parsed.help || command === "help") {
+    const helpCmd = parsed.help ? command : subcommand;
+    if (helpCmd && COMMAND_HELP[helpCmd]) {
+      console.log(COMMAND_HELP[helpCmd]);
+    } else {
+      console.log(HELP_TEXT);
+    }
+    return;
+  }
   switch (command) {
+    case "init":
+    case "setup":
+      initCommand({ cwd, scope });
+      break;
     case "status":
       await statusCommand({ cwd, json, quiet });
       break;
+    case "momentum":
+      await momentumCommand({ cwd, json, quiet });
+      break;
+    case "briefing":
+      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 });
+      break;
+    case "log":
+      await logCommand({
+        cwd,
+        json,
+        quiet,
+        subcommand,
+        count: parsed.count,
+        branch: parsed.branch,
+        since: parsed.since,
+        until: parsed.until,
+        source: parsed.source,
+        follow: parsed.follow,
+        search: parsed.search,
+        oneline: parsed.oneline,
+        stat: parsed.stat,
+        blockerOnly: parsed.blockerOnly,
+        today: parsed.today,
+        week: parsed.week,
+        sessions: parsed.sessions
+      });
+      break;
+    case "continue":
+      await continueCommand({ cwd, json, quiet, target: parsed.target, open: parsed.open });
+      break;
     case "save":
-      await saveCommand({ cwd });
+      await saveCommand({
+        cwd,
+        message: message || void 0,
+        nextStepOverride: nextStepOverride || void 0,
+        json,
+        quiet,
+        force
+      });
       break;
     case "hook":
       if (subcommand === "install") {
@@ -1096,14 +3215,11 @@ async function main() {
       } else if (subcommand === "uninstall") {
         hookUninstallCommand(shell || void 0);
       } else {
-        console.error(
-          `Unknown hook subcommand: "${subcommand}". Use "install" or "uninstall".`
-        );
-        process.exit(1);
+        console.log(COMMAND_HELP.hook);
       }
       break;
     case "version":
-      console.log(`keepgoing v${"0.3.3"}`);
+      console.log(`keepgoing v${"1.1.0"}`);
       break;
     case "activate":
       await activateCommand({ licenseKey: subcommand });
@@ -1111,7 +3227,6 @@ async function main() {
     case "deactivate":
       await deactivateCommand({ licenseKey: subcommand || void 0 });
       break;
-    case "help":
     case "":
       console.log(HELP_TEXT);
       break;