@chatpanel/events 0.80.1 → 0.81.1

package/board-tool.js

@@ -0,0 +1,144 @@
+// The `board` tool — how a member operates on the board.
+//
+// Every role gets it, whatever its grants: it reaches nothing outside the run. Four actions:
+// `read` the threads this member may see, `post` a note or draft in a thread, `reply` to a
+// post (agree, dispute with a ref, extend), and `ask` — open an ask thread and WAIT for a
+// person to answer it, from either client. Members do not chat freely: a post is typed, a
+// reply hangs off a post, and an ask pauses the member's own task, never the run.
+//
+// Bound per task: the member's role and task are fixed at bind time, so a member cannot post
+// as someone else, and its ask lands in its own task's context.
+
+import { boardText, POST_KINDS, ASK_TYPES } from './team-board.js';
+
+export const BOARD_TOOL_NAME = 'board';
+export const DEFAULT_ASK_TIMEOUT_MS = 10 * 60_000;
+
+export function boardToolSpec() {
+  return {
+    name: BOARD_TOOL_NAME,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    description:
+      'The team board — where the other members\' work is, and where you speak to them and to the user. '
+      + 'Actions: {"action":"read"} the threads you may see; '
+      + '{"action":"post","kind":"note|draft|question","text":"…","refs":["…"]} a post in your task\'s thread; '
+      + '{"action":"reply","postId":"…","kind":"note","text":"…","refs":["…"]} a reply to another member\'s post — agree, dispute with a ref, extend; '
+      + '{"action":"ask","type":"info|budget|permission|direction","text":"what you need and why","options":["…"]} asks the USER and waits for the answer (minutes). '
+      + 'Ask only when you are stuck — a fact you could not find, a choice only the user can make. Otherwise decide, say what you assumed, and go on.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['read', 'post', 'reply', 'ask'] },
+        kind: { type: 'string', enum: POST_KINDS.filter((k) => k !== 'finding' && k !== 'answer' && k !== 'decision') },
+        text: { type: 'string' },
+        refs: { type: 'array', items: { type: 'string' } },
+        postId: { type: 'string', description: 'For reply: the post to reply to.' },
+        threadId: { type: 'string', description: 'For post: another thread you may see (default: your task\'s).' },
+        type: { type: 'string', enum: [...ASK_TYPES], description: 'For ask.' },
+        options: { type: 'array', items: { type: 'string' }, description: 'For ask: choices to offer the user.' },
+      },
+      required: ['action'],
+    },
+  };
+}
+
+const json = (v) => JSON.stringify(v);
+
+/**
+ * @param board     the run's live board (team-board.js createBoard)
+ * @param role      the member's role id
+ * @param taskId    the member's task
+ * @param taskIds   the tasks this member may read (its dependencies, or null for all)
+ * @param waitFor   `async (threadId, timeoutMs, signal) => { text, by } | null` — the runner's answer box
+ * @param onAsk     `(thread, post) => void` — the runner marks the task waiting
+ */
+export function boardToolProvider({ board, role, taskId, taskIds = null, waitFor = null, onAsk = null, askTimeoutMs = DEFAULT_ASK_TIMEOUT_MS, signal = null } = {}) {
+  const ownThread = () => board.threadForTask(taskId) || board.openThread({ taskId, kind: 'task', title: taskId, by: 'runner' });
+  return {
+    id: 'board',
+    specs: [boardToolSpec()],
+    system: 'Other members\' work is on the board (the `board` tool): read it before repeating a lookup, reply where you disagree, and ask the user only when you are stuck.',
+    async execute(name, input) {
+      if (name !== BOARD_TOOL_NAME) return json({ error: `Unknown tool: ${name}` });
+      const action = String(input?.action || '');
+      if (action === 'read') {
+        const text = boardText(board, { taskIds, role });
+        const threads = board.threads().filter((t) => t.kind !== 'proposal').map((t) => ({ id: t.id, kind: t.kind, title: t.title, status: t.status, by: t.by, posts: t.posts }));
+        return json({ board: text || 'Nothing on the board yet.', threads, postIds: board.posts().filter((p) => p.kind !== 'answer').map((p) => ({ id: p.id, threadId: p.threadId, by: p.by, kind: p.kind, head: p.text.slice(0, 80) })) });
+      }
+      const text = String(input?.text || '').trim();
+      if (action === 'post' || action === 'reply') {
+        if (!text) return json({ error: `${action} needs text.` });
+        let threadId = ownThread().id;
+        let replyTo = null;
+        if (action === 'reply') {
+          const target = board.postById(String(input?.postId || ''));
+          if (!target) return json({ error: `No post ${input?.postId}. Read the board for post ids.` });
+          threadId = target.threadId; replyTo = target.id;
+        } else if (input?.threadId && board.thread(String(input.threadId))) {
+          threadId = String(input.threadId);
+        }
+        const post = board.post({ threadId, by: role, kind: input?.kind || 'note', text, refs: input?.refs, replyTo });
+        return json({ posted: post.id, threadId, replyTo });
+      }
+      if (action === 'ask') {
+        if (!text) return json({ error: 'ask needs text — what you need and why.' });
+        if (typeof waitFor !== 'function') return json({ error: 'This run cannot wait for the user. Decide on your best assumption and say what you assumed.' });
+        const { thread, post } = board.ask({ taskId, by: role, type: input?.type, text, options: input?.options, timeoutMs: askTimeoutMs });
+        onAsk?.(thread, post);
+        const answer = await waitFor(thread.id, askTimeoutMs, signal);
+        if (!answer) return json({ answered: false, threadId: thread.id, hint: 'No answer arrived in time. Proceed on your best assumption, say what you assumed, and note that the user did not answer.' });
+        return json({ answered: true, threadId: thread.id, answer: answer.text, by: answer.by });
+      }
+      return json({ error: `Unknown action "${action}". Use read, post, reply or ask.` });
+    },
+  };
+}
+
+/**
+ * The runner's answer box: `wait(threadId, ms, signal)` resolves when `answer(threadId, …)`
+ * is called — by the host, from its own UI or from the run store's tail when the OTHER
+ * client answered. An answer that arrives before anyone waits is kept.
+ */
+export function createAnswerBox() {
+  const waiting = new Map(); // threadId -> resolve
+  const early = new Map(); // threadId -> answer
+  return {
+    wait(threadId, timeoutMs, signal = null) {
+      if (early.has(threadId)) { const a = early.get(threadId); early.delete(threadId); return Promise.resolve(a); }
+      return new Promise((resolve) => {
+        let timer = null;
+        const done = (v) => { clearTimeout(timer); waiting.delete(threadId); signal?.removeEventListener?.('abort', onAbort); resolve(v); };
+        const onAbort = () => done(null);
+        waiting.set(threadId, done);
+        if (timeoutMs > 0) timer = setTimeout(() => done(null), timeoutMs);
+        if (typeof timer?.unref === 'function') timer.unref();
+        signal?.addEventListener?.('abort', onAbort, { once: true });
+      });
+    },
+    answer(threadId, answer) {
+      const a = { text: String(answer?.text ?? answer ?? ''), by: answer?.by || 'person', id: answer?.id || null };
+      const w = waiting.get(threadId);
+      if (w) w(a); else early.set(threadId, a);
+      return !!w;
+    },
+    get pending() { return [...waiting.keys()]; },
+  };
+}
+
+/** The host's toolset with the board tool added — first, so it is read first. */
+export function withBoardTool(toolset, provider) {
+  if (!toolset) {
+    return {
+      specs: [...provider.specs], system: provider.system,
+      execute: (name, input) => provider.execute(name, input),
+    };
+  }
+  const own = new Set(provider.specs.map((s) => s.name));
+  return {
+    ...toolset,
+    specs: [...provider.specs, ...(toolset.specs || []).filter((s) => !own.has(s.name))],
+    system: [provider.system, toolset.system].filter(Boolean).join('\n\n'),
+    execute: (name, input, ...rest) => (own.has(name) ? provider.execute(name, input) : toolset.execute(name, input, ...rest)),
+  };
+}

package/budget.js

@@ -67,7 +67,7 @@ export function usageOf(u = {}) {
 export function createBudget(declared, { now = () => Date.now() } = {}) {
   const v = validateBudget(declared);
   if (!v.ok) throw new BudgetError('INVALID', v.errors.join('; '));
-  const cap = normalizeBudget(declared);
+  const cap = { ...normalizeBudget(declared) };
   const startedAt = now();
   const spent = { tokens: 0, calls: 0, usd: 0 };
   const elapsed = () => now() - startedAt;
@@ -103,6 +103,12 @@ export function createBudget(declared, { now = () => Date.now() } = {}) {
     },
     remaining,
     exhausted,
+    /** A person raised the cap mid-run (a budget ask answered "allow"): by a factor, once. */
+    raise(factor = 1.5) {
+      const f = Math.max(1, Number(factor) || 1);
+      for (const k of Object.keys(cap)) if (cap[k] !== undefined) cap[k] = Math.ceil(cap[k] * f);
+      return { ...cap };
+    },
     snapshot() {
       return { cap, spent: { ...spent, ms: elapsed() }, remaining: remaining(), exhausted: exhausted() };
     },

package/index.js

@@ -194,8 +194,9 @@ export { recipeToolProvider, recipeToolSpec, describeRecipeForApproval, RECIPE_T
 export { createBudget, validateBudget, normalizeBudget, usageOf, BudgetError, BUDGET_DIMENSIONS } from './budget.js';
 export { defineTeam, validateTeam, normalizeTeam, normalizeGrants, grantAllows, describeRole, TeamError, ROLE_MODES, MERGE_POLICIES, PLAN_MODES, GRANTABLE, STARTER_TEAMS, starterTeams, blankTeam, teamFromForm, slugTeamName } from './team.js';
 export { fixedPlan, parsePlan, plannerPrompt, waves, breakCycles, TEAM_PLAN_SCHEMA } from './team-plan.js';
-export { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims, FINDINGS_SCHEMA, FINDING_KINDS } from './team-board.js';
-export { runTeam, dryRunTeam, isModelUnavailable, TeamRunError, RUN_STATUSES } from './team-run.js';
+export { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims, FINDINGS_SCHEMA, FINDING_KINDS, THREAD_KINDS, THREAD_STATUSES, POST_KINDS, POST_STATUSES, ASK_TYPES, emptyBoardState, foldBoard, findingsOf } from './team-board.js';
+export { boardToolProvider, boardToolSpec, createAnswerBox, withBoardTool, BOARD_TOOL_NAME, DEFAULT_ASK_TIMEOUT_MS } from './board-tool.js';
+export { runTeam, resumeTeam, dryRunTeam, isModelUnavailable, TeamRunError, RUN_STATUSES } from './team-run.js';
 export { teamToolProvider, teamToolSpec, describeTeamForApproval, TEAM_TOOL_NAME } from './team-tool.js';
 export { teamLine, teamLanes } from './team-trail.js';
 export { mcpDispatchProvider, MCP_TOOL_NAME } from './mcp-dispatch.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.80.1",
+  "version": "0.81.1",
   "description": "The canonical ChatPanel event-log and capability contracts \u2014 typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",
@@ -90,6 +90,7 @@
     "./synthesis.js": "./synthesis.js",
     "./tags.js": "./tags.js",
     "./team-board.js": "./team-board.js",
+    "./board-tool.js": "./board-tool.js",
     "./team-plan.js": "./team-plan.js",
     "./team-run.js": "./team-run.js",
     "./team-tool.js": "./team-tool.js",
@@ -205,6 +206,7 @@
     "synthesis.js",
     "tags.js",
     "team-board.js",
+    "board-tool.js",
     "team-plan.js",
     "team-run.js",
     "team-tool.js",

package/team-board.js

@@ -1,11 +1,17 @@
-// The board — what a team's members say to each other, as typed findings, not talk.
+// The board — where a team's members meet: a message board, not a log.
 //
-// Members do not read each other's transcripts. A task ends with FINDINGS: claims with the
-// refs they came from (the brief shape, I-K1), drafts, links, questions. A later task reads
-// the board, sized like a shielded tool result so a long-running team does not feed a
-// later member forty thousand characters of earlier members. The board is the run's record:
-// durable, attributable per role, and — after a run — the thing that can become draft
-// briefs and be promoted on convergence (W7), rather than evaporating with the run.
+// One board per run. A THREAD per task (and one per ask, discussion or proposal); POSTS in
+// threads — a member's findings, its notes, a question, a person's answer, a draft, a
+// decision — and REPLIES hanging off posts. Members do not read each other's transcripts:
+// a task ends with FINDINGS (claims with the refs they came from, I-K1), those become posts
+// in its thread, and a later task reads the threads it depends on, threaded and sized like a
+// shielded tool result. A member that disagrees replies where it disagrees; a member that
+// is stuck ASKS, and its task waits for a person — on either client — to answer. A person
+// posting is a member posting, and a person's decision on any post wins.
+//
+// The board is the run's record: durable (every change is an event the run store folds with
+// `foldBoard`), attributable per member, and — after a run — what can become draft briefs
+// and be promoted on convergence (W7), rather than evaporating with the run.
 //
 // Findings are parsed GENEROUSLY from a model's answer through the structured layer, and a
 // task whose answer cannot be read as findings is not lost: its whole answer becomes one
@@ -65,46 +71,225 @@ export function parseFindings(text, { role, taskId } = {}) {
   return [stamp({ kind: 'draft', text: prose.slice(0, 2000), refs: [] }, 0)];
 }
 
-export function createBoard({ now = () => Date.now() } = {}) {
-  const findings = [];
+// ── threads, posts, asks ────────────────────────────────────────────────────────────────
+
+export const THREAD_KINDS = Object.freeze(['task', 'ask', 'discussion', 'proposal']);
+export const THREAD_STATUSES = Object.freeze(['open', 'waiting', 'resolved', 'approved', 'rejected']);
+export const POST_KINDS = Object.freeze(['finding', 'note', 'question', 'answer', 'draft', 'decision']);
+export const POST_STATUSES = Object.freeze(['open', 'proposed', 'approved', 'rejected']);
+export const ASK_TYPES = Object.freeze(['info', 'budget', 'permission', 'direction']);
+export const RUNNER = 'runner';
+export const PERSON = 'person';
+export const MAX_POST_TEXT = 4000;
+
+const clip = (t, n) => String(t || '').trim().slice(0, n);
+const refsOf = (r) => (Array.isArray(r) ? r.map(String).filter(Boolean).slice(0, 8) : []);
+
+/** The empty folded state — what a run record holds, what `foldBoard` grows. */
+export function emptyBoardState() { return { threads: [], posts: [] }; }
+
+/**
+ * Fold one board event into a state (pure; the gateway's run store and both clients use it).
+ * Ids dedupe: an answer posted through the gateway and echoed by the running client's runner
+ * arrives twice with one id and lands once.
+ */
+export function foldBoard(state, ev) {
+  const s = state && Array.isArray(state.threads) && Array.isArray(state.posts) ? state : emptyBoardState();
+  const type = String(ev?.type || '');
+  const p = ev?.payload && typeof ev.payload === 'object' ? ev.payload : ev || {};
+  if (type === 'board.thread' && p.thread?.id) {
+    if (!s.threads.some((t) => t.id === p.thread.id)) s.threads.push({ ...p.thread });
+  } else if (type === 'board.post' && p.post?.id) {
+    if (!s.posts.some((x) => x.id === p.post.id)) s.posts.push({ ...p.post });
+    const t = s.threads.find((x) => x.id === p.post.threadId);
+    if (t) { t.lastAt = p.post.at; t.lastBy = p.post.by; t.posts = (t.posts || 0) + 1; }
+  } else if (type === 'board.decision' && p.postId) {
+    const x = s.posts.find((q) => q.id === p.postId);
+    if (x) { x.status = p.status; x.decidedBy = p.by; x.decidedAt = p.at ?? ev?.at; }
+  } else if (type === 'board.thread-status' && p.threadId) {
+    const t = s.threads.find((x) => x.id === p.threadId);
+    if (t) { t.status = p.status; if (p.status !== 'waiting') t.waitingOn = null; }
+  }
+  return s;
+}
+
+/**
+ * The live board a run works on. `state` seeds it (a resume); `onEvent` receives every
+ * change as the event the run store folds. The legacy findings API (`add`, `all`, `byTask`)
+ * stays: a finding is a post of kind `finding` in its task's thread.
+ */
+export function createBoard({ now = () => Date.now(), newId = null, state = null, onEvent = null } = {}) {
+  const st = state && Array.isArray(state.threads) ? { threads: state.threads.map((t) => ({ ...t })), posts: (state.posts || []).map((x) => ({ ...x })) } : emptyBoardState();
   const listeners = new Set();
-  return {
-    add(list) {
-      const at = now();
+  let seq = st.posts.length + st.threads.length;
+  const mk = (prefix) => (newId ? newId(prefix) : `${prefix}_${(++seq).toString(36)}${Math.random().toString(36).slice(2, 6)}`);
+  const say = (type, payload) => { const ev = { type, at: now(), ...payload }; if (onEvent) onEvent(type, ev); return ev; };
+  const threadOf = (id) => st.threads.find((t) => t.id === id);
+  const postOf = (id) => st.posts.find((x) => x.id === id);
+  const threadForTask = (taskId) => st.threads.find((t) => t.kind === 'task' && t.taskId === taskId);
+
+  const api = {
+    /** Open a thread. A task's thread is opened once; asking for it again returns it. */
+    openThread({ id = null, taskId = null, kind = 'discussion', title = '', by = RUNNER, status = 'open', ask = null } = {}) {
+      if (kind === 'task' && taskId) { const had = threadForTask(taskId); if (had) return had; }
+      const thread = { id: id || mk('th'), kind: THREAD_KINDS.includes(kind) ? kind : 'discussion', taskId, title: clip(title, 200), by, status: THREAD_STATUSES.includes(status) ? status : 'open', at: now(), posts: 0, ...(ask ? { ask } : {}) };
+      st.threads.push(thread);
+      say('board.thread', { thread: { ...thread } });
+      return thread;
+    },
+    /** A post in a thread; `replyTo` makes it a reply. */
+    post({ id = null, threadId, by, kind = 'note', text = '', refs = [], replyTo = null, status = 'open', finding = null, ask = null } = {}) {
+      const t = threadOf(threadId);
+      if (!t) throw new Error(`no thread ${threadId}`);
+      if (id && postOf(id)) return postOf(id);
+      const post = {
+        id: id || mk('p'), threadId, by: String(by || RUNNER), kind: POST_KINDS.includes(kind) ? kind : 'note',
+        text: clip(text, MAX_POST_TEXT), refs: refsOf(refs), replyTo, status: POST_STATUSES.includes(status) ? status : 'open', at: now(),
+        ...(finding ? { finding } : {}), ...(ask ? { ask } : {}),
+      };
+      st.posts.push(post);
+      t.lastAt = post.at; t.lastBy = post.by; t.posts = (t.posts || 0) + 1;
+      say('board.post', { post: { ...post } });
+      for (const l of listeners) l(post);
+      return post;
+    },
+    /** A reply hangs off a post and lives in that post's thread. */
+    reply({ postId, ...args }) {
+      const target = postOf(postId || args.replyTo);
+      if (!target) throw new Error(`no post ${postId}`);
+      return api.post({ ...args, threadId: target.threadId, replyTo: target.id });
+    },
+    /** A person's (or the judge's) decision on a post. */
+    decide(postId, status, by = PERSON) {
+      const x = postOf(postId);
+      if (!x || !['approved', 'rejected', 'proposed', 'open'].includes(status)) return null;
+      x.status = status; x.decidedBy = by; x.decidedAt = now();
+      say('board.decision', { postId, status, by, at: x.decidedAt });
+      return x;
+    },
+    setThreadStatus(threadId, status, extra = {}) {
+      const t = threadOf(threadId);
+      if (!t || !THREAD_STATUSES.includes(status)) return null;
+      t.status = status; if (status !== 'waiting') t.waitingOn = null; Object.assign(t, extra);
+      say('board.thread-status', { threadId, status, ...extra });
+      return t;
+    },
+    /**
+     * A member is stuck: open an ask thread (status `waiting`) with the question as its
+     * first post. The runner waits on it; a person answers from either client.
+     */
+    ask({ taskId = null, by, type = 'info', text, options = [], timeoutMs = 0, title = '' } = {}) {
+      const ask = { type: ASK_TYPES.includes(type) ? type : 'info', options: (Array.isArray(options) ? options : []).map(String).slice(0, 6), timeoutMs };
+      const thread = api.openThread({ taskId, kind: 'ask', title: title || clip(text, 120), by, status: 'waiting', ask });
+      thread.waitingOn = PERSON;
+      const post = api.post({ threadId: thread.id, by, kind: 'question', text, ask });
+      return { thread, post };
+    },
+    /** The answer to an ask — from a person, on any client. Resolves the thread. */
+    answer(threadId, { id = null, text, by = PERSON } = {}) {
+      const t = threadOf(threadId);
+      if (!t) return null;
+      const post = api.post({ id, threadId, by, kind: 'answer', text });
+      api.setThreadStatus(threadId, 'resolved', { answeredAt: post.at });
+      return post;
+    },
+    thread: threadOf,
+    threadForTask,
+    threads: () => st.threads.map((t) => ({ ...t })),
+    posts: (threadId = null) => st.posts.filter((x) => !threadId || x.threadId === threadId).map((x) => ({ ...x })),
+    postById: postOf,
+    /** Every ask still waiting — what a client pins at the top. */
+    waiting: () => st.threads.filter((t) => t.kind === 'ask' && t.status === 'waiting').map((t) => ({ ...t })),
+    /** The whole board, for the run record and for a resume. */
+    state: () => ({ threads: st.threads.map((t) => ({ ...t })), posts: st.posts.map((x) => ({ ...x })) }),
+
+    // ── findings, as before: a finding is a post in its task's thread ──
+    add(list, { by = null } = {}) {
+      let n = 0;
       for (const f of Array.isArray(list) ? list : [list]) {
         if (!f || !f.text) continue;
-        const entry = { ...f, at };
-        findings.push(entry);
-        for (const l of listeners) l(entry);
+        const t = f.taskId ? (threadForTask(f.taskId) || api.openThread({ taskId: f.taskId, kind: 'task', title: f.taskId })) : (st.threads.find((x) => x.kind === 'discussion' && x.title === 'findings') || api.openThread({ kind: 'discussion', title: 'findings' }));
+        api.post({ id: f.id, threadId: t.id, by: by || f.role || RUNNER, kind: 'finding', text: f.text, refs: f.refs, finding: { kind: f.kind || 'claim', confidence: f.confidence ?? null } });
+        n += 1;
       }
-      return findings.length;
+      return n;
     },
-    all: () => [...findings],
-    byTask: (taskId) => findings.filter((f) => f.taskId === taskId),
-    byRole: (role) => findings.filter((f) => f.role === role),
-    onFinding(fn) { listeners.add(fn); return () => listeners.delete(fn); },
-    get size() { return findings.length; },
+    all: () => st.posts.filter((x) => x.kind === 'finding').map(asFinding(st)),
+    byTask: (taskId) => api.all().filter((f) => f.taskId === taskId),
+    byRole: (role) => api.all().filter((f) => f.role === role),
+    onFinding(fn) { const l = (p) => { if (p.kind === 'finding') fn(asFinding(st)(p)); }; listeners.add(l); return () => listeners.delete(l); },
+    get size() { return st.posts.filter((x) => x.kind === 'finding').length; },
   };
+  return api;
+}
+
+/** A finding post in the legacy finding shape (what merge, briefs and lanes read). */
+function asFinding(st) {
+  return (p) => {
+    const t = st.threads.find((x) => x.id === p.threadId);
+    return { id: p.id, kind: p.finding?.kind || 'claim', text: p.text, refs: p.refs || [], confidence: p.finding?.confidence ?? null, role: p.by, taskId: t?.taskId || null, at: p.at, status: p.status };
+  };
+}
+
+/** Findings from a folded state (a run record read from the store). */
+export function findingsOf(state) {
+  const st = state && Array.isArray(state.posts) ? state : emptyBoardState();
+  return st.posts.filter((x) => x.kind === 'finding').map(asFinding(st));
 }
 
 /**
  * What a later task READS: the findings of the tasks it depends on (or everything so far),
  * sized. Newest are kept whole; the oldest are what get cut, and the cut is stated.
  */
-export function boardText(findings, { taskIds = null, max = BOARD_TEXT_MAX } = {}) {
-  const list = (findings || []).filter((f) => !taskIds || taskIds.includes(f.taskId));
-  if (!list.length) return '';
-  const lines = list.map((f) => `- [${f.kind}${f.role ? ` · ${f.role}` : ''}${f.confidence != null ? ` · ${Math.round(f.confidence * 100)}%` : ''}] ${f.text}${f.refs?.length ? ` (refs: ${f.refs.join(', ')})` : ''}`);
-  let out = lines.join('\n');
-  if (out.length <= max) return `Findings so far:\n${out}`;
-  let kept = [];
+export function boardText(source, { taskIds = null, max = BOARD_TEXT_MAX, role = null } = {}) {
+  // A board (threads + posts) reads threaded; a bare findings array reads as before.
+  const state = source && typeof source.state === 'function' ? source.state() : (source && Array.isArray(source.posts) ? source : null);
+  const lines = state ? threadedLines(state, { taskIds, role }) : findingLines(source, taskIds);
+  if (!lines.length) return '';
+  const head = state ? 'The board so far' : 'Findings so far';
+  const out = lines.join('\n');
+  if (out.length <= max) return `${head}:\n${out}`;
+  const kept = [];
   let size = 0;
   for (let i = lines.length - 1; i >= 0; i -= 1) {
     if (size + lines[i].length + 1 > max) break;
     kept.unshift(lines[i]);
     size += lines[i].length + 1;
   }
-  return `Findings so far (${lines.length - kept.length} earlier ones omitted for length):\n${kept.join('\n')}`;
+  return `${head} (${lines.length - kept.length} earlier lines omitted for length):\n${kept.join('\n')}`;
+}
+
+function findingLines(findings, taskIds) {
+  return (findings || []).filter((f) => !taskIds || taskIds.includes(f.taskId))
+    .map((f) => `- [${f.kind}${f.role ? ` · ${f.role}` : ''}${f.confidence != null ? ` · ${Math.round(f.confidence * 100)}%` : ''}] ${f.text}${f.refs?.length ? ` (refs: ${f.refs.join(', ')})` : ''}`);
+}
+
+/**
+ * What a member READS: the task threads it depends on (or every task thread), the answered
+ * asks and settled discussions — never rejected posts — threaded, a reply under its post.
+ * A person's decision is marked so a member treats it as settled.
+ */
+function threadedLines(state, { taskIds, role }) {
+  const out = [];
+  const posts = state.posts;
+  const threads = state.threads.filter((t) => {
+    if (t.kind === 'task') return !taskIds || taskIds.includes(t.taskId);
+    if (t.kind === 'ask') return t.status === 'resolved' && (!role || t.by === role || t.by === RUNNER);
+    if (t.kind === 'discussion') return true;
+    return false; // a proposal is the run's output, not a member's input
+  });
+  for (const t of threads) {
+    const own = posts.filter((x) => x.threadId === t.id && x.status !== 'rejected');
+    if (!own.length) continue;
+    out.push(`## ${t.kind}${t.by && t.by !== RUNNER ? ` by ${t.by}` : ''}: ${t.title}${t.status === 'resolved' && t.kind === 'ask' ? ' (answered)' : ''}`);
+    const line = (x, depth) => {
+      const tag = [x.kind === 'finding' ? (x.finding?.kind || 'claim') : x.kind, x.by, x.finding?.confidence != null ? `${Math.round(x.finding.confidence * 100)}%` : null, x.status === 'approved' ? 'APPROVED' : x.status === 'proposed' ? 'proposed' : null, x.kind === 'decision' || x.by === PERSON ? 'SETTLED' : null].filter(Boolean).join(' · ');
+      out.push(`${'  '.repeat(depth)}- [${tag}] ${x.text}${x.refs?.length ? ` (refs: ${x.refs.join(', ')})` : ''}`);
+      for (const r of own.filter((y) => y.replyTo === x.id)) line(r, depth + 1);
+    };
+    for (const x of own.filter((y) => !y.replyTo)) line(x, 0);
+  }
+  return out;
 }
 
 /** Findings → the claim shape a draft brief takes (W7): text + refs as `{ kind, id }`. */

package/team-run.js

@@ -19,10 +19,11 @@
 import { normalizeTeam } from './team.js';
 import { createBudget } from './budget.js';
 import { fixedPlan, plannerPrompt, parsePlan, waves } from './team-plan.js';
-import { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims } from './team-board.js';
+import { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims, RUNNER } from './team-board.js';
+import { boardToolProvider, createAnswerBox, withBoardTool, DEFAULT_ASK_TIMEOUT_MS } from './board-tool.js';
 import { converge } from './promotion.js';
 
-export const RUN_STATUSES = Object.freeze(['planning', 'running', 'merging', 'completed', 'partial', 'over-budget', 'stopped', 'failed']);
+export const RUN_STATUSES = Object.freeze(['planning', 'running', 'merging', 'waiting', 'completed', 'partial', 'over-budget', 'stopped', 'failed']);
 const DEFAULT_CONCURRENCY = 3;
 
 export class TeamRunError extends Error {
@@ -88,15 +89,29 @@ export async function runTeam({
   team, request, callModel, toolsFor = () => undefined, appoint = null, runRecipe = null,
   now = () => Date.now(), newId = () => `run_${Math.random().toString(36).slice(2, 10)}`,
   emit = () => {}, signal = null, maxConcurrency = DEFAULT_CONCURRENCY, runId = null,
+  // Asks: the box a person's answers arrive in (the host feeds it from its UI and from the
+  // run store's tail), and how long a member waits before the run checkpoints. 0 = a member
+  // that asks is told to proceed on its own assumption at once.
+  answers = null, askTimeoutMs = DEFAULT_ASK_TIMEOUT_MS,
+  // A checkpoint from a run that ended `waiting` — see resumeTeam.
+  resume = null,
 } = {}) {
   if (typeof callModel !== 'function') throw new TeamRunError('BAD_RUN', 'callModel required');
   const t = normalizeTeam(team); // throws on a team without a budget — O1
-  const id = runId || newId();
-  const budget = createBudget(t.budget, { now });
-  const board = createBoard({ now });
-  const startedAt = now();
-  const tasksOut = [];
+  const id = runId || resume?.runId || newId();
+  const budget = createBudget(resume?.budget?.cap || t.budget, { now });
+  if (resume?.budget?.spent) budget.charge({ tokens: resume.budget.spent.tokens, calls: resume.budget.spent.calls, usd: resume.budget.spent.usd });
   const say = (type, payload = {}) => emit(type, { runId: id, at: now(), ...payload });
+  // Every change to the board is an event the run store folds — the other client reads it live.
+  const board = createBoard({ now, state: resume?.board || null, onEvent: (type, ev) => say(type, ev) });
+  // No answer box from the host means nobody can answer: asks are off, a member that asks is
+  // told to proceed on its own assumption at once, and the budget stop is final.
+  const box = answers || createAnswerBox();
+  const askMs = answers ? askTimeoutMs : 0;
+  const startedAt = resume?.startedAt || now();
+  // Tasks a checkpoint already finished are carried over, not re-run.
+  const tasksOut = (resume?.tasks || []).filter((x) => x.status === 'ok').map((x) => ({ ...x }));
+  const carried = new Set(tasksOut.map((x) => x.id));
   const roleOf = (rid) => t.roles.find((r) => r.id === rid);
   // `exclude` holds what failed as unavailable this run; a re-appointment skips it. A role's
   // pinned model is tried first and, when it is the one that failed, the roster steps in.
@@ -107,12 +122,12 @@ export async function runTeam({
   const MAX_APPOINTMENTS = 3;
   const stopped = () => !!signal?.aborted;
 
-  say('run.started', { team: t.name, request: String(request || ''), budget: t.budget, roles: t.roles.map((r) => r.id) });
+  say(resume ? 'run.resumed' : 'run.started', { team: t.name, request: String(request || ''), budget: budget.cap, roles: t.roles.map((r) => r.id), ...(resume ? { carried: [...carried] } : {}) });
 
   // ── plan ──────────────────────────────────────────────────────────────────────────────
-  let tasks;
-  let planBy = 'fixed';
-  if (t.plan === 'planner') {
+  let tasks = resume?.plan?.tasks?.length ? resume.plan.tasks : null;
+  let planBy = resume?.plan?.by || 'fixed';
+  if (!tasks && t.plan === 'planner') {
     const planner = strongestRole(t);
     const m = modelFor(planner);
     if (m && budget.canAfford({ tokens: 0 })) {
@@ -124,20 +139,37 @@ export async function runTeam({
   }
   if (!tasks) tasks = fixedPlan(t, request);
   say('plan.ready', { by: planBy, tasks: tasks.map((x) => ({ id: x.id, role: x.role, title: x.title, dependsOn: x.dependsOn })) });
+  // A thread per task, before anything runs: a member's findings and replies have a home.
+  for (const task of tasks) board.openThread({ taskId: task.id, kind: 'task', title: task.title || task.id, by: RUNNER });
 
   const finish = (status, extra = {}) => {
     const usage = budget.snapshot();
-    const out = { runId: id, team: t.name, status, plan: { by: planBy, tasks }, tasks: tasksOut, board: board.all(), usage, startedAt, endedAt: now(), ...extra };
-    say('run.done', { status, usage, proposal: out.proposal || null, failedTaskIds: tasksOut.filter((x) => x.status === 'failed').map((x) => x.id) });
+    const out = { runId: id, team: t.name, status, plan: { by: planBy, tasks }, tasks: tasksOut, board: board.all(), threads: board.state(), usage, startedAt, endedAt: now(), ...extra };
+    // What a resume needs, on the record: the plan, what finished, the board, the spend.
+    if (status === 'waiting') out.checkpoint = { runId: id, startedAt, plan: { by: planBy, tasks }, tasks: tasksOut, board: board.state(), budget: { cap: budget.cap, spent: usage.spent } };
+    say('run.done', { status, usage, proposal: out.proposal || null, failedTaskIds: tasksOut.filter((x) => x.status === 'failed').map((x) => x.id), waitingTaskIds: tasksOut.filter((x) => x.status === 'waiting').map((x) => x.id), ...(out.checkpoint ? { checkpoint: out.checkpoint } : {}) });
     return out;
   };
 
+  /**
+   * The runner asks the person (a budget, a direction). Same thread shape as a member's ask;
+   * answered from either client; null when nobody answered in time or asks are off.
+   */
+  const askPerson = async ({ type, text, options, taskId = null }) => {
+    if (askMs <= 0) return null;
+    const { thread } = board.ask({ taskId, by: RUNNER, type, text, options, timeoutMs: askMs });
+    say('run.waiting', { threadId: thread.id, askType: type, text, options });
+    return box.wait(thread.id, askMs, signal);
+  };
+  let waitingOnPerson = false; // a task that timed out on its ask — the run checkpoints
+
   // ── fan out, in waves ─────────────────────────────────────────────────────────────────
   let overBudget = false;
-  for (const wave of waves(tasks)) {
-    if (stopped() || overBudget) break;
+  let budgetAsked = !!resume?.budgetAsked;
+  for (const wave of waves(tasks.filter((x) => !carried.has(x.id)))) {
+    if (stopped() || overBudget || waitingOnPerson) break;
     await pool(wave, maxConcurrency, async (task) => {
-      if (stopped() || overBudget) { tasksOut.push({ id: task.id, role: task.role, status: 'skipped', text: '', findings: [] }); return; }
+      if (stopped() || overBudget || waitingOnPerson) { tasksOut.push({ id: task.id, role: task.role, status: 'skipped', text: '', findings: [] }); return; }
       const role = roleOf(task.role);
       const t0 = now();
       say('task.started', { taskId: task.id, role: task.role, title: task.title });
@@ -145,6 +177,11 @@ export async function runTeam({
       let usage = null;
       let status = 'ok';
       let error = null;
+      // The task's own abort: an ask nobody answered in time stops THIS member's turn (the
+      // run then checkpoints), without stopping the run's other members.
+      const taskAc = new AbortController();
+      signal?.addEventListener?.('abort', () => taskAc.abort(), { once: true });
+      let askedAndWaiting = null;
       try {
         if (role.mode === 'recipe') {
           if (typeof runRecipe !== 'function') throw new Error('this host cannot run recipes');
@@ -154,10 +191,22 @@ export async function runTeam({
           // A call's tokens are unknown until it returns; what can be asked beforehand is
           // whether the budget is already exhausted and whether one more call is allowed.
           if (!budget.canAfford({ tokens: 0 })) { overBudget = true; throw new Error('over budget'); }
-          const prior = boardText(board.all(), { taskIds: task.dependsOn?.length ? task.dependsOn : null });
+          // What this member reads: the threads of the tasks it depends on, answered asks (its
+          // own — a resumed task finds the person's answer here), settled discussions.
+          const prior = boardText(board, { taskIds: task.dependsOn?.length ? task.dependsOn : null, role: role.id });
           const prompt = [task.prompt, prior, findingsInstruction()].filter(Boolean).join('\n\n');
           // A host may build a toolset asynchronously (connecting MCP servers takes time).
-          const tools = await toolsFor(role);
+          // The board tool rides on top of whatever the role was granted.
+          const boardTool = boardToolProvider({
+            board, role: role.id, taskId: task.id, taskIds: task.dependsOn?.length ? task.dependsOn : null, askTimeoutMs: askMs, signal: taskAc.signal,
+            onAsk: (thread) => { say('task.waiting', { taskId: task.id, role: role.id, threadId: thread.id, text: thread.title }); },
+            waitFor: askMs > 0 ? async (threadId, ms, sig) => {
+              const a = await box.wait(threadId, ms, sig);
+              if (!a && !stopped()) { askedAndWaiting = threadId; taskAc.abort(); }
+              return a;
+            } : null,
+          });
+          const tools = withBoardTool(await toolsFor(role), boardTool);
           // A model that is not there — not deployed, no key, gone — is not the task failing:
           // the next model on the roster is appointed and the task tried again, up to three
           // models. Anything else (a refusal, a timeout, a bad request) fails the task.
@@ -168,12 +217,13 @@ export async function runTeam({
             if (attempt > 1) say('task.reappointed', { taskId: task.id, role: role.id, model: m.model, after: [...exclude] });
             const res = await callModel({
               runId: id, taskId: task.id, role: role.id, model: m.model, mode: m.mode || role.mode,
-              system: role.prompt, prompt, tools, signal,
+              system: role.prompt, prompt, tools, signal: taskAc.signal,
               onDelta: (delta, full) => say('task.delta', { taskId: task.id, role: role.id, delta, text: full }),
             });
             usage = res?.usage || null;
             if (usage) budget.charge(usage);
-            if (res?.aborted) { status = 'stopped'; break; }
+            if (askedAndWaiting) { status = 'waiting'; waitingOnPerson = true; break; }
+            if (res?.aborted || taskAc.signal.aborted) { status = 'stopped'; break; }
             // A turn that ended with nothing to say — an agent that exited, a stream that
             // died after its tool calls — is not a done task: three members "completed" empty
             // once, the run merged nothing, and the caller ran the team again. It is treated
@@ -185,21 +235,34 @@ export async function runTeam({
           }
         }
       } catch (e) {
-        status = overBudget ? 'over-budget' : 'failed';
-        error = String(e?.message || e);
+        if (askedAndWaiting) { status = 'waiting'; waitingOnPerson = true; }
+        else { status = overBudget ? 'over-budget' : 'failed'; error = String(e?.message || e); }
       }
       const findings = status === 'ok' ? parseFindings(text, { role: role.id, taskId: task.id }) : [];
       if (findings.length) { board.add(findings); for (const f of findings) say('task.finding', { taskId: task.id, role: role.id, finding: f }); }
-      const row = { id: task.id, role: task.role, title: task.title, status, text, error, usage, ms: now() - t0, findings };
+      const thread = board.threadForTask(task.id);
+      if (thread && status !== 'waiting') board.setThreadStatus(thread.id, 'resolved');
+      const row = { id: task.id, role: task.role, title: task.title, status, text, error, usage, ms: now() - t0, findings, ...(askedAndWaiting ? { waitingOn: askedAndWaiting } : {}) };
       tasksOut.push(row);
-      say(status === 'ok' ? 'task.done' : 'task.failed', { taskId: task.id, role: task.role, status, error, ms: row.ms, findings: findings.length });
+      say(status === 'ok' ? 'task.done' : 'task.failed', { taskId: task.id, role: task.role, status, error, ms: row.ms, findings: findings.length, ...(askedAndWaiting ? { threadId: askedAndWaiting } : {}) });
       if (budget.exhausted()) overBudget = true;
     });
+    // Over budget with work left: ask the person ONCE for more, on the board, before stopping.
+    if (overBudget && !budgetAsked && !stopped()) {
+      budgetAsked = true;
+      const left = tasks.filter((x) => !tasksOut.some((y) => y.id === x.id)).length;
+      const spent = budget.snapshot().spent;
+      const a = await askPerson({ type: 'budget', text: `The team has used its budget (${Object.entries(spent).filter(([k]) => budget.cap[k] !== undefined).map(([k, v]) => `${k} ${v} of ${budget.cap[k]}`).join(', ')}) with ${left} task${left === 1 ? '' : 's'} left. Raise it by half, or stop here with what it has?`, options: ['Raise by half', 'Stop here'] });
+      if (a && /raise|allow|yes|more|continue/i.test(a.text)) { budget.raise(1.5); overBudget = false; }
+    }
   }
   // Every planned task gets a row — what never ran is recorded as skipped, not forgotten.
   for (const task of tasks) if (!tasksOut.some((x) => x.id === task.id)) tasksOut.push({ id: task.id, role: task.role, title: task.title, status: 'skipped', text: '', findings: [] });
   if (stopped()) return finish('stopped');
-  if (overBudget) return finish('over-budget', { proposal: mergeCheap(t, board.all(), tasksOut) });
+  if (waitingOnPerson) return finish('waiting', { proposal: null, budgetAsked });
+  // Over budget is a STOP only when it left work undone; a budget spent on the last task
+  // is a run that finished, and the merge below falls back to the cheap one if it must.
+  if (overBudget && tasksOut.some((x) => x.status === 'skipped' || x.status === 'over-budget')) return finish('over-budget', { proposal: mergeCheap(t, board.all(), tasksOut) });
 
   // ── merge ─────────────────────────────────────────────────────────────────────────────
   say('run.merging', { policy: t.merge });
@@ -213,7 +276,7 @@ export async function runTeam({
       const prompt = [
         `You are the ${judge.name || judge.id} of team "${t.name}". Review the team's findings for the request below and write the final answer — accurate, concise, and only what the findings support. Flag anything the members disagreed on.`,
         `Request: ${String(request || '').trim()}`,
-        boardText(board.all()),
+        boardText(board),
       ].join('\n\n');
       const res = await callModel({ runId: id, taskId: 'merge', role: judge.id, model: m.model, mode: 'model', system: judge.prompt, prompt, tools: undefined, signal });
       if (res?.usage) budget.charge(res.usage);
@@ -230,10 +293,23 @@ export async function runTeam({
   } else {
     proposal = mergeCheap(t, board.all(), tasksOut);
   }
+  // The merge is a proposal thread: a draft the person approves, rejects or replies to.
+  if (proposal?.text || proposal?.agreed) {
+    const th = board.openThread({ kind: 'proposal', title: `Proposal — ${t.merge}`, by: proposal.by || RUNNER });
+    board.post({ threadId: th.id, by: proposal.by || RUNNER, kind: 'draft', status: 'proposed', text: proposal.text || (proposal.agreed || []).map((c) => c.text).join('\n'), refs: [] });
+  }
   const failed = tasksOut.some((x) => x.status !== 'ok');
   return finish(failed ? 'partial' : 'completed', { proposal });
 }
 
+/** Continue a run that ended `waiting` from its checkpoint — the answered ask is on the board. */
+export function resumeTeam({ checkpoint, ...deps } = {}) {
+  if (!checkpoint?.plan?.tasks) throw new TeamRunError('BAD_RESUME', 'a checkpoint with a plan is required');
+  // The waiting task runs again; its ask thread now holds the answer, and boardText gives it
+  // to the member. Tasks recorded `waiting`/`skipped` are dropped from the carried list.
+  return runTeam({ ...deps, resume: checkpoint });
+}
+
 /** No model: the members' work side by side, findings first — always available. */
 function mergeCheap(team, findings, tasks) {
   const sections = tasks.filter((x) => x.status === 'ok').map((x) => {

package/team-tool.js

@@ -116,9 +116,12 @@ export function teamToolProvider({ teams = [], run = null, appoint = null, confi
       if (action === 'run') {
         if (!request) return json({ error: 'run needs a request — what should the team do?' });
         if (typeof run !== 'function') return json({ error: 'This surface cannot run a team.' });
-        const key = `${team.name}\n${request}`;
+        // ONE run per team per turn — keyed by the team, not the request: a model that
+        // re-runs after a partial result rephrases the request each time, and that was a
+        // second circle. Its partial result stands; the person decides what happens next.
+        const key = team.name;
         const prior = ran.get(key);
-        if (prior) return json({ error: `The "${team.name}" team already ran this request in this turn (run ${prior.runId}, ${prior.status}). Do not run it again: tell the user what happened — ${prior.summary} — and ask how to proceed.`, runId: prior.runId, status: prior.status, tasks: prior.tasks });
+        if (prior) return json({ error: `The "${team.name}" team already ran in this turn (run ${prior.runId}, ${prior.status}). Do not run it again, even with a different request: report what it produced — ${prior.summary} — with its proposal, and ask the user how to proceed.`, runId: prior.runId, status: prior.status, tasks: prior.tasks, proposal: prior.proposal });
         const dry = dryRunTeam(team, request, { appoint });
         if (!dry.ok) return json({ error: `No model is available for role(s): ${dry.missing.join(', ')}.`, roles: dry.roles });
         const result = await run({ team, request, toolset: bound });
@@ -126,10 +129,10 @@ export function teamToolProvider({ teams = [], run = null, appoint = null, confi
         const tasks = (result.tasks || []).map((x) => ({ id: x.id, role: x.role, status: x.status, ms: x.ms, findings: (x.findings || []).length, error: x.error || undefined }));
         const failed = tasks.filter((x) => x.status !== 'ok');
         const summary = failed.length ? failed.map((x) => `${x.role} ${x.status}${x.error ? ` (${x.error})` : ''}`).join('; ') : `${findings.length} findings`;
-        ran.set(key, { runId: result.runId, status: result.status, summary, tasks });
+        ran.set(key, { runId: result.runId, status: result.status, summary, tasks, proposal: result.proposal });
         const hint = result.status === 'over-budget' ? 'The team stopped at its budget; the proposal is what it had. Say so.'
           : result.status === 'failed' ? `The run FAILED — ${summary}. Do not run the team again this turn. Tell the user exactly which role failed and why, and ask whether to retry, change the team\'s models in Settings → Teams, or answer without the team.`
-          : failed.length ? `Some roles did not finish — ${summary}. Say so alongside the proposal.` : undefined;
+          : failed.length ? `Some roles did not finish — ${summary}. Present the proposal as the team's answer and say which role did not finish; do NOT run the team again this turn.` : undefined;
         return json({ name: team.name, runId: result.runId, status: result.status, proposal: result.proposal, tasks, findings, usage: result.usage, hint });
       }
       return json({ error: `Unknown action "${action}". Use run, dry_run or save.` });

package/team-trail.js

@@ -10,6 +10,11 @@ export function teamLine(ev) {
     case 'run.started': return { type: 'status', text: `team ${ev.team}: ${(ev.roles || []).join(', ')}` };
     case 'plan.ready': return { type: 'status', text: `plan: ${(ev.tasks || []).length} task${(ev.tasks || []).length === 1 ? '' : 's'} (${ev.by})` };
     case 'task.started': return { type: 'tool', name: role, text: `${role} · ${ev.title || ev.taskId}` };
+    case 'task.waiting': return { type: 'status', text: `${role} is waiting on you — ${ev.text || 'a question on the board'}` };
+    case 'run.waiting': return { type: 'status', text: `waiting on you — ${ev.text || ev.type || 'a question on the board'}` };
+    case 'run.resumed': return { type: 'status', text: `team ${ev.team} resumed${(ev.carried || []).length ? ` (${ev.carried.length} task${ev.carried.length === 1 ? '' : 's'} carried over)` : ''}` };
+    case 'board.post': return ev.post && ev.post.kind !== 'finding' ? { type: 'status', text: `${ev.post.by} ${ev.post.replyTo ? 'replied' : 'posted'} (${ev.post.kind}): ${String(ev.post.text || '').slice(0, 120)}` } : null;
+    case 'board.decision': return { type: 'status', text: `${ev.by || 'someone'} ${ev.status} a post` };
     case 'task.reappointed': return { type: 'status', text: `${role} → ${ev.model} (${(ev.after || []).join(', ')} unavailable)` };
     case 'task.tool': return { type: 'tool', name: ev.name, text: `${role} ran ${ev.name}${ev.text ? ` — ${ev.text}` : ''}` };
     case 'task.finding': return { type: 'status', text: `${role}: ${String(ev.finding?.text || '').slice(0, 140)}` };
@@ -30,7 +35,10 @@ export function teamLanes(prev, ev) {
     case 'task.started': lanes.tasks[ev.taskId] = { ...(lanes.tasks[ev.taskId] || { id: ev.taskId, role: ev.role, title: ev.title }), status: 'running' }; break;
     case 'task.delta': if (lanes.tasks[ev.taskId]) lanes.tasks[ev.taskId] = { ...lanes.tasks[ev.taskId], text: ev.text }; break;
     case 'task.finding': lanes.findings += 1; if (lanes.tasks[ev.taskId]) lanes.tasks[ev.taskId] = { ...lanes.tasks[ev.taskId], findings: (lanes.tasks[ev.taskId].findings || 0) + 1 }; break;
+    case 'task.waiting': if (lanes.tasks[ev.taskId]) lanes.tasks[ev.taskId] = { ...lanes.tasks[ev.taskId], status: 'waiting', waitingOn: ev.threadId }; lanes.waiting = [...(lanes.waiting || []), ev.threadId]; break;
     case 'task.done': case 'task.failed': if (lanes.tasks[ev.taskId]) lanes.tasks[ev.taskId] = { ...lanes.tasks[ev.taskId], status: ev.status || 'ok', ms: ev.ms }; break;
+    case 'board.thread-status': if (ev.status !== 'waiting' && lanes.waiting) lanes.waiting = lanes.waiting.filter((x) => x !== ev.threadId); break;
+    case 'run.waiting': lanes.waiting = [...(lanes.waiting || []), ev.threadId]; break;
     case 'run.done': lanes.status = ev.status; lanes.usage = ev.usage; break;
     default: break;
   }