@keepgoingdev/cli 1.1.1 → 1.2.1

package/dist/index.js

@@ -320,7 +320,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`);
@@ -585,9 +586,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";
@@ -609,23 +660,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 {
@@ -643,20 +694,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 = {
@@ -672,7 +725,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
@@ -680,8 +733,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);
       }
@@ -696,6 +749,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) {
@@ -734,8 +789,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 {
@@ -747,7 +802,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) {
@@ -926,35 +981,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;
@@ -988,10 +1043,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;
@@ -1008,11 +1063,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();
 }
@@ -1041,7 +1096,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 {
@@ -1052,8 +1114,8 @@ var DefaultFeatureGate = class {
 var currentGate = new DefaultFeatureGate();
 
 // ../../packages/shared/src/reader.ts
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path7 from "path";
 var STORAGE_DIR2 = ".keepgoing";
 var META_FILE2 = "meta.json";
 var SESSIONS_FILE2 = "sessions.json";
@@ -1075,16 +1137,16 @@ var KeepGoingReader = class {
     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);
+    this.storagePath = path7.join(mainRoot, STORAGE_DIR2);
+    this.metaFilePath = path7.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path7.join(this.storagePath, SESSIONS_FILE2);
+    this.decisionsFilePath = path7.join(this.storagePath, DECISIONS_FILE);
+    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() {
@@ -1322,10 +1384,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;
@@ -1334,9 +1396,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: "",
@@ -1365,36 +1427,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) {
@@ -1423,15 +1504,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);
@@ -1450,15 +1538,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) {
@@ -1489,29 +1582,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 };
@@ -1588,6 +1697,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`, {
@@ -1606,6 +1748,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/render.ts
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
@@ -1919,14 +2107,14 @@ function renderEnrichedBriefingQuiet(briefing) {
 // src/updateCheck.ts
 import { spawn } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import path8 from "path";
-import os3 from "os";
-var CLI_VERSION = "1.1.1";
+import path9 from "path";
+import os4 from "os";
+var CLI_VERSION = "1.2.1";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@keepgoingdev/cli/latest";
 var FETCH_TIMEOUT_MS = 5e3;
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var CACHE_DIR = path8.join(os3.homedir(), ".keepgoing");
-var CACHE_PATH = path8.join(CACHE_DIR, "update-check.json");
+var CACHE_DIR = path9.join(os4.homedir(), ".keepgoing");
+var CACHE_PATH = path9.join(CACHE_DIR, "update-check.json");
 function isNewerVersion(current, latest) {
   const cur = current.split(".").map(Number);
   const lat = latest.split(".").map(Number);
@@ -2041,7 +2229,7 @@ async function statusCommand(opts) {
 }
 
 // src/commands/save.ts
-import path9 from "path";
+import path10 from "path";
 async function saveCommand(opts) {
   const { cwd, message, nextStepOverride, json, quiet, force } = opts;
   const isManual = !!message;
@@ -2070,9 +2258,9 @@ async function saveCommand(opts) {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path9.basename(f)).join(", ")}`;
+  const summary = message ?? buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path10.basename(f)).join(", ")}`;
   const nextStep = nextStepOverride ?? buildSmartNextStep(events);
-  const projectName = path9.basename(resolveStorageRoot(cwd));
+  const projectName = path10.basename(resolveStorageRoot(cwd));
   const sessionId = generateSessionId({
     workspaceRoot: cwd,
     branch: gitBranch ?? void 0,
@@ -2105,12 +2293,25 @@ async function saveCommand(opts) {
 }
 
 // src/commands/hook.ts
-import fs6 from "fs";
-import path10 from "path";
-import os4 from "os";
+import fs7 from "fs";
+import path11 from "path";
+import os5 from "os";
 import { execSync } from "child_process";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
 var HOOK_MARKER_END = "# keepgoing-hook-end";
+var POST_COMMIT_MARKER_START = "# keepgoing-post-commit-start";
+var POST_COMMIT_MARKER_END = "# keepgoing-post-commit-end";
+var KEEPGOING_HOOKS_DIR = path11.join(os5.homedir(), ".keepgoing", "hooks");
+var POST_COMMIT_HOOK_PATH = path11.join(KEEPGOING_HOOKS_DIR, "post-commit");
+var KEEPGOING_MANAGED_MARKER = path11.join(KEEPGOING_HOOKS_DIR, ".keepgoing-managed");
+var POST_COMMIT_HOOK = `#!/bin/sh
+${POST_COMMIT_MARKER_START}
+# Runs after every git commit. Detects high-signal decisions.
+if command -v keepgoing-mcp-server >/dev/null 2>&1; then
+  keepgoing-mcp-server --detect-decisions 2>/dev/null &
+fi
+${POST_COMMIT_MARKER_END}
+`;
 var ZSH_HOOK = `${HOOK_MARKER_START}
 # KeepGoing shell hook \u2014 auto-injected by 'keepgoing hook install'
 if command -v keepgoing >/dev/null 2>&1; then
@@ -2143,7 +2344,7 @@ if command -v keepgoing >/dev/null 2>&1
 end
 ${HOOK_MARKER_END}`;
 function detectShellRcFile(shellOverride) {
-  const home = os4.homedir();
+  const home = os5.homedir();
   let shell;
   if (shellOverride) {
     shell = shellOverride.toLowerCase();
@@ -2166,17 +2367,155 @@ function detectShellRcFile(shellOverride) {
     }
   }
   if (shell === "zsh") {
-    return { shell: "zsh", rcFile: path10.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path11.join(home, ".zshrc") };
   }
   if (shell === "bash") {
-    return { shell: "bash", rcFile: path10.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path11.join(home, ".bashrc") };
   }
   if (shell === "fish") {
-    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path10.join(home, ".config");
-    return { shell: "fish", rcFile: path10.join(xdgConfig, "fish", "config.fish") };
+    const xdgConfig = process.env["XDG_CONFIG_HOME"] || path11.join(home, ".config");
+    return { shell: "fish", rcFile: path11.join(xdgConfig, "fish", "config.fish") };
   }
   return void 0;
 }
+function resolveGlobalGitignorePath() {
+  try {
+    const configured = execSync("git config --global core.excludesfile", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (configured) {
+      return configured.startsWith("~") ? path11.join(os5.homedir(), configured.slice(1)) : configured;
+    }
+  } catch {
+  }
+  return path11.join(os5.homedir(), ".gitignore_global");
+}
+function installGlobalGitignore() {
+  const ignorePath = resolveGlobalGitignorePath();
+  let existing = "";
+  try {
+    existing = fs7.readFileSync(ignorePath, "utf-8");
+  } catch {
+  }
+  if (existing.split("\n").some((line) => line.trim() === ".keepgoing")) {
+    console.log(`Global gitignore: .keepgoing already present in ${ignorePath}`);
+  } else {
+    const suffix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    fs7.appendFileSync(ignorePath, `${suffix}.keepgoing
+`, "utf-8");
+    console.log(`Global gitignore: .keepgoing added to ${ignorePath}`);
+  }
+  try {
+    execSync("git config --global core.excludesfile", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    execSync(`git config --global core.excludesfile "${ignorePath}"`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+}
+function uninstallGlobalGitignore() {
+  const ignorePath = resolveGlobalGitignorePath();
+  let existing = "";
+  try {
+    existing = fs7.readFileSync(ignorePath, "utf-8");
+  } catch {
+    return;
+  }
+  const lines = existing.split("\n");
+  const filtered = lines.filter((line) => line.trim() !== ".keepgoing");
+  if (filtered.length !== lines.length) {
+    fs7.writeFileSync(ignorePath, filtered.join("\n"), "utf-8");
+    console.log(`Global gitignore: .keepgoing removed from ${ignorePath}`);
+  }
+}
+function installPostCommitHook() {
+  fs7.mkdirSync(KEEPGOING_HOOKS_DIR, { recursive: true });
+  if (fs7.existsSync(POST_COMMIT_HOOK_PATH)) {
+    const existing = fs7.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
+    if (existing.includes(POST_COMMIT_MARKER_START)) {
+      console.log(`Git post-commit hook: already installed at ${POST_COMMIT_HOOK_PATH}`);
+    } else {
+      const suffix = existing.endsWith("\n") ? "" : "\n";
+      const block = `${suffix}
+${POST_COMMIT_MARKER_START}
+# Runs after every git commit. Detects high-signal decisions.
+if command -v keepgoing-mcp-server >/dev/null 2>&1; then
+  keepgoing-mcp-server --detect-decisions 2>/dev/null &
+fi
+${POST_COMMIT_MARKER_END}
+`;
+      fs7.appendFileSync(POST_COMMIT_HOOK_PATH, block, "utf-8");
+      console.log(`Git post-commit hook: appended to existing ${POST_COMMIT_HOOK_PATH}`);
+    }
+  } else {
+    fs7.writeFileSync(POST_COMMIT_HOOK_PATH, POST_COMMIT_HOOK, { mode: 493 });
+    console.log(`Git post-commit hook: installed at ${POST_COMMIT_HOOK_PATH}`);
+  }
+  fs7.chmodSync(POST_COMMIT_HOOK_PATH, 493);
+  let currentHooksPath;
+  try {
+    currentHooksPath = execSync("git config --global core.hooksPath", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+  }
+  if (currentHooksPath === KEEPGOING_HOOKS_DIR) {
+    console.log(`Git hooks path: already set to ${KEEPGOING_HOOKS_DIR}`);
+  } else if (currentHooksPath) {
+    console.log(`Git hooks path: set to ${currentHooksPath}`);
+    console.log(`  To use KeepGoing's post-commit hook, add the following to ${currentHooksPath}/post-commit:`);
+    console.log(`  if command -v keepgoing-mcp-server >/dev/null 2>&1; then`);
+    console.log(`    keepgoing-mcp-server --detect-decisions 2>/dev/null &`);
+    console.log(`  fi`);
+  } else {
+    console.log(`Git post-commit hook: saved to ${POST_COMMIT_HOOK_PATH}`);
+    console.log(`  To activate it globally, run:`);
+    console.log(`    git config --global core.hooksPath "${KEEPGOING_HOOKS_DIR}"`);
+    console.log(`  Note: this overrides per-repo .git/hooks/ for all repositories.`);
+  }
+}
+function uninstallPostCommitHook() {
+  if (fs7.existsSync(POST_COMMIT_HOOK_PATH)) {
+    const existing = fs7.readFileSync(POST_COMMIT_HOOK_PATH, "utf-8");
+    if (existing.includes(POST_COMMIT_MARKER_START)) {
+      const pattern = new RegExp(
+        `
+?${POST_COMMIT_MARKER_START}[\\s\\S]*?${POST_COMMIT_MARKER_END}
+?`,
+        "g"
+      );
+      const updated = existing.replace(pattern, "").trim();
+      if (!updated || updated === "#!/bin/sh") {
+        fs7.unlinkSync(POST_COMMIT_HOOK_PATH);
+        console.log(`Git post-commit hook: removed ${POST_COMMIT_HOOK_PATH}`);
+      } else {
+        fs7.writeFileSync(POST_COMMIT_HOOK_PATH, updated + "\n", "utf-8");
+        console.log(`Git post-commit hook: KeepGoing block removed from ${POST_COMMIT_HOOK_PATH}`);
+      }
+    }
+  }
+  try {
+    const currentHooksPath = execSync("git config --global core.hooksPath", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (currentHooksPath === KEEPGOING_HOOKS_DIR) {
+      execSync("git config --global --unset core.hooksPath", {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      console.log("Git hooks path: global core.hooksPath unset");
+    }
+  } catch {
+  }
+  if (fs7.existsSync(KEEPGOING_MANAGED_MARKER)) {
+    fs7.unlinkSync(KEEPGOING_MANAGED_MARKER);
+  }
+}
 function hookInstallCommand(shellOverride) {
   const detected = detectShellRcFile(shellOverride);
   if (!detected) {
@@ -2189,18 +2528,23 @@ function hookInstallCommand(shellOverride) {
   const hookBlock = shell === "zsh" ? ZSH_HOOK : shell === "fish" ? FISH_HOOK : BASH_HOOK;
   let existing = "";
   try {
-    existing = fs6.readFileSync(rcFile, "utf-8");
+    existing = fs7.readFileSync(rcFile, "utf-8");
   } catch {
   }
   if (existing.includes(HOOK_MARKER_START)) {
     console.log(`KeepGoing hook is already installed in ${rcFile}.`);
+    installGlobalGitignore();
+    installPostCommitHook();
     return;
   }
-  fs6.appendFileSync(rcFile, `
+  fs7.appendFileSync(rcFile, `
 ${hookBlock}
 `, "utf-8");
   console.log(`KeepGoing hook installed in ${rcFile}.`);
-  console.log(`Reload your shell config to activate it:
+  installGlobalGitignore();
+  installPostCommitHook();
+  console.log(`
+Reload your shell config to activate it:
 `);
   console.log(`  source ${rcFile}`);
 }
@@ -2215,7 +2559,7 @@ function hookUninstallCommand(shellOverride) {
   const { rcFile } = detected;
   let existing = "";
   try {
-    existing = fs6.readFileSync(rcFile, "utf-8");
+    existing = fs7.readFileSync(rcFile, "utf-8");
   } catch {
     console.log(`${rcFile} not found \u2014 nothing to remove.`);
     return;
@@ -2231,9 +2575,12 @@ function hookUninstallCommand(shellOverride) {
     "g"
   );
   const updated = existing.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-  fs6.writeFileSync(rcFile, updated, "utf-8");
+  fs7.writeFileSync(rcFile, updated, "utf-8");
   console.log(`KeepGoing hook removed from ${rcFile}.`);
-  console.log(`Reload your shell config to deactivate it:
+  uninstallGlobalGitignore();
+  uninstallPostCommitHook();
+  console.log(`
+Reload your shell config to deactivate it:
 `);
   console.log(`  source ${rcFile}`);
 }
@@ -2482,7 +2829,7 @@ async function decisionsCommand(opts) {
     }
     return;
   }
-  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
+  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("decisions")) {
     console.error(
       'Decision Detection requires a Pro license.\nRun "keepgoing activate <key>" or visit https://keepgoing.dev/add-ons to purchase.'
     );
@@ -2686,8 +3033,8 @@ function renderGrouped(sessions, showStat) {
     }
   }
 }
-function logDecisions(reader, opts) {
-  const license = getLicenseForFeature("decisions");
+async function logDecisions(reader, opts) {
+  const license = await getLicenseForFeatureWithRevalidation("decisions");
   if (!license) {
     console.log("Decision tracking requires a Pro license. Run: keepgoing activate <key>");
     return;
@@ -2733,7 +3080,7 @@ async function logCommand(opts) {
     return;
   }
   if (opts.subcommand === "decisions") {
-    logDecisions(reader, opts);
+    await logDecisions(reader, opts);
   } else {
     logSessions(reader, opts);
   }
@@ -3216,7 +3563,7 @@ async function main() {
       }
       break;
     case "version":
-      console.log(`keepgoing v${"1.1.1"}`);
+      console.log(`keepgoing v${"1.2.1"}`);
       break;
     case "activate":
       await activateCommand({ licenseKey: subcommand });

package/package.json

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