tsunami-code 3.0.0 → 3.2.0

package/index.js

@@ -6,6 +6,9 @@ import { join } from 'path';
 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';
@@ -21,7 +24,7 @@ import {
   getSessionContext
 } from './lib/memory.js';
 
-const VERSION = '3.0.0';
+const VERSION = '3.2.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';
@@ -173,6 +176,9 @@ async function run() {
   initProjectMemory(cwd);
   setSession({ sessionDir, cwd });
 
+  // Load skills
+  let skills = loadSkills(cwd);
+
   // Inject server context into AgentTool
   injectServerContext(serverUrl, buildSystemPrompt());
 
@@ -219,6 +225,31 @@ async function run() {
     dim(` · ${sessionId} · Type your task. /help for commands. Ctrl+C to exit.\n`)
   );
 
+  // 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);
 
@@ -407,6 +438,30 @@ async function run() {
       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'));
@@ -515,6 +570,32 @@ 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'));
+          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; }
@@ -539,13 +620,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

@@ -237,11 +237,15 @@ async function streamCompletion(serverUrl, messages, onToken, memoryContext = ''
         fullContent += token;
         onToken(token);
       }
-      // Capture real token counts from usage field (sent on final chunk by llama.cpp)
+      // 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;
       }
     }
   }
@@ -315,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 = [];

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

@@ -642,10 +642,41 @@ 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
 ];

package/package.json

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