tsunami-code 2.6.0 → 2.7.0

package/.tsunami/CODEBASE.md

@@ -0,0 +1,8 @@
+# Project Notes
+
+
+## [2026-04-03T06:20:55.390Z]
+Project version is 2.6.0
+
+## [2026-04-03T06:24:24.305Z]
+schema.ts file not found

package/.tsunami/memory/package.json.md

@@ -0,0 +1,8 @@
+# Memory: package.json
+
+## Notes
+
+## Changes
+
+## Access Log
+- [2026-04-03T06:20:04.011Z] Read

package/.tsunami/memory/schema.ts.md

@@ -0,0 +1,8 @@
+# Memory: schema.ts
+
+## Notes
+
+## Changes
+
+## Access Log
+- [2026-04-03T06:23:17.357Z] Read

package/index.js

@@ -4,10 +4,10 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
-import { agentLoop } from './lib/loop.js';
+import { agentLoop, quickCompletion } from './lib/loop.js';
 import { buildSystemPrompt } from './lib/prompt.js';
-import { runPreflight } from './lib/preflight.js';
-import { setSession } from './lib/tools.js';
+import { runPreflight, checkServer } from './lib/preflight.js';
+import { setSession, undo, undoStackSize } from './lib/tools.js';
 import {
   initSession,
   initProjectMemory,
@@ -20,7 +20,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '2.6.0';
+const VERSION = '2.7.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';
@@ -115,7 +115,7 @@ if (argv.includes('--help') || argv.includes('-h')) {
 }
 
 if (argv.includes('--version') || argv.includes('-v')) {
-  console.log(`keystonecli v${VERSION}`);
+  console.log(`tsunami v${VERSION}`);
   process.exit(0);
 }
 
@@ -129,10 +129,29 @@ if (setServerIdx !== -1 && argv[setServerIdx + 1]) {
   process.exit(0);
 }
 
+// ── Confirm Callback (dangerous command prompt) ─────────────────────────────
+function makeConfirmCallback(rl) {
+  return async (cmd) => {
+    return new Promise((resolve) => {
+      rl.pause();
+      process.stdout.write(`\n  ${yellow('⚠  Dangerous:')} ${dim(cmd.slice(0, 120))}\n`);
+      process.stdout.write(`  ${yellow('Proceed?')} ${dim('(y/N) ')}`);
+      const handler = (data) => {
+        process.stdin.removeListener('data', handler);
+        rl.resume();
+        process.stdout.write('\n');
+        resolve(data.toString().trim().toLowerCase() === 'y');
+      };
+      process.stdin.once('data', handler);
+    });
+  };
+}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function run() {
   const serverUrl = getServerUrl(argv);
   const cwd = process.cwd();
+  let planMode = argv.includes('--plan');
 
   // Initialize memory systems
   const { sessionId, sessionDir } = initSession(cwd);
@@ -168,6 +187,39 @@ async function run() {
   let currentServerUrl = serverUrl;
   let messages = [];
   let systemPrompt = buildSystemPrompt();
+  let _inputTokens = 0;
+  let _outputTokens = 0;
+
+  // --resume: inject last session summary
+  if (argv.includes('--resume')) {
+    const lastSummary = getLastSessionSummary(cwd);
+    if (lastSummary) {
+      console.log(dim('  Resuming from last session...\n'));
+      messages.push({ role: 'user', content: `[Resuming]\n\n${lastSummary}` });
+      messages.push({ role: 'assistant', content: 'Understood, I have the previous session context. Ready to continue.' });
+    }
+  }
+
+  // Compact messages helper
+  async function compactMessages(focus = '') {
+    if (messages.length < 3) { console.log(dim('  Nothing substantial to compact.\n')); return; }
+    process.stdout.write(dim('  ↯ Compacting...'));
+    const historyText = messages
+      .filter(m => !['system'].includes(m.role))
+      .map(m => {
+        const c = typeof m.content === 'string' ? m.content.slice(0, 250) : '[tool result]';
+        return `${m.role.toUpperCase()}: ${c}`;
+      }).join('\n\n');
+    const focusLine = focus ? ` Focus on: ${focus}.` : '';
+    const prompt = `Summarize this conversation in 4-6 bullet points. Preserve: goal, files changed, key decisions, current progress, next step.${focusLine}\n\n${historyText}`;
+    const summary = await quickCompletion(currentServerUrl, buildSystemPrompt(), prompt);
+    const before = messages.length;
+    messages = summary
+      ? [{ role: 'user', content: `[Compacted — ${before} messages]\n\n${summary}` }, { role: 'assistant', content: 'Understood, continuing.' }]
+      : messages.slice(-4);
+    process.stdout.write('\r' + ' '.repeat(25) + '\r');
+    console.log(green('  ✓ Compacted') + dim(` ${before} → ${messages.length} messages\n`));
+  }
 
   function resetSession() {
     messages = [];
@@ -186,7 +238,7 @@ async function run() {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: cyan('❯ '),
+    prompt: planMode ? yellow('❯ [plan] ') : cyan('❯ '),
     terminal: process.stdin.isTTY
   });
 
@@ -255,6 +307,19 @@ async function run() {
       return;
     }
 
+    if (sub === 'last') {
+      const { getLastSessionSummary } = await import('./lib/memory.js');
+      const summary = getLastSessionSummary(cwd);
+      if (!summary) {
+        console.log(dim('  No previous session summary found.\n'));
+      } else {
+        console.log(blue('\n  Last Session Summary'));
+        console.log(dim('  ' + summary.replace(/\n/g, '\n  ')));
+        console.log();
+      }
+      return;
+    }
+
     if (sub === 'clear') {
       // Reinitialize session (clear session memory, keep project memory)
       resetSession();
@@ -288,17 +353,74 @@ async function run() {
 
       switch (cmd) {
         case 'help':
-          console.log(dim(`
-  Commands:
-    /clear            Start new conversation
-    /status           Show context size
-    /server <url>     Change server URL for this session
-    /memory           Show memory stats
-    /memory files     List files with memory entries
-    /memory view <f>  Show memory for a file
-    /memory clear     Clear session memory (keep project memory)
-    /exit             Exit
-`));
+          console.log(blue('\n  Tsunami Code CLI — Commands\n'));
+          {
+            const cmds = [
+              ['/compact [focus]', 'Summarize context and continue'],
+              ['/plan',            'Toggle read-only plan mode'],
+              ['/undo',            'Undo last file change'],
+              ['/doctor',          'Run health diagnostics'],
+              ['/cost',            'Show token usage estimate'],
+              ['/memory',          'Show project memory stats'],
+              ['/memory files',    'List files with memory'],
+              ['/memory view <f>', 'Show memory for a file'],
+              ['/memory last',     'Show last session summary'],
+              ['/memory clear',    'Clear session memory'],
+              ['/clear',           'Start new conversation'],
+              ['/status',          'Show context size and server'],
+              ['/server <url>',    'Change model server URL'],
+              ['/exit',            'Exit'],
+            ];
+            for (const [c, desc] of cmds) {
+              console.log(`  ${cyan(c.padEnd(22))} ${dim(desc)}`);
+            }
+            console.log();
+          }
+          break;
+        case 'compact':
+          await compactMessages(rest.join(' '));
+          break;
+        case 'plan':
+          planMode = !planMode;
+          if (planMode) console.log(yellow('  Plan mode ON — read-only, no writes or execution.\n'));
+          else console.log(green('  Plan mode OFF — full capabilities restored.\n'));
+          rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+          break;
+        case 'undo': {
+          const restored = undo();
+          if (restored) console.log(green(`  ✓ Restored: ${restored}\n`));
+          else console.log(dim('  Nothing to undo.\n'));
+          break;
+        }
+        case 'doctor': {
+          const { getRgPath } = await import('./lib/preflight.js');
+          const { getMemoryStats: _getMemoryStats } = await import('./lib/memory.js');
+
+          const nodeVer = process.versions.node;
+          const nodeMajor = parseInt(nodeVer.split('.')[0]);
+          const rgPath = getRgPath();
+          const stats = _getMemoryStats(cwd);
+          const hasTsunami = existsSync(join(cwd, '.tsunami'));
+          const hasTsunamiMd = existsSync(join(cwd, 'TSUNAMI.md'));
+          const serverOk = await checkServer(currentServerUrl).catch(() => false);
+
+          console.log(blue('\n  🩺 Tsunami Code Diagnostics\n'));
+          console.log((nodeMajor >= 18 ? green : red)(`  ${nodeMajor >= 18 ? '✓' : '✗'} Node.js v${nodeVer}`));
+          console.log((serverOk ? green : red)(`  ${serverOk ? '✓' : '✗'} Server: ${currentServerUrl}`));
+          console.log((rgPath ? green : yellow)(`  ${rgPath ? '✓' : '⚠'} ripgrep: ${rgPath || 'not found'}`));
+          console.log((hasTsunami ? green : dim)(`  ${hasTsunami ? '✓' : '○'} Project memory: ${hasTsunami ? `.tsunami/ (${stats.projectMemoryFiles} files, ${formatBytes(stats.projectMemorySize)})` : 'none'}`));
+          console.log((hasTsunamiMd ? green : yellow)(`  ${hasTsunamiMd ? '✓' : '⚠'} TSUNAMI.md: ${hasTsunamiMd ? 'found' : 'not found (add one for project instructions)'}`));
+          console.log(dim(`\n  Session : ${sessionId}`));
+          console.log(dim(`  Version : tsunami-code v${VERSION}`));
+          console.log(dim(`  CWD     : ${cwd}\n`));
+          break;
+        }
+        case 'cost':
+          console.log(blue('\n  Session Token Estimate'));
+          console.log(dim(`  Input  : ~${_inputTokens.toLocaleString()}`));
+          console.log(dim(`  Output : ~${_outputTokens.toLocaleString()}`));
+          console.log(dim(`  Total  : ~${(_inputTokens + _outputTokens).toLocaleString()}`));
+          console.log(dim('  (Estimates only)\n'));
           break;
         case 'clear':
           resetSession();
@@ -358,14 +480,27 @@ async function run() {
           printToolCall(toolName, toolArgs);
           firstToken = true;
         },
-        { sessionDir, cwd }
+        { sessionDir, cwd, planMode },
+        makeConfirmCallback(rl)
       );
 
+      // Token estimation
+      const inputChars = fullMessages.reduce((s, m) => s + (typeof m.content === 'string' ? m.content.length : 0), 0);
+      _inputTokens += Math.round(inputChars / 4);
+      const outputChars = fullMessages.filter(m => m.role === 'assistant').reduce((s, m) => s + (m.content?.length || 0), 0);
+      _outputTokens = Math.round(outputChars / 4);
+
       // Update messages from the loop (fullMessages was mutated by agentLoop)
       // Trim to rolling window: keep system + last 8 entries
       const loopMessages = fullMessages.slice(1); // drop system, agentLoop added to fullMessages
       messages = trimMessages([{ role: 'system', content: systemPrompt }, ...loopMessages]).slice(1);
 
+      // Auto-compact
+      if (messages.length > 24) {
+        await compactMessages();
+        console.log(dim('  ↯ Auto-compacted\n'));
+      }
+
       process.stdout.write('\n\n');
     } catch (e) {
       process.stdout.write('\n');

package/lib/loop.js

@@ -3,11 +3,32 @@ import { ALL_TOOLS } from './tools.js';
 import {
   assembleContext,
   extractFilePaths,
-  logFileAccess,
   logFileChange,
   appendDecision
 } from './memory.js';
 
+// ── Dangerous command detection ──────────────────────────────────────────────
+const DANGEROUS_PATTERNS = [
+  /rm\s+-[rf]+\s+[^-]/,
+  /DROP\s+TABLE/i,
+  /DROP\s+DATABASE/i,
+  /DROP\s+SCHEMA/i,
+  /ALTER\s+TABLE.*DROP\s+COLUMN/i,
+  /git\s+push\s+.*--force/,
+  /git\s+push\s+-f\b/,
+  /git\s+reset\s+--hard/,
+  /del\s+\/[sf]/i,
+  /Remove-Item.*-Recurse.*-Force/i,
+  /truncate\s+table/i,
+  /delete\s+from\s+\w+\s*;?\s*$/i,
+];
+function isDangerous(cmd) {
+  return DANGEROUS_PATTERNS.some(p => p.test(cmd || ''));
+}
+
+// Skip waitForServer after first successful connection
+let _serverVerified = false;
+
 // Parse tool calls from any format the model might produce
 function parseToolCalls(content) {
   const calls = [];
@@ -88,10 +109,6 @@ function normalizeArgs(args) {
   return out;
 }
 
-/**
- * Detect key patterns in Bash commands and return a decision string, or null.
- * We log psql, npm, pm2, git, and deploy-related commands.
- */
 function bashDecisionHint(cmd) {
   if (!cmd) return null;
   const c = cmd.trim();
@@ -105,26 +122,31 @@ function bashDecisionHint(cmd) {
   return null;
 }
 
-async function runTool(name, args, sessionInfo) {
+// Only log decisions that are actually meaningful
+function meaningfulDecision(toolName, args) {
+  if (toolName === 'Note') return `NOTE: ${(args.note || '').slice(0, 120)}`;
+  if (toolName === 'Checkpoint') return `CHECKPOINT: ${(args.content || '').split('\n')[0].slice(0, 120)}`;
+  if (toolName === 'Write') return `WROTE: ${args.file_path} (${(args.content || '').split('\n').length} lines)`;
+  if (toolName === 'Edit') return `EDITED: ${args.file_path} — replaced "${(args.old_string || '').slice(0, 60).replace(/\n/g, '↵')}"`;
+  if (toolName === 'Bash') return bashDecisionHint(args.command);
+  return null;
+}
+
+async function runTool(name, args, sessionInfo, sessionFiles) {
   const tool = ALL_TOOLS.find(t => t.name === name);
   if (!tool) return `Error: Unknown tool "${name}"`;
   try {
     const parsed = typeof args === 'string' ? JSON.parse(args) : args;
     const normalized = normalizeArgs(parsed);
 
-    // Auto-capture memory BEFORE running the tool (for access/change logging)
-    if (sessionInfo) {
-      const { sessionDir, cwd } = sessionInfo;
-      try {
-        if (name === 'Read' && normalized.file_path) {
-          logFileAccess(cwd, normalized.file_path);
-        }
-      } catch {}
-    }
-
     const result = await tool.run(normalized);
 
-    // Auto-capture memory AFTER running the tool
+    // Auto-capture: track files touched for context assembly
+    if (sessionFiles && normalized.file_path) {
+      sessionFiles.add(normalized.file_path);
+    }
+
+    // Auto-capture: write/edit → log to project memory
     if (sessionInfo) {
       const { sessionDir, cwd } = sessionInfo;
       try {
@@ -134,10 +156,10 @@ async function runTool(name, args, sessionInfo) {
         } else if (name === 'Edit' && normalized.file_path) {
           const preview = (normalized.old_string || '').slice(0, 60).replace(/\n/g, '↵');
           logFileChange(cwd, normalized.file_path, `Edited: replaced "${preview}"`);
-        } else if (name === 'Bash') {
-          const hint = bashDecisionHint(normalized.command);
-          if (hint) appendDecision(sessionDir, hint);
         }
+        // Log only meaningful decisions — not every Read/Glob/Grep
+        const decision = meaningfulDecision(name, normalized);
+        if (decision) appendDecision(sessionDir, decision);
       } catch {}
     }
 
@@ -147,24 +169,20 @@ async function runTool(name, args, sessionInfo) {
   }
 }
 
-async function waitForServer(serverUrl, retries = 10, delay = 2000) {
+async function waitForServer(serverUrl, retries = 5, delay = 1000) {
   for (let i = 0; i < retries; i++) {
     try {
       const r = await fetch(`${serverUrl}/health`);
       const j = await r.json();
-      if (j.status === 'ok') return;
+      if (j.status === 'ok') { _serverVerified = true; return; }
     } catch {}
     await new Promise(r => setTimeout(r, delay));
   }
   throw new Error(`Model server not responding at ${serverUrl}`);
 }
 
-/**
- * Stream a completion from the model server.
- * Injects memoryContext into the system message if provided.
- */
 async function streamCompletion(serverUrl, messages, onToken, memoryContext = '') {
-  await waitForServer(serverUrl, 5, 1000);
+  if (!_serverVerified) await waitForServer(serverUrl);
 
   // Inject memory context into the system message (first message with role=system)
   let finalMessages = messages;
@@ -227,55 +245,90 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
  * @param {{ sessionDir: string, cwd: string } | null} sessionInfo
  * @param {number} maxIterations
  */
-export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessionInfo = null, maxIterations = 15) {
-  // Extract the current task from the last user message for context assembly
+export async function quickCompletion(serverUrl, systemPrompt, userMessage) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 12000);
+  try {
+    const res = await fetch(`${serverUrl}/v1/chat/completions`, {
+      method: 'POST',
+      signal: controller.signal,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'local',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userMessage }
+        ],
+        stream: false,
+        temperature: 0.1,
+        max_tokens: 600
+      })
+    });
+    clearTimeout(timer);
+    const json = await res.json();
+    return json.choices?.[0]?.message?.content || '';
+  } catch {
+    clearTimeout(timer);
+    return '';
+  }
+}
+
+export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessionInfo = null, confirmCallback = null, maxIterations = 15) {
   const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
   const currentTask = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
 
-  for (let i = 0; i < maxIterations; i++) {
-    // Assemble memory context before each model call
-    let memoryContext = '';
-    if (sessionInfo) {
-      try {
-        const filesToConsider = extractFilePaths(currentTask);
-        memoryContext = assembleContext({
-          sessionDir: sessionInfo.sessionDir,
-          cwd: sessionInfo.cwd,
-          currentTask,
-          filesToConsider
-        });
-      } catch {}
-    }
+  // Files touched during this turn — fed back into context assembly each iteration
+  const sessionFiles = new Set(extractFilePaths(currentTask));
+
+  // Assemble memory context once before the turn, refresh after files are touched
+  const buildMemoryContext = () => {
+    if (!sessionInfo) return '';
+    try {
+      return assembleContext({
+        sessionDir: sessionInfo.sessionDir,
+        cwd: sessionInfo.cwd,
+        currentTask,
+        filesToConsider: [...sessionFiles]
+      });
+    } catch { return ''; }
+  };
+
+  let memoryContext = buildMemoryContext();
 
+  for (let i = 0; i < maxIterations; i++) {
     const content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
     const toolCalls = parseToolCalls(content);
 
     messages.push({ role: 'assistant', content });
 
-    if (toolCalls.length === 0) {
-      // Log final assistant response as a decision if it's substantive
-      if (sessionInfo && content.length > 50) {
-        try {
-          const summary = content.slice(0, 150).replace(/\n/g, ' ');
-          appendDecision(sessionInfo.sessionDir, `RESPONSE: ${summary}`);
-        } catch {}
-      }
-      break;
-    }
+    if (toolCalls.length === 0) break;
 
     const results = [];
     for (const tc of toolCalls) {
-      onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
-      const result = await runTool(tc.name, tc.arguments, sessionInfo);
-      results.push(`[${tc.name} result]\n${String(result).slice(0, 8000)}`);
+      // Plan mode: block Write, Edit, Bash
+      if (sessionInfo?.planMode && ['Write', 'Edit', 'Bash'].includes(tc.name)) {
+        results.push(`[${tc.name} result]\n[PLAN MODE] ${tc.name} is disabled. Describe what you would do instead.`);
+        onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
+        continue;
+      }
 
-      // Log tool execution as a decision entry
-      if (sessionInfo) {
-        try {
-          const argsPreview = JSON.stringify(tc.arguments || {}).slice(0, 80);
-          appendDecision(sessionInfo.sessionDir, `TOOL ${tc.name}: ${argsPreview}`);
-        } catch {}
+      // Dangerous command confirmation
+      if (tc.name === 'Bash' && confirmCallback) {
+        const parsed = typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : tc.arguments;
+        const normalized = normalizeArgs(parsed);
+        if (isDangerous(normalized.command)) {
+          const ok = await confirmCallback(normalized.command);
+          if (!ok) {
+            onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
+            results.push(`[${tc.name} result]\nCommand blocked by user. Find a safer approach to accomplish this.`);
+            continue;
+          }
+        }
       }
+
+      onToolCall(tc.name, typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments));
+      const result = await runTool(tc.name, tc.arguments, sessionInfo, sessionFiles);
+      results.push(`[${tc.name} result]\n${String(result).slice(0, 8000)}`);
     }
 
     messages.push({
@@ -283,6 +336,8 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
       content: results.join('\n\n---\n\n') + '\n\nContinue with the task.'
     });
 
+    // Refresh memory context now that new files may have been touched
+    memoryContext = buildMemoryContext();
     onToken('\n');
   }
 }

package/lib/tools.js

@@ -7,6 +7,16 @@ import { addFileNote, updateContext, appendDecision } from './memory.js';
 
 const execAsync = promisify(exec);
 
+// ── Undo Stack ───────────────────────────────────────────────────────────────
+const _undoStack = [];
+const MAX_UNDO = 20;
+export function undo() {
+  if (_undoStack.length === 0) return null;
+  const { filePath, content } = _undoStack.pop();
+  try { writeFileSync(filePath, content, 'utf8'); return filePath; } catch { return null; }
+}
+export function undoStackSize() { return _undoStack.length; }
+
 // ── Session Context (set by index.js at startup) ──────────────────────────────
 let _sessionDir = null;
 let _cwd = null;
@@ -97,6 +107,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 {}
       writeFileSync(file_path, content, 'utf8');
       return `Written ${content.split('\n').length} lines to ${file_path}`;
     } catch (e) {
@@ -127,6 +144,11 @@ 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 {}
       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;
@@ -249,7 +271,9 @@ Set file_path to null for project-wide notes (written to CODEBASE.md).`,
   async run({ file_path, note }) {
     try {
       if (!_cwd) return 'Note saved (no project memory initialized yet)';
-      addFileNote(_cwd, file_path || null, note);
+      // Normalize: model sometimes passes "null" or "undefined" as a string
+      const fp = (!file_path || file_path === 'null' || file_path === 'undefined') ? null : file_path;
+      addFileNote(_cwd, fp, note);
       return `Note saved to project memory${file_path ? ` for ${file_path}` : ' (CODEBASE.md)'}.`;
     } catch (e) {
       return `Note recorded (memory write failed silently: ${e.message})`;
@@ -277,7 +301,7 @@ The content should be a clear summary of:
 4. Any blockers or important context
 
 EXAMPLE:
-  Checkpoint({ content: "Task: Add dispo pipeline tracking to leads table.\n\nDone:\n- Added status column (MATCHING/CONTACTED/INTERESTED/WALKTHROUGH/CONTRACTED/CLOSED)\n- Updated shared/schema.ts with new enum\n- Route GET /api/deals/pipeline written and tested\n\nNext: Wire up the React frontend pipeline component to the new route.\n\nContext: The deals table has a lead_id FK — pipeline state lives on deals, not leads." })`,
+  Checkpoint({ content: "Task: [what the user asked for]\n\nDone:\n- [steps completed so far]\n\nNext: [exact next step]\n\nContext: [any gotchas or decisions made that affect what comes next]" })`,
   input_schema: {
     type: 'object',
     properties: {

package/package.json

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