@keepgoingdev/mcp-server 0.6.1 → 0.7.1

package/dist/index.js

@@ -149,6 +149,18 @@ function getCommitsSince(workspacePath, sinceTimestamp) {
 function getCommitMessagesSince(workspacePath, sinceTimestamp) {
   return getGitLogSince(workspacePath, "%s", sinceTimestamp);
 }
+function getCommitMessageByHash(workspacePath, commitHash) {
+  try {
+    const result = execFileSync("git", ["log", "-1", "--format=%s", commitHash], {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    return result.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
 function getFilesChangedInCommit(workspacePath, commitHash) {
   try {
     const result = execFileSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
@@ -350,7 +362,8 @@ function buildRecentActivity(lastSession, recentSessions, recentCommitMessages)
     parts.push("1 recent session");
   }
   if (lastSession.summary) {
-    parts.push(`Last: ${lastSession.summary}`);
+    const brief = lastSession.summary.length > 120 ? lastSession.summary.slice(0, 117) + "..." : lastSession.summary;
+    parts.push(`Last: ${brief}`);
   }
   if (lastSession.touchedFiles.length > 0) {
     parts.push(`${lastSession.touchedFiles.length} files touched`);
@@ -691,9 +704,59 @@ function formatContinueOnPrompt(context, options) {
 }
 
 // ../../packages/shared/src/storage.ts
+import fs2 from "fs";
+import path4 from "path";
+import { randomUUID as randomUUID2, createHash } from "crypto";
+
+// ../../packages/shared/src/registry.ts
 import fs from "fs";
+import os from "os";
 import path3 from "path";
-import { randomUUID as randomUUID2, createHash } from "crypto";
+var KEEPGOING_DIR = path3.join(os.homedir(), ".keepgoing");
+var KNOWN_PROJECTS_FILE = path3.join(KEEPGOING_DIR, "known-projects.json");
+var STALE_PROJECT_MS = 90 * 24 * 60 * 60 * 1e3;
+function readKnownProjects() {
+  try {
+    if (fs.existsSync(KNOWN_PROJECTS_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(KNOWN_PROJECTS_FILE, "utf-8"));
+      if (raw && Array.isArray(raw.projects)) {
+        return raw;
+      }
+    }
+  } catch {
+  }
+  return { version: 1, projects: [] };
+}
+function writeKnownProjects(data) {
+  if (!fs.existsSync(KEEPGOING_DIR)) {
+    fs.mkdirSync(KEEPGOING_DIR, { recursive: true });
+  }
+  const tmpFile = KNOWN_PROJECTS_FILE + ".tmp";
+  fs.writeFileSync(tmpFile, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmpFile, KNOWN_PROJECTS_FILE);
+}
+function registerProject(projectPath, projectName) {
+  try {
+    const data = readKnownProjects();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const name = projectName || path3.basename(projectPath);
+    const existingIdx = data.projects.findIndex((p) => p.path === projectPath);
+    if (existingIdx >= 0) {
+      data.projects[existingIdx].lastSeen = now;
+      if (projectName) {
+        data.projects[existingIdx].name = name;
+      }
+    } else {
+      data.projects.push({ path: projectPath, name, lastSeen: now });
+    }
+    const cutoff = Date.now() - STALE_PROJECT_MS;
+    data.projects = data.projects.filter((p) => new Date(p.lastSeen).getTime() > cutoff);
+    writeKnownProjects(data);
+  } catch {
+  }
+}
+
+// ../../packages/shared/src/storage.ts
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
 var SESSIONS_FILE = "sessions.json";
@@ -715,23 +778,23 @@ var KeepGoingWriter = class {
   currentTasksFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
-    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);
+    this.storagePath = path4.join(mainRoot, STORAGE_DIR);
+    this.sessionsFilePath = path4.join(this.storagePath, SESSIONS_FILE);
+    this.stateFilePath = path4.join(this.storagePath, STATE_FILE);
+    this.metaFilePath = path4.join(this.storagePath, META_FILE);
+    this.currentTasksFilePath = path4.join(this.storagePath, CURRENT_TASKS_FILE);
   }
   ensureDir() {
-    if (!fs.existsSync(this.storagePath)) {
-      fs.mkdirSync(this.storagePath, { recursive: true });
+    if (!fs2.existsSync(this.storagePath)) {
+      fs2.mkdirSync(this.storagePath, { recursive: true });
     }
   }
   saveCheckpoint(checkpoint, projectName) {
     this.ensureDir();
     let sessionsData;
     try {
-      if (fs.existsSync(this.sessionsFilePath)) {
-        const raw = JSON.parse(fs.readFileSync(this.sessionsFilePath, "utf-8"));
+      if (fs2.existsSync(this.sessionsFilePath)) {
+        const raw = JSON.parse(fs2.readFileSync(this.sessionsFilePath, "utf-8"));
         if (Array.isArray(raw)) {
           sessionsData = { version: 1, project: projectName, sessions: raw };
         } else {
@@ -749,20 +812,22 @@ var KeepGoingWriter = class {
     if (sessionsData.sessions.length > MAX_SESSIONS) {
       sessionsData.sessions = sessionsData.sessions.slice(-MAX_SESSIONS);
     }
-    fs.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
+    fs2.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
     const state = {
       lastSessionId: checkpoint.id,
       lastKnownBranch: checkpoint.gitBranch,
       lastActivityAt: checkpoint.timestamp
     };
-    fs.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+    fs2.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
     this.updateMeta(checkpoint.timestamp);
+    const mainRoot = resolveStorageRoot(this.storagePath);
+    registerProject(mainRoot, projectName);
   }
   updateMeta(timestamp) {
     let meta;
     try {
-      if (fs.existsSync(this.metaFilePath)) {
-        meta = JSON.parse(fs.readFileSync(this.metaFilePath, "utf-8"));
+      if (fs2.existsSync(this.metaFilePath)) {
+        meta = JSON.parse(fs2.readFileSync(this.metaFilePath, "utf-8"));
         meta.lastUpdated = timestamp;
       } else {
         meta = {
@@ -778,7 +843,7 @@ var KeepGoingWriter = class {
         lastUpdated: timestamp
       };
     }
-    fs.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+    fs2.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
   }
   // ---------------------------------------------------------------------------
   // Multi-session API
@@ -786,8 +851,8 @@ var KeepGoingWriter = class {
   /** Read all current tasks from current-tasks.json. Auto-prunes stale sessions. */
   readCurrentTasks() {
     try {
-      if (fs.existsSync(this.currentTasksFilePath)) {
-        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+      if (fs2.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs2.readFileSync(this.currentTasksFilePath, "utf-8"));
         const tasks = Array.isArray(raw) ? raw : raw.tasks ?? [];
         return this.pruneStale(tasks);
       }
@@ -802,6 +867,8 @@ var KeepGoingWriter = class {
   upsertSession(update) {
     this.ensureDir();
     this.upsertSessionCore(update);
+    const mainRoot = resolveStorageRoot(this.storagePath);
+    registerProject(mainRoot);
   }
   /** Core upsert logic: merges the update into current-tasks.json and returns the pruned task list. */
   upsertSessionCore(update) {
@@ -840,8 +907,8 @@ var KeepGoingWriter = class {
   // ---------------------------------------------------------------------------
   readAllTasksRaw() {
     try {
-      if (fs.existsSync(this.currentTasksFilePath)) {
-        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+      if (fs2.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs2.readFileSync(this.currentTasksFilePath, "utf-8"));
         return Array.isArray(raw) ? [...raw] : [...raw.tasks ?? []];
       }
     } catch {
@@ -853,7 +920,7 @@ var KeepGoingWriter = class {
   }
   writeTasksFile(tasks) {
     const data = { version: 1, tasks };
-    fs.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
+    fs2.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
   }
 };
 function generateSessionId(context) {
@@ -1032,35 +1099,35 @@ function capitalize(s) {
 }
 
 // ../../packages/shared/src/decisionStorage.ts
-import fs3 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path6 from "path";
 
 // ../../packages/shared/src/license.ts
 import crypto from "crypto";
-import fs2 from "fs";
-import os from "os";
-import path4 from "path";
+import fs3 from "fs";
+import os2 from "os";
+import path5 from "path";
 var LICENSE_FILE = "license.json";
 var DEVICE_ID_FILE = "device-id";
 function getGlobalLicenseDir() {
-  return path4.join(os.homedir(), ".keepgoing");
+  return path5.join(os2.homedir(), ".keepgoing");
 }
 function getGlobalLicensePath() {
-  return path4.join(getGlobalLicenseDir(), LICENSE_FILE);
+  return path5.join(getGlobalLicenseDir(), LICENSE_FILE);
 }
 function getDeviceId() {
   const dir = getGlobalLicenseDir();
-  const filePath = path4.join(dir, DEVICE_ID_FILE);
+  const filePath = path5.join(dir, DEVICE_ID_FILE);
   try {
-    const existing = fs2.readFileSync(filePath, "utf-8").trim();
+    const existing = fs3.readFileSync(filePath, "utf-8").trim();
     if (existing) return existing;
   } catch {
   }
   const id = crypto.randomUUID();
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
-  fs2.writeFileSync(filePath, id, "utf-8");
+  fs3.writeFileSync(filePath, id, "utf-8");
   return id;
 }
 var DECISION_DETECTION_VARIANT_ID = 1361527;
@@ -1094,10 +1161,10 @@ function readLicenseStore() {
   const licensePath = getGlobalLicensePath();
   let store;
   try {
-    if (!fs2.existsSync(licensePath)) {
+    if (!fs3.existsSync(licensePath)) {
       store = { version: 2, licenses: [] };
     } else {
-      const raw = fs2.readFileSync(licensePath, "utf-8");
+      const raw = fs3.readFileSync(licensePath, "utf-8");
       const data = JSON.parse(raw);
       if (data?.version === 2 && Array.isArray(data.licenses)) {
         store = data;
@@ -1114,11 +1181,11 @@ function readLicenseStore() {
 }
 function writeLicenseStore(store) {
   const dirPath = getGlobalLicenseDir();
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
   }
-  const licensePath = path4.join(dirPath, LICENSE_FILE);
-  fs2.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
+  const licensePath = path5.join(dirPath, LICENSE_FILE);
+  fs3.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
   _cachedStore = store;
   _cacheTimestamp = Date.now();
 }
@@ -1147,7 +1214,14 @@ function getLicenseForFeature(feature) {
     return features?.includes(feature);
   });
 }
+function getAllLicensesNeedingRevalidation() {
+  return getActiveLicenses().filter((l) => needsRevalidation(l));
+}
 var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function needsRevalidation(entry) {
+  const lastValidated = new Date(entry.lastValidatedAt).getTime();
+  return Date.now() - lastValidated > REVALIDATION_THRESHOLD_MS;
+}
 
 // ../../packages/shared/src/featureGate.ts
 var DefaultFeatureGate = class {
@@ -1169,23 +1243,23 @@ var DecisionStorage = class {
   decisionsFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
-    this.storagePath = path5.join(mainRoot, STORAGE_DIR2);
-    this.decisionsFilePath = path5.join(this.storagePath, DECISIONS_FILE);
+    this.storagePath = path6.join(mainRoot, STORAGE_DIR2);
+    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE);
   }
   ensureStorageDir() {
-    if (!fs3.existsSync(this.storagePath)) {
-      fs3.mkdirSync(this.storagePath, { recursive: true });
+    if (!fs4.existsSync(this.storagePath)) {
+      fs4.mkdirSync(this.storagePath, { recursive: true });
     }
   }
   getProjectName() {
-    return path5.basename(path5.dirname(this.storagePath));
+    return path6.basename(path6.dirname(this.storagePath));
   }
   load() {
     try {
-      if (!fs3.existsSync(this.decisionsFilePath)) {
+      if (!fs4.existsSync(this.decisionsFilePath)) {
         return createEmptyProjectDecisions(this.getProjectName());
       }
-      const raw = fs3.readFileSync(this.decisionsFilePath, "utf-8");
+      const raw = fs4.readFileSync(this.decisionsFilePath, "utf-8");
       const data = JSON.parse(raw);
       return data;
     } catch {
@@ -1195,7 +1269,7 @@ var DecisionStorage = class {
   save(decisions) {
     this.ensureStorageDir();
     const content = JSON.stringify(decisions, null, 2);
-    fs3.writeFileSync(this.decisionsFilePath, content, "utf-8");
+    fs4.writeFileSync(this.decisionsFilePath, content, "utf-8");
   }
   /**
    * Save a decision record as a draft. Always persists regardless of Pro
@@ -1446,8 +1520,8 @@ function tryDetectDecision(opts) {
 }
 
 // ../../packages/shared/src/reader.ts
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path7 from "path";
 var STORAGE_DIR3 = ".keepgoing";
 var META_FILE2 = "meta.json";
 var SESSIONS_FILE2 = "sessions.json";
@@ -1469,16 +1543,16 @@ var KeepGoingReader = class {
     this.workspacePath = workspacePath;
     const mainRoot = resolveStorageRoot(workspacePath);
     this._isWorktree = mainRoot !== workspacePath;
-    this.storagePath = path6.join(mainRoot, STORAGE_DIR3);
-    this.metaFilePath = path6.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path6.join(this.storagePath, SESSIONS_FILE2);
-    this.decisionsFilePath = path6.join(this.storagePath, DECISIONS_FILE2);
-    this.stateFilePath = path6.join(this.storagePath, STATE_FILE2);
-    this.currentTasksFilePath = path6.join(this.storagePath, CURRENT_TASKS_FILE2);
+    this.storagePath = path7.join(mainRoot, STORAGE_DIR3);
+    this.metaFilePath = path7.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path7.join(this.storagePath, SESSIONS_FILE2);
+    this.decisionsFilePath = path7.join(this.storagePath, DECISIONS_FILE2);
+    this.stateFilePath = path7.join(this.storagePath, STATE_FILE2);
+    this.currentTasksFilePath = path7.join(this.storagePath, CURRENT_TASKS_FILE2);
   }
   /** Check if .keepgoing/ directory exists. */
   exists() {
-    return fs4.existsSync(this.storagePath);
+    return fs5.existsSync(this.storagePath);
   }
   /** Read state.json, returns undefined if missing or corrupt. */
   getState() {
@@ -1716,10 +1790,10 @@ var KeepGoingReader = class {
   }
   readJsonFile(filePath) {
     try {
-      if (!fs4.existsSync(filePath)) {
+      if (!fs5.existsSync(filePath)) {
         return void 0;
       }
-      const raw = fs4.readFileSync(filePath, "utf-8");
+      const raw = fs5.readFileSync(filePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -1728,9 +1802,9 @@ var KeepGoingReader = class {
 };
 
 // ../../packages/shared/src/setup.ts
-import fs5 from "fs";
-import os2 from "os";
-import path7 from "path";
+import fs6 from "fs";
+import os3 from "os";
+import path8 from "path";
 var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
 var SESSION_START_HOOK = {
   matcher: "",
@@ -1759,36 +1833,55 @@ var POST_TOOL_USE_HOOK = {
     }
   ]
 };
-var CLAUDE_MD_SECTION = `
+var SESSION_END_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --save-checkpoint"
+    }
+  ]
+};
+var KEEPGOING_RULES_VERSION = 1;
+var KEEPGOING_RULES_CONTENT = `<!-- @keepgoingdev/mcp-server v${KEEPGOING_RULES_VERSION} -->
 ## 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
+- \`summary\`: 1-2 sentences. What changed and why \u2014 no file paths, no implementation details (those are captured from git).
+- \`nextStep\`: What to do next
 - \`blocker\`: Any blocker (if applicable)
 `;
+function getRulesFileVersion(content) {
+  const match = content.match(/<!-- @keepgoingdev\/mcp-server v(\d+) -->/);
+  return match ? parseInt(match[1], 10) : null;
+}
 var STATUSLINE_CMD = "npx -y @keepgoingdev/mcp-server --statusline";
+function detectClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path8.join(os3.homedir(), ".claude");
+}
 function hasKeepGoingHook(hookEntries) {
   return hookEntries.some(
     (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
   );
 }
-function resolveScopePaths(scope, workspacePath) {
+function resolveScopePaths(scope, workspacePath, overrideClaudeDir) {
   if (scope === "user") {
-    const claudeDir2 = path7.join(os2.homedir(), ".claude");
+    const claudeDir2 = overrideClaudeDir || detectClaudeDir();
     return {
       claudeDir: claudeDir2,
-      settingsPath: path7.join(claudeDir2, "settings.json"),
-      claudeMdPath: path7.join(claudeDir2, "CLAUDE.md")
+      settingsPath: path8.join(claudeDir2, "settings.json"),
+      claudeMdPath: path8.join(claudeDir2, "CLAUDE.md"),
+      rulesPath: path8.join(claudeDir2, "rules", "keepgoing.md")
     };
   }
-  const claudeDir = path7.join(workspacePath, ".claude");
-  const dotClaudeMdPath = path7.join(workspacePath, ".claude", "CLAUDE.md");
-  const rootClaudeMdPath = path7.join(workspacePath, "CLAUDE.md");
+  const claudeDir = path8.join(workspacePath, ".claude");
+  const dotClaudeMdPath = path8.join(workspacePath, ".claude", "CLAUDE.md");
+  const rootClaudeMdPath = path8.join(workspacePath, "CLAUDE.md");
   return {
     claudeDir,
-    settingsPath: path7.join(claudeDir, "settings.json"),
-    claudeMdPath: fs5.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath
+    settingsPath: path8.join(claudeDir, "settings.json"),
+    claudeMdPath: fs6.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath,
+    rulesPath: path8.join(workspacePath, ".claude", "rules", "keepgoing.md")
   };
 }
 function writeHooksToSettings(settings) {
@@ -1817,15 +1910,22 @@ function writeHooksToSettings(settings) {
     settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
     changed = true;
   }
+  if (!Array.isArray(settings.hooks.SessionEnd)) {
+    settings.hooks.SessionEnd = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.SessionEnd)) {
+    settings.hooks.SessionEnd.push(SESSION_END_HOOK);
+    changed = true;
+  }
   return changed;
 }
 function checkHookConflict(scope, workspacePath) {
   const otherPaths = resolveScopePaths(scope === "user" ? "project" : "user", workspacePath);
-  if (!fs5.existsSync(otherPaths.settingsPath)) {
+  if (!fs6.existsSync(otherPaths.settingsPath)) {
     return null;
   }
   try {
-    const otherSettings = JSON.parse(fs5.readFileSync(otherPaths.settingsPath, "utf-8"));
+    const otherSettings = JSON.parse(fs6.readFileSync(otherPaths.settingsPath, "utf-8"));
     const hooks = otherSettings?.hooks;
     if (!hooks) return null;
     const hasConflict = Array.isArray(hooks.SessionStart) && hasKeepGoingHook(hooks.SessionStart) || Array.isArray(hooks.Stop) && hasKeepGoingHook(hooks.Stop);
@@ -1844,15 +1944,20 @@ function setupProject(options) {
     scope = "project",
     sessionHooks = true,
     claudeMd = true,
+    claudeDir: claudeDirOverride,
     statusline
   } = options;
   const messages = [];
   let changed = false;
-  const { claudeDir, settingsPath, claudeMdPath } = resolveScopePaths(scope, workspacePath);
-  const scopeLabel = scope === "user" ? "~/.claude/settings.json" : ".claude/settings.json";
+  const { claudeDir, settingsPath, claudeMdPath, rulesPath } = resolveScopePaths(
+    scope,
+    workspacePath,
+    claudeDirOverride
+  );
+  const scopeLabel = scope === "user" ? path8.join("~", path8.relative(os3.homedir(), claudeDir), "settings.json").replace(/\\/g, "/") : ".claude/settings.json";
   let settings = {};
-  if (fs5.existsSync(settingsPath)) {
-    settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+  if (fs6.existsSync(settingsPath)) {
+    settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
   }
   let settingsChanged = false;
   if (sessionHooks) {
@@ -1883,29 +1988,45 @@ function setupProject(options) {
     statusline?.cleanup?.();
   }
   if (settingsChanged) {
-    if (!fs5.existsSync(claudeDir)) {
-      fs5.mkdirSync(claudeDir, { recursive: true });
+    if (!fs6.existsSync(claudeDir)) {
+      fs6.mkdirSync(claudeDir, { recursive: true });
     }
-    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs6.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`);
+    const rulesDir = path8.dirname(rulesPath);
+    const rulesLabel = scope === "user" ? path8.join(path8.relative(os3.homedir(), path8.dirname(rulesPath)), "keepgoing.md").replace(/\\/g, "/") : ".claude/rules/keepgoing.md";
+    if (fs6.existsSync(rulesPath)) {
+      const existing = fs6.readFileSync(rulesPath, "utf-8");
+      const existingVersion = getRulesFileVersion(existing);
+      if (existingVersion === null) {
+        messages.push(`Rules file: Custom file found at ${rulesLabel}, skipping`);
+      } else if (existingVersion >= KEEPGOING_RULES_VERSION) {
+        messages.push(`Rules file: Already up to date (v${existingVersion}), skipped`);
+      } else {
+        if (!fs6.existsSync(rulesDir)) {
+          fs6.mkdirSync(rulesDir, { recursive: true });
+        }
+        fs6.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
+        changed = true;
+        messages.push(`Rules file: Updated v${existingVersion} \u2192 v${KEEPGOING_RULES_VERSION} at ${rulesLabel}`);
+      }
     } else {
-      const updated = existing + CLAUDE_MD_SECTION;
-      const mdDir = path7.dirname(claudeMdPath);
-      if (!fs5.existsSync(mdDir)) {
-        fs5.mkdirSync(mdDir, { recursive: true });
+      const existingClaudeMd = fs6.existsSync(claudeMdPath) ? fs6.readFileSync(claudeMdPath, "utf-8") : "";
+      if (!fs6.existsSync(rulesDir)) {
+        fs6.mkdirSync(rulesDir, { recursive: true });
       }
-      fs5.writeFileSync(claudeMdPath, updated);
+      fs6.writeFileSync(rulesPath, KEEPGOING_RULES_CONTENT);
       changed = true;
-      messages.push(`CLAUDE.md: Added KeepGoing section to ${mdLabel}`);
+      if (existingClaudeMd.includes("## KeepGoing")) {
+        const mdLabel = scope === "user" ? "~/.claude/CLAUDE.md" : "CLAUDE.md";
+        messages.push(
+          `Rules file: Created ${rulesLabel} (you can now remove the ## KeepGoing section from ${mdLabel})`
+        );
+      } else {
+        messages.push(`Rules file: Created ${rulesLabel}`);
+      }
     }
   }
   return { messages, changed };
@@ -1982,6 +2103,39 @@ async function activateLicense(licenseKey, instanceName, options) {
     return { valid: false, error: message };
   }
 }
+async function validateLicense(licenseKey, instanceId, options) {
+  try {
+    const res = await fetchWithTimeout(`${BASE_URL}/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ license_key: licenseKey, instance_id: instanceId })
+    });
+    const data = await safeJson(res);
+    if (!res.ok || !data?.valid) {
+      return { valid: false, isNetworkError: false, error: data?.error || `Validation failed (${res.status})` };
+    }
+    if (!options?.allowTestMode && data.license_key?.test_mode) {
+      return { valid: false, isNetworkError: 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) {
+        return { valid: false, isNetworkError: false, error: productError };
+      }
+    }
+    return {
+      valid: true,
+      licenseKey: data.license_key?.key,
+      customerName: data.meta?.customer_name,
+      productName: data.meta?.product_name,
+      variantId: data.meta?.variant_id,
+      variantName: data.meta?.variant_name
+    };
+  } catch (err) {
+    const message = err instanceof Error && err.name === "AbortError" ? "Request timed out. Please check your network connection and try again." : err instanceof Error ? err.message : "Network error";
+    return { valid: false, isNetworkError: true, error: message };
+  }
+}
 async function deactivateLicense(licenseKey, instanceId) {
   try {
     const res = await fetchWithTimeout(`${BASE_URL}/deactivate`, {
@@ -2000,6 +2154,52 @@ async function deactivateLicense(licenseKey, instanceId) {
   }
 }
 
+// ../../packages/shared/src/licenseRevalidation.ts
+async function revalidateStaleLicenses(options) {
+  const stale = getAllLicensesNeedingRevalidation();
+  const result = { checked: stale.length, refreshed: 0, revoked: 0, skippedNetworkError: 0 };
+  if (stale.length === 0) return result;
+  const updates = /* @__PURE__ */ new Map();
+  for (const entry of stale) {
+    const vResult = await validateLicense(entry.licenseKey, entry.instanceId, {
+      allowTestMode: options?.allowTestMode
+    });
+    if (vResult.valid) {
+      const patch = {
+        lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (vResult.customerName) patch.customerName = vResult.customerName;
+      updates.set(entry.licenseKey, patch);
+      result.refreshed++;
+    } else if (vResult.isNetworkError) {
+      result.skippedNetworkError++;
+    } else {
+      updates.set(entry.licenseKey, { status: "inactive" });
+      result.revoked++;
+    }
+  }
+  if (updates.size > 0) {
+    const store = readLicenseStore();
+    for (const [key, patch] of updates) {
+      const idx = store.licenses.findIndex((l) => l.licenseKey === key);
+      if (idx >= 0) {
+        Object.assign(store.licenses[idx], patch);
+      }
+    }
+    writeLicenseStore(store);
+  }
+  return result;
+}
+async function getLicenseForFeatureWithRevalidation(feature, options) {
+  const license = getLicenseForFeature(feature);
+  if (!license) return void 0;
+  if (needsRevalidation(license)) {
+    await revalidateStaleLicenses(options);
+    return getLicenseForFeature(feature);
+  }
+  return license;
+}
+
 // src/tools/getMomentum.ts
 import { z } from "zod";
 function registerGetMomentum(server, reader, workspacePath) {
@@ -2253,7 +2453,7 @@ function registerGetReentryBriefing(server, reader, workspacePath) {
 }
 
 // src/tools/saveCheckpoint.ts
-import path8 from "path";
+import path9 from "path";
 import { z as z4 } from "zod";
 function registerSaveCheckpoint(server, reader, workspacePath) {
   server.tool(
@@ -2269,7 +2469,7 @@ function registerSaveCheckpoint(server, reader, workspacePath) {
       const gitBranch = getCurrentBranch(workspacePath);
       const touchedFiles = getTouchedFiles(workspacePath);
       const commitHashes = getCommitsSince(workspacePath, lastSession?.timestamp);
-      const projectName = path8.basename(resolveStorageRoot(workspacePath));
+      const projectName = path9.basename(resolveStorageRoot(workspacePath));
       const sessionId = generateSessionId({ workspaceRoot: workspacePath, branch: gitBranch ?? void 0, worktreePath: workspacePath });
       const checkpoint = createCheckpoint({
         summary,
@@ -2336,7 +2536,7 @@ function registerGetDecisions(server, reader) {
           ]
         };
       }
-      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("decisions")) {
         return {
           content: [
             {
@@ -2389,7 +2589,7 @@ function registerGetDecisions(server, reader) {
 function registerGetCurrentTask(server, reader) {
   server.tool(
     "get_current_task",
-    "Get current live session tasks. Shows all active AI agent sessions, what each is doing, last files edited, and next steps. Supports multiple concurrent sessions.",
+    "Get a bird's eye view of all active Claude sessions. See what each session is working on, which branch it is on, and when it last did something. Useful when running multiple parallel sessions across worktrees.",
     {},
     async () => {
       if (!reader.exists()) {
@@ -2402,7 +2602,7 @@ function registerGetCurrentTask(server, reader) {
           ]
         };
       }
-      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("session-awareness")) {
         return {
           content: [
             {
@@ -2438,12 +2638,15 @@ function registerGetCurrentTask(server, reader) {
       for (const task of [...activeTasks, ...finishedTasks]) {
         const statusIcon = task.sessionActive ? "\u{1F7E2}" : "\u2705";
         const statusLabel = task.sessionActive ? "Active" : "Finished";
-        const sessionLabel = task.agentLabel || task.sessionId || "Session";
+        const sessionLabel = task.sessionLabel || task.agentLabel || task.sessionId || "Session";
         lines.push(`### ${statusIcon} ${sessionLabel} (${statusLabel})`);
         lines.push(`- **Updated:** ${formatRelativeTime(task.updatedAt)}`);
         if (task.branch) {
           lines.push(`- **Branch:** ${task.branch}`);
         }
+        if (task.agentLabel && task.sessionLabel) {
+          lines.push(`- **Agent:** ${task.agentLabel}`);
+        }
         if (task.taskSummary) {
           lines.push(`- **Doing:** ${task.taskSummary}`);
         }
@@ -2484,25 +2687,25 @@ function registerGetCurrentTask(server, reader) {
 import { z as z6 } from "zod";
 
 // src/cli/migrate.ts
-import fs6 from "fs";
-import os3 from "os";
-import path9 from "path";
+import fs7 from "fs";
+import os4 from "os";
+import path10 from "path";
 var STATUSLINE_CMD2 = "npx -y @keepgoingdev/mcp-server --statusline";
 function isLegacyStatusline(command) {
   return !command.includes("--statusline") && command.includes("keepgoing-statusline");
 }
 function migrateStatusline(wsPath) {
-  const settingsPath = path9.join(wsPath, ".claude", "settings.json");
-  if (!fs6.existsSync(settingsPath)) return void 0;
+  const settingsPath = path10.join(wsPath, ".claude", "settings.json");
+  if (!fs7.existsSync(settingsPath)) return void 0;
   try {
-    const settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
     const cmd = settings.statusLine?.command;
     if (!cmd || !isLegacyStatusline(cmd)) return void 0;
     settings.statusLine = {
       type: "command",
       command: STATUSLINE_CMD2
     };
-    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     cleanupLegacyScript();
     return "[KeepGoing] Migrated statusline to auto-updating command (restart Claude Code to apply)";
   } catch {
@@ -2510,10 +2713,10 @@ function migrateStatusline(wsPath) {
   }
 }
 function cleanupLegacyScript() {
-  const legacyScript = path9.join(os3.homedir(), ".claude", "keepgoing-statusline.sh");
-  if (fs6.existsSync(legacyScript)) {
+  const legacyScript = path10.join(os4.homedir(), ".claude", "keepgoing-statusline.sh");
+  if (fs7.existsSync(legacyScript)) {
     try {
-      fs6.unlinkSync(legacyScript);
+      fs7.unlinkSync(legacyScript);
     } catch {
     }
   }
@@ -2526,15 +2729,17 @@ function registerSetupProject(server, workspacePath) {
     'Set up KeepGoing hooks and instructions. Use scope "user" for global setup (all projects) or "project" for per-project setup.',
     {
       sessionHooks: z6.boolean().optional().default(true).describe("Add session hooks to settings.json"),
-      claudeMd: z6.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md"),
-      scope: z6.enum(["project", "user"]).optional().default("project").describe('Where to write config: "user" for global (~/.claude/), "project" for per-project (.claude/)')
+      claudeMd: z6.boolean().optional().default(true).describe("Add KeepGoing instructions to .claude/rules/keepgoing.md"),
+      scope: z6.enum(["project", "user"]).optional().default("project").describe('Where to write config: "user" for global (~/.claude/), "project" for per-project (.claude/)'),
+      claudeDir: z6.string().optional().describe("Override the Claude config directory for user scope (defaults to CLAUDE_CONFIG_DIR env var or ~/.claude)")
     },
-    async ({ sessionHooks, claudeMd, scope }) => {
+    async ({ sessionHooks, claudeMd, scope, claudeDir }) => {
       const result = setupProject({
         workspacePath,
         scope,
         sessionHooks,
         claudeMd,
+        claudeDir,
         statusline: {
           isLegacy: isLegacyStatusline,
           cleanup: cleanupLegacyScript
@@ -2872,7 +3077,7 @@ async function handlePrintMomentum() {
   process.exit(0);
 }
 async function handlePrintCurrent() {
-  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("session-awareness")) {
     process.exit(0);
   }
   const wsPath = resolveWsPath();
@@ -2909,7 +3114,7 @@ async function handlePrintCurrent() {
 }
 
 // src/cli/saveCheckpoint.ts
-import path10 from "path";
+import path11 from "path";
 async function handleSaveCheckpoint() {
   const wsPath = resolveWsPath();
   const reader = new KeepGoingReader(wsPath);
@@ -2937,9 +3142,9 @@ async function handleSaveCheckpoint() {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path10.basename(f)).join(", ")}`;
+  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path11.basename(f)).join(", ")}`;
   const nextStep = buildSmartNextStep(events);
-  const projectName = path10.basename(resolveStorageRoot(wsPath));
+  const projectName = path11.basename(resolveStorageRoot(wsPath));
   const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
   const checkpoint = createCheckpoint({
     summary,
@@ -2960,16 +3165,19 @@ async function handleSaveCheckpoint() {
     branch: gitBranch ?? void 0,
     updatedAt: checkpoint.timestamp
   });
-  if ((process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("decisions")) && commitMessages.length > 0) {
-    const headHash = getHeadCommitHash(wsPath) || commitHashes[0];
-    if (headHash) {
+  if (process.env.KEEPGOING_PRO_BYPASS === "1" || await getLicenseForFeatureWithRevalidation("decisions")) {
+    for (let i = 0; i < commitHashes.length; i++) {
+      const hash = commitHashes[i];
+      const message = commitMessages[i];
+      if (!hash || !message) continue;
+      const files = getFilesChangedInCommit(wsPath, hash);
       const detected = tryDetectDecision({
         workspacePath: wsPath,
         checkpointId: checkpoint.id,
         gitBranch,
-        commitHash: headHash,
-        commitMessage: commitMessages[0],
-        filesChanged: touchedFiles
+        commitHash: hash,
+        commitMessage: message,
+        filesChanged: files
       });
       if (detected) {
         console.log(`[KeepGoing] Decision detected: ${detected.category} (${(detected.confidence * 100).toFixed(0)}% confidence)`);
@@ -2981,7 +3189,7 @@ async function handleSaveCheckpoint() {
 }
 
 // src/cli/transcriptUtils.ts
-import fs7 from "fs";
+import fs8 from "fs";
 var TAIL_READ_BYTES = 8192;
 var TOOL_VERB_MAP = {
   Edit: "editing",
@@ -3032,9 +3240,9 @@ function isAssistantEntry(entry) {
   return entry.message?.role === "assistant";
 }
 function extractSessionLabel(transcriptPath) {
-  if (!transcriptPath || !fs7.existsSync(transcriptPath)) return null;
+  if (!transcriptPath || !fs8.existsSync(transcriptPath)) return null;
   try {
-    const raw = fs7.readFileSync(transcriptPath, "utf-8");
+    const raw = fs8.readFileSync(transcriptPath, "utf-8");
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -3063,19 +3271,19 @@ function extractSessionLabel(transcriptPath) {
   return null;
 }
 function extractCurrentAction(transcriptPath) {
-  if (!transcriptPath || !fs7.existsSync(transcriptPath)) return null;
+  if (!transcriptPath || !fs8.existsSync(transcriptPath)) return null;
   try {
-    const stat = fs7.statSync(transcriptPath);
+    const stat = fs8.statSync(transcriptPath);
     const fileSize = stat.size;
     if (fileSize === 0) return null;
     const readSize = Math.min(fileSize, TAIL_READ_BYTES);
     const offset = fileSize - readSize;
     const buf = Buffer.alloc(readSize);
-    const fd = fs7.openSync(transcriptPath, "r");
+    const fd = fs8.openSync(transcriptPath, "r");
     try {
-      fs7.readSync(fd, buf, 0, readSize, offset);
+      fs8.readSync(fd, buf, 0, readSize, offset);
     } finally {
-      fs7.closeSync(fd);
+      fs8.closeSync(fd);
     }
     const tail = buf.toString("utf-8");
     const lines = tail.split("\n").reverse();
@@ -3177,8 +3385,8 @@ async function handleUpdateTaskFromHook() {
 }
 
 // src/cli/statusline.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 var STDIN_TIMEOUT_MS2 = 3e3;
 async function handleStatusline() {
   const chunks = [];
@@ -3205,9 +3413,9 @@ async function handleStatusline() {
       if (!label) {
         try {
           const gitRoot = findGitRoot(dir);
-          const tasksFile = path11.join(gitRoot, ".keepgoing", "current-tasks.json");
-          if (fs8.existsSync(tasksFile)) {
-            const data = JSON.parse(fs8.readFileSync(tasksFile, "utf-8"));
+          const tasksFile = path12.join(gitRoot, ".keepgoing", "current-tasks.json");
+          if (fs9.existsSync(tasksFile)) {
+            const data = JSON.parse(fs9.readFileSync(tasksFile, "utf-8"));
             const tasks = pruneStaleTasks(data.tasks ?? []);
             const match = sessionId ? tasks.find((t) => t.sessionId === sessionId) : void 0;
             if (match?.sessionLabel) {
@@ -3254,6 +3462,35 @@ async function handleContinueOn() {
   process.exit(0);
 }
 
+// src/cli/detectDecisions.ts
+async function handleDetectDecisions() {
+  const wsPath = resolveWsPath();
+  if (!(process.env.KEEPGOING_PRO_BYPASS === "1" || await getLicenseForFeatureWithRevalidation("decisions"))) {
+    process.exit(0);
+  }
+  const reader = new KeepGoingReader(wsPath);
+  if (!reader.exists()) {
+    process.exit(0);
+  }
+  const gitBranch = getCurrentBranch(wsPath);
+  const headHash = getHeadCommitHash(wsPath);
+  if (!headHash) process.exit(0);
+  const commitMessage = getCommitMessageByHash(wsPath, headHash);
+  if (!commitMessage) process.exit(0);
+  const files = getFilesChangedInCommit(wsPath, headHash);
+  const detected = tryDetectDecision({
+    workspacePath: wsPath,
+    gitBranch,
+    commitHash: headHash,
+    commitMessage,
+    filesChanged: files
+  });
+  if (detected) {
+    console.log(`[KeepGoing] Decision detected: ${detected.category} (${(detected.confidence * 100).toFixed(0)}% confidence)`);
+  }
+  process.exit(0);
+}
+
 // src/index.ts
 var CLI_HANDLERS = {
   "--print-momentum": handlePrintMomentum,
@@ -3262,7 +3499,8 @@ var CLI_HANDLERS = {
   "--update-task-from-hook": handleUpdateTaskFromHook,
   "--print-current": handlePrintCurrent,
   "--statusline": handleStatusline,
-  "--continue-on": handleContinueOn
+  "--continue-on": handleContinueOn,
+  "--detect-decisions": handleDetectDecisions
 };
 var flag = process.argv.slice(2).find((a) => a in CLI_HANDLERS);
 if (flag) {