pi-extended-teams 2.2.10 → 2.3.1

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/lead-attachment.ts

@@ -0,0 +1,91 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { TSchema } from "@sinclair/typebox";
+import { Key } from "@mariozechner/pi-tui";
+import { connectReloadOwner, type ReloadOwner } from "./reload-owner";
+import { createTeamHost, type TeamHostBinding } from "./team-host";
+import { registerAgentReportRenderer } from "../events/register-events";
+import { publicTeamToolMetadata } from "../tools/public-team-tools";
+import { registerCoordinationTools, type CoordinationToolsOptions } from "../tools/coordination-tools";
+import { registerTaskRuntimeTools, type TaskRuntimeToolsOptions } from "../tools/task-runtime-tools";
+import { registerFavoriteModelsCommand } from "../ui/favorite-models-command";
+import { registerExtensionsCommand } from "../ui/extensions-command";
+import { registerOnboardingCommand } from "../ui/onboarding-command";
+import { registerCheckpointsCommand } from "../ui/checkpoints-command";
+
+export interface TeamExecutionOwner extends ReloadOwner<TeamHostBinding> {
+  host: ReturnType<typeof createTeamHost>;
+  coordination: CoordinationToolsOptions;
+  taskTools: TaskRuntimeToolsOptions;
+  activate(): void;
+}
+
+export function registerLeadAttachment(pi: ExtensionAPI, createOwner: () => TeamExecutionOwner): void {
+  let connection: Awaited<ReturnType<typeof connectReloadOwner<TeamHostBinding>>> | undefined;
+  let attaching: Promise<void> | undefined;
+  const attach = (ctx: any, event: any): Promise<void> => {
+    if (connection) return Promise.resolve();
+    return attaching ??= connectReloadOwner(ctx.sessionManager, ctx.sessionManager.getSessionId(), { pi, ctx, event }, createOwner)
+      .then(value => { connection = value; execution().activate(); }).finally(() => { attaching = undefined; });
+  };
+  const execution = (): TeamExecutionOwner => {
+    if (!connection) throw new Error("Team execution is not attached to this session.");
+    return connection.owner as TeamExecutionOwner;
+  };
+
+  for (const metadata of Object.values(publicTeamToolMetadata)) {
+    pi.registerTool<TSchema>({ ...metadata, async execute(id, params, signal, update, ctx) {
+      await attach(ctx, { reason: "startup" });
+      const owner = execution();
+      return owner.host.tools.get(metadata.name).execute(id, params, signal, update, owner.host.snapshot(ctx));
+    } });
+  }
+  // These lead-only adapters carry no running task state. In-process child
+  // tools remain owned by the retained controller and its original imports.
+  registerCoordinationTools(pi, {
+    isTeammate: false, agentName: "team-lead",
+    get terminal() { return execution().coordination.terminal; },
+    getTeamName: () => execution().coordination.getTeamName(),
+    requireWriteAgentTeam: () => execution().coordination.requireWriteAgentTeam(),
+    requireTeamContext: name => execution().coordination.requireTeamContext(name),
+    releaseAllClaimsForAgent: (...args) => execution().coordination.releaseAllClaimsForAgent(...args),
+    drainWriteQueue: name => execution().coordination.drainWriteQueue(name),
+    resolveSkillFile: (...args) => execution().coordination.resolveSkillFile(...args),
+    adoptTeamAsLead: (name, ctx) => execution().coordination.adoptTeamAsLead(name, ctx && execution().host.snapshot(ctx)),
+    renderLeadInboxStatus: () => execution().coordination.renderLeadInboxStatus(),
+    resetLeadWakeNotifiedCount: () => execution().coordination.resetLeadWakeNotifiedCount(),
+    deliverMessageToActiveAgent: (...args) => execution().coordination.deliverMessageToActiveAgent!(...args),
+  });
+  registerTaskRuntimeTools(pi, {
+    isTeammate: false,
+    get terminal() { return execution().taskTools.terminal; },
+    get runningReadAgents() { return execution().taskTools.runningReadAgents; },
+    readAgentKey: (...args) => execution().taskTools.readAgentKey(...args),
+    getTeamName: () => execution().taskTools.getTeamName(),
+    interruptTeammate: name => execution().taskTools.interruptTeammate!(name),
+    cancelQueuedAgent: (...args) => execution().taskTools.cancelQueuedAgent!(...args),
+    shutdownTeammate: (...args) => execution().taskTools.shutdownTeammate(...args),
+  });
+  registerAgentReportRenderer(pi);
+  registerFavoriteModelsCommand(pi);
+  registerExtensionsCommand(pi);
+  registerOnboardingCommand(pi);
+  registerCheckpointsCommand(pi);
+  pi.registerShortcut(Key.alt("tab"), {
+    description: "Cycle active writer-agent tmux screens",
+    handler: ctx => execution().host.shortcuts.get(Key.alt("tab"))?.handler(execution().host.snapshot(ctx)),
+  });
+
+  pi.on("session_start", (event, ctx) => attach(ctx, event));
+  pi.on("session_shutdown", async event => {
+    const current = connection;
+    connection = undefined;
+    await current?.shutdown(event.reason ?? "quit");
+  });
+  for (const name of ["context", "turn_start", "tool_execution_start", "tool_execution_end", "message_end", "turn_end",
+    "before_agent_start", "agent_end", "agent_settled", "session_compact", "session_tree"] as const) {
+    (pi.on as any)(name, (event: unknown, ctx: unknown) => {
+      const owner = execution();
+      return owner.host.emit(name, event, owner.host.snapshot(ctx));
+    });
+  }
+}

package/extensions/runtime/reload-owner.ts

@@ -0,0 +1,107 @@
+export interface ReloadOwner<Attachment> {
+  attach(attachment: Attachment): void | Promise<void>;
+  detach(): void;
+  close(reason: string): Promise<void>;
+  hasWork(): boolean;
+}
+
+interface RetainedOwner {
+  owner: ReloadOwner<unknown>;
+  state: "attaching" | "attached" | "detached" | "closing";
+  generation: number;
+  deadline?: number;
+  timer?: ReturnType<typeof setTimeout>;
+  closing?: Promise<void>;
+}
+
+interface Registry {
+  version: 1;
+  sessions: WeakMap<object, Map<string, RetainedOwner>>;
+}
+
+const REGISTRY_KEY = Symbol.for("pi-extended-teams.reload-owners.v1");
+const RECOVERY_WINDOW_MS = 60_000;
+
+// Pi re-evaluates modules on reload, but keeps the Node realm and (in the
+// supported host) the root SessionManager. Session IDs alone can collide
+// between two independent hosts opening the same saved conversation.
+function registry(): Registry {
+  const globals = globalThis as typeof globalThis & { [REGISTRY_KEY]?: Registry };
+  return globals[REGISTRY_KEY] ??= { version: 1, sessions: new WeakMap() };
+}
+
+export async function connectReloadOwner<Attachment>(
+  manager: object,
+  sessionId: string,
+  attachment: Attachment,
+  createOwner: () => ReloadOwner<Attachment>,
+): Promise<{ owner: ReloadOwner<Attachment>; shutdown(reason: string): Promise<void> }> {
+  const sessions = registry().sessions;
+  let owners = sessions.get(manager);
+  if (!owners) sessions.set(manager, owners = new Map());
+  let record = owners.get(sessionId);
+  if (record && record.state !== "detached") {
+    throw new Error(`Team execution owner is ${record.state}; refusing a replacement.`);
+  }
+  if (!record) {
+    record = { owner: createOwner() as ReloadOwner<unknown>, state: "attaching", generation: 0 };
+    owners.set(sessionId, record);
+  }
+  const current = record;
+  const generation = ++current.generation;
+  current.state = "attaching";
+
+  const close = (reason: string): Promise<void> => {
+    if (current.closing) return current.closing;
+    current.state = "closing";
+    current.generation++;
+    clearTimeout(current.timer);
+    current.closing = Promise.resolve().then(() => current.owner.close(reason)).then(() => {
+      if (owners.get(sessionId) === current) owners.delete(sessionId);
+    });
+    return current.closing;
+  };
+  const armDeadline = (): void => {
+    clearTimeout(current.timer);
+    const epoch = current.generation;
+    current.timer = setTimeout(() => {
+      if (current.generation !== epoch || current.state === "attached") return;
+      // A failed cleanup remains in the registry as a fence. Durable lifecycle
+      // records retain the cleanup evidence; do not silently replace this owner.
+      void close("reload-timeout").catch(() => {});
+    }, Math.max(0, (current.deadline ?? Date.now()) - Date.now()));
+    current.timer.unref?.();
+  };
+
+  const isClosing = () => current.state === "closing";
+  if (current.deadline !== undefined) armDeadline();
+  try {
+    await current.owner.attach(attachment);
+    if (current.generation !== generation || current.state !== "attaching") {
+      throw new Error("Team reload attachment expired while reconnecting.");
+    }
+    clearTimeout(current.timer);
+    current.deadline = undefined;
+    current.state = "attached";
+  } catch (error) {
+    if (!isClosing()) {
+      current.owner.detach();
+      current.state = "detached";
+      current.deadline ??= Date.now() + RECOVERY_WINDOW_MS;
+      armDeadline();
+    }
+    throw error;
+  }
+
+  return {
+    owner: current.owner as ReloadOwner<Attachment>,
+    async shutdown(reason) {
+      if (current.generation !== generation || current.state !== "attached") return;
+      if (reason !== "reload" || !current.owner.hasWork()) return close(reason);
+      current.owner.detach();
+      current.state = "detached";
+      current.deadline = Date.now() + RECOVERY_WINDOW_MS;
+      armDeadline();
+    },
+  };
+}

package/extensions/runtime/team-host.ts

@@ -0,0 +1,124 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+type Handler = (...args: any[]) => any;
+export interface TeamHostBinding { pi: ExtensionAPI; ctx: any; event: any }
+
+// Explicit root-facing capabilities used by the execution owner. This is not
+// an ExtensionAPI proxy: registrations are data, and detached sends are kept
+// separate from native agent work and its raw delivery promises.
+export function createTeamHost() {
+  let binding: TeamHostBinding | undefined;
+  let generation = 0;
+  let ready = false;
+  let closed = false;
+  const handlers = new Map<string, Handler[]>();
+  const tools = new Map<string, any>();
+  const shortcuts = new Map<string, any>();
+  const subscriptions = new Set<{ name: string; handler: Handler; unsubscribe?: () => void }>();
+  const pending: Array<(pi: ExtensionAPI) => void> = [];
+  const waiters = new Set<{ resolve(): void; reject(error: Error): void }>();
+  const current = () => {
+    if (!binding) throw new Error("The team host is detached during reload.");
+    return binding;
+  };
+  function send(action: (pi: ExtensionAPI) => void) {
+    if (binding && ready) action(binding.pi);
+    else if (!closed) pending.push(action);
+  }
+  const api = {
+    on(name: string, handler: Handler) { handlers.set(name, [...(handlers.get(name) ?? []), handler]); },
+    registerTool(tool: any) { tools.set(tool.name, tool); },
+    registerCommand() {},
+    registerShortcut(key: string, shortcut: any) { shortcuts.set(key, shortcut); },
+    getCommands: () => current().pi.getCommands(),
+    getAllTools: () => current().pi.getAllTools(),
+    appendEntry: (...args: Parameters<ExtensionAPI["appendEntry"]>) => current().pi.appendEntry(...args),
+    sendUserMessage: (...args: Parameters<ExtensionAPI["sendUserMessage"]>) => send(pi => pi.sendUserMessage(...args)),
+    sendMessage: (...args: Parameters<ExtensionAPI["sendMessage"]>) => send(pi => {
+      if (typeof pi.sendMessage === "function") pi.sendMessage(...args);
+      else pi.sendUserMessage(args[0].content);
+    }),
+    events: {
+      emit(name: string, payload: unknown) { send(pi => pi.events.emit(name, payload)); },
+      on(name: string, handler: Handler) {
+        const subscription = { name, handler, unsubscribe: binding?.pi.events.on(name, handler) };
+        subscriptions.add(subscription);
+        return () => { subscription.unsubscribe?.(); subscriptions.delete(subscription); };
+      },
+    },
+  };
+  function detach() {
+    ready = false;
+    binding = undefined;
+    generation++;
+    for (const subscription of subscriptions) {
+      subscription.unsubscribe?.();
+      subscription.unsubscribe = undefined;
+    }
+  }
+  function snapshot(ctx: any) {
+    const epoch = generation;
+    const available = () => binding && generation === epoch;
+    const ui: Record<string, unknown> = {};
+    for (const name of ["notify", "setStatus", "setWidget", "setTitle", "setEditorComponent", "setWorkingMessage", "setHeader", "setFooter"]) {
+      ui[name] = (...args: unknown[]) => { if (available()) return binding!.ctx.ui?.[name]?.(...args); };
+    }
+    for (const name of ["custom", "select", "confirm", "input", "editor", "getEditorComponent", "getToolsExpanded"]) {
+      ui[name] = (...args: unknown[]) => { if (available()) return binding!.ctx.ui?.[name]?.(...args); };
+    }
+    Object.defineProperty(ui, "theme", { get: () => available() ? binding!.ctx.ui?.theme : undefined });
+    const trusted = ctx.isProjectTrusted?.() === true;
+    return {
+      cwd: ctx.cwd, sessionManager: ctx.sessionManager, modelRegistry: ctx.modelRegistry,
+      model: ctx.model, thinkingLevel: ctx.thinkingLevel, hasUI: ctx.hasUI, mode: ctx.mode, ui,
+      isProjectTrusted: () => trusted,
+      isIdle: () => available() ? binding!.ctx.isIdle() : false,
+      getContextUsage: () => available() ? binding!.ctx.getContextUsage?.() : undefined,
+      getSystemPrompt: () => available() ? binding!.ctx.getSystemPrompt?.() : "",
+      shutdown: () => { if (available()) return binding!.ctx.shutdown(); },
+    };
+  }
+  return {
+    api, tools, shortcuts, snapshot,
+    get attached() { return !!binding; },
+    get ready() { return ready && !!binding; },
+    get context() { return binding ? snapshot(binding.ctx) : undefined; },
+    attach(next: TeamHostBinding) {
+      if (closed) throw new Error("The team execution owner is closing.");
+      binding = next;
+      ready = false;
+      generation++;
+      for (const subscription of subscriptions) subscription.unsubscribe = next.pi.events.on(subscription.name, subscription.handler);
+    },
+    detach,
+    async emit(name: string, event: any, ctx: any) {
+      let result: any;
+      for (const handler of handlers.get(name) ?? []) {
+        const value = await handler(event, ctx);
+        if (value !== undefined) result = value;
+      }
+      return result;
+    },
+    flush() {
+      ready = !!binding && !closed;
+      while (ready && binding && pending.length) {
+        const action = pending.shift()!;
+        // Remove before invoking: a thrown/uncertain host send is not replayed.
+        try { action(binding.pi); }
+        catch (error) { binding.ctx.ui?.notify?.(`Team delivery needs attention: ${String(error)}. Read the saved inbox/reports.`, "warning"); }
+      }
+      if (binding) { for (const waiter of waiters) waiter.resolve(); waiters.clear(); }
+    },
+    whenAttached(): Promise<void> {
+      if (closed) return Promise.reject(new Error("Team execution is closing."));
+      if (binding && ready) return Promise.resolve();
+      return new Promise((resolve, reject) => waiters.add({ resolve, reject }));
+    },
+    close() {
+      closed = true;
+      detach();
+      for (const waiter of waiters) waiter.reject(new Error("Team reload recovery expired or the session closed."));
+      waiters.clear();
+    },
+  };
+}

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 {