@amenophis1er/foreman 0.1.12 → 0.1.14

package/README.md

@@ -230,12 +230,36 @@ result.
 ```sh
 npm ci && npm run setup      # dependencies, then the dashboard build
 npm start                    # serves http://localhost:4177
-npm test                     # 365 tests, node:test
+npm test                     # 379 tests, node:test
 npm run typecheck            # server and dashboard
 npm run dev                  # API + Vite together
 scripts/dev-restart.sh       # restarts the server only when nothing would be lost
 ```
 
+## Use Foreman from another agent
+
+`foreman mcp` serves Foreman's tools over stdio, so a Claude Code session, Codex
+or Antigravity can watch and launch missions without a polling loop:
+
+```sh
+claude mcp add foreman -- foreman mcp
+codex mcp add foreman -- foreman mcp
+agy mcp add foreman -- foreman mcp
+```
+
+Tools: `fleet_status`, `list_runs`, `run_status` (with `wait_seconds` and
+`until`: one call that blocks until the run changes, finishes, or needs you),
+`run_report` (a finished run in one call: the director's report, DONE WHEN,
+changed files, branch and pull request), `run_transcript`, `mission_doc`,
+`project_memory`, `search_runs`, `doctor`, `link_project` (folder or Git URL),
+`start_mission`, `steer`. Start, wait until finished, read the report: three calls. It talks to the running server at `FOREMAN_URL`
+(default `http://localhost:4177`) and has no logic of its own.
+
+Deliberately absent: approving or denying, answering the director's questions,
+interrupt, resume, raising a budget, opening a pull request, settings and keys.
+Those are the moments Foreman exists to put a human in; `run_status` says when
+a run needs one, and with what, so the agent's job is to send you to decide.
+
 To run a checkout beside an installed Foreman on the same machine, give it its
 own port and leave the bot to the installed one:
 

package/bin/foreman.mjs

@@ -34,6 +34,7 @@ const USAGE = `foreman ${pkg.version}
   foreman uninstall          Remove the service and the background server; keeps ~/.foreman
   foreman uninstall --purge --yes   …and delete ~/.foreman (every run's history) too
   foreman completion install Tab-completion for these commands (zsh, bash, fish); or "completion zsh" to print it
+  foreman mcp                Serve Foreman's tools to another agent over stdio (claude mcp add foreman -- foreman mcp)
   foreman --version | --help
 
 Environment:
@@ -56,7 +57,7 @@ if (command === '--help' || command === '-h' || command === 'help') {
 } else if (command === 'start') {
   register();
   await import(new URL('../src/server.ts', import.meta.url).href);
-} else if (['doctor', 'open', 'service', 'up', 'down', 'stop', 'restart', 'status', 'logs', 'uninstall', 'update', 'completion'].includes(command)) {
+} else if (['doctor', 'open', 'service', 'up', 'down', 'stop', 'restart', 'status', 'logs', 'uninstall', 'update', 'completion', 'mcp'].includes(command)) {
   register();
   const { runCli } = await import(new URL('../src/cli.ts', import.meta.url).href);
   process.exitCode = await runCli(command, rest, { version: pkg.version, bin: new URL(import.meta.url) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amenophis1er/foreman",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Autonomous mission runner on the Claude Agent SDK: a director plans, delegates to workers, verifies, and reports — from one dashboard, your phone, or the CLI.",
   "keywords": [
     "claude",
@@ -51,6 +51,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.259",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "@playwright/mcp": "^0.0.80",
     "qrcode": "^1.5.4",
     "tsx": "^4.23.13",

package/skills/director/SKILL.md

@@ -5,6 +5,11 @@ description: Kick off a Foreman mission for the current project — ensures the
 
 # /director — launch a Foreman mission from this session
 
+> Prefer the MCP: `claude mcp add foreman -- foreman mcp` gives this session
+> `start_mission`, `run_status` (with a wait, so no polling) and the rest as
+> tools, with the same governance. The steps below are the curl fallback for a
+> session without it.
+
 You are the launcher only. The mission itself runs in Foreman's own director
 and worker sessions with budgets, approval cards, and MISSION.md governance;
 the human supervises from the dashboard, not from this session. Do NOT do the

package/src/cli.ts

@@ -498,6 +498,13 @@ export async function runCli(command: string, rest: string[], ctx: { version: st
     case 'uninstall': return uninstall(rest);
     case 'status': return status();
     case 'doctor': return doctor();
+    case 'mcp': {
+      // Stdio is the protocol channel: nothing else may print there.
+      const { serveMcp } = await import('./mcp.js');
+      await serveMcp();
+      await new Promise(() => {}); // until the client closes the pipe
+      return 0;
+    }
     case 'completion': {
       const { completionScript, detectShell, installCompletion } = await import('./completion.js');
       const arg = rest[0];

package/src/completion.ts

@@ -25,6 +25,7 @@ export const COMMANDS: Array<[string, string]> = [
   ['service', 'Keep Foreman running at login'],
   ['uninstall', 'Remove the service and the background server'],
   ['completion', 'Shell completion: zsh, bash, fish, or install'],
+  ['mcp', 'Serve Foreman\'s tools to another agent over stdio'],
   ['help', 'Show usage'],
   ['version', 'Print the version'],
 ];

package/src/deck.ts

@@ -847,7 +847,7 @@ function sendJson(res: ServerResponse, code: number, body: unknown): void {
  */
 export async function handleDeckRoute(
   req: IncomingMessage, res: ServerResponse, url: URL,
-  lookup: (scope: 'runs' | 'projects', id: string) => Promise<{ folder: string } | null>,
+  lookup: (scope: 'runs' | 'projects', id: string) => Promise<{ folder: string; deck?: Deck } | null>,
 ): Promise<boolean> {
   // The same jail and the same viewer serve two scopes: a run (its deck,
   // relative to a baseline) and a project (its tree as it stands, no baseline).
@@ -863,7 +863,9 @@ export async function handleDeckRoute(
     if (!run) { sendJson(res, 404, { error: 'not found' }); return true; }
 
     if (what === 'deck') {
-      sendJson(res, 200, await deckFor(run.folder, runId));
+      // A finished run's deck is the one frozen when it ended (snapshot.ts);
+      // the caller hands it over. A running run is diffed live.
+      sendJson(res, 200, run.deck ?? await deckFor(run.folder, runId));
       return true;
     }
     if (what === 'tree') {

package/src/gitwork.test.ts

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { mkdtemp, writeFile } from 'node:fs/promises';
-import { closeMissionBranch, ensureMissionBranch, gitInfo, missionBranchName, startMissionBranch } from './gitwork.js';
+import { closeMissionBranch, ensureMissionBranch, gitInfo, missionBranchName, startMissionBranch, renameMissionBranch } from './gitwork.js';
 
 const sh = (cwd: string, ...args: string[]) => execFileSync('git', args, { cwd, stdio: 'pipe', env: { ...process.env, GIT_CONFIG_GLOBAL: '/dev/null' } }).toString();
 
@@ -93,3 +93,18 @@ test('prDraft: the run title, the brief, the boxes as the mission left them, and
   assert.match(d.body, /## Done when\n\n- \[x\] footer\.html exists\n- \[ \] linked from index/);
   assert.match(d.body, /branch `foreman\/add-a-footer-ab12` from `main` · spend \$0\.42/);
 });
+
+
+test('renameMissionBranch takes the run title once there is one, and leaves a branch that moved on', async () => {
+  const dir = await repo();
+  const g = await startMissionBranch(dir, 'Repo: this folder is a git worktree. Do the thing.', '1788713434983-226123af');
+  assert.ok(!('error' in g));
+  assert.equal(g.branch, 'foreman/repo-this-folder-is-a-git-23af');
+  const renamed = await renameMissionBranch(dir, g.branch, 'Studio data sanitization and null handling', '1788713434983-226123af');
+  assert.equal(renamed, 'foreman/studio-data-sanitization-and-null-23af');
+  assert.equal(sh(dir, 'rev-parse', '--abbrev-ref', 'HEAD').trim(), renamed);
+  // Same name again: nothing to do. Not on the branch any more: left alone.
+  assert.equal(await renameMissionBranch(dir, renamed!, 'Studio data sanitization and null handling', '1788713434983-226123af'), null);
+  sh(dir, 'checkout', '-q', 'main');
+  assert.equal(await renameMissionBranch(dir, renamed!, 'Another title', '1788713434983-226123af'), null);
+});

package/src/gitwork.ts

@@ -70,7 +70,12 @@ export async function gitInfo(folder: string): Promise<GitInfo> {
 /** `foreman/<first words of the brief>-<id tail>`: readable in `git branch`, unique per run. */
 export function missionBranchName(mission: string, runId: string): string {
   const first = mission.split('\n').find((l) => l.trim())?.trim() ?? 'mission';
-  const slug = first.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').split('-').filter(Boolean).slice(0, 6).join('-').slice(0, 40).replace(/-+$/, '') || 'mission';
+  // Whole words up to six and forty characters: a name cut mid-word
+  // ("null-handli") reads worse than a shorter one.
+  const words = first.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').split('-').filter(Boolean).slice(0, 6);
+  let slug = '';
+  for (const w of words) { const next = slug ? `${slug}-${w}` : w; if (next.length > 40) break; slug = next; }
+  slug = slug || words[0]?.slice(0, 40) || 'mission';
   const tail = runId.replace(/[^a-z0-9]/gi, '').slice(-4).toLowerCase();
   return `foreman/${slug}-${tail}`;
 }
@@ -92,6 +97,27 @@ export async function startMissionBranch(folder: string, mission: string, runId:
   return { branch, base: info.branch ?? 'HEAD', baseHead: info.head ?? null };
 }
 
+/**
+ * The branch takes the run's title once there is one. Branches are created
+ * before the title exists (the title is a model call that lands seconds
+ * later), so they started from the brief's first words — and briefs that all
+ * open with the same boilerplate gave every run the same name. Renamed in
+ * place, only while nothing has been committed on it and it is still checked
+ * out. Returns the new name, or null when it was left as it was.
+ */
+export async function renameMissionBranch(folder: string, from: string, title: string, runId: string): Promise<string | null> {
+  const to = missionBranchName(title, runId);
+  if (to === from) return null;
+  const info = await gitInfo(folder);
+  if (!info.repo || info.branch !== from) return null;
+  try {
+    await git(['branch', '-m', from, to], folder);
+    return to;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Back on the mission's branch for a resume. Returns null when already or
  * now there, else why not — a dirty tree that would be clobbered, typically.

package/src/mcp.test.ts

@@ -0,0 +1,181 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { doneWhen, eventLine, foremanTools, isForemanCheckout, waitForRunEvent } from './mcp.js';
+
+/** A Foreman server as the tools see it: routes answered from a table, requests recorded. */
+function fakeServer(routes: Record<string, unknown | ((body: unknown) => unknown)>) {
+  const calls: Array<{ method: string; path: string; body?: unknown }> = [];
+  const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = new URL(String(input));
+    const key = `${init?.method ?? 'GET'} ${url.pathname}${url.search}`;
+    const keyNoQuery = `${init?.method ?? 'GET'} ${url.pathname}`;
+    const body = init?.body ? JSON.parse(String(init.body)) : undefined;
+    calls.push({ method: init?.method ?? 'GET', path: url.pathname + url.search, body });
+    const hit = key in routes ? routes[key] : routes[keyNoQuery];
+    if (hit === undefined) return new Response(JSON.stringify({ error: 'not found' }), { status: 404 });
+    const val = typeof hit === 'function' ? (hit as (b: unknown) => unknown)(body) : hit;
+    if (val instanceof Response) return val;
+    return new Response(JSON.stringify(val), { status: 200, headers: { 'content-type': 'application/json' } });
+  }) as unknown as typeof fetch;
+  return { fetchImpl, calls };
+}
+
+const run = (o: Record<string, unknown> = {}) => ({
+  id: 'r1', projectId: 'p1', mission: 'Fix the thing', title: 'Fix', status: 'running', costUsd: 1.25, budgetUsd: 5,
+  costBasis: 'priced', createdAt: 1, directorModel: 'fable', workerModel: 'opus',
+  workers: [{ id: 'worker-1', status: 'done', costUsd: 0.4, task: 'write tests' }],
+  git: { branch: 'foreman/fix-r1', base: 'main' }, ...o,
+});
+const tool = (tools: ReturnType<typeof foremanTools>, name: string) => tools.find((t) => t.name === name)!;
+
+test('fleet_status reads /projects and says what needs a human', async () => {
+  const { fetchImpl } = fakeServer({
+    'GET /projects': { version: '0.1.12', projects: [
+      { id: 'p1', name: 'app', folder: '/x/app', activeRun: run(), lastRun: null, pendingPermissions: 1, pendingQuestions: 0, git: { branch: 'main' } },
+      { id: 'p2', name: 'lib', folder: '/x/lib', activeRun: null, lastRun: { id: 'r0', mission: 'Old', status: 'done', costUsd: 2, createdAt: 1 }, pendingPermissions: 0, pendingQuestions: 0 },
+    ] },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'fleet_status').run({});
+  assert.match(r.text, /app \(p1\).*main\n  running: r1 · running · \$1\.25 of \$5\.00/);
+  assert.match(r.text, /NEEDS YOU: 1 pending/);
+  assert.match(r.text, /lib \(p2\)[^\n]*\n  idle · last: done · \$2\.00/);
+});
+
+test('run_status: crew, DONE WHEN from the mission doc, needs, and no wait on a finished run', async () => {
+  const { fetchImpl, calls } = fakeServer({
+    'GET /runs': { runs: [run({ status: 'interrupted', stopReason: 'budget' })] },
+    'GET /projects': { projects: [{ id: 'p1', name: 'app', folder: '/x/app', activeRun: null, lastRun: null, needs: [] }] },
+    'GET /missiondoc': { doc: '# M\n## DONE WHEN\n- [x] tests pass\n- [ ] docs updated\n' },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'run_status').run({ runId: 'r1', wait_seconds: 30 });
+  assert.match(r.text, /stopped at its budget cap/);
+  assert.match(r.text, /DONE WHEN 1\/2\n  open: docs updated/);
+  assert.match(r.text, /worker-1 · done/);
+  assert.match(r.text, /^finished$/m);
+  assert.ok(!calls.some((c) => c.path.startsWith('/events')), 'a finished run is never waited on');
+});
+
+test('run_status with a wait returns when the run\'s picture changes, not on a bare event', async () => {
+  const sse = () => new ReadableStream<Uint8Array>({
+    start(c) {
+      const enc = new TextEncoder();
+      c.enqueue(enc.encode(': connected\n\n'));
+      c.enqueue(enc.encode('event: cost\ndata: {"runId":"other","projectId":"p9","data":{}}\n\n'));
+      c.enqueue(enc.encode('event: worker_started\ndata: {"runId":"r1","projectId":"p1","data":{"id":"worker-2"}}\n\n'));
+    },
+  });
+  let rounds = 0;
+  const { fetchImpl } = fakeServer({
+    // First round: an event, but the same run — no change. Second: a new worker.
+    'GET /runs': () => ({ runs: [run(rounds >= 2 ? { workers: [{ id: 'worker-1', status: 'done', costUsd: 0.4, task: 'write tests' }, { id: 'worker-2', status: 'running', costUsd: 0, task: 'more' }] } : {})] }),
+    'GET /projects': { projects: [{ id: 'p1', name: 'app', folder: '/x/app', activeRun: run(), needs: [{ kind: 'perm', id: 'a1', runId: 'r1', text: 'director wants Bash — rm -rf dist' }] }] },
+    'GET /missiondoc': { doc: '' },
+    'GET /events': () => { rounds += 1; return new Response(sse(), { status: 200, headers: { 'content-type': 'text/event-stream' } }); },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'run_status').run({ runId: 'r1', wait_seconds: 5 });
+  assert.match(r.text, /changed: yes/);
+  assert.ok(rounds >= 2, 'the first event changed nothing visible, so it kept waiting');
+  assert.match(r.text, /worker-2 · running/);
+  assert.match(r.text, /NEEDS YOU \(1\) — only a human can answer/);
+  assert.match(r.text, /\[perm\] director wants Bash/);
+});
+
+test('run_status until=finished waits through events that are not the end, and stops at the end', async () => {
+  // Two rounds: a cost tick (not finished) then the run turns done.
+  let rounds = 0;
+  const sseOnce = () => new ReadableStream<Uint8Array>({ start(c) { c.enqueue(new TextEncoder().encode('event: cost\ndata: {"runId":"r1","projectId":"p1","data":{}}\n\n')); } });
+  const { fetchImpl, calls } = fakeServer({
+    'GET /runs': () => ({ runs: [run({ status: rounds >= 2 ? 'done' : 'running' })] }),
+    'GET /projects': { projects: [{ id: 'p1', name: 'app', folder: '/x/app', activeRun: null, needs: [] }] },
+    'GET /missiondoc': { doc: '' },
+    'GET /events': () => { rounds += 1; return new Response(sseOnce(), { status: 200 }); },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'run_status').run({ runId: 'r1', wait_seconds: 10, until: 'finished' });
+  assert.match(r.text, /r1 · done/);
+  assert.match(r.text, /^finished$/m);
+  assert.ok(calls.filter((c) => c.path.startsWith('/events')).length >= 2, 'kept waiting past the first event');
+});
+
+test('run_status until=needs_you returns when an approval appears', async () => {
+  let asked = false;
+  const { fetchImpl } = fakeServer({
+    'GET /runs': { runs: [run()] },
+    'GET /projects': () => ({ projects: [{ id: 'p1', name: 'app', folder: '/x/app', activeRun: run(), needs: asked ? [{ kind: 'perm', id: 'a1', runId: 'r1', text: 'director wants Bash' }] : [] }] }),
+    'GET /missiondoc': { doc: '' },
+    'GET /events': () => { asked = true; return new Response(new ReadableStream<Uint8Array>({ start(c) { c.enqueue(new TextEncoder().encode('event: permission_request\ndata: {"runId":"r1","projectId":"p1","data":{}}\n\n')); } }), { status: 200 }); },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'run_status').run({ runId: 'r1', wait_seconds: 5, until: 'needs_you' });
+  assert.match(r.text, /^needs you$/m);
+  assert.match(r.text, /\[perm\] director wants Bash/);
+});
+
+test('run_report: the director\'s last words, DONE WHEN, changed files and the branch in one call', async () => {
+  const say = (agent: string, text: string) => ({ ts: 1, event: 'message', data: { agent, msg: { type: 'assistant', message: { content: [{ type: 'text', text }] } } } });
+  const { fetchImpl } = fakeServer({
+    'GET /runs': { runs: [run({ status: 'done', git: { branch: 'foreman/fix-r1', base: 'main', commits: 1, pr: 'https://github.com/o/r/pull/9', prState: 'merged' } })] },
+    'GET /runs/r1/events': { events: [say('director', 'Starting.'), say('worker-1', 'A long worker message that must not be mistaken for the report.'), say('director', 'All done: tests pass, docs updated, nothing left undone in this mission.')] },
+    'GET /missiondoc': { doc: '- [x] tests pass\n- [x] docs updated\n' },
+    'GET /runs/r1/deck': { baseline: { kind: 'git' }, files: [{ path: 'src/a.ts', status: 'modified', additions: 10, deletions: 2 }, { path: 'old.txt', status: 'modified', additions: 1, deletions: 1, preexisting: true }], artifacts: [{ path: 'shot.png', kind: 'image' }], totals: { files: 2, additions: 11, deletions: 3 } },
+  });
+  const r = await tool(foremanTools({ base: 'http://f', fetchImpl }), 'run_report').run({ runId: 'r1' });
+  assert.match(r.text, /branch foreman\/fix-r1 from main · 1 commit · PR https:\/\/github.com\/o\/r\/pull\/9 \(merged\)/);
+  assert.match(r.text, /DONE WHEN 2\/2/);
+  assert.match(r.text, /changed: 1 file · \+11 −3 · 1 screenshot · 1 already dirty before the run/);
+  assert.match(r.text, /modified src\/a\.ts  \+10 −2/);
+  assert.match(r.text, /Director's report:\nAll done: tests pass/);
+  assert.doesNotMatch(r.text, /worker message/);
+});
+
+test('waitForRunEvent gives up at the timeout when nothing arrives for the run', async () => {
+  const quiet = new ReadableStream<Uint8Array>({ start(c) { c.enqueue(new TextEncoder().encode(': connected\n\n')); } });
+  const { fetchImpl } = fakeServer({ 'GET /events': new Response(quiet, { status: 200 }) });
+  const t0 = Date.now();
+  assert.equal(await waitForRunEvent('http://f', 'r1', 1, fetchImpl), false);
+  assert.ok(Date.now() - t0 >= 900, 'waited about the timeout');
+});
+
+test('start_mission: 409 is a fact, the run id is read back, and Foreman itself is refused', async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'foreman-mcp-'));
+  const self = path.join(dir, 'foreman'); await mkdir(path.join(self, 'src'), { recursive: true });
+  await writeFile(path.join(self, 'package.json'), JSON.stringify({ name: 'x', bin: { foreman: 'bin/foreman.mjs' } }));
+  assert.equal(isForemanCheckout(self), true);
+  assert.equal(isForemanCheckout(dir), false);
+  let started = false;
+  const { fetchImpl, calls } = fakeServer({
+    'GET /projects': { projects: [{ id: 'p1', name: 'app', folder: dir, activeRun: null }, { id: 'pf', name: 'foreman', folder: self, activeRun: null }] },
+    'POST /run': (b: unknown) => { started = true; return (b as { projectId: string }).projectId === 'busy' ? new Response(JSON.stringify({ error: 'busy' }), { status: 409 }) : { ok: true }; },
+    'GET /runs': () => ({ runs: started ? [run({ status: 'running', budgetUsd: 3 })] : [] }),
+  });
+  const tools = foremanTools({ base: 'http://f', fetchImpl });
+  const refused = await tool(tools, 'start_mission').run({ projectId: 'pf', brief: 'Harden the server please', budgetUsd: 3 });
+  assert.match(refused.text, /Refused: this folder is Foreman itself/);
+  assert.ok(!calls.some((c) => c.method === 'POST'), 'nothing was posted for the refused one');
+  const ok = await tool(tools, 'start_mission').run({ projectId: 'p1', brief: 'Fix the flaky test in ci', budgetUsd: 3, worker: 'sonnet' });
+  assert.match(ok.text, /Started r1 on app, cap \$3\.00/);
+  assert.deepEqual(calls.find((c) => c.method === 'POST')!.body, { projectId: 'p1', mission: 'Fix the flaky test in ci', budgetUsd: 3, workerModel: 'sonnet' });
+  await rm(dir, { recursive: true, force: true });
+});
+
+test('the tool set has no human-only actions', () => {
+  const names = foremanTools({ base: 'http://f' }).map((t) => t.name);
+  for (const forbidden of ['approve', 'deny', 'permission', 'answer', 'interrupt', 'resume', 'budget', 'pull_request', 'open_pr', 'settings', 'key']) {
+    assert.ok(!names.some((n) => n.split('_').includes(forbidden) || n === forbidden), `${forbidden} must not be a tool`);
+  }
+  assert.deepEqual(names, ['fleet_status', 'list_runs', 'run_status', 'run_report', 'run_transcript', 'mission_doc', 'project_memory', 'search_runs', 'doctor', 'link_project', 'start_mission', 'steer']);
+});
+
+test('a server that is not there is said in one sentence with the start command', async () => {
+  const fetchImpl = (async () => { throw new Error('ECONNREFUSED'); }) as unknown as typeof fetch;
+  await assert.rejects(tool(foremanTools({ base: 'http://localhost:4177', fetchImpl }), 'fleet_status').run({}), /not answering at http:\/\/localhost:4177 .*Start it with `foreman`/);
+});
+
+test('eventLine and doneWhen condense what the transcript and the doc say', () => {
+  assert.equal(eventLine('permission_request', { agent: 'director', toolName: 'Bash', decisionReason: 'leaves the folder' }), 'NEEDS YOU — director wants Bash (leaves the folder)');
+  assert.equal(eventLine('message', { agent: 'worker-1', msg: { type: 'assistant', message: { content: [{ type: 'text', text: 'Done.\n\nAll  green.' }] } } }), 'worker-1: Done. All green.');
+  assert.equal(eventLine('message', { agent: 'w', msg: { type: 'user' } }), null);
+  assert.equal(eventLine('cost', {}), null);
+  assert.deepEqual(doneWhen('- [ ] a\n* [x] b\n- [X] c\nnot a box'), { done: ['b', 'c'], open: ['a'] });
+});