ac-teams 0.0.15 → 0.0.17

package/README.md

@@ -26,7 +26,7 @@ Your Pi session is the root; its child agents are members. Ask Pi to delegate a
 | `team_task` | Plan solo or team work, create tasks in batches, and track ownership and dependencies |
 | `team_message` | Send notifications and read or search team history |
 
-`/teams` or `/teams panel` opens Tasks, Teammates, and Activity. `/teams teammate <name-or-id>` opens a teammate directly; subcommands and teammate names autocomplete. Use the task graph or list, send feedback, and open a member's full live Pi session.
+`/teams` or `/teams panel` opens Tasks, Teammates, and Board. `/teams teammate <name-or-id>` opens a teammate directly; subcommands and teammate names autocomplete. Use the task graph or list, send feedback, and open a member's full live Pi session.
 
 The task summary sits above the input. The agent selector sits below the input, above your existing footer, and shows descriptive names, models, and context usage. ac-teams publishes a compact team status without replacing the footer or editor supplied by other extensions. `/teams config` toggles these displays independently.
 

package/docs/operations.md

@@ -127,6 +127,8 @@ State schema 3 adds stable task numbers and short labels. Opening a schema 1 or
 
 Schema 1 also migrates progress: `pending` becomes `todo`, `claimed` becomes `in_progress`, and `completed` becomes `done`. Migration writes atomically and rejects invalid snapshots without replacement. Older ac-teams code cannot reopen schema 3; stop old sessions before updating.
 
+State schema 5 turns messages into board posts: each has a `summary`, optional `detail`, and an optional `task` or `replyTo`; tasks gain an optional `delegator` and `outcome` post reference, and records an optional `waiting` registration. Opening a schema 4 team keeps every message's text unchanged as its summary. Older done tasks have no outcome, and no delegation is inferred. Schema 5 state cannot be opened by older ac-teams versions.
+
 State schema 4 adds a role to each record: `main` or `member`. Opening a schema 3 team makes the root record a main session and every other record a member. A record without a role has left the team. A promotion records each step, so a failure rolls the member back to a stopped member with its original transcript path.
 
 Only the coordinator writes state. Mutations validate a copy, flush a temporary snapshot, atomically rename it, and flush the directory before returning success. An exclusive process-identity lock prevents concurrent owners. Private team directories use 0700; state files and the authenticated Unix socket use 0600. Uncertain locks fail closed.

package/docs/usage.md

@@ -6,7 +6,7 @@ ac-teams provides three tools for planning and tracking solo and delegated work.
 | --- | --- | --- |
 | `team_agent` | `launch`, `list`, `status`, `stop`, `resume`, `limits`, `cleanup` | A parent controls its descendants, not peers or ancestors |
 | `team_task` | `create`, `list`, `read`, `edit`, `claim`, `start`, `release`, `complete`, `reopen` | Claim reserves work; dependencies gate starting, not ownership |
-| `team_message` | `send`, `history`, `search` | Recipients select who receives notification, not who can read |
+| `team_message` | `send`, `history`, `search`, `wait` | Routing selects who is notified, not who can read |
 
 In interactive Pi, `/teams` or `/teams panel` opens the team panel. `/teams teammate <name-or-id>` opens a live teammate directly; autocomplete suggests subcommands and teammate names. You can also enter an exact teammate ID. The older `/teams open <id>` form remains supported. Headless roots retain the status listing. `/teams stop` stops every member; main sessions keep running. `/teams join` and `/teams leave` change which team this session belongs to. See [operations](operations.md) for limits, recovery, and worktree cleanup.
 
@@ -22,13 +22,13 @@ Context shows Pi's reported token estimate, window size, and percentage, for exa
 
 - Press Down from an empty editor to focus Main in the agent selector. Up/Down select members; Enter opens the selected live session; Esc returns to editing.
 - Ctrl+Shift+Left returns from a member to Main. Switching preserves the member's process, session, and draft. Returning does not stop it.
-- `/teams` opens three tabs. Tab moves between Tasks, Teammates, and Activity; Esc closes the panel.
-    - **Tasks:** Arrow keys select nodes in the dependency graph. G toggles graph/list, and Enter shows full details. Green means Done, red Blocked, cyan Working, and neutral Ready; written labels remain visible. Large or unsupported graphs fall back to the list.
+- `/teams` opens three tabs. Tab moves between Tasks, Teammates, and Board; Esc closes the panel.
+    - **Tasks:** Arrow keys select nodes in the dependency graph. G toggles graph/list, and Enter shows full details. The graph opens fitted to the pane; `-` and `+` shorten or restore titles gradually (number and status always stay), and F returns to fit. The selected box has a heavy border and accent text. Green means Done, red Blocked, cyan Working, and neutral Ready; written labels remain visible. Large or unsupported graphs fall back to the list.
     - **Teammates:** Shows working, idle, stopped, and needs-input counts; interrupted sessions count as needing input. Enter opens a live member, or quietly resumes a stopped member's saved session before opening it. Right opens details; Esc returns to the roster. Model, context, and directory appear above session IDs and paths. Root can open any member; member views can open their descendants.
         - Wider rosters also show Tasks (completed / currently assigned total) and the directory's final folder name. Reassigned tasks leave the previous owner's counts. Narrower views drop Directory first, then Tasks; full paths and counts remain in details.
         - Press `/` to filter names (case-insensitive). Enter applies the filter; Esc while editing clears it. Backspace edits the query. Press `/` again to edit an applied filter.
         - H hides or shows stopped members. Interrupted sessions remain visible for recovery. All members are visible by default; filters affect only this panel, not team state.
-    - **Activity:** Shows the latest 100 persistent team messages rather than every tool update. Use `team_message history` to read older messages.
+    - **Board:** Shows the latest 100 posts, one row each with sender, kind (post, reply, or outcome), summary, task, and time. The details pane shows recipients, task, summary, detail, and replies. Use `team_message history` to read older posts.
 - N composes a task request for Main. C on a task sends feedback to its creator. Enter sends; Shift+Enter adds a newline; Esc cancels without losing the draft. These messages do not directly edit the task graph. Feedback resumes a stopped creator when possible; otherwise, the receipt explicitly reports delivery to Main instead.
 
 A task request is a proposal, not an instruction to create a task. Main receives guidance to review the agreed scope and existing work first: reuse a task that already covers the request, extend one when coherent and permitted, or create distinct in-scope work. It should clarify unresolved scope conflicts and explain its decision with task references.
@@ -37,9 +37,9 @@ The send receipt confirms delivery, not acceptance or task creation. This is age
 
 Each team tool call uses one line with a status dot, tool name, action, and result preview. Bold, colored badges such as `[todo]` separate statuses from titles and names.
 
-The `+N lines` hint shows the hidden detail count. Ctrl+O expands the full request and response JSON; mouse-enabled Pi views also support clicking the row.
+The `+N lines` hint shows the hidden detail count. Ctrl+O expands the full response JSON; mouse-enabled Pi views also support clicking the row.
 
-Tool summaries and team notification previews prefer teammate names over IDs. Message receipt IDs stay out of compact summaries. Ctrl+O expands the original request and response, including IDs. Unknown members fall back to their IDs. UI state colors do not replace the underlying progress, ownership, or dependency fields.
+Tool summaries and team notification previews prefer teammate names over IDs. Message receipt IDs stay out of compact summaries. Ctrl+O expands the response, including IDs. Unknown members fall back to their IDs. UI state colors do not replace the underlying progress, ownership, or dependency fields.
 
 ## Main sessions share one team
 
@@ -88,7 +88,7 @@ Task list and mutation responses give the model compact summaries, including UUI
 
 ## Give members bounded assignments
 
-Before delegating a deliverable, create or reuse a shared task and include its ID in the member's brief. Track independently owned outcomes, not every agent, tool call, or procedural step. For example:
+Before delegating a deliverable, create or reuse a shared task and pass it as the launch `task`. The new member owns it, you become its delegator, and its posts and completion outcome reach you. Track independently owned outcomes, not every agent, tool call, or procedural step. For example:
 
 - A fix and an independently owned test assignment need separate tasks.
 - A diagnosis others need for follow-up needs a task, even if the investigation is read-only.
@@ -101,13 +101,13 @@ Review the current task list and relevant details first. Reuse an existing task
 {"action":"create","label":"Parser review","title":"Review parser errors and malformed input","description":"Read-only review of src/parser.ts. Acceptance: report concrete malformed-input failures with reproduction steps, or report that none were found."}
 ```
 
-Put the returned task UUID in the brief in place of `<task-id>`. Example `team_agent` arguments:
+Pass the returned task UUID as `task`. Example `team_agent` arguments:
 
 ```json
-{"action":"launch","name":"parser-review","brief":"Task <task-id>: claim and start it, then review src/parser.ts. Read only; do not delegate or edit. Send findings to root through team_message. Complete the task after checking its acceptance criteria, or report blockers."}
+{"action":"launch","name":"parser-review","task":"<task-id>","brief":"Review src/parser.ts for malformed-input failures. Read only; do not delegate or edit."}
 ```
 
-These are prompt guidelines, not launch requirements. ac-teams neither creates tasks automatically nor blocks launches without tasks.
+The launch task must be a to-do task that is unowned or yours; a failed launch returns it. ac-teams neither creates tasks automatically nor blocks launches without tasks. After delegating, do distinct work or `wait`; do not repeat the delegated work.
 
 Every launch needs a unique descriptive `name`: one or two lowercase words, hyphenated if two, at most 40 characters. For example, `parser-review` or `research`. `main`, `root`, and names matching an existing member's ID are reserved. Names remain stable across stop/resume; IDs remain the API references.
 
@@ -141,9 +141,9 @@ Use the returned task ID with these actions:
 | --- | --- |
 | `claim` | Reserve an unowned to-do task, even if blocked. Progress stays `todo`. |
 | `start` | Claim unowned work and move `todo` to `in_progress` atomically, only when every dependency is `done`. An existing owner must be the caller. |
-| `complete` | The owner moves `in_progress` to `done`, with `acceptance: true`. Ownership remains. |
+| `complete` | The owner moves `in_progress` to `done`, with `acceptance: true` and an outcome `summary` (optional `detail`). One atomic step records the outcome post and the done state; an identical retry returns the original. Ownership remains. |
 | `release` | Clear ownership. In-progress work returns to `todo`; done work stays `done`. |
-| `reopen` | Explicitly move `done` to `todo`, retaining any owner. Refuse if a dependent is in progress or done. |
+| `reopen` | Explicitly move `done` to `todo`, retaining any owner and clearing the outcome reference; the outcome post stays. Refuse if a dependent is in progress or done. |
 
 Starting never steals another owner's work. Only the owner can complete or release its work. An ancestor may explicitly release a stopped or interrupted descendant's ownership. The owner or root can reopen an owned task; any member can reopen an unowned one. Done tasks cannot be claimed until reopened.
 
@@ -151,27 +151,27 @@ Include `dependencies` on creation or `edit`. Any member can edit unowned to-do
 
 `acceptance: true` asserts that the agent checked the acceptance criteria; it is not an independent test runner. Stop/crash retains ownership and progress. There is no automatic reassignment.
 
-## Send messages instead of polling
+## Post to the board instead of polling
 
-Example `team_message` arguments:
+Every post has a one-line `summary` that stands alone, optional `detail`, and an existing `task` or a `replyTo` post. Example `team_message` arguments:
 
 ```json
-{"action":"send","recipients":["root"],"text":"Parser review complete. No edits; two malformed-input cases need tests."}
+{"action":"send","task":"<task-id>","summary":"Parser rejects empty input with a clear error; two malformed cases still crash.","detail":"Repro: ..."}
 ```
 
-Use exact teammate names (such as `"oom-review"`) or member IDs in `recipients`; IDs remain valid. Omit `recipients` to notify all other live members.
+Use exact teammate names (such as `"oom-review"`) or member IDs in `recipients`; IDs remain valid. A post reaches its named `recipients`, the linked task's owner and delegator (the creator when there is none), the author of a replied-to post, and members waiting on that task, never the sender. A reply inherits its post's task. Posts are never broadcast: one with no recipients, task, or reply is rejected, as are unknown member IDs. All team members can read the full history.
 
-Each recipient must resolve to a different live member. An unknown name, a stopped member, or two entries for the same member rejects the whole send.
-
-Receipts and stored history retain resolved IDs. All team members can read the full history, including direct messages.
+Receipts and stored history retain resolved IDs.
 
 ```json
 {"action":"history","after":0,"limit":20}
 ```
 
-Use the last returned `seq` as the next `after` cursor. `search` adds a case-sensitive literal `query`; results remain cursor-paged. Reads never consume messages. Task and message result pages are limited to 100 items.
+Use the last returned `seq` as the next `after` cursor. `search` adds a case-sensitive literal `query` over summaries and detail; results remain cursor-paged. Reads never consume posts. Task and message result pages are limited to 100 items.
+
+Notices carry each post's summary and steer into the recipient's next safe point: an idle member wakes, a busy one sees them after its current tool batch. Read history only for detail your own work needs. A notice is acknowledged once it is persisted in the recipient's session, so a crash before that redelivers it.
 
-New messages queue a compact Pi follow-up: an idle member wakes, while a busy member finishes its current work first. Notifications batch for 50 ms and reference history rather than copying every message into context. Notification acknowledgement means queued, not read or acted on.
+`wait` with `tasks` yields: if a post is already waiting it returns at once; otherwise the turn ends without another model request, and the next post addressed to you or on those tasks starts a new one. Starting any turn clears the wait.
 
 Messages survive crashes; exactly-once delivery or model execution does not. Avoid acknowledgement-only replies.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ac-teams",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Small, persistent teams for Pi",
   "type": "module",
   "license": "MIT",

package/src/coordinator.ts

@@ -29,6 +29,9 @@ export const taskRequestGuidance = [
   "Respect completion checks and add only real dependencies. Explain the decision and any actual task changes to the user.",
 ].join(" ");
 
+/** Posts per notice, oldest first; the session acknowledges a batch before the next one goes out. */
+const noticeBatch = 20;
+
 export function assistantEvent(message: unknown): { type: string; text: string } | undefined {
   if (!isRecord(message) || message.role !== "assistant") return;
   if (message.stopReason === "error") return { type: "model_error", text: String(message.errorMessage || "Model request failed").slice(0, 2000) };
@@ -95,7 +98,7 @@ export class Coordinator {
     this.options = options;
     this.self = options.self ?? "root";
     const root: Member = { id: "root", role: "main", depth: 0, token: randomUUID(), cwd: options.cwd, status: "idle", notified: 0, sessionId: options.id, sessionFile: options.sessionFile, model: options.model, thinking: options.thinking };
-    const initial: TeamState = { version: 4, id: options.id, key: randomUUID(), limit: options.limit, depth: options.depth, members: { root }, tasks: {}, messages: [] };
+    const initial: TeamState = { version: 5, id: options.id, key: randomUUID(), limit: options.limit, depth: options.depth, members: { root }, tasks: {}, messages: [] };
     this.store = new Store(initial, options.home);
     this.socketPath = join(this.store.dir, "coordinator.sock");
   }
@@ -280,7 +283,7 @@ export class Coordinator {
       current.modelName = event.modelName;
       current.contextUsage = event.contextUsage ?? undefined;
     }
-    else if (event.type === "agent_start") { current.status = "busy"; current.activity = "Working"; delete current.error; delete current.summary; }
+    else if (event.type === "agent_start") { delete current.waiting; current.status = "busy"; current.activity = "Working"; delete current.error; delete current.summary; }
     else if (event.type === "agent_settled") { delete current.needsInput; current.status = "idle"; current.activity = current.error ? "Model request failed" : current.summary || "Available for follow-up"; }
     else if (event.type === "activity") current.activity = event.text;
     else if (event.type === "summary") current.summary = event.text?.slice(0, 500);
@@ -291,7 +294,7 @@ export class Coordinator {
     }
     if (event.type === "model_error" && !isMain(member) && member.status !== "stopping") {
       const recipient = member.parent && isLive(this.store.state.members[member.parent]) ? member.parent : this.self;
-      this.store.message(actor, { action: "send", recipients: [recipient], text: `Member ${actor} model error: ${event.text || "Model request failed"}` });
+      this.store.message(actor, { action: "send", recipients: [recipient], summary: `Member ${actor} model error: ${event.text || "Model request failed"}` });
       this.notify(recipient);
     }
   }
@@ -331,7 +334,7 @@ export class Coordinator {
         catch (error) { fallback = `Creator ${recipient} could not resume (${String(error)}); delivered to ${memberName(this.store.state.members[main])} instead. `; recipient = main; }
       }
     }
-    const message = this.store.message(actor, { action: "send", recipients: [recipient], text }, true) as Message;
+    const message = this.store.message(actor, { action: "send", recipients: [recipient], summary: text }, true) as Message;
     this.notify(recipient);
     return `${fallback}Sent to ${isMain(this.store.state.members[recipient]) ? memberName(this.store.state.members[recipient]) : recipient} · message ${message.seq}`;
   }
@@ -365,6 +368,8 @@ export class Coordinator {
     if (this.closed) throw new Error("Team is stopping");
     if (through <= this.store.state.members[id].notified) return;
     this.store.update(state => { state.members[id].notified = through; });
+    // Batches are bounded, so posts beyond the acknowledged batch go out next.
+    this.notify(id);
   }
   private notify(id: string): void {
     if (this.closed || this.notices.has(id)) return;
@@ -373,11 +378,11 @@ export class Coordinator {
       const member = this.store.state.members[id];
       if (!member || !isLive(member)) return;
       const pending = this.store.state.messages.filter(message => message.seq > member.notified && message.recipients.includes(id));
-      const through = pending.at(-1)?.seq;
+      const batch = pending.slice(0, noticeBatch), through = batch.at(-1)?.seq;
       if (!through) return;
       try {
-        if (id === this.self) this.options.notice(through, pending.slice(-5));
-        else { const socket = this.sockets.get(id); if (socket) send(socket, { type: "notice", through, messages: pending.slice(-5) }); }
+        if (id === this.self) this.options.notice(through, batch);
+        else { const socket = this.sockets.get(id); if (socket) send(socket, { type: "notice", through, messages: batch }); }
       } catch (error) { this.options.warning(`Team notification remains in history: ${String(error)}`); }
     }, 50));
   }
@@ -392,10 +397,10 @@ export class Coordinator {
       if (member.access) throw new Error("Sandboxed members cannot send user team actions; use Main");
       return this.userAction(actor, args as UserAction);
     }
-    if (operation === "task") return this.store.task(actor, args as TaskArgs);
-    if (operation === "message") {
-      const result = this.store.message(actor, args as MessageArgs);
-      if ((args as MessageArgs).action === "send") for (const id of Object.keys(this.store.state.members)) this.notify(id);
+    if (operation === "task" || operation === "message") {
+      const last = this.store.state.messages.at(-1)?.seq ?? 0;
+      const result = operation === "task" ? this.store.task(actor, args as TaskArgs) : this.store.message(actor, args as MessageArgs);
+      for (const message of this.store.state.messages.filter(message => message.seq > last)) for (const id of message.recipients) this.notify(id);
       return result;
     }
     return this.agent(actor, args as AgentArgs, authorizedLimit);
@@ -471,8 +476,14 @@ export class Coordinator {
     const member: Member = resumed ? { ...resumed, token: randomUUID(), status: "starting", error: undefined, contextUsage: undefined, modelName: undefined, handover: undefined } : { id, name: args.name, role: "member", parent: actor, depth, token: randomUUID(), cwd, status: "starting", notified: 0, access, provider: access ? provider : undefined };
     const resources = this.resources();
     for (const warning of resources.warnings) this.options.warning(warning);
-    // Reserve synchronously before the first await so concurrent launches cannot oversubscribe.
-    this.store.update(next => { next.members[id] = member; });
+    const assigned = args.task === undefined ? undefined : state.tasks[args.task];
+    if (args.task !== undefined && (!assigned || assigned.status !== "todo" || (assigned.owner && assigned.owner !== actor))) throw new Error("A launch task must be an existing to-do task that is unowned or yours");
+    // Reserve synchronously before the first await so concurrent launches cannot oversubscribe or double-assign.
+    this.store.update(next => {
+      next.members[id] = member;
+      if (assigned) Object.assign(next.tasks[assigned.id], { owner: id, delegator: actor, revision: next.tasks[assigned.id].revision + 1 });
+    });
+    const brief = assigned ? `${args.brief}\n\nYou own team task ${taskName(assigned)} [${assigned.id}], delegated by ${memberName(parent)}. Start it, and finish with team_task complete and an outcome summary; that one call reports back.` : args.brief;
     this.publishStatus();
     member.model = args.model; member.thinking = args.thinking ?? "off";
     member.terminal = this.options.interactive === true;
@@ -546,14 +557,19 @@ export class Coordinator {
       if (rpcState.model.name !== undefined || rpcState.contextUsage !== undefined) this.recordEvent(id, { type: "telemetry", model: args.model, modelName: rpcState.model.name, contextUsage: rpcState.contextUsage ?? null });
       this.store.update(next => { if (next.members[id].status === "starting") next.members[id].status = prompt ? "busy" : "idle"; });
       this.publishStatus();
-      if (prompt) await agent.request("prompt", { message: args.brief, streamingBehavior: "followUp" });
+      if (prompt) await agent.request("prompt", { message: brief, streamingBehavior: "followUp" });
       return { ...this.publicMember(this.store.state.members[id]), resources };
     } catch (error) {
       clearTimeout(timer); this.ready.delete(id);
       if (agent) await agent.stop();
       // The exit handler may already own the container removal; wait for it so a failed launch leaves nothing running.
       await this.releaseSandbox(id); await this.releasing.get(id);
-      this.store.update(next => { next.members[id].status = "interrupted"; delete next.members[id].needsInput; next.members[id].error = error instanceof Error ? error.message : "Startup failed"; });
+      this.store.update(next => {
+        next.members[id].status = "interrupted"; delete next.members[id].needsInput; next.members[id].error = error instanceof Error ? error.message : "Startup failed";
+        // A failed launch returns its untouched reservation.
+        const task = assigned && next.tasks[assigned.id];
+        if (task && task.owner === id && task.status === "todo") { delete task.owner; delete task.delegator; task.revision++; }
+      });
       this.publishStatus();
       throw error;
     }

package/src/graph.ts

@@ -2,7 +2,7 @@ import { render, type MermaidArt } from "grok-mermaid";
 import { sliceByColumn, visibleWidth } from "@earendil-works/pi-tui";
 import { stripVTControlCharacters } from "node:util";
 
-import { taskName, type TaskView } from "./types.ts";
+import type { TaskView } from "./types.ts";
 import { cleanText } from "./render.ts";
 
 export function taskStatus(task: TaskView): "Done" | "Blocked" | "Working" | "Ready" {
@@ -16,11 +16,20 @@ const label = (text: string) => stripVTControlCharacters(text).replace(/[\x00-\x
   .replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 const cell = (art: MermaidArt, y: number, x: number) => sliceByColumn(art.plain[y] ?? "", x, 1);
 
-export function buildTaskGraph(tasks: TaskView[]): TaskGraph | null {
+/** Shorten a title to at most `budget` columns, preferring a word boundary, with an ellipsis when cut. */
+export function shortenTitle(title: string, budget: number): string {
+  if (visibleWidth(title) <= budget) return title;
+  if (budget < 2) return "";
+  const cut = sliceByColumn(title, 0, budget - 1), space = cut.lastIndexOf(" ");
+  return (space >= cut.length * 0.6 ? cut.slice(0, space) : cut).trimEnd() + "…";
+}
+
+/** Each box shows `#n title · status`; zooming out gives the title fewer columns. Number and status always stay. */
+export function buildTaskGraph(tasks: TaskView[], titleBudget = Infinity): TaskGraph | null {
   if (!tasks.length || tasks.length > 100 || tasks.reduce((size, task) => size + task.dependencies.length, 0) > 300) return null;
   const ids = new Set(tasks.map(task => task.id));
   if (ids.size !== tasks.length || new Set(tasks.map(task => task.number)).size !== tasks.length || tasks.some(task => task.id.length > 128 || !Number.isSafeInteger(task.number) || task.number < 1 || task.dependencies.some(id => !ids.has(id)))) return null;
-  const source = ["flowchart TD", ...tasks.map((task, index) => `n${index}["○ ${label(cleanText(taskName(task)))} · ${taskStatus(task)}"]`),
+  const source = ["flowchart TD", ...tasks.map((task, index) => `n${index}["○ ${label(`#${task.number} ${shortenTitle(cleanText(task.title), titleBudget)}`.trimEnd())} · ${taskStatus(task)}"]`),
     ...tasks.flatMap((task, index) => task.dependencies.map(id => `n${tasks.findIndex(parent => parent.id === id)} --> n${index}`)),
   ].join("\n");
   let art: MermaidArt | null;
@@ -43,7 +52,7 @@ export function buildTaskGraph(tasks: TaskView[]): TaskGraph | null {
       const left = borders[i], right = borders[i + 1];
       if (cell(rendered, y - 1, left) !== "┌" || cell(rendered, y - 1, right) !== "┐") continue;
       const header = sliceByColumn(rendered.plain[y], left + 1, right - left - 1).trimStart();
-      const task = tasks.find(task => header.startsWith(`○ #${task.number} `));
+      const task = tasks.find(task => header.startsWith(`○ #${task.number} `) || header === `○ #${task.number}`);
       if (!task || bounds.has(task.id)) continue;
       for (let bottom = y + 1; bottom < rendered.plain.length; bottom++) {
         if (cell(rendered, bottom, left) === "└" && cell(rendered, bottom, right) === "┘") {

package/src/group.ts

@@ -0,0 +1,134 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { stripVTControlCharacters } from "node:util";
+
+type Row = {
+  message?: { customType?: string; details?: { messages?: { kind?: string }[] } };
+  toolName?: string; args?: { action?: unknown }; expanded?: boolean; _expanded?: boolean;
+  render(width: number): string[];
+};
+type Chat = { children: unknown[]; render(width: number): string[] };
+const hook = Symbol.for("ac-teams.hook.notice-groups");
+const widget = "ac-teams-notice-groups";
+
+const isRow = (child: unknown): child is Row => typeof child === "object" && child !== null && typeof (child as Row).render === "function";
+const isNotice = (row: Row) => row.message?.customType === "ac-teams";
+const isTeam = (child: unknown): child is Row => isRow(child) && (isNotice(child) || /^team_(agent|task|message)$/.test(child.toolName ?? ""));
+
+type Post = { from?: string; summary?: string; task?: string; kind?: string };
+type Labels = Readonly<Record<string, string>>;
+const quiet = new Set(["list", "read", "status", "history", "search", "limits"]);
+const oneLine = (text: unknown) => String(text ?? "").split("\n")[0]!.replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+
+/** What the folded rows did, in plain words: the header phrases, then one line per post. Read-only calls add nothing. */
+/** Transcript state carried across blocks, top to bottom: which tasks are done, and whether the session yielded on a wait. */
+type Progress = { done: Set<string>; waiting: boolean; self: string };
+
+function describe(rows: Row[], labels: Labels, progress: Progress): { header: string; posts: string[] } {
+  const name = (id: unknown) => typeof id === "string" ? labels[id] ?? id : "?";
+  const short = (id: unknown) => name(id).split(" ")[0]!;
+  const phrases = new Map<string, string[]>();
+  const add = (verb: string, ...items: string[]) => phrases.set(verb, [...(phrases.get(verb) ?? []), ...items]);
+  const posts: string[] = [], watched = new Set<string>();
+  for (const row of rows) {
+    const args = (row.args ?? {}) as Record<string, unknown>, action = String(args.action ?? "");
+    if (!row.toolName) {
+      for (const post of (row.message?.details?.messages ?? []) as Post[]) {
+        if (post.task) watched.add(post.task);
+        if (post.kind === "outcome" && post.task) progress.done.add(post.task);
+        // The first post after a wait is the one that started the next turn.
+        const woke = progress.waiting ? ` (woke ${progress.self})` : "";
+        progress.waiting = false;
+        posts.push(`${name(post.from)} ${post.kind === "outcome" ? `completed ${name(post.task)}` : `→ ${post.task ? name(post.task) : "you"}`}${woke}: ${oneLine(post.summary)}`);
+      }
+      continue;
+    }
+    progress.waiting = row.toolName === "team_message" && action === "wait";
+    if (Array.isArray(args.tasks) && action === "wait") for (const id of args.tasks) if (typeof id === "string") watched.add(id);
+    if (quiet.has(action)) continue;
+    else if (row.toolName === "team_agent" && action === "launch") add("launched", String(args.name ?? "a teammate"));
+    else if (row.toolName === "team_task" && action === "create") add("created", ...(Array.isArray(args.tasks) ? args.tasks : [args]).map(() => "task"));
+    else if (row.toolName === "team_message" && action === "wait") add("waiting on", ...(Array.isArray(args.tasks) ? args.tasks.map(short) : ["new posts"]));
+    else if (row.toolName === "team_message" && action === "send") add("messaged", ...(Array.isArray(args.recipients) ? args.recipients.map(name) : [args.task ? short(args.task) : "team"]));
+    else add(action, row.toolName === "team_task" ? short(args.id) : name(args.id));
+  }
+  const done = posts.filter(post => post.includes(" completed ")).length;
+  const parts = [...phrases].map(([verb, items]) => verb === "created" ? `created ${items.length} task${items.length === 1 ? "" : "s"}` : `${verb} ${[...new Set(items)].join(", ")}`);
+  if (posts.length) parts.push(done === posts.length ? `${done} completed` : `${posts.length} update${posts.length === 1 ? "" : "s"}`);
+  // One word for where things stand: every task this block touched is done, the session is yielded on a wait, or work continues.
+  const status = watched.size && [...watched].every(id => progress.done.has(id)) ? "done" : progress.waiting ? "waiting" : "working";
+  return { header: [status, ...parts].join(" · "), posts };
+}
+
+/**
+ * Folds each run of team tool rows and team notices into one block: a plain-words header, then one line per post.
+ * Rows that draw nothing (an empty assistant turn between tool calls) stay inside a run; any visible other row ends it.
+ * An expanded row shows the whole run natively.
+ */
+export function groupTeamRows(children: unknown[], width: number, style: (header: string, posts: string[], width: number, warnings: string[]) => string[], labels: Labels, self = "this session", ours: (line: string) => boolean = () => false): unknown[] {
+  const out: unknown[] = [];
+  const progress: Progress = { done: new Set(), waiting: false, self };
+  for (let i = 0; i < children.length;) {
+    if (!isTeam(children[i])) {
+      // The user's message also wakes a yielded session; footers and other rows do not.
+      if ((children[i] as object | null)?.constructor?.name === "UserMessageComponent") progress.waiting = false;
+      out.push(children[i]); i++; continue;
+    }
+    let end = i, last = i;
+    const team: Row[] = [], found: { index: number; text: string }[] = [];
+    while (end < children.length) {
+      const child = children[end];
+      if (isTeam(child)) { team.push(child); last = end; }
+      else {
+        const lines = isRow(child) ? child.render(width).map(line => stripVTControlCharacters(line).trim()).filter(Boolean) : undefined;
+        // Blank rows (spacers, an empty assistant turn) stay inside a run, and so do ac-teams' own warnings; anything else ends it.
+        if (!lines) break;
+        if (lines.length === 1 && ours(lines[0]!)) found.push({ index: end, text: lines[0]! });
+        else if (lines.length) break;
+      }
+      end++;
+    }
+    const warnings = [...new Set(found.filter(item => item.index < last).map(item => item.text))];
+    const members = children.slice(i, last + 1);
+    // Describe in transcript order now, so progress reflects every earlier block; rendering only reads the result.
+    const { header, posts } = describe(team, labels, progress);
+    if (team.length < 2) out.push(...members);
+    else {
+      out.push({ render(width: number) {
+        if (team.some(row => row.expanded || row._expanded)) return members.flatMap(row => (row as Row).render(width));
+        // Native rendering stays in charge of visibility, so /silent (which empties notice rows) still hides a notice-only block.
+        if (team.every(row => isNotice(row) && !row.render(width).length)) return [];
+        return ["", ...style(header, posts, width, warnings)];
+      }, invalidate() {} });
+    }
+    i = last + 1;
+  }
+  return out;
+}
+
+/** Pi has no API to merge transcript rows, so this wraps the chat container's render through an invisible widget; any unexpected shape leaves the transcript native. */
+export function bindNoticeGroups(ctx: ExtensionContext, labels: () => Labels, self: () => string, ours: (line: string) => boolean) {
+  if (ctx.mode !== "tui") return;
+  ctx.ui.setWidget(widget, tui => {
+    // SAFETY: Pi's private layout (document, then chat last); the shape checks below reject anything else.
+    const chat = (tui as unknown as { children?: { children?: unknown[] }[] }).children?.[0]?.children?.at(-1) as Chat | undefined;
+    if (chat && Array.isArray(chat.children) && typeof chat.render === "function" && !Object.hasOwn(chat, hook)) {
+      const original = chat.render;
+      const theme = ctx.ui.theme;
+      const style = (header: string, posts: string[], width: number, warnings: string[]) => {
+        const lines = [theme.fg("accent", theme.bold("ac-teams")) + theme.fg("muted", ` · ${header}`) + theme.fg("dim", " (Ctrl+O for details)")];
+        for (const warning of warnings) lines.push(theme.fg("warning", `  ${warning}`));
+        for (const post of posts.slice(-5)) lines.push(theme.fg("text", `  ${post}`));
+        if (posts.length > 5) lines.splice(1, 0, theme.fg("dim", `  … ${posts.length - 5} earlier`));
+        return lines.map(line => truncateToWidth(line, width));
+      };
+      Object.defineProperty(chat, hook, { value: true });
+      chat.render = function (this: Chat, width: number) {
+        const children = this.children;
+        this.children = groupTeamRows(children, width, style, labels(), self(), ours);
+        try { return original.call(this, width); } finally { this.children = children; }
+      };
+    }
+    return { render: () => [], invalidate() {} };
+  }, { placement: "belowEditor" });
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+import { bindNoticeGroups } from "./group.ts";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { fileURLToPath } from "node:url";
 import { AgentSchema, TaskSchema, MessageSchema, validate } from "./schemas.ts";
@@ -13,7 +14,7 @@ import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { promisify } from "node:util";
-import { createMemberLabels, readState, teamsHome } from "./store.ts";
+import { createMemberLabels, readState, stateLabels, teamsHome } from "./store.ts";
 import { teamEntryType, type TeamEntry } from "./mains.ts";
 import { isMain, memberName, taskName, type TeamState } from "./types.ts";
 import { Coordinator, assistantEvent, taskRequestGuidance } from "./coordinator.ts";
@@ -51,14 +52,31 @@ export default function teams(pi: ExtensionAPI) {
   const cachedLabels = createMemberLabels();
   function memberLabels(): Record<string, string> {
     try {
-      if (coordinator) return Object.fromEntries(Object.values(coordinator.store.state.members).map(member => [member.id, memberName(member)]));
+      if (coordinator) return stateLabels(coordinator.store.state);
       return cachedLabels(child ? dirname(environment[0]!) : join(teamsHome(), teamId(context!)));
     } catch { return { root: "Main" }; } // A transcript can render before its team is available.
   }
   pi.registerMessageRenderer("ac-teams", teamMessageRenderer(memberLabels));
-  const warn = (message: string) => context?.ui.notify(message, "warning");
+  /** Warnings this extension showed, so a folded team block can absorb its own (Pi prints them as "Warning: ..."). */
+  const ownWarnings = new Set<string>();
+  const warn = (message: string) => { ownWarnings.add(`Warning: ${message}`); context?.ui.notify(message, "warning"); };
+  /** Highest notice handed to Pi, and highest found persisted in this session and acknowledged. */
+  let sent = 0, acked = 0;
   const notify = (through: number, messages: Message[] = []) => {
-    pi.sendMessage({ customType: "ac-teams", content: `New team messages through sequence ${through}. Read team_message history after your last cursor. Reply only with useful updates, not acknowledgements.`, display: true, details: { through, messages } }, { deliverAs: "followUp", triggerTurn: true });
+    if (through <= sent) return;
+    // Unacknowledged posts are offered again; show each one once.
+    messages = messages.filter(message => message.seq > sent);
+    sent = through;
+    const labels = memberLabels(), name = (id: string) => labels[id] ?? id;
+    const lines = messages.map(message => `[${message.seq}] ${name(message.from)}${message.kind === "outcome" ? " completed" : ""}${message.task ? ` ${name(message.task)} [${message.task}]` : ""}: ${message.summary}${message.detail ? " (detail via team_message history)" : ""}`);
+    pi.sendMessage({ customType: "ac-teams", content: `Team posts:\n${lines.join("\n")}\nAct only if one needs you. Fetch detail only to settle a question about your own work.`, display: true, details: { through, messages } }, { deliverAs: "steer", triggerTurn: true });
+  };
+  /** Acknowledges notices only once they are durable session entries, so a crash before persistence redelivers them. */
+  const reconcile = (ctx: ExtensionContext) => {
+    const through = ctx.sessionManager.getEntries().reduce((max, entry) => entry.type === "custom_message" && entry.customType === "ac-teams" ? Math.max(max, Number((entry.details as { through?: number } | undefined)?.through) || 0) : max, 0);
+    sent = Math.max(sent, through);
+    if (through <= acked || (!connection && !coordinator)) return;
+    acked = through;
     if (connection) void connection.request("ack", { through }).catch(error => warn(String(error)));
     else coordinator?.ack(coordinator.self, through);
   };
@@ -273,15 +291,16 @@ export default function teams(pi: ExtensionAPI) {
     }
   });
   pi.on("agent_start", (_event, ctx) => report(ctx, { type: "agent_start" }));
-  pi.on("agent_settled", (_event, ctx) => { inputCount = 0; report(ctx, { type: "agent_settled" }); });
+  pi.on("turn_end", (_event, ctx) => reconcile(ctx));
+  pi.on("agent_settled", (_event, ctx) => { inputCount = 0; reconcile(ctx); report(ctx, { type: "agent_settled" }); });
   pi.on("tool_execution_start", (event, ctx) => report(ctx, { type: "activity", text: `Running ${event.toolName}`.slice(0, 500) }));
   pi.on("message_end", (event, ctx) => {
     const change = assistantEvent(event.message);
     if (change) report(ctx, change);
   });
   function output(data: unknown) { return { content: [{ type: "text" as const, text: JSON.stringify(data) }], details: data }; }
-  const guidance = "Team launches use real long-lived Pi sessions. Idle members count against the shared ceiling and retain their processes and extensions. Check team_agent list resources before adding concurrency; teammate launch/resume results include pre-launch host headroom. Resource warnings are advisory, not a memory reservation or capacity guarantee. Choose concurrency using resource readings and observed progress, not low headroom alone. If contention slows progress, stop unneeded idle members and resume their saved sessions later. Use teammate names for messaging and stable IDs for member control and tasks; query status and history instead of acknowledging notifications. Limits cover only ac-teams, not other launchers or shell commands.";
-  const taskTrackingGuidance = "Before delegating a deliverable through team_agent, create or reuse a team_task and include its ID in the member's brief. Use one shared task list for your own work and delegated work; do not create one task per teammate by default. Quick lookups and brief second opinions need no separate task unless their results need coordination or follow-up.";
+  const guidance = "Team launches use real long-lived Pi sessions. Idle members count against the shared ceiling and retain their processes and extensions. Check team_agent list resources before adding concurrency; teammate launch/resume results include pre-launch host headroom. Resource warnings are advisory, not a memory reservation or capacity guarantee. Choose concurrency using resource readings and observed progress, not low headroom alone. If contention slows progress, stop unneeded idle members and resume their saved sessions later. Use teammate names for messaging and stable IDs for member control and tasks; never acknowledge notifications. Limits cover only ac-teams, not other launchers or shell commands.";
+  const taskTrackingGuidance = "Before delegating a deliverable through team_agent, create or reuse a team_task and pass it as the launch task; its owner's completion outcome reports back to you. Use one shared task list for your own work and delegated work; do not create one task per teammate by default. Quick lookups and brief second opinions need no separate task unless their results need coordination or follow-up.";
   pi.registerTool({
     name: "team_agent", label: "Team agent", description: "Launch/resume Pi members, list/status, stop owned subtrees, change root limits, and explicitly clean stopped worktrees. Create or reuse team_task entries for delegated deliverables; quick lookups need no task unless results need coordination or follow-up.",
     promptGuidelines: [guidance, taskTrackingGuidance, "Delegation needs the user's authorization. Give each new member a unique descriptive name (one or two lowercase words, hyphenated if two), plus a bounded brief. Names remain stable on resume. Avoid concurrent writers in the same cwd. Worktrees are opt-in."],
@@ -310,12 +329,15 @@ export default function teams(pi: ExtensionAPI) {
     },
   });
   pi.registerTool({
-    name: "team_message", label: "Team message", description: "Send a persistent direct/team message to teammate names or IDs, or read cursor-paged history. Send returns a receipt with resolved IDs; history and search return full messages. New messages queue a compact follow-up notification for each recipient.",
-    promptGuidelines: ["Do not poll team_message history while waiting for replies; notifications trigger a follow-up turn. On notification, read team_message history after your last read cursor and advance it through the returned messages. An empty result means no newer messages, not that a teammate has finished."],
+    name: "team_message", label: "Team message", description: "Post to the team board, read history or search, or wait. A post has a required one-line summary that stands alone, optional detail, and links an existing task or replies to a post. It reaches named recipients (teammate names or IDs) plus the linked task's owner and delegator; it is never broadcast. Recipients receive summaries at their next safe point. Wait yields this turn until a post reaches you or lands on the given tasks.",
+    promptGuidelines: ["Post only what changes someone's work: an outcome, a blocker, a question, or new context. Do not acknowledge notices or narrate progress.", "Notices carry summaries; read history only for the detail a question about your own work needs.", "After delegating, do not repeat the delegated work. Do distinct work, or call team_message wait with the delegated task IDs as your last action; never poll history."],
     parameters: MessageSchema,
     ...teamToolRenderers("team_message", memberLabels),
     async execute(_id, args, _signal, _update, ctx) {
-      const result = await handle("message", args, ctx);
+      // Posts already shown in a notice are not news to this wait.
+      const result = await handle("message", args.action === "wait" && args.after === undefined ? { ...args, after: sent } : args, ctx);
+      // Nothing ready: end the turn without another model request; the next matching notice starts a new one.
+      if (args.action === "wait") return { ...output(result), terminate: (result as Message[]).length === 0 };
       if (args.action === "send") {
         const { seq, id, recipients } = result as Message;
         return output({ seq, id, recipients });
@@ -393,7 +415,7 @@ export default function teams(pi: ExtensionAPI) {
     pi.sendMessage({ customType: "ac-teams", display: true, details: { through: state.messages.at(-1)?.seq ?? 0, messages: recent }, content: [
       `Joined team ${state.id} as ${name(team!.member)}, a main session.`,
       open.length ? `Open tasks:\n${open.map(task => `- ${taskName(task)} (${task.status}, ${name(task.owner)})`).join("\n")}` : "No open tasks.",
-      recent.length ? `Recent messages:\n${recent.map(message => `- ${name(message.from)}: ${message.text.split("\n")[0].slice(0, 200)}`).join("\n")}` : "No messages yet.",
+      recent.length ? `Recent messages:\n${recent.map(message => `- ${name(message.from)}: ${message.summary.split("\n")[0].slice(0, 200)}`).join("\n")}` : "No messages yet.",
     ].join("\n\n") }, { triggerTurn: false });
   }
   /** /teams leave: hands this session's work back and drops its main-session role. */
@@ -410,7 +432,7 @@ export default function teams(pi: ExtensionAPI) {
   }
   pi.on("session_start", async (_event, ctx) => {
     if (!child && linkedSession && linkedSession !== ctx.sessionManager.getSessionId()) { await close(); drafts.clear(); }
-    context = ctx; exiting = false; inputCount = 0;
+    context = ctx; exiting = false; inputCount = 0; sent = acked = 0;
     if (child) {
       if (environment.some(value => !value)) throw new Error("Incomplete AC_TEAMS membership environment; refusing independent-root fallback");
       const link = new Connection(environment[0]!, environment[1]!, environment[2]!);
@@ -428,6 +450,9 @@ export default function teams(pi: ExtensionAPI) {
       if (data?.left) disable("This session left its team; use /teams join to join one");
       else if (team) await rejoin(ctx);
     }
+    // Notices persisted before a crash or reconnect count as delivered; acknowledge them so they are not shown twice.
+    reconcile(ctx);
+    bindNoticeGroups(ctx, memberLabels, () => memberLabels()[memberId()] ?? "this session", line => ownWarnings.has(line));
     startTelemetry(ctx);
     if (!warned) {
       warned = true;