tsunami-code 3.4.0 → 3.6.0

package/index.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import readline from 'readline';
 import chalk from 'chalk';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } 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, linesChanged } 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,
@@ -24,8 +24,9 @@ import {
   getRecentDecisions,
   getSessionContext
 } from './lib/memory.js';
+import { listMemories, readMemory, saveMemory, deleteMemory, getMemdirPath } from './lib/memdir.js';
 
-const VERSION = '3.4.0';
+const VERSION = '3.6.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';
@@ -82,6 +83,72 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
 }
 
+// ── Syntax highlighter — line-buffered, applied to streaming model output ──────
+// Buffers tokens until newlines, then applies chalk markup per line.
+// createHighlighter(write) returns an onToken(token) function.
+function createHighlighter(write) {
+  let buf = '';
+  let inFence = false;
+  let fenceMark = '```';
+
+  function renderLine(line) {
+    if (inFence) {
+      // Exit fence?
+      if (line.trimStart().startsWith(fenceMark[0].repeat(3))) {
+        inFence = false;
+        write(chalk.dim(line) + '\n');
+        return;
+      }
+      write(chalk.green(line) + '\n');
+      return;
+    }
+
+    // Enter fence?
+    const fenceM = line.trimStart().match(/^(`{3,}|~{3,})/);
+    if (fenceM) {
+      inFence = true;
+      fenceMark = fenceM[1][0].repeat(3);
+      write(chalk.dim(line) + '\n');
+      return;
+    }
+
+    // Heading
+    if (/^#{1,6} /.test(line)) {
+      write(chalk.bold.cyan(line) + '\n');
+      return;
+    }
+
+    // Horizontal rule
+    if (/^[-*_]{3,}$/.test(line.trim())) {
+      write(chalk.dim(line) + '\n');
+      return;
+    }
+
+    // Inline markup (bold + inline code only — keep it fast)
+    const styled = line
+      .replace(/\*\*([^*\n]+)\*\*/g, (_, t) => chalk.bold(t))
+      .replace(/__([^_\n]+)__/g, (_, t) => chalk.bold(t))
+      .replace(/`([^`\n]+)`/g, (_, t) => chalk.yellow('`' + t + '`'));
+
+    write(styled + '\n');
+  }
+
+  return function onToken(token) {
+    buf += token;
+    let nl;
+    while ((nl = buf.indexOf('\n')) !== -1) {
+      renderLine(buf.slice(0, nl));
+      buf = buf.slice(nl + 1);
+    }
+  };
+}
+
+// Flush remaining buffer (call at end of response)
+function flushHighlighter(highlighter) {
+  // inject a trailing newline so any buffered content gets rendered
+  highlighter('\n');
+}
+
 // ── CLI Parsing ───────────────────────────────────────────────────────────────
 const argv = process.argv.slice(2);
 
@@ -172,6 +239,60 @@ async function run() {
   const cwd = process.cwd();
   let planMode = argv.includes('--plan');
 
+  // ── --print mode: non-interactive single-shot, pipe-friendly ────────────────
+  // Usage: tsunami --print "fix the bug in server.js"
+  //        tsunami --server http://... --print "your prompt"
+  const printIdx = argv.indexOf('--print');
+  if (printIdx !== -1) {
+    const printPrompt = argv.slice(printIdx + 1).join(' ').trim();
+    if (!printPrompt) {
+      process.stderr.write('Usage: tsunami --print "your prompt"\n');
+      process.exit(1);
+    }
+
+    const { errors } = await runPreflight(serverUrl);
+    if (errors.length) {
+      for (const e of errors) process.stderr.write(`Error: ${e}\n`);
+      process.exit(1);
+    }
+
+    const { sessionId, sessionDir } = initSession(cwd);
+    initProjectMemory(cwd);
+    setSession({ sessionDir, cwd });
+
+    const sp = buildSystemPrompt();
+    injectServerContext(serverUrl, sp);
+
+    const msgs = [
+      { role: 'system', content: sp },
+      { role: 'user', content: printPrompt }
+    ];
+
+    const highlight = createHighlighter((s) => process.stdout.write(s));
+    try {
+      await agentLoop(
+        serverUrl, msgs,
+        (token) => highlight(token),
+        (name, args) => {
+          let parsed = {};
+          try { parsed = JSON.parse(args); } catch {}
+          const preview = Object.entries(parsed)
+            .map(([k, v]) => `${k}=${JSON.stringify(String(v).slice(0, 40))}`).join(', ');
+          process.stderr.write(`\n[${name}(${preview})]\n`);
+        },
+        { sessionDir, cwd, planMode: false },
+        null, 15
+      );
+    } catch (e) {
+      process.stderr.write(`Error: ${e.message}\n`);
+      process.exit(1);
+    }
+    flushHighlighter(highlight);
+    process.stdout.write('\n');
+    process.exit(0);
+    return;
+  }
+
   const sessionStartTime = Date.now();
 
   // Initialize memory systems
@@ -323,11 +444,31 @@ async function run() {
     return [system, ...rest.slice(-maxEntries)];
   }
 
+  // Slash command list for tab completion — keep in sync with switch cases + skills
+  const SLASH_COMMANDS = [
+    '/help', '/compact', '/plan', '/undo', '/doctor', '/cost', '/memory', '/clear',
+    '/status', '/server', '/model', '/mcp', '/effort', '/copy', '/btw', '/rewind',
+    '/diff', '/stats', '/export', '/history', '/exit', '/quit', '/kairos', '/skills',
+    '/skill-create', '/skill-list', '/init', '/memdir',
+  ];
+
+  function tabCompleter(line) {
+    if (line.startsWith('/')) {
+      // Supplement with loaded skill names
+      const skillCmds = skills.map(s => `/${s.slug}`);
+      const all = [...new Set([...SLASH_COMMANDS, ...skillCmds])].sort();
+      const hits = all.filter(c => c.startsWith(line));
+      return [hits.length ? hits : all, line];
+    }
+    return [[], line];
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: planMode ? yellow('❯ [plan] ') : cyan('❯ '),
-    terminal: process.stdin.isTTY
+    terminal: process.stdin.isTTY,
+    completer: tabCompleter,
   });
 
   rl.prompt();
@@ -441,7 +582,58 @@ async function run() {
     return FRUSTRATION_PATTERNS.some(p => p.test(text));
   }
 
+  // ── Multiline input state ───────────────────────────────────────────────────
+  // Mode 1 — backslash continuation: line ending with \
+  // Mode 2 — heredoc block: """ on a line by itself opens/closes
+  let mlBuffer = [];
+  let mlHeredoc = false;
+
   rl.on('line', async (input) => {
+    // ── Multiline: heredoc mode (""" toggle) ──────────────────────────────────
+    if (input.trimStart() === '"""' || input.trimStart() === "'''") {
+      if (!mlHeredoc) {
+        mlHeredoc = true;
+        rl.setPrompt(dim('··· '));
+        rl.prompt();
+        return;
+      } else {
+        // Close heredoc — submit accumulated buffer
+        mlHeredoc = false;
+        const assembled = mlBuffer.join('\n');
+        mlBuffer = [];
+        rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+        // Fall through with assembled as the input
+        return _handleInput(assembled);
+      }
+    }
+
+    if (mlHeredoc) {
+      mlBuffer.push(input);
+      rl.prompt();
+      return;
+    }
+
+    // ── Multiline: backslash continuation ─────────────────────────────────────
+    if (input.endsWith('\\')) {
+      mlBuffer.push(input.slice(0, -1));
+      rl.setPrompt(dim('··· '));
+      rl.prompt();
+      return;
+    }
+
+    if (mlBuffer.length > 0) {
+      // Final line of a backslash continuation
+      mlBuffer.push(input);
+      const assembled = mlBuffer.join('\n');
+      mlBuffer = [];
+      rl.setPrompt(planMode ? yellow('❯ [plan] ') : cyan('❯ '));
+      return _handleInput(assembled);
+    }
+
+    return _handleInput(input);
+  });
+
+  async function _handleInput(input) {
     const line = input.trim();
     if (!line) { rl.prompt(); return; }
 
@@ -458,7 +650,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','copy','btw','rewind','diff','stats','export'].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}`
@@ -500,14 +692,19 @@ 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'],
+              ['/init [--force]',  'Generate TSUNAMI.md from codebase analysis'],
+              ['/memdir',         'List persistent cross-session memories'],
+              ['/memdir add <n>', 'Add a memory entry'],
+              ['/memdir delete',  'Delete a memory entry'],
+              ['/history',        'Show recent command history'],
+              ['/exit',           'Exit'],
             ];
             for (const [c, desc] of cmds) {
               console.log(`  ${cyan(c.padEnd(22))} ${dim(desc)}`);
@@ -526,8 +723,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': {
@@ -790,6 +1003,135 @@ async function run() {
         case 'exit': case 'quit':
           gracefulExit(0);
           return;
+
+        case 'init': {
+          // Analyze codebase and generate TSUNAMI.md project instructions
+          const tsunamiPath = join(cwd, 'TSUNAMI.md');
+          if (existsSync(tsunamiPath) && !rest.includes('--force')) {
+            console.log(yellow(`  TSUNAMI.md already exists. Use /init --force to regenerate.\n`));
+            break;
+          }
+          process.stdout.write(dim('  ↯ Analyzing codebase...\n'));
+
+          // Gather context: file tree, package.json, git log
+          let initCtx = `Working directory: ${cwd}\n\n`;
+          try {
+            const { execSync: _e } = await import('child_process');
+            // File tree (top-level + src/)
+            try {
+              const tree = _e('git ls-files --others --cached --exclude-standard | head -60', { cwd, encoding: 'utf8', stdio: ['pipe','pipe','ignore'] });
+              initCtx += `Files (git-tracked):\n${tree}\n`;
+            } catch {
+              try {
+                const { readdirSync: _r } = await import('fs');
+                const top = _r(cwd).slice(0, 40).join('\n');
+                initCtx += `Files (top-level):\n${top}\n`;
+              } catch {}
+            }
+            // package.json
+            const pkgPath = join(cwd, 'package.json');
+            if (existsSync(pkgPath)) {
+              initCtx += `\npackage.json:\n${readFileSync(pkgPath, 'utf8').slice(0, 1000)}\n`;
+            }
+            // Git log
+            try {
+              const log = _e('git log --oneline -10', { cwd, encoding: 'utf8', stdio: ['pipe','pipe','ignore'] });
+              initCtx += `\nRecent git history:\n${log}\n`;
+            } catch {}
+            // README
+            for (const rname of ['README.md', 'README']) {
+              const rp = join(cwd, rname);
+              if (existsSync(rp)) {
+                initCtx += `\nREADME:\n${readFileSync(rp, 'utf8').slice(0, 800)}\n`;
+                break;
+              }
+            }
+          } catch {}
+
+          const initSystemPrompt = 'You are an expert developer analyzing a codebase to write project instructions for an AI coding agent CLI. Be concise, direct, and specific.';
+          const initUserPrompt = `Analyze this codebase context and generate a TSUNAMI.md project instruction file for an AI coding agent.
+
+The file should contain:
+1. A short description of the project (2-3 sentences)
+2. Tech stack (languages, frameworks, key libraries)
+3. Project structure (key directories and their purpose)
+4. Critical patterns and conventions (naming, file organization, auth patterns, etc.)
+5. Common pitfalls to avoid (traps, gotchas, things to check first)
+6. How to build/run/test the project
+7. Key files to read before making changes
+
+Keep each section tight. Use bullet points. This will be injected into an AI agent's context on every turn.
+
+Codebase context:
+${initCtx}
+
+Output ONLY the TSUNAMI.md content, starting with "# Project: <name>"`;
+
+          const initContent = await quickCompletion(currentServerUrl, initSystemPrompt, initUserPrompt);
+          if (!initContent || initContent.length < 50) {
+            console.log(red('  Failed to generate TSUNAMI.md (model returned empty response).\n'));
+            break;
+          }
+          writeFileSync(tsunamiPath, initContent, 'utf8');
+          systemPrompt = buildSystemPrompt(); // reload with new TSUNAMI.md
+          console.log(green(`  ✓ Created TSUNAMI.md (${initContent.length} chars)\n`));
+          console.log(dim('  Tip: review and edit it to add project-specific traps.\n'));
+          break;
+        }
+
+        case 'memdir': {
+          // Persistent cross-session auto-memory management
+          const sub = rest[0]?.toLowerCase();
+
+          if (!sub || sub === 'list') {
+            const mems = listMemories();
+            if (mems.length === 0) {
+              console.log(dim(`\n  No auto-memories yet.\n  Path: ${getMemdirPath()}\n`));
+            } else {
+              console.log(blue(`\n  Auto-memory (${mems.length} entries) — ${getMemdirPath()}\n`));
+              for (const m of mems) {
+                console.log(`  ${cyan(m.name.padEnd(20))} ${dim(m.preview)}`);
+              }
+              console.log();
+            }
+            break;
+          }
+
+          if (sub === 'view' && rest[1]) {
+            const name = rest.slice(1).join('-');
+            const content = readMemory(name);
+            if (!content) {
+              console.log(red(`  No memory named "${name}"\n`));
+            } else {
+              console.log(blue(`\n  Memory: ${name}\n`));
+              console.log(dim('  ' + content.replace(/\n/g, '\n  ')));
+              console.log();
+            }
+            break;
+          }
+
+          if (sub === 'add' && rest[1]) {
+            const name = rest[1];
+            const content = rest.slice(2).join(' ');
+            if (!content) { console.log(red('  Usage: /memdir add <name> <content>\n')); break; }
+            const path = saveMemory(name, content);
+            if (path) console.log(green(`  ✓ Saved: ${path}\n`));
+            else console.log(red('  Failed to save memory.\n'));
+            break;
+          }
+
+          if (sub === 'delete' && rest[1]) {
+            const name = rest.slice(1).join('-');
+            const ok = deleteMemory(name);
+            if (ok) console.log(green(`  ✓ Deleted: ${name}\n`));
+            else console.log(red(`  No memory named "${name}"\n`));
+            break;
+          }
+
+          console.log(dim('  Usage: /memdir [list|view <name>|add <name> <content>|delete <name>]\n'));
+          break;
+        }
+
         default:
           console.log(red(`  Unknown command: /${cmd}\n`));
       }
@@ -829,22 +1171,28 @@ 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;
+    const highlight = createHighlighter((s) => process.stdout.write(s));
     try {
       await agentLoop(
         currentServerUrl,
         fullMessages,
         (token) => {
           if (firstToken) { process.stdout.write('  '); firstToken = false; }
-          process.stdout.write(token);
+          highlight(token);
         },
         (toolName, toolArgs) => {
+          flushHighlighter(highlight);
           printToolCall(toolName, toolArgs);
           firstToken = true;
         },
         { sessionDir, cwd, planMode },
         makeConfirmCallback(rl)
       );
+      flushHighlighter(highlight);
 
       // Token estimation
       const inputChars = fullMessages.reduce((s, m) => s + (typeof m.content === 'string' ? m.content.length : 0), 0);
@@ -863,6 +1211,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');
@@ -876,15 +1229,24 @@ async function run() {
     }
     rl.resume();
     rl.prompt();
-  });
+  }
 
   process.on('SIGINT', () => {
     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/hooks.js

@@ -0,0 +1,114 @@
+/**
+ * Hooks system — lifecycle hooks fired around tool execution.
+ *
+ * Config locations (merged, project overrides global):
+ *   ~/.tsunami-code/hooks.json   — global
+ *   .tsunami/hooks.json          — project-level
+ *
+ * Format:
+ * {
+ *   "hooks": {
+ *     "PreToolUse":  [{ "matcher": "Bash", "command": "echo $HOOK_TOOL" }],
+ *     "PostToolUse": [{ "command": "..." }],
+ *     "Stop":        [{ "command": "notify-send Done" }],
+ *     "Notification":[{ "command": "..." }]
+ *   }
+ * }
+ *
+ * PreToolUse:  non-zero exit code blocks the tool; return value from fireHook is false.
+ * All others:  errors are silently ignored.
+ * Env vars set for every hook: HOOK_EVENT, HOOK_TOOL, HOOK_FILE, HOOK_COMMAND, HOOK_DATA (JSON).
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import os from 'os';
+
+const CONFIG_DIR = join(os.homedir(), '.tsunami-code');
+
+function loadConfig(cwd) {
+  let merged = { hooks: {} };
+
+  function merge(src) {
+    for (const [event, handlers] of Object.entries(src.hooks || {})) {
+      if (!Array.isArray(handlers)) continue;
+      merged.hooks[event] = [...(merged.hooks[event] || []), ...handlers];
+    }
+  }
+
+  const globalPath = join(CONFIG_DIR, 'hooks.json');
+  if (existsSync(globalPath)) {
+    try { merge(JSON.parse(readFileSync(globalPath, 'utf8'))); } catch {}
+  }
+
+  if (cwd) {
+    const projectPath = join(cwd, '.tsunami', 'hooks.json');
+    if (existsSync(projectPath)) {
+      try { merge(JSON.parse(readFileSync(projectPath, 'utf8'))); } catch {}
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Fire a hook event.
+ *
+ * @param {'PreToolUse'|'PostToolUse'|'Stop'|'Notification'} event
+ * @param {object} data  — { tool?, args?, result? }
+ * @param {string} [cwd]
+ * @returns {Promise<boolean>}  false only when PreToolUse blocks execution
+ */
+export async function fireHook(event, data, cwd) {
+  const config = loadConfig(cwd);
+  const handlers = config.hooks[event];
+  if (!handlers || handlers.length === 0) return true;
+
+  const dataJson = JSON.stringify(data);
+  const env = {
+    ...process.env,
+    HOOK_EVENT: event,
+    HOOK_DATA: dataJson,
+    HOOK_TOOL: data.tool || '',
+    HOOK_FILE: data.args?.file_path || data.args?.path || '',
+    HOOK_COMMAND: data.args?.command || '',
+  };
+
+  const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+
+  for (const handler of handlers) {
+    if (!handler.command) continue;
+
+    // matcher: regex against tool name (case-insensitive)
+    if (handler.matcher && data.tool) {
+      try {
+        if (!new RegExp(handler.matcher, 'i').test(data.tool)) continue;
+      } catch {
+        if (handler.matcher !== data.tool) continue;
+      }
+    }
+
+    try {
+      execSync(handler.command, {
+        env,
+        cwd: cwd || process.cwd(),
+        stdio: ['ignore', 'ignore', 'ignore'],
+        timeout: 5000,
+        shell,
+      });
+    } catch (e) {
+      // PreToolUse: non-zero exit = block
+      if (event === 'PreToolUse') return false;
+      // All other hooks: ignore errors
+    }
+  }
+
+  return true;
+}
+
+export function hasHooks(cwd) {
+  const globalPath = join(CONFIG_DIR, 'hooks.json');
+  const projectPath = cwd ? join(cwd, '.tsunami', 'hooks.json') : null;
+  return existsSync(globalPath) || Boolean(projectPath && existsSync(projectPath));
+}

package/lib/loop.js

@@ -6,6 +6,7 @@ import {
   logFileChange,
   appendDecision
 } from './memory.js';
+import { fireHook } from './hooks.js';
 
 // ── Tool result summarization (generateToolUseSummary pattern) ───────────────
 const SUMMARY_THRESHOLD = 2000; // chars — results larger than this get compressed
@@ -59,6 +60,11 @@ 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 = [];
@@ -169,8 +175,16 @@ async function runTool(name, args, sessionInfo, sessionFiles) {
     const parsed = typeof args === 'string' ? JSON.parse(args) : args;
     const normalized = normalizeArgs(parsed);
 
+    // PreToolUse hook — non-zero exit blocks the tool
+    const cwd = sessionInfo?.cwd;
+    const allowed = await fireHook('PreToolUse', { tool: name, args: normalized }, cwd);
+    if (!allowed) return `[${name} blocked by PreToolUse hook]`;
+
     const result = await tool.run(normalized);
 
+    // PostToolUse hook (fire-and-forget — errors ignored)
+    fireHook('PostToolUse', { tool: name, args: normalized, result: String(result).slice(0, 500) }, cwd).catch(() => {});
+
     // Auto-capture: track files touched for context assembly
     if (sessionFiles && normalized.file_path) {
       sessionFiles.add(normalized.file_path);
@@ -232,7 +246,7 @@ 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']
     })
@@ -500,4 +514,9 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
     memoryContext = buildMemoryContext();
     onToken('\n');
   }
+
+  // Stop hook — fire after agent loop completes
+  if (sessionInfo?.cwd) {
+    fireHook('Stop', { turns: maxIterations }, sessionInfo.cwd).catch(() => {});
+  }
 }

package/lib/memdir.js

@@ -0,0 +1,118 @@
+/**
+ * Auto-memory (memdir) — persistent cross-session, cross-project memory.
+ *
+ * Storage: ~/.tsunami-code/memory/<slug>.md
+ * Auto-injected into every system prompt as <auto-memory> block.
+ * Model writes via the Memory tool (registered dynamically in tools.js).
+ * User manages via /memdir commands in index.js.
+ */
+
+import {
+  existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync
+} from 'fs';
+import { join, basename } from 'path';
+import os from 'os';
+
+const MEMDIR = join(os.homedir(), '.tsunami-code', 'memory');
+
+function ensure() {
+  if (!existsSync(MEMDIR)) mkdirSync(MEMDIR, { recursive: true });
+}
+
+function slug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'note';
+}
+
+/**
+ * Load all memory entries and return a formatted context string.
+ * Returns '' if no entries exist.
+ */
+export function getMemdirContext() {
+  ensure();
+  try {
+    const files = readdirSync(MEMDIR).filter(f => f.endsWith('.md')).sort();
+    if (files.length === 0) return '';
+
+    const parts = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(MEMDIR, file), 'utf8').trim();
+        if (content) parts.push(`### ${basename(file, '.md')}\n${content}`);
+      } catch {}
+    }
+
+    if (parts.length === 0) return '';
+    return `\n\n<auto-memory>\n${parts.join('\n\n')}\n</auto-memory>`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Save or overwrite a memory entry.
+ * @param {string} name  — human name (will be slugified)
+ * @param {string} content
+ * @returns {string|null}  path on success, null on failure
+ */
+export function saveMemory(name, content) {
+  ensure();
+  const path = join(MEMDIR, `${slug(name)}.md`);
+  try {
+    writeFileSync(path, content.trim() + '\n', 'utf8');
+    return path;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List all memory entries with a short preview.
+ * @returns {{ name: string, path: string, preview: string, size: number }[]}
+ */
+export function listMemories() {
+  ensure();
+  try {
+    return readdirSync(MEMDIR)
+      .filter(f => f.endsWith('.md'))
+      .sort()
+      .map(f => {
+        const path = join(MEMDIR, f);
+        let preview = '';
+        let size = 0;
+        try {
+          const content = readFileSync(path, 'utf8').trim();
+          preview = content.slice(0, 80).replace(/\n/g, ' ');
+          size = content.length;
+        } catch {}
+        return { name: basename(f, '.md'), path, preview, size };
+      });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read a single memory entry's full content.
+ * @param {string} name
+ * @returns {string|null}
+ */
+export function readMemory(name) {
+  const path = join(MEMDIR, `${slug(name)}.md`);
+  if (!existsSync(path)) return null;
+  try { return readFileSync(path, 'utf8').trim(); } catch { return null; }
+}
+
+/**
+ * Delete a memory entry.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function deleteMemory(name) {
+  const path = join(MEMDIR, `${slug(name)}.md`);
+  try {
+    if (existsSync(path)) { unlinkSync(path); return true; }
+  } catch {}
+  return false;
+}
+
+export function getMemdirPath() { return MEMDIR; }

package/lib/prompt.js

@@ -2,14 +2,27 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
 import { execSync } from 'child_process';
+import { getMemdirContext } from './memdir.js';
 
 function getGitContext() {
   try {
     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 {
@@ -40,6 +53,8 @@ export function buildSystemPrompt(memoryContext = '') {
 
   const gitContext = getGitContext();
 
+  const memdirContext = getMemdirContext();
+
   return `You are an expert software engineer and technical assistant operating as a CLI agent. You think deeply before acting, trace data flow before changing code, and verify your work.
 
 To use a tool, output ONLY this format — nothing else before or after the tool call block:
@@ -125,5 +140,5 @@ Notes persist permanently in .tsunami/memory/. Checkpoints persist for the sessi
 - Error paths as clear as success paths
 - Parameterized queries only — never concatenate user input into SQL
 - Every protected route: check auth at the top, first line
-</code_quality>${context}${memoryContext ? `\n\n${memoryContext}` : ''}`;
+</code_quality>${context}${memdirContext}${memoryContext ? `\n\n${memoryContext}` : ''}`;
 }

package/lib/tools.js

@@ -12,15 +12,55 @@ const execAsync = promisify(exec);
 // Mirrors cost-tracker.ts addToTotalLinesChanged pattern
 export const linesChanged = { added: 0, removed: 0 };
 
-// ── Undo Stack ───────────────────────────────────────────────────────────────
-const _undoStack = [];
-const MAX_UNDO = 20;
+// ── 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;
@@ -112,13 +152,7 @@ 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');
@@ -153,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;

package/package.json

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