@chatpanel/events 0.75.0 → 0.77.0

package/index.js

@@ -197,6 +197,7 @@ export { fixedPlan, parsePlan, plannerPrompt, waves, breakCycles, TEAM_PLAN_SCHE
 export { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims, FINDINGS_SCHEMA, FINDING_KINDS } from './team-board.js';
 export { runTeam, dryRunTeam, 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';
 export { createManifest, ManifestError, SOURCES } from './manifest.js';
 export { createKernel, meetDecisions, KernelError, REQUIRED_PLUGINS, ALLOW_ALL } from './kernel.js';
@@ -213,7 +214,7 @@ export { SOURCE_TRUST, SkillSourceError, defineSkillSource, createSkillSourceReg
 export { SKILL_MANIFEST_VERSION, SKILL_CONTEXTS, SKILL_HISTORY_SCOPES, SKILL_MCP_MODES, SKILL_TRUST, SKILL_FILE_KINDS, SKILL_UPCASTERS, SkillManifestError, isSafeSkillPath, originOf, trustOf, skillFiles, needsBridge, declaredAccess, originLabel, sameSkillOrigin, skillIsStale, validateSkill, upcastSkill, upcastSkills, normalizeSkill } from './skill-manifest.js';
 export { SKILL_VARS, SKILL_VAR_NAMES, skillVar, skillVarPattern, parseSkillVars, lintSkillPrompt, suggestSkillVar, substituteSkillVars, expandSkillPrompt, skillVarGuidance, SkillVarError } from './skill-vars.js';
 export { lineAt, writerAffordance, INSTRUCTION_RE, instructionOnLine, GOAL_MIN_NEW, goalDraftAllowed, createSpendMeter, writerTail, draftSeparator, groundingBlock, writerRequest, AUTOCOMPLETE_SYSTEM, AUTOCOMPLETE_MAX_TOKENS, AUTOCOMPLETE_TEMPERATURE, clipCompletion, GEARS, WRITER_PREFS, WRITER_PREF_DEFAULTS, normalizeWriterPrefs, normalizeIntent } from './cowriter-writer.js';
-export { SLASH_TYPING_RE, enabledSkills, slashCommandItems, matchSlashSkill, matchSlashRecipe, recipeInvocationText, slashCommandInsert, skillInvocationOf, skillInvocationLabel } from './slash-commands.js';
+export { SLASH_TYPING_RE, enabledSkills, slashCommandItems, matchSlashSkill, matchSlashRecipe, recipeInvocationText, matchSlashTeam, teamInvocationText, slashCommandInsert, skillInvocationOf, skillInvocationLabel } from './slash-commands.js';
 export { outlineOf, parseListItem, continueList, indentSelection, toggleWrap, toggleLinePrefix, toggleTask, toggleLink, docStats, selectionStats } from './markdown-authoring.js';
 export {
   MAX_TAG_LENGTH, MAX_TAGS, normalizeTag, normalizeTags, hasTag, addTag, removeTag, toggleTag,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.75.0",
+  "version": "0.77.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",
@@ -93,6 +93,7 @@
     "./team-plan.js": "./team-plan.js",
     "./team-run.js": "./team-run.js",
     "./team-tool.js": "./team-tool.js",
+    "./team-trail.js": "./team-trail.js",
     "./team.js": "./team.js",
     "./text-search.js": "./text-search.js",
     "./theme.js": "./theme.js",
@@ -207,6 +208,7 @@
     "team-plan.js",
     "team-run.js",
     "team-tool.js",
+    "team-trail.js",
     "team.js",
     "text-search.js",
     "theme.js",

package/slash-commands.js

@@ -37,6 +37,12 @@ function recipeItem(recipe) {
   return { type: 'recipe', command: recipe.name || '', icon: '🧩', description: recipe.description || 'Saved recipe', recipe };
 }
 
+// A saved TEAM answers to a slash the same way: `/research <request>` is a request to run
+// it, and the `team` tool does the rest.
+function teamItem(team) {
+  return { type: 'team', command: team.name || '', icon: '🧑‍🤝‍🧑', description: team.description || 'Agent team', team };
+}
+
 /** Skills that are switched on. Absence of the flag means enabled (older records have none). */
 export function enabledSkills(skills) {
   return (Array.isArray(skills) ? skills : []).filter((s) => !!s && s.enabled !== false);
@@ -58,6 +64,7 @@ export function slashCommandItems({
   builtins = [],
   skills = [],
   recipes = [],
+  teams = [],
   prefix = '',
   skillsAllowed = false,
   features = {},
@@ -70,7 +77,8 @@ export function slashCommandItems({
   }));
   const skillItems = skillsAllowed ? enabledSkills(skills).map(skillItem) : [];
   const recipeItems = (recipes || []).filter((r) => r && r.enabled !== false && r.name).map(recipeItem);
-  return [...own, ...skillItems, ...recipeItems]
+  const teamItems = (teams || []).filter((t) => t && t.enabled !== false && t.name).map(teamItem);
+  return [...own, ...skillItems, ...recipeItems, ...teamItems]
     .filter((item) => item.command && item.command.toLowerCase().startsWith(normalized))
     .slice(0, 12);
 }
@@ -100,6 +108,20 @@ export function recipeInvocationText(recipe, args = '') {
   return `Run the saved recipe "${recipe.name}"${a ? ` with this input: ${a}` : ''}. Use the recipe tool; if a parameter is missing, ask for it.`;
 }
 
+/** "/research compare A and B" → the team, and the rest of the line as its request. */
+export function matchSlashTeam(text, teams = []) {
+  const m = /^\/([a-z0-9_-]+)\s*([\s\S]*)$/i.exec(String(text || ''));
+  if (!m) return null;
+  const team = (teams || []).find((t) => t && t.enabled !== false && String(t.name || '').toLowerCase() === m[1].toLowerCase());
+  return team ? { team, args: m[2].trim() } : null;
+}
+
+/** What the model receives for a team command: a request to run it, never a prompt expansion. */
+export function teamInvocationText(team, args = '') {
+  const a = String(args || '').trim();
+  return `Run the saved team "${team.name}"${a ? ` on this request: ${a}` : ''}. Use the team tool; if the request is unclear, ask first.`;
+}
+
 export function slashCommandInsert(item) {
   return item?.command ? `/${item.command} ` : '/';
 }

package/team-run.js

@@ -48,7 +48,9 @@ export function dryRunTeam(team, request, { appoint = null } = {}) {
   const t = normalizeTeam(team);
   const roles = t.roles.map((r) => {
     const a = appoint ? appoint(r) : null;
-    return { id: r.id, name: r.name, mode: r.mode, prefer: r.prefer, model: a?.model || r.model || null, appointed: !!(a?.model || r.model), grants: r.grants, ...(r.recipe ? { recipe: r.recipe } : {}) };
+    // `model` is what callModel will be handed (a target id in a client that resolves ids);
+    // `label` is what a person should read — the appointer says which, when it knows.
+    return { id: r.id, name: r.name, mode: r.mode, prefer: r.prefer, model: a?.model || r.model || null, label: a?.label || a?.model || r.model || null, appointed: !!(a?.model || r.model), grants: r.grants, ...(r.recipe ? { recipe: r.recipe } : {}) };
   });
   const missing = roles.filter((r) => r.mode !== 'recipe' && !r.appointed).map((r) => r.id);
   return {
@@ -137,9 +139,11 @@ export async function runTeam({
           if (!budget.canAfford({ tokens: 0 })) { overBudget = true; throw new Error('over budget'); }
           const prior = boardText(board.all(), { taskIds: task.dependsOn?.length ? task.dependsOn : null });
           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);
           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: toolsFor(role), signal,
+            system: role.prompt, prompt, tools, signal,
             onDelta: (delta, full) => say('task.delta', { taskId: task.id, role: role.id, delta, text: full }),
           });
           usage = res?.usage || null;

package/team-tool.js

@@ -49,7 +49,7 @@ export function teamToolSpec(teams) {
 /** The card a person approves a new team on. */
 export function describeTeamForApproval(team, dry) {
   const lines = [`${team.name}${team.description ? ` — ${team.description}` : ''}`, `Plan: ${team.plan || 'fixed'} · merge: ${team.merge || 'concat'}${team.judge ? ` (judge: ${team.judge})` : ''}`];
-  for (const r of dry?.roles || team.roles || []) lines.push(`• ${describeRole({ ...r, model: r.model || undefined })}${r.appointed === false ? ' — NO MODEL AVAILABLE' : ''}`);
+  for (const r of dry?.roles || team.roles || []) lines.push(`• ${describeRole({ ...r, model: r.label || r.model || undefined })}${r.appointed === false ? ' — NO MODEL AVAILABLE' : ''}`);
   const b = team.budget || {};
   lines.push(`Budget: ${Object.entries(b).map(([k, v]) => `${k} ${v}`).join(' · ')}`);
   lines.push('Runs go through your own models and tools; a team may not act on a page. Nothing a team produces lands without you.');

package/team-trail.js

@@ -0,0 +1,37 @@
+// A team run as a trail reads it: one line per event in the trail's own vocabulary, and
+// the run's lanes — one per task — folded from the same events. Both clients draw a run
+// from these; neither decides for itself what "task.done" means in words. The event
+// vocabulary is team-run.js's `emit`; the lanes are what a pane, a card or a phone renders.
+
+/** One trail line per team event, in the trail's own vocabulary. */
+export function teamLine(ev) {
+  const role = ev.role ? `${ev.role}` : 'team';
+  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.started': return { type: 'tool', name: role, text: `${role} · ${ev.title || ev.taskId}` };
+    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)}` };
+    case 'task.done': return { type: 'status', text: `${role} done · ${ev.findings || 0} finding${ev.findings === 1 ? '' : 's'}` };
+    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` : ''}` };
+    default: return null;
+  }
+}
+
+/** The run's lanes — one per task — folded from its events, for the pane. */
+export function teamLanes(prev, ev) {
+  const lanes = prev ? { ...prev, tasks: { ...prev.tasks } } : { runId: ev.runId, team: '', status: 'running', tasks: {}, findings: 0 };
+  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.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.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 'run.done': lanes.status = ev.status; lanes.usage = ev.usage; break;
+    default: break;
+  }
+  return lanes;
+}