ac-teams 0.0.14 → 0.0.16

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. Sequence launches while members are starting or memory is pressured; 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;

package/src/panel.ts

@@ -2,17 +2,22 @@ import { basename } from "node:path";
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Editor, indexedColor, matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { contextSummary } from "./telemetry.ts";
-import { buildTaskGraph, moveTaskSelection, taskStatus } from "./graph.ts";
+import { buildTaskGraph, moveTaskSelection, taskStatus, type TaskGraph } from "./graph.ts";
 import { cleanText as clean } from "./render.ts";
 import type { PanelHost } from "./ui-types.ts";
-import { taskName, type TaskView } from "./types.ts";
+import { taskName, type Message, type TaskView } from "./types.ts";
 
 export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Promise<void> {
   if (ctx.mode !== "tui") throw new Error("Teams panel requires interactive terminal mode");
   let snapshot = await host.snapshot();
   let tasks = snapshot.tasks;
   let events = snapshot.messages.slice().reverse();
-  let taskGraph = buildTaskGraph(tasks);
+  // Zoom is the title width each box gets, from the longest title (100%) down to none (number and status only).
+  const longest = () => Math.max(1, ...tasks.map(task => visibleWidth(clean(task.title))));
+  let graphs = new Map<number, TaskGraph | null>();
+  const graphAt = (budget: number) => { if (!graphs.has(budget)) graphs.set(budget, buildTaskGraph(tasks, budget)); return graphs.get(budget)!; };
+  let zoom: number | "fit" = "fit", shownZoom = longest();
+  let taskGraph = graphAt(shownZoom);
   const drafts = host.drafts;
   const name = (id: string | undefined) => id === "root" ? "Main" : clean(snapshot.members.find(member => member.id === id)?.name ?? id ?? "Unassigned");
   const creator = (task: TaskView) => (task as TaskView & { creator?: string }).creator ?? "root";
@@ -26,7 +31,7 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
     let timer: ReturnType<typeof setTimeout> | undefined;
     let focused = true;
     let memberQuery = "", searching = false, hideStopped = false;
-    const tabs = ["Tasks", "Teammates", "Activity"];
+    const tabs = ["Tasks", "Teammates", "Board"];
     const selectedTask = () => tasks[taskIndex];
     const memberIds = () => ["root", ...snapshot.members.filter(member => member.id !== "root").map(member => member.id)]
       .filter(id => name(id).toLowerCase().includes(memberQuery.toLowerCase())
@@ -46,7 +51,7 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
         taskIndex = Math.max(0, tasks.findIndex(task => task.id === taskId));
         memberIndex = Math.max(0, memberIds().indexOf(memberId));
         eventIndex = Math.max(0, events.findIndex(event => event.id === eventId));
-        if (changed) taskGraph = buildTaskGraph(tasks);
+        if (changed) { graphs = new Map(); taskGraph = graphAt(Math.min(shownZoom, longest())); }
       } catch (error) { if (!disposed) receipt = `Refresh failed: ${clean(String(error))}`; }
       finally { if (!disposed) { refresh(); timer = setTimeout(() => void poll(), 2000); } }
     }
@@ -115,23 +120,36 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
       const task = selectedTask();
       if (!task) return wrap([heading("No tasks yet"), "Request a task with N. Main creates and organizes it."], width);
       const unlocked = tasks.filter(other => other.dependencies.includes(task.id));
+      const outcome = task.outcome ? snapshot.messages.find(message => message.id === task.outcome) : undefined;
+      const [first = "", ...rest] = outcome ? clean(outcome.summary).split("\n") : [];
+      const prerequisites = task.dependencies.map(id => {
+        const parent = tasks.find(item => item.id === id);
+        return parent ? `${taskTitle(parent.id)} · ${stateLabel(parent)}` : `${clean(id)} · Unavailable`;
+      });
       return wrap([
-        heading(clean(taskName(task))), label("Title", clean(task.title)), label("ID", task.id), "",
-        label("State", stateLabel(task)), label("Owner", name(task.owner)), label("Creator", name(creator(task))), "",
-        heading("Description"), clean(task.description), "",
-        heading("Prerequisites"),
-        ...(task.dependencies.length ? task.dependencies.map(id => {
-          const parent = tasks.find(item => item.id === id);
-          return parent ? `${clean(taskName(parent))} · ${taskStatus(parent)}` : `${clean(id)} · Unavailable`;
-        }) : [fg("muted", "None; this task can start independently.")]), "",
-        heading("Unlocks"), ...(unlocked.length ? unlocked.map(item => clean(taskName(item))) : [fg("muted", "No dependent tasks.")]),
-        "",
-        fg("accent", "C  Give feedback to creator"), fg("accent", "O  Open owner's full session"),
-        ...(!detail ? [fg("muted", "Enter  Full details")] : []),
+        heading(taskTitle(task.id)) + fg("muted", " · ") + stateLabel(task), "",
+        label("Owner", name(task.owner)), ...(task.delegator ? [label("Delegator", name(task.delegator))] : []),
+        label("Creator", name(creator(task))), "",
+        ...(outcome ? [section(`Outcome from ${name(outcome.from)}`, width), theme.bold(first), ...rest, ...(outcome.detail ? ["", fg("muted", clean(outcome.detail))] : []), ""] : []),
+        section("Description", width), clean(task.description), "",
+        section("Dependencies", width),
+        label("Needs", prerequisites.length ? prerequisites.join(", ") : fg("muted", "Nothing; can start now")),
+        label("Unlocks", unlocked.length ? unlocked.map(item => taskTitle(item.id)).join(", ") : fg("muted", "No other tasks")), "",
+        section("Actions", width), fg("accent", "C") + "  Give feedback to creator", fg("accent", "O") + "  Open owner's session", "",
+        fg("dim", `ID ${task.id}`),
       ], width);
     }
 
     function graphLines(width: number) {
+      if (zoom === "fit") {
+        // Largest title width that still fits the pane (binary search; graphs are cached per width).
+        const fits = (budget: number) => { const g = graphAt(budget); return !!g && g.art.width <= width && g.art.plain.length <= bodyHeight - 1; };
+        let low = 0, high = longest();
+        if (fits(high)) low = high;
+        else while (low < high - 1) { const mid = (low + high) >> 1; if (fits(mid)) low = mid; else high = mid; }
+        shownZoom = low;
+      } else shownZoom = zoom;
+      taskGraph = graphAt(shownZoom);
       if (!taskGraph) return undefined;
       const { art, bounds } = taskGraph;
       const selected = bounds.get(selectedTask()?.id ?? "");
@@ -150,10 +168,12 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
           if (active && y === box.top + 1) text = text.replace("○ ", "● ");
           const border = y === box.top || y === box.bottom;
           const content = sliceByColumn(text, 1, box.right - box.left - 1), status = taskStatus(task);
-          const color = status === "Done" ? "dim" : "text";
+          const color = active ? "accent" : status === "Done" ? "dim" : "text";
           const index = y === box.bottom - 1 && content.trimEnd().endsWith(status) ? content.lastIndexOf(status) : -1;
           const interior = index < 0 ? fg(color, content) : fg(color, content.slice(0, index)) + stateLabel(task) + fg(color, content.slice(index + status.length));
-          const styled = border ? statusText(task, text) : statusText(task, "│") + (active ? theme.bold(interior) : interior) + statusText(task, "│");
+          // The selected box keeps its status colour but gets a heavy border and bold text, so selection never competes with status.
+          const edge = (part: string) => statusText(task, active ? part.replace(/[┌┐└┘─│┬┴]/g, ch => ({ "┌": "┏", "┐": "┓", "└": "┗", "┘": "┛", "─": "━", "│": "┃", "┬": "┯", "┴": "┷" })[ch]!) : part);
+          const styled = border ? edge(text) : edge("│") + (active ? theme.bold(interior) : interior) + edge("│");
           row = sliceByColumn(row, 0, box.left) + styled + sliceByColumn(row, box.right + 1, art.width);
         }
         const indent = " ".repeat(Math.max(0, Math.floor((width - art.width) / 2)));
@@ -184,9 +204,9 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
       let selectedHeight = 1, graphWidth = 0;
       if (tab === 0) {
         const graphData = graph ? graphLines(leftWidth) : undefined;
-        left = graphData ? graphData.rows : tasks.length ? [fg("muted", "  Task / State"), "",
+        left = graphData ? graphData.rows : tasks.length ? [fg("muted", "  Task"), "",
           ...tasks.map((task, index) => {
-            const text = `${index === taskIndex ? "●" : " "} ${clean(taskName(task))}`;
+            const text = `${index === taskIndex ? "●" : " "} ${taskTitle(task.id)}`;
             const body = fg(taskStatus(task) === "Done" ? "dim" : "text", truncateToWidth(text, Math.max(1, leftWidth - 10)));
             return (index === taskIndex ? theme.bold(body) : body) + " · " + stateLabel(task);
           })] : [heading("No tasks yet"), "N  Request a task from Main"];
@@ -211,8 +231,8 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
         const nameExtra = Math.min(spare, Math.max(0, ...ids.map(id => visibleWidth(name(id)) - nameWidth)));
         const gap = " ".repeat(4 + Math.floor((spare - nameExtra) / gaps));
         nameWidth += nameExtra + (spare - nameExtra) % gaps;
-        left = [fg("muted", `  ${pad("Member", nameWidth)}${gap}${pad("Session", sessionWidth)}`
-          + (showTasks ? `${gap}${pad("Tasks", tasksWidth)}` : "") + (showDirectory ? `${gap}Directory` : "")), ...ids.map((id, index) => {
+        left = [fg("muted", `  ${pad("Member", nameWidth)}${gap}${pad("State", sessionWidth)}`
+          + (showTasks ? `${gap}${pad("Done", tasksWidth)}` : "") + (showDirectory ? `${gap}Directory` : "")), ...ids.map((id, index) => {
           const member = snapshot.members.find(member => member.id === id);
           const selected = index === memberIndex;
           const stopped = member && ["stopped", "interrupted"].includes(member.status);
@@ -230,11 +250,19 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
         selectedRow = memberIndex + 1;
         right = split ? memberDetails(rightWidth) : [];
       } else {
-        left = events.length ? [fg("muted", "  Recent messages · newest first"), "", ...events.flatMap((event, index) => [
-          `${index === eventIndex ? "●" : " "} ${name(event.from)} → ${event.recipients.map(name).join(", ") || "Team"}`,
-          fg("muted", `  ${clean(event.time)} · ${clean(event.text).split("\n")[0]}`), "",
-        ])] : [heading("No activity yet"), fg("muted", "Recent persistent team messages appear here.")];
-        selectedRow = eventIndex * 3 + 2;
+        // One row per post: who, what kind, its summary headline, then task and time as quieter context.
+        const fromWidth = Math.min(16, Math.max(4, ...events.map(event => visibleWidth(name(event.from)))));
+        const taskWidth = Math.min(5, Math.max(4, ...events.map(event => event.task ? visibleWidth(taskRef(event.task)) : 0)));
+        const summaryWidth = Math.max(1, leftWidth - (2 + fromWidth + 2 + 7 + 2 + 2 + taskWidth + 2 + 5));
+        left = events.length ? [fg("muted", `  ${pad("From", fromWidth)}  ${pad("Kind", 7)}  ${pad("Summary", summaryWidth)}  ${pad("Task", taskWidth)}  Time`),
+          ...events.map((event, index) => {
+            const selected = index === eventIndex;
+            const from = pad(name(event.from), fromWidth), summary = pad(headline(event), summaryWidth);
+            return fg(selected ? "accent" : "dim", `${selected ? "●" : " "} `) + (selected ? theme.bold(fg("accent", from)) : from) + "  "
+              + kindLabel(event) + "  " + (selected ? theme.bold(summary) : summary) + "  "
+              + fg("muted", pad(event.task ? taskRef(event.task) : "", taskWidth)) + "  " + fg("dim", clock(event.time).slice(0, 5));
+          })] : [heading("No posts yet"), fg("muted", "Updates, questions, replies, and outcomes appear here.")];
+        selectedRow = eventIndex + 1;
         right = split ? eventDetails(rightWidth) : [];
       }
 
@@ -243,8 +271,12 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
       if (selectedRow + selectedHeight > scroll + viewHeight) scroll = selectedRow + selectedHeight - viewHeight;
       scroll = Math.max(0, Math.min(scroll, Math.max(0, left.length - viewHeight)));
       const viewport = left.slice(scroll, scroll + viewHeight);
-      if (graphWidth) viewport.unshift(fg("muted", `↑ ${scroll} rows above · ↓ ${Math.max(0, left.length - scroll - viewHeight)} below`
-        + (graphWidth > leftWidth ? ` · ← ${columnScroll} cols · ${Math.max(0, graphWidth - columnScroll - leftWidth)} →` : "")));
+      if (graphWidth) {
+        const hidden = scroll || left.length > scroll + viewHeight || graphWidth > leftWidth;
+        viewport.unshift(fg("muted", `Zoom ${Math.round(100 * shownZoom / longest())}%${zoom === "fit" ? " (fit)" : ""}`
+          + (hidden ? ` · ↑ ${scroll} rows · ↓ ${Math.max(0, left.length - scroll - viewHeight)} rows` : "")
+          + (graphWidth > leftWidth ? ` · ← ${columnScroll} cols · ${Math.max(0, graphWidth - columnScroll - leftWidth)} cols →` : "")));
+      }
       return Array.from({ length: bodyHeight }, (_, index) => {
         let row = viewport[index] ?? "";
         if (!graphWidth && index === 0 && scroll > 0) row = fg("muted", `↑ ${scroll} rows above`);
@@ -253,10 +285,39 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
       });
     }
 
+    /** Task number and full title; labels are too short to say what a post is about. */
+    function taskTitle(id: string) {
+      const task = tasks.find(item => item.id === id);
+      return task ? clean(`#${task.number} ${task.title}`) : clean(id);
+    }
+
+    const headline = (event: Message) => clean(event.summary).split("\n")[0];
+    const taskRef = (id: string) => { const task = tasks.find(item => item.id === id); return task ? `#${task.number}` : "#?"; };
+    const kindLabel = (event: Message) => event.kind === "outcome" ? fg("success", pad("Outcome", 7))
+      : event.replyTo ? fg("accent", pad("Reply", 7)) : fg("muted", pad("Post", 7));
+    // A labelled rule separates tiers more clearly than bold text alone.
+    const section = (title: string, width: number) => theme.bold(fg("accent", title)) + " " + fg("dim", "─".repeat(Math.max(0, width - visibleWidth(title) - 1)));
+    const post = (id: string | undefined) => snapshot.messages.find(message => message.id === id);
+    const clock = (time: string) => { const date = new Date(time); return isNaN(+date) ? clean(time) : date.toTimeString().slice(0, 8); };
+
+    // Tiers: headline (first summary line), the rest of the summary, then optional detail and the thread around it.
     function eventDetails(width: number) {
       const event = events[eventIndex];
-      if (!event) return wrap([heading("No activity yet"), "Recent persistent team messages appear here."], width);
-      return wrap([heading("Team message"), "", label("From", name(event.from)), label("To", event.recipients.map(name).join(", ") || "Team"), label("Time", clean(event.time)), "", clean(event.text)], width);
+      if (!event) return wrap([heading("No posts yet"), "Updates, questions, replies, and outcomes appear here."], width);
+      const [first = "", ...rest] = clean(event.summary).split("\n");
+      const parent = post(event.replyTo), task = event.task ? tasks.find(item => item.id === event.task) : undefined;
+      const replies = snapshot.messages.filter(message => message.replyTo === event.id);
+      const date = new Date(event.time);
+      return wrap([
+        kindLabel(event).trimEnd() + fg("muted", ` from ${name(event.from)}`),
+        label("To", event.recipients.map(name).join(", ") || "Team"),
+        ...(event.task ? [label("Task", `${taskTitle(event.task)}${task ? ` · ${stateLabel(task)}` : ""}`)] : []),
+        ...(parent ? [label("Reply to", `${name(parent.from)}: ${headline(parent)}`)] : []),
+        label("Time", isNaN(+date) ? clean(event.time) : date.toLocaleString()), "",
+        section("Summary", width), theme.bold(first), ...rest,
+        ...(event.detail ? ["", section("Detail", width), clean(event.detail)] : []),
+        ...(replies.length ? ["", section(`Replies (${replies.length})`, width), ...replies.map(reply => `${name(reply.from)}: ${headline(reply)}`)] : []),
+      ], width);
     }
 
     function memberDetails(width: number) {
@@ -265,20 +326,21 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
       if (!id) return wrap([heading("No matching teammates"), "Change the name filter or show stopped members."], width);
       const member = snapshot.members.find(member => member.id === id);
       const assigned = tasks.filter(task => task.owner === id);
-      return wrap([heading(name(id)), "", label("State", member?.needsInput ? fg("error", "Needs input") : clean(member?.status ?? (id === "root" ? "Main conversation" : "Unavailable")).replace(/^./, char => char.toUpperCase())),
+      const stopped = member && ["stopped", "interrupted"].includes(member.status);
+      return wrap([
+        heading(name(id)) + fg("muted", " · ") + (member?.needsInput ? fg("error", "Needs input") : clean(member?.status ?? (id === "root" ? "Main conversation" : "Unavailable")).replace(/^./, char => char.toUpperCase())), "",
         label("Model", clean(member?.modelName || member?.model?.slice(member.model.indexOf("/") + 1) || "Unknown")),
         label("Context", clean(contextSummary(member?.contextUsage).replace(/^context unknown/, "Unknown"))),
         label("Directory", clean(member?.cwd ?? (id === host.self ? ctx.cwd : "Unavailable"))),
-        label("Tasks", taskProgress(id)), fg("muted", "Completed / currently assigned"),
-        ...(member?.error ? [label("Error", clean(member.error))] : []), "", heading("Assigned tasks"),
-        ...assigned.map(task => `${clean(taskName(task))} · ${taskStatus(task)}`),
-        ...(assigned.length ? [] : [fg("muted", "No assigned tasks.")]), "",
-        fg("accent", member && ["stopped", "interrupted"].includes(member.status) ? "Enter  Resume and open" : "Enter  Open session"),
-        ...(!detail ? [fg("muted", "→  Details")] : []),
-        ...(!host.child && member?.role === "member" ? [fg("accent", "P  Promote to main session"), fg("muted", "Stops member; reopens transcript as a main session.")] : []),
-        "", heading("Session details"), label("ID", id),
-        label("Session", clean(member?.sessionFile ?? member?.sessionId ?? "Unavailable")),
-        label("Worktree", member?.worktree ? clean(`${member.worktree.path} (${member.worktree.branch})`) : "None"),
+        ...(member?.error ? [label("Error", fg("error", clean(member.error)))] : []), "",
+        section(`Tasks (${assigned.filter(task => task.status === "done").length} of ${assigned.length} done)`, width),
+        ...(assigned.length ? assigned.map(task => `${taskTitle(task.id)} · ${stateLabel(task)}`) : [fg("muted", "No assigned tasks.")]), "",
+        section("Actions", width), fg("accent", "Enter") + (stopped ? "  Resume and open session" : "  Open session"),
+        ...(!host.child && member?.role === "member" ? [fg("accent", "P") + "  Promote to main session " + fg("muted", "(stops the member, reopens its transcript as a main session)")] : []), "",
+        section("Session", width),
+        fg("muted", label("ID", id)),
+        fg("muted", label("File", clean(member?.sessionFile ?? member?.sessionId ?? "Unavailable"))),
+        fg("muted", label("Worktree", member?.worktree ? clean(`${member.worktree.path} (${member.worktree.branch})`) : "None")),
       ], width);
     }
 
@@ -297,7 +359,7 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
           : compose ? "Enter Send · Shift+Enter Newline · Esc Keep draft"
           : detail ? tab === 0 ? "↑↓ Scroll · C Feedback · O Open owner · Esc Back"
             : tab === 1 ? "↑↓ Scroll · Enter Open session · Esc Back" : "↑↓ Scroll · O Open related session · Esc Back"
-          : tab === 0 ? `${graph ? "↑↓←→" : "↑↓"} Select · Enter Details · G Graph/List · C Feedback · N New task · Tab Next · Esc Close`
+          : tab === 0 ? `${graph ? "↑↓←→" : "↑↓"} Select · Enter Details · G Graph/List${graph ? " · +/- Zoom · F Fit" : ""} · C Feedback · N New task · Tab Next · Esc Close`
           : tab === 1 ? `${filters} · ↑↓ Select · → Details · Enter Open session · N New task · Tab Next · Esc Close`
           : "↑↓ Select · Enter Details · O Open related session · Tab Next · Esc Close";
         const teammates = snapshot.members.filter(member => member.id !== "root");
@@ -307,7 +369,7 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
         const summaryText = tab === 0
           ? `${tasks.length} tasks · ${["Working", "Ready", "Blocked", "Done"].map(state => `${tasks.filter(task => taskStatus(task) === state).length} ${state.toLowerCase()}`).join(" · ")}`
           : tab === 1 ? `${teammates.length} teammate${teammates.length === 1 ? "" : "s"} · ${["working", "idle", "stopped", "needs input"].map(state => `${memberStates.filter(value => value === state).length} ${state}`).join(" · ")}`
-          : `${events.length} message${events.length === 1 ? "" : "s"} · newest first`;
+          : `${events.length} post${events.length === 1 ? "" : "s"} · ${events.filter(event => event.kind === "outcome").length} outcomes · ${events.filter(event => event.replyTo).length} replies`;
         const summary = wrapTextWithAnsi(fg("muted", summaryText), inner);
         const receipts = receipt ? wrapTextWithAnsi(fg("muted", receipt), inner) : [];
         const hints = wrapTextWithAnsi(fg("dim", help), inner);
@@ -360,6 +422,13 @@ export async function showTeamsPanel(ctx: ExtensionContext, host: PanelHost): Pr
           else if (tab === 1) memberIndex = Math.max(0, Math.min(memberIds().length - 1, memberIndex + delta));
           else eventIndex = Math.max(0, Math.min(events.length - 1, eventIndex + delta));
         } else if (data.toLowerCase() === "g" && tab === 0 && !detail) { graph = !graph; scroll = 0; }
+        else if (tab === 0 && graph && !detail && ["+", "=", "-"].includes(data)) {
+          // Steps of 1.25x title width, like a smooth zoom; always at least one column so each press shows a change.
+          const at = zoom === "fit" ? shownZoom : zoom;
+          zoom = data === "-" ? Math.max(0, Math.min(at - 1, Math.floor(at / 1.25)))
+            : Math.min(longest(), Math.max(at + 1, Math.ceil(at * 1.25)));
+          scroll = 0; columnScroll = 0;
+        } else if (tab === 0 && graph && !detail && data.toLowerCase() === "f") { zoom = "fit"; scroll = 0; columnScroll = 0; }
         else if (data.toLowerCase() === "n") begin("new");
         else if (data.toLowerCase() === "c" && tab === 0) begin("feedback");
         else if (data.toLowerCase() === "p" && tab === 1 && !host.child) {

package/src/render.ts

@@ -62,7 +62,7 @@ function toolSummary(data: unknown, theme: Theme, labels: Readonly<Record<string
     const value = data as Record<string, unknown>;
     if (Array.isArray(value.members)) return preview(value.members, `${value.members.length} members`, theme, labels);
     if (Array.isArray(value.tasks)) return preview(value.tasks, value.total === undefined ? `${value.tasks.length} tasks` : `${value.tasks.length} of ${value.total} tasks`, theme, labels);
-    const label = value.title ?? value.name ?? value.brief ?? value.text ?? value.query ?? (Array.isArray(value.recipients) ? undefined : value.id === undefined ? undefined : memberLabel(value.id, labels));
+    const label = value.title ?? value.name ?? value.brief ?? value.summary ?? value.text ?? value.query ?? (Array.isArray(value.recipients) ? undefined : value.id === undefined ? undefined : memberLabel(value.id, labels));
     const status = value.status === undefined ? "" : inline(value.status);
     const color = status === "done" ? "success"
       : status === "interrupted" ? "error"
@@ -75,7 +75,7 @@ function toolSummary(data: unknown, theme: Theme, labels: Readonly<Record<string
     }
     return parts.filter(Boolean).join(" ");
   }
-  return data === undefined || data === null ? "" : inline(data);
+  return data === undefined || data === null ? "" : memberLabel(data, labels);
 }
 
 export function teamToolRenderers(name: string, getLabels: MemberLabels = defaultLabels): ToolRenderers {
@@ -97,12 +97,12 @@ export function teamToolRenderers(name: string, getLabels: MemberLabels = defaul
         try { data = JSON.parse(text); } catch { data = text; }
       }
       const labels = getLabels();
-      const outcome = context.isError ? `error · ${inline(text)}` : toolSummary(data, theme, labels) || "done";
+      const waiting = action === "wait" && Array.isArray(data) && data.length === 0;
+      const outcome = context.isError ? `error · ${inline(text)}` : waiting ? "turn ended; the next post wakes this session" : toolSummary(data, theme, labels) || "done";
       const request = toolSummary(fields, theme, labels);
       const heading = `${theme.fg(context.isError ? "error" : "success", "●")} ${theme.fg("toolTitle", name)} · ${inline(action ?? "...")} → ${outcome}${request && !outcome.includes(request) ? ` · ${request}` : ""}`;
-      const requestJSON = cleanText(JSON.stringify(context.args, null, 2));
       const responseJSON = cleanText(result.details === undefined ? text : JSON.stringify(result.details, null, 2));
-      const hiddenLines = requestJSON.split("\n").length + responseJSON.split("\n").length + 2;
+      const hiddenLines = responseJSON.split("\n").length;
       const hint = theme.fg("muted", options.expanded ? " (" : ` … +${hiddenLines} lines (`)
         + keyHint("app.tools.expand", options.expanded ? "to collapse" : "to expand") + theme.fg("muted", ")");
       const row = new Container();
@@ -117,9 +117,6 @@ export function teamToolRenderers(name: string, getLabels: MemberLabels = defaul
         },
       });
       if (options.expanded) {
-        row.addChild(new Text(theme.fg("muted", "Request"), context.outputPad, 0));
-        row.addChild(new Text(requestJSON, context.outputPad, 0));
-        row.addChild(new Text(theme.fg("muted", "Response"), context.outputPad, 0));
         row.addChild(new Text(responseJSON, context.outputPad, 0));
       }
       return row;
@@ -129,12 +126,15 @@ export function teamToolRenderers(name: string, getLabels: MemberLabels = defaul
 
 export function teamMessageRenderer(getLabels: MemberLabels = defaultLabels): MessageRenderer {
   return (message, { expanded }, theme) => {
-    const details = message.details as { through?: number; messages?: { from: string; text: string; recipients: string[] }[] } | undefined;
-    const recent = details?.messages?.at(-1);
+    const details = message.details as { through?: number; messages?: { from: string; summary: string; recipients: string[]; task?: string; kind?: string }[] } | undefined;
+    const posts = details?.messages ?? [], recent = posts.at(-1);
+    const more = posts.length > 1 ? ` (+${posts.length - 1} more)` : "";
     const labels = getLabels();
     const name = (id: string) => memberLabel(id, labels);
-    const preview = recent ? `${name(recent.from)} → ${recent.recipients.map(name).join(", ")} · ${recent.text.split("\n")[0]}` : `Updates through ${details?.through ?? "unknown"}`;
-    return entry("Team message", details ?? { content: message.content }, expanded, theme, false, preview);
+    // Lead with what happened: "count-a completed #1 Count lines · 37 lines", or "count-a → Main · #1 … · question".
+    const what = recent && (recent.kind === "outcome" && recent.task ? `${name(recent.from)} completed ${name(recent.task)}` : `${name(recent.from)} → ${recent.recipients.map(name).join(", ")}${recent.task ? ` · ${name(recent.task)}` : ""}`);
+    const preview = recent ? `${what} · ${recent.summary.split("\n")[0]}${more}` : `Updates through ${details?.through ?? "unknown"}`;
+    return entry("ac-teams", details ?? { content: message.content }, expanded, theme, false, preview);
   };
 }
 

package/src/resources.ts

@@ -3,8 +3,8 @@ import { readFileSync } from "node:fs";
 export interface HostResources {
   scope: "host";
   memory: { totalBytes: number; availableBytes: number; swapUsedBytes: number } | null;
-  /** Percentage of wall time stalled on memory over the last ten seconds (Linux PSI). */
-  memoryPressure: { someAvg10: number; fullAvg10: number } | null;
+  /** Linux PSI percentages: partial ten-second pressure and full ten-/sixty-second pressure. */
+  memoryPressure: { someAvg10: number; fullAvg10: number; fullAvg60: number } | null;
   warnings: string[];
 }
 
@@ -22,19 +22,19 @@ export function hostResources(read: (path: string) => string = path => readFileS
       const swapTotal = bytes("SwapTotal"), swapFree = bytes("SwapFree");
       if ([totalBytes, availableBytes, swapTotal, swapFree].every(Number.isSafeInteger) && totalBytes > 0 && availableBytes <= totalBytes && swapFree <= swapTotal) {
         result.memory = { totalBytes, availableBytes, swapUsedBytes: swapTotal - swapFree };
-        if (availableBytes < totalBytes * 0.1) result.warnings.push("Host available memory is below 10%. Sequence work; stop unneeded idle members and resume their saved sessions later.");
+        if (availableBytes < totalBytes * 0.1) result.warnings.push("Host available memory is below 10%. This is low headroom, not a per-member capacity estimate.");
       }
     } catch { /* Missing or unreadable metrics remain explicitly unavailable. */ }
     try {
       const text = read("/proc/pressure/memory");
-      const avg = (kind: string) => {
-        const match = text.match(new RegExp(`^${kind} avg10=(\\d+(?:\\.\\d+)?) `, "m"));
+      const avg = (kind: string, window: 10 | 60) => {
+        const match = text.match(new RegExp(`^${kind} .*?\\bavg${window}=(\\d+(?:\\.\\d+)?) `, "m"));
         return match ? Number(match[1]) : NaN;
       };
-      const someAvg10 = avg("some"), fullAvg10 = avg("full");
-      if ([someAvg10, fullAvg10].every(value => Number.isFinite(value) && value >= 0 && value <= 100) && fullAvg10 <= someAvg10) {
-        result.memoryPressure = { someAvg10, fullAvg10 };
-        if (someAvg10 > 0) result.warnings.push(`Host tasks stalled on memory for ${someAvg10}% of the last ten seconds. Prefer sequential work over more teammates.`);
+      const someAvg10 = avg("some", 10), fullAvg10 = avg("full", 10), fullAvg60 = avg("full", 60);
+      if ([someAvg10, fullAvg10, fullAvg60].every(value => Number.isFinite(value) && value >= 0 && value <= 100) && fullAvg10 <= someAvg10) {
+        result.memoryPressure = { someAvg10, fullAvg10, fullAvg60 };
+        if (fullAvg60 >= 5 || fullAvg10 >= 10) result.warnings.push(`Significant memory contention detected (full avg10: ${fullAvg10}%, full avg60: ${fullAvg60}%). Consider reducing concurrency if progress is slowing.`);
       }
     } catch { /* PSI is optional on older kernels. */ }
   }

package/src/schemas.ts

@@ -13,6 +13,7 @@ export const AgentSchema = Type.Object({
   worktree: Type.Optional(Type.Boolean()), base: Type.Optional(id), target: Type.Optional(id),
   limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
   depth: Type.Optional(Type.Integer({ minimum: 0, maximum: 10 })),
+  task: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Launch only: an existing to-do task the new member owns, with you as its delegator. Its activity reaches you; include its goal in the brief." })),
   access: Type.Optional(Type.Object({
     read: Type.Optional(Type.Array(Type.String({ minLength: 1, maxLength: 4096 }), { maxItems: 32 })),
     write: Type.Optional(Type.Array(Type.String({ minLength: 1, maxLength: 4096 }), { maxItems: 32 })),
@@ -32,12 +33,19 @@ export const TaskSchema = Type.Object({
   offset: Type.Optional(Type.Integer({ minimum: 0 })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
   action: Type.Union(["create", "list", "read", "edit", "claim", "start", "release", "complete", "reopen"].map(v => Type.Literal(v))),
   id: Type.Optional(id), ...taskFields,
+  summary: Type.Optional(Type.String({ minLength: 1, maxLength: 16000, description: "Complete: the outcome, published atomically with done: what was done, how it was checked, and caveats. Start with the result itself (e.g. 37 lines); the first line is the one people see. Complete enough that the delegator can act without reading detail." })),
+  detail: Type.Optional(Type.String({ minLength: 1, maxLength: 16000, description: "Complete: optional supporting detail, read on demand." })),
   tasks: Type.Optional(Type.Array(Type.Object({ ...taskFields, title: Type.String({ minLength: 1, maxLength: 500 }) }, { additionalProperties: false }), { minItems: 1, maxItems: 100, description: "Create several tasks atomically. Use instead of top-level task fields. Dependencies must refer to existing task IDs, not items in this batch." })),
 }, { additionalProperties: false });
 export const MessageSchema = Type.Object({
-  action: Type.Union(["send", "history", "search"].map(v => Type.Literal(v))),
-  recipients: Type.Optional(Type.Array(id, { minItems: 1, maxItems: 100, uniqueItems: true, description: "Exact teammate names or member IDs. Each must resolve to a different live member. Omit to notify all other live members." })),
-  text: Type.Optional(text), query: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+  action: Type.Union(["send", "history", "search", "wait"].map(v => Type.Literal(v))),
+  tasks: Type.Optional(Type.Array(id, { maxItems: 100, uniqueItems: true, description: "Wait: also wake on posts linked to these tasks, e.g. ones you delegated." })),
+  recipients: Type.Optional(Type.Array(id, { minItems: 1, maxItems: 100, uniqueItems: true, description: "Exact teammate names or member IDs." })),
+  summary: Type.Optional(Type.String({ minLength: 1, maxLength: 16000, description: "Send: delivered directly to recipients. Start with the point (the first line is the one people see) and what it changes; complete enough to act on." })),
+  detail: Type.Optional(Type.String({ minLength: 1, maxLength: 16000, description: "Send: optional supporting detail, read only when needed." })),
+  task: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Send: link an existing task; its owner and delegator receive the post." })),
+  replyTo: Type.Optional(Type.String({ minLength: 1, maxLength: 128, description: "Send: the post ID this answers; its author receives the reply and it stays on that post's task." })),
+  query: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
   after: Type.Optional(Type.Integer({ minimum: 0 })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
 }, { additionalProperties: false });
 const UserActionSchema = Type.Object({
@@ -67,6 +75,7 @@ export function validate(operation: string, value: unknown): void {
     const args = value as { action: string; name?: string };
     if (args.action === "launch" && !args.name) throw new Error("A descriptive teammate name is required on launch");
     if (args.action !== "launch" && args.name !== undefined) throw new Error("A teammate name can only be set on launch");
+    if (args.action !== "launch" && (value as { task?: unknown }).task !== undefined) throw new Error("A task can only be assigned on launch");
     if (args.action !== "launch" && (value as { access?: unknown }).access !== undefined) throw new Error("Access can only be set on launch; resume keeps the member's access");
   }
 }