@chatpanel/events 0.92.1 → 0.95.0

package/team-run.js

@@ -256,7 +256,7 @@ export async function runTeam({
   const running = new Set();
   const isDone = (tid) => carried.has(tid) || tasksOut.some((x) => x.id === tid);
   // A sub-task with no holder cannot run; it is recorded `unassigned` at the end.
-  const ready = () => tasks.filter((x) => x.role && !isDone(x.id) && !running.has(x.id) && (x.dependsOn || []).every(isDone));
+  const ready = () => tasks.filter((x) => x.role && x.kind !== 'merge' && !isDone(x.id) && !running.has(x.id) && (x.dependsOn || []).every(isDone));
   let subtasks = tasks.filter((x) => x.parent).length;
 
   /**
@@ -378,7 +378,11 @@ export async function runTeam({
       // say it needs among what the role holds. A model attempt that ends with zero calls
       // while holding one of these is nudged once, then may finish.
       const grantsHeld = role?.grants || [];
-      const mustUse = role?.mode === 'model' ? [...new Set([...grantsNeededFor(task.prompt, { held: grantsHeld }), ...(task.grants || []).filter((g) => grantsHeld.includes(g) || (g.startsWith('mcp:') && grantsHeld.includes('mcp')))])] : [];
+      // THE MERGE IS A TASK LIKE THE OTHERS (its row, thread, transcript and work log), with
+      // three differences: it reads the whole board, it answers in prose rather than findings,
+      // and it is never nudged — "verify a figure with a tool" is its instruction, not a need.
+      const isMerge = task.kind === 'merge';
+      const mustUse = role?.mode === 'model' && !isMerge ? [...new Set([...grantsNeededFor(task.prompt, { held: grantsHeld }), ...(task.grants || []).filter((g) => grantsHeld.includes(g) || (g.startsWith('mcp:') && grantsHeld.includes('mcp')))])] : [];
       let nudged = false;
       try {
         if (!role) throw new Error(`no role "${task.role}" in the team`);
@@ -392,12 +396,12 @@ export async function runTeam({
           if (!budget.canAfford({ tokens: 0 })) { overBudget = true; throw new Error('over budget'); }
           // 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');
+          const prior = boardText(board, { taskIds: !isMerge && task.dependsOn?.length ? task.dependsOn : null, role: role.id });
+          const prompt = [task.prompt, prior, isMerge ? '' : findingsInstruction()].filter(Boolean).join('\n\n');
           // A host may build a toolset asynchronously (connecting MCP servers takes time).
           // 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,
+            board, role: role.id, taskId: task.id, taskIds: !isMerge && 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 }); },
             onRequest: (req) => onRequest(task, role, req),
             waitFor: askMs > 0 ? async (threadId, ms, sig) => {
@@ -513,7 +517,8 @@ export async function runTeam({
       } finally {
         unsubscribe?.();
       }
-      const findings = status === 'ok' ? parseFindings(text, { role: role?.id, taskId: task.id }) : [];
+      // The merge's answer is the proposal, not a finding of its own (it would double every claim).
+      const findings = status === 'ok' && !isMerge ? 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 thread = board.threadForTask(task.id);
       // The thread says how the task ended. A failure is posted in it as well — a person reading
@@ -532,7 +537,7 @@ export async function runTeam({
         say('task.scored', {
           agentId: role.agent || role.id, taskId: task.id, role: role.id, model: lastModelOf(attempts), engine: routed?.engine || null, scm: scm || undefined, outcome: status === 'ok' ? 'task.done' : 'task.failed',
           size: { ms: row.ms, steps: (row.transcript || []).length, tools: (row.transcript || []).filter((m) => m.role === 'tool').length, findings: findings.length, tokens: usage ? Number(usage.input_tokens || usage.prompt_tokens || 0) + Number(usage.output_tokens || usage.completion_tokens || 0) : 0 },
-          roleKind: 'ic', tools: toolNamesOf(row.transcript), with: t.roles.filter((r) => r.id !== role.id).map((r) => r.agent || r.id),
+          roleKind: isMerge ? 'orchestrator' : 'ic', tools: toolNamesOf(row.transcript), with: t.roles.filter((r) => r.id !== role.id).map((r) => r.agent || r.id),
           refs: [`run:${id}`, ...(board.threadForTask(task.id) ? [`thread:${board.threadForTask(task.id).id}`] : [])], error: error || undefined,
           ...(task.parent ? { parent: task.parent, requestedBy: task.requestedBy || null } : {}),
         });
@@ -551,7 +556,7 @@ export async function runTeam({
     // 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) => x.role && !tasksOut.some((y) => y.id === x.id)).length;
+      const left = tasks.filter((x) => x.role && x.kind !== 'merge' && !tasksOut.some((y) => y.id === x.id)).length;
       const spent = budget.snapshot().spent;
       const what = left ? `${left} task${left === 1 ? '' : 's'} and the merge left` : 'only the merge left';
       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 ${what}. Raise it by half, or stop here with what it has?`, options: ['Raise by half', 'Stop here'] });
@@ -560,7 +565,7 @@ export async function runTeam({
   }
   // Every planned task gets a row — what never ran is recorded as skipped, not forgotten;
   // a sub-task nobody took is `unassigned`, which is its own kind of undone.
-  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: task.parent && !task.role ? 'unassigned' : 'skipped', text: '', findings: [], ...(task.parent ? { parent: task.parent } : {}) });
+  for (const task of tasks) if (task.kind !== 'merge' && !tasksOut.some((x) => x.id === task.id)) tasksOut.push({ id: task.id, role: task.role, title: task.title, status: task.parent && !task.role ? 'unassigned' : 'skipped', text: '', findings: [], ...(task.parent ? { parent: task.parent } : {}) });
   if (stopped()) return finish('stopped');
   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
@@ -574,46 +579,32 @@ export async function runTeam({
   if (!okTasks.length) return finish('failed', { proposal: null });
   if (t.merge === 'judge') {
     const judge = roleOf(t.judge) || strongestRole(t);
-    const m = modelFor(judge);
-    if (m?.model && budget.canAfford({ tokens: 0 })) {
-      const prompt = [
-        `You are the ${judge.name || judge.id} of team "${t.name}". The members' work is on the board below (and in the board tool). Write the team's FINAL ANSWER to the request: complete, well organised, only what the findings support, with the refs they came from. Say plainly what was not found or assumed. Flag anything the members disagreed on. Do not research from scratch — verify a figure with a tool only where the board is silent or contradictory.`,
-        `Request: ${String(request || '').trim()}`,
-        boardText(board),
-      ].join('\n\n');
-      // The judge works with its own grants (it may verify a figure) and the board — and it
-      // is a run member like the others: a model that is not there rotates.
-      say('task.started', { taskId: 'merge', role: judge.id, title: `merge (${judge.name || judge.id})` });
-      const judgeTools = withBoardTool(withRunCache(await toolsFor(judge), runCache, { role: judge.id }), boardToolProvider({ board, role: judge.id, taskId: 'merge', taskIds: null }));
-      let res = null;
-      const excl = new Set();
-      let judgeErr = '';
-      let judgeModel = null; // the appointment that answered (or the last one tried)
-      let judgeRoute = null;
-      for (let attempt = 1; attempt <= MAX_APPOINTMENTS; attempt++) {
-        const mm = attempt === 1 ? (runExclude.has(m?.model) ? modelFor(judge, excluding(excl)) : m) : modelFor(judge, excluding(excl));
-        if (!mm?.model) break;
-        if (attempt > 1) say('task.reappointed', { taskId: 'merge', role: judge.id, model: mm.model, after: [...excl], error: judgeErr });
-        say('task.model', { taskId: 'merge', role: judge.id, model: mm.model, attempt });
-        judgeModel = mm; judgeRoute = routeOf(mm, judge, { attempt, exclude: excl });
-        say('task.routed', { taskId: 'merge', role: judge.id, attempt, ...judgeRoute });
-        res = await callModel({ runId: id, taskId: 'merge', role: judge.id, model: mm.model, mode: 'model', system: judge.prompt, prompt, tools: judgeTools, signal, onDelta: (delta, full) => say('task.delta', { taskId: 'merge', role: judge.id, delta, text: full }) });
-        if (res?.usage) budget.charge(res.usage);
-        if (res?.ok && String(res.text || '').trim()) break;
-        const err = res?.ok ? 'the model returned no answer' : (res?.error || 'the model did not answer');
-        if (stopped() || !isModelUnavailable(err)) break;
-        excl.add(mm.model); runExclude.add(mm.model); judgeErr = err;
-      }
-      const judged = res?.ok && String(res.text || '').trim();
-      say(judged ? 'task.done' : 'task.failed', { taskId: 'merge', role: judge.id, status: judged ? 'ok' : 'failed', error: judged ? null : (res?.error || 'the judge did not answer'), findings: 0 });
-      const judgeScm = normalizeScm(res?.scm);
-      if (judgeScm) say('task.scm', { taskId: 'merge', role: judge.id, ...judgeScm });
-      say('task.scored', { agentId: judge.id, taskId: 'merge', role: judge.id, model: judgeModel?.model || m?.model, engine: judgeRoute?.engine || null, scm: judgeScm || undefined, outcome: judged ? 'task.done' : 'task.failed', size: { ms: 0, steps: 1, tools: 0, findings: board.all().length, tokens: 0 }, roleKind: 'orchestrator', tools: [], with: t.roles.filter((r) => r.id !== judge.id).map((r) => r.agent || r.id), refs: [`run:${id}`] });
-      say('run.usage', { usage: budget.snapshot() });
-      proposal = judged ? { kind: 'answer', text: String(res.text || ''), by: judge.id } : mergeCheap(t, board.all(), tasksOut);
-    } else {
-      proposal = mergeCheap(t, board.all(), tasksOut);
+    // The judge's task IS the merge (team-plan.js fixedPlan) — and it is a TASK: a row on the
+    // record, a thread, a transcript, a work log, a scorecard entry with real evidence. Before
+    // this it was a bare model call whose task.started/task.done named a task the record did
+    // not have, so the fold dropped them and the writer of the final answer showed nowhere.
+    // A resumed run that died mid-merge finds the task on its plan and continues it.
+    let mergeTask = tasks.find((x) => x.kind === 'merge');
+    if (!mergeTask) {
+      mergeTask = {
+        id: 'merge', kind: 'merge', role: judge.id, title: `merge (${judge.name || judge.id})`,
+        prompt: [
+          `You are the ${judge.name || judge.id} of team "${t.name}". The members' work is on the board below (and in the board tool). Write the team's FINAL ANSWER to the request: complete, well organised, only what the findings support, with the refs they came from. Say plainly what was not found or assumed. Flag anything the members disagreed on. Do not research from scratch — verify a figure with a tool only where the board is silent or contradictory.`,
+          `Request: ${String(request || '').trim()}`,
+        ].join('\n\n'),
+        dependsOn: tasks.filter((x) => x.role && x.kind !== 'merge').map((x) => x.id),
+      };
+      tasks.push(mergeTask);
+      say('task.added', { taskId: mergeTask.id, kind: 'merge', role: mergeTask.role, title: mergeTask.title, dependsOn: mergeTask.dependsOn });
+      board.openThread({ taskId: mergeTask.id, kind: 'task', title: mergeTask.title, by: RUNNER, holder: judge.id });
     }
+    const done = tasksOut.find((x) => x.id === mergeTask.id && x.status === 'ok');
+    const row = done || (modelFor(judge)?.model && budget.canAfford({ tokens: 0 }) ? await runTask(mergeTask) : null);
+    // The merge is a task: stopped or waiting on a person mid-way, the run is too — and it
+    // resumes from the merge's transcript, like any other.
+    if (stopped()) return finish('stopped');
+    if (waitingOnPerson) return finish('waiting', { proposal: null, budgetAsked });
+    proposal = row?.status === 'ok' && String(row.text || '').trim() ? { kind: 'answer', text: String(row.text), by: judge.id, taskId: mergeTask.id } : mergeCheap(t, board.all(), tasksOut);
   } else if (t.merge === 'converge') {
     const drafts = okTasks.map((x) => ({ claims: toBriefClaims(x.findings) }));
     const { agreed, disputed } = converge(drafts, { minAgree: Math.min(2, drafts.length) });

package/team-tool.js

@@ -1,4 +1,6 @@
-// The `team` tool — a team invoked from any chat: run, dry_run, save.
+// The `team` tool — a team invoked from any chat: run, dry_run, save — and `project`, a goal
+// handed to the executive (project-run.js): jobs, recruiting, rounds run as teams, a review,
+// follow-ups, done-when, every step on the project record a person reads on the board.
 //
 // The recipe tool's twin, on purpose: one registered tool whose description is the
 // catalogue, `dry_run` showing what a person would approve, `save` proposing a team from the
@@ -48,13 +50,18 @@ export function teamToolSpec(teams) {
       + 'Actions: {"action":"run","name":"<team>","request":"<what to do>"} runs one (streams; may take a while); '
       + '{"action":"dry_run","name":"<team>","request":"…"} shows roles, models, tools and budget without running; '
       + '{"action":"save","team":{…}} proposes a NEW team after a task that would benefit from several roles — the user approves it on a card. '
+      + '{"action":"project","goal":"<what done looks like>","title":"<short name>","doneWhen":"<a check the result can be held to>","budget":{"tokens":200000,"ms":3600000}} hands a GOAL to the executive: it posts jobs, recruits agents from the pool for each, runs them as teams in rounds, reviews the results against done-when, posts follow-ups, asks the user before spending or changing scope, and closes when done-when holds (may take a long while; use it for a goal with several parts, not a question). '
       + 'A team: {"name":"research" (a short identifier: letters, digits, - _; used as /research),"description":"…","roles":[{"id":"researcher","prompt":"…","prefer":"balanced","grants":["data","web"]},{"id":"writer","prompt":"…","prefer":"strong","grants":["none"]}],"merge":"judge","judge":"writer","budget":{"tokens":40000,"ms":300000}}. '
       + 'grants: none | data | web | history | mcp | mcp:<server> | shell | fs:write | scm:read | scm:push | scm:pr. A role may say "agent":"<id>" instead of a prompt to stand for an agent from the pool. merge: judge | converge | concat | first. A budget is required. '
       + 'Order the work with "dependsOn": a role that builds on another\'s findings (a budget checker on a researcher) lists it, so it runs after and reads the board instead of searching again. The judge does not need a task of its own - the merge is its work.',
     parameters: {
       type: 'object',
       properties: {
-        action: { type: 'string', enum: ['run', 'dry_run', 'save'] },
+        action: { type: 'string', enum: ['run', 'dry_run', 'save', 'project'] },
+        goal: { type: 'string', description: 'For project: the goal, in the user\'s words — what done looks like.' },
+        title: { type: 'string', description: 'For project: a short name.' },
+        doneWhen: { type: 'string', description: 'For project: the check the result is held to.' },
+        budget: { type: 'object', description: 'For project: {"tokens","ms","usd"} for the whole project.', additionalProperties: true },
         name: { type: 'string', description: 'Team name, for run / dry_run.' },
         request: { type: 'string', description: 'What the team should do, for run / dry_run.' },
         team: { type: 'object', description: 'The team to save, for save.', additionalProperties: true },
@@ -82,13 +89,16 @@ const json = (v) => JSON.stringify(v);
  * @param appoint      `(role) => { model, mode } | null` for the dry run
  * @param confirmSave  `async (detail, team) => 'allow' | 'deny'`; absent = save refused
  * @param saveTeam     `async (team) => void`
+ * @param runProject   `async ({ goal, title, doneWhen, budget, toolset }) => project result` — the
+ *                     host's executive loop (project-run.js runProject with its own deps);
+ *                     absent, the action is refused
  */
 /**
  * `resolve` is the host's `(team) => team` that fills roles standing for agents from the
  * pool (agent.js resolveTeam) — applied before a dry run and before a run, never to what is
  * saved: the stored team keeps its references, the run gets the cards as they are now.
  */
-export function teamToolProvider({ teams = [], run = null, appoint = null, confirmSave = null, saveTeam = null, resolve = null } = {}) {
+export function teamToolProvider({ teams = [], run = null, appoint = null, confirmSave = null, saveTeam = null, resolve = null, runProject = null } = {}) {
   const byName = new Map(usable(teams).map((t) => [t.name, t]));
   // A team whose roles stand for agents is filled from the pool on the way to a run; a
   // resolver that throws (an agent missing from the pool) is the tool's error, not a crash.
@@ -103,6 +113,7 @@ export function teamToolProvider({ teams = [], run = null, appoint = null, confi
     specs: [teamToolSpec(teams)],
     system: [
       byName.size ? 'Saved agent teams exist (see the `team` tool). When a request is broad enough that several roles would do it better — research plus writing, several sources to reconcile — run the matching team rather than doing it all in one turn.' : '',
+      runProject ? 'A GOAL with several parts (a project, not a question) goes to the executive: call the `team` tool with {"action":"project","goal":…,"doneWhen":…} and report what it produced.' : '',
       (confirmSave && saveTeam) ? 'When the user asks to create, make, set up or save a team (of agents / roles), do not run one: call the `team` tool with {"action":"save","team":{…}} — pick roles, prompts, grants and a budget from what they said, and ask only for what you cannot infer. The user approves it on a card.' : '',
     ].filter(Boolean).join(' '),
     bind(toolset) { bound = toolset; },
@@ -127,6 +138,26 @@ export function teamToolProvider({ teams = [], run = null, appoint = null, confi
         return json({ saved: stored.name, roles: stored.roles.map((r) => r.id), hint: `Run it with {"action":"run","name":"${stored.name}","request":"…"} or by typing /${stored.name}.` });
       }
 
+      if (action === 'project') {
+        const goal = String(input?.goal || '').trim();
+        if (!goal) return json({ error: 'project needs a goal — what does done look like?' });
+        if (typeof runProject !== 'function') return json({ error: 'This surface cannot run a project. Run a team instead, or describe the jobs.' });
+        // One project per turn, like one run per team: a loop that asks the person and gets
+        // "stop" is not started again with a rephrased goal.
+        if (ran.has('project')) { const p = ran.get('project'); return json({ error: `A project already ran in this turn (${p.projectId}, ${p.status}). Report its result and ask the user how to proceed.`, ...p }); }
+        let result;
+        try {
+          result = await runProject({ goal, title: String(input?.title || '').trim(), doneWhen: String(input?.doneWhen || '').trim(), budget: input?.budget && typeof input.budget === 'object' ? input.budget : null, toolset: bound });
+        } catch (e) { return json({ error: e?.message || String(e) }); }
+        const out = { projectId: result.projectId, status: result.status, rounds: result.rounds, jobs: result.jobs, runs: result.runs, report: result.report, spend: result.spend, why: result.why || undefined };
+        ran.set('project', out);
+        const hint = result.status === 'done' ? 'Done-when holds and the project is closed. Present the report as the answer; the jobs and their runs are on the board.'
+          : result.status === 'over-budget' ? 'The project stopped at its budget; the report so far stands. Say so and ask whether to raise it.'
+          : result.status === 'failed' ? `The project FAILED — ${result.why || 'see the jobs'}. Do not start it again this turn; tell the user which job failed and why.`
+          : `The project is ${result.status}${result.why ? ` — ${result.why}` : ''}. Present the report so far and say what is left; do not start it again this turn.`;
+        return json({ ...out, hint });
+      }
+
       const team = byName.get(String(input?.name || ''));
       if (!team) return json({ error: `No team named "${input?.name}".`, available: [...byName.keys()] });
       const request = String(input?.request || '').trim();
@@ -159,7 +190,7 @@ export function teamToolProvider({ teams = [], run = null, appoint = null, confi
           : 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.` });
+      return json({ error: `Unknown action "${action}". Use run, dry_run, save or project.` });
     },
   };
 }

package/team-trail.js

@@ -9,6 +9,7 @@ export function teamLine(ev) {
   switch (ev.type) {
     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.added': return { type: 'status', text: `${ev.kind === 'merge' ? 'the merge' : ev.title || ev.taskId} is ${role}'s${(ev.dependsOn || []).length ? ` — after ${ev.dependsOn.join(', ')}` : ''}` };
     case 'task.started': return { type: 'tool', name: role, text: `${role} · ${ev.title || ev.taskId}${ev.resumed ? ` (resumed, ${ev.steps} steps so far)` : ''}` };
     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'}` };
@@ -30,6 +31,14 @@ export function teamLine(ev) {
     case 'task.failed': return { type: 'error', text: `${role} ${ev.status || 'failed'}${ev.error ? ` — ${ev.error}` : ''}` };
     case 'run.merging': return { type: 'status', text: `merging (${ev.policy})` };
     case 'run.done': return { type: 'status', text: `team ${ev.status}${ev.usage?.spent?.tokens ? ` · ${ev.usage.spent.tokens} tokens` : ''}` };
+    // A PROJECT (project-run.js): the executive's steps, the jobs, the report — the same
+    // strip a run's lines go to, so a person sees the loop move without opening the board.
+    case 'project.thinking': return { type: 'status', text: `executive is ${ev.what === 'project_review' ? 'reviewing the round' : 'planning the jobs'}${ev.model ? ` (${ev.model})` : ''}` };
+    case 'project.status': return { type: 'status', text: `project ${ev.status}${ev.by ? ` (${ev.by})` : ''}` };
+    case 'project.decision': return ev.kind === 'answer' || ev.kind === 'status' ? null : { type: 'status', text: `${ev.by || 'executive'} · ${ev.kind}: ${String(ev.text || '').split('\n')[0].slice(0, 140)}` };
+    case 'job.posted': return { type: 'status', text: `job posted: ${ev.job?.title || ev.job?.id || '?'}${ev.job?.needs?.skills?.length ? ` (${ev.job.needs.skills.join(', ')})` : ''}` };
+    case 'job.updated': return ev.job?.status && ['recruited', 'done', 'failed'].includes(ev.job.status) ? { type: ev.job.status === 'failed' ? 'error' : 'status', text: `job ${ev.job.id} ${ev.job.status}${ev.job.recruited?.agentId ? ` → ${ev.job.recruited.agentId}` : ''}${ev.job.status === 'failed' && ev.job.result?.text ? ` — ${String(ev.job.result.text).slice(0, 120)}` : ''}` } : null;
+    case 'project.report': return { type: 'status', text: `report written (${ev.by || 'executive'})` };
     default: return null;
   }
 }
@@ -40,6 +49,7 @@ export function teamLanes(prev, ev) {
   switch (ev.type) {
     case 'run.started': lanes.team = ev.team; lanes.roles = ev.roles; break;
     case 'plan.ready': for (const t of ev.tasks || []) lanes.tasks[t.id] = { id: t.id, role: t.role, title: t.title, status: 'pending', findings: 0 }; break;
+    case 'task.added': lanes.tasks[ev.taskId] = { id: ev.taskId, role: ev.role, title: ev.title, status: 'pending', findings: 0, ...(ev.kind ? { kind: ev.kind } : {}) }; break;
     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;

package/tool-hints.js

@@ -24,7 +24,13 @@ export function sourceCitationSystem({ compact = false } = {}) {
 
 export function toolStatus(result) {
   const o = resultObject(result);
-  if (!o) return '';
+  if (!o) {
+    // A plain-text result (a search's prose, a relayed agent's line): an error when it says
+    // so the way the shared tools do — `error: …`, `web_search failed: …` — else fine.
+    const s = typeof result === 'string' ? result : (result && typeof result === 'object' && typeof result.text === 'string' ? result.text : '');
+    if (!s.trim()) return '';
+    return /^(error:|\w+ failed\b)/i.test(s) ? `error: ${s.slice(0, 80)}` : 'ok';
+  }
   if (o.error) {
     const detail = errorDetail(o);
     if (o.blocked) return `blocked: ${detail}`.slice(0, 90);

package/tool-loop-guard.js

@@ -0,0 +1,184 @@
+// The loop guard — what stops a model that keeps asking the same thing.
+//
+// Lived inside the extension's providers.js for a year, which meant the desktop could not
+// use it and wrote a smaller one (a `seen` map and a repeat count) that answered the same
+// model behaviour differently: the extension blocked a repeated write BEFORE running it,
+// the desktop ran it once and replayed it; the extension noticed a whole round repeating,
+// the desktop only a single call. Same tools, same model, two outcomes. Now one guard,
+// with everything either client had learned:
+//
+//   • a call repeated past `maxIdenticalCalls` is not executed — a READ is answered from
+//     its first result (a pure read asked twice has one answer, and refusing it is how a
+//     small model concludes the tool is broken and invents an answer); a WRITE is refused
+//     with a result that says why, because replaying a click would be a lie about
+//     something that changed the world;
+//   • observation tools never count — read → act → read again with the same empty input
+//     is correct, not a loop;
+//   • a discrete-input tool that SUCCEEDED (a keystroke, a click) is progress and clears
+//     its own count — pressing Enter twice is normal; failing to press it twice is not;
+//   • a ROUND that repeats the previous round byte for byte, or in which every call was
+//     blocked, counts toward `stalled` — and a stalled turn is offered no more tools, so
+//     the model has to answer with what it has;
+//   • `repeats` counts every replay and refusal across the turn, so a loop can tell when
+//     the model has been told enough times (the desktop's rule: three, then a closing
+//     request with no tools).
+//
+// Class R: no I/O, no clock. Names are read through `effectiveToolName` so a dispatched
+// action is judged on what it is, not on the dispatcher's name.
+
+import { effectiveToolName } from './tool-traits.js';
+import { resultText } from './adaptive-tool-policy.js';
+
+export const DEFAULT_MAX_IDENTICAL_CALLS = 3;
+export const DEFAULT_MAX_STALLED_ROUNDS = 2;
+export const DEFAULT_MAX_REPEATS = 3;
+
+// Observation/read tools are MEANT to be repeated with the SAME (empty) input.
+export const OBSERVATION_TOOLS = new Set(['inspect_page', 'read_canvas', 'screenshot', 'marked_screenshot']);
+
+// Tools whose whole job is ONE discrete physical input. A SUCCESSFUL application counts as
+// progress and clears the repeat count; a failing one (unknown key, nothing at point) does
+// not, so a genuinely stuck call still trips the guard.
+export const INPUT_PROGRESS_TOOLS = new Set([
+  'press_key', 'type_text', 'click_at', 'move_mouse', 'click_mark', 'draw_path', 'input_sequence',
+  'click_element', 'click_by_text',
+]);
+
+/** A tool whose repetition signals a LOOP (search/query/fetch), not one meant to repeat. */
+export function isLoopableTool(name) {
+  return !OBSERVATION_TOOLS.has(name) && !INPUT_PROGRESS_TOOLS.has(name) && name !== 'scroll';
+}
+
+function stableStringify(value) {
+  if (value == null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`;
+}
+
+/** The identity of a call: its name and its arguments with keys in a stable order. */
+export function stableToolCallKey(name, input) {
+  return `${String(name || '')}\n${stableStringify(input ?? {})}`;
+}
+
+/** The identity of a ROUND: its loopable calls, sorted — so a re-read or a scroll never makes two rounds look alike. */
+export function roundSignature(calls) {
+  return (Array.isArray(calls) ? calls : [])
+    .filter((c) => isLoopableTool(effectiveToolName(c?.name, c?.input)))
+    .map((c) => stableToolCallKey(c.name, c.input))
+    .sort()
+    .join('|');
+}
+
+/** The result a refused repeat receives — machine-readable, with the way out spelled out. */
+export function blockedToolResult(name, message, extra = {}) {
+  return JSON.stringify({
+    ok: false,
+    blocked: true,
+    error: 'tool_loop_blocked',
+    tool: name || 'tool',
+    message,
+    retry_hint: 'Answer using the already available conversation context and tool results. Do not call more tools unless the user asks you to continue.',
+    ...extra,
+  });
+}
+
+/**
+ * Did a repeatable tool actually do something? For `scroll`, "more page below"; for a
+ * discrete input, `ok: true`. Anything else is not progress — the step cap is the backstop.
+ */
+export function toolMadeProgress(name, result, input = null) {
+  // Through the dispatcher too: `page {action:'scroll'}` is a scroll. Judged by the bare
+  // name, four scrolls through `page` looked like a stuck loop and were blocked.
+  const eff = effectiveToolName(name, input);
+  if (eff === 'scroll') {
+    try { return JSON.parse(resultText(result))?.atBottom === false; } catch { return false; }
+  }
+  if (INPUT_PROGRESS_TOOLS.has(eff)) {
+    try { return JSON.parse(resultText(result))?.ok === true; } catch { return false; }
+  }
+  return false;
+}
+
+/**
+ * @param maxIdenticalCalls  how many times the SAME call runs before it is replayed or refused
+ * @param maxStalledRounds   how many no-progress rounds in a row before `stalled`
+ * @param maxRepeats         how many replays/refusals in a turn before `looping`
+ */
+export function createToolLoopGuard({
+  maxIdenticalCalls = DEFAULT_MAX_IDENTICAL_CALLS,
+  maxStalledRounds = DEFAULT_MAX_STALLED_ROUNDS,
+  maxRepeats = DEFAULT_MAX_REPEATS,
+} = {}) {
+  const counts = new Map();
+  const lastResult = new Map(); // key → what that identical call returned the first time
+  let stalledRounds = 0;
+  let lastSignature = null;
+  let repeats = 0;
+
+  return {
+    // No nuclear per-turn kill switch — one looping tool must not disable the rest. The
+    // round cap is the overall backstop.
+    get disabled() { return false; },
+    get stalled() { return stalledRounds >= maxStalledRounds; },
+    /** Replays and refusals so far this turn. */
+    get repeats() { return repeats; },
+    /** The model has been answered "you already asked that" enough times to stop asking. */
+    get looping() { return repeats >= maxRepeats; },
+
+    /**
+     * After each round, note progress. No progress = every call was blocked, OR the round's
+     * loopable call-set is byte-identical to the previous round's (a loop even before the
+     * per-tool threshold trips). An exact-repeat round is definitive — two strikes at once.
+     */
+    noteRound(blockedCount, total, signature = '') {
+      const allBlocked = total > 0 && blockedCount >= total;
+      const repeatRound = !!signature && signature === lastSignature;
+      lastSignature = signature;
+      if (repeatRound) stalledRounds += 2;
+      else if (allBlocked) stalledRounds += 1;
+      else stalledRounds = 0;
+    },
+
+    /** Clear a call's repeat count when it actually made progress. */
+    reset(key) { if (key) counts.delete(key); },
+
+    /** Remember what a READ returned, so a repeat can be answered instead of refused. */
+    remember(key, name, input, result, { readOnly = false } = {}) {
+      if (!key || !result || !readOnly) return;
+      lastResult.set(key, result);
+    },
+
+    /**
+     * Should this call run? `{ blocked, replayed, count, key, result }` — `result` is what to
+     * answer with when it should not.
+     */
+    check(name, input) {
+      if (OBSERVATION_TOOLS.has(effectiveToolName(name, input))) return { blocked: false };
+      const key = stableToolCallKey(name, input);
+      const count = (counts.get(key) || 0) + 1;
+      counts.set(key, count);
+      if (count > maxIdenticalCalls && lastResult.has(key)) {
+        // Serve the answer it already earned — and say so, because a model that repeats
+        // itself is usually waiting for a value that will not change. Still counted, so a
+        // genuinely stuck loop stays visible in the log.
+        repeats += 1;
+        const prior = lastResult.get(key);
+        const note = '[This exact call was already made this turn; the result is unchanged. Answer from what you have.]';
+        const result = typeof prior === 'string' ? `${prior}\n\n${note}` : (prior && typeof prior === 'object' && typeof prior.text === 'string' ? { ...prior, text: `${prior.text}\n\n${note}` } : prior);
+        return { blocked: false, replayed: true, count, key, result };
+      }
+      if (count > maxIdenticalCalls) {
+        repeats += 1;
+        return {
+          blocked: true, count, key,
+          result: blockedToolResult(
+            name,
+            `Skipped a repeated identical ${name || 'tool'} call (${count}× with the same input). Vary the input or try a different action — your other tools still work.`,
+            { repeated: true, identicalCallCount: count, maxIdenticalCalls },
+          ),
+        };
+      }
+      return { blocked: false, count, key };
+    },
+  };
+}

package/tool-traits.js

@@ -150,9 +150,33 @@ export function withDestructiveGate(toolset, { confirm = null, only = () => true
   };
 }
 
-// A dispatcher carries the real action in `input.action`; the gate must see through it or
-// `mcp {action:"mcp_x__delete_repo"}` is judged by the name "mcp".
-function defaultEffectiveName(name, input) {
+// A dispatcher carries the real action in `input.action`; every name-based policy must
+// see through it or `mcp {action:"mcp_x__delete_repo"}` is judged by the name "mcp" — and
+// `page {action:'screenshot'}` taken four times looks like a stuck loop instead of a look.
+// One definition: the extension, the desktop and the gate each had their own copy.
+export function effectiveToolName(name, input) {
   const action = input && typeof input === 'object' ? input.action : null;
   return typeof action === 'string' && action ? action : name;
 }
+const defaultEffectiveName = effectiveToolName;
+
+// Local tools whose reads may overlap in one round: they touch the user's own data or the
+// network, never the one tab a page tool is driving. Everything not remote and not here
+// runs one at a time, whatever its name says — a wrong "parallel" races the world, a wrong
+// "serial" only costs latency. The `find` dispatcher is here as a whole: everything behind
+// it is a read of the user's data or the web (its writes are separate tools by design).
+//
+// ONE list. The extension and the desktop each kept their own and they drifted within
+// weeks — the desktop serialised `recall` and `skill_open` that the extension overlapped.
+export const PARALLEL_LOCAL_RE = /^(find$|history_|web_search$|weather$|get_result$|skill_open$|skill_file$|recall$|memory_recall$|meeting_live_transcript$)/;
+
+/**
+ * May this call share a batch with its neighbours? Read-only by its traits, not pinned
+ * serial by the toolset, and either remote (its own server) or on the local overlap list.
+ */
+export function parallelEligible(tools, call, traits) {
+  if (!traits?.readOnly) return false;
+  if (tools?.serialTools?.has(call.name)) return false;
+  const eff = effectiveToolName(call.name, call.input);
+  return !!tools?.remoteTools?.has(call.name) || PARALLEL_LOCAL_RE.test(eff) || PARALLEL_LOCAL_RE.test(call.name);
+}