tsunami-code 2.9.0 → 3.1.0

package/index.js

@@ -4,7 +4,9 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
-import { agentLoop, quickCompletion, setModel, getModel } from './lib/loop.js';
+import { agentLoop, quickCompletion, setModel, getModel, tokenStats } from './lib/loop.js';
+import { injectServerContext } from './lib/tools.js';
+import { loadSkills, getSkillCommand, createSkill, listSkills } from './lib/skills.js';
 import { buildSystemPrompt } from './lib/prompt.js';
 import { runPreflight, checkServer } from './lib/preflight.js';
 import { setSession, undo, undoStackSize } from './lib/tools.js';
@@ -20,7 +22,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '2.9.0';
+const VERSION = '3.1.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,8 +174,34 @@ async function run() {
   initProjectMemory(cwd);
   setSession({ sessionDir, cwd });
 
+  // Load skills
+  let skills = loadSkills(cwd);
+
+  // Inject server context into AgentTool
+  injectServerContext(serverUrl, buildSystemPrompt());
+
   printBanner(serverUrl);
 
+  // Persistent history — load previous commands
+  const HISTORY_FILE = join(CONFIG_DIR, 'history.jsonl');
+  function appendHistory(line) {
+    try {
+      const entry = JSON.stringify({ cmd: line, ts: Date.now(), cwd }) + '\n';
+      import('fs').then(({ appendFileSync }) => { try { appendFileSync(HISTORY_FILE, entry, 'utf8'); } catch {} });
+    } catch {}
+  }
+  function loadHistory() {
+    try {
+      if (!existsSync(HISTORY_FILE)) return [];
+      return readFileSync(HISTORY_FILE, 'utf8')
+        .trim().split('\n').filter(Boolean)
+        .map(l => { try { return JSON.parse(l).cmd; } catch { return null; } })
+        .filter(Boolean).reverse().slice(0, 200);
+    } catch { return []; }
+  }
+  const historyEntries = loadHistory();
+  let historyIdx = -1;
+
   // Preflight checks
   process.stdout.write(dim('  Checking server connection...'));
   const { errors, warnings } = await runPreflight(serverUrl);
@@ -356,15 +384,57 @@ async function run() {
     console.log(red(`  Unknown memory subcommand: ${sub}\n  Try: /memory, /memory files, /memory view <file>, /memory clear\n`));
   }
 
+  // Frustration detection — from leaked userPromptKeywords.ts pattern
+  const FRUSTRATION_PATTERNS = [
+    /\b(wtf|fuck|shit|damn|idiot|stupid|useless|broken|wrong|garbage|trash|terrible|awful|hate)\b/i,
+    /\b(not working|still broken|still wrong|same error|again|ugh|argh)\b/i,
+    /!{2,}/,
+    /\b(why (would|did|is|are|does|do) you|you (keep|always|never|can't|cannot|won't|don't))\b/i,
+    /\b(i (said|told|asked)|stop|listen|pay attention)\b/i
+  ];
+  function detectFrustration(text) {
+    return FRUSTRATION_PATTERNS.some(p => p.test(text));
+  }
+
   rl.on('line', async (input) => {
     const line = input.trim();
     if (!line) { rl.prompt(); return; }
 
+    // Append to persistent history
+    if (!line.startsWith('/')) {
+      appendHistory(line);
+      historyIdx = -1;
+    }
+
     if (line.startsWith('/')) {
       const parts = line.slice(1).split(' ');
       const cmd = parts[0].toLowerCase();
       const rest = parts.slice(1);
 
+      // 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'].includes(cmd)) {
+        // Run the skill prompt as a user message
+        const userContent = skillMatch.args
+          ? `[Skill: ${skillMatch.skill.name}]\n${skillMatch.prompt}`
+          : skillMatch.prompt;
+        messages.push({ role: 'user', content: userContent });
+        const fullMessages = [{ role: 'system', content: systemPrompt }, ...messages];
+        rl.pause(); isProcessing = true;
+        process.stdout.write('\n' + dim(`  ◈ Running skill: ${skillMatch.skill.name}\n\n`));
+        let firstToken = true;
+        try {
+          await agentLoop(currentServerUrl, fullMessages, (token) => {
+            if (firstToken) { process.stdout.write('  '); firstToken = false; }
+            process.stdout.write(token);
+          }, (name, args) => { printToolCall(name, args); firstToken = true; },
+          { sessionDir, cwd, planMode }, makeConfirmCallback(rl));
+          process.stdout.write('\n\n');
+        } catch(e) { console.error(red(`  Error: ${e.message}\n`)); }
+        isProcessing = false; rl.resume(); rl.prompt();
+        return;
+      }
+
       switch (cmd) {
         case 'help':
           console.log(blue('\n  Tsunami Code CLI — Commands\n'));
@@ -384,6 +454,7 @@ async function run() {
               ['/status',          'Show context size and server'],
               ['/server <url>',    'Change model server URL'],
               ['/model [name]',    'Show or change active model (default: local)'],
+              ['/history',         'Show recent command history'],
               ['/exit',            'Exit'],
             ];
             for (const [c, desc] of cmds) {
@@ -430,13 +501,22 @@ async function run() {
           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'));
+        case 'cost': {
+          const hasReal = tokenStats.requests > 0;
+          console.log(blue('\n  Session Token Usage'));
+          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}`));
+          } else {
+            console.log(dim(`  Input  : ~${_inputTokens.toLocaleString()} (estimated)`));
+            console.log(dim(`  Output : ~${_outputTokens.toLocaleString()} (estimated)`));
+            console.log(dim(`  Total  : ~${(_inputTokens + _outputTokens).toLocaleString()} (estimated)`));
+          }
+          console.log();
           break;
+        }
         case 'clear':
           resetSession();
           console.log(green('  Session cleared.\n'));
@@ -463,6 +543,27 @@ async function run() {
         case 'memory':
           await handleMemoryCommand(rest);
           break;
+        case 'skills':
+        case 'skill-list':
+          console.log(dim('\n' + listSkills(skills) + '\n'));
+          break;
+        case 'skill-create': {
+          const [skillName, ...skillBody] = rest;
+          if (!skillName) { console.log(red('  Usage: /skill-create <name> <prompt...>\n')); break; }
+          const body = skillBody.join(' ') || 'Do the following: {{ARGS}}';
+          const { slug } = createSkill(cwd, skillName, body, 'project');
+          skills = loadSkills(cwd);
+          console.log(green(`  Skill created: /${slug}\n`));
+          break;
+        }
+        case 'history': {
+          const recent = historyEntries.slice(0, 20);
+          if (recent.length === 0) { console.log(dim('  No history yet.\n')); break; }
+          console.log(blue(`\n  Recent commands (${recent.length}):`));
+          recent.forEach((h, i) => console.log(dim(`  ${String(i + 1).padStart(2)}  ${h.slice(0, 100)}`)));
+          console.log();
+          break;
+        }
         case 'exit': case 'quit':
           gracefulExit(0);
           return;
@@ -479,6 +580,11 @@ async function run() {
       userContent = `[Previous session summary]\n${lastSessionSummary}\n\n---\n\n${line}`;
     }
 
+    // Frustration injection — tell the model to acknowledge and course-correct
+    if (detectFrustration(line)) {
+      userContent += '\n\n[system: User appears frustrated. Acknowledge the issue directly, do not repeat the same approach. Be concise and action-focused.]';
+    }
+
     const fullMessages = [
       { role: 'system', content: systemPrompt },
       ...messages,

package/lib/loop.js

@@ -1,5 +1,5 @@
 import fetch from 'node-fetch';
-import { ALL_TOOLS } from './tools.js';
+import { ALL_TOOLS, injectAgentLoop, injectServerContext } from './tools.js';
 import {
   assembleContext,
   extractFilePaths,
@@ -29,6 +29,9 @@ function isDangerous(cmd) {
 // Skip waitForServer after first successful connection
 let _serverVerified = false;
 
+// Real token tracking from API responses
+export const tokenStats = { input: 0, output: 0, requests: 0 };
+
 // Current model identifier — changeable at runtime via /model command
 let _currentModel = 'local';
 export function setModel(model) { _currentModel = model; }
@@ -234,6 +237,16 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
         fullContent += token;
         onToken(token);
       }
+      // Capture real token counts + finish reason
+      if (parsed.usage) {
+        tokenStats.input += parsed.usage.prompt_tokens || 0;
+        tokenStats.output += parsed.usage.completion_tokens || 0;
+        tokenStats.requests++;
+        tokenStats.lastPromptTokens = parsed.usage.prompt_tokens || 0;
+      }
+      if (parsed.choices?.[0]?.finish_reason) {
+        tokenStats.lastFinishReason = parsed.choices[0].finish_reason;
+      }
     }
   }
 
@@ -278,6 +291,12 @@ export async function quickCompletion(serverUrl, systemPrompt, userMessage) {
   }
 }
 
+// Self-register into tools.js so AgentTool can call back into us
+// (done here at module load time to avoid circular import at parse time)
+import('./tools.js').then(m => {
+  m.injectAgentLoop(agentLoop);
+}).catch(() => {});
+
 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 : '';
@@ -300,12 +319,39 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
 
   let memoryContext = buildMemoryContext();
 
+  // Max tokens recovery — mirrors Claude Code's MAX_OUTPUT_TOKENS_RECOVERY_LIMIT=3
+  let maxTokensRecoveryCount = 0;
+  const MAX_TOKENS_RECOVERY = 3;
+
+  // Token-aware auto-compact — compact at 80% of context window (4096 default)
+  const CONTEXT_WINDOW = 4096;
+  const COMPACT_THRESHOLD = Math.floor(CONTEXT_WINDOW * 0.80);
+
   for (let i = 0; i < maxIterations; i++) {
+    // Pre-flight: if last prompt consumed >80% of context, auto-compact before next call
+    if (tokenStats.lastPromptTokens > COMPACT_THRESHOLD && messages.length > 4) {
+      onToken('\n[auto-compact: context at ' + Math.round(tokenStats.lastPromptTokens / CONTEXT_WINDOW * 100) + '%]\n');
+      // Keep system + last 4 messages only
+      const sys = messages[0];
+      messages.length = 0;
+      messages.push(sys, ...messages.slice(-4));
+      tokenStats.lastPromptTokens = 0;
+    }
+
     const content = await streamCompletion(serverUrl, messages, onToken, memoryContext);
     const toolCalls = parseToolCalls(content);
 
     messages.push({ role: 'assistant', content });
 
+    // Max tokens recovery: if model hit length limit and produced no tool calls, continue
+    if (toolCalls.length === 0 && tokenStats.lastFinishReason === 'length' && maxTokensRecoveryCount < MAX_TOKENS_RECOVERY) {
+      maxTokensRecoveryCount++;
+      tokenStats.lastFinishReason = null;
+      messages.push({ role: 'user', content: 'Continue from exactly where you left off. Do not repeat anything.' });
+      continue;
+    }
+    maxTokensRecoveryCount = 0;
+
     if (toolCalls.length === 0) break;
 
     const results = [];
@@ -347,7 +393,26 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
 
       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)}`);
+      const resultStr = String(result);
+
+      // Handle Snip signal — surgically remove message indices from context
+      if (tc.name === 'Snip') {
+        try {
+          const sig = JSON.parse(resultStr);
+          if (sig.__snip__ && Array.isArray(sig.indices)) {
+            const toRemove = new Set(sig.indices.map(Number));
+            // messages[0] is system prompt, indices are 1-based user/assistant turns
+            const kept = messages.filter((_, i) => i === 0 || !toRemove.has(i - 1));
+            const removed = messages.length - kept.length;
+            messages.length = 0;
+            kept.forEach(m => messages.push(m));
+            results.push(`[Snip result]\nRemoved ${removed} messages from context. Reason: ${sig.reason}`);
+            continue;
+          }
+        } catch {}
+      }
+
+      results.push(`[${tc.name} result]\n${resultStr.slice(0, 8000)}`);
     }
 
     messages.push({

package/lib/prompt.js

@@ -67,8 +67,12 @@ Available tools: Bash, Read, Write, Edit, Glob, Grep, Note, Checkpoint. Use them
 - **Note**: Save a permanent discovery to project memory (.tsunami/). Use liberally for traps, patterns, architectural decisions.
 - **Checkpoint**: Save current task progress to session memory so work is resumable if the session ends.
 - **WebFetch**: Fetch any URL and get the page content as text. Use for docs, GitHub files, APIs.
+- **WebSearch**: Search the web via DuckDuckGo. Returns titles, URLs, snippets. Follow up with WebFetch.
 - **TodoWrite**: Manage a persistent task list (add/complete/delete/list). Use for any multi-step task.
 - **AskUser**: Ask the user a clarifying question when genuinely blocked. Use sparingly.
+- **Agent**: Spawn a sub-agent to handle an independent task. Call multiple times in one response for parallel execution.
+- **Snip**: Surgically remove specific messages from context to free space without losing everything.
+- **Brief**: Write a working-memory note to yourself. Injected into next turn — ensures nothing is forgotten on long tasks.
 </tools>
 
 <reasoning_protocol>

package/lib/skills.js

@@ -0,0 +1,103 @@
+/**
+ * Skills system — user-defined slash commands stored as markdown files.
+ * Mirrors Claude Code's SkillTool / commands system.
+ *
+ * Skills live in:
+ *   ~/.tsunami-code/skills/*.md        (global)
+ *   <project>/.tsunami/skills/*.md     (project-local, higher priority)
+ *
+ * File format:
+ *   # Skill Name
+ *   Optional description line
+ *
+ *   Prompt content here. Can reference {{ARGS}} for user-supplied arguments.
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, basename } from 'path';
+import os from 'os';
+
+const GLOBAL_SKILLS_DIR = join(os.homedir(), '.tsunami-code', 'skills');
+
+function ensureSkillsDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+function parseSkillFile(filePath, content) {
+  const lines = content.split('\n');
+  const titleLine = lines.find(l => l.startsWith('# '));
+  const name = titleLine ? titleLine.slice(2).trim() : basename(filePath, '.md');
+  const slug = slugify(name);
+
+  // Description: first non-empty line after the title that starts with lowercase
+  const titleIdx = lines.indexOf(titleLine);
+  const descLine = lines.slice(titleIdx + 1).find(l => l.trim() && !l.startsWith('#'));
+  const description = descLine?.trim() || `Run ${name} skill`;
+
+  // Prompt: everything after the first blank line after title
+  const bodyStart = lines.findIndex((l, i) => i > titleIdx && l.trim() === '') + 1;
+  const prompt = bodyStart > 0 ? lines.slice(bodyStart).join('\n').trim() : content;
+
+  return { name, slug, description, prompt, filePath };
+}
+
+export function loadSkills(cwd) {
+  const skills = new Map(); // slug → skill
+
+  // Load global skills first
+  ensureSkillsDir(GLOBAL_SKILLS_DIR);
+  for (const dir of [GLOBAL_SKILLS_DIR, join(cwd, '.tsunami', 'skills')]) {
+    if (!existsSync(dir)) continue;
+    try {
+      for (const file of readdirSync(dir).filter(f => f.endsWith('.md'))) {
+        const filePath = join(dir, file);
+        const content = readFileSync(filePath, 'utf8');
+        const skill = parseSkillFile(filePath, content);
+        skills.set(skill.slug, skill); // project skills override global
+      }
+    } catch {}
+  }
+
+  return skills;
+}
+
+export function getSkillCommand(skills, input) {
+  // Match /skill-slug [args...]
+  const parts = input.slice(1).split(' ');
+  const slug = parts[0].toLowerCase();
+  const args = parts.slice(1).join(' ');
+
+  const skill = skills.get(slug);
+  if (!skill) return null;
+
+  const prompt = args
+    ? skill.prompt.replace(/\{\{ARGS\}\}/g, args).replace(/\{\{args\}\}/g, args)
+    : skill.prompt;
+
+  return { skill, prompt, args };
+}
+
+export function createSkill(cwd, name, content, scope = 'project') {
+  const dir = scope === 'global'
+    ? GLOBAL_SKILLS_DIR
+    : join(cwd, '.tsunami', 'skills');
+  ensureSkillsDir(dir);
+  const slug = slugify(name);
+  const filePath = join(dir, `${slug}.md`);
+  const fileContent = `# ${name}\n\n${content}\n`;
+  writeFileSync(filePath, fileContent, 'utf8');
+  return { slug, filePath };
+}
+
+export function listSkills(skills) {
+  if (skills.size === 0) return 'No skills defined. Create one with /skill-create <name>.';
+  const lines = ['Available skills:'];
+  for (const s of skills.values()) {
+    lines.push(`  /${s.slug.padEnd(20)} ${s.description}`);
+  }
+  return lines.join('\n');
+}

package/lib/tools.js

@@ -453,4 +453,199 @@ Do NOT use for:
   }
 };
 
-export const ALL_TOOLS = [BashTool, ReadTool, WriteTool, EditTool, GlobTool, GrepTool, NoteTool, CheckpointTool, WebFetchTool, TodoWriteTool, AskUserTool];
+// ── WEB SEARCH ────────────────────────────────────────────────────────────────
+export const WebSearchTool = {
+  name: 'WebSearch',
+  description: `Search the web and return results. Use when you need current information, documentation, error solutions, or anything not in the codebase.
+
+Returns titles, URLs, and snippets for the top results. Follow up with WebFetch on a specific result to get the full content.`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      num_results: { type: 'number', description: 'Number of results to return (default 8, max 20)' }
+    },
+    required: ['query']
+  },
+  async run({ query, num_results = 8 }) {
+    try {
+      const n = Math.min(num_results, 20);
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 12000);
+      const res = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36',
+          'Accept': 'text/html'
+        }
+      });
+      clearTimeout(timer);
+      if (!res.ok) return `Error: HTTP ${res.status}`;
+      const html = await res.text();
+
+      // Parse results from DuckDuckGo HTML
+      const results = [];
+      const resultBlocks = html.match(/<div class="result[^"]*"[\s\S]*?<\/div>\s*<\/div>/g) || [];
+      for (const block of resultBlocks.slice(0, n)) {
+        const titleMatch = block.match(/<a[^>]+class="result__a"[^>]*>([\s\S]*?)<\/a>/);
+        const urlMatch = block.match(/href="([^"]+)"/);
+        const snippetMatch = block.match(/<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/);
+
+        const title = titleMatch ? titleMatch[1].replace(/<[^>]+>/g, '').trim() : '';
+        const href = urlMatch ? urlMatch[1] : '';
+        const snippet = snippetMatch ? snippetMatch[1].replace(/<[^>]+>/g, '').trim() : '';
+
+        // DuckDuckGo uses redirect URLs — extract the actual URL
+        const actualUrl = href.includes('uddg=')
+          ? decodeURIComponent(href.match(/uddg=([^&]+)/)?.[1] || href)
+          : href;
+
+        if (title && actualUrl) {
+          results.push(`${results.length + 1}. ${title}\n   ${actualUrl}\n   ${snippet}`);
+        }
+      }
+
+      if (results.length === 0) return `No results found for: ${query}`;
+      return `Search results for "${query}":\n\n${results.join('\n\n')}`;
+    } catch (e) {
+      if (e.name === 'AbortError') return 'Error: Search timed out';
+      return `Error: ${e.message}`;
+    }
+  }
+};
+
+// ── AGENT TOOL ────────────────────────────────────────────────────────────────
+// Circular import prevention — agentLoop is injected at runtime by loop.js
+let _agentLoopRef = null;
+export function injectAgentLoop(fn) { _agentLoopRef = fn; }
+
+export const AgentTool = {
+  name: 'Agent',
+  description: `Launch a sub-agent to handle an independent task in parallel. The sub-agent has access to all the same tools (Bash, Read, Write, Edit, Glob, Grep, WebFetch, WebSearch, etc.) and works autonomously until done.
+
+USE THIS FOR:
+- Independent subtasks that don't depend on each other (run multiple Agents in one response)
+- Long-running research tasks you don't want in the main context
+- Isolated operations (e.g. "analyze file A" + "analyze file B" simultaneously)
+
+The agent returns a summary of what it did and what it found. Keep the task description specific and self-contained — the sub-agent has no knowledge of the current conversation.
+
+IMPORTANT: You can call Agent multiple times in one response to run tasks truly in parallel.`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      task: { type: 'string', description: 'Complete, self-contained task description for the sub-agent' },
+      serverUrl: { type: 'string', description: 'Override server URL (optional)' }
+    },
+    required: ['task']
+  },
+  async run({ task, serverUrl }) {
+    if (!_agentLoopRef) return 'Error: AgentTool not initialized (no agent loop reference)';
+    if (!_currentServerUrl) return 'Error: AgentTool not initialized (no server URL)';
+
+    const url = serverUrl || _currentServerUrl;
+    const subMessages = [
+      { role: 'system', content: _agentSystemPrompt || 'You are a capable software engineering sub-agent. Complete the given task fully and return a summary of what you did.' },
+      { role: 'user', content: task }
+    ];
+
+    const outputTokens = [];
+    let done = false;
+    try {
+      await _agentLoopRef(
+        url,
+        subMessages,
+        (token) => { outputTokens.push(token); },
+        () => {}, // tool call display — silent in sub-agent
+        null, // no session info for sub-agents
+        null, // no confirm callback
+        10    // max iterations
+      );
+      done = true;
+    } catch (e) {
+      return `Sub-agent error: ${e.message}`;
+    }
+
+    // Find the last assistant message as the result
+    const lastAssistant = [...subMessages].reverse().find(m => m.role === 'assistant');
+    const result = lastAssistant?.content || outputTokens.join('');
+    return `[Sub-agent result]\n${String(result).slice(0, 6000)}`;
+  }
+};
+
+// Server URL + system prompt injected by loop.js at startup
+let _currentServerUrl = null;
+let _agentSystemPrompt = null;
+export function injectServerContext(serverUrl, systemPrompt) {
+  _currentServerUrl = serverUrl;
+  _agentSystemPrompt = systemPrompt;
+}
+
+// ── SNIP TOOL ─────────────────────────────────────────────────────────────────
+// The model calls this to surgically remove specific turns from context
+// loop.js handles the actual splice — this is a signal tool
+export const SnipTool = {
+  name: 'Snip',
+  description: `Remove specific conversation turns from context to free up space, without losing the whole conversation like /compact does.
+
+Use when:
+- A specific tool result was very large and is no longer needed (e.g. a full file read you've already processed)
+- An early exploration phase produced lots of output that's no longer relevant
+- You want to keep recent context but drop stale earlier parts
+
+The 'indices' are 0-based positions in the conversation (0 = first user message after system prompt).
+Use /status to see current message count, then pick which to snip.`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      indices: {
+        type: 'array',
+        items: { type: 'number' },
+        description: 'Array of 0-based message indices to remove from context'
+      },
+      reason: { type: 'string', description: 'Why you are snipping these (logged for transparency)' }
+    },
+    required: ['indices']
+  },
+  async run({ indices, reason }) {
+    // Actual snipping happens in agentLoop — this signals intent
+    return JSON.stringify({ __snip__: true, indices, reason: reason || 'context management' });
+  }
+};
+
+// ── BRIEF TOOL ────────────────────────────────────────────────────────────────
+export const BriefTool = {
+  name: 'Brief',
+  description: `Write a self-briefing note to yourself about the current task state. This gets injected into context on the next turn, ensuring nothing is forgotten even if context is trimmed.
+
+Use after major milestones in long tasks. Different from Checkpoint — Brief is for your own working memory, not user-visible progress.
+
+Example:
+  Brief({ content: "Working on auth refactor. Done: DB schema updated, sessions table migrated. Current: updating login route. Not done: logout, password reset. Key discovery: sessions table uses TEXT not UUID for user_id — do not cast." })`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      content: { type: 'string', description: 'Your working memory note — what you know, what is done, what is next, what to watch out for' }
+    },
+    required: ['content']
+  },
+  async run({ content }) {
+    try {
+      if (!_sessionDir) return 'Brief recorded (no session initialized)';
+      // Reuse checkpoint mechanism — both go to session context
+      updateContext(_sessionDir, `[BRIEF]\n${content}`);
+      return 'Brief saved to working memory.';
+    } catch (e) {
+      return `Brief recorded (write failed: ${e.message})`;
+    }
+  }
+};
+
+export const ALL_TOOLS = [
+  BashTool, ReadTool, WriteTool, EditTool, GlobTool, GrepTool,
+  NoteTool, CheckpointTool,
+  WebFetchTool, WebSearchTool,
+  TodoWriteTool, AskUserTool,
+  AgentTool, SnipTool, BriefTool
+];

package/package.json

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