tsunami-code 3.3.0 → 3.5.0

package/index.js

@@ -4,14 +4,14 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
-import { agentLoop, quickCompletion, setModel, getModel, tokenStats } from './lib/loop.js';
+import { agentLoop, quickCompletion, setModel, getModel, tokenStats, setTemperature, getTemperature } from './lib/loop.js';
 import { injectServerContext } from './lib/tools.js';
 import { loadSkills, getSkillCommand, createSkill, listSkills } from './lib/skills.js';
 import { isCoordinatorTask, stripCoordinatorPrefix, buildCoordinatorSystemPrompt } from './lib/coordinator.js';
 import { getDueTasks, markDone, cancelTask, listTasks, formatTaskList } from './lib/kairos.js';
 import { buildSystemPrompt } from './lib/prompt.js';
 import { runPreflight, checkServer } from './lib/preflight.js';
-import { setSession, undo, undoStackSize, registerMcpTools } from './lib/tools.js';
+import { setSession, undo, undoStackSize, beginUndoTurn, registerMcpTools, linesChanged } from './lib/tools.js';
 import { connectMcpServers, getMcpToolObjects, getMcpStatus, getMcpConfigPath, disconnectAll as disconnectMcp } from './lib/mcp.js';
 import {
   initSession,
@@ -25,7 +25,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '3.3.0';
+const VERSION = '3.5.0';
 const CONFIG_DIR = join(os.homedir(), '.tsunami-code');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 const DEFAULT_SERVER = 'https://radiometric-reita-amuck.ngrok-free.dev';
@@ -172,6 +172,8 @@ async function run() {
   const cwd = process.cwd();
   let planMode = argv.includes('--plan');
 
+  const sessionStartTime = Date.now();
+
   // Initialize memory systems
   const { sessionId, sessionDir } = initSession(cwd);
   initProjectMemory(cwd);
@@ -456,7 +458,7 @@ async function run() {
 
       // Skills: check if this is a skill command before built-ins
       const skillMatch = getSkillCommand(skills, line);
-      if (skillMatch && !['help','compact','plan','undo','doctor','cost','clear','status','server','model','memory','history','exit','quit','skill-create','skill-list','skills','mcp'].includes(cmd)) {
+      if (skillMatch && !['help','compact','plan','undo','doctor','cost','clear','status','server','model','memory','history','exit','quit','skill-create','skill-list','skills','mcp','copy','btw','rewind','diff','stats','export','effort'].includes(cmd)) {
         // Run the skill prompt as a user message
         const userContent = skillMatch.args
           ? `[Skill: ${skillMatch.skill.name}]\n${skillMatch.prompt}`
@@ -498,6 +500,13 @@ async function run() {
               ['/server <url>',    'Change model server URL'],
               ['/model [name]',    'Show or change active model (default: local)'],
               ['/mcp',             'Show MCP server status and tools'],
+              ['/effort <level>',  'Set reasoning effort: low/medium/high/max'],
+              ['/copy',            'Copy last response to clipboard'],
+              ['/btw <note>',      'Inject a note into conversation without a response'],
+              ['/rewind',          'Remove last user+assistant exchange'],
+              ['/diff',            'Show git diff of session file changes'],
+              ['/stats',           'Session stats: lines, tokens, duration'],
+              ['/export [file]',   'Export conversation to markdown file'],
               ['/history',         'Show recent command history'],
               ['/exit',            'Exit'],
             ];
@@ -518,8 +527,24 @@ async function run() {
           break;
         case 'undo': {
           const restored = undo();
-          if (restored) console.log(green(`  ✓ Restored: ${restored}\n`));
-          else console.log(dim('  Nothing to undo.\n'));
+          if (restored) {
+            if (restored.length === 1) console.log(green(`  ✓ Restored: ${restored[0]}\n`));
+            else console.log(green(`  ✓ Restored ${restored.length} files:\n`) + restored.map(f => dim(`    ${f}`)).join('\n') + '\n');
+          } else {
+            console.log(dim('  Nothing to undo.\n'));
+          }
+          break;
+        }
+        case 'effort': {
+          const level = rest[0]?.toLowerCase();
+          const levels = { low: 0.5, medium: 0.2, high: 0.05, max: 0.0 };
+          if (!level || !levels[level] && levels[level] !== 0) {
+            const cur = getTemperature();
+            console.log(dim(`  Current temperature: ${cur}\n  Usage: /effort <low|medium|high|max>\n`));
+            break;
+          }
+          setTemperature(levels[level]);
+          console.log(green(`  Effort: ${level} (temperature ${levels[level]})\n`));
           break;
         }
         case 'mcp': {
@@ -566,12 +591,20 @@ async function run() {
         }
         case 'cost': {
           const hasReal = tokenStats.requests > 0;
-          console.log(blue('\n  Session Token Usage'));
+          console.log(blue('\n  Session Token Usage\n'));
           if (hasReal) {
-            console.log(dim(`  Input  : ${tokenStats.input.toLocaleString()} tokens (actual)`));
-            console.log(dim(`  Output : ${tokenStats.output.toLocaleString()} tokens (actual)`));
-            console.log(dim(`  Total  : ${(tokenStats.input + tokenStats.output).toLocaleString()} tokens`));
-            console.log(dim(`  Requests: ${tokenStats.requests}`));
+            console.log(dim(`  Input    : ${tokenStats.input.toLocaleString()} tokens`));
+            console.log(dim(`  Output   : ${tokenStats.output.toLocaleString()} tokens`));
+            console.log(dim(`  Total    : ${(tokenStats.input + tokenStats.output).toLocaleString()} tokens`));
+            console.log(dim(`  Requests : ${tokenStats.requests}`));
+            // Per-model breakdown (mirrors cost-tracker.ts formatModelUsage)
+            const models = Object.entries(tokenStats.byModel);
+            if (models.length > 1) {
+              console.log(blue('\n  By model:\n'));
+              for (const [model, usage] of models) {
+                console.log(dim(`  ${model.padEnd(20)} ${usage.input.toLocaleString()} in  ${usage.output.toLocaleString()} out  (${usage.requests} req)`));
+              }
+            }
           } else {
             console.log(dim(`  Input  : ~${_inputTokens.toLocaleString()} (estimated)`));
             console.log(dim(`  Output : ~${_outputTokens.toLocaleString()} (estimated)`));
@@ -580,6 +613,137 @@ async function run() {
           console.log();
           break;
         }
+        case 'copy': {
+          // Copy last assistant response to clipboard — from commands.ts copy command
+          const lastAss = [...messages].reverse().find(m => m.role === 'assistant');
+          if (!lastAss) { console.log(dim('  Nothing to copy.\n')); break; }
+          const text = typeof lastAss.content === 'string' ? lastAss.content : JSON.stringify(lastAss.content);
+          try {
+            const { execSync } = await import('child_process');
+            if (process.platform === 'darwin') {
+              execSync('pbcopy', { input: text, stdio: ['pipe', 'ignore', 'ignore'] });
+            } else if (process.platform === 'win32') {
+              execSync('clip', { input: text, stdio: ['pipe', 'ignore', 'ignore'], shell: true });
+            } else {
+              execSync('xclip -selection clipboard 2>/dev/null || xsel --clipboard --input', { input: text, stdio: ['pipe', 'ignore', 'ignore'], shell: true });
+            }
+            console.log(green(`  ✓ Copied ${text.length.toLocaleString()} chars to clipboard\n`));
+          } catch (e) {
+            console.log(red(`  Copy failed: ${e.message}\n`));
+          }
+          break;
+        }
+        case 'btw': {
+          // Inject a sticky note into conversation without triggering a model turn
+          // From CC's btw command — useful for mid-task context injection
+          const note = rest.join(' ');
+          if (!note) { console.log(red('  Usage: /btw <note>\n')); break; }
+          messages.push({ role: 'user', content: `[btw: ${note}]` });
+          messages.push({ role: 'assistant', content: 'Noted.' });
+          console.log(green('  ✓ Noted.\n'));
+          break;
+        }
+        case 'rewind': {
+          // Remove last user+assistant exchange from context
+          // From CC's rewind command
+          if (messages.length < 2) { console.log(dim('  Nothing to rewind.\n')); break; }
+          // Find last assistant message
+          let lastAssIdx = -1;
+          for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'assistant') { lastAssIdx = i; break; }
+          }
+          if (lastAssIdx === -1) { console.log(dim('  Nothing to rewind.\n')); break; }
+          // Find the user message that preceded it
+          let lastUserIdx = lastAssIdx;
+          for (let i = lastAssIdx - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') { lastUserIdx = i; break; }
+          }
+          const removed = messages.splice(lastUserIdx).length;
+          console.log(green(`  ✓ Rewound ${removed} message(s). Context: ${messages.length} messages.\n`));
+          break;
+        }
+        case 'diff': {
+          // Show git diff of file changes made this session
+          // From CC's diff command
+          try {
+            const { execSync: _exec } = await import('child_process');
+            const statArgs = rest.includes('--full') ? '' : '--stat';
+            let diffOut = '';
+            try {
+              diffOut = _exec(`git diff HEAD ${statArgs}`, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            } catch {
+              diffOut = _exec(`git diff ${statArgs}`, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            }
+            if (!diffOut.trim()) {
+              console.log(dim('  No changes detected. (Use git add to stage new files.)\n'));
+            } else {
+              console.log(blue('\n  Session diff:\n'));
+              console.log(dim(diffOut.trim().split('\n').map(l => '  ' + l).join('\n')));
+              if (statArgs === '--stat') console.log(dim('\n  Tip: /diff --full for full patch\n'));
+              else console.log();
+            }
+          } catch (e) {
+            console.log(dim(`  No git repository or no changes. (${e.message.slice(0, 60)})\n`));
+          }
+          break;
+        }
+        case 'stats': {
+          // Session statistics — mirrors cost-tracker.ts formatTotalCost pattern
+          const elapsed = Date.now() - sessionStartTime;
+          const mins = Math.floor(elapsed / 60000);
+          const secs = Math.floor((elapsed % 60000) / 1000);
+          const durationStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+          const totalTok = tokenStats.input + tokenStats.output;
+          console.log(blue('\n  Session Stats\n'));
+          console.log(dim(`  Duration         ${durationStr}`));
+          console.log(dim(`  Requests         ${tokenStats.requests}`));
+          console.log(dim(`  Input tokens     ${tokenStats.input.toLocaleString()}`));
+          console.log(dim(`  Output tokens    ${tokenStats.output.toLocaleString()}`));
+          console.log(dim(`  Total tokens     ${totalTok.toLocaleString()}`));
+          console.log(dim(`  Lines added      ${linesChanged.added}`));
+          console.log(dim(`  Lines removed    ${linesChanged.removed}`));
+          console.log(dim(`  Messages         ${messages.length}`));
+          const models = Object.entries(tokenStats.byModel);
+          if (models.length > 1) {
+            console.log(blue('\n  By model:\n'));
+            for (const [model, usage] of models) {
+              console.log(dim(`  ${model.padEnd(20)} ${usage.input.toLocaleString()} in  ${usage.output.toLocaleString()} out`));
+            }
+          }
+          console.log();
+          break;
+        }
+        case 'export': {
+          // Export full conversation to a markdown file
+          // From CC's export command
+          const filename = rest[0] || `tsunami-session-${new Date().toISOString().slice(0,19).replace(/:/g,'-')}.md`;
+          const exportPath = filename.startsWith('/') || filename.startsWith('D:') || filename.startsWith('C:') ? filename : join(cwd, filename);
+          const lines = [
+            `# Tsunami Code Session`,
+            ``,
+            `**Date:** ${new Date().toISOString()}`,
+            `**Directory:** ${cwd}`,
+            `**Messages:** ${messages.length}`,
+            `**Tokens:** ${(tokenStats.input + tokenStats.output).toLocaleString()}`,
+            ``,
+            `---`,
+            ``
+          ];
+          for (const msg of messages) {
+            if (msg.role === 'system') continue;
+            const roleLabel = msg.role === 'user' ? '### User' : '### Assistant';
+            const text = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content, null, 2);
+            lines.push(roleLabel, '', text, '', '---', '');
+          }
+          try {
+            const { writeFileSync: _wfs } = await import('fs');
+            _wfs(exportPath, lines.join('\n'), 'utf8');
+            console.log(green(`  ✓ Exported to: ${exportPath}\n`));
+          } catch (e) {
+            console.log(red(`  Export failed: ${e.message}\n`));
+          }
+          break;
+        }
         case 'clear':
           resetSession();
           console.log(green('  Session cleared.\n'));
@@ -682,6 +846,9 @@ async function run() {
     isProcessing = true;
     process.stdout.write('\n');
 
+    // Open a new undo turn — all Write/Edit calls during this turn grouped together
+    beginUndoTurn();
+
     let firstToken = true;
     try {
       await agentLoop(
@@ -716,6 +883,11 @@ async function run() {
         console.log(dim('  ↯ Auto-compacted\n'));
       }
 
+      // getDynamicSkills — reload if model created/modified skill files this turn
+      // From CC's getDynamicSkills pattern in commands.ts
+      const newSkills = loadSkills(cwd);
+      if (newSkills.length !== skills.length) skills = newSkills;
+
       process.stdout.write('\n\n');
     } catch (e) {
       process.stdout.write('\n');
@@ -735,9 +907,18 @@ async function run() {
     if (!isProcessing) {
       gracefulExit(0);
     } else {
-      // If processing, mark pending and let the loop finish
+      // Remove interrupted command from history (from history.ts removeLastFromHistory)
+      try {
+        if (existsSync(HISTORY_FILE)) {
+          const lines = readFileSync(HISTORY_FILE, 'utf8').trimEnd().split('\n').filter(Boolean);
+          if (lines.length > 0) lines.pop();
+          import('fs').then(({ writeFileSync: wfs }) => {
+            try { wfs(HISTORY_FILE, lines.join('\n') + (lines.length ? '\n' : ''), 'utf8'); } catch {}
+          });
+        }
+      } catch {}
       pendingClose = true;
-      console.log(dim('\n  (finishing current operation...)\n'));
+      console.log(dim('\n  (interrupted)\n'));
     }
   });
 }

package/lib/loop.js

@@ -44,13 +44,26 @@ function isDangerous(cmd) {
 let _serverVerified = false;
 
 // Real token tracking from API responses
-export const tokenStats = { input: 0, output: 0, requests: 0 };
+// byModel mirrors cost-tracker.ts per-model usage accumulation
+export const tokenStats = { input: 0, output: 0, requests: 0, byModel: {} };
+
+// Token warning thresholds from query.ts calculateTokenWarningState
+const TOKEN_WARN_LEVELS = [
+  { pct: 0.95, label: '⚠ Context critical — run /compact now', urgent: true },
+  { pct: 0.85, label: '⚠ Context high', urgent: true },
+  { pct: 0.70, label: '◦ Context at', urgent: false },
+];
 
 // Current model identifier — changeable at runtime via /model command
 let _currentModel = 'local';
 export function setModel(model) { _currentModel = model; }
 export function getModel() { return _currentModel; }
 
+// Temperature — changeable via /effort command
+let _temperature = 0.1;
+export function setTemperature(t) { _temperature = Math.max(0, Math.min(1, t)); }
+export function getTemperature() { return _temperature; }
+
 // Parse tool calls from any format the model might produce
 function parseToolCalls(content) {
   const calls = [];
@@ -224,13 +237,22 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
       model: _currentModel,
       messages: finalMessages,
       stream: true,
-      temperature: 0.1,
+      temperature: _temperature,
       max_tokens: 4096,
       stop: ['</tool_call>\n\nContinue']
     })
   });
 
-  if (!res.ok) throw new Error(`Model server: ${res.status} ${await res.text()}`);
+  if (!res.ok) {
+    const errText = await res.text();
+    // PROMPT_TOO_LONG detection — mirrors query.ts isPromptTooLongMessage
+    if (res.status === 400 || errText.toLowerCase().includes('context') || errText.toLowerCase().includes('too long') || errText.toLowerCase().includes('tokens')) {
+      const e = new Error(`Model server: ${res.status} ${errText}`);
+      e.isPromptTooLong = true;
+      throw e;
+    }
+    throw new Error(`Model server: ${res.status} ${errText}`);
+  }
 
   let fullContent = '';
   let buffer = '';
@@ -253,10 +275,18 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
       }
       // Capture real token counts + finish reason
       if (parsed.usage) {
-        tokenStats.input += parsed.usage.prompt_tokens || 0;
-        tokenStats.output += parsed.usage.completion_tokens || 0;
+        const pt = parsed.usage.prompt_tokens || 0;
+        const ct = parsed.usage.completion_tokens || 0;
+        tokenStats.input += pt;
+        tokenStats.output += ct;
         tokenStats.requests++;
-        tokenStats.lastPromptTokens = parsed.usage.prompt_tokens || 0;
+        tokenStats.lastPromptTokens = pt;
+        // Per-model accumulation
+        const m = _currentModel;
+        if (!tokenStats.byModel[m]) tokenStats.byModel[m] = { input: 0, output: 0, requests: 0 };
+        tokenStats.byModel[m].input += pt;
+        tokenStats.byModel[m].output += ct;
+        tokenStats.byModel[m].requests++;
       }
       if (parsed.choices?.[0]?.finish_reason) {
         tokenStats.lastFinishReason = parsed.choices[0].finish_reason;
@@ -352,7 +382,34 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
       tokenStats.lastPromptTokens = 0;
     }
 
-    const content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
+    let content;
+    try {
+      content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
+    } catch (e) {
+      // PROMPT_TOO_LONG recovery — compact and retry once
+      if (e.isPromptTooLong && messages.length > 4) {
+        onToken('\n[context too long — auto-compacting and retrying]\n');
+        const sys = messages[0];
+        const tail = messages.slice(-3);
+        messages.length = 0;
+        messages.push(sys, ...tail);
+        content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
+      } else {
+        throw e;
+      }
+    }
+
+    // Token warning thresholds (from query.ts calculateTokenWarningState)
+    if (tokenStats.lastPromptTokens > 0) {
+      const pct = tokenStats.lastPromptTokens / CONTEXT_WINDOW;
+      for (const level of TOKEN_WARN_LEVELS) {
+        if (pct >= level.pct) {
+          onToken(`\n[${level.label}${level.urgent ? '' : ` ${Math.round(pct * 100)}%`}]\n`);
+          break;
+        }
+      }
+    }
+
     const toolCalls = parseToolCalls(content);
 
     messages.push({ role: 'assistant', content });

package/lib/prompt.js

@@ -8,8 +8,20 @@ function getGitContext() {
     const branch = execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
     const status = execSync('git status --short', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
     const log = execSync('git log --oneline -5', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    const parts = [`Branch: ${branch}`];
-    if (status) parts.push(`Changed files:\n${status}`);
+    // Main branch detection (from context.ts getDefaultBranch pattern)
+    let mainBranch = 'main';
+    try { mainBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim().replace('refs/remotes/origin/', ''); } catch {}
+    if (!mainBranch) try { mainBranch = execSync('git config init.defaultBranch', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch {}
+    // Git user name (from context.ts)
+    let userName = '';
+    try { userName = execSync('git config user.name', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); } catch {}
+    // Truncate status at 2000 chars (from context.ts MAX_STATUS_CHARS)
+    const truncatedStatus = status.length > 2000
+      ? status.slice(0, 2000) + '\n... (truncated — run git status for full output)'
+      : status;
+    const parts = [`Branch: ${branch}`, `Main branch (for PRs): ${mainBranch}`];
+    if (userName) parts.push(`Git user: ${userName}`);
+    if (truncatedStatus) parts.push(`Changed files:\n${truncatedStatus}`);
     if (log) parts.push(`Recent commits:\n${log}`);
     return `\n\n<git>\n${parts.join('\n\n')}\n</git>`;
   } catch {

package/lib/tools.js

@@ -8,15 +8,59 @@ import fetch from 'node-fetch';
 
 const execAsync = promisify(exec);
 
-// ── Undo Stack ───────────────────────────────────────────────────────────────
-const _undoStack = [];
-const MAX_UNDO = 20;
+// ── Lines Changed Tracking ────────────────────────────────────────────────────
+// Mirrors cost-tracker.ts addToTotalLinesChanged pattern
+export const linesChanged = { added: 0, removed: 0 };
+
+// ── Undo Stack (per-turn batching) ───────────────────────────────────────────
+// Mirrors CC's multi-file undo: each turn's file changes grouped together.
+// /undo restores ALL files changed in the last turn at once.
+const _undoTurns = [];       // Array of turns: each is [{ filePath, content }]
+let _currentTurnFiles = [];  // Accumulates file snapshots for the active turn
+const MAX_UNDO_TURNS = 10;
+
+/** Call before each agent turn starts to open a new undo group. */
+export function beginUndoTurn() {
+  if (_currentTurnFiles.length > 0) {
+    _undoTurns.push([..._currentTurnFiles]);
+    if (_undoTurns.length > MAX_UNDO_TURNS) _undoTurns.shift();
+  }
+  _currentTurnFiles = [];
+}
+
+function _pushFileSnapshot(filePath) {
+  // Only snapshot once per file per turn (first state = what to restore to)
+  if (_currentTurnFiles.some(f => f.filePath === filePath)) return;
+  try {
+    const content = existsSync(filePath) ? readFileSync(filePath, 'utf8') : null;
+    _currentTurnFiles.push({ filePath, content });
+  } catch {}
+}
+
+/** Undo all file changes from the most recent turn. Returns list of restored paths. */
 export function undo() {
-  if (_undoStack.length === 0) return null;
-  const { filePath, content } = _undoStack.pop();
-  try { writeFileSync(filePath, content, 'utf8'); return filePath; } catch { return null; }
+  // Commit current turn if it has anything
+  if (_currentTurnFiles.length > 0) {
+    _undoTurns.push([..._currentTurnFiles]);
+    _currentTurnFiles = [];
+  }
+  if (_undoTurns.length === 0) return null;
+  const turn = _undoTurns.pop();
+  const restored = [];
+  for (const { filePath, content } of turn.reverse()) {
+    try {
+      if (content === null) {
+        // File was created this turn — remove it
+        import('fs').then(({ unlinkSync }) => { try { unlinkSync(filePath); } catch {} });
+      } else {
+        writeFileSync(filePath, content, 'utf8');
+      }
+      restored.push(filePath);
+    } catch {}
+  }
+  return restored.length ? restored : null;
 }
-export function undoStackSize() { return _undoStack.length; }
+export function undoStackSize() { return _undoTurns.length + (_currentTurnFiles.length > 0 ? 1 : 0); }
 
 // ── Session Context (set by index.js at startup) ──────────────────────────────
 let _sessionDir = null;
@@ -108,15 +152,13 @@ export const WriteTool = {
   },
   async run({ file_path, content }) {
     try {
-      // Undo stack: save previous content before overwriting
-      try {
-        if (existsSync(file_path)) {
-          _undoStack.push({ filePath: file_path, content: readFileSync(file_path, 'utf8') });
-          if (_undoStack.length > MAX_UNDO) _undoStack.shift();
-        }
-      } catch {}
+      _pushFileSnapshot(file_path);
+      const newLineCount = content.split('\n').length;
+      const oldLineCount = existsSync(file_path) ? readFileSync(file_path, 'utf8').split('\n').length : 0;
       writeFileSync(file_path, content, 'utf8');
-      return `Written ${content.split('\n').length} lines to ${file_path}`;
+      linesChanged.added += Math.max(0, newLineCount - oldLineCount);
+      linesChanged.removed += Math.max(0, oldLineCount - newLineCount);
+      return `Written ${newLineCount} lines to ${file_path}`;
     } catch (e) {
       return `Error writing file: ${e.message}`;
     }
@@ -145,11 +187,7 @@ export const EditTool = {
     if (!existsSync(file_path)) return `Error: File not found: ${file_path}`;
     try {
       let content = readFileSync(file_path, 'utf8');
-      // Undo stack: save current content before editing
-      try {
-        _undoStack.push({ filePath: file_path, content });
-        if (_undoStack.length > MAX_UNDO) _undoStack.shift();
-      } catch {}
+      _pushFileSnapshot(file_path);
       if (!content.includes(old_string)) return `Error: old_string not found in ${file_path}`;
       if (!replace_all) {
         const count = content.split(old_string).length - 1;
@@ -159,6 +197,9 @@ export const EditTool = {
         ? content.split(old_string).join(new_string)
         : content.replace(old_string, new_string);
       writeFileSync(file_path, updated, 'utf8');
+      // Track lines changed: old_string lines removed, new_string lines added
+      linesChanged.added += new_string.split('\n').length;
+      linesChanged.removed += old_string.split('\n').length;
       return `Edited ${file_path}`;
     } catch (e) {
       return `Error editing file: ${e.message}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsunami-code",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "Tsunami Code CLI — AI coding agent by Keystone World Management Navy Seal Unit XI3",
   "type": "module",
   "bin": {