tsunami-code 3.1.0 → 3.3.0

package/index.js

@@ -7,9 +7,12 @@ import os from 'os';
 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 { 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 } from './lib/tools.js';
+import { setSession, undo, undoStackSize, registerMcpTools } from './lib/tools.js';
+import { connectMcpServers, getMcpToolObjects, getMcpStatus, getMcpConfigPath, disconnectAll as disconnectMcp } from './lib/mcp.js';
 import {
   initSession,
   initProjectMemory,
@@ -22,7 +25,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '3.1.0';
+const VERSION = '3.3.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';
@@ -223,6 +226,47 @@ async function run() {
     dim(` · ${sessionId} · Type your task. /help for commands. Ctrl+C to exit.\n`)
   );
 
+  // MCP: connect servers from ~/.tsunami-code/mcp.json (non-blocking — warnings only)
+  {
+    const mcpResults = await connectMcpServers();
+    if (mcpResults.length > 0) {
+      const mcpTools = getMcpToolObjects();
+      registerMcpTools(mcpTools);
+      const ok = mcpResults.filter(r => !r.error);
+      const fail = mcpResults.filter(r => r.error);
+      if (ok.length) console.log(green(`  ✓ MCP`) + dim(` ${ok.map(r => `${r.name}(${r.toolCount})`).join(', ')}`));
+      if (fail.length) {
+        for (const f of fail) console.log(yellow(`  ⚠ MCP "${f.name}" failed: ${f.error}`));
+      }
+      if (ok.length || fail.length) console.log();
+    }
+  }
+
+  // KAIROS: run due background tasks on startup
+  const dueTasks = getDueTasks();
+  if (dueTasks.length > 0) {
+    console.log(yellow(`  ⏰ KAIROS: ${dueTasks.length} background task(s) due\n`));
+    for (const task of dueTasks) {
+      console.log(dim(`  Running: ${task.prompt.slice(0, 80)}...\n`));
+      const kairosMessages = [
+        { role: 'system', content: buildSystemPrompt() },
+        { role: 'user', content: `[KAIROS background task]\n${task.prompt}` }
+      ];
+      try {
+        await agentLoop(serverUrl, kairosMessages,
+          (t) => process.stdout.write(t),
+          () => {},
+          { sessionDir, cwd, planMode: false },
+          null, 10
+        );
+        markDone(task.id);
+        process.stdout.write('\n\n');
+      } catch (e) {
+        console.log(red(`  KAIROS task failed: ${e.message}\n`));
+      }
+    }
+  }
+
   // Load last session summary if available
   const lastSessionSummary = getLastSessionSummary(cwd);
 
@@ -291,9 +335,8 @@ async function run() {
 
   // ── Exit handler ─────────────────────────────────────────────────────────────
   function gracefulExit(code = 0) {
-    try {
-      endSession(sessionDir);
-    } catch {}
+    try { endSession(sessionDir); } catch {}
+    try { disconnectMcp(); } catch {}
     console.log(dim('\n  Goodbye.\n'));
     process.exit(code);
   }
@@ -413,7 +456,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'].includes(cmd)) {
+      if (skillMatch && !['help','compact','plan','undo','doctor','cost','clear','status','server','model','memory','history','exit','quit','skill-create','skill-list','skills','mcp'].includes(cmd)) {
         // Run the skill prompt as a user message
         const userContent = skillMatch.args
           ? `[Skill: ${skillMatch.skill.name}]\n${skillMatch.prompt}`
@@ -454,6 +497,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)'],
+              ['/mcp',             'Show MCP server status and tools'],
               ['/history',         'Show recent command history'],
               ['/exit',            'Exit'],
             ];
@@ -478,6 +522,25 @@ async function run() {
           else console.log(dim('  Nothing to undo.\n'));
           break;
         }
+        case 'mcp': {
+          const mcpServers = getMcpStatus();
+          if (mcpServers.length === 0) {
+            console.log(dim(`\n  No MCP servers connected.`));
+            console.log(dim(`  Add servers to: ${getMcpConfigPath()}`));
+            console.log(dim('  Format: { "servers": { "name": { "command": "npx", "args": [...] } } }\n'));
+          } else {
+            console.log(blue(`\n  MCP Servers (${mcpServers.length})\n`));
+            for (const srv of mcpServers) {
+              console.log(`  ${cyan(srv.name)} ${dim(`— ${srv.toolCount} tool${srv.toolCount !== 1 ? 's' : ''}`)}`);
+              for (const tool of srv.tools) {
+                const desc = tool.description ? dim(` — ${tool.description}`) : '';
+                console.log(`    ${dim('•')} ${tool.name}${desc}`);
+              }
+            }
+            console.log();
+          }
+          break;
+        }
         case 'doctor': {
           const { getRgPath } = await import('./lib/preflight.js');
           const { getMemoryStats: _getMemoryStats } = await import('./lib/memory.js');
@@ -543,6 +606,19 @@ async function run() {
         case 'memory':
           await handleMemoryCommand(rest);
           break;
+        case 'kairos': {
+          const sub = rest[0];
+          if (!sub || sub === 'list') {
+            console.log(blue('\n  KAIROS Scheduled Tasks\n'));
+            console.log(dim(formatTaskList(listTasks()) + '\n'));
+          } else if (sub === 'cancel' && rest[1]) {
+            cancelTask(rest[1]);
+            console.log(green(`  Cancelled: ${rest[1]}\n`));
+          } else {
+            console.log(dim('  Usage: /kairos [list|cancel <id>]\n'));
+          }
+          break;
+        }
         case 'skills':
         case 'skill-list':
           console.log(dim('\n' + listSkills(skills) + '\n'));
@@ -580,13 +656,23 @@ async function run() {
       userContent = `[Previous session summary]\n${lastSessionSummary}\n\n---\n\n${line}`;
     }
 
-    // Frustration injection — tell the model to acknowledge and course-correct
+    // Frustration injection
     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.]';
     }
 
+    // Coordinator mode — use special system prompt that instructs parallel worker routing
+    let activeSystemPrompt = systemPrompt;
+    let coordinatorActive = false;
+    if (isCoordinatorTask(line)) {
+      activeSystemPrompt = buildCoordinatorSystemPrompt(systemPrompt);
+      userContent = stripCoordinatorPrefix(userContent);
+      coordinatorActive = true;
+      process.stdout.write(dim('\n  ◈ Coordinator mode activated — routing to parallel workers\n'));
+    }
+
     const fullMessages = [
-      { role: 'system', content: systemPrompt },
+      { role: 'system', content: activeSystemPrompt },
       ...messages,
       { role: 'user', content: userContent }
     ];

package/lib/coordinator.js

@@ -0,0 +1,63 @@
+/**
+ * Coordinator mode — mirrors Claude Code's coordinator/coordinatorMode.js
+ *
+ * When activated (--coordinator flag or @team prefix), a coordinator agent
+ * analyzes the task, decomposes it into independent subtasks, and routes
+ * each to a worker Agent. Workers run in parallel. Coordinator aggregates
+ * results and produces a final summary.
+ *
+ * Architecture (from leaked source):
+ *   Coordinator has a different system prompt:
+ *     - Knows it is orchestrating workers
+ *     - Must break task into INDEPENDENT subtasks (no deps between workers)
+ *     - Must spawn one Agent per subtask
+ *     - Aggregates worker results into a coherent response
+ *
+ *   Workers:
+ *     - Each worker only sees its own subtask
+ *     - No shared state between workers
+ *     - Results flow back to coordinator via Agent tool return values
+ */
+
+export const COORDINATOR_SYSTEM_INJECTION = `
+<coordinator_mode>
+You are operating as a COORDINATOR agent. Your job is NOT to do the work yourself —
+it is to orchestrate WORKER agents that do the work in parallel.
+
+RULES:
+1. Analyze the task and identify subtasks that can run independently
+2. For each independent subtask, call Agent({ task: "..." }) — you can call multiple Agent() in a single response to run them in parallel
+3. Wait for all worker results, then synthesize a final answer
+4. Never do work a worker could do — delegate everything
+5. Keep subtasks self-contained: each worker has no knowledge of other workers
+
+SUBTASK DECOMPOSITION GUIDE:
+- "analyze X and Y" → two Agent calls (analyze X, analyze Y)
+- "search for A then use it in B" → NOT parallelizable (sequential dependency)
+- "update files A, B, C independently" → three Agent calls
+- "refactor module X" → one Agent call (single coherent task)
+
+When you have all worker results, write a final COORDINATOR SUMMARY that:
+- States what was accomplished
+- Highlights any conflicts or issues workers found
+- Lists files changed
+- Notes anything requiring follow-up
+</coordinator_mode>
+`;
+
+export function isCoordinatorTask(input) {
+  // Explicit triggers
+  if (input.startsWith('@team ') || input.startsWith('@coordinator ')) return true;
+  // Heuristic: task mentions multiple independent files/components
+  const parallelKeywords = /\b(and also|in parallel|simultaneously|at the same time|both.*and|all of the following)\b/i;
+  const multiFile = (input.match(/\b\w+\.\w{2,4}\b/g) || []).length >= 3;
+  return parallelKeywords.test(input) && multiFile;
+}
+
+export function stripCoordinatorPrefix(input) {
+  return input.replace(/^@(team|coordinator)\s+/i, '');
+}
+
+export function buildCoordinatorSystemPrompt(baseSystemPrompt) {
+  return baseSystemPrompt + COORDINATOR_SYSTEM_INJECTION;
+}

package/lib/kairos.js

@@ -0,0 +1,75 @@
+/**
+ * KAIROS — background scheduled tasks.
+ * Mirrors Claude Code's unreleased autonomous background agent mode.
+ *
+ * Tasks stored in ~/.tsunami-code/kairos.json
+ * Each task: { id, prompt, schedule, lastRun, status, createdAt }
+ * schedule: 'once' | 'hourly' | 'daily' | cron-like string (HH:MM)
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { randomBytes } from 'crypto';
+
+const CONFIG_DIR = join(os.homedir(), '.tsunami-code');
+const KAIROS_FILE = join(CONFIG_DIR, 'kairos.json');
+
+function load() {
+  if (!existsSync(KAIROS_FILE)) return [];
+  try { return JSON.parse(readFileSync(KAIROS_FILE, 'utf8')); } catch { return []; }
+}
+
+function save(tasks) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(KAIROS_FILE, JSON.stringify(tasks, null, 2), 'utf8');
+}
+
+export function scheduleTask(prompt, schedule = 'once') {
+  const tasks = load();
+  const id = randomBytes(4).toString('hex');
+  tasks.push({ id, prompt, schedule, status: 'pending', createdAt: new Date().toISOString(), lastRun: null });
+  save(tasks);
+  return id;
+}
+
+export function listTasks() { return load(); }
+
+export function cancelTask(id) {
+  const tasks = load().filter(t => t.id !== id);
+  save(tasks);
+}
+
+export function markDone(id) {
+  const tasks = load();
+  const t = tasks.find(t => t.id === id);
+  if (t) { t.status = t.schedule === 'once' ? 'done' : 'pending'; t.lastRun = new Date().toISOString(); }
+  save(tasks);
+}
+
+export function getDueTasks() {
+  const now = new Date();
+  return load().filter(t => {
+    if (t.status === 'done') return false;
+    if (t.status === 'running') return false;
+    if (!t.lastRun) return true; // never run
+    const last = new Date(t.lastRun);
+    if (t.schedule === 'once') return t.status === 'pending';
+    if (t.schedule === 'hourly') return (now - last) >= 3600000;
+    if (t.schedule === 'daily') return (now - last) >= 86400000;
+    // HH:MM format
+    if (/^\d{2}:\d{2}$/.test(t.schedule)) {
+      const [h, m] = t.schedule.split(':').map(Number);
+      const due = new Date(now); due.setHours(h, m, 0, 0);
+      return now >= due && (now - last) >= 86400000;
+    }
+    return false;
+  });
+}
+
+export function formatTaskList(tasks) {
+  if (!tasks.length) return 'No KAIROS tasks scheduled.';
+  return tasks.map(t =>
+    `  [${t.id}] ${t.status.padEnd(8)} ${t.schedule.padEnd(8)} ${t.prompt.slice(0, 60)}`
+  ).join('\n');
+}

package/lib/loop.js

@@ -7,6 +7,20 @@ import {
   appendDecision
 } from './memory.js';
 
+// ── Tool result summarization (generateToolUseSummary pattern) ───────────────
+const SUMMARY_THRESHOLD = 2000; // chars — results larger than this get compressed
+const SUMMARIZABLE_TOOLS = new Set(['Read', 'Bash', 'WebFetch', 'WebSearch', 'Grep']);
+
+async function generateToolUseSummary(serverUrl, toolName, result) {
+  const systemPrompt =
+    'You are a lossless summarizer for an AI agent\'s working memory. ' +
+    'Extract every key fact, file path, function name, error message, variable name, value, and data point from the tool result. ' +
+    'Preserve anything the agent might need to act on. ' +
+    'Be dense and specific. No preamble. Target: under 350 words.';
+  const userMessage = `Tool: ${toolName}\n\nResult:\n${result.slice(0, 12000)}`;
+  return await quickCompletion(serverUrl, systemPrompt, userMessage);
+}
+
 // ── Dangerous command detection ──────────────────────────────────────────────
 const DANGEROUS_PATTERNS = [
   /rm\s+-[rf]+\s+[^-]/,
@@ -412,7 +426,17 @@ export async function agentLoop(serverUrl, messages, onToken, onToolCall, sessio
         } catch {}
       }
 
-      results.push(`[${tc.name} result]\n${resultStr.slice(0, 8000)}`);
+      // Compress large results before storing in context
+      let resultForContext = resultStr;
+      if (resultStr.length > SUMMARY_THRESHOLD && SUMMARIZABLE_TOOLS.has(tc.name)) {
+        try {
+          const summary = await generateToolUseSummary(serverUrl, tc.name, resultStr);
+          if (summary && summary.length < resultStr.length * 0.75) {
+            resultForContext = `[Summarized ${resultStr.length} → ${summary.length} chars]\n${summary}`;
+          }
+        } catch { /* keep raw result on failure */ }
+      }
+      results.push(`[${tc.name} result]\n${resultForContext.slice(0, 8000)}`);
     }
 
     messages.push({

package/lib/mcp.js

@@ -0,0 +1,258 @@
+/**
+ * MCP (Model Context Protocol) client for Tsunami Code.
+ *
+ * Reads ~/.tsunami-code/mcp.json, spawns server processes,
+ * speaks JSON-RPC 2.0 over stdio, discovers tools, and wraps
+ * them as Tsunami tool objects that plug into ALL_TOOLS.
+ *
+ * Config format (~/.tsunami-code/mcp.json):
+ * {
+ *   "servers": {
+ *     "filesystem": {
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ *       "env": {}
+ *     }
+ *   }
+ * }
+ */
+
+import { spawn } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+const MCP_CONFIG_PATH = join(os.homedir(), '.tsunami-code', 'mcp.json');
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+
+// Active connections: name → { process, pending: Map<id, {resolve, reject}>, tools: [], buffer: '' }
+const _servers = new Map();
+let _nextId = 1000;
+
+// ── Config ────────────────────────────────────────────────────────────────────
+function loadMcpConfig() {
+  if (!existsSync(MCP_CONFIG_PATH)) return { servers: {} };
+  try {
+    return JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf8'));
+  } catch {
+    return { servers: {} };
+  }
+}
+
+// ── JSON-RPC over stdio ───────────────────────────────────────────────────────
+function sendRequest(server, method, params = {}) {
+  return new Promise((resolve, reject) => {
+    const id = _nextId++;
+    server.pending.set(id, { resolve, reject });
+
+    const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+    try {
+      server.process.stdin.write(msg);
+    } catch (e) {
+      server.pending.delete(id);
+      reject(new Error(`Failed to write to MCP server stdin: ${e.message}`));
+      return;
+    }
+
+    // Auto-reject after 10s to prevent hanging
+    const timer = setTimeout(() => {
+      if (server.pending.has(id)) {
+        server.pending.delete(id);
+        reject(new Error(`MCP request timed out (${method})`));
+      }
+    }, 10000);
+
+    // Clear timer when resolved
+    const orig = server.pending.get(id);
+    server.pending.set(id, {
+      resolve: (v) => { clearTimeout(timer); resolve(v); },
+      reject:  (e) => { clearTimeout(timer); reject(e); }
+    });
+  });
+}
+
+function sendNotification(server, method, params = {}) {
+  try {
+    const msg = JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n';
+    server.process.stdin.write(msg);
+  } catch {}
+}
+
+function attachStdioHandler(serverName, server) {
+  server.process.stdout.on('data', (chunk) => {
+    server.buffer += chunk.toString();
+    // Process complete newline-delimited JSON messages
+    let nl;
+    while ((nl = server.buffer.indexOf('\n')) !== -1) {
+      const line = server.buffer.slice(0, nl).trim();
+      server.buffer = server.buffer.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        // Only handle responses (have id), not notifications
+        if (msg.id !== undefined && server.pending.has(msg.id)) {
+          const { resolve, reject } = server.pending.get(msg.id);
+          server.pending.delete(msg.id);
+          if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+          else resolve(msg.result);
+        }
+      } catch { /* malformed JSON — skip */ }
+    }
+  });
+
+  server.process.stderr.on('data', () => {}); // absorb stderr silently
+
+  server.process.on('error', () => {
+    _servers.delete(serverName);
+    // Reject all pending requests
+    for (const { reject } of server.pending.values()) {
+      reject(new Error(`MCP server "${serverName}" crashed`));
+    }
+    server.pending.clear();
+  });
+
+  server.process.on('exit', () => {
+    _servers.delete(serverName);
+    for (const { reject } of server.pending.values()) {
+      reject(new Error(`MCP server "${serverName}" exited`));
+    }
+    server.pending.clear();
+  });
+}
+
+// ── Connect a single server ───────────────────────────────────────────────────
+async function connectServer(name, config) {
+  try {
+    const { command, args = [], env = {} } = config;
+
+    if (!command) throw new Error('Missing "command" in MCP server config');
+
+    const child = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...env },
+      shell: process.platform === 'win32'
+    });
+
+    const server = {
+      process: child,
+      pending: new Map(),
+      tools: [],
+      buffer: ''
+    };
+    _servers.set(name, server);
+    attachStdioHandler(name, server);
+
+    // 1. Initialize handshake
+    await sendRequest(server, 'initialize', {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: { tools: {} },
+      clientInfo: { name: 'tsunami-code', version: '3.3.0' }
+    });
+
+    // 2. Send initialized notification (spec requires this, no response)
+    sendNotification(server, 'notifications/initialized');
+
+    // 3. Discover tools
+    const listResult = await sendRequest(server, 'tools/list', {});
+    server.tools = listResult?.tools || [];
+
+    return { name, toolCount: server.tools.length, tools: server.tools.map(t => t.name) };
+  } catch (e) {
+    _servers.delete(name);
+    return { name, toolCount: 0, error: e.message };
+  }
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Connect all servers from mcp.json and return a status array.
+ * Safe to call even if mcp.json doesn't exist.
+ */
+export async function connectMcpServers() {
+  const config = loadMcpConfig();
+  const entries = Object.entries(config.servers || {});
+  if (entries.length === 0) return [];
+
+  const results = await Promise.allSettled(
+    entries.map(([name, cfg]) => connectServer(name, cfg))
+  );
+
+  return results.map(r =>
+    r.status === 'fulfilled' ? r.value : { error: r.reason?.message || 'unknown error' }
+  );
+}
+
+/**
+ * Returns Tsunami tool objects for all discovered MCP tools.
+ * Call this after connectMcpServers() and push the results into ALL_TOOLS.
+ */
+export function getMcpToolObjects() {
+  const toolObjects = [];
+
+  for (const [serverName, server] of _servers) {
+    for (const toolDef of server.tools) {
+      // Prefix with mcp__ to avoid name collisions with built-ins
+      const tsunamiName = `mcp__${serverName}__${toolDef.name}`;
+
+      toolObjects.push({
+        name: tsunamiName,
+        description: `[MCP:${serverName}] ${toolDef.description || toolDef.name}\n\nOriginal name: ${toolDef.name}`,
+        input_schema: toolDef.inputSchema || { type: 'object', properties: {} },
+        async run(args) {
+          const srv = _servers.get(serverName);
+          if (!srv) return `Error: MCP server "${serverName}" is not connected`;
+          try {
+            const result = await sendRequest(srv, 'tools/call', {
+              name: toolDef.name,
+              arguments: args
+            });
+            // MCP content blocks: [{ type: "text", text: "..." }, { type: "image", ... }]
+            const content = result?.content || [];
+            if (content.length === 0) return '(empty result)';
+            return content
+              .map(block => {
+                if (block.type === 'text') return block.text;
+                if (block.type === 'image') return `[image: ${block.mimeType || 'unknown'}]`;
+                return JSON.stringify(block);
+              })
+              .join('\n');
+          } catch (e) {
+            return `Error: ${e.message}`;
+          }
+        }
+      });
+    }
+  }
+
+  return toolObjects;
+}
+
+/**
+ * Returns status of all connected servers for /mcp command.
+ */
+export function getMcpStatus() {
+  if (_servers.size === 0) return [];
+  return Array.from(_servers.entries()).map(([name, server]) => ({
+    name,
+    toolCount: server.tools.length,
+    tools: server.tools.map(t => ({ name: t.name, description: (t.description || '').slice(0, 80) }))
+  }));
+}
+
+/**
+ * Returns config file path for user reference.
+ */
+export function getMcpConfigPath() {
+  return MCP_CONFIG_PATH;
+}
+
+/**
+ * Kill all child processes on exit.
+ */
+export function disconnectAll() {
+  for (const [, server] of _servers) {
+    try { server.process.kill('SIGTERM'); } catch {}
+  }
+  _servers.clear();
+}

package/lib/tools.js

@@ -642,10 +642,54 @@ Example:
   }
 };
 
+// ── KAIROS TOOL ───────────────────────────────────────────────────────────────
+export const KairosTool = {
+  name: 'Kairos',
+  description: `Schedule a background task to run automatically. Tasks are stored persistently and checked each time Tsunami Code starts.
+
+Use for:
+- "Run this check every morning"
+- "Remind me to do X next time I open this project"
+- "Watch for Y and alert me when it changes"
+
+Schedules: 'once' | 'hourly' | 'daily' | 'HH:MM' (daily at specific time)`,
+  input_schema: {
+    type: 'object',
+    properties: {
+      prompt:   { type: 'string', description: 'The task prompt to run when triggered' },
+      schedule: { type: 'string', description: "When to run: 'once', 'hourly', 'daily', or 'HH:MM'", default: 'once' }
+    },
+    required: ['prompt']
+  },
+  async run({ prompt, schedule = 'once' }) {
+    try {
+      const { scheduleTask } = await import('./kairos.js');
+      const id = scheduleTask(prompt, schedule);
+      return `Task scheduled [${id}] — will run ${schedule}. View with /kairos.`;
+    } catch (e) {
+      return `Error scheduling task: ${e.message}`;
+    }
+  }
+};
+
 export const ALL_TOOLS = [
   BashTool, ReadTool, WriteTool, EditTool, GlobTool, GrepTool,
   NoteTool, CheckpointTool,
   WebFetchTool, WebSearchTool,
   TodoWriteTool, AskUserTool,
-  AgentTool, SnipTool, BriefTool
+  AgentTool, SnipTool, BriefTool,
+  KairosTool
 ];
+
+/**
+ * Register MCP tool objects into the live tool list.
+ * Called after MCP servers connect so the agent loop sees them immediately.
+ */
+export function registerMcpTools(mcpToolObjects) {
+  for (const tool of mcpToolObjects) {
+    // Don't double-register if reconnecting
+    if (!ALL_TOOLS.find(t => t.name === tool.name)) {
+      ALL_TOOLS.push(tool);
+    }
+  }
+}

package/package.json

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