tsunami-code 3.5.0 → 3.6.1

package/index.js

@@ -1,7 +1,7 @@
 #!/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, setTemperature, getTemperature } from './lib/loop.js';
@@ -24,8 +24,9 @@ import {
   getRecentDecisions,
   getSessionContext
 } from './lib/memory.js';
+import { listMemories, readMemory, saveMemory, deleteMemory, getMemdirPath } from './lib/memdir.js';
 
-const VERSION = '3.5.0';
+const VERSION = '3.6.1';
 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';
@@ -64,7 +65,7 @@ const blue = (s) => chalk.blue(s);
 function printBanner(serverUrl) {
   console.log(cyan(bold('\n  🌊 Tsunami Code CLI')) + dim(` v${VERSION}`));
   console.log(dim('  by Keystone World Management · Navy Seal Unit XI3'));
-  console.log(dim(`  Model server: ${serverUrl}\n`));
+  console.log(dim('  International AI Wars\n'));
 }
 
 function printToolCall(name, args) {
@@ -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; }
 
@@ -507,8 +699,12 @@ async function run() {
               ['/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)}`);
@@ -807,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`));
       }
@@ -850,21 +1175,24 @@ async function run() {
     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);
@@ -901,7 +1229,7 @@ async function run() {
     }
     rl.resume();
     rl.prompt();
-  });
+  }
 
   process.on('SIGINT', () => {
     if (!isProcessing) {

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
@@ -174,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);
@@ -505,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,6 +2,7 @@ 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 {
@@ -52,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:
@@ -137,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/package.json

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