@claudemini/shit-cli 1.4.0 → 1.5.0

package/lib/doctor.js

@@ -5,20 +5,10 @@
  * Similar to 'entire doctor' - repairs corrupted state and cleans up
  */
 
-import { existsSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -33,7 +23,6 @@ function checkShitLogsStructure(projectRoot) {
       type: 'missing_directory',
       message: '.shit-logs directory not found',
       fix: () => {
-        const { mkdirSync } = require('fs');
         mkdirSync(shitLogsDir, { recursive: true });
         return 'Created .shit-logs directory';
       }
@@ -67,7 +56,6 @@ function checkShitLogsStructure(projectRoot) {
         message: 'index.json is corrupted',
         fix: () => {
           const backup = `${indexFile}.backup.${Date.now()}`;
-          const { copyFileSync } = require('fs');
           copyFileSync(indexFile, backup);
 
           const initialIndex = {
@@ -98,7 +86,7 @@ function checkSessionDirectories(projectRoot) {
   const entries = readdirSync(shitLogsDir);
   const sessionDirs = entries.filter(name => {
     const fullPath = join(shitLogsDir, name);
-    return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
   });
 
   for (const sessionDir of sessionDirs) {
@@ -132,7 +120,6 @@ function checkSessionDirectories(projectRoot) {
           sessionDir,
           fix: () => {
             const backup = `${stateFile}.backup.${Date.now()}`;
-            const { copyFileSync } = require('fs');
             copyFileSync(stateFile, backup);
 
             const defaultState = {
@@ -166,7 +153,7 @@ function checkOrphanedShadowBranches(projectRoot) {
     const sessionDirs = existsSync(shitLogsDir) ?
       readdirSync(shitLogsDir).filter(name => {
         const fullPath = join(shitLogsDir, name);
-        return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+        return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
       }) : [];
 
     for (const branch of branches) {
@@ -208,11 +195,12 @@ function checkStuckSessions(projectRoot) {
   const entries = readdirSync(shitLogsDir);
   const sessionDirs = entries.filter(name => {
     const fullPath = join(shitLogsDir, name);
-    return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
   });
 
   const now = new Date();
   const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  const endedHookTypes = new Set(['session-end', 'SessionEnd', 'stop', 'session_end', 'end']);
 
   for (const sessionDir of sessionDirs) {
     const sessionPath = join(shitLogsDir, sessionDir);
@@ -221,13 +209,18 @@ function checkStuckSessions(projectRoot) {
     if (existsSync(stateFile)) {
       try {
         const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
-        const startTime = new Date(state.start_time);
-
-        // Check for sessions older than 24 hours without end_time
-        if (!state.end_time && startTime < oneDayAgo) {
+        const lastActivity = new Date(state.last_time || state.start_time);
+        const hasValidLastActivity = !Number.isNaN(lastActivity.getTime());
+        const endedByHook = endedHookTypes.has(state.last_hook_type);
+        const hasShadowBranch = typeof state.shadow_branch === 'string' && state.shadow_branch.length > 0;
+        const hasCheckpoint = Array.isArray(state.checkpoints) && state.checkpoints.length > 0;
+        const consideredEnded = Boolean(state.end_time) || endedByHook || hasShadowBranch || hasCheckpoint;
+
+        // Stuck means inactive for >24h and not explicitly/implicitly ended.
+        if (!consideredEnded && hasValidLastActivity && lastActivity < oneDayAgo) {
           issues.push({
             type: 'stuck_session',
-            message: `Stuck session: ${sessionDir} (started ${startTime.toLocaleString()})`,
+            message: `Stuck session: ${sessionDir} (last activity ${lastActivity.toLocaleString()})`,
             sessionDir,
             fix: () => {
               state.end_time = new Date().toISOString();
@@ -248,7 +241,7 @@ function checkStuckSessions(projectRoot) {
 
 export default async function doctor(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const autoFix = args.includes('--fix') || args.includes('--auto-fix');
     const verbose = args.includes('--verbose') || args.includes('-v');
 

package/lib/enable.js

@@ -9,17 +9,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot } from './config.js';
 
 // Agent-specific hook configurations
 const AGENT_HOOKS = {
@@ -95,9 +85,30 @@ function setupAgentHooks(projectRoot, agentType) {
   }
 
   // Add shit-cli hooks
-  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
 
   for (const [hookName, command] of Object.entries(config.hooks)) {
+    if (agentType === 'claude-code') {
+      const current = settings.hooks[hookName];
+      const existing = Array.isArray(current)
+        ? current
+        : (typeof current === 'string'
+          ? [{ matcher: '', hooks: [{ type: 'command', command: current }] }]
+          : []);
+      const alreadyExists = existing.some(entry =>
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some(hook => typeof hook?.command === 'string' && hook.command.includes('shit log'))
+      );
+
+      if (!alreadyExists) {
+        existing.push({ matcher: '', hooks: [{ type: 'command', command }] });
+      }
+      settings.hooks[hookName] = existing;
+      continue;
+    }
+
     settings.hooks[hookName] = command;
   }
 
@@ -164,7 +175,7 @@ function initializeShitLogs(projectRoot) {
 
 export default async function enable(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
 
     // Parse arguments
     const agents = [];

package/lib/explain.js

@@ -5,19 +5,25 @@
  * Provides human-readable explanation of what happened in a session
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
+function git(args, cwd, ignoreError = false) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 10000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch (error) {
+    if (ignoreError) {
+      return null;
     }
-    dir = join(dir, '..');
+    throw error;
   }
-  throw new Error('Not in a git repository');
 }
 
 function getSessionData(sessionId, projectRoot) {
@@ -41,7 +47,6 @@ function getSessionData(sessionId, projectRoot) {
 }
 
 function explainFromSummary(summaryText) {
-  const lines = summaryText.split('\n');
   const explanation = [];
 
   // Extract key information
@@ -113,23 +118,20 @@ function explainFromSummary(summaryText) {
 function explainFromCommit(commitSha, projectRoot) {
   try {
     // Try to find associated checkpoint
-    const checkpoints = execSync('git branch --list "shit/checkpoints/v1/*"', {
-      cwd: projectRoot,
-      encoding: 'utf-8'
-    }).split('\n').filter(Boolean);
+    const checkpoints = (git(['branch', '--list', 'shit/checkpoints/v1/*'], projectRoot, true) || '')
+      .split('\n')
+      .map(line => line.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
 
     for (const branch of checkpoints) {
       try {
-        const log = execSync(`git log ${branch} --oneline -1`, {
-          cwd: projectRoot,
-          encoding: 'utf-8'
-        }).trim();
+        const log = git(['log', branch, '--oneline', '-1'], projectRoot, true);
+        if (!log) {
+          continue;
+        }
 
         if (log.includes(commitSha.slice(0, 12))) {
-          const message = execSync(`git log ${branch} --format=%B -1`, {
-            cwd: projectRoot,
-            encoding: 'utf-8'
-          }).trim();
+          const message = git(['log', branch, '--format=%B', '-1'], projectRoot, true) || '';
 
           return `📸 This commit has an associated checkpoint:\n\nBranch: ${branch}\n\n${message}`;
         }
@@ -146,13 +148,13 @@ function explainFromCommit(commitSha, projectRoot) {
 
 export default async function explain(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const target = args[0];
 
     if (!target) {
       console.log('Usage: shit explain <session-id | commit-sha>');
       console.log('\nExamples:');
-      console.log('  shit explain 2026-02-28-abc12345  # Explain a session');
+      console.log('  shit explain b5613b31-c732-4546-9be5-f8ae36f2327f  # Explain a session');
       console.log('  shit explain abc1234              # Explain a commit');
       process.exit(1);
     }
@@ -170,23 +172,26 @@ export default async function explain(args) {
     }
 
     // Try as commit
-    try {
-      execSync('git rev-parse --verify ' + target + '^{commit}', {
-        cwd: projectRoot,
-        stdio: 'ignore'
-      });
-
-      console.log('📸 Commit Explanation\n');
-      console.log(explainFromCommit(target, projectRoot));
-      return;
-    } catch {
-      // Not a commit
+    const isCommitLike = /^[a-f0-9]{4,40}$/i.test(target);
+    if (isCommitLike) {
+      const resolvedCommit = git(['rev-parse', '--verify', `${target}^{commit}`], projectRoot, true);
+      if (resolvedCommit) {
+        console.log('📸 Commit Explanation\n');
+        console.log(explainFromCommit(resolvedCommit, projectRoot));
+        return;
+      }
     }
 
+    // Not a commit
+
     // Try partial match
-    const sessions = execSync('ls .shit-logs', { cwd: projectRoot, encoding: 'utf-8' })
-      .split('\n')
-      .filter(s => s.includes(target));
+    const logDir = join(projectRoot, '.shit-logs');
+    const sessions = existsSync(logDir)
+      ? readdirSync(logDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && SESSION_ID_REGEX.test(entry.name))
+        .map(entry => entry.name)
+        .filter(name => name.includes(target))
+      : [];
 
     if (sessions.length > 0) {
       const matchedSession = sessions[0];

package/lib/reset.js

@@ -5,20 +5,10 @@
  * Similar to 'entire reset' - removes shadow branch and session state
  */
 
-import { existsSync, readFileSync, rmSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -53,9 +43,11 @@ function findActiveSession(projectRoot) {
     return null;
   }
 
-  const { readdirSync, statSync } = require('fs');
   const sessions = readdirSync(shitLogsDir)
-    .filter(name => name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/))
+    .filter(name => {
+      const fullPath = join(shitLogsDir, name);
+      return SESSION_ID_REGEX.test(name) && statSync(fullPath).isDirectory();
+    })
     .map(name => ({
       name,
       path: join(shitLogsDir, name),
@@ -68,7 +60,7 @@ function findActiveSession(projectRoot) {
 
 export default async function reset(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const force = args.includes('--force') || args.includes('-f');
 
     // Get current commit
@@ -112,7 +104,7 @@ export default async function reset(args) {
           if (state.checkpoints && state.checkpoints.some(cp => cp.linked_commit === commitSha)) {
             // Remove checkpoint references
             state.checkpoints = state.checkpoints.filter(cp => cp.linked_commit !== commitSha);
-            require('fs').writeFileSync(stateFile, JSON.stringify(state, null, 2));
+            writeFileSync(stateFile, JSON.stringify(state, null, 2));
             console.log('✅ Updated session state');
           }
         } catch {

package/lib/resume.js

@@ -8,17 +8,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { randomUUID } from 'crypto';
+import { getProjectRoot } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -26,19 +17,37 @@ function git(cmd, cwd) {
 
 function findCheckpoint(projectRoot, checkpointId) {
   try {
-    const branches = git('branch --list "shit/*"', projectRoot)
+    const branches = git('branch --list "shit/checkpoints/v1/*" "shit/*"', projectRoot)
       .split('\n')
       .map(b => b.trim().replace(/^\*?\s*/, ''))
       .filter(Boolean);
 
     for (const branch of branches) {
-      const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
-      if (match) {
-        const [, baseCommit, sessionShort] = match;
-        if (sessionShort.startsWith(checkpointId) || baseCommit.startsWith(checkpointId)) {
-          const log = git(`log ${branch} --oneline -1`, projectRoot);
-          const timestamp = git(`log ${branch} --format=%ci -1`, projectRoot);
+      const timestamp = git(`log ${branch} --format=%ci -1`, projectRoot);
+      const log = git(`log ${branch} --oneline -1`, projectRoot);
+
+      const checkpointMatch = branch.match(/^shit\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+      if (checkpointMatch) {
+        const branchKey = `${checkpointMatch[1]}-${checkpointMatch[2]}`;
+        const message = git(`log ${branch} --format=%B -1`, projectRoot);
+        const linkedMatch = message.match(/@ ([a-f0-9]+)/);
+        const baseCommit = linkedMatch ? linkedMatch[1] : null;
+
+        if (branchKey.startsWith(checkpointId) || checkpointMatch[2].startsWith(checkpointId) || (baseCommit && baseCommit.startsWith(checkpointId))) {
+          return {
+            branch,
+            baseCommit,
+            sessionShort: checkpointMatch[2],
+            timestamp,
+            message: log.split(' ').slice(1).join(' ')
+          };
+        }
+      }
 
+      const shadowMatch = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+      if (shadowMatch) {
+        const [, baseCommit, sessionShort] = shadowMatch;
+        if (sessionShort.startsWith(checkpointId) || baseCommit.startsWith(checkpointId)) {
           return {
             branch,
             baseCommit,
@@ -116,11 +125,7 @@ function restoreSessionData(projectRoot, sessionData, newSessionId) {
 }
 
 function generateSessionId() {
-  const now = new Date();
-  const date = now.toISOString().split('T')[0]; // YYYY-MM-DD
-  const uuid = Math.random().toString(36).substring(2, 15) +
-               Math.random().toString(36).substring(2, 15);
-  return `${date}-${uuid}`;
+  return randomUUID();
 }
 
 function updateSessionState(sessionDir, checkpoint) {
@@ -149,7 +154,7 @@ function updateSessionState(sessionDir, checkpoint) {
 
 export default async function resume(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const checkpointId = args.find(arg => !arg.startsWith('-'));
 
     if (!checkpointId) {
@@ -164,19 +169,19 @@ export default async function resume(args) {
     const checkpoint = findCheckpoint(projectRoot, checkpointId);
     if (!checkpoint) {
       console.error(`❌ Checkpoint not found: ${checkpointId}`);
-      console.error('   Use "shit shadow" to list available checkpoints');
+      console.error('   Use "shit checkpoints" to list available checkpoints');
       process.exit(1);
     }
 
     console.log(`✅ Found checkpoint: ${checkpoint.sessionShort}`);
     console.log(`   Branch: ${checkpoint.branch}`);
-    console.log(`   Base commit: ${checkpoint.baseCommit}`);
+    console.log(`   Base commit: ${checkpoint.baseCommit || 'unknown'}`);
     console.log(`   Created: ${new Date(checkpoint.timestamp).toLocaleString()}`);
     console.log();
 
     // Check if we're already at the right commit
     const currentCommit = git('rev-parse HEAD', projectRoot);
-    if (!currentCommit.startsWith(checkpoint.baseCommit)) {
+    if (checkpoint.baseCommit && !currentCommit.startsWith(checkpoint.baseCommit)) {
       console.log(`🔄 Checking out base commit: ${checkpoint.baseCommit}`);
       git(`checkout ${checkpoint.baseCommit}`, projectRoot);
     }

package/lib/rewind.js

@@ -5,54 +5,71 @@
  * Similar to 'entire rewind' - rollback to known good state
  */
 
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
 }
 
+function parseCheckpointRef(projectRoot, branch) {
+  const shadowMatch = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+  if (shadowMatch) {
+    return {
+      type: 'shadow',
+      baseCommit: shadowMatch[1],
+      sessionShort: shadowMatch[2],
+      lookupKey: shadowMatch[2],
+    };
+  }
+
+  const checkpointMatch = branch.match(/^shit\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+  if (checkpointMatch) {
+    const message = git(`log ${branch} --format=%B -1`, projectRoot);
+    const linkedMatch = message.match(/@ ([a-f0-9]+)/);
+    const date = checkpointMatch[1];
+    const sessionShort = checkpointMatch[2];
+    return {
+      type: 'checkpoint',
+      baseCommit: linkedMatch ? linkedMatch[1] : null,
+      sessionShort,
+      lookupKey: `${date}-${sessionShort}`,
+    };
+  }
+
+  return null;
+}
+
 function listCheckpoints(projectRoot) {
   try {
-    // Get shadow branches
-    const branches = git('branch --list "shit/*"', projectRoot)
+    const branches = git('branch --list "shit/checkpoints/v1/*" "shit/*"', projectRoot)
       .split('\n')
       .map(b => b.trim().replace(/^\*?\s*/, ''))
       .filter(Boolean);
+    const uniqueBranches = [...new Set(branches)];
 
     const checkpoints = [];
 
-    for (const branch of branches) {
+    for (const branch of uniqueBranches) {
       try {
+        const parsed = parseCheckpointRef(projectRoot, branch);
+        if (!parsed) {
+          continue;
+        }
+
         const log = git(`log ${branch} --oneline -1`, projectRoot);
         const [commit, ...messageParts] = log.split(' ');
         const message = messageParts.join(' ');
-
-        // Extract session info from branch name: shit/<commit>-<session>
-        const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
-        if (match) {
-          const [, baseCommit, sessionShort] = match;
-          checkpoints.push({
-            branch,
-            commit,
-            baseCommit,
-            sessionShort,
-            message,
-            timestamp: git(`log ${branch} --format=%ci -1`, projectRoot)
-          });
-        }
+        checkpoints.push({
+          branch,
+          commit,
+          baseCommit: parsed.baseCommit,
+          sessionShort: parsed.sessionShort,
+          lookupKey: parsed.lookupKey,
+          type: parsed.type,
+          message,
+          timestamp: git(`log ${branch} --format=%ci -1`, projectRoot)
+        });
       } catch {
         // Skip invalid branches
       }
@@ -84,6 +101,10 @@ function hasUncommittedChanges(projectRoot) {
 function rewindToCheckpoint(projectRoot, checkpoint, force = false) {
   const currentCommit = getCurrentCommit(projectRoot);
 
+  if (!checkpoint.baseCommit) {
+    throw new Error(`Checkpoint ${checkpoint.lookupKey || checkpoint.sessionShort} is missing a linked base commit`);
+  }
+
   if (!force && hasUncommittedChanges(projectRoot)) {
     throw new Error('Working directory has uncommitted changes. Use --force to override or commit changes first.');
   }
@@ -100,7 +121,7 @@ function rewindToCheckpoint(projectRoot, checkpoint, force = false) {
 
 export default async function rewind(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const force = args.includes('--force') || args.includes('-f');
     const interactive = args.includes('--interactive') || args.includes('-i');
 
@@ -112,7 +133,7 @@ export default async function rewind(args) {
 
     if (checkpoints.length === 0) {
       console.log('❌ No checkpoints found');
-      console.log('   Checkpoints are created automatically when sessions end.');
+      console.log('   Checkpoints are created when you run "shit commit".');
       process.exit(1);
     }
 
@@ -120,7 +141,8 @@ export default async function rewind(args) {
       // Find specific checkpoint
       targetCheckpoint = checkpoints.find(cp =>
         cp.sessionShort.startsWith(checkpointArg) ||
-        cp.baseCommit.startsWith(checkpointArg)
+        cp.lookupKey.startsWith(checkpointArg) ||
+        (cp.baseCommit && cp.baseCommit.startsWith(checkpointArg))
       );
 
       if (!targetCheckpoint) {
@@ -132,22 +154,25 @@ export default async function rewind(args) {
       console.log('📋 Available checkpoints:\n');
       checkpoints.forEach((cp, i) => {
         const date = new Date(cp.timestamp).toLocaleString();
-        console.log(`${i + 1}. ${cp.sessionShort} (${cp.baseCommit.slice(0, 7)}) - ${date}`);
+        const base = cp.baseCommit ? cp.baseCommit.slice(0, 7) : 'unknown';
+        const key = cp.lookupKey || cp.sessionShort;
+        console.log(`${i + 1}. ${key} (${base}) - ${date}`);
         console.log(`   ${cp.message}`);
         console.log();
       });
 
       // For now, just use the most recent
       targetCheckpoint = checkpoints[0];
-      console.log(`Using most recent checkpoint: ${targetCheckpoint.sessionShort}`);
+      console.log(`Using most recent checkpoint: ${targetCheckpoint.lookupKey || targetCheckpoint.sessionShort}`);
     } else {
       // Use most recent checkpoint
       targetCheckpoint = checkpoints[0];
     }
 
-    console.log(`🔄 Rewinding to checkpoint: ${targetCheckpoint.sessionShort}`);
+    const selectedKey = targetCheckpoint.lookupKey || targetCheckpoint.sessionShort;
+    console.log(`🔄 Rewinding to checkpoint: ${selectedKey}`);
     console.log(`   Branch: ${targetCheckpoint.branch}`);
-    console.log(`   Base commit: ${targetCheckpoint.baseCommit}`);
+    console.log(`   Base commit: ${targetCheckpoint.baseCommit || 'unknown'}`);
     console.log(`   Created: ${new Date(targetCheckpoint.timestamp).toLocaleString()}`);
     console.log();
 
@@ -164,7 +189,7 @@ export default async function rewind(args) {
     console.log(`   git reset --hard ${previousCommit}`);
     console.log();
     console.log('💡 To resume from this checkpoint:');
-    console.log(`   shit resume ${targetCheckpoint.sessionShort}`);
+    console.log(`   shit resume ${selectedKey}`);
 
   } catch (error) {
     console.error('❌ Failed to rewind:', error.message);

package/lib/session.js

@@ -105,6 +105,12 @@ export function processEvent(state, event, hookType, projectRoot) {
     return;
   }
 
+  // Mark session as ended for end/stop hooks.
+  if (hookType === 'session-end' || hookType === 'SessionEnd' || hookType === 'stop' || hookType === 'session_end' || hookType === 'end') {
+    state.end_time = now;
+    return;
+  }
+
   // Tool events
   if (hookType === 'post-tool-use' && toolName) {
     state.tool_counts[toolName] = (state.tool_counts[toolName] || 0) + 1;