@tmustier/pi-agent-teams 0.4.0-beta.3 → 0.5.0

package/scripts/smoke-test.mts

@@ -31,9 +31,12 @@ import {
 } from "../extensions/teams/task-store.js";
 import { ensureTeamConfig, loadTeamConfig, upsertMember, setMemberStatus, updateTeamHooksPolicy } from "../extensions/teams/team-config.js";
 import { sanitizeName } from "../extensions/teams/names.js";
-import { isDeprecatedTeammateModelId } from "../extensions/teams/model-policy.js";
+import { formatProviderModel, isDeprecatedTeammateModelId, resolveTeammateModelSelection } from "../extensions/teams/model-policy.js";
+import { getMemberModel, getMemberThinking, shortModelLabel } from "../extensions/teams/teams-ui-shared.js";
 import { getTeamsNamingRules, getTeamsStrings } from "../extensions/teams/teams-style.js";
 import {
+	HOOK_CONTRACT_VERSION,
+	buildHookContextPayload,
 	getTeamsHookFailureAction,
 	getTeamsHookFollowupOwnerPolicy,
 	getTeamsHookMaxReopensPerTask,
@@ -42,6 +45,7 @@ import {
 	shouldCreateHookFollowupTask,
 	shouldReopenTaskOnHookFailure,
 } from "../extensions/teams/hooks.js";
+import { TranscriptTracker, type TranscriptEntry } from "../extensions/teams/activity-tracker.js";
 import { listDiscoveredTeams } from "../extensions/teams/team-discovery.js";
 import {
 	acquireTeamAttachClaim,
@@ -50,6 +54,7 @@ import {
 	releaseTeamAttachClaim,
 } from "../extensions/teams/team-attach-claim.js";
 import { getTeamHelpText } from "../extensions/teams/leader-team-command.js";
+import { isTeamDone, formatElapsed, lastMessageSummary } from "../extensions/teams/teams-ui-shared.js";
 import {
 	TEAM_MAILBOX_NS,
 	isIdleNotification,
@@ -64,6 +69,8 @@ import {
 	isPlanApprovedMessage,
 	isPlanRejectedMessage,
 } from "../extensions/teams/protocol.js";
+import { pollLeaderInbox } from "../extensions/teams/leader-inbox.js";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 
 // ── helpers ──────────────────────────────────────────────────────────
 let passed = 0;
@@ -117,6 +124,81 @@ assert(!isDeprecatedTeammateModelId("claude-sonnet-4-5"), "does not block sonnet
 assert(!isDeprecatedTeammateModelId("claude-sonnet-4.5"), "does not block sonnet-4.5");
 assert(!isDeprecatedTeammateModelId("gpt-5.1-codex-mini"), "keeps current models allowed");
 
+const modelResolvedExplicit = resolveTeammateModelSelection({
+	modelOverride: "openai-codex/gpt-5.1-codex-mini",
+	leaderProvider: "anthropic",
+	leaderModelId: "claude-sonnet-4-5",
+});
+assert(modelResolvedExplicit.ok, "resolveTeammateModelSelection accepts provider/model override");
+if (modelResolvedExplicit.ok) {
+	assertEq(modelResolvedExplicit.value.source, "override", "explicit override source");
+	assertEq(formatProviderModel(modelResolvedExplicit.value.provider, modelResolvedExplicit.value.modelId), "openai-codex/gpt-5.1-codex-mini", "explicit override keeps provider/model");
+}
+
+const modelResolvedModelOnly = resolveTeammateModelSelection({
+	modelOverride: "gpt-5.1-codex-mini",
+	leaderProvider: "openai-codex",
+	leaderModelId: "gpt-5.1-codex-mini",
+});
+assert(modelResolvedModelOnly.ok, "resolveTeammateModelSelection accepts model-only override");
+if (modelResolvedModelOnly.ok) {
+	assertEq(formatProviderModel(modelResolvedModelOnly.value.provider, modelResolvedModelOnly.value.modelId), "openai-codex/gpt-5.1-codex-mini", "model-only override inherits leader provider");
+}
+
+const modelResolvedInvalid = resolveTeammateModelSelection({ modelOverride: "openai-codex/" });
+assert(!modelResolvedInvalid.ok, "resolveTeammateModelSelection rejects invalid provider/model override");
+if (!modelResolvedInvalid.ok) {
+	assertEq(modelResolvedInvalid.reason, "invalid_override", "invalid override reason");
+}
+
+const modelResolvedDeprecated = resolveTeammateModelSelection({ modelOverride: "claude-sonnet-4" });
+assert(!modelResolvedDeprecated.ok, "resolveTeammateModelSelection rejects deprecated override");
+if (!modelResolvedDeprecated.ok) {
+	assertEq(modelResolvedDeprecated.reason, "deprecated_override", "deprecated override reason");
+}
+
+const modelResolvedDeprecatedLeader = resolveTeammateModelSelection({
+	leaderProvider: "anthropic",
+	leaderModelId: "claude-sonnet-4-20250514",
+});
+assert(modelResolvedDeprecatedLeader.ok, "resolveTeammateModelSelection handles deprecated leader model fallback");
+if (modelResolvedDeprecatedLeader.ok) {
+	assertEq(modelResolvedDeprecatedLeader.value.source, "default", "deprecated leader model is not inherited");
+	assertEq(formatProviderModel(modelResolvedDeprecatedLeader.value.provider, modelResolvedDeprecatedLeader.value.modelId), null, "deprecated leader fallback has no explicit model");
+}
+
+// ── 1c. UI shared helpers ────────────────────────────────────────────
+console.log("\n1c. teams-ui-shared helpers");
+{
+	// shortModelLabel
+	assertEq(shortModelLabel("anthropic/claude-sonnet-4-5-20250514"), "claude-sonnet-4-5", "shortModelLabel strips provider and date");
+	assertEq(shortModelLabel("openai-codex/gpt-5.1-codex-mini"), "gpt-5.1-codex-mini", "shortModelLabel strips provider, no date");
+	assertEq(shortModelLabel("claude-sonnet-4-5-20250514"), "claude-sonnet-4-5", "shortModelLabel strips date without provider");
+	assertEq(shortModelLabel("claude-opus-4-20250514-v2"), "claude-opus-4", "shortModelLabel strips date with variant suffix");
+	assertEq(shortModelLabel("gpt-5.1-codex-mini"), "gpt-5.1-codex-mini", "shortModelLabel keeps clean model id");
+
+	// getMemberModel
+	assertEq(getMemberModel(undefined), null, "getMemberModel returns null for undefined member");
+	assertEq(
+		getMemberModel({ name: "a", role: "worker", addedAt: "", status: "online" }),
+		null,
+		"getMemberModel returns null when no meta",
+	);
+	assertEq(
+		getMemberModel({ name: "a", role: "worker", addedAt: "", status: "online", meta: { model: "anthropic/claude-sonnet-4-5" } }),
+		"anthropic/claude-sonnet-4-5",
+		"getMemberModel extracts model from meta",
+	);
+
+	// getMemberThinking
+	assertEq(getMemberThinking(undefined), null, "getMemberThinking returns null for undefined member");
+	assertEq(
+		getMemberThinking({ name: "a", role: "worker", addedAt: "", status: "online", meta: { thinkingLevel: "high" } }),
+		"high",
+		"getMemberThinking extracts thinking from meta",
+	);
+}
+
 // ── 2. fs-lock ───────────────────────────────────────────────────────
 console.log("\n2. fs-lock.withLock");
 {
@@ -205,6 +287,31 @@ console.log("\n3. mailbox");
 	});
 	const msgs3 = await popUnreadMessages(teamDir, TEAM_MAILBOX_NS, "agent1");
 	assertEq(msgs3.length, 2, "pop returns 2 new unread messages");
+
+	// urgent messages
+	await writeToMailbox(teamDir, TEAM_MAILBOX_NS, "agent1", {
+		from: "peer",
+		text: "urgent interrupt",
+		timestamp: "2025-01-01T00:03:00Z",
+		urgent: true,
+	});
+	const msgs4 = await popUnreadMessages(teamDir, TEAM_MAILBOX_NS, "agent1");
+	assertEq(msgs4.length, 1, "pop returns 1 urgent message");
+	{
+		const m = msgs4.at(0);
+		assertEq(m?.urgent, true, "urgent flag preserved");
+		assertEq(m?.text, "urgent interrupt", "urgent message text correct");
+	}
+
+	// non-urgent messages default to no urgent field
+	await writeToMailbox(teamDir, TEAM_MAILBOX_NS, "agent1", {
+		from: "peer",
+		text: "normal msg",
+		timestamp: "2025-01-01T00:04:00Z",
+	});
+	const msgs5 = await popUnreadMessages(teamDir, TEAM_MAILBOX_NS, "agent1");
+	assertEq(msgs5.length, 1, "pop returns 1 normal message");
+	assertEq(msgs5.at(0)?.urgent, undefined, "non-urgent message has no urgent flag");
 }
 
 // ── 4. task-store ────────────────────────────────────────────────────
@@ -557,6 +664,7 @@ console.log("\n9. teams-hooks (quality gates)");
 
 	assert(res.ran === true, "runs on_task_completed hook");
 	assert(res.exitCode === 0, "hook exit code is 0");
+	assertEq(res.contractVersion, HOOK_CONTRACT_VERSION, "result includes contract version");
 	assert(fs.existsSync(outFile), "hook wrote output file");
 	const hookOutRaw = fs.readFileSync(outFile, "utf8").trim();
 	const hookOut = JSON.parse(hookOutRaw) as {
@@ -601,6 +709,67 @@ console.log("\n9. teams-hooks (quality gates)");
 	assertEq(getTeamsHookMaxReopensPerTask({}), 3, "hook max reopens default is 3");
 	assertEq(getTeamsHookMaxReopensPerTask({ PI_TEAMS_HOOKS_MAX_REOPENS_PER_TASK: "0" }), 0, "hook max reopens supports zero");
 
+	// contract version constant
+	assert(typeof HOOK_CONTRACT_VERSION === "number", "HOOK_CONTRACT_VERSION is a number");
+	assert(HOOK_CONTRACT_VERSION >= 1, "HOOK_CONTRACT_VERSION >= 1");
+	assert(Number.isInteger(HOOK_CONTRACT_VERSION), "HOOK_CONTRACT_VERSION is an integer");
+
+	// buildHookContextPayload produces correct shape
+	const payload = buildHookContextPayload({
+		event: "task_completed",
+		teamId: "test-team",
+		teamDir: "/tmp/test",
+		taskListId: "test-tl",
+		style: "normal",
+		memberName: "agent1",
+		timestamp: "2025-01-01T00:00:00Z",
+		completedTask: {
+			id: "42",
+			subject: "Test subject",
+			description: "Test desc",
+			owner: "agent1",
+			status: "completed",
+			blocks: ["43"],
+			blockedBy: [],
+			metadata: { result: "ok" },
+			createdAt: "2025-01-01T00:00:00Z",
+			updatedAt: "2025-01-01T00:00:00Z",
+		},
+	});
+	assertEq(payload.version, HOOK_CONTRACT_VERSION, "payload version matches constant");
+	assertEq(payload.event, "task_completed", "payload event correct");
+	assertEq(payload.team.id, "test-team", "payload team.id correct");
+	assertEq(payload.member, "agent1", "payload member correct");
+	assertEq(payload.task?.id, "42", "payload task.id correct");
+	assertEq(payload.task?.owner, "agent1", "payload task.owner correct");
+	assertEq(payload.task?.blocks.at(0), "43", "payload task.blocks preserved");
+
+	// null task for idle events
+	const idlePayload = buildHookContextPayload({
+		event: "idle",
+		teamId: "test-team",
+		teamDir: "/tmp/test",
+		taskListId: "test-tl",
+		style: "normal",
+	});
+	assertEq(idlePayload.task, null, "idle payload has null task");
+	assertEq(idlePayload.member, null, "idle payload has null member when not provided");
+
+	// disabled hooks still return contract version
+	const disabledRes = await runTeamsHook({
+		invocation: {
+			event: "idle",
+			teamId: "noop",
+			teamDir: "/tmp/noop",
+			taskListId: "noop",
+			style: "normal",
+		},
+		cwd: tmpRoot,
+		env: { PI_TEAMS_HOOKS_ENABLED: "0" },
+	});
+	assertEq(disabledRes.ran, false, "disabled hooks do not run");
+	assertEq(disabledRes.contractVersion, HOOK_CONTRACT_VERSION, "disabled hooks still report contract version");
+
 	// restore env
 	if (prevRoot === undefined) delete process.env.PI_TEAMS_ROOT_DIR;
 	else process.env.PI_TEAMS_ROOT_DIR = prevRoot;
@@ -672,20 +841,352 @@ console.log("\n10. team discovery + attach claims");
 	}
 }
 
-// ── 11. docs/help drift guard ────────────────────────────────────────
-console.log("\n11. docs/help drift guard");
+// ── 11. /team done (end-of-run cleanup) ──────────────────────────────
+console.log("\n11. /team done (end-of-run)");
+{
+	const doneDir = path.join(tmpRoot, "done-test");
+	const doneTeamId = "done-team";
+	const doneTeamDir = path.join(doneDir, doneTeamId);
+	const doneTlId = doneTeamId;
+
+	await ensureTeamConfig(doneTeamDir, { teamId: doneTeamId, taskListId: doneTlId, leadName: "team-lead", style: "normal" });
+	await upsertMember(doneTeamDir, { name: "alice", role: "worker", status: "online" });
+	await upsertMember(doneTeamDir, { name: "bob", role: "worker", status: "online" });
+
+	// Create tasks and mark all completed
+	const t1 = await createTask(doneTeamDir, doneTlId, { subject: "Task 1", description: "", owner: "alice" });
+	const t2 = await createTask(doneTeamDir, doneTlId, { subject: "Task 2", description: "", owner: "bob" });
+	await completeTask(doneTeamDir, doneTlId, t1.id, "alice");
+	await completeTask(doneTeamDir, doneTlId, t2.id, "bob");
+
+	const doneTasks = await listTasks(doneTeamDir, doneTlId);
+	const allCompleted = doneTasks.every((t) => t.status === "completed");
+	assert(allCompleted, "/team done precondition: all tasks completed");
+	assertEq(doneTasks.length, 2, "/team done: 2 tasks exist");
+
+	// Mark workers offline (simulating what /team done does)
+	await setMemberStatus(doneTeamDir, "alice", "offline", { meta: { stoppedReason: "team-done" } });
+	await setMemberStatus(doneTeamDir, "bob", "offline", { meta: { stoppedReason: "team-done" } });
+
+	const cfgAfter = await loadTeamConfig(doneTeamDir);
+	const onlineAfter = (cfgAfter?.members ?? []).filter((m) => m.role === "worker" && m.status === "online");
+	assertEq(onlineAfter.length, 0, "/team done: all workers offline after done");
+
+	const offlineAlice = cfgAfter?.members.find((m) => m.name === "alice");
+	assert(offlineAlice?.meta?.["stoppedReason"] === "team-done", "/team done: alice has stoppedReason=team-done");
+
+	// Test force-done with in-progress tasks (simulates --force path)
+	const forceDir = path.join(tmpRoot, "force-done-test");
+	const forceTeamId = "force-done-team";
+	const forceTeamDir = path.join(forceDir, forceTeamId);
+	const forceTlId = forceTeamId;
+
+	await ensureTeamConfig(forceTeamDir, { teamId: forceTeamId, taskListId: forceTlId, leadName: "team-lead", style: "normal" });
+	await upsertMember(forceTeamDir, { name: "carol", role: "worker", status: "online" });
+
+	const ft1 = await createTask(forceTeamDir, forceTlId, { subject: "Ongoing work", description: "", owner: "carol" });
+	await startAssignedTask(forceTeamDir, forceTlId, ft1.id, "carol");
+
+	const forceTasks = await listTasks(forceTeamDir, forceTlId);
+	assertEq(forceTasks[0]?.status, "in_progress", "/team done --force precondition: task in_progress");
+
+	// Simulate force-done: unassign in-progress tasks
+	await unassignTasksForAgent(forceTeamDir, forceTlId, "carol", "team done");
+	await setMemberStatus(forceTeamDir, "carol", "offline", { meta: { stoppedReason: "team-done" } });
+
+	const forceTasksAfter = await listTasks(forceTeamDir, forceTlId);
+	assertEq(forceTasksAfter[0]?.status, "pending", "/team done --force: in-progress task reset to pending");
+	assertEq(forceTasksAfter[0]?.owner, undefined, "/team done --force: in-progress task unassigned");
+
+	const forceCfgAfter = await loadTeamConfig(forceTeamDir);
+	const forceCarol = forceCfgAfter?.members.find((m) => m.name === "carol");
+	assertEq(forceCarol?.status, "offline", "/team done --force: worker offline");
+
+	// Test idempotency: calling done again on already-done team is safe
+	await setMemberStatus(doneTeamDir, "alice", "offline", { meta: { stoppedReason: "team-done" } });
+	await setMemberStatus(doneTeamDir, "bob", "offline", { meta: { stoppedReason: "team-done" } });
+	const idempotentCfg = await loadTeamConfig(doneTeamDir);
+	const idempotentOnline = (idempotentCfg?.members ?? []).filter((m) => m.role === "worker" && m.status === "online");
+	assertEq(idempotentOnline.length, 0, "/team done idempotent: still 0 online after second done");
+	const idempotentTasks = await listTasks(doneTeamDir, doneTlId);
+	const idempotentAllDone = idempotentTasks.every((t) => t.status === "completed");
+	assert(idempotentAllDone, "/team done idempotent: tasks still completed after second done");
+}
+
+// ── 12. isTeamDone (pure function unit tests) ───────────────────────
+console.log("\n12. isTeamDone");
+{
+	// Minimal mock: isTeamDone only reads .status from TeammateRpc values
+	type MockRpc = { status: string };
+	const mockMap = (entries: Array<[string, MockRpc]>) =>
+		new Map(entries) as unknown as ReadonlyMap<string, import("../extensions/teams/teammate-rpc.js").TeammateRpc>;
+
+	const completedTask = (id: string): import("../extensions/teams/task-store.js").TeamTask => ({
+		id, subject: "x", description: "", status: "completed",
+		blocks: [], blockedBy: [], metadata: {}, createdAt: "", updatedAt: "",
+	});
+	const pendingTask = (id: string): import("../extensions/teams/task-store.js").TeamTask => ({
+		id, subject: "x", description: "", status: "pending",
+		blocks: [], blockedBy: [], metadata: {}, createdAt: "", updatedAt: "",
+	});
+	const inProgressTask = (id: string): import("../extensions/teams/task-store.js").TeamTask => ({
+		id, subject: "x", description: "", status: "in_progress",
+		blocks: [], blockedBy: [], metadata: {}, createdAt: "", updatedAt: "",
+	});
+
+	// No tasks → not done
+	assert(!isTeamDone([], mockMap([])), "isTeamDone: empty tasks = false");
+
+	// All completed, no teammates → done
+	assert(isTeamDone([completedTask("1"), completedTask("2")], mockMap([])), "isTeamDone: all completed, no teammates = true");
+
+	// All completed, all idle → done
+	assert(
+		isTeamDone([completedTask("1")], mockMap([["alice", { status: "idle" }]])),
+		"isTeamDone: all completed + idle teammate = true",
+	);
+
+	// All completed, one streaming → not done
+	assert(
+		!isTeamDone([completedTask("1")], mockMap([["alice", { status: "streaming" }]])),
+		"isTeamDone: all completed + streaming teammate = false",
+	);
+
+	// All completed, one starting → not done
+	assert(
+		!isTeamDone([completedTask("1")], mockMap([["alice", { status: "starting" }]])),
+		"isTeamDone: all completed + starting teammate = false",
+	);
+
+	// All completed, stopped teammate → done
+	assert(
+		isTeamDone([completedTask("1")], mockMap([["alice", { status: "stopped" }]])),
+		"isTeamDone: all completed + stopped teammate = true",
+	);
+
+	// Pending task → not done
+	assert(
+		!isTeamDone([completedTask("1"), pendingTask("2")], mockMap([])),
+		"isTeamDone: one pending = false",
+	);
+
+	// In-progress task → not done
+	assert(
+		!isTeamDone([completedTask("1"), inProgressTask("2")], mockMap([])),
+		"isTeamDone: one in-progress = false",
+	);
+
+	// Mixed: all completed, mixed teammate states (idle + stopped) → done
+	assert(
+		isTeamDone(
+			[completedTask("1"), completedTask("2")],
+			mockMap([["alice", { status: "idle" }], ["bob", { status: "stopped" }]]),
+		),
+		"isTeamDone: all completed + idle+stopped = true",
+	);
+}
+
+// ── 13. formatElapsed + lastMessageSummary ───────────────────────────
+console.log("\n13. formatElapsed + lastMessageSummary");
+{
+	assert(formatElapsed(500) === "0s", "formatElapsed <1s rounds to 0s");
+	assert(formatElapsed(1000) === "1s", "formatElapsed 1s");
+	assert(formatElapsed(45000) === "45s", "formatElapsed 45s");
+	assert(formatElapsed(90000) === "1m30s", "formatElapsed 1m30s");
+	assert(formatElapsed(120000) === "2m", "formatElapsed 2m exact");
+	assert(formatElapsed(3600000) === "1h", "formatElapsed 1h exact");
+	assert(formatElapsed(3660000) === "1h1m", "formatElapsed 1h1m");
+
+	// lastMessageSummary with undefined rpc
+	assert(lastMessageSummary(undefined) === "", "lastMessageSummary(undefined) is empty");
+
+	// lastMessageSummary with mock rpc-like object (only lastAssistantText matters)
+	const mockRpc = { lastAssistantText: "Hello world, this is a test" } as unknown as import("../extensions/teams/teammate-rpc.js").TeammateRpc;
+	const summary = lastMessageSummary(mockRpc, 20);
+	assert(summary.length <= 20, "lastMessageSummary respects maxLen");
+	assert(summary.endsWith("…"), "lastMessageSummary truncates with ellipsis");
+
+	const shortRpc = { lastAssistantText: "Short" } as unknown as import("../extensions/teams/teammate-rpc.js").TeammateRpc;
+	assert(lastMessageSummary(shortRpc, 20) === "Short", "lastMessageSummary keeps short text intact");
+}
+
+// ── 14. leader-inbox LLM message injection ───────────────────────────
+console.log("\n14. leader-inbox LLM message injection");
+{
+	const inboxTeamDir = path.join(tmpRoot, "inbox-test");
+	const inboxTaskListId = "inbox-tl";
+	const leadName = "team-lead";
+	const style = "default";
+
+	// Set up team config
+	await ensureTeamConfig(inboxTeamDir, { teamId: "inbox-team", taskListId: inboxTaskListId, leadName, style });
+
+	// Create and complete a task with a result
+	const t1 = await createTask(inboxTeamDir, inboxTaskListId, { subject: "Fix tests", description: "", owner: "alice" });
+	await completeTask(inboxTeamDir, inboxTaskListId, t1.id, "alice", "All 12 tests passing");
+
+	// Write an idle notification with completedTaskId
+	const ts = new Date().toISOString();
+	await writeToMailbox(inboxTeamDir, TEAM_MAILBOX_NS, leadName, {
+		from: "alice",
+		text: JSON.stringify({
+			type: "idle_notification",
+			from: "alice",
+			timestamp: ts,
+			completedTaskId: t1.id,
+			completedStatus: "completed",
+		}),
+		timestamp: ts,
+	});
+
+	// Track messages sent to leader LLM
+	const llmMessages: Array<{ content: string; options?: { deliverAs?: string } }> = [];
+
+	// Minimal ExtensionContext stub
+	const stubCtx = {
+		cwd: inboxTeamDir,
+		ui: { notify: () => {} },
+		sessionManager: { getSessionId: () => "inbox-team" },
+	} as unknown as ExtensionContext;
+
+	await pollLeaderInbox({
+		ctx: stubCtx,
+		teamId: "inbox-team",
+		teamDir: inboxTeamDir,
+		taskListId: inboxTaskListId,
+		leadName,
+		style,
+		pendingPlanApprovals: new Map(),
+		sendLeaderLlmMessage: (content, options) => {
+			llmMessages.push({ content, options });
+		},
+	});
+
+	assert(llmMessages.length === 1, "one LLM message sent on task completion");
+	const msg0 = llmMessages[0];
+	if (msg0) {
+		assert(msg0.content.includes("[Team]"), "LLM message has [Team] prefix");
+		assert(msg0.content.includes("alice"), "LLM message includes worker name");
+		assert(msg0.content.includes(t1.id), "LLM message includes task id");
+		assert(msg0.content.includes("Fix tests"), "LLM message includes task subject");
+		assert(msg0.content.includes("All 12 tests passing"), "LLM message includes result");
+		assert(msg0.content.includes("All 1 task(s) are now completed"), "LLM message includes allDone summary");
+		assertEq(msg0.options?.deliverAs, "followUp", "LLM message uses followUp delivery");
+	}
+
+	// Test failure path with abort metadata
+	const t2 = await createTask(inboxTeamDir, inboxTaskListId, { subject: "Deploy staging", description: "", owner: "bob" });
+	await updateTask(inboxTeamDir, inboxTaskListId, t2.id, (cur) => ({
+		...cur,
+		status: "pending",
+		metadata: {
+			...(cur.metadata ?? {}),
+			abortReason: "timeout after 60s",
+			partialResult: "Deployed but health check failed",
+		},
+	}));
+
+	const ts2 = new Date().toISOString();
+	await writeToMailbox(inboxTeamDir, TEAM_MAILBOX_NS, leadName, {
+		from: "bob",
+		text: JSON.stringify({
+			type: "idle_notification",
+			from: "bob",
+			timestamp: ts2,
+			completedTaskId: t2.id,
+			completedStatus: "failed",
+		}),
+		timestamp: ts2,
+	});
+
+	llmMessages.length = 0;
+	await pollLeaderInbox({
+		ctx: stubCtx,
+		teamId: "inbox-team",
+		teamDir: inboxTeamDir,
+		taskListId: inboxTaskListId,
+		leadName,
+		style,
+		pendingPlanApprovals: new Map(),
+		sendLeaderLlmMessage: (content, options) => {
+			llmMessages.push({ content, options });
+		},
+	});
+
+	assert(llmMessages.length === 1, "one LLM message sent on task failure");
+	const failMsg = llmMessages[0];
+	if (failMsg) {
+		assert(failMsg.content.includes("failed"), "failure LLM message includes failed");
+		assert(failMsg.content.includes("timeout after 60s"), "failure LLM message includes abortReason");
+		assert(failMsg.content.includes("health check failed"), "failure LLM message includes partialResult");
+	}
+
+	// Test hook-aware allDone qualifier
+	const t3 = await createTask(inboxTeamDir, inboxTaskListId, { subject: "Final task", description: "", owner: "carol" });
+	await completeTask(inboxTeamDir, inboxTaskListId, t3.id, "carol", "Done");
+	// Also complete t2 so all tasks are done
+	await updateTask(inboxTeamDir, inboxTaskListId, t2.id, (cur) => ({
+		...cur,
+		status: "completed",
+		owner: "bob",
+	}));
+
+	const ts3 = new Date().toISOString();
+	await writeToMailbox(inboxTeamDir, TEAM_MAILBOX_NS, leadName, {
+		from: "carol",
+		text: JSON.stringify({
+			type: "idle_notification",
+			from: "carol",
+			timestamp: ts3,
+			completedTaskId: t3.id,
+			completedStatus: "completed",
+		}),
+		timestamp: ts3,
+	});
+
+	llmMessages.length = 0;
+	await pollLeaderInbox({
+		ctx: stubCtx,
+		teamId: "inbox-team",
+		teamDir: inboxTeamDir,
+		taskListId: inboxTaskListId,
+		leadName,
+		style,
+		pendingPlanApprovals: new Map(),
+		enqueueHook: () => {}, // hooks present → should qualify allDone
+		sendLeaderLlmMessage: (content, options) => {
+			llmMessages.push({ content, options });
+		},
+	});
+
+	assert(llmMessages.length === 1, "one LLM message sent with hooks active");
+	const hookMsg = llmMessages[0];
+	if (hookMsg) {
+		assert(hookMsg.content.includes("quality gates are still running"), "allDone qualified when hooks active");
+		assert(!hookMsg.content.includes("Review results and determine next steps"), "no premature wrap-up prompt when hooks active");
+	}
+}
+
+// ── 15. docs/help drift guard ────────────────────────────────────────
+console.log("\n15. docs/help drift guard");
 {
 	const help = getTeamHelpText();
+	assert(help.includes("/team done"), "help mentions /team done");
 	assert(help.includes("/team style list"), "help mentions /team style list");
 	assert(help.includes("/team style init"), "help mentions /team style init");
 	assert(help.includes("/team attach <teamId> [--claim]"), "help mentions /team attach claim mode");
 	assert(help.includes("/team detach"), "help mentions /team detach");
+	assert(help.includes("[--urgent]"), "help mentions --urgent flag");
+	assert(help.includes("/team gc"), "help mentions /team gc");
+	assert(help.includes("/team status"), "help mentions /team status");
 
 	const readmePath = path.join(process.cwd(), "README.md");
 	if (!fs.existsSync(readmePath)) {
 		console.log("  (skipped) README.md not found");
 	} else {
 		const readme = fs.readFileSync(readmePath, "utf8");
+		assert(readme.includes("/team done"), "README mentions /team done");
+		assert(readme.includes("\"action\": \"team_done\""), "README mentions teams tool team_done action");
 		assert(readme.includes("/team style list"), "README mentions /team style list");
 		assert(readme.includes("/team attach <teamId> [--claim]"), "README mentions /team attach claim mode");
 		assert(readme.includes("/team detach"), "README mentions /team detach");
@@ -696,6 +1197,8 @@ console.log("\n11. docs/help drift guard");
 		assert(readme.includes("\"action\": \"plan_approve\""), "README mentions teams tool plan_approve action");
 		assert(readme.includes("\"action\": \"hooks_policy_get\""), "README mentions teams tool hooks_policy_get action");
 		assert(readme.includes("\"action\": \"hooks_policy_set\""), "README mentions teams tool hooks_policy_set action");
+		assert(readme.includes("\"action\": \"model_policy_get\""), "README mentions teams tool model_policy_get action");
+		assert(readme.includes("\"action\": \"model_policy_check\""), "README mentions teams tool model_policy_check action");
 		assert(readme.includes("PI_TEAMS_HOOKS_FAILURE_ACTION"), "README mentions hook failure action policy");
 		assert(readme.includes("PI_TEAMS_HOOKS_MAX_REOPENS_PER_TASK"), "README mentions hook reopen cap policy");
 		assert(readme.includes("PI_TEAMS_HOOK_CONTEXT_JSON"), "README mentions hook context json contract");
@@ -704,7 +1207,202 @@ console.log("\n11. docs/help drift guard");
 		assert(readme.includes("`t` or `shift+t`"), "README mentions panel task toggle key");
 		assert(readme.includes("task view: `c` complete"), "README mentions panel task mutations");
 		assert(readme.includes("`r` reassign"), "README mentions panel task reassignment");
+		assert(readme.includes("tool args inline"), "README mentions transcript tool content display");
 		assert(readme.includes("_styles"), "README mentions _styles directory");
+		assert(readme.includes("[--urgent]"), "README mentions --urgent flag");
+		assert(readme.includes("\"urgent\": true"), "README mentions urgent tool param example");
+		assert(readme.includes("/team gc"), "README mentions /team gc command");
+		assert(readme.includes("/team cleanup"), "README mentions /team cleanup command");
+		assert(readme.includes("docs/hook-contract.md"), "README references hook contract doc");
+		assert(readme.includes("member_status"), "README mentions teams tool member_status action");
+		assert(readme.includes("/team status"), "README mentions /team status command");
+		assert(readme.includes("PI_TEAMS_STALL_THRESHOLD_MS"), "README mentions stall threshold env var");
+		assert(readme.includes("Stall detection"), "README mentions stall detection feature");
+		assert(readme.includes("Time in state"), "README mentions time-in-state feature");
+	}
+
+	const skillPath = path.join(process.cwd(), "skills/agent-teams/SKILL.md");
+	if (!fs.existsSync(skillPath)) {
+		console.log("  (skipped) SKILL.md not found");
+	} else {
+		const skill = fs.readFileSync(skillPath, "utf8");
+		assert(skill.includes("team_done"), "SKILL.md mentions team_done action");
+		assert(skill.includes("/team done"), "SKILL.md mentions /team done command");
+		assert(skill.includes("urgent"), "SKILL.md mentions urgent flag");
+		assert(skill.includes("model_policy_get"), "SKILL.md mentions model_policy_get action");
+		assert(skill.includes("hooks_policy_get"), "SKILL.md mentions hooks_policy_get action");
+	}
+}
+
+// ── 12. transcript tracker (tool content summarization) ─────────────
+{
+	console.log(`\n12. transcript tracker (tool content summarization)`);
+
+	const tracker = new TranscriptTracker();
+
+	// Helper to get last entry with proper narrowing
+	function lastEntry(name: string): TranscriptEntry {
+		const entries = tracker.get(name).getEntries();
+		const last = entries[entries.length - 1];
+		if (!last) throw new Error("no transcript entries");
+		return last;
+	}
+
+	// Simulate tool_execution_start with read tool
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc1",
+		toolName: "Read",
+		args: { path: "/src/index.ts" },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "read tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "/src/index.ts", "read summary is file path");
+		}
+	}
+
+	// Simulate tool_execution_end with content array (ToolResultMessage shape)
+	tracker.handleEvent("alice", {
+		type: "tool_execution_end",
+		toolCallId: "tc1",
+		toolName: "Read",
+		result: { content: [{ type: "text", text: "file contents here\nline two" }] },
+		isError: false,
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_end", "read tool_end recorded");
+		if (e.kind === "tool_end") {
+			assert(e.summary === "file contents here line two", "read result summarized from content array");
+			assert(!e.isError, "read result not error");
+		}
+	}
+
+	// Simulate bash tool with command
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc2",
+		toolName: "Bash",
+		args: { command: "npm run   check" },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "bash tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "npm run check", "bash summary normalizes whitespace");
+		}
+	}
+
+	// Simulate bash error result
+	tracker.handleEvent("alice", {
+		type: "tool_execution_end",
+		toolCallId: "tc2",
+		toolName: "Bash",
+		result: { content: [{ type: "text", text: "Command failed with exit code 1" }] },
+		isError: true,
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_end", "bash error tool_end recorded");
+		if (e.kind === "tool_end") {
+			assert(e.isError, "bash error flagged");
+			assert(e.summary === "Command failed with exit code 1", "bash error summary from content");
+		}
+	}
+
+	// Simulate edit tool
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc3",
+		toolName: "Edit",
+		args: { path: "/src/utils.ts", oldText: "foo", newText: "bar" },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "edit tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "/src/utils.ts", "edit summary is file path");
+		}
+	}
+
+	// Simulate grep tool
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc4",
+		toolName: "Grep",
+		args: { pattern: "TODO", path: "/src" },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "grep tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "TODO in /src", "grep summary includes pattern and path");
+		}
+	}
+
+	// Simulate team_message tool — should show recipient + message, not just recipient
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc4b",
+		toolName: "team_message",
+		args: { recipient: "bob", message: "please rebase onto main", urgent: false },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "team_message tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "→ bob: please rebase onto main", "team_message summary includes recipient and message");
+		}
+	}
+
+	// Simulate unknown tool — fallback to first string arg
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc5",
+		toolName: "CustomTool",
+		args: { target: "my-resource" },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "unknown tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary === "my-resource", "unknown tool fallback to first string arg");
+		}
+	}
+
+	// Simulate empty result
+	tracker.handleEvent("alice", {
+		type: "tool_execution_end",
+		toolCallId: "tc5",
+		toolName: "CustomTool",
+		result: { content: [{ type: "text", text: "" }] },
+		isError: false,
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_end", "empty result tool_end recorded");
+		if (e.kind === "tool_end") {
+			assert(e.summary === "(empty)", "empty result shows (empty)");
+		}
+	}
+
+	// Simulate long summary truncation
+	const longPath = "/very/long/" + "a".repeat(200) + ".ts";
+	tracker.handleEvent("alice", {
+		type: "tool_execution_start",
+		toolCallId: "tc6",
+		toolName: "Read",
+		args: { path: longPath },
+	});
+	{
+		const e = lastEntry("alice");
+		assert(e.kind === "tool_start", "long path tool_start recorded");
+		if (e.kind === "tool_start") {
+			assert(e.summary !== null && e.summary.length <= 120, "long summary truncated to 120 chars");
+			assert(e.summary !== null && e.summary.endsWith("…"), "truncated summary ends with ellipsis");
+		}
 	}
 }