parallelclaw 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 Notable changes to parallelclaw (formerly memex-mvp). Older history lives in the git log.
 
+## 1.2.0 — delegate by talking + the laptop as executor
+
+Coordination, now from natural language. Two MCP tools so any MCP client (Claude
+Code, Cursor, OpenClaw) can delegate and check on work without touching the CLI:
+- **`parallelclaw_delegate`** `{prompt, to, kind, content}` — hand a task to
+  another of your agents. Fired when you say "tell Kimi to …", "delegate this to
+  the VPS agent", "have X do this while I'm away". `to:"any"` broadcasts.
+- **`parallelclaw_tasks`** `{filter: mine|inbox|results|all, status, limit}` —
+  status of what you delegated, your inbox, or completed answers.
+
+SERVER_INSTRUCTIONS gained an "AGENT COORDINATION" recipe so the agent recognizes
+the delegation intent and surfaces results from the SessionStart 📥 block.
+
+### Mac headless executor (Phase 2b) — the laptop runs delegated tasks too
+`lib/executor.js` + `task-executor install|uninstall|status` / `task-run-once`:
+a launchd timer drains the inbox while the Mac is awake, running each claimed
+safe-kind task through `claude -p` and writing the result back — closing any↔any
+auto-coordination both directions. Selective-auto: only SAFE_KINDS (research /
+content / test / general / review / summarize / analysis) auto-run, addressed-to-me
+only unless `--any`; the exec prompt forbids destructive actions and `claude -p`
+runs without `--dangerously-skip-permissions`. Honest limit: only while awake.
+The always-on cron-prompt flow stays the path for Linux/VPS nodes
+(`docs/design/executor-prompt.md`). Hands-off loop live-proven on the Mac↔Kimi mesh.
+
 ## 1.1.0 — agent coordination: hardened task ledger + executor + result-routing
 
 The first release where the **coordination layer works end-to-end**: one of your

package/ingest.js

@@ -159,6 +159,9 @@ if (subcommand && subcommand !== '--help' && subcommand.startsWith('-') === fals
     'task-claim':    async () => (await import('./lib/tasks.js')).cmdTaskClaim(),
     'task-update':   async () => (await import('./lib/tasks.js')).cmdTaskUpdate(),
     'task-results':  async () => (await import('./lib/tasks.js')).cmdTaskResults(),
+    // Phase 2b — Mac headless executor (run delegated inbox tasks via `claude -p`)
+    'task-run-once': async () => (await import('./lib/executor.js')).cmdTaskRunOnce(),
+    'task-executor': async () => (await import('./lib/executor.js')).cmdTaskExecutor(),
     serve: cmdServe, // explicit foreground; same as no-arg
     // All scan / export modes fall through to module-level logic at EOF.
     // cmdServe is a no-op marker so the dispatch doesn't error.

package/lib/executor.js

@@ -0,0 +1,238 @@
+/**
+ * Mac headless executor (Phase 2b).
+ *
+ * Lets THIS node (a laptop running Claude Code) be an executor too: while the
+ * Mac is awake, a launchd timer drains the ParallelClaw inbox by running each
+ * claimed task through `claude -p` (headless Claude Code) and writing the result
+ * back. The always-on nodes (Kimi/OpenClaw) use the cron-PROMPT instead
+ * (docs/design/executor-prompt.md); this is the code path for the laptop.
+ *
+ * Honest limit: launchd StartInterval only fires while the Mac is awake — a
+ * sleeping laptop simply doesn't run, and the task WAITS in the ledger. There is
+ * no cloud Claude Code, so "run it now while my laptop is closed" can't happen.
+ *
+ * Safety (selective-auto): only tasks whose `kind` is in SAFE_KINDS auto-run,
+ * and (by default) only those addressed to me — broadcasts ("any") are left for
+ * the always-on nodes unless --any is passed. The exec prompt forbids
+ * destructive/irreversible actions; `claude -p` runs WITHOUT
+ * --dangerously-skip-permissions, so risky tools are declined rather than
+ * silently performed.
+ */
+
+import { homedir, platform } from 'node:os';
+import { join, resolve } from 'node:path';
+import { writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { execFile, execSync } from 'node:child_process';
+
+import { getOrigin } from './config.js';
+import { listTasks, claimTask, updateTask } from './tasks.js';
+
+const HOME = homedir();
+const MEMEX_DIR = process.env.MEMEX_DIR || join(HOME, '.memex');
+const DATA = join(MEMEX_DIR, 'data');
+
+const EXEC_LABEL = 'com.parallelclaw.memex.executor';
+const EXEC_PLIST = join(HOME, 'Library', 'LaunchAgents', `${EXEC_LABEL}.plist`);
+const EXEC_OUT_LOG = join(DATA, 'executor.out.log');
+const EXEC_ERR_LOG = join(DATA, 'executor.err.log');
+
+// Auto-runnable task classes. Read/produce-text work is safe to run unattended;
+// anything that mutates another machine's state is intentionally absent and is
+// left in the inbox for explicit handling (one-tap approval = future v1 UI).
+export const SAFE_KINDS = ['research', 'content', 'test', 'general', 'review', 'summarize', 'analysis'];
+
+const DEFAULT_TIMEOUT_MS = 240000; // 4 min — matches the always-on cron budget
+
+function buildExecPrompt(env) {
+  return [
+    'You are an autonomous ParallelClaw executor running headlessly via `claude -p`.',
+    'A task was delegated to you by another of the user\'s agents. Do it, then print ONLY the',
+    'result/output (no preamble, no "I will…").',
+    '',
+    'SAFETY: do NOT perform destructive or irreversible actions — no deploys, no git push/',
+    'force-push, no deleting or overwriting files outside a scratch directory, no spending, no',
+    'outbound messages. If the task genuinely requires any of that, instead print exactly what',
+    'needs human approval and stop.',
+    '',
+    `TASK (kind: ${env.kind || 'general'}, from: ${env.from || '?'}):`,
+    env.prompt || '',
+    env.content ? `\nADDITIONAL CONTEXT:\n${env.content}` : '',
+  ].join('\n');
+}
+
+/** Default runner: headless `claude -p`. Returns stdout; rejects on error/timeout. */
+function claudeRunner(prompt, { timeoutMs = DEFAULT_TIMEOUT_MS, cwd } = {}) {
+  return new Promise((res, rej) => {
+    const bin = process.env.PARALLELCLAW_CLAUDE_BIN || 'claude';
+    execFile(bin, ['-p', prompt],
+      { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024, encoding: 'utf8', cwd: cwd || DATA },
+      (err, stdout, stderr) => {
+        if (err) {
+          if (err.killed) return rej(new Error(`claude -p timed out after ${timeoutMs}ms`));
+          return rej(new Error(String(stderr || err.message).slice(0, 300)));
+        }
+        res(String(stdout || '').trim());
+      });
+  });
+}
+
+/**
+ * One drain pass over the inbox. opts:
+ *   db?            — shared connection (else opens its own writable handle)
+ *   runner?        — async (prompt, {timeoutMs}) => string (default: claude -p) — injectable for tests
+ *   allowKinds?    — auto-run allowlist (default SAFE_KINDS)
+ *   includeBroadcast? — also take to:'any' tasks (default false — leave for always-on nodes)
+ *   timeoutMs?, now?, log?
+ * Returns [{ id, status, skipped? }] for what it acted on.
+ */
+export async function runInboxOnce({
+  db = null, runner = null, allowKinds = SAFE_KINDS, includeBroadcast = false,
+  timeoutMs = DEFAULT_TIMEOUT_MS, now = Date.now(), log = () => {},
+} = {}) {
+  const me = getOrigin();
+  const exec = runner || claudeRunner;
+  const acted = [];
+  let inbox = listTasks({ inbox: true, db, limit: 50 });
+  inbox = inbox.filter((t) => t.to === me || (includeBroadcast && t.to === 'any'));
+  for (const t of inbox) {
+    if (!allowKinds.includes(t.kind)) {
+      log(`skip ${t.id}: kind '${t.kind}' not in auto-allowlist (left for one-tap)`);
+      acted.push({ id: t.id, status: 'skipped', reason: 'kind' });
+      continue;
+    }
+    const claimed = claimTask(t.id, { db, now });
+    if (!claimed) { log(`skip ${t.id}: not claimable (taken/raced)`); acted.push({ id: t.id, status: 'skipped', reason: 'claim' }); continue; }
+    try {
+      const out = await exec(buildExecPrompt(claimed), { timeoutMs });
+      const result = (out && String(out).trim()) || '(executor produced no output)';
+      updateTask(t.id, 'done', { result, db });
+      log(`done ${t.id}`);
+      acted.push({ id: t.id, status: 'done' });
+    } catch (e) {
+      updateTask(t.id, 'failed', { result: `executor error: ${e.message}`.slice(0, 500), db });
+      log(`failed ${t.id}: ${e.message}`);
+      acted.push({ id: t.id, status: 'failed' });
+    }
+  }
+  return acted;
+}
+
+// ── launchd (macOS) — run one drain pass every N min while awake ──────────────
+
+function resolveClaudeBin() {
+  try { return execSync('command -v claude', { encoding: 'utf8' }).trim() || 'claude'; }
+  catch (_) { return 'claude'; }
+}
+
+export function buildExecutorLaunchAgentPlist({ script, mins, nodePath, claudeBin, includeBroadcast }) {
+  const interval = Math.max(60, Math.floor(mins * 60));
+  const argv = [nodePath, script, 'task-run-once'];
+  if (includeBroadcast) argv.push('--any');
+  const argXml = argv.map((a) => `    <string>${a}</string>`).join('\n');
+  // launchd's PATH is minimal and excludes /opt/homebrew/bin where `claude`
+  // usually lives — bake an explicit PATH + the resolved claude path so the
+  // headless run finds it. (Same class of bug as the brew `timeout` PATH trap.)
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${EXEC_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argXml}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key><string>${HOME}</string>
+    <key>MEMEX_DIR</key><string>${MEMEX_DIR}</string>
+    <key>PARALLELCLAW_CLAUDE_BIN</key><string>${claudeBin}</string>
+    <key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>${interval}</integer>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${EXEC_OUT_LOG}</string>
+  <key>StandardErrorPath</key><string>${EXEC_ERR_LOG}</string>
+  <key>WorkingDirectory</key><string>${resolve(script, '..')}</string>
+</dict>
+</plist>
+`;
+}
+
+export function installExecutor({ scriptPath, everyMinutes = 10, nodePath = process.execPath, includeBroadcast = false } = {}) {
+  if (platform() !== 'darwin') {
+    throw new Error('The headless executor service is macOS-only. On an always-on Linux node, use the cron-prompt in docs/design/executor-prompt.md instead.');
+  }
+  const script = resolve(scriptPath || process.argv[1]);
+  if (!existsSync(script)) throw new Error(`installExecutor: script not found at ${script}`);
+  const mins = Math.max(1, Math.floor(Number(everyMinutes) || 10));
+  const claudeBin = resolveClaudeBin();
+  mkdirSync(DATA, { recursive: true });
+  mkdirSync(join(HOME, 'Library', 'LaunchAgents'), { recursive: true });
+  const plist = buildExecutorLaunchAgentPlist({ script, mins, nodePath, claudeBin, includeBroadcast });
+  try { execSync(`launchctl unload ${JSON.stringify(EXEC_PLIST)}`, { stdio: 'ignore' }); } catch (_) {}
+  writeFileSync(EXEC_PLIST, plist);
+  execSync(`launchctl load ${JSON.stringify(EXEC_PLIST)}`, { stdio: 'inherit' });
+  return { platform: 'darwin', unitPath: EXEC_PLIST, everyMinutes: mins, claudeBin, includeBroadcast };
+}
+
+export function uninstallExecutor() {
+  if (platform() !== 'darwin') return { platform: platform(), unitPath: null };
+  try { execSync(`launchctl unload ${JSON.stringify(EXEC_PLIST)}`, { stdio: 'ignore' }); } catch (_) {}
+  if (existsSync(EXEC_PLIST)) unlinkSync(EXEC_PLIST);
+  return { platform: 'darwin', unitPath: EXEC_PLIST };
+}
+
+export function executorStatus() {
+  if (platform() !== 'darwin') return { installed: false, running: false, manager: 'none' };
+  const installed = existsSync(EXEC_PLIST);
+  let running = false, detail = '';
+  if (installed) {
+    try {
+      const out = execSync(`launchctl list 2>/dev/null | grep ${EXEC_LABEL} || true`, { encoding: 'utf8' });
+      running = out.trim().length > 0; detail = out.trim();
+    } catch (_) {}
+  }
+  return { installed, running, manager: 'launchd', unitPath: EXEC_PLIST, detail };
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────────────
+
+export async function cmdTaskRunOnce() {
+  const argv = process.argv.slice(3);
+  const includeBroadcast = argv.includes('--any');
+  const acted = await runInboxOnce({ includeBroadcast, log: (m) => console.error(`[executor] ${m}`) });
+  const ran = acted.filter((a) => a.status === 'done' || a.status === 'failed');
+  if (!ran.length) { console.log('executor: nothing to run.'); process.exit(0); }
+  for (const r of ran) console.log(`${r.status === 'done' ? '✓' : '✗'} ${r.id} ${r.status}`);
+  process.exit(0);
+}
+
+export function cmdTaskExecutor() {
+  const sub = process.argv[3];
+  const argv = process.argv.slice(4);
+  const getOpt = (flag, def) => { const i = argv.indexOf(flag); return i >= 0 && argv[i + 1] ? argv[i + 1] : def; };
+  try {
+    if (sub === 'install') {
+      const r = installExecutor({
+        everyMinutes: parseInt(getOpt('--every', '10'), 10) || 10,
+        includeBroadcast: argv.includes('--any'),
+      });
+      console.log(`✓ Mac executor installed (every ${r.everyMinutes}m while awake).`);
+      console.log(`  claude: ${r.claudeBin}   broadcast tasks: ${r.includeBroadcast ? 'yes' : 'no (addressed-only)'}`);
+      console.log(`  auto-runs kinds: ${SAFE_KINDS.join(', ')} — others wait in the inbox.`);
+      console.log(`  unit: ${r.unitPath}`);
+    } else if (sub === 'uninstall') {
+      uninstallExecutor(); console.log('✓ Mac executor uninstalled (tasks/data preserved).');
+    } else if (sub === 'status') {
+      const s = executorStatus();
+      console.log(`executor: installed=${s.installed} running=${s.running} (${s.manager})`);
+      if (s.detail) console.log(`  ${s.detail}`);
+    } else {
+      console.error('usage: task-executor <install|uninstall|status> [--every <min>] [--any]');
+      process.exit(2);
+    }
+  } catch (e) { console.error(`✗ ${e.message}`); process.exit(1); }
+  process.exit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallelclaw",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Local-first personal AI ops layer. Shared verbatim memory across your agents (Claude Code, Cursor, OpenClaw, Hermes, Obsidian, Telegram) in one SQLite + FTS5 corpus — plus a coordination layer where any of your agents can delegate tasks to any other. Searchable from any MCP-compatible client.",
   "type": "module",
   "main": "server.js",
@@ -31,7 +31,7 @@
     "sync": "node ingest.js",
     "ingest": "node ingest.js",
     "bot": "node bot/index.js",
-    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/get-conversation-paging.test.js && node test/search-filters.test.js && node test/origin.test.js && node test/tasks.test.js && node test/store-document.test.js && node test/cli.test.js && node test/hook.test.js && node test/telegram-html.test.js && node test/telegram-decisions.test.js && node test/telegram-pending.test.js && node test/telegram-notify.test.js && node test/notify-click-action.test.js && node test/inbox-watcher.test.js && node test/e2e-inbox.test.js && node test/ingest-file.test.js && node test/openclaw-channel.test.js && node test/openclaw-channel-e2e.test.js && node test/wire-openclaw.test.js && node test/sync/server-bootstrap.test.js && node test/sync/push-pull-roundtrip.test.js && node test/sync/cli-end-to-end.test.js && node test/sync/adaptive-batch.test.js && node test/sync/service.test.js && node test/sync/skip-accounting.test.js && node test/sync/pair.test.js && node test/sync/join-token.test.js && node test/sync/tunnel-service.test.js && node test/sync/mcp-invite.test.js && node test/sync/skip-accounting.test.js",
+    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/get-conversation-paging.test.js && node test/search-filters.test.js && node test/origin.test.js && node test/tasks.test.js && node test/executor.test.js && node test/store-document.test.js && node test/cli.test.js && node test/hook.test.js && node test/telegram-html.test.js && node test/telegram-decisions.test.js && node test/telegram-pending.test.js && node test/telegram-notify.test.js && node test/notify-click-action.test.js && node test/inbox-watcher.test.js && node test/e2e-inbox.test.js && node test/ingest-file.test.js && node test/openclaw-channel.test.js && node test/openclaw-channel-e2e.test.js && node test/wire-openclaw.test.js && node test/sync/server-bootstrap.test.js && node test/sync/push-pull-roundtrip.test.js && node test/sync/cli-end-to-end.test.js && node test/sync/adaptive-batch.test.js && node test/sync/service.test.js && node test/sync/skip-accounting.test.js && node test/sync/pair.test.js && node test/sync/join-token.test.js && node test/sync/tunnel-service.test.js && node test/sync/mcp-invite.test.js && node test/sync/skip-accounting.test.js",
     "prepublishOnly": "npm test"
   },
   "engines": {

package/server.js

@@ -44,6 +44,7 @@ import {
   KNOWN_SOURCES,
   CONFIG_PATH,
 } from './lib/config.js';
+import { createTask, listTasks, listTaskResults } from './lib/tasks.js';
 import {
   canonicalize as canonicalizeUrl,
   extractDomain,
@@ -1329,6 +1330,18 @@ This merges main + subagent messages in chronological order with a
   titles. Compare short_ids and date ranges before concluding duplicate.
 - Re-imports are idempotent (UNIQUE on msg_id, recount-on-upsert).
 
+══ AGENT COORDINATION (delegate tasks across your agents) ══
+
+ParallelClaw isn't only memory — your agents can hand tasks to each other over
+the same synced ledger. When the user says "tell Kimi to …", "ask the VPS agent
+to …", "delegate this to <agent>", or "have <agent> do X while I'm away":
+  → call parallelclaw_delegate({ prompt, to: "<agent>" })   (to:"any" = broadcast)
+The target agent claims it (atomic — never double-run) and runs it when
+available; the answer returns to you. To check delegated work or surface answers,
+call parallelclaw_tasks (filter: mine / inbox / results). Newly-finished results
+also appear automatically in this session's "📥 results from tasks you delegated"
+block. Don't shell out to raw SQL or the task-* CLI from here — use these tools.
+
 ══ CONVENTIONS ══
 
 - BE PROACTIVE. If past context would sharpen your answer, pull it
@@ -1985,6 +1998,43 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'parallelclaw_delegate',
+    description:
+      'Hand a task to ANOTHER of the user\'s agents (cross-tool, cross-machine) via the shared ParallelClaw ledger. ' +
+      'CALL THIS when the user says "tell Kimi to …", "ask the VPS agent to …", "delegate this to <agent>", ' +
+      '"have <agent> do X while I\'m away", or when an always-on agent should run bulk/long work. The task is ' +
+      'written to the synced ledger; the target agent claims and runs it when available, and the result returns ' +
+      'to you (your next session\'s 📥 block, or via parallelclaw_tasks filter:"results"). Set `to` to the target ' +
+      'node\'s origin label (e.g. "kimi", "vps1"); omit or "any" to broadcast to whichever always-on agent grabs ' +
+      'it first. Destructive cross-machine actions are NOT auto-run — state that in the prompt.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'What the other agent should do — self-contained; it has no access to this conversation.' },
+        to: { type: 'string', default: 'any', description: 'Target agent origin label (e.g. "kimi", "vps1"), or "any" to broadcast.' },
+        kind: { type: 'string', default: 'general', description: 'Task class hint: research / code / content / test / …' },
+        content: { type: 'string', description: 'Optional extra context/material to carry with the task.' },
+      },
+      required: ['prompt'],
+    },
+  },
+  {
+    name: 'parallelclaw_tasks',
+    description:
+      'Check the ParallelClaw task ledger. filter="mine" (default): tasks you delegated + their status/result; ' +
+      '"inbox": tasks waiting for THIS node to run; "results": completed answers to your delegations; "all": ' +
+      'everything. Use after parallelclaw_delegate to see whether the other agent finished, or to surface results.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        filter: { type: 'string', enum: ['mine', 'inbox', 'results', 'all'], default: 'mine' },
+        status: { type: 'string', enum: ['submitted', 'working', 'done', 'failed'], description: 'Optional status filter.' },
+        limit: { type: 'integer', default: 20, minimum: 1, maximum: 100 },
+        format: { type: 'string', enum: ['markdown', 'json'], default: 'markdown' },
+      },
+    },
+  },
 ];
 
 // v0.11.11 experimental sync — expose the one-paste pairing tool ONLY when
@@ -3575,6 +3625,41 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       });
     }
 
+    if (name === 'parallelclaw_delegate') {
+      const prompt = typeof args.prompt === 'string' ? args.prompt.trim() : '';
+      if (!prompt) return textResult('parallelclaw_delegate: `prompt` is required (what should the other agent do?).');
+      const to = (typeof args.to === 'string' && args.to.trim()) ? args.to.trim().toLowerCase() : 'any';
+      const kind = (typeof args.kind === 'string' && args.kind.trim()) ? args.kind.trim() : 'general';
+      const content = typeof args.content === 'string' ? args.content : null;
+      const { id } = createTask({ prompt, to, kind, content });
+      return textResult(
+        `✓ Delegated task \`${id}\` → **${to}** (from ${getOrigin()}).\n` +
+        `Runs when ${to === 'any' ? 'an always-on agent' : to} is available; the result returns to you ` +
+        `(next session's 📥 block, or parallelclaw_tasks filter:"results").`
+      );
+    }
+
+    if (name === 'parallelclaw_tasks') {
+      const filter = ['mine', 'inbox', 'results', 'all'].includes(args.filter) ? args.filter : 'mine';
+      const limit = Math.min(100, Math.max(1, args.limit || 20));
+      const statusFilter = ['submitted', 'working', 'done', 'failed'].includes(args.status) ? args.status : null;
+      let rows;
+      if (filter === 'results') rows = listTaskResults({});
+      else if (filter === 'inbox') rows = listTasks({ inbox: true, limit });
+      else if (filter === 'mine') rows = listTasks({ mine: true, status: statusFilter, limit });
+      else rows = listTasks({ status: statusFilter, limit });
+      if (pickFormat(args) === 'json') return jsonResult({ filter, count: rows.length, tasks: rows });
+      if (!rows.length) return textResult(`No tasks (filter: ${filter}).`);
+      const icon = { submitted: '○', working: '◐', done: '✓', failed: '✗' };
+      const lines = [`ParallelClaw tasks (${filter}):`, ''];
+      for (const t of rows) {
+        lines.push(`${icon[t.status] || '?'} \`${t.id}\`  ${t.from} → ${t.to}  [${t.status}]`);
+        lines.push(`    ${String(t.prompt || '').slice(0, 90)}`);
+        if (t.result) lines.push(`    └ result: ${String(t.result).slice(0, 200)}`);
+      }
+      return textResult(lines.join('\n'));
+    }
+
     return textResult(`Unknown tool: ${name}`);
   } catch (err) {
     log('tool error:', name, err.message);