@tmustier/pi-agent-teams 0.1.2 → 0.2.0

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  typecheck-and-smoke:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20.x"
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Typecheck (strict)
+        run: npm run typecheck
+
+      - name: Smoke test
+        run: npm run smoke-test
+
+      - name: Package (dry run)
+        run: npm pack --dry-run

package/README.md

@@ -20,6 +20,17 @@ Additional Pi-specific capabilities:
 - **Git worktrees** — optionally give each teammate its own worktree so they work on isolated branches without conflicting edits.
 - **Session branching** — clone the leader's conversation context into a teammate so it starts with full awareness of the work so far, instead of from scratch.
 
+## UI style
+
+The extension supports two UI styles:
+
+- **normal** (default): "Team leader" + "Teammate <name>"
+- **soviet**: "Chairman" + "Comrade <name>" (in soviet mode, the system decides names for you)
+
+Configure via:
+- env: `PI_TEAMS_STYLE=normal|soviet`
+- command: `/team style normal` or `/team style soviet`
+
 ## Install
 
 **Option A — install from npm:**
@@ -46,9 +57,16 @@ Verify with `/team id` — it should print the current team info.
 
 ## Quick start
 
+The fastest way to get going is `/swarm`:
+
+```
+/swarm build the auth module               # agent spawns a team and coordinates the work
+/swarm                                     # agent asks you what to do, then swarms on it
 ```
-# In a Pi session with the extension loaded:
 
+Or drive it manually:
+
+```
 /team spawn alice                          # spawn a teammate (fresh session, shared workspace)
 /team spawn bob branch worktree            # spawn with leader context + isolated worktree
 
@@ -58,6 +76,8 @@ Verify with `/team id` — it should print the current team info.
 /team dm alice Check the edge cases too    # direct message
 /team broadcast Wrapping up soon           # message everyone
 
+/tw                                        # open the interactive widget panel
+
 /team shutdown alice                       # graceful shutdown (handshake)
 /team cleanup                              # remove team artifacts when done
 ```
@@ -79,14 +99,23 @@ Or let the model drive it with the delegate tool:
 
 ## Commands
 
-All commands live under `/team`.
+### Shortcuts
+
+| Command | Description |
+| --- | --- |
+| `/swarm [task]` | Tell the agent to spawn a team and work on a task |
+| `/tw` | Open the interactive widget panel |
+
+### Team management
 
-### Teammates
+All management commands live under `/team`.
 
 | Command | Description |
 | --- | --- |
 | `/team spawn <name> [fresh\|branch] [shared\|worktree]` | Start a teammate |
 | `/team list` | List teammates and their status |
+| `/team panel` | Interactive widget panel (same as `/tw`) |
+| `/team style <normal\|soviet>` | Set UI style (normal/soviet) |
 | `/team send <name> <msg>` | Send a prompt over RPC |
 | `/team steer <name> <msg>` | Redirect an in-flight run |
 | `/team dm <name> <msg>` | Send a mailbox message |
@@ -97,7 +126,7 @@ All commands live under `/team`.
 | `/team kill <name>` | Force-terminate |
 | `/team cleanup [--force]` | Delete team artifacts |
 | `/team id` | Print team/task-list IDs and paths |
-| `/team env <name>` | Print env vars to start a manual worker |
+| `/team env <name>` | Print env vars to start a manual teammate |
 
 ### Tasks
 
@@ -119,6 +148,7 @@ All commands live under `/team`.
 | --- | --- | --- |
 | `PI_TEAMS_ROOT_DIR` | Storage root (absolute or relative to `~/.pi/agent`) | `~/.pi/agent/teams` |
 | `PI_TEAMS_DEFAULT_AUTO_CLAIM` | Whether spawned teammates auto-claim tasks | `1` (on) |
+| `PI_TEAMS_STYLE` | UI style (`normal` or `soviet`) | `normal` |
 
 ## Storage layout
 
@@ -150,7 +180,7 @@ Filesystem-level test of the task store, mailbox, and team config.
 node scripts/e2e-rpc-test.mjs
 ```
 
-Starts a leader in RPC mode, spawns a worker, runs a shutdown handshake, verifies cleanup. Sets `PI_TEAMS_ROOT_DIR` to a temp directory so nothing touches `~/.pi/agent/teams`.
+Starts a leader in RPC mode, spawns a teammate, runs a shutdown handshake, verifies cleanup. Sets `PI_TEAMS_ROOT_DIR` to a temp directory so nothing touches `~/.pi/agent/teams`.
 
 ### tmux dogfooding
 
@@ -159,7 +189,7 @@ Starts a leader in RPC mode, spawns a worker, runs a shutdown handshake, verifie
 tmux attach -t pi-teams
 ```
 
-Starts a leader + one tmux window per worker for interactive testing.
+Starts a leader + one tmux window per teammate for interactive testing.
 
 ## License
 

package/docs/claude-parity.md

@@ -12,12 +12,14 @@ This document tracks **feature parity gaps** between:
 
 - `pi-agent-teams` (Pi extension)
 
+> Terminology note: the extension supports `PI_TEAMS_STYLE=normal|soviet`. These docs often say "comrade" for parity with Claude Teams, but in **normal** style you’ll see "teammate" and "team leader" in the UI.
+
 ## Scope / philosophy
 
 - Target the **same coordination primitives** as Claude Teams:
   - shared task list
   - mailbox messaging
-  - long-lived teammates
+  - long-lived comrades
 - Prefer **inspectable, local-first artifacts** (files + lock files).
 - Avoid guidance that bypasses Claude feature gating; we only document behavior.
 - Accept that some Claude UX (terminal keybindings + split-pane integration) may not be achievable in Pi without deeper TUI/terminal integration.
@@ -31,16 +33,16 @@ Legend: ✅ implemented • 🟡 partial • ❌ missing
 | Enablement | `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` + settings | N/A | Pi extension is always available when installed/loaded. | — |
 | Team config | `~/.claude/teams/<team>/config.json` w/ members | ✅ | Implemented via `extensions/teams/team-config.ts` (stored under `~/.pi/agent/teams/...` or `PI_TEAMS_ROOT_DIR`). | P0 |
 | Task list (shared) | `~/.claude/tasks/<taskListId>/` + states + deps | ✅ | File-per-task + deps (`blockedBy`/`blocks`); `/team task dep add|rm|ls`; self-claim skips blocked tasks. | P0 |
-| Self-claim | Teammates can self-claim next unassigned, unblocked task; file locking | ✅ | Implemented: `claimNextAvailableTask()` + locks; enabled by default (`PI_TEAMS_DEFAULT_AUTO_CLAIM=1`). | P0 |
-| Explicit assign | Lead assigns task to teammate | ✅ | `/team task assign` sets owner + pings via mailbox. | P0 |
-| “Message” vs “broadcast” | Send to one teammate or all teammates | ✅ | `/team dm` + `/team broadcast` use mailbox; `/team send` uses RPC. Broadcast recipients = team config workers + RPC-spawned map + active task owners; manual tmux workers self-register into `config.json` on startup. | P0 |
-| Teammate↔teammate messaging | Teammates can message each other directly | ✅ | Workers register `team_message` LLM-callable tool; sends via mailbox + CC's leader with `peer_dm_sent` notification. | P1 |
-| Display modes | In-process selection (Shift+Up/Down); split panes (tmux/iTerm) | ❌ | Pi has a widget + commands, but no terminal-level teammate navigation/panes. | P2 |
+| Self-claim | Comrades can self-claim next unassigned, unblocked task; file locking | ✅ | Implemented: `claimNextAvailableTask()` + locks; enabled by default (`PI_TEAMS_DEFAULT_AUTO_CLAIM=1`). | P0 |
+| Explicit assign | Lead assigns task to comrade | ✅ | `/team task assign` sets owner + pings via mailbox. | P0 |
+| “Message” vs “broadcast” | Send to one comrade or all comrades | ✅ | `/team dm` + `/team broadcast` use mailbox; `/team send` uses RPC. Broadcast recipients = team config workers + RPC-spawned map + active task owners; manual tmux workers self-register into `config.json` on startup. | P0 |
+| Comrade↔comrade messaging | Comrades can message each other directly | ✅ | Workers register `team_message` LLM-callable tool; sends via mailbox + CC's leader with `peer_dm_sent` notification. | P1 |
+| Display modes | In-process selection (Shift+Up/Down); split panes (tmux/iTerm) | ❌ | Pi has a widget + commands, but no terminal-level comrade navigation/panes. | P2 |
 | Delegate mode | Lead restricted to coordination-only tools | ✅ | `/team delegate [on|off]` toggles; `pi.on("tool_call")` blocks `bash/edit/write`; `PI_TEAMS_DELEGATE_MODE=1` env. Widget shows `[delegate]`. | P1 |
-| Plan approval | Teammate can be "plan required" and needs lead approval to implement | ✅ | `/team spawn <name> plan` sets `PI_TEAMS_PLAN_REQUIRED=1`; worker restricted to read-only tools; submits plan via `plan_approval_request`; `/team plan approve|reject <name>`. | P1 |
-| Shutdown handshake | Lead requests shutdown; teammate can approve/reject | ✅ | Full protocol: `shutdown_request` → `shutdown_approved` or `shutdown_rejected` (when worker is busy). `/team shutdown <name>` (graceful) + `/team kill` (force). | P1 |
-| Cleanup team | “Clean up the team” removes shared resources after teammates stopped | ✅ | `/team cleanup [--force]` deletes only `<teamsRoot>/<teamId>` after safety checks. | P1 |
-| Hooks / quality gates | `TeammateIdle`, `TaskCompleted` hooks | ❌ | Add optional hook runner in leader on idle/task-complete events (script execution + exit-code gating). | P2 |
+| Plan approval | Comrade can be "plan required" and needs lead approval to implement | ✅ | `/team spawn <name> plan` sets `PI_TEAMS_PLAN_REQUIRED=1`; worker restricted to read-only tools; submits plan via `plan_approval_request`; `/team plan approve|reject <name>`. | P1 |
+| Shutdown handshake | Lead requests shutdown; comrade can approve/reject | ✅ | Full protocol: `shutdown_request` → `shutdown_approved` or `shutdown_rejected` (when worker is busy). `/team shutdown <name>` (graceful) + `/team kill` (force). | P1 |
+| Cleanup team | “Clean up the team” removes shared resources after comrades stopped | ✅ | `/team cleanup [--force]` deletes only `<teamsRoot>/<teamId>` after safety checks. | P1 |
+| Hooks / quality gates | `ComradeIdle`, `TaskCompleted` hooks | ❌ | Add optional hook runner in leader on idle/task-complete events (script execution + exit-code gating). | P2 |
 | Task list UX | Ctrl+T toggle; show all/clear tasks by asking | 🟡 | Widget + `/team task list` show blocked/deps; `/team task show <id>`; `/team task clear [completed|all]`. No Ctrl+T toggle yet. | P0 |
 | Shared task list across sessions | `CLAUDE_CODE_TASK_LIST_ID=...` | ✅ | `PI_TEAMS_TASK_LIST_ID` env on leader + worker; `/team task use <taskListId>` switches the leader (and newly spawned workers). Existing workers need a restart to pick up changes. Persisted in config.json. | P1 |
 
@@ -80,7 +82,7 @@ Legend: ✅ implemented • 🟡 partial • ❌ missing
 
 7) **Cleanup** ✅
    - `/team cleanup [--force]` deletes only `<teamsRoot>/<teamId>` after safety checks.
-   - Refuses if RPC teammates are running or there are `in_progress` tasks unless `--force`.
+   - Refuses if RPC comrades are running or there are `in_progress` tasks unless `--force`.
 
 8) **Peer-to-peer messaging** ✅
    - Workers register `team_message` LLM-callable tool (recipient + message params)
@@ -93,10 +95,10 @@ Legend: ✅ implemented • 🟡 partial • ❌ missing
 
 ### P2: UX + “product-level” parity
 
-10) **Better teammate interaction UX**
+10) **Better comrade interaction UX**
    - Explore whether Pi’s TUI API can support:
-     - selecting a teammate from the widget
-     - “entering” a teammate transcript view
+     - selecting a comrade from the widget
+     - “entering” a comrade transcript view
    - (Optional) tmux integration for split panes.
 
 11) **Hooks / quality gates**

package/docs/field-notes-teams-setup.md

@@ -4,12 +4,14 @@ Date: 2026-02-07
 
 Goal: dogfood the Teams extension to implement its own roadmap (Claude parity), and capture anything that surprised/confused us while setting it up.
 
+> Terminology note: the extension supports `PI_TEAMS_STYLE=normal|soviet`. In normal style the UI says "teammate" and "team leader"; in soviet style it says "comrade" and "chairman".
+
 ## Test run: test1
 
 Decisions: tmux session `pi-teams-test1`; `PI_TEAMS_ROOT_DIR=~/projects/pi-agent-teams/test1`; `teamId=0baaa0e6-8020-4d9a-bf33-c1a65f99a2f7`; workers started manually in tmux (not `/team spawn`).
 
 First impressions:
-- Manual tmux workers are usable. Initially the leader showed “(no teammates)” because it only tracked RPC-spawned workers; now manual workers **upsert themselves into `config.json` on startup**, and the leader widget renders online workers from team config.
+- Manual tmux workers are usable. Initially the leader showed “(no comrades)” because it only tracked RPC-spawned workers; now manual workers **upsert themselves into `config.json` on startup**, and the leader widget renders online workers from team config.
 - Pinning `PI_TEAMS_ROOT_DIR` made reruns/id discovery predictable (no “find the new folder” step).
 - tmux workflow feels close to Claude-style split panes; bootstrap ergonomics still need smoothing.
 - Surprise: `/team spawn <name> branch` failed once with `Entry <id> not found` (branch-from leaf missing on disk); `/team spawn <name> fresh` worked.
@@ -73,9 +75,9 @@ First impressions:
 
 - **tmux vs `/team spawn`**: `/team spawn` uses `pi --mode rpc` subprocesses.
   - Pros: simple, managed lifecycle.
-  - Cons: you don’t see a full interactive teammate UI like Claude’s split-pane mode.
+  - Cons: you don’t see a full interactive comrade UI like Claude’s split-pane mode.
   - We manually started workers in separate tmux windows (setting `PI_TEAMS_WORKER=1`, `PI_TEAMS_TEAM_ID=...`, etc). This now shows up in the leader widget because workers upsert themselves into `config.json`, and the leader renders online workers from team config.
-  - Update: leader now renders teammates from `team config` and also auto-adds unknown senders on idle notifications (so manual tmux workers feel first-class).
+  - Update: leader now renders comrades from `team config` and also auto-adds unknown senders on idle notifications (so manual tmux workers feel first-class).
   - Improvement idea: optional spawn mode that starts a worker in a new tmux pane/window.
 
 - **Two messaging paths** (`/team send` vs `/team dm`):
@@ -84,7 +86,7 @@ First impressions:
   - Improvement idea: clearer naming and/or a single “message” command with a mode flag.
 
 - **Runaway tasks / timeboxing**: a vague task prompt can turn into a long “research spiral”.
-  - In manual-tmux mode, there isn’t a great way (yet) for the leader to *steer* an in-flight run (unlike `/team steer` for RPC-spawned teammates).
+  - In manual-tmux mode, there isn’t a great way (yet) for the leader to *steer* an in-flight run (unlike `/team steer` for RPC-spawned comrades).
   - Improvement idea: add a mailbox-level “steer” protocol message that workers can treat as an in-flight follow-up if they’re currently running.
 
 - **Failure semantics are underspecified**: tool failures show up in the worker UI, but our task store currently only supports `pending|in_progress|completed`.

package/docs/smoke-test-plan.md

@@ -0,0 +1,130 @@
+# pi-agent-teams — Runtime Smoke Test Plan
+
+## Prerequisites
+
+- `pi` CLI installed (`pi --version` → `0.52.x+`)
+- `node_modules/` present (run `npm install` or symlink from main repo)
+- `npx tsx` available for running `.mts` test scripts
+
+## 1. Automated Unit Smoke Test (no interactive session)
+
+Exercises all core primitives directly via `tsx`:
+
+```bash
+npx tsx scripts/smoke-test.mts
+```
+
+**What it tests** (60 assertions):
+
+| Module           | Coverage                                                        |
+|------------------|-----------------------------------------------------------------|
+| `names.ts`       | `sanitizeName` character replacement, edge cases                |
+| `fs-lock.ts`     | `withLock` returns value, cleans up lock file                   |
+| `mailbox.ts`     | `writeToMailbox`, `popUnreadMessages`, read-once semantics      |
+| `task-store.ts`  | CRUD, `startAssignedTask`, `completeTask`, `claimNextAvailable`,|
+|                  | `unassignTasksForAgent`, dependencies, `clearTasks`             |
+| `team-config.ts` | `ensureTeamConfig` (idempotent), `upsertMember`, `setMemberStatus`, `loadTeamConfig` |
+| `protocol.ts`    | All 11 message parsers (valid + invalid JSON + wrong type)      |
+| Pi CLI           | `pi --version` executes                                        |
+
+**Expected result:** `PASSED: 60  FAILED: 0`
+
+## 2. Extension Loading Test
+
+Verify Pi can load the extension entry point without crashing:
+
+```bash
+pi --no-extensions -e extensions/teams/index.ts --help
+```
+
+**Expected:** exits 0, shows Pi help output (no TypeScript/import errors).
+
+## 3. Interactive Smoke Test (manual)
+
+### 3a. Launch Pi with the extension
+
+```bash
+# From the repo root:
+pi --no-extensions -e extensions/teams/index.ts
+```
+
+Or, if the extension is symlinked into `~/.pi/agent/extensions/pi-agent-teams`:
+
+```bash
+pi   # auto-loads from extensions dir
+```
+
+### 3b. Check extension is active
+
+```
+/team help
+```
+
+**Expected:** shows usage lines for `/team spawn`, `/team task`, etc.
+
+### 3c. Spawn a teammate ("comrade" in soviet style)
+
+```
+/team spawn agent1 fresh shared
+```
+
+**Expected:** notification "Spawned agent1" or similar, widget shows `Teammate agent1: idle` (or `Comrade agent1: idle` in soviet style).
+
+### 3d. Create and assign a task
+
+```
+/team task add agent1: Say hello
+/team task list
+```
+
+**Expected:** task #1 created, assigned to agent1, status `pending` → `in_progress`.
+
+### 3e. Verify mailbox delivery
+
+```
+/team dm agent1 ping from lead
+```
+
+**Expected:** "DM queued for agent1" notification.
+
+### 3f. Delegate via tool
+
+Ask the model:
+> "Delegate a task to agent1: write a haiku about coding"
+
+**Expected:** the `teams` tool is invoked, task created and assigned.
+
+### 3g. Shutdown
+
+```
+/team shutdown agent1
+/team kill agent1
+```
+
+**Expected:** agent1 goes offline, widget updates.
+
+## 4. Worker-side Smoke (verifying child process)
+
+To test the worker role directly:
+
+```bash
+PI_TEAMS_WORKER=1 \
+PI_TEAMS_TEAM_ID=test-team \
+PI_TEAMS_AGENT_NAME=agent1 \
+PI_TEAMS_LEAD_NAME=team-lead \
+PI_TEAMS_STYLE=normal \
+pi --no-extensions -e extensions/teams/index.ts --mode rpc
+```
+
+**Expected:** process starts in RPC mode, registers `team_message` tool, polls mailbox.
+
+## 5. Checklist Summary
+
+| # | Test                          | Method     | Status |
+|---|-------------------------------|------------|--------|
+| 1 | Unit primitives (60 asserts)  | Automated  | ✅     |
+| 2 | Extension loading             | CLI        | ✅     |
+| 3 | Interactive spawn/task/dm     | Manual     | 📋     |
+| 4 | Worker-side RPC               | Manual     | 📋     |
+
+✅ = verified in this run, 📋 = documented for manual execution.

package/extensions/teams/activity-tracker.ts

@@ -0,0 +1,234 @@
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+
+// ── Transcript types ──
+
+export type TranscriptEntry =
+	| { kind: "text"; text: string; timestamp: number }
+	| { kind: "tool_start"; toolName: string; timestamp: number }
+	| { kind: "tool_end"; toolName: string; durationMs: number; timestamp: number }
+	| { kind: "turn_end"; turnNumber: number; tokens: number; timestamp: number };
+
+const MAX_TRANSCRIPT = 200;
+
+export class TranscriptLog {
+	private entries: TranscriptEntry[] = [];
+
+	push(entry: TranscriptEntry): void {
+		this.entries.push(entry);
+		if (this.entries.length > MAX_TRANSCRIPT) {
+			this.entries.splice(0, this.entries.length - MAX_TRANSCRIPT);
+		}
+	}
+
+	getEntries(): readonly TranscriptEntry[] {
+		return this.entries;
+	}
+
+	get length(): number {
+		return this.entries.length;
+	}
+
+	reset(): void {
+		this.entries = [];
+	}
+}
+
+export class TranscriptTracker {
+	private logs = new Map<string, TranscriptLog>();
+	private toolStarts = new Map<string, Map<string, number>>(); // name -> toolCallId -> startTimestamp
+	private pendingText = new Map<string, string>(); // name -> accumulated text
+	private turnCounts = new Map<string, number>();
+	private lastTokens = new Map<string, number>(); // name -> tokens from last message_end
+
+	handleEvent(name: string, ev: AgentEvent): void {
+		const log = this.getOrCreate(name);
+		const now = Date.now();
+
+		if (ev.type === "message_update") {
+			const ame = ev.assistantMessageEvent;
+			if (ame.type === "text_delta") {
+				const cur = this.pendingText.get(name) ?? "";
+				this.pendingText.set(name, cur + ame.delta);
+				// Flush complete lines
+				this.flushText(name, log, now, false);
+			}
+			return;
+		}
+
+		if (ev.type === "tool_execution_start") {
+			// Flush any pending text before a tool starts
+			this.flushText(name, log, now, true);
+			const starts = this.toolStarts.get(name) ?? new Map<string, number>();
+			starts.set(ev.toolCallId, now);
+			this.toolStarts.set(name, starts);
+			log.push({ kind: "tool_start", toolName: ev.toolName, timestamp: now });
+			return;
+		}
+
+		if (ev.type === "tool_execution_end") {
+			const starts = this.toolStarts.get(name);
+			const startTs = starts?.get(ev.toolCallId);
+			const durationMs = startTs != null ? now - startTs : 0;
+			starts?.delete(ev.toolCallId);
+			log.push({ kind: "tool_end", toolName: ev.toolName, durationMs, timestamp: now });
+			return;
+		}
+
+		if (ev.type === "message_end") {
+			// Capture tokens for use in the turn_end entry
+			const msg: unknown = ev.message;
+			if (isRecord(msg)) {
+				const usage = msg.usage;
+				if (isRecord(usage) && typeof usage.totalTokens === "number") {
+					this.lastTokens.set(name, (this.lastTokens.get(name) ?? 0) + usage.totalTokens);
+				}
+			}
+			return;
+		}
+
+		if (ev.type === "agent_end") {
+			// Flush remaining text
+			this.flushText(name, log, now, true);
+			const turn = (this.turnCounts.get(name) ?? 0) + 1;
+			this.turnCounts.set(name, turn);
+			const tokens = this.lastTokens.get(name) ?? 0;
+			log.push({ kind: "turn_end", turnNumber: turn, tokens, timestamp: now });
+			this.lastTokens.set(name, 0);
+			return;
+		}
+	}
+
+	get(name: string): TranscriptLog {
+		return this.logs.get(name) ?? new TranscriptLog();
+	}
+
+	reset(name: string): void {
+		this.logs.delete(name);
+		this.toolStarts.delete(name);
+		this.pendingText.delete(name);
+		this.turnCounts.delete(name);
+		this.lastTokens.delete(name);
+	}
+
+	private getOrCreate(name: string): TranscriptLog {
+		const existing = this.logs.get(name);
+		if (existing) return existing;
+		const created = new TranscriptLog();
+		this.logs.set(name, created);
+		return created;
+	}
+
+	private flushText(name: string, log: TranscriptLog, timestamp: number, force: boolean): void {
+		const buf = this.pendingText.get(name);
+		if (!buf) return;
+
+		// Split into lines; keep the last incomplete line unless forced
+		const parts = buf.split("\n");
+		if (force) {
+			// Flush everything
+			for (const part of parts) {
+				const trimmed = part.trimEnd();
+				if (trimmed) log.push({ kind: "text", text: trimmed, timestamp });
+			}
+			this.pendingText.delete(name);
+		} else if (parts.length > 1) {
+			// Flush all complete lines, keep the last (potentially incomplete) part
+			for (let i = 0; i < parts.length - 1; i++) {
+				const part = parts[i];
+				if (part == null) continue;
+				const trimmed = part.trimEnd();
+				if (trimmed) log.push({ kind: "text", text: trimmed, timestamp });
+			}
+			this.pendingText.set(name, parts[parts.length - 1] ?? "");
+		}
+	}
+}
+
+// ── Activity types ──
+
+type TrackedEventType = "tool_execution_start" | "tool_execution_end" | "agent_end" | "message_end";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+	return typeof v === "object" && v !== null;
+}
+
+export interface TeammateActivity {
+	toolUseCount: number;
+	currentToolName: string | null;
+	lastToolName: string | null;
+	turnCount: number;
+	totalTokens: number;
+	recentEvents: Array<{ type: TrackedEventType; toolName?: string; timestamp: number }>;
+}
+
+const MAX_RECENT = 10;
+
+function emptyActivity(): TeammateActivity {
+	return {
+		toolUseCount: 0,
+		currentToolName: null,
+		lastToolName: null,
+		turnCount: 0,
+		totalTokens: 0,
+		recentEvents: [],
+	};
+}
+
+export class ActivityTracker {
+	private data = new Map<string, TeammateActivity>();
+
+	handleEvent(name: string, ev: AgentEvent): void {
+		const a = this.getOrCreate(name);
+		const now = Date.now();
+
+		if (ev.type === "tool_execution_start") {
+			a.currentToolName = ev.toolName;
+			a.recentEvents.push({ type: ev.type, toolName: ev.toolName, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "tool_execution_end") {
+			const toolName = a.currentToolName ?? ev.toolName;
+			a.toolUseCount++;
+			a.lastToolName = toolName;
+			a.currentToolName = null;
+			a.recentEvents.push({ type: ev.type, toolName, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "agent_end") {
+			a.turnCount++;
+			a.recentEvents.push({ type: ev.type, timestamp: now });
+			if (a.recentEvents.length > MAX_RECENT) a.recentEvents.shift();
+			return;
+		}
+
+		if (ev.type === "message_end") {
+			const msg: unknown = ev.message;
+			if (!isRecord(msg)) return;
+			const usage = msg.usage;
+			if (!isRecord(usage)) return;
+			const totalTokens = usage.totalTokens;
+			if (typeof totalTokens === "number") a.totalTokens += totalTokens;
+		}
+	}
+
+	get(name: string): TeammateActivity {
+		return this.data.get(name) ?? emptyActivity();
+	}
+
+	reset(name: string): void {
+		this.data.delete(name);
+	}
+
+	private getOrCreate(name: string): TeammateActivity {
+		const existing = this.data.get(name);
+		if (existing) return existing;
+
+		const created = emptyActivity();
+		this.data.set(name, created);
+		return created;
+	}
+}

package/extensions/teams/fs-lock.ts

@@ -4,6 +4,10 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
+function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
+	return typeof err === "object" && err !== null && "code" in err;
+}
+
 export interface LockOptions {
 	/** How long to wait to acquire the lock before failing. */
 	timeoutMs?: number;
@@ -18,10 +22,12 @@ export interface LockOptions {
 export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, opts: LockOptions = {}): Promise<T> {
 	const timeoutMs = opts.timeoutMs ?? 10_000;
 	const staleMs = opts.staleMs ?? 60_000;
-	const pollMs = opts.pollMs ?? 50;
+	const basePollMs = opts.pollMs ?? 50;
+	const maxPollMs = Math.max(basePollMs, 1_000);
 	const start = Date.now();
 
 	let fd: number | null = null;
+	let attempt = 0;
 
 	while (fd === null) {
 		try {
@@ -32,8 +38,8 @@ export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, op
 				label: opts.label,
 			};
 			fs.writeFileSync(fd, JSON.stringify(payload));
-		} catch (err: any) {
-			if (err?.code !== "EEXIST") throw err;
+		} catch (err: unknown) {
+			if (!isErrnoException(err) || err.code !== "EEXIST") throw err;
 
 			// Stale lock handling
 			try {
@@ -41,16 +47,26 @@ export async function withLock<T>(lockFilePath: string, fn: () => Promise<T>, op
 				const age = Date.now() - st.mtimeMs;
 				if (age > staleMs) {
 					fs.unlinkSync(lockFilePath);
+					attempt = 0;
 					continue;
 				}
 			} catch {
 				// ignore: stat/unlink failures fall through to wait
 			}
 
-			if (Date.now() - start > timeoutMs) {
+			const elapsedMs = Date.now() - start;
+			if (elapsedMs > timeoutMs) {
 				throw new Error(`Timeout acquiring lock: ${lockFilePath}`);
 			}
-			await sleep(pollMs);
+
+			attempt += 1;
+			const expBackoff = Math.min(maxPollMs, basePollMs * 2 ** Math.min(attempt, 6));
+			const jitterFactor = 0.5 + Math.random(); // [0.5, 1.5)
+			const jitteredBackoff = Math.min(maxPollMs, Math.round(expBackoff * jitterFactor));
+
+			const remainingMs = timeoutMs - elapsedMs;
+			const sleepMs = Math.max(1, Math.min(remainingMs, jitteredBackoff));
+			await sleep(sleepMs);
 		}
 	}