pi-extended-teams 2.2.9 → 2.3.0

package/extensions/agents/write-agent.ts

@@ -97,6 +97,9 @@ export function createWriteAgentRuntime(options: WriteAgentRuntimeOptions) {
   }
 
   async function startWriteAgent(teamName: string, member: Member, prompt: string): Promise<string> {
+    if (["checkpoint", "checkpointAssignment", "continueFrom", "continue_from"].some(field => Reflect.get(member, field) !== undefined)) {
+      throw new Error("Checkpoint-enabled agents require in-process lead admission; legacy terminal startup is unsupported.");
+    }
     assertWriterUsesConfiguredLevel(member);
     if (!options.terminal) {
       throw new Error("pi-extended-teams requires running inside tmux for write agents.");

package/extensions/events/register-events.ts

@@ -9,10 +9,12 @@ import { cleanupAgentSessionFolders, cleanupOrphanedTeams } from "../internal/se
 import { summarizeSessionUsage } from "../internal/session-usage";
 import { formatElapsed, formatTokenCount } from "../ui/renderers";
 import { isWorkflowSpawnedMember } from "../../src/utils/workflow-metadata";
-import { FAVORITE_MODEL_SLOTS, loadSettings } from "../../src/utils/settings";
+import { globalSettingsPath, projectSettingsPath } from "../../src/utils/settings";
+import { normalizeRepairPolicy } from "../../src/results/repair-policy";
 import { generateLifecycleRunId } from "../../src/utils/lifecycle-tombstone";
 import { cleanupStaleSessionContextReferences } from "../internal/session-context-reference";
 import { cleanupStalePrivateAgentSessions } from "../internal/agent-session-files";
+import { expireCheckpoints } from "../../src/results/checkpoint-retention";
 
 export const LEAD_ORCHESTRATION_GUIDANCE = `\n\npi-extended-teams lead orchestration rules:\n- Choose tiers by the agent's intended outcome, not by vague task importance. read-review is the normal default for focused review, verification, and bounded synthesis.\n- Use read-collect when the lane gathers bounded facts without owning the conclusion. Use read-analyze when it must explain behavior or root cause across connected evidence. Reserve read-critical for irreducible high-stakes security, architecture, concurrency, migration, or data-correctness reasoning.\n- For edits, use write-patch for a narrow localized change, write-feature for a bounded feature with a known design, write-system for a cross-cutting integration/refactor within explicitly claimed files, and write-critical only for high-risk security, concurrency, recovery, migration, or data-integrity changes.\n- Prefer the canonical read-*/write-* tiers. Legacy reading-*/writing-* names are compatibility aliases for this minor release, not intent guidance.\n- A spawned agent owns its assigned lane until it reports, blocks, fails, or the user cancels it. Do not duplicate, take over, test, edit, or synthesize that same lane in parallel; work only on clearly unrelated lanes.\n- When no unrelated work remains, end the turn. The extension resumes you when a report arrives. One get_agent_status snapshot is allowed when current status is needed; do not repeatedly call it, sleep, busy-wait, loop on inbox/status, send nudges, do dummy work, or treat healthy silence as failure.\n- Wait for the actual report before synthesizing. Intervene only on a reported blocker/error, actual health failure, or explicit user cancellation/change.\n- For durable bug, security, or testing claims from an agent report or backlog, concrete, reproducible findings with file/line evidence or a focused failing regression may proceed directly to TDD repair.
 - Use a separate read-only confirmation only when evidence is missing or weak, the claim is disputed, or irreducible high-risk uncertainty remains; never reconfirm an already confirmed finding.`;
@@ -42,6 +44,13 @@ export function isInboxFileWatchEvent(inboxFile: string, filename: string | Buff
   return !changedName || changedName === inboxBase || changedName === `${inboxBase}.lock`;
 }
 
+function hasPersistedTeamSettings(ctx: any): boolean {
+  if (fs.existsSync(globalSettingsPath())) return true;
+  return typeof ctx.cwd === "string"
+    && ctx.isProjectTrusted?.() === true
+    && fs.existsSync(projectSettingsPath(ctx.cwd));
+}
+
 export function registerExtensionEvents(pi: any, options: RegisterEventsOptions): void {
   let teammateWakeIfUnread: (() => Promise<void>) | null = null;
   let teammatePendingInboxWake = false;
@@ -163,14 +172,14 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
       } catch {
         // Session-start janitors are best-effort and must not block initialization.
       }
-      const settings = loadSettings({ projectDir: ctx.cwd });
-      const configuredTiers = FAVORITE_MODEL_SLOTS.filter((slot) => {
-        const config = settings.favoriteModels[slot];
-        return !!config?.model && !!config.thinking;
-      });
-      if (configuredTiers.length === 0) {
+      try {
+        for (const diagnostic of await expireCheckpoints()) ctx.ui?.notify?.(diagnostic, "warning");
+      } catch (error) {
+        ctx.ui?.notify?.(`Checkpoint expiry: ${String(error)}`, "warning");
+      }
+      if (!hasPersistedTeamSettings(ctx)) {
         ctx.ui?.notify?.(
-          "No agent intent tiers are configured. Define them with /agents-favorite-models before spawning agents. See README.md for intent-tier examples.",
+          "pi-extended-teams is not configured yet. Run /pi-extended-teams-onboard for agent-led model and shared-extension setup.",
           "warning"
         );
       }
@@ -399,13 +408,16 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
             if (member.thinking) modelInfo += ` with thinking level: ${member.thinking}`;
             modelInfo += `. When reporting your model or thinking level, use these exact values.`;
           }
+          const repairGuidance = normalizeRepairPolicy(member?.repairPolicy)
+            ? "Call report_and_exit when finished. If it returns an unaccepted repair request, remain active, repair only the assigned scope, and resubmit. Report blocked or failed if repair is unsafe. Claims and shutdown wait for an accepted final report."
+            : undefined;
           if ((member?.role ?? "write") === "write") {
             const workflowGuard = member && isWorkflowSpawnedMember(member)
               ? "\n- Workflow mode: do not create helper fanout yourself. Ask team-lead with send_message for an explicit workflow assignment."
               : "\n- If you need read-only help, ask team-lead with send_message. The lead decides whether to spawn another agent.";
-            roleSpecificGuidance = `\n\nEdit-agent rules:\n- Before editing or writing any repository file, call claim_file with every path you intend to change and wait for the claim to be granted.\n- If claim_file reports conflicts, do not edit those files; coordinate with your lead instead.${workflowGuard}\n- Release claims with release_file as soon as you are done editing those paths.\n- When your work is finished, call report_and_exit. It sends your final report, releases any remaining file claims, and shuts you down. Do not wait for the lead to kill you.`;
+            roleSpecificGuidance = `\n\nEdit-agent rules:\n- Before editing or writing any repository file, call claim_file with every path you intend to change and wait for the claim to be granted.\n- If claim_file reports conflicts, do not edit those files; coordinate with your lead instead.${workflowGuard}\n- Release claims with release_file as soon as you are done editing those paths.\n- ${repairGuidance ?? "When your work is finished, call report_and_exit. It sends your final report, releases any remaining file claims, and shuts you down. Do not wait for the lead to kill you."}`;
           } else {
-            roleSpecificGuidance = `\n\nRead-agent rules:\n- You are read-only: investigate and report. Do not edit files or make any mutating changes.\n- When finished, produce your final report and stop. Do not wait for the lead to kill you.`;
+            roleSpecificGuidance = `\n\nRead-agent rules:\n- You are read-only: investigate and report. Do not edit files or make any mutating changes.\n- ${repairGuidance ?? "When finished, produce your final report and stop. Do not wait for the lead to kill you."}`;
           }
           rosterInfo = `\n\n${options.formatRosterForPrompt(await options.buildRoster(teamName))}\nUse this roster as a snapshot. If you need updated roster or liveness details, ask team-lead with send_message. Do not poll.`;
         } catch {

package/extensions/index.ts

@@ -8,11 +8,14 @@ import { runReadAgentInProcess, sendMessageToRunningReadAgent } from "./agents/r
 import { createWriteAgentRuntime } from "./agents/write-agent.js";
 import { registerExtensionEvents } from "./events/register-events.js";
 import { createLifecycleRuntime } from "./team/lifecycle.js";
+import { createCombinedSessionCost } from "./team/session-cost.js";
 import { buildRoster as buildTeamRoster, formatRosterForPrompt, releaseAllClaimsForAgent, requireTeamContext as resolveTeamContext, requireWriteAgentTeam as resolveWriteAgentTeam } from "./team/roster.js";
 import { createWriterScreenState, registerWriterScreenShortcut, removeWriterScreenTab, upsertWriterScreenTab, type ActiveWriterTab } from "./team/writer-screens.js";
 import { registerFavoriteModelsCommand } from "./ui/favorite-models-command.js";
 import { registerExtensionsCommand } from "./ui/extensions-command.js";
-import { installAgentNavigation } from "./ui/agent-navigation.js";
+import { registerOnboardingCommand } from "./ui/onboarding-command.js";
+import { registerCheckpointsCommand } from "./ui/checkpoints-command.js";
+import { hasActiveReadAgentLifecycle, installAgentNavigation, orderAgentNavigationEntries } from "./ui/agent-navigation.js";
 import { buildReadHelperPrompt, registerCoordinationTools } from "./tools/coordination-tools.js";
 import { createReportProgressTool } from "./tools/agent-communication-tools.js";
 import { registerTaskRuntimeTools } from "./tools/task-runtime-tools.js";
@@ -26,11 +29,14 @@ import { createActiveAgentSleepController, runWithActiveAgentSleepAssertion } fr
 import { createTeammateInterrupter } from "./runtime/teammate-interrupt.js";
 export { panelBgFill, framePanel, frameWidget, frameWidgetFullWidth, logWindowStart } from "./ui/frame.js";
 import * as messaging from "../src/utils/messaging";
+import { requestCompletionGroupWake, observeCompletionGroupWakes } from "../src/results/completion-group-wake";
+import { recoverCompletionGroups } from "../src/results/completion-group-recovery";
 import * as teams from "../src/utils/teams";
 import * as runtime from "../src/utils/runtime";
 import * as teamPaths from "../src/utils/paths";
 import { listReadHelperQueue, removeQueuedReadHelperRequest } from "../src/utils/read-helper-queue";
 import type { Member } from "../src/utils/models";
+import { projectAgentStatus, projectLifecycleFence } from "../src/orchestration/status-projection";
 import { getTerminalAdapter } from "../src/adapters/terminal-registry";
 import { createSpawnResourcePlan, parentProjectTrustForSpawn } from "./resources/spawn-resource-plan.js";
 import { generateExtensionInstanceId, listLifecycleTombstones, onLifecycleTombstoneCleared, readLifecycleTombstone } from "../src/utils/lifecycle-tombstone";
@@ -40,6 +46,7 @@ export default function (pi: ExtensionAPI) {
   const agentName = process.env.PI_AGENT_NAME || "team-lead";
   const extensionInstanceId = generateExtensionInstanceId();
   const envTeamName = process.env.PI_TEAM_NAME;
+  const combinedSessionCost = isTeammate ? undefined : createCombinedSessionCost(pi);
 
   // Teammates are explicitly bound by PI_TEAM_NAME. Lead sessions are adopted
   // later at session_start only when the persisted Pi session id matches.
@@ -172,11 +179,12 @@ export default function (pi: ExtensionAPI) {
     targetTeamName: string,
     targetAgentName: string,
     content: string,
-    expectedRecipientRunId?: string
+    expectedRecipientRunId?: string,
+    requireReceipt = false
   ): Promise<boolean> {
     const target = runningReadAgents.get(readAgentKey(targetTeamName, targetAgentName));
     if (expectedRecipientRunId !== undefined && target?.runId !== expectedRecipientRunId) return false;
-    const delivered = await sendMessageToRunningReadAgent(target, content);
+    const delivered = await sendMessageToRunningReadAgent(target, content, requireReceipt);
     if (delivered) renderReadAgentStatus();
     return delivered;
   }
@@ -229,13 +237,6 @@ export default function (pi: ExtensionAPI) {
     return !!status.lastHeartbeatAt && (now - status.lastHeartbeatAt) <= runtime.HEARTBEAT_STALE_MS;
   }
 
-  function hasActiveReadAgentLifecycle(agent: RunningReadAgent): boolean {
-    return agent.teardownState !== "stopping"
-      && agent.teardownState !== "quarantined"
-      && agent.teardownState !== "persistence_failed"
-      && agent.teardownState !== "finalized";
-  }
-
   function isVisibleRuntimeOnlyMember(
     member: Member,
     runtimeStatus: runtime.AgentRuntimeStatus | null,
@@ -337,11 +338,11 @@ export default function (pi: ExtensionAPI) {
   // message with display:false still reaches the model as a user turn (see
   // convertToLlm) but is never rendered, so team coordination stays silent.
   // Falls back to a visible user message on older pi builds without sendMessage.
-  function quietTrigger(content: string): void {
+  function quietTrigger(content: string, details?: Record<string, unknown>): void {
     const api = pi as any;
     if (typeof api.sendMessage === "function") {
       api.sendMessage(
-        { customType: "pi-extended-teams-wake", content, display: false },
+        { customType: "pi-extended-teams-wake", content, display: false, ...(details ? { details } : {}) },
         { triggerTurn: true, deliverAs: "followUp" }
       );
     } else {
@@ -378,9 +379,46 @@ export default function (pi: ExtensionAPI) {
     pi.events?.emit?.("pi-extended-teams:agent-progress", { teamName: progressTeamName, name, status, updatedAt });
   }
 
-  function wakeLeadForInboxReports(unread: any[]): void {
-    if (!teamName) return;
-    const keyedUnread = unread.map((message) => ({
+  const currentCompletionGroups = new Set<string>();
+  const observedWakeEntries = new Set<string>();
+  const groupWarnings = new Set<string>();
+  const sessionEntries = (ctx: any) => ctx?.sessionManager?.getEntries?.() ?? ctx?.sessionManager?.getBranch?.() ?? [];
+  function warnGroup(error: unknown): void {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!groupWarnings.has(message)) {
+      groupWarnings.add(message);
+      sessionCtx?.ui?.notify?.(message, "warning");
+    }
+  }
+  async function observeGroupHistory(ctx: any): Promise<void> {
+    if (!teamName || extensionShuttingDown) return;
+    const target = teamName;
+    const entries = sessionEntries(ctx).filter((entry: any) => !observedWakeEntries.has(`${target}:${entry.id}`));
+    const result = await observeCompletionGroupWakes(target, getPiSessionId(ctx) ?? "", entries);
+    for (const id of result.observed) observedWakeEntries.add(`${target}:${id}`);
+    for (const error of result.errors) warnGroup(error);
+  }
+  async function requestGroupInboxWakes(unread: any[]): Promise<void> {
+    if (!teamName || !sessionCtx || extensionShuttingDown) return;
+    const target = teamName;
+    const ctx = sessionCtx;
+    for (const message of unread.filter(item => item.metadata?.completionGroup)) {
+      try {
+        if (typeof (pi as any).sendMessage !== "function") throw new Error("Grouped wakes require Pi custom messages; use read_inbox for the saved index.");
+        await requestCompletionGroupWake(target, getPiSessionId(ctx) ?? "", message, (content, details) => {
+          if (extensionShuttingDown || ctx !== sessionCtx) throw new Error("Group wake unconfirmed: the lead session is closing.");
+          quietTrigger(content, details);
+        });
+      } catch (error) { warnGroup(error); }
+    }
+  }
+  async function wakeLeadForInboxReports(unread: any[]): Promise<void> {
+    if (!teamName || extensionShuttingDown) return;
+    const target = teamName;
+    const ctx = sessionCtx;
+    await requestGroupInboxWakes(unread);
+    if (extensionShuttingDown || target !== teamName || ctx !== sessionCtx) return;
+    const keyedUnread = unread.filter(message => !message.metadata?.completionGroup).map((message) => ({
       message,
       key: String(message?.id || `${message?.from || "unknown"}:${message?.timestamp || ""}:${message?.text || ""}`),
     }));
@@ -412,7 +450,7 @@ export default function (pi: ExtensionAPI) {
     if (isTeammate) return;
     const unread = await messaging.peekInbox(targetTeamName, agentName, true);
     await renderLeadInboxStatus();
-    wakeLeadForInboxReports(unread);
+    await wakeLeadForInboxReports(unread);
   }
 
   function getIdleReadAgentNudgeMessage(agent: RunningReadAgent, status: ReadAgentStatusDescription): string | null {
@@ -567,11 +605,12 @@ export default function (pi: ExtensionAPI) {
 
     const now = Date.now();
     const activityTeamName = teamName || null;
-    const runningAgents = activityTeamName
+    const sessionAgents = activityTeamName
       ? Array.from(runningReadAgents.values())
-        .filter(agent => agent.teamName === activityTeamName && hasActiveReadAgentLifecycle(agent))
+        .filter(agent => agent.teamName === activityTeamName)
         .sort((a, b) => a.name.localeCompare(b.name))
       : [];
+    const runningAgents = sessionAgents.filter(hasActiveReadAgentLifecycle);
     const readAgents = runningAgents.filter(agent => (agent.role || "read") === "read");
     const writeAgents = runningAgents.filter(agent => (agent.role || "read") === "write");
     const activityConfig = activityTeamName ? await teams.readConfig(activityTeamName).catch(() => null) : null;
@@ -579,17 +618,21 @@ export default function (pi: ExtensionAPI) {
     const activityTombstones = activityTeamName
       ? await listLifecycleTombstones(activityTeamName).catch(() => [])
       : [];
-    const runtimeOnlyMembers = activityTeamName
-      ? (await Promise.all(activityMembers
+    const unsettledAgents = sessionAgents.filter(agent => !hasActiveReadAgentLifecycle(agent)
+      && agent.teardownState !== "finalized"
+      && !activityTombstones.some(fence => fence.agentName === agent.name));
+    const runtimeOnlyCandidates = activityTeamName
+      ? await Promise.all(activityMembers
         .filter(member => member.name !== "team-lead")
         .filter(member => !runningReadAgents.has(readAgentKey(activityTeamName, member.name)))
         .map(async (member) => ({
           member,
           runtimeStatus: await runtime.readRuntimeStatus(activityTeamName, member.name).catch(() => null),
-        }))))
-        .filter((entry): entry is { member: Member; runtimeStatus: runtime.AgentRuntimeStatus } => isVisibleRuntimeOnlyMember(entry.member, entry.runtimeStatus, now))
-        .filter(({ member, runtimeStatus }) => member.lifecycleRunId === runtimeStatus.lifecycleRunId)
+        })))
       : [];
+    const runtimeOnlyMembers = runtimeOnlyCandidates
+      .filter((entry): entry is { member: Member; runtimeStatus: runtime.AgentRuntimeStatus } => isVisibleRuntimeOnlyMember(entry.member, entry.runtimeStatus, now))
+      .filter(({ member, runtimeStatus }) => member.lifecycleRunId === runtimeStatus.lifecycleRunId);
     const runtimeOnlyMemberNames = new Set(runtimeOnlyMembers.map(({ member }) => member.name));
     const runtimeOnlyReadMembers = runtimeOnlyMembers.filter(({ member }) => memberActivityRole(member) === "read");
     const runtimeOnlyWriteMembers = runtimeOnlyMembers.filter(({ member }) => memberActivityRole(member) === "write");
@@ -618,6 +661,11 @@ export default function (pi: ExtensionAPI) {
         .filter(member => member.name !== "team-lead" && member.isActive !== false && memberActivityRole(member) === "write")
         .filter(member => !!(member.tmuxPaneId && terminal?.isAlive?.(member.tmuxPaneId)) && !runningReadAgents.has(readAgentKey(activityTeamName, member.name)) && !runtimeOnlyMemberNames.has(member.name)) ?? []
       : [];
+    const unobservedMembers = runtimeOnlyCandidates.filter(({ member }) => member.isActive !== false
+      && !runtimeOnlyMemberNames.has(member.name)
+      && !activeWriteMembers.some(writer => writer.name === member.name)
+      && !activityTombstones.some(fence => fence.agentName === member.name));
+    const activeCount = runningAgents.length + runtimeOnlyMembers.length + activeWriteMembers.length + unobservedMembers.length;
     navigationRuntimeAgents.clear();
     for (const { member, runtimeStatus } of runtimeOnlyReadMembers) {
       if (member.lifecycleRunId === runtimeStatus.lifecycleRunId) {
@@ -633,11 +681,12 @@ export default function (pi: ExtensionAPI) {
     leadInboxUnreadCount = unreadLeadMessages.length;
     clearLeadInboxWidgetOnce();
 
-    if ((readAgents.length > 0 || writeAgents.length > 0 || runtimeOnlyReadMembers.length > 0 || runtimeOnlyWriteMembers.length > 0 || activeWriteMembers.length > 0 || activityTombstones.length > 0) && !readAgentStatusTimer) {
+    const hasVisibleAgents = activeCount > 0 || unsettledAgents.length > 0 || activityTombstones.length > 0;
+    if (hasVisibleAgents && !readAgentStatusTimer) {
       readAgentStatusTimer = setInterval(renderReadAgentStatus, 1000);
     }
 
-    if (readAgents.length === 0 && writeAgents.length === 0 && runtimeOnlyReadMembers.length === 0 && runtimeOnlyWriteMembers.length === 0 && activeWriteMembers.length === 0 && activityTombstones.length === 0) {
+    if (!hasVisibleAgents) {
       sessionCtx.ui.setStatus?.("01-pi-extended-teams-read", undefined);
       clearTeamActivityWidget();
       sessionCtx.ui.setWidget?.("01-pi-extended-teams-status", undefined);
@@ -648,7 +697,6 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    const activeCount = readAgents.length + writeAgents.length + runtimeOnlyReadMembers.length + runtimeOnlyWriteMembers.length + activeWriteMembers.length;
     const entries: TeamActivityStatusEntry[] = [];
     const footerStatuses: string[] = [];
     const statusCounts: Record<string, number> = {};
@@ -742,16 +790,43 @@ export default function (pi: ExtensionAPI) {
       footerStatuses.push(formatAgentProgressStatus(agent.name, agent.model, agent.thinking, agent.modelSlot, elapsed, contextUsage, agent.latestProgress, now));
     }
 
+    for (const { member, runtimeStatus } of unobservedMembers) {
+      const projected = projectAgentStatus({ member, runtime: runtimeStatus, fence: { status: "absent" }, terminalAlive: null, now });
+      const telemetry = !projected.runtime ? "runtime telemetry unavailable"
+        : runtimeHeartbeatIsRecent(projected.runtime, now) ? "awaiting runtime readiness" : "heartbeat stale";
+      countStatus(projected.phase);
+      entries.push({ name: member.name, role: memberActivityRole(member), status: projected.phase, detail: telemetry });
+      footerStatuses.push(`(${member.name}) ${projected.phase} · ${telemetry}`);
+    }
+
+    for (const agent of unsettledAgents) {
+      const status = agent.teardownState === "persistence_failed" ? "persistence-failed"
+        : agent.teardownState === "quarantined" ? "quarantined" : "stopping";
+      const reason = agent.teardownError instanceof Error ? agent.teardownError.message
+        : agent.teardownResult?.error || "cleanup has not settled";
+      const detail = status === "stopping" ? "Finishing cleanup" : `Cleanup blocked: ${reason} · use check_teammate`;
+      countStatus(status);
+      entries.push({ name: agent.name, role: agent.role === "write" ? "write" : "read", status, detail });
+    }
+
     for (const { agentName: quarantinedName, result } of activityTombstones) {
+      if (result.status === "occupied" && result.tombstone.phase === "persistence_closed"
+        && runningAgents.some(agent => agent.name === quarantinedName && agent.runId === result.tombstone.runId)) {
+        const entryIndex = entries.findIndex(entry => entry.name === quarantinedName);
+        footerStatuses[entryIndex] += " · Finishing cleanup";
+        continue;
+      }
       const persistedMember = activityMembers.find(member => member.name === quarantinedName);
       const role = result.status === "occupied"
         ? result.tombstone.role
         : persistedMember ? memberActivityRole(persistedMember) : "read";
-      const detail = result.status === "occupied"
-        ? `inactive · run ${result.tombstone.runId} · ${result.tombstone.phase}`
-        : `inactive · corrupt lifecycle tombstone · ${result.error}`;
-      countStatus("quarantined");
-      entries.push({ name: quarantinedName, role, status: "quarantined", detail });
+      const projected = projectLifecycleFence(persistedMember ?? {}, result);
+      const reason = projected.error || (result.status === "occupied" && result.tombstone.phase === "timed_out" ? "cleanup timed out" : "cleanup failed");
+      const detail = projected.phase === "stopping"
+        ? "Finishing cleanup"
+        : `Cleanup blocked: ${reason} · use check_teammate`;
+      countStatus(projected.phase);
+      entries.push({ name: quarantinedName, role, status: projected.phase, detail });
     }
 
     wakeLeadForIdleReadAgents(idleNudgeMessages);
@@ -762,8 +837,8 @@ export default function (pi: ExtensionAPI) {
     sessionCtx.ui.setWidget?.("01-pi-extended-teams-status", undefined);
     updateTeamActivityWidget({
       activeCount,
-      readCount: readAgents.length + runtimeOnlyReadMembers.length,
-      writeCount: writeAgents.length + runtimeOnlyWriteMembers.length + activeWriteMembers.length,
+      readCount: readAgents.length + runtimeOnlyReadMembers.length + unobservedMembers.filter(({ member }) => memberActivityRole(member) === "read").length,
+      writeCount: writeAgents.length + runtimeOnlyWriteMembers.length + activeWriteMembers.length + unobservedMembers.filter(({ member }) => memberActivityRole(member) === "write").length,
       unreadCount: leadInboxUnreadCount,
       entries,
       statusCounts,
@@ -951,7 +1026,7 @@ export default function (pi: ExtensionAPI) {
       try {
         const unread = await messaging.readInbox(teamName, agentName, true, false);
         await renderLeadInboxStatus();
-        wakeLeadForInboxReports(unread);
+        await wakeLeadForInboxReports(unread);
       } catch {
         // Ignore errors for lead polling
       }
@@ -965,10 +1040,12 @@ export default function (pi: ExtensionAPI) {
   function adoptTeamAsLead(name: string, ctx?: any): void {
     if (isTeammate || !name) return;
     const sessionId = getPiSessionId(ctx ?? sessionCtx);
+    registerLeadSession(name, sessionId);
+    // Private jobs retain cleanup ownership, not the public roster/inbox/UI scope.
+    if (name.startsWith("prompt-build-")) return;
     if (teamName !== name) {
       teamName = name;
     }
-    registerLeadSession(name, sessionId);
     ensureReadAgentStatusTicker();
     startLeadInboxPolling();
     startReadHelperQueueDraining();
@@ -1091,6 +1168,7 @@ export default function (pi: ExtensionAPI) {
     try {
       await stopRunningAgentsForShutdown(reason);
     } finally {
+      combinedSessionCost?.deactivate();
       activeAgentSleepController.dispose();
     }
 
@@ -1121,14 +1199,23 @@ export default function (pi: ExtensionAPI) {
   });
 
   if (!isTeammate) {
+    pi.on("context", async (_event: any, ctx: any) => { await observeGroupHistory(ctx); });
     pi.on("session_start", async (_event: any, ctx: any) => {
+      await observeGroupHistory(ctx);
+      if (teamName) {
+        try {
+          const config = await teams.readConfig(teamName);
+          for (const error of await recoverCompletionGroups(teamName, getPiSessionId(ctx) ?? "", config.members, sessionEntries(ctx), currentCompletionGroups)) warnGroup(error);
+          await requestGroupInboxWakes(await messaging.peekInbox(teamName, agentName, true));
+        } catch (error) { warnGroup(error); }
+      }
       installAgentNavigation(ctx, {
         getAgents: () => {
           const readers = Array.from(runningReadAgents.values())
             .filter(agent => !teamName || agent.teamName === teamName);
-          return [...readers, ...Array.from(navigationRuntimeAgents.values())
-            .filter(agent => !teamName || agent.teamName === teamName)]
-            .filter((agent, index, agents) => agents.findIndex(candidate => candidate.name === agent.name) === index);
+          const runtimeAgents = Array.from(navigationRuntimeAgents.values())
+            .filter(agent => !teamName || agent.teamName === teamName);
+          return orderAgentNavigationEntries(readers, runtimeAgents);
         },
         interruptAgent: async (name: string) => {
           const result = await interruptTeammate(name);
@@ -1188,6 +1275,8 @@ export default function (pi: ExtensionAPI) {
 
   registerFavoriteModelsCommand(pi);
   registerExtensionsCommand(pi);
+  if (!isTeammate) registerOnboardingCommand(pi);
+  if (!isTeammate) registerCheckpointsCommand(pi);
 
   registerWriterScreenShortcut(pi, {
     getTeamName: () => teamName,
@@ -1218,7 +1307,11 @@ export default function (pi: ExtensionAPI) {
       createNestedReadAgentTools: (binding: Parameters<TeamToolsRuntime["createNestedReadAgentTools"]>[0]) => {
         return teamToolsRuntime?.createNestedReadAgentTools(binding) ?? [];
       },
+      nestedChildSnapshot: (binding: Parameters<TeamToolsRuntime["nestedChildSnapshot"]>[0]) => {
+        return teamToolsRuntime?.nestedChildSnapshot(binding) ?? { running: 0, queued: 0 };
+      },
       pendingChildController,
+      beginCostRun: combinedSessionCost?.begin,
     };
   }
 
@@ -1233,6 +1326,7 @@ export default function (pi: ExtensionAPI) {
     startWriteAgent,
     shutdownTeammate,
     adoptTeamAsLead,
+    onCompletionGroupUse: groupId => { currentCompletionGroups.add(groupId); },
     buildRoster,
     isTeammate,
     agentName,

package/extensions/internal/pi-check-operations.ts

@@ -0,0 +1,24 @@
+import type { CheckOperations } from "../../src/results/check-runner";
+import { loadPiRuntimeApi } from "./pi-runtime-api";
+
+export async function loadNativeCheckOperations(suppliedApi?: unknown): Promise<CheckOperations | undefined> {
+  const api: unknown = suppliedApi === undefined ? await loadPiRuntimeApi() : suppliedApi;
+  if (typeof api !== "object" || api === null) return undefined;
+  const factory: unknown = Reflect.get(api, "createLocalBashOperations");
+  if (typeof factory !== "function") return undefined;
+  const operations: unknown = factory();
+  if (typeof operations !== "object" || operations === null) return undefined;
+  const exec: unknown = Reflect.get(operations, "exec");
+  if (typeof exec !== "function") return undefined;
+  return {
+    async exec(command, cwd, options) {
+      const result: unknown = await Reflect.apply(exec, operations, [command, cwd, options]);
+      if (typeof result !== "object" || result === null) throw new Error("Native check returned no exit evidence.");
+      const exitCode: unknown = Reflect.get(result, "exitCode");
+      if (exitCode !== null && (typeof exitCode !== "number" || !Number.isInteger(exitCode))) {
+        throw new Error("Native check returned invalid exit evidence.");
+      }
+      return { exitCode };
+    },
+  };
+}

package/extensions/internal/session-files.ts

@@ -31,18 +31,22 @@ export function findLeadTeamForSession(sessionId?: string): string | null {
     const teamsDir = path.dirname(paths.teamDir("__probe__"));
     if (!fs.existsSync(teamsDir)) return null;
 
+    let latest: { name: string; selectedAt: number } | undefined;
     for (const teamDir of fs.readdirSync(teamsDir)) {
+      if (teamDir.startsWith("prompt-build-")) continue;
       try {
         const sessionFile = paths.leadSessionPath(teamDir);
         if (!fs.existsSync(sessionFile)) continue;
         const session = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
         if (session.sessionId === sessionId && session.pid === process.pid) {
-          return teamDir;
+          const selectedAt = typeof session.startedAt === "number" && Number.isFinite(session.startedAt) ? session.startedAt : 0;
+          if (!latest || selectedAt > latest.selectedAt) latest = { name: teamDir, selectedAt };
         }
       } catch {
         // ignore entries that are not valid team names, and invalid session files
       }
     }
+    return latest?.name ?? null;
   } catch {
     // ignore errors
   }
@@ -50,13 +54,17 @@ export function findLeadTeamForSession(sessionId?: string): string | null {
 }
 
 export function registerLeadSession(teamName: string, sessionId?: string) {
+  const previousTeam = findLeadTeamForSession(sessionId);
+  const previous = previousTeam ? readJsonFile(paths.leadSessionPath(previousTeam)) : null;
+  // Ownership selections stay ordered even when two adoptions share a clock tick.
+  const selectedAt = Math.max(Date.now(), typeof previous?.startedAt === "number" && Number.isFinite(previous.startedAt) ? previous.startedAt + 1 : 0);
   const sessionFile = paths.leadSessionPath(teamName);
   const dir = path.dirname(sessionFile);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(sessionFile, JSON.stringify({
     pid: process.pid,
     sessionId,
-    startedAt: Date.now(),
+    startedAt: selectedAt,
   }));
 }
 

package/extensions/runtime/teammate-interrupt.ts

@@ -12,7 +12,7 @@ export interface TeammateInterruptResult {
   message: string;
   agentKind?: "read" | "write";
   lifecycleRunId?: string;
-  mechanism?: "agent-session-abort" | "tmux-escape";
+  mechanism?: "agent-session-abort" | "assigned-check-abort" | "tmux-escape";
   reason?: "no-active-session" | "session-not-created" | "lifecycle-closing"
     | "missing-pane" | "missing-runtime-proof" | "terminal-interrupt-unavailable";
   error?: string;
@@ -73,15 +73,18 @@ async function interruptReadAgent(
   }
 
   const generation = state.activeOperationGeneration;
+  const checkOperation = state.checkOperation;
   const toolName = state.activeToolName?.trim();
-  if (!generation || !toolName || state.status !== "working" || !state.session.isStreaming) {
+  if (!toolName || state.status !== "working" || (!checkOperation && (!generation || !state.session.isStreaming))) {
     return result("no_command", state.name, `Agent ${state.name} has no running tool command to interrupt.`, fields);
   }
   if (state.operationInterruptPromise) {
     return result("pending", state.name, `An interrupt is already pending for ${state.name}'s running ${toolName} command.`, fields);
   }
 
-  const operationSettlement = state.activeOperationSettlementPromise;
+  const operationSettlement = checkOperation
+    ? Promise.all([checkOperation.settled, state.activeOperationSettlementPromise]).then(() => {})
+    : state.activeOperationSettlementPromise;
   if (!operationSettlement) {
     return result("no_command", state.name, `Agent ${state.name} has no running tool command to interrupt.`, fields);
   }
@@ -89,7 +92,10 @@ async function interruptReadAgent(
   state.interruptRequestedGeneration = generation;
   let nativeAbort: Promise<void>;
   try {
-    nativeAbort = Promise.resolve(state.session.abort());
+    checkOperation?.controller.abort();
+    nativeAbort = checkOperation && !state.session.isStreaming
+      ? Promise.resolve()
+      : Promise.resolve(state.session.abort());
   } catch (error) {
     if (state.interruptRequestedGeneration === generation) state.interruptRequestedGeneration = undefined;
     const message = errorText(error);
@@ -130,7 +136,7 @@ async function interruptReadAgent(
     });
   }
   return result("interrupted", state.name, `Interrupted ${state.name}'s running ${toolName} command. The agent is still active and can receive a follow-up message.`, {
-    ...fields, mechanism: "agent-session-abort",
+    ...fields, mechanism: checkOperation ? "assigned-check-abort" : "agent-session-abort",
   });
 }
 

package/extensions/runtime/types.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { ReportResult } from "../../src/results/report-result";
 import type { ContextUsageSnapshot, RuntimeError } from "../../src/utils/runtime";
 import type { ManagedReadAgentLifecycleState } from "../agents/read-agent-session-lifecycle";
 
@@ -46,6 +47,8 @@ export interface RunningReadAgent extends ManagedReadAgentLifecycleState {
   cleanupPrivateSessionOnFinalize?: boolean;
   /** Fail finalization closed so runtime, member, fence, and transcript remain recoverable. */
   finalizationBlockedReason?: string;
+  /** Optional accounting observer, called only after exact successful lifecycle settlement. */
+  onCostSettled?(): void;
   session?: AgentSession;
   moveToHerdr?(): Promise<void>;
   finished?: Promise<void>;
@@ -63,6 +66,7 @@ export interface CompletedAgentReport {
   name: string;
   role: string;
   status: "completed" | "failed";
+  result?: ReportResult;
   report: string;
   summary?: string;
   completedAt: number;

package/extensions/team/lifecycle.ts

@@ -4,6 +4,12 @@ import * as paths from "../../src/utils/paths";
 import * as runtime from "../../src/utils/runtime";
 import * as messaging from "../../src/utils/messaging";
 import * as teams from "../../src/utils/teams";
+import { readStoredTeamReportEvent } from "../../src/utils/report-events";
+import { resyncReportCheckpoint } from "../../src/results/checkpoint-report";
+import { createReportResult } from "../../src/results/report-result";
+import { VerificationController } from "../../src/results/verification-controller";
+import { CompletionGroup } from "../../src/results/completion-group";
+import { enqueueCompletionGroupDeliveries } from "../../src/results/completion-group-delivery";
 import { loadSettings } from "../../src/utils/settings";
 import type { Member } from "../../src/utils/models";
 import type { RunningReadAgent } from "../runtime/types";
@@ -259,6 +265,25 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
             return;
           }
 
+          const bound = createReportResult(teamName, member.name, expectedRunId, {});
+          const report = await readStoredTeamReportEvent(teamName, bound.reportId);
+          const result = { ...bound, verification: report?.result?.verification ?? bound.verification, repair: report?.result?.repair };
+          const candidate = currentMember ?? member;
+          const controller = new VerificationController({ teamName, result, cwd: candidate.cwd,
+            checks: candidate.assignedChecks, repair: candidate.repairPolicy });
+          if (candidate.repairPolicy || result.repair || fs.existsSync(controller.journalPath)) {
+            await controller.cancelAndRequireSettled();
+          }
+          if ((candidate.checkpointAssignment || member.checkpointAssignment) && !report?.checkpoint) throw new Error("Checkpoint report provenance is unavailable.");
+          if (report?.checkpoint) await resyncReportCheckpoint(report);
+          const groupBinding = candidate.completionGroup ?? member.completionGroup ?? report?.completionGroup;
+          if (groupBinding) {
+            const group = new CompletionGroup(teamName, groupBinding.groupId);
+            if (report?.result) await group.recordReport(groupBinding.slotId, report.result, report.status);
+            else await group.apply({ type: reason === "quit" ? "cancelled" : "interrupted", ...groupBinding,
+              runId: expectedRunId, reason: `Agent lifecycle ended (${reason}) without a final report.` });
+            await enqueueCompletionGroupDeliveries(group);
+          }
           releasedClaims = await releaseClaims(teamName, member.name);
 
           // Private transcript cleanup is the first destructive recovery step.
@@ -327,6 +352,7 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
       if (drainQueue && (member.role ?? "write") === "write") {
         void options.drainWriteQueue(teamName).catch(() => {});
       }
+      try { expectedState?.onCostSettled?.(); } catch { /* Accounting cannot alter settlement. */ }
       try {
         options.onTeammateSettled?.(teamName, { ...member, lifecycleRunId: expectedRunId });
       } catch {