@aiplumber/session-recall 1.5.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@aiplumber/session-recall",
+  "version": "1.5.0",
+  "description": "Pull context from previous Claude Code sessions. Sessions end, context resets - this tool lets you continue where you left off.",
+  "bin": {
+    "session-recall": "./session-recall"
+  },
+  "files": [
+    "session-recall",
+    "README.md"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "session",
+    "context",
+    "recall",
+    "cli"
+  ],
+  "author": "Hung Nguyen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pnwtech/session-recall.git"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/session-recall

@@ -0,0 +1,1351 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Filter patterns
+const SHELL_PREFIXES = ['ls ', 'cat ', 'npm ', 'cd ', 'git ', 'mkdir ', 'rm ', 'cp ', 'mv ', 'grep ', 'find '];
+const NOISE_TYPES = ['progress', 'file-history-snapshot', 'system', 'queue-operation'];
+const MAX_USER_MSG_LENGTH = 200;
+const ACTIVE_SESSION_THRESHOLD_MS = 60000; // Sessions with activity in last 60s are "active"
+
+// Token estimation (~4 chars per token for English, conservative)
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+// Marker detection patterns
+const MARKERS = {
+  aha_moment: [/oh!/i, /YES/, /now I see/i, /did we just discover/i, /that's it/i],
+  pushback: [/^no$/i, /^wait$/i, /for real\?/i, /nooo+/i, /^but /i, /hold on/i],
+  strong_opinion: [/\bmust\b/i, /\bnever\b/i, /\balways\b/i, /\bneed to\b/i],
+  clarification: [/you mean/i, /so basically/i, /in other words/i],
+  decision: /^[A-D](,\s*[A-D])*$/i
+};
+
+function readJsonl(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return content.trim().split('\n').map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch (e) {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+function isToolResult(msg) {
+  if (!msg.message?.content) return false;
+  const content = msg.message.content;
+  if (Array.isArray(content)) {
+    return content.some(c => c.type === 'tool_result');
+  }
+  return false;
+}
+
+function isShellCommand(text) {
+  if (typeof text !== 'string') return false;
+  return SHELL_PREFIXES.some(prefix => text.startsWith(prefix));
+}
+
+function getAssistantText(msg) {
+  if (!msg.message?.content) return null;
+  const content = msg.message.content;
+  if (!Array.isArray(content)) return null;
+
+  const textBlocks = content.filter(c => c.type === 'text');
+  if (textBlocks.length === 0) return null;
+  return textBlocks.map(t => t.text).join('\n');
+}
+
+function getUserText(msg) {
+  if (!msg.message?.content) return null;
+  const content = msg.message.content;
+  if (typeof content === 'string') return content;
+  return null;
+}
+
+function detectMarker(text) {
+  if (!text) return null;
+
+  for (const [marker, patterns] of Object.entries(MARKERS)) {
+    if (Array.isArray(patterns)) {
+      if (patterns.some(p => p.test(text))) return marker;
+    } else if (patterns.test(text)) {
+      return marker;
+    }
+  }
+  return null;
+}
+
+function isDiscourse(msg) {
+  if (NOISE_TYPES.includes(msg.type)) return false;
+
+  if (msg.type === 'user') {
+    if (isToolResult(msg)) return false;
+    const text = getUserText(msg);
+    if (!text) return false;
+    if (text.length > MAX_USER_MSG_LENGTH) return false;
+    if (isShellCommand(text)) return false;
+    return true;
+  }
+
+  if (msg.type === 'assistant') {
+    const text = getAssistantText(msg);
+    return text !== null && text.length > 0;
+  }
+
+  return false;
+}
+
+function buildToolResultMeta(messages) {
+  const meta = {};
+  const toolUseInfo = {};
+
+  // First pass: collect tool_use timestamps, model, agent info, and Task details
+  for (const msg of messages) {
+    if (msg.type === 'assistant' && msg.message?.content && Array.isArray(msg.message.content)) {
+      const model = msg.message?.model || null;
+      const agentId = msg.isSidechain ? msg.agentId : null;
+      for (const block of msg.message.content) {
+        if (block.type === 'tool_use' && block.id) {
+          const info = {
+            timestamp: msg.timestamp ? new Date(msg.timestamp).getTime() : null,
+            model: model,
+            agentId: agentId
+          };
+          // Capture Task tool details
+          if (block.name === 'Task' && block.input) {
+            info.taskDescription = block.input.description || null;
+            info.taskPrompt = block.input.prompt || null;
+          }
+          toolUseInfo[block.id] = info;
+        }
+      }
+    }
+  }
+
+  // Second pass: collect tool_result sizes and calculate duration
+  for (const msg of messages) {
+    if (msg.type === 'user' && msg.message?.content && Array.isArray(msg.message.content)) {
+      for (const block of msg.message.content) {
+        if (block.type === 'tool_result' && block.tool_use_id) {
+          const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+          const resultTs = msg.timestamp ? new Date(msg.timestamp).getTime() : null;
+          const info = toolUseInfo[block.tool_use_id] || {};
+          const durationMs = (resultTs && info.timestamp) ? resultTs - info.timestamp : null;
+
+          const metaEntry = {
+            size: content?.length || 0,
+            durationMs: durationMs,
+            model: info.model,
+            agentId: info.agentId,
+            taskDescription: info.taskDescription,
+            taskPrompt: info.taskPrompt
+          };
+
+          // Parse Task tool result for agentId and output_file
+          if (info.taskDescription && content) {
+            const agentMatch = content.match(/agentId:\s*(\w+)/);
+            const outputMatch = content.match(/output_file:\s*([^\n]+)/);
+            if (agentMatch) metaEntry.taskAgentId = agentMatch[1];
+            if (outputMatch) metaEntry.taskOutputFile = outputMatch[1].trim();
+          }
+
+          meta[block.tool_use_id] = metaEntry;
+        }
+      }
+    }
+  }
+  return meta;
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function formatDuration(ms) {
+  if (ms === null || ms === undefined) return '';
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function shortModelName(model) {
+  if (!model) return '';
+  if (model.includes('opus')) return 'opus';
+  if (model.includes('sonnet')) return 'sonnet';
+  if (model.includes('haiku')) return 'haiku';
+  if (model.includes('gemini')) return 'gemini';
+  return model.substring(0, 10);
+}
+
+function collapseToolCall(msg, resultMeta = {}) {
+  if (msg.type !== 'assistant') return null;
+  if (!msg.message?.content || !Array.isArray(msg.message.content)) return null;
+
+  const toolUses = msg.message.content.filter(c => c.type === 'tool_use');
+  if (toolUses.length === 0) return null;
+
+  return toolUses.map(t => {
+    const name = t.name;
+    const input = t.input || {};
+    const shortId = t.id ? t.id.substring(5, 17) : '';
+    const meta = resultMeta[t.id] || {};
+    const size = meta.size !== undefined ? formatSize(meta.size) : '';
+    const duration = meta.durationMs ? formatDuration(meta.durationMs) : '';
+    const model = meta.model ? shortModelName(meta.model) : '';
+    const agent = meta.agentId ? `@${meta.agentId}` : '';
+    const suffix = size || duration || model || agent ? ` (${[model, size, duration, agent].filter(Boolean).join(', ')})` : '';
+
+    if (name === 'Task') {
+      const desc = meta.taskDescription || input.description || 'task';
+      const taskAgent = meta.taskAgentId ? `@${meta.taskAgentId}` : '';
+      const taskOutput = meta.taskOutputFile || '';
+      const taskInfo = [taskAgent, taskOutput].filter(Boolean).join(' → ');
+      const taskSuffix = [model, size, duration, taskInfo].filter(Boolean).join(', ');
+      return `[${shortId} Task: ${desc}] (${taskSuffix})`;
+    } else if (name === 'Read') {
+      return `[${shortId} Read: ${input.file_path}]${suffix}`;
+    } else if (name === 'Bash') {
+      const cmd = input.command?.substring(0, 60) || 'command';
+      return `[${shortId} Ran: ${cmd}${input.command?.length > 60 ? '...' : ''}]${suffix}`;
+    } else if (name === 'Write') {
+      return `[${shortId} Write: ${input.file_path}]${suffix}`;
+    } else if (name === 'Edit') {
+      return `[${shortId} Edit: ${input.file_path}]${suffix}`;
+    } else if (name === 'Glob') {
+      return `[${shortId} Glob: ${input.pattern}]${suffix}`;
+    } else if (name === 'Grep') {
+      return `[${shortId} Grep: ${input.pattern}]${suffix}`;
+    } else {
+      return `[${shortId} ${name}]${suffix}`;
+    }
+  }).join(' ');
+}
+
+// ========== COMMANDS ==========
+
+function cmdParse(jsonlPath, opts) {
+  const messages = readJsonl(jsonlPath);
+  const discourse = messages.filter(isDiscourse);
+
+  // Calculate totals for dry-run
+  let totalChars = 0;
+  const contents = discourse.map(msg => {
+    const text = msg.type === 'user' ? getUserText(msg) : getAssistantText(msg);
+    totalChars += (text?.length || 0);
+    return { msg, text };
+  });
+
+  if (opts.dryRun) {
+    const userCount = discourse.filter(m => m.type === 'user').length;
+    const assistantCount = discourse.filter(m => m.type === 'assistant').length;
+    console.log(`--- DRY RUN: parse ---`);
+    console.log(`Messages: ${discourse.length} (${userCount} user, ${assistantCount} assistant)`);
+    console.log(`Characters: ${totalChars.toLocaleString()}`);
+    console.log(`Estimated tokens: ~${estimateTokens({length: totalChars}).toLocaleString()}`);
+    console.log(`Filtered out: ${messages.length - discourse.length} noise messages`);
+    return;
+  }
+
+  if (opts.format === 'text') {
+    contents.forEach(({ msg, text }) => {
+      const role = msg.type === 'user' ? 'USER' : 'ASSISTANT';
+      const ts = msg.timestamp ? new Date(msg.timestamp).toISOString().substring(11, 19) : '';
+      console.log(`[${ts}] ${role}: ${text?.substring(0, 150)}${text?.length > 150 ? '...' : ''}`);
+    });
+  } else {
+    contents.forEach(({ msg, text }) => {
+      const output = {
+        type: msg.type,
+        timestamp: msg.timestamp,
+        content: text
+      };
+      console.log(JSON.stringify(output));
+    });
+  }
+
+  if (opts.stats) {
+    const userCount = discourse.filter(m => m.type === 'user').length;
+    const assistantCount = discourse.filter(m => m.type === 'assistant').length;
+    console.error(`\n--- Stats ---`);
+    console.error(`Total discourse: ${discourse.length} (${userCount} user, ${assistantCount} assistant)`);
+    console.error(`Filtered out: ${messages.length - discourse.length} noise messages`);
+    console.error(`Estimated tokens: ~${estimateTokens({length: totalChars}).toLocaleString()}`);
+  }
+}
+
+function cmdHot(jsonlPath, opts) {
+  const messages = readJsonl(jsonlPath);
+  const discourse = messages.filter(isDiscourse);
+  const lastN = parseInt(opts.last) || 30;
+
+  const hot = discourse.slice(-lastN);
+
+  const exchanges = hot.map(msg => {
+    const text = msg.type === 'user' ? getUserText(msg) : getAssistantText(msg);
+    return {
+      ts: msg.timestamp,
+      role: msg.type === 'user' ? 'user' : 'assistant',
+      content: text,
+      marker: detectMarker(text)
+    };
+  });
+
+  const totalChars = exchanges.reduce((sum, e) => sum + (e.content?.length || 0), 0);
+
+  if (opts.dryRun) {
+    const userCount = exchanges.filter(e => e.role === 'user').length;
+    const assistantCount = exchanges.filter(e => e.role === 'assistant').length;
+    const markedCount = exchanges.filter(e => e.marker).length;
+    console.log(`--- DRY RUN: hot --last ${lastN} ---`);
+    console.log(`Exchanges: ${exchanges.length} (${userCount} user, ${assistantCount} assistant)`);
+    console.log(`Marked moments: ${markedCount}`);
+    console.log(`Characters: ${totalChars.toLocaleString()}`);
+    console.log(`Estimated tokens: ~${estimateTokens({length: totalChars}).toLocaleString()}`);
+    console.log(`Available discourse: ${discourse.length} total`);
+    return;
+  }
+
+  const insights = exchanges.filter(e => e.marker === 'aha_moment' || e.marker === 'strong_opinion');
+  const lastInsight = insights.length > 0 ? insights[insights.length - 1].content : null;
+
+  const output = {
+    source: path.resolve(jsonlPath),
+    extracted: new Date().toISOString(),
+    message_count: exchanges.length,
+    thread: 'extracted from ' + path.basename(jsonlPath),
+    last_insight: lastInsight?.substring(0, 200) || 'none detected',
+    momentum: exchanges.length > 20 ? 'high' : exchanges.length > 10 ? 'medium' : 'low',
+    exchanges
+  };
+
+  console.log(JSON.stringify(output, null, 2));
+}
+
+function getToolResultText(msg) {
+  if (!msg.message?.content || !Array.isArray(msg.message.content)) return null;
+  const result = msg.message.content.find(c => c.type === 'tool_result');
+  if (!result) return null;
+  return typeof result.content === 'string' ? result.content : JSON.stringify(result.content);
+}
+
+function cmdRinse(inputPath, opts) {
+  // Check if input is a directory or file
+  const stat = fs.statSync(inputPath);
+  const isDir = stat.isDirectory();
+
+  let allMessages = [];
+  if (isDir) {
+    const jsonlFiles = fs.readdirSync(inputPath).filter(f => f.endsWith('.jsonl'));
+    // Sort by modification time to get chronological order
+    const filesWithStats = jsonlFiles.map(f => {
+      const filePath = path.join(inputPath, f);
+      const msgs = readJsonl(filePath);
+      const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+      const firstTs = timestamps.length > 0 ? Math.min(...timestamps) : 0;
+      return { filePath, msgs, firstTs };
+    });
+    filesWithStats.sort((a, b) => a.firstTs - b.firstTs);
+    for (const f of filesWithStats) {
+      allMessages.push(...f.msgs);
+    }
+  } else {
+    allMessages = readJsonl(inputPath);
+  }
+
+  const messages = allMessages;
+  const collapseTools = opts.collapseTools;
+  const mild = opts.mild;
+  const truncateLen = mild ? 200 : 500;
+
+  const output = [];
+
+  for (const msg of messages) {
+    if (NOISE_TYPES.includes(msg.type)) continue;
+
+    if (msg.type === 'user') {
+      // Tool results handling
+      if (isToolResult(msg)) {
+        if (mild) {
+          // Mild: keep tool results but truncated
+          const resultText = getToolResultText(msg);
+          if (resultText) {
+            output.push({
+              role: 'tool_result',
+              ts: msg.timestamp,
+              content: resultText.substring(0, truncateLen) + (resultText.length > truncateLen ? '...' : '')
+            });
+          }
+        }
+        // Otherwise (collapse mode): skip entirely
+        continue;
+      }
+
+      const text = getUserText(msg);
+      if (text) {
+        output.push({
+          role: 'user',
+          ts: msg.timestamp,
+          content: text.substring(0, 500)
+        });
+      }
+    } else if (msg.type === 'assistant') {
+      const text = getAssistantText(msg);
+      const toolSummary = collapseTools ? collapseToolCall(msg) : null;
+
+      if (text) {
+        output.push({
+          role: 'assistant',
+          ts: msg.timestamp,
+          content: text.substring(0, truncateLen)
+        });
+      } else if (toolSummary && (collapseTools || mild)) {
+        output.push({
+          role: 'assistant',
+          ts: msg.timestamp,
+          content: toolSummary
+        });
+      }
+    }
+  }
+
+  const totalChars = output.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+
+  if (opts.dryRun) {
+    const userCount = output.filter(m => m.role === 'user').length;
+    const assistantCount = output.filter(m => m.role === 'assistant').length;
+    const toolResultCount = output.filter(m => m.role === 'tool_result').length;
+    const mode = mild ? '--logistics' : (collapseTools ? '--gotime' : '');
+    console.log(`--- DRY RUN: rinse${mode ? ' ' + mode : ''} ---`);
+
+    if (isDir) {
+      const jsonlFiles = fs.readdirSync(inputPath).filter(f => f.endsWith('.jsonl'));
+      const filesWithStats = jsonlFiles.map(f => {
+        const filePath = path.join(inputPath, f);
+        const msgs = readJsonl(filePath);
+        const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+        const firstTs = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : null;
+        return { file: f, filePath, msgs, firstTs, raw: msgs.length };
+      });
+      filesWithStats.sort((a, b) => (a.firstTs || 0) - (b.firstTs || 0));
+
+      console.log(`Source: ${inputPath}`);
+      console.log(``);
+      console.log(`SESSIONS TO MERGE:`);
+      console.log(`#  DATE        TIME      RAW  FILE`);
+      console.log(`────────────────────────────────────────────────────────────────────`);
+      filesWithStats.forEach((s, i) => {
+        const date = s.firstTs ? s.firstTs.toISOString().substring(0, 10) : 'unknown';
+        const time = s.firstTs ? s.firstTs.toISOString().substring(11, 16) : '??:??';
+        const fileName = s.file.replace('.jsonl', '');
+        console.log(`${String(i + 1).padStart(2)}  ${date}  ${time}    ${String(s.raw).padStart(4)}  ${fileName}`);
+      });
+      console.log(`────────────────────────────────────────────────────────────────────`);
+    } else {
+      console.log(`Source: ${path.basename(inputPath)}`);
+    }
+
+    const tokens = estimateTokens({length: totalChars});
+    console.log(``);
+    console.log(`OUTPUT:`);
+    console.log(`Messages: ${output.length} (${userCount} user, ${assistantCount} assistant${toolResultCount ? ', ' + toolResultCount + ' tool_result' : ''})`);
+    console.log(`Characters: ${totalChars.toLocaleString()}`);
+    console.log(`Estimated tokens: ~${tokens.toLocaleString()}`);
+    console.log(`Compression: ${messages.length} → ${output.length} (${Math.round((1 - output.length/messages.length) * 100)}% reduction)`);
+    return;
+  }
+
+  // Check token limit before outputting (only for directories)
+  const TOKEN_LIMIT = 50000;
+  const tokens = estimateTokens({length: totalChars});
+  if (isDir && tokens > TOKEN_LIMIT && !opts.yolo) {
+    console.error(`\n⚠️  HOLD UP: ${tokens.toLocaleString()} tokens exceeds safe limit (${TOKEN_LIMIT.toLocaleString()})`);
+    console.error(`   This will eat most of your context window.`);
+    console.error(`\n   To proceed anyway: --yolo`);
+    console.error(`   Or pick specific sessions instead of entire folder.`);
+    process.exit(1);
+  }
+
+  if (opts.format === 'text') {
+    output.forEach(m => {
+      const ts = m.ts ? new Date(m.ts).toISOString().substring(11, 19) : '';
+      console.log(`[${ts}] ${m.role.toUpperCase()}: ${m.content}`);
+    });
+  } else {
+    output.forEach(m => console.log(JSON.stringify(m)));
+  }
+
+  console.error(`\n--- Rinsed ${messages.length} → ${output.length} messages (${estimateTokens({length: totalChars}).toLocaleString()} tokens) ---`);
+}
+
+function cmdState(jsonlPath) {
+  const messages = readJsonl(jsonlPath);
+  const discourse = messages.filter(isDiscourse);
+
+  const typeCounts = {};
+  messages.forEach(m => {
+    typeCounts[m.type] = (typeCounts[m.type] || 0) + 1;
+  });
+
+  const markerCounts = { aha_moment: 0, pushback: 0, strong_opinion: 0, clarification: 0, decision: 0 };
+  discourse.forEach(msg => {
+    const text = msg.type === 'user' ? getUserText(msg) : getAssistantText(msg);
+    const marker = detectMarker(text);
+    if (marker) markerCounts[marker]++;
+  });
+
+  const timestamps = messages.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+  const firstTs = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : null;
+  const lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : null;
+
+  console.log(`Source: ${path.resolve(jsonlPath)}`);
+  console.log(`Total messages: ${messages.length}`);
+  console.log(`\nBy type:`);
+  Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).forEach(([type, count]) => {
+    console.log(`  ${type}: ${count}`);
+  });
+
+  console.log(`\nFiltered discourse: ${discourse.length} messages`);
+  console.log(`  user: ${discourse.filter(m => m.type === 'user').length}`);
+  console.log(`  assistant: ${discourse.filter(m => m.type === 'assistant').length}`);
+
+  console.log(`\nDetected markers:`);
+  Object.entries(markerCounts).forEach(([marker, count]) => {
+    if (count > 0) console.log(`  ${marker}: ${count}`);
+  });
+
+  if (firstTs && lastTs) {
+    console.log(`\nTime range:`);
+    console.log(`  First: ${firstTs.toISOString()}`);
+    console.log(`  Last:  ${lastTs.toISOString()}`);
+    const durationMs = lastTs - firstTs;
+    const hours = Math.floor(durationMs / 3600000);
+    const mins = Math.floor((durationMs % 3600000) / 60000);
+    console.log(`  Duration: ${hours}h ${mins}m`);
+  }
+}
+
+function extractToolCalls(messages) {
+  const toolCalls = [];
+  const toolResults = {};
+
+  for (const msg of messages) {
+    // Extract tool_use from assistant messages
+    if (msg.type === 'assistant' && msg.message?.content) {
+      const content = msg.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'tool_use') {
+            toolCalls.push({
+              id: block.id,
+              name: block.name,
+              input: block.input,
+              timestamp: msg.timestamp
+            });
+          }
+        }
+      }
+    }
+
+    // Extract tool_result from user messages
+    if (msg.type === 'user' && msg.message?.content) {
+      const content = msg.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'tool_result' && block.tool_use_id) {
+            toolResults[block.tool_use_id] = block.content;
+          }
+        }
+      }
+    }
+  }
+
+  // Attach results to calls
+  for (const call of toolCalls) {
+    call.result = toolResults[call.id] || null;
+  }
+
+  return toolCalls;
+}
+
+function cmdTools(opts) {
+  const dir = cwdToProjectFolder();
+  if (!dir) {
+    console.error(`No project folder found for CWD: ${process.cwd()}`);
+    process.exit(1);
+  }
+
+  // Get most recent session
+  const jsonlFiles = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+  if (jsonlFiles.length === 0) {
+    console.error('No sessions found');
+    process.exit(1);
+  }
+
+  // Sort by modification time to get most recent
+  const filesWithStats = jsonlFiles.map(f => {
+    const filePath = path.join(dir, f);
+    const msgs = readJsonl(filePath);
+    const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+    const lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : new Date(0);
+    return { filePath, msgs, lastTs };
+  });
+  filesWithStats.sort((a, b) => b.lastTs - a.lastTs);
+
+  // Exclude currently active sessions
+  const now = Date.now();
+  const inactiveSessions = filesWithStats.filter(s => {
+    const ageMs = now - s.lastTs.getTime();
+    return ageMs > ACTIVE_SESSION_THRESHOLD_MS;
+  });
+
+  if (inactiveSessions.length === 0) {
+    console.error('No inactive sessions found (only the current session exists)');
+    process.exit(1);
+  }
+
+  const session = inactiveSessions[0];
+  const toolCalls = extractToolCalls(session.msgs);
+
+  // If --show flag, find and display specific tool result
+  if (opts.show) {
+    const searchId = opts.show;
+    const match = toolCalls.find(t => t.id.includes(searchId));
+    if (!match) {
+      console.error(`No tool call found matching: ${searchId}`);
+      console.error(`\nAvailable IDs (showing last 10):`);
+      toolCalls.slice(-10).forEach(t => {
+        console.error(`  ${t.id.substring(5, 17)} - ${t.name}`);
+      });
+      process.exit(1);
+    }
+
+    console.log(`=== TOOL RESULT: ${match.id} ===`);
+    console.log(`Tool: ${match.name}`);
+    console.log(`Time: ${match.timestamp ? new Date(match.timestamp).toISOString().substring(11, 19) : 'unknown'}`);
+    if (match.input) {
+      if (match.name === 'Bash') {
+        console.log(`Command: ${match.input.command?.substring(0, 100)}${match.input.command?.length > 100 ? '...' : ''}`);
+      } else if (match.name === 'Read') {
+        console.log(`File: ${match.input.file_path}`);
+      } else if (match.name === 'Edit' || match.name === 'Write') {
+        console.log(`File: ${match.input.file_path}`);
+      }
+    }
+    console.log(`\n--- RESULT ---`);
+    if (match.result) {
+      console.log(typeof match.result === 'string' ? match.result : JSON.stringify(match.result, null, 2));
+    } else {
+      console.log('(no result captured)');
+    }
+    return;
+  }
+
+  // List all tool calls
+  console.log(`=== TOOL CALLS (${toolCalls.length} total) ===`);
+  console.log(`Session: ${path.basename(session.filePath)}`);
+  console.log(``);
+  console.log(`#    ID            TIME      TOOL     SUMMARY`);
+  console.log(`───────────────────────────────────────────────────────────────────────────`);
+
+  toolCalls.forEach((t, i) => {
+    const shortId = t.id.substring(5, 17);
+    const ts = t.timestamp ? new Date(t.timestamp).toISOString().substring(11, 19) : '??:??:??';
+    let summary = '';
+
+    if (t.name === 'Bash') {
+      summary = t.input?.command?.substring(0, 40) || '';
+    } else if (t.name === 'Read') {
+      summary = t.input?.file_path?.split('/').pop() || '';
+    } else if (t.name === 'Edit' || t.name === 'Write') {
+      summary = t.input?.file_path?.split('/').pop() || '';
+    } else if (t.name === 'Grep') {
+      summary = t.input?.pattern || '';
+    } else if (t.name === 'Glob') {
+      summary = t.input?.pattern || '';
+    }
+
+    const num = String(i + 1).padStart(3);
+    const name = t.name.padEnd(8);
+    console.log(`${num}  ${shortId}  ${ts}  ${name} ${summary}`);
+  });
+
+  console.log(``);
+  const exampleId = toolCalls.length > 0 ? toolCalls[0].id.substring(5, 17) : '<id>';
+  console.log(`Use: session-recall tools --show ${exampleId} to see specific result`);
+}
+
+function cmdCheckpoints(opts) {
+  const dir = cwdToProjectFolder();
+  if (!dir) {
+    console.error(`No project folder found for CWD: ${process.cwd()}`);
+    process.exit(1);
+  }
+
+  const jsonlFiles = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+  if (jsonlFiles.length === 0) {
+    console.error('No sessions found');
+    process.exit(1);
+  }
+
+  // Collect all checkpoints from all sessions
+  const checkpoints = [];
+
+  for (const file of jsonlFiles) {
+    const filePath = path.join(dir, file);
+    const msgs = readJsonl(filePath);
+
+    for (const msg of msgs) {
+      // Look for Bash tool calls with session-recall --checkpoint
+      if (msg.type === 'assistant' && msg.message?.content && Array.isArray(msg.message.content)) {
+        for (const block of msg.message.content) {
+          if (block.type === 'tool_use' && block.name === 'Bash') {
+            const cmd = block.input?.command || '';
+            const match = cmd.match(/session-recall\s+--checkpoint\s+["']?([^"'\n]+)["']?/);
+            if (match) {
+              checkpoints.push({
+                name: match[1].trim(),
+                timestamp: msg.timestamp,
+                toolId: block.id,
+                session: file
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (checkpoints.length === 0) {
+    console.log('No checkpoints found.');
+    console.log('Create one with: session-recall --checkpoint "description"');
+    return;
+  }
+
+  // Sort by timestamp
+  checkpoints.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+
+  console.log(`=== CHECKPOINTS (${checkpoints.length} total) ===`);
+  console.log(``);
+  console.log(`#   TIME      ID            NAME`);
+  console.log(`────────────────────────────────────────────────────────────────────`);
+
+  checkpoints.forEach((cp, i) => {
+    const ts = cp.timestamp ? new Date(cp.timestamp).toISOString().substring(11, 19) : '??:??:??';
+    const shortId = cp.toolId ? cp.toolId.substring(5, 17) : '????????????';
+    console.log(`${String(i + 1).padStart(2)}  ${ts}  ${shortId}  ${cp.name}`);
+  });
+
+  console.log(``);
+  console.log(`Use: session-recall last 1 --after "checkpoint name" to recall from checkpoint`);
+}
+
+function calcSessionCosts(messages) {
+  // Calculate logistics (mild) output
+  const logisticsOutput = [];
+  for (const msg of messages) {
+    if (NOISE_TYPES.includes(msg.type)) continue;
+    if (msg.type === 'user') {
+      if (isToolResult(msg)) {
+        const resultText = getToolResultText(msg);
+        if (resultText) {
+          logisticsOutput.push({ content: resultText.substring(0, 200) });
+        }
+        continue;
+      }
+      const text = getUserText(msg);
+      if (text) logisticsOutput.push({ content: text.substring(0, 500) });
+    } else if (msg.type === 'assistant') {
+      const text = getAssistantText(msg);
+      const toolSummary = collapseToolCall(msg);
+      if (text) logisticsOutput.push({ content: text.substring(0, 200) });
+      else if (toolSummary) logisticsOutput.push({ content: toolSummary });
+    }
+  }
+  const logisticsChars = logisticsOutput.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+
+  // Calculate gotime (collapse) output
+  const gotimeOutput = [];
+  for (const msg of messages) {
+    if (NOISE_TYPES.includes(msg.type)) continue;
+    if (msg.type === 'user') {
+      if (isToolResult(msg)) continue;
+      const text = getUserText(msg);
+      if (text) gotimeOutput.push({ content: text.substring(0, 500) });
+    } else if (msg.type === 'assistant') {
+      const text = getAssistantText(msg);
+      const toolSummary = collapseToolCall(msg);
+      if (text) gotimeOutput.push({ content: text.substring(0, 500) });
+      else if (toolSummary) gotimeOutput.push({ content: toolSummary });
+    }
+  }
+  const gotimeChars = gotimeOutput.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+
+  // Calculate hot context
+  const discourse = messages.filter(isDiscourse);
+  const hot30 = discourse.slice(-30);
+  const hot50 = discourse.slice(-50);
+  const hot30Chars = hot30.reduce((sum, m) => {
+    const text = m.type === 'user' ? getUserText(m) : getAssistantText(m);
+    return sum + (text?.length || 0);
+  }, 0);
+  const hot50Chars = hot50.reduce((sum, m) => {
+    const text = m.type === 'user' ? getUserText(m) : getAssistantText(m);
+    return sum + (text?.length || 0);
+  }, 0);
+
+  return {
+    raw: messages.length,
+    hot30: { count: hot30.length, tokens: estimateTokens({ length: hot30Chars }) },
+    hot50: { count: hot50.length, tokens: estimateTokens({ length: hot50Chars }) },
+    gotime: { count: gotimeOutput.length, tokens: estimateTokens({ length: gotimeChars }) },
+    logistics: { count: logisticsOutput.length, tokens: estimateTokens({ length: logisticsChars }) }
+  };
+}
+
+function cmdCost(inputPath) {
+  // Check if input is a directory or file
+  const stat = fs.statSync(inputPath);
+  const isDir = stat.isDirectory();
+  const dir = isDir ? inputPath : path.dirname(inputPath);
+  const jsonlFiles = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+
+  if (jsonlFiles.length === 0) {
+    console.error('No .jsonl files found in ' + dir);
+    process.exit(1);
+  }
+
+  // If directory, use first file as "current" for single-session stats
+  const jsonlPath = isDir ? path.join(dir, jsonlFiles[0]) : inputPath;
+  const messages = readJsonl(jsonlPath);
+  const costs = calcSessionCosts(messages);
+
+  // Calculate project totals if multiple sessions or if scanning directory
+  let projectCosts = null;
+  if (jsonlFiles.length > 1 || isDir) {
+    const allMessages = [];
+    for (const file of jsonlFiles) {
+      const filePath = path.join(dir, file);
+      const msgs = readJsonl(filePath);
+      allMessages.push(...msgs);
+    }
+    projectCosts = calcSessionCosts(allMessages);
+    projectCosts.sessionCount = jsonlFiles.length;
+  }
+
+  console.log(`=== IMPORT COST COMPARISON ===`);
+  console.log(`Source: ${isDir ? dir : path.basename(jsonlPath)}`);
+
+  if (!isDir) {
+    console.log(`Raw messages: ${costs.raw}`);
+    console.log(``);
+    console.log(`THIS SESSION:`);
+    console.log(`OPTION              MESSAGES    TOKENS    USE CASE`);
+    console.log(`─────────────────────────────────────────────────────────`);
+    console.log(`hot --last 30       ${String(costs.hot30.count).padStart(4)}        ~${String(costs.hot30.tokens.toLocaleString()).padStart(6)}    Quick continue`);
+    console.log(`hot --last 50       ${String(costs.hot50.count).padStart(4)}        ~${String(costs.hot50.tokens.toLocaleString()).padStart(6)}    More context`);
+    console.log(`rinse --gotime      ${String(costs.gotime.count).padStart(4)}        ~${String(costs.gotime.tokens.toLocaleString()).padStart(6)}    Full session, action mode`);
+    console.log(`rinse --logistics   ${String(costs.logistics.count).padStart(4)}        ~${String(costs.logistics.tokens.toLocaleString()).padStart(6)}    Full session, see what was done`);
+  }
+
+  if (projectCosts) {
+    // Get individual session stats sorted by date
+    const sessionStats = [];
+    for (const file of jsonlFiles) {
+      const filePath = path.join(dir, file);
+      const msgs = readJsonl(filePath);
+      const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+      const firstTs = timestamps.length > 0 ? new Date(Math.min(...timestamps)) : null;
+      const lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : null;
+      const sessCosts = calcSessionCosts(msgs);
+      sessionStats.push({
+        file,
+        filePath,
+        firstTs,
+        lastTs,
+        raw: msgs.length,
+        gotime: sessCosts.gotime.tokens,
+        logistics: sessCosts.logistics.tokens
+      });
+    }
+    // Sort by first timestamp
+    sessionStats.sort((a, b) => (a.firstTs || 0) - (b.firstTs || 0));
+
+    console.log(``);
+    console.log(`ALL SESSIONS IN PROJECT (${projectCosts.sessionCount}):`);
+    console.log(`#  DATE        TIME      RAW   GOTIME  LOGISTICS  FILE`);
+    console.log(`──────────────────────────────────────────────────────────────────────────────`);
+
+    // Split into significant (>500 tokens) and tiny sessions
+    const TINY_THRESHOLD = 500;
+    const significant = sessionStats.filter(s => s.gotime >= TINY_THRESHOLD);
+    const tiny = sessionStats.filter(s => s.gotime < TINY_THRESHOLD);
+
+    significant.forEach((s, i) => {
+      const date = s.firstTs ? s.firstTs.toISOString().substring(0, 10) : 'unknown';
+      const time = s.firstTs ? s.firstTs.toISOString().substring(11, 16) : '??:??';
+      const isCurrent = s.filePath === path.resolve(jsonlPath) ? ' ←' : '';
+      const fileName = s.file.replace('.jsonl', '');
+      console.log(`${String(i + 1).padStart(2)}  ${date}  ${time}    ${String(s.raw).padStart(4)}   ~${String(s.gotime.toLocaleString()).padStart(6)}   ~${String(s.logistics.toLocaleString()).padStart(6)}  ${fileName}${isCurrent}`);
+    });
+
+    if (tiny.length > 0) {
+      const tinyRaw = tiny.reduce((sum, s) => sum + s.raw, 0);
+      const tinyGotime = tiny.reduce((sum, s) => sum + s.gotime, 0);
+      const tinyLogistics = tiny.reduce((sum, s) => sum + s.logistics, 0);
+      console.log(`    ... ${tiny.length} small sessions     ${String(tinyRaw).padStart(4)}   ~${String(tinyGotime.toLocaleString()).padStart(6)}   ~${String(tinyLogistics.toLocaleString()).padStart(6)}`);
+    }
+
+    console.log(`──────────────────────────────────────────────────────────────────────────────`);
+    console.log(`    TOTAL              ${String(projectCosts.raw).padStart(4)}   ~${String(projectCosts.gotime.tokens.toLocaleString()).padStart(6)}   ~${String(projectCosts.logistics.tokens.toLocaleString()).padStart(6)}`);
+  }
+
+  console.log(``);
+  console.log(`Pick your path, then run the command.`);
+}
+
+function cwdToProjectFolder() {
+  // Map CWD to Claude project folder
+  // /home/hung/.skills/scripture-keeper -> -home-hung--skills-scripture-keeper
+  // Both / and . are replaced with -
+  const cwd = process.cwd();
+  const projectName = cwd.replace(/[\/\.]/g, '-');
+  const projectsDir = path.join(process.env.HOME, '.claude', 'projects');
+  const projectPath = path.join(projectsDir, projectName);
+
+  if (fs.existsSync(projectPath)) {
+    return projectPath;
+  }
+  return null;
+}
+
+function cmdLast(arg1, arg2, opts) {
+  // Usage: last [N] [folder]
+  // arg1 could be: undefined, a number string, or a folder path
+  // arg2 could be: undefined, or a folder path (if arg1 was a number)
+  const projectsDir = path.join(process.env.HOME, '.claude', 'projects');
+
+  let n = 1;
+  let dir = null;
+  let filterAfterTs = null;
+
+  // Parse arguments
+  if (arg1) {
+    if (!isNaN(parseInt(arg1))) {
+      // arg1 is a number
+      n = parseInt(arg1);
+      // Check if arg2 is a folder
+      if (arg2 && fs.existsSync(arg2)) {
+        const stat = fs.statSync(arg2);
+        dir = stat.isDirectory() ? arg2 : path.dirname(arg2);
+      }
+    } else if (fs.existsSync(arg1)) {
+      // arg1 is a folder
+      const stat = fs.statSync(arg1);
+      dir = stat.isDirectory() ? arg1 : path.dirname(arg1);
+    }
+  }
+
+  // Default behavior: use CWD project unless --all specified
+  if (!dir && !opts.all) {
+    dir = cwdToProjectFolder();
+    if (!dir) {
+      console.error(`No project folder found for CWD: ${process.cwd()}`);
+      console.error(`Use --all to scan all projects.`);
+      process.exit(1);
+    }
+  }
+
+  // If --after is specified, find the checkpoint in the current project
+  if (opts.after) {
+    if (!dir) {
+      console.error(`--after requires CWD project context (cannot use --all)`);
+      process.exit(1);
+    }
+
+    const jsonlFiles = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    let checkpoint = null;
+
+    for (const file of jsonlFiles) {
+      const filePath = path.join(dir, file);
+      const msgs = readJsonl(filePath);
+
+      for (const msg of msgs) {
+        // Look for Bash tool calls with session-recall --checkpoint
+        if (msg.type === 'assistant' && msg.message?.content && Array.isArray(msg.message.content)) {
+          for (const block of msg.message.content) {
+            if (block.type === 'tool_use' && block.name === 'Bash') {
+              const cmd = block.input?.command || '';
+              const match = cmd.match(/session-recall\s+--checkpoint\s+["']?([^"'\n]+)["']?/);
+              if (match && match[1].trim() === opts.after) {
+                checkpoint = {
+                  name: match[1].trim(),
+                  timestamp: msg.timestamp,
+                  session: file
+                };
+                break;
+              }
+            }
+          }
+        }
+        if (checkpoint) break;
+      }
+      if (checkpoint) break;
+    }
+
+    if (!checkpoint) {
+      console.error(`Checkpoint not found: "${opts.after}"`);
+      console.error(`Available checkpoints:`);
+
+      // List all available checkpoints
+      const checkpoints = [];
+      for (const file of jsonlFiles) {
+        const filePath = path.join(dir, file);
+        const msgs = readJsonl(filePath);
+
+        for (const msg of msgs) {
+          if (msg.type === 'assistant' && msg.message?.content && Array.isArray(msg.message.content)) {
+            for (const block of msg.message.content) {
+              if (block.type === 'tool_use' && block.name === 'Bash') {
+                const cmd = block.input?.command || '';
+                const match = cmd.match(/session-recall\s+--checkpoint\s+["']?([^"'\n]+)["']?/);
+                if (match) {
+                  checkpoints.push({
+                    name: match[1].trim(),
+                    timestamp: msg.timestamp
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if (checkpoints.length === 0) {
+        console.error('  (none)');
+      } else {
+        checkpoints.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+        checkpoints.forEach(cp => {
+          const ts = cp.timestamp ? new Date(cp.timestamp).toISOString().substring(11, 19) : '??:??:??';
+          console.error(`  "${cp.name}" (${ts})`);
+        });
+      }
+      process.exit(1);
+    }
+
+    filterAfterTs = checkpoint.timestamp ? new Date(checkpoint.timestamp).getTime() : null;
+  }
+
+  // Collect all sessions
+  let allSessions = [];
+
+  if (dir) {
+    // Single project folder
+    const jsonlFiles = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+    for (const file of jsonlFiles) {
+      const filePath = path.join(dir, file);
+      const msgs = readJsonl(filePath);
+      const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+      const lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : null;
+      allSessions.push({ filePath, msgs, lastTs, project: path.basename(dir) });
+    }
+  } else {
+    // Scan all projects
+    if (!fs.existsSync(projectsDir)) {
+      console.error('No projects found at ' + projectsDir);
+      process.exit(1);
+    }
+    const projects = fs.readdirSync(projectsDir).filter(p => {
+      const pPath = path.join(projectsDir, p);
+      return fs.statSync(pPath).isDirectory();
+    });
+    for (const proj of projects) {
+      const projPath = path.join(projectsDir, proj);
+      const jsonlFiles = fs.readdirSync(projPath).filter(f => f.endsWith('.jsonl'));
+      for (const file of jsonlFiles) {
+        const filePath = path.join(projPath, file);
+        try {
+          const msgs = readJsonl(filePath);
+          const timestamps = msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
+          const lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : null;
+          allSessions.push({ filePath, msgs, lastTs, project: proj });
+        } catch (e) {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  // Sort by last timestamp descending
+  allSessions.sort((a, b) => (b.lastTs || 0) - (a.lastTs || 0));
+
+  // Exclude currently active sessions (activity within threshold)
+  const now = Date.now();
+  const inactiveSessions = allSessions.filter(s => {
+    if (!s.lastTs) return true; // Include sessions with no timestamp
+    const ageMs = now - s.lastTs.getTime();
+    return ageMs > ACTIVE_SESSION_THRESHOLD_MS;
+  });
+
+  // Take last N from inactive sessions
+  const selected = inactiveSessions.slice(0, n);
+
+  if (selected.length === 0) {
+    console.error('No sessions found');
+    process.exit(1);
+  }
+
+  // Count excluded active sessions for reporting
+  const excludedActive = allSessions.length - inactiveSessions.length;
+
+  if (opts.dryRun) {
+    console.log(`--- DRY RUN: last ${n} ---`);
+    if (excludedActive > 0) {
+      console.log(`(Excluded ${excludedActive} active session${excludedActive > 1 ? 's' : ''} with activity in last ${ACTIVE_SESSION_THRESHOLD_MS / 1000}s)`);
+    }
+    console.log(`\nMOST RECENT SESSIONS:`);
+    console.log(`#  LAST ACTIVE       RAW   PROJECT`);
+    console.log(`────────────────────────────────────────────────────────────────────`);
+    selected.forEach((s, i) => {
+      const ts = s.lastTs ? s.lastTs.toISOString().replace('T', ' ').substring(0, 16) : 'unknown';
+      console.log(`${String(i + 1).padStart(2)}  ${ts}    ${String(s.msgs.length).padStart(4)}   ${s.project}`);
+    });
+
+    // Calculate combined output
+    let allMsgs = selected.flatMap(s => s.msgs);
+    // Apply checkpoint filter if specified
+    if (filterAfterTs) {
+      allMsgs = allMsgs.filter(msg => {
+        const msgTs = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+        return msgTs > filterAfterTs;
+      });
+    }
+    const output = [];
+    for (const msg of allMsgs) {
+      if (NOISE_TYPES.includes(msg.type)) continue;
+      if (msg.type === 'user') {
+        if (isToolResult(msg)) continue;
+        const text = getUserText(msg);
+        if (text) output.push({ content: text.substring(0, 500) });
+      } else if (msg.type === 'assistant') {
+        const text = getAssistantText(msg);
+        const toolSummary = collapseToolCall(msg);
+        if (text) output.push({ content: text.substring(0, 500) });
+        else if (toolSummary) output.push({ content: toolSummary });
+      }
+    }
+    const totalChars = output.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+    console.log(`────────────────────────────────────────────────────────────────────`);
+    console.log(`\nOUTPUT: ${output.length} messages, ~${estimateTokens({length: totalChars}).toLocaleString()} tokens`);
+    return;
+  }
+
+  // Output combined rinse (gotime mode)
+  let allMsgs = selected.flatMap(s => s.msgs);
+  // Sort by timestamp
+  allMsgs.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+
+  // Filter by checkpoint timestamp if --after was specified
+  if (filterAfterTs) {
+    allMsgs = allMsgs.filter(msg => {
+      const msgTs = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+      return msgTs > filterAfterTs;
+    });
+  }
+
+  // Build tool result metadata (size, duration)
+  const resultMeta = buildToolResultMeta(allMsgs);
+
+  for (const msg of allMsgs) {
+    if (NOISE_TYPES.includes(msg.type)) continue;
+    if (msg.type === 'user') {
+      if (isToolResult(msg)) continue;
+      const text = getUserText(msg);
+      if (text) {
+        const ts = msg.timestamp ? new Date(msg.timestamp).toISOString().substring(11, 19) : '';
+        console.log(`[${ts}] USER: ${text.substring(0, 500)}`);
+      }
+    } else if (msg.type === 'assistant') {
+      const text = getAssistantText(msg);
+      const toolSummary = collapseToolCall(msg, resultMeta);
+      const ts = msg.timestamp ? new Date(msg.timestamp).toISOString().substring(11, 19) : '';
+      if (text) {
+        console.log(`[${ts}] ASSISTANT: ${text.substring(0, 500)}`);
+      } else if (toolSummary) {
+        console.log(`[${ts}] ASSISTANT: ${toolSummary}`);
+      }
+    }
+  }
+
+  // Print instructions for Claude
+  console.log(``);
+  console.log(`---`);
+  console.log(`To get a specific tool result: session-recall tools --show <id>`);
+  console.log(`Session file: ${selected[0]?.filePath || 'unknown'}`);
+}
+
+function showHelp() {
+  console.log(`
+session-recall - Extract discourse from Claude conversation JSONL files
+
+USAGE:
+  session-recall <command> <jsonl-path> [options]
+
+COMMANDS:
+  parse <jsonl>              Extract clean discourse, filter noise
+    -f, --format <type>      Output: jsonl (default) or text
+    -s, --stats              Show stats after output
+    -d, --dry-run            Show token estimate without output
+
+  hot <jsonl>                Extract last N meaningful exchanges
+    -l, --last <n>           Number of exchanges (default: 30)
+    -d, --dry-run            Show token estimate without output
+
+  rinse <jsonl|folder>       Compress for import, filter noise
+    --logistics              Keep tool results (truncated) - see what was done
+    --gotime                 Drop tool results - just discourse & decisions
+    --yolo                   Override 50k token safety limit for folders
+    -f, --format <type>      Output: jsonl (default) or text
+    -d, --dry-run            Show token estimate without output
+
+  state <jsonl>              Show what exists, counts, markers
+
+  cost <jsonl|folder>        Compare token costs for logistics vs gotime
+
+  last [N] [folder]          Get last N sessions (default: 1, CWD project only)
+    -a, --all                Scan all projects (not just CWD)
+    -d, --dry-run            Show what would be pulled without output
+
+  tools                      List tool calls in most recent session (CWD project)
+    --show <id>              Show specific tool result by ID (partial match)
+
+  checkpoints                List all checkpoints in current project
+
+  --checkpoint "name"        Create a checkpoint marker (use as standalone flag)
+
+  last [N] --after "name"    Recall from after a checkpoint
+
+EXAMPLES:
+  session-recall last 1 -d                          # Check what's available
+  session-recall last 1 -f text                     # Pull last session
+  session-recall tools                              # List tool calls
+  session-recall tools --show 014opBVN             # Get specific tool result
+
+  # Checkpoints - mark progress, recall from any point
+  session-recall --checkpoint "finished research"   # Create checkpoint
+  session-recall checkpoints                        # List all checkpoints
+  session-recall last 1 --after "finished research" # Recall from checkpoint
+`);
+}
+
+// ========== ARGUMENT PARSING ==========
+
+function parseArgs(args) {
+  const opts = {};
+  const positional = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-f' || arg === '--format') {
+      opts.format = args[++i];
+    } else if (arg === '-s' || arg === '--stats') {
+      opts.stats = true;
+    } else if (arg === '-l' || arg === '--last') {
+      opts.last = args[++i];
+    } else if (arg === '-c' || arg === '--collapse-tools' || arg === '--gotime') {
+      opts.collapseTools = true;
+    } else if (arg === '-m' || arg === '--mild' || arg === '--logistics') {
+      opts.mild = true;
+    } else if (arg === '--yolo') {
+      opts.yolo = true;
+    } else if (arg === '-d' || arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if (arg === '-a' || arg === '--all') {
+      opts.all = true;
+    } else if (arg === '--show') {
+      opts.show = args[++i];
+    } else if (arg === '--checkpoint') {
+      opts.checkpoint = args[++i];
+    } else if (arg === '--after') {
+      opts.after = args[++i];
+    } else if (arg === '-h' || arg === '--help') {
+      opts.help = true;
+    } else if (!arg.startsWith('-')) {
+      positional.push(arg);
+    }
+  }
+
+  return { opts, positional };
+}
+
+// ========== MAIN ==========
+
+const args = process.argv.slice(2);
+const { opts, positional } = parseArgs(args);
+
+// Handle --checkpoint flag first (no-op marker that gets logged)
+if (opts.checkpoint) {
+  console.log(`✓ Checkpoint: ${opts.checkpoint}`);
+  console.log(`  Time: ${new Date().toISOString()}`);
+  console.log(`  Use 'session-recall checkpoints' to list all checkpoints`);
+  process.exit(0);
+}
+
+if (opts.help || positional.length === 0) {
+  showHelp();
+  process.exit(0);
+}
+
+const command = positional[0];
+const jsonlPath = positional[1];
+
+// 'last', 'tools', and 'checkpoints' commands don't require a path
+if (!jsonlPath && command !== 'help' && command !== 'last' && command !== 'tools' && command !== 'checkpoints') {
+  console.error('Error: JSONL path required');
+  showHelp();
+  process.exit(1);
+}
+
+// For 'last' command, the second arg might be a number, not a path
+if (command !== 'last' && jsonlPath && !fs.existsSync(jsonlPath)) {
+  console.error(`Error: File not found: ${jsonlPath}`);
+  process.exit(1);
+}
+
+switch (command) {
+  case 'parse':
+    cmdParse(jsonlPath, opts);
+    break;
+  case 'hot':
+    cmdHot(jsonlPath, opts);
+    break;
+  case 'rinse':
+    cmdRinse(jsonlPath, opts);
+    break;
+  case 'state':
+    cmdState(jsonlPath);
+    break;
+  case 'cost':
+    cmdCost(jsonlPath);
+    break;
+  case 'last':
+    cmdLast(jsonlPath, positional[2], opts);
+    break;
+  case 'tools':
+    cmdTools(opts);
+    break;
+  case 'checkpoints':
+    cmdCheckpoints(opts);
+    break;
+  case 'help':
+    showHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}