Add batch reads, @file completion, interruptible commands, tool sets

Tools, six built-in to fourteen:
- read_many_files: up to 20 paths read concurrently, each with its own window.
  An unreadable path is reported in its own block instead of throwing.
- multi_edit: several edits to one file, validated in memory first so a late
  failure cannot leave the file half-written.
- list_dir: ignore-aware depth-limited tree.
- git_status/diff/log/show/blame: read-only, spawned with a fixed argv rather
  than a shell string, which is what makes them safe to auto-approve.

toolSets gates them. core is always on; edit-plus and git are optional. A
disabled set reaches neither the wire nor the system prompt, since a prompt
naming an absent tool teaches calls that cannot succeed.

Interface:
- Reasoning streams to a collapsed panel, ctrl-r expands, dropped when the turn
  ends: it is progress, not the answer.
- The tool in flight is named from tool-input-start, before its arguments finish
  streaming, and cleared on its result.
- Prompts typed mid-turn queue and drain in order. esc clears the queue as well
  as aborting.
- @ opens a path picker fed by the ignore-aware walker. Prefix matches rank
  above substring matches, so @src/ means "under src/". The walk runs on the
  first @, not at startup.

ctrl-c kills the command in flight and keeps the turn. The call throws rather
than returning, so the model cannot read a killed command as one that ran and
failed on its own terms. The kill takes the whole process tree: killing cmd /c
alone left the real command holding both pipes open, so the read never returned
and the interrupt did nothing for 19 seconds.

Two pruning fixes:
- A tool result whose tool call was pruned is now dropped with it. Pruning
  counts messages, so the cut landed between an assistant tool-call and the tool
  message answering it, producing 400 "No tool call found for function call
  output with call_id ...". The reverse pairing is left alone: a call awaiting
  its result is what a suspended approval looks like.
- ignore.ts called statFs without importing it, so walk() crashed on the first
  symlink.

482 tests, up from 404. Docs synced across README, ROADMAP, TODO, and all of
docs/: tool sets, the new tools, ctrl-c semantics, the tool-start event, and the
two hand-maintained tool-name lists recorded as a known weakness.

test/ui-panels.test.tsx

@@ -5,7 +5,7 @@ import { createAskTool } from '../src/ask';
 import { applySubagentEvent } from '../src/ui/App';
 import { AskPanel, createAskBridge } from '../src/ui/Ask';
 import { Markdown } from '../src/ui/Markdown';
-import { SubagentPanel, TodoPanel, StatusBar, InfoPanel, type SubagentView } from '../src/ui/Panels';
+import { SubagentPanel, TodoPanel, StatusBar, InfoPanel, ActiveTool, QueuePanel, ThinkingPanel, type SubagentView } from '../src/ui/Panels';
 import type { SubagentEvent } from '../src/subagent';
 
 const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
@@ -116,6 +116,55 @@ test('the info panel renders a markdown body', () => {
   app.unmount();
 });
 
+test('the active tool line names the tool and the file it is touching', () => {
+  const app = render(<ActiveTool name="read_file" summary="src/session.ts" />);
+  const frame = app.lastFrame() ?? '';
+  expect(frame).toContain('read_file');
+  expect(frame).toContain('src/session.ts');
+  app.unmount();
+});
+
+test('the active tool line renders before the arguments have arrived', () => {
+  const app = render(<ActiveTool name="grep" />);
+  expect(app.lastFrame()).toContain('grep');
+  app.unmount();
+});
+
+test('thinking collapses to a token count, and expands on request', () => {
+  const text = 'x'.repeat(1648);
+  const collapsed = render(<ThinkingPanel text={text} />);
+  expect(collapsed.lastFrame()).toContain('~412 tokens');
+  expect(collapsed.lastFrame()).not.toContain('xxxx');
+  collapsed.unmount();
+
+  const open = render(<ThinkingPanel text={'first line\nsecond line'} expanded />);
+  const frame = open.lastFrame() ?? '';
+  expect(frame).toContain('second line');
+  expect(frame).toContain('collapse');
+  open.unmount();
+});
+
+test('no reasoning renders nothing at all', () => {
+  const app = render(<ThinkingPanel text="" />);
+  expect(app.lastFrame() ?? '').toBe('');
+  app.unmount();
+});
+
+test('the queue panel counts what is waiting and lists it in order', () => {
+  const app = render(<QueuePanel prompts={['first thing', 'second thing']} />);
+  const frame = app.lastFrame() ?? '';
+  expect(frame).toContain('queued: 2');
+  expect(frame).toContain('1. first thing');
+  expect(frame).toContain('2. second thing');
+  app.unmount();
+});
+
+test('an empty queue renders nothing', () => {
+  const app = render(<QueuePanel prompts={[]} />);
+  expect(app.lastFrame() ?? '').toBe('');
+  app.unmount();
+});
+
 const events: SubagentEvent[] = [
   { type: 'start', id: 'a', kind: 'explore', description: 'first task' },
   { type: 'step', id: 'a', tool: 'grep', summary: 'needle' },