@chatpanel/events 0.89.3 → 0.90.0

package/index.js

@@ -212,7 +212,8 @@ export { DEFAULT_MIN_CALLS, cardOverride, applyCard } from './model-candidates.j
 export { SCM_KINDS, validateConnection, normalizeConnection, parseRemote, connectionFor, branchFor, worktreeDirFor, credentialEnv, describeConnection, blankConnection, connectionFromForm } from './scm-connection.js';
 export { messagesFor, mergeTranscript, clipTranscript, clipMessage, newSteps, continuationNote, createControl, STEP_MAX_CHARS, TASK_TRANSCRIPT_MAX_CHARS } from './team-task.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 { teamToolProvider, teamToolSpec, teamToolTimeoutMs, describeTeamForApproval, TEAM_TOOL_NAME } from './team-tool.js';
+export { workLogFor, workLogText, workLogEvidence, describeCall, WORKLOG_KINDS } from './team-worklog.js';
 export { teamLine, teamLanes } from './team-trail.js';
 export { mcpDispatchProvider, MCP_TOOL_NAME } from './mcp-dispatch.js';
 export { createManifest, ManifestError, SOURCES } from './manifest.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.89.3",
+  "version": "0.90.0",
   "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",
@@ -107,6 +107,7 @@
     "./team-run.js": "./team-run.js",
     "./team-tool.js": "./team-tool.js",
     "./team-trail.js": "./team-trail.js",
+    "./team-worklog.js": "./team-worklog.js",
     "./team.js": "./team.js",
     "./text-search.js": "./text-search.js",
     "./theme.js": "./theme.js",
@@ -238,6 +239,7 @@
     "team-run.js",
     "team-tool.js",
     "team-trail.js",
+    "team-worklog.js",
     "team.js",
     "text-search.js",
     "theme.js",

package/team-board.js

@@ -74,7 +74,9 @@ export function parseFindings(text, { role, taskId } = {}) {
 // ── threads, posts, asks ────────────────────────────────────────────────────────────────
 
 export const THREAD_KINDS = Object.freeze(['task', 'ask', 'discussion', 'proposal']);
-export const THREAD_STATUSES = Object.freeze(['open', 'waiting', 'resolved', 'approved', 'rejected']);
+// `failed`: the task behind the thread ended without an answer (every model on the roster
+// tried, or a hard error) — not `resolved`, which read as "done" on the board.
+export const THREAD_STATUSES = Object.freeze(['open', 'waiting', 'resolved', 'failed', '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']);

package/team-run.js

@@ -23,7 +23,7 @@ import { fixedPlan, plannerPrompt, parsePlan, waves } from './team-plan.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 { createRunCache, withRunCache } from './team-cache.js';
-import { messagesFor, mergeTranscript, clipTranscript, clipMessage as clipTranscriptOne, newSteps, continuationNote } from './team-task.js';
+import { messagesFor, mergeTranscript, clipTranscript, clipMessage as clipTranscriptOne, newSteps, continuationNote, isThought } from './team-task.js';
 import { converge } from './promotion.js';
 
 export const RUN_STATUSES = Object.freeze(['planning', 'running', 'merging', 'waiting', 'completed', 'partial', 'over-budget', 'stopped', 'failed']);
@@ -58,7 +58,11 @@ export function isModelUnavailable(error) {
   // Also: a relayed agent that exited, a provider that closed the stream, and a turn that
   // came back with nothing — the model did not answer, and the next one might. A refusal,
   // a timeout the caller set, a bad request or a budget stop are not this.
-  return /model[_ ]not[_ ]found|not found|not deployed|inaccessible|does not exist|no such model|unknown model|unsupported model|not available|unavailable|no api key|not configured|"status":\s*(404|401|403|500|502|503)\b|\b(404|401|403|502|503)\b|exited \d+|returned no answer|did not answer|closed the connection|couldn't reach|could not reach|ECONNREFUSED|overloaded|capacity/i.test(m);
+  // A server that is not there: Node says ECONNREFUSED, a browser says only "Failed to
+  // fetch" (the extension reports it as "network error") — a local model killed mid-run
+  // arrived as the latter and ended the task on its first attempt with Claude Code sitting
+  // idle on the roster.
+  return /model[_ ]not[_ ]found|not found|not deployed|inaccessible|does not exist|no such model|unknown model|unsupported model|not available|unavailable|no api key|not configured|"status":\s*(404|401|403|500|502|503)\b|\b(404|401|403|502|503)\b|exited \d+|returned no answer|did not answer|closed the connection|couldn't reach|could not reach|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|socket hang up|fetch failed|failed to fetch|load failed|network ?error|overloaded|capacity/i.test(m);
 }
 
 export function dryRunTeam(team, request, { appoint = null } = {}) {
@@ -235,9 +239,13 @@ export async function runTeam({
         if (req.type !== 'handoff' || req.taskId !== task.id) return false;
         handoffTo = req; taskAc.abort(); return true;
       }) || null;
+      // Every recorded step says when and under which attempt — the board's work log and the
+      // scorecard read the task by these, so a step reported after the fact is stamped now.
+      let attemptNo = 0;
+      const stamp = (m) => clipTranscriptOne({ ...m, at: Number.isFinite(m?.at) ? m.at : now(), attempt: Number.isFinite(m?.attempt) ? m.attempt : attemptNo });
       const recordSteps = (before, after) => {
         const added = newSteps(before, after);
-        if (added.length) say('task.step', { taskId: task.id, role: role.id, steps: added.map((m) => clipTranscriptOne(m)) });
+        if (added.length) say('task.step', { taskId: task.id, role: role.id, steps: added.map(stamp) });
       };
       try {
         if (role.mode === 'recipe') {
@@ -295,13 +303,16 @@ export async function runTeam({
             routed = routeOf(m, role, { attempt, exclude, handoff: handoffNow });
             say('task.routed', { taskId: task.id, role: role.id, attempt, ...routed });
             attempts.push({ model: m.model, engine: routed.engine, at: now(), continued: !!note });
+            attemptNo = attempts.length;
             const sent = messagesFor({ transcript }, { prompt, note });
             // The record grows AS THE ATTEMPT GOES: a host that reports each wire message the
             // moment it exists (a tool call, its result) puts it on the record then, so a
             // process that dies mid-attempt leaves the work so far behind it, not nothing.
             let live = sent;
-            if (sent.length > transcript.length) recordSteps(transcript, sent);
-            const onStep = (message) => { if (message && message.role) { live = [...live, message]; say('task.step', { taskId: task.id, role: role.id, steps: [clipTranscriptOne(message)] }); } };
+            // (thoughts are on the record but not on the wire, so compare against the wire's view)
+            const wireBefore = transcript.filter((m) => !isThought(m));
+            if (sent.length > wireBefore.length) recordSteps(wireBefore, sent);
+            const onStep = (message) => { if (message && message.role) { live = [...live, message]; say('task.step', { taskId: task.id, role: role.id, steps: [stamp(message)] }); } };
             const res = await callModel({
               runId: id, taskId: task.id, role: role.id, model: m.model, mode: m.mode || role.mode,
               system: role.prompt, prompt, messages: sent, tools, signal: taskAc.signal,
@@ -355,7 +366,13 @@ export async function runTeam({
       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 thread = board.threadForTask(task.id);
-      if (thread && status !== 'waiting') board.setThreadStatus(thread.id, 'resolved');
+      // The thread says how the task ended. A failure is posted in it as well — a person reading
+      // the board sees "researcher failed: network error" where it happened, and what was tried.
+      if (thread && status === 'ok') board.setThreadStatus(thread.id, 'resolved');
+      else if (thread && status !== 'waiting') {
+        board.post({ threadId: thread.id, by: RUNNER, kind: 'note', text: `${role.id} ${status === 'over-budget' ? 'stopped at the budget' : 'failed'}${error ? `: ${String(error).slice(0, 300)}` : ''}${attempts.length > 1 ? ` (after ${attempts.length} models: ${attempts.map((a) => a.model).join(', ')})` : ''}.` });
+        board.setThreadStatus(thread.id, 'failed');
+      }
       const row = { id: task.id, role: task.role, title: task.title, status, text, error, usage, ms: now() - t0, findings, transcript: clipTranscript(transcript), attempts, ...(routed ? { routed } : {}), ...(scm ? { scm } : {}), ...(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, ...(askedAndWaiting ? { threadId: askedAndWaiting } : {}) });

package/team-task.js

@@ -26,9 +26,20 @@ export function clipMessage(m) {
   if (m.tool_calls) out.tool_calls = m.tool_calls.map((c) => ({ id: c.id, type: c.type || 'function', function: { name: c.function?.name, arguments: clipStr(String(c.function?.arguments ?? ''), STEP_MAX_CHARS) } }));
   if (m.tool_call_id) out.tool_call_id = m.tool_call_id;
   if (m.name) out.name = m.name;
+  // The member's reasoning, when the model streams it: on the record for the board and the
+  // scorecard, never sent back on the wire (messagesFor drops it).
+  if (typeof m.thought === 'string') out.thought = clipStr(m.thought, STEP_MAX_CHARS);
+  // When the step happened and under which attempt — the work log orders by these.
+  if (Number.isFinite(m.at)) out.at = m.at;
+  if (Number.isFinite(m.attempt)) out.attempt = m.attempt;
   return out;
 }
 
+/** A step that is the member thinking aloud — no content, no call — recorded, not replayed. */
+export function isThought(m) {
+  return !!m && m.role === 'assistant' && typeof m.thought === 'string' && m.content == null && !(Array.isArray(m.tool_calls) && m.tool_calls.length);
+}
+
 /** The record's copy of a transcript: clipped per message and bounded as a whole (oldest tool traffic goes first). */
 export function clipTranscript(messages) {
   const list = (Array.isArray(messages) ? messages : []).filter((m) => m && m.role && m.role !== 'system').map(clipMessage);
@@ -67,7 +78,7 @@ export function continuationNote({ kind = 'handoff', from = '', to = '', reason
  * it first) so a transcript never carries a role prompt that a later role might not share.
  */
 export function messagesFor(task, { prompt, note = null } = {}) {
-  const transcript = Array.isArray(task?.transcript) ? task.transcript : [];
+  const transcript = (Array.isArray(task?.transcript) ? task.transcript : []).filter((m) => !isThought(m));
   if (!transcript.length) return [{ role: 'user', content: String(prompt || '') }];
   const last = transcript[transcript.length - 1];
   // A transcript that ends in an unanswered tool call cannot be continued as-is: close it.

package/team-tool.js

@@ -26,10 +26,23 @@ function catalogue(teams) {
   return `Saved teams: ${list.map((t) => `${t.name} (${(t.roles || []).map((r) => r.id).join(', ')})${t.description ? ` — ${t.description}` : ''}`).join('; ')}.`;
 }
 
+/**
+ * How long one call of the tool may take: the longest budget among the teams plus the merge,
+ * never under two minutes. A relay between a CLI agent and this tool (the bridge's MCP
+ * server) times a call by this; without it a 300 s team hit the relay's 120 s default,
+ * Claude Code was told "tool call timed out" and ran the team AGAIN while the first run was
+ * still working.
+ */
+export function teamToolTimeoutMs(teams) {
+  const longest = Math.max(0, ...(teams || []).map((t) => Number(t?.budget?.ms) || 0));
+  return Math.max(120_000, (longest || 10 * 60_000) + 60_000);
+}
+
 export function teamToolSpec(teams) {
   return {
     name: TEAM_TOOL_NAME,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    timeoutMs: teamToolTimeoutMs(teams),
     description:
       `Saved agent teams — several roles working a request in parallel, merged into one answer. ${catalogue(teams)} `
       + 'Actions: {"action":"run","name":"<team>","request":"<what to do>"} runs one (streams; may take a while); '

package/team-worklog.js

@@ -0,0 +1,146 @@
+// The work log — a task's thread as the record of the work, not just its posts.
+//
+// A task is a conversation (team-task.js): every step is on the record as it happens — the
+// prompt, the member's text, its reasoning when the model streams it, each tool call and
+// what came back — beside the attempts (which model, when, how it ended), the hand-offs, the
+// posts in its thread, and how the task ended. The board drew the posts alone, and a task
+// that failed before its first post looked like nothing had happened. This folds all of it
+// into ONE ordered timeline, the same in both clients, so what a member did, tried, was told
+// and produced is read in one place — by a person, by the next wave, and by whoever rates
+// the member (evidence first: calls made, findings kept, models burned, budget spent).
+//
+// Pure: a run record (team-record.js) in, entries out. No rendering here.
+
+import { isThought } from './team-task.js';
+
+export const WORKLOG_KINDS = Object.freeze(['attempt', 'prompt', 'note', 'thought', 'text', 'call', 'result', 'handoff', 'post', 'end']);
+
+const num = (v, d = 0) => (Number.isFinite(v) ? v : d);
+const str = (v) => (v == null ? '' : typeof v === 'string' ? v : JSON.stringify(v));
+
+function parseArgs(raw) {
+  if (raw && typeof raw === 'object') return raw;
+  try { return JSON.parse(String(raw || '{}')); } catch { return { raw: String(raw || '') }; }
+}
+
+/** One line for a tool call: `find web_search "…"` — the dispatcher's action stands in front. */
+export function describeCall(call) {
+  const name = call?.function?.name || call?.name || 'tool';
+  const args = parseArgs(call?.function?.arguments ?? call?.arguments);
+  const action = args?.action ? ` ${args.action}` : '';
+  const inner = args?.args && typeof args.args === 'object' ? args.args : args;
+  const first = inner && typeof inner === 'object' ? Object.entries(inner).find(([k, v]) => k !== 'action' && k !== 'args' && (typeof v === 'string' || typeof v === 'number')) : null;
+  return `${name}${action}${first ? ` ${first[0]}=${JSON.stringify(String(first[1]).slice(0, 120))}` : ''}`;
+}
+
+/**
+ * The timeline of one task: `[{ kind, at, by, attempt, ... }]`, oldest first. Every entry has
+ * an `at`; a step recorded without one (an older build) inherits its attempt's, so the order
+ * still holds. `by` is the role for what the member did, `runner` for the runner's lines, and
+ * whoever posted for a post.
+ */
+export function workLogFor(run, taskId) {
+  const task = (run?.tasks || []).find((t) => t.id === taskId);
+  if (!task) return [];
+  const by = task.role || task.id;
+  const out = [];
+  const attempts = Array.isArray(task.attempts) ? task.attempts : [];
+  const baseAt = num(task.startedAt, num(attempts[0]?.at, num(run?.startedAt, 0)));
+  attempts.forEach((a, i) => out.push({ kind: 'attempt', at: num(a.at, baseAt + i), by: 'runner', attempt: i + 1, model: a.model || '', engine: a.engine || null, continued: !!a.continued, status: a.status || null, error: a.error || null }));
+
+  // Steps: stamped ones sort by their time; unstamped ones follow their attempt in order.
+  const steps = Array.isArray(task.transcript) ? task.transcript : [];
+  const calls = new Map();
+  let lastAt = baseAt;
+  let attemptOf = 1;
+  steps.forEach((m, i) => {
+    if (!m || !m.role) return;
+    if (Number.isFinite(m.attempt)) attemptOf = m.attempt;
+    else if (attempts.length) attemptOf = Math.max(attemptOf, 1 + attempts.findLastIndex((x) => num(x.at, 0) <= lastAt + 1));
+    // Unstamped: after everything before it, and after its attempt began.
+    const at = Number.isFinite(m.at) ? m.at : Math.max(lastAt, num(attempts[attemptOf - 1]?.at, 0)) + 1;
+    lastAt = Math.max(lastAt, at);
+    const attempt = attemptOf;
+    if (m.role === 'user') {
+      out.push({ kind: i === 0 ? 'prompt' : 'note', at, by: 'runner', attempt, text: str(m.content) });
+    } else if (m.role === 'assistant') {
+      if (isThought(m)) { out.push({ kind: 'thought', at, by, attempt, text: m.thought }); return; }
+      if (typeof m.content === 'string' && m.content.trim()) out.push({ kind: 'text', at, by, attempt, text: m.content });
+      for (const c of Array.isArray(m.tool_calls) ? m.tool_calls : []) {
+        const id = c.id || `c${i}`;
+        calls.set(id, c);
+        out.push({ kind: 'call', at, by, attempt, callId: id, name: c.function?.name || 'tool', args: parseArgs(c.function?.arguments), text: describeCall(c) });
+      }
+    } else if (m.role === 'tool') {
+      const c = m.tool_call_id ? calls.get(m.tool_call_id) : null;
+      out.push({ kind: 'result', at, by: 'tool', attempt, callId: m.tool_call_id || null, name: c?.function?.name || m.name || 'tool', text: str(m.content), error: /^error[:\s]/i.test(str(m.content)) });
+    }
+  });
+
+  for (const h of Array.isArray(task.handoffs) ? task.handoffs : []) out.push({ kind: 'handoff', at: num(h.at, lastAt), by: h.by || 'person', from: h.from || '', to: h.to || '', text: h.reason || '' });
+
+  // The thread's posts — a member's findings, a question, an answer, a decision, the runner's notes.
+  const thread = (run?.threads?.threads || []).find((t) => t.taskId === taskId && t.kind === 'task');
+  if (thread) for (const p of (run.threads.posts || []).filter((x) => x.threadId === thread.id)) out.push({ kind: 'post', at: num(p.at, lastAt), by: p.by || '', post: p, text: p.text || '' });
+
+  // What the member is saying right now — the attempt's text before it is a step.
+  const lastText = [...out].reverse().find((e) => e.kind === 'text');
+  if (task.status === 'running' && task.text && task.text !== lastText?.text) out.push({ kind: 'text', at: num(run?.lastEventAt, lastAt + 1), by, attempt: attemptOf, text: task.text, live: true });
+
+  if (task.endedAt || ['ok', 'failed', 'over-budget', 'stopped', 'waiting'].includes(task.status)) {
+    // Findings: the task's count, or the finding posts in its thread — a member's board posts
+    // count as its answer (team-run.js), and a record folded from an older run has only those.
+    const findings = Math.max(num(task.findings, 0), out.filter((e) => e.kind === 'post' && e.post?.kind === 'finding').length);
+    const tools = Math.max(num(task.tools, 0), out.filter((e) => e.kind === 'call').length);
+    out.push({ kind: 'end', at: num(task.endedAt, num(run?.lastEventAt, lastAt + 2)), by: 'runner', status: task.status, error: task.error || null, ms: num(task.ms, 0), findings, tools, text: endText({ ...task, findings, tools }, attempts) });
+  }
+  return out.sort((a, b) => a.at - b.at || WORKLOG_KINDS.indexOf(a.kind) - WORKLOG_KINDS.indexOf(b.kind));
+}
+
+function endText(task, attempts) {
+  const tried = attempts.length > 1 ? ` after ${attempts.length} models (${attempts.map((a) => a.model).join(' → ')})` : '';
+  const s = task.status;
+  if (s === 'ok') return `done${tried} · ${task.findings || 0} finding${task.findings === 1 ? '' : 's'} · ${task.tools || 0} tool call${task.tools === 1 ? '' : 's'}`;
+  if (s === 'waiting') return 'waiting on a person';
+  if (s === 'over-budget') return `stopped at the budget${tried}`;
+  if (s === 'stopped') return `stopped${tried}`;
+  return `failed${tried}${task.error ? `: ${task.error}` : ''}`;
+}
+
+/** The log as text — for a brief, a rating, a test: one line per entry, results shortened. */
+export function workLogText(entries, { resultChars = 200 } = {}) {
+  return (entries || []).map((e) => {
+    switch (e.kind) {
+      case 'attempt': return `▸ attempt ${e.attempt}: ${e.model}${e.continued ? ' (continues)' : ''}`;
+      case 'prompt': return `▸ task: ${e.text}`;
+      case 'note': return `▸ runner → ${e.text}`;
+      case 'thought': return `${e.by} (thinking): ${e.text}`;
+      case 'text': return `${e.by}: ${e.text}`;
+      case 'call': return `${e.by} → ${e.text}`;
+      case 'result': return `  ← ${e.name}: ${e.text.length > resultChars ? `${e.text.slice(0, resultChars)}…` : e.text}`;
+      case 'handoff': return `▸ handed from ${e.from} to ${e.to} by ${e.by}${e.text ? ` — ${e.text}` : ''}`;
+      case 'post': return `${e.by} posted ${e.post?.kind || 'note'}: ${e.text}`;
+      case 'end': return `▸ ${e.text}`;
+      default: return '';
+    }
+  }).filter(Boolean).join('\n');
+}
+
+/**
+ * What the log says about the work, as numbers — the evidence a rating starts from, before
+ * any opinion (a judge's, a peer's, a person's) is added beside it.
+ */
+export function workLogEvidence(entries) {
+  const ev = { calls: 0, results: 0, resultErrors: 0, thoughts: 0, texts: 0, attempts: 0, handoffs: 0, posts: 0, findings: 0, decided: { approved: 0, rejected: 0 }, status: null, ms: 0 };
+  for (const e of entries || []) {
+    if (e.kind === 'call') ev.calls++;
+    else if (e.kind === 'result') { ev.results++; if (e.error) ev.resultErrors++; }
+    else if (e.kind === 'thought') ev.thoughts++;
+    else if (e.kind === 'text') ev.texts++;
+    else if (e.kind === 'attempt') ev.attempts++;
+    else if (e.kind === 'handoff') ev.handoffs++;
+    else if (e.kind === 'post') { ev.posts++; if (e.post?.kind === 'finding') ev.findings++; if (e.post?.status === 'approved') ev.decided.approved++; if (e.post?.status === 'rejected') ev.decided.rejected++; }
+    else if (e.kind === 'end') { ev.status = e.status; ev.ms = e.ms; ev.findings = Math.max(ev.findings, e.findings || 0); }
+  }
+  return ev;
+}