pi-maestro-teammate 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-maestro-teammate",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Pi extension — teammate agent dispatch with DAG task graphs, RPC messaging, and compact TUI",
   "type": "module",
   "keywords": [

package/src/extension/index.ts

@@ -127,6 +127,7 @@ import {
   getTeammatePermissionBroker,
   registerTeammateChildProxyCaller,
 } from "../runs/child-extensions.ts";
+import { setQuietMode } from "../quiet-state.ts";
 
 export const TEAMMATE_PROMPT_SNIPPET =
   "Dispatch bounded work to discovered teammate roles for parallel, sequential, or specialist execution.";
@@ -146,7 +147,10 @@ export const TEAMMATE_PROMPT_GUIDELINES = [
 ];
 
 function displayMessageForResult(result: SingleResult): string {
-  const lastMessage = result.messages.at(-1)?.content ?? "(no output)";
+  const lastMessage = result.messages.at(-1)?.content
+    ?? (result.structuredOutput !== undefined
+      ? `[structured_output] ${truncateUtf8Tail(JSON.stringify(result.structuredOutput), 512)}`
+      : "(no output)");
   if (result.exitCode === 0) return lastMessage;
 
   const schemaDiagnostic = result.messages
@@ -1812,6 +1816,7 @@ export default function registerTeammateExtension(
               .map((name) => taskIndexByName.get(name))
               .filter((dependency): dependency is number => dependency !== undefined),
             status: "pending",
+            requestedModel: task.model,
           });
         });
       }
@@ -1840,6 +1845,7 @@ export default function registerTeammateExtension(
         inbox: [],
         outputLog: [],
         lastActivityAt: Date.now(),
+        requestedModel: isMultiTask ? undefined : singleTask.model,
         replyTo: params.reply_to,
         // Root-tool dispatches start the tree.
         depth: 0,
@@ -1891,6 +1897,7 @@ export default function registerTeammateExtension(
             inbox: [],
             outputLog: [],
             lastActivityAt: Date.now(),
+            requestedModel: task.model,
             spawnedBy: correlationId,
             // Graph tasks belong to their dispatch, so they share its depth;
             // a teammate call made *by* one of them is what advances it.
@@ -1953,15 +1960,18 @@ export default function registerTeammateExtension(
           }),
           onRetry: (retry) => applyAgentRetryState(state, retry),
           onTurnComplete: (result: SingleResult) => {
-          const lastMessage = displayMessageForResult(result);
-          const settle = isMultiTask ? settleGraphTaskAgent : settleAgent;
-          settle(
-            state,
-            result.correlationId,
-            result.exitCode,
-            lastMessage,
-            result.wakeable !== false,
-          );
+            const target = state.activeRuns.get(result.correlationId) ?? activeAgent;
+            target.resolvedModel = target.resolvedModel ?? result.model;
+            if (result.attemptedModels) target.attemptedModels = [...result.attemptedModels];
+            const lastMessage = displayMessageForResult(result);
+            const settle = isMultiTask ? settleGraphTaskAgent : settleAgent;
+            settle(
+              state,
+              result.correlationId,
+              result.exitCode,
+              lastMessage,
+              result.wakeable !== false,
+            );
           },
           onProgress: (() => {
           const UPDATE_INTERVAL = 300; // ms — throttle TUI updates
@@ -2001,6 +2011,9 @@ export default function registerTeammateExtension(
               durationMs: data.durationMs,
               lastActivityAt: data.lastActivityAt,
               resultReadyAt: data.resultReadyAt,
+              requestedModel: data.requestedModel ?? existing?.requestedModel,
+              resolvedModel: data.resolvedModel ?? existing?.resolvedModel,
+              attemptedModels: data.attemptedModels ?? existing?.attemptedModels,
               ...(data.lastMessage
                 ? { lastMessage: truncateUtf8Tail(data.lastMessage, AGENT_BUFFER_LIMITS.lastResultBytes) }
                 : {}),
@@ -2018,6 +2031,11 @@ export default function registerTeammateExtension(
               clearAgentResultReadyState(state, entry.correlationId);
             }
             const childAgent = state.activeRuns.get(entry.correlationId);
+            if (childAgent) {
+              childAgent.requestedModel = entry.requestedModel ?? childAgent.requestedModel;
+              childAgent.resolvedModel = entry.resolvedModel ?? childAgent.resolvedModel;
+              childAgent.attemptedModels = entry.attemptedModels ?? childAgent.attemptedModels;
+            }
             if (childAgent && childAgent !== activeAgent) {
               childAgent.lastActivityAt = Date.now();
               childAgent.status = entry.status === "completed" ? "sleeping" : entry.status;
@@ -2251,7 +2269,8 @@ export default function registerTeammateExtension(
               settleAgent(state, correlationId, exitCode, summaries, params.context !== "fork");
               emitComplete(pi, id, activeGraphMode, correlationId, exitCode, totalDur);
 
-              pi.sendMessage(
+              safeSendMessage(
+                pi,
                 {
                   customType: "teammate-complete",
                   content: summaries,
@@ -2386,7 +2405,8 @@ export default function registerTeammateExtension(
             if (!result.lifecyclePending) {
               settleAgent(state, correlationId, result.exitCode, lastMsg, result.wakeable !== false);
             }
-            pi.sendMessage(
+            safeSendMessage(
+              pi,
               {
                 customType: "teammate-complete",
                 content: lastMsg,
@@ -2426,7 +2446,8 @@ export default function registerTeammateExtension(
             settleAgent(state, correlationId, result.exitCode, lastMsg, result.wakeable !== false);
           }
 
-          pi.sendMessage(
+          safeSendMessage(
+            pi,
             {
               customType: "teammate-complete",
               content: lastMsg,
@@ -3381,7 +3402,9 @@ export default function registerTeammateExtension(
   if (!isChild) {
   pi.events.on(COCKPIT_UI_OWNERSHIP_EVENT, (payload) => {
     if (!payload || typeof payload !== "object") return;
-    cockpitOwnsAgents = (payload as { agents?: unknown }).agents === true;
+    const ownership = payload as { agents?: unknown; quiet?: unknown; quietSymbols?: unknown };
+    cockpitOwnsAgents = ownership.agents === true;
+    setQuietMode(ownership.quiet === true, ownership.quietSymbols);
     updateAgentWidget();
   });
   pi.events.on(TEAMMATE_STARTED_EVENT, () => {
@@ -3473,6 +3496,9 @@ interface ListedAgent {
   resultReadyAt?: number;
   /** Relayed permission/question requests this agent is blocked on. */
   pendingInteractions?: number;
+  requestedModel?: string;
+  resolvedModel?: string;
+  attemptedModels?: string[];
 }
 
 export function buildRoleList(cwd: string): { entries: AgentSummary[]; text: string } {
@@ -3557,6 +3583,9 @@ export function buildAgentList(
       depth,
       treePrefix,
       status: entry.status,
+      requestedModel: entry.requestedModel,
+      resolvedModel: entry.resolvedModel,
+      attemptedModels: entry.attemptedModels,
       ...(entry.resultReadyAt !== undefined ? { resultReadyAt: entry.resultReadyAt } : {}),
       ...(entry.pendingInteractions?.size ? { pendingInteractions: entry.pendingInteractions.size } : {}),
     });
@@ -3604,6 +3633,9 @@ export function buildAgentList(
         dependencies: progress.dependencies,
         toolCount: progress.toolCount,
         tokens: progress.tokens,
+        requestedModel: progress.requestedModel,
+        resolvedModel: progress.resolvedModel,
+        attemptedModels: progress.attemptedModels,
         ...(progress.resultReadyAt !== undefined ? { resultReadyAt: progress.resultReadyAt } : {}),
       });
       childIndex++;
@@ -3652,6 +3684,14 @@ export function buildAgentList(
           stalled ? `STALLED idle ${idleSeconds}s` : idleSeconds >= 5 ? `idle ${idleSeconds}s` : "",
           entry.toolCount ? `${entry.toolCount} tools` : "",
           entry.tokens ? `${entry.tokens} tok` : "",
+          entry.resolvedModel
+            ? `model=${entry.resolvedModel}`
+            : entry.requestedModel
+              ? `requested=${entry.requestedModel}`
+              : "",
+          entry.attemptedModels && entry.attemptedModels.length > 1
+            ? `attempted=${entry.attemptedModels.join(",")}`
+            : "",
           entry.inboxSize ? `inbox=${entry.inboxSize}` : "",
         ].filter(Boolean).join(" · ");
         return `${entry.treePrefix}${iconFor(entry.status)} ${identity} · ${metadata}`;
@@ -3771,6 +3811,15 @@ export function buildWatchOutput(target: WatchTarget, lineCount: number): string
       "---",
       ...log,
     ];
+    if (agent.resolvedModel || agent.requestedModel) {
+      output.push(
+        `Model: ${agent.resolvedModel ?? "not reported"}`
+        + (agent.requestedModel ? ` (requested ${agent.requestedModel})` : ""),
+      );
+    }
+    if (agent.attemptedModels && agent.attemptedModels.length > 1) {
+      output.push(`Attempted models: ${agent.attemptedModels.join(", ")}`);
+    }
     if (agent.status === "retrying" && agent.retry) {
       const retryIn = Math.max(0, Math.ceil((agent.retry.nextRetryAt - Date.now()) / 1000));
       output.push(`Retry ${agent.retry.attempt}/${agent.retry.maxRetries} in ${retryIn}s: ${agent.retry.lastError}`);
@@ -3807,6 +3856,15 @@ export function buildWatchOutput(target: WatchTarget, lineCount: number): string
     "---",
     ...log,
   ];
+  if (progress.resolvedModel || progress.requestedModel) {
+    output.push(
+      `Model: ${progress.resolvedModel ?? "not reported"}`
+      + (progress.requestedModel ? ` (requested ${progress.requestedModel})` : ""),
+    );
+  }
+  if (progress.attemptedModels && progress.attemptedModels.length > 1) {
+    output.push(`Attempted models: ${progress.attemptedModels.join(", ")}`);
+  }
   const lastMessage = progress.lastMessage?.trim();
   if (progress.resultReadyAt !== undefined && progress.status === "running") {
     output.push("Pi completed a no-tool assistant turn; final agent_end confirmation is pending.");
@@ -4038,6 +4096,28 @@ function emitComplete(
   });
 }
 
+/**
+ * Deferred background and IPC callbacks routinely outlive session replacement:
+ * after ctx.newSession()/fork()/switchSession()/reload() the host invalidates
+ * the captured ExtensionAPI and every action method throws synchronously via
+ * assertActive. The notification target no longer exists, and agent state has
+ * already settled via settleAgent/killAgent plus eventBus emit (which is not
+ * guarded), so drop the send instead of letting the throw escape into an
+ * unhandled rejection that kills the pi process.
+ */
+export function safeSendMessage(
+  pi: ExtensionAPI,
+  message: Parameters<ExtensionAPI["sendMessage"]>[0],
+  options?: Parameters<ExtensionAPI["sendMessage"]>[1],
+): void {
+  try {
+    pi.sendMessage(message, options);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("extension ctx is stale")) return;
+    console.error("[pi-maestro-teammate] deferred sendMessage failed:", error);
+  }
+}
+
 export function notifyBackgroundFailure(
   pi: ExtensionAPI,
   id: string,
@@ -4049,7 +4129,8 @@ export function notifyBackgroundFailure(
     `Background teammate failed (agent=${agent}, correlationId=${correlationId}, phase=background-promise): `
     + `${error instanceof Error ? error.message : String(error)}`;
   emitComplete(pi, id, agent, correlationId, 1, 0);
-  pi.sendMessage(
+  safeSendMessage(
+    pi,
     {
       customType: "teammate-complete",
       content: message,
@@ -4314,6 +4395,10 @@ function settleAgentLifecycle(
 ): void {
   clearAgentResultReadyState(state, correlationId);
   if (exitCode !== 0) {
+    const agent = state.activeRuns.get(correlationId);
+    if (agent && lastResult !== undefined) {
+      agent.lastResult = truncateUtf8Tail(lastResult, AGENT_BUFFER_LIMITS.lastResultBytes);
+    }
     killAgent(state, correlationId, undefined, "failed", abortProcess);
     return;
   }
@@ -4366,6 +4451,9 @@ export function recordSettledAgent(
     status,
     settledAt: Date.now(),
     ...(agent.lastResult ? { lastResult: agent.lastResult } : {}),
+    ...(agent.requestedModel ? { requestedModel: agent.requestedModel } : {}),
+    ...(agent.resolvedModel ? { resolvedModel: agent.resolvedModel } : {}),
+    ...(agent.attemptedModels ? { attemptedModels: [...agent.attemptedModels] } : {}),
   });
   while (memo.size > SETTLED_AGENT_MEMO_LIMIT) {
     const oldest = memo.keys().next();
@@ -4649,7 +4737,7 @@ export async function handleChildInteractionRequest(
     : questionSummary(payload.questions);
   const parentAuthorization = interaction === "permission" && payload.authorization === "parent";
   if (!parentAuthorization) {
-    pi.sendMessage({
+    safeSendMessage(pi, {
       customType: "teammate-interaction-request",
       content: `? @${agentLabel} ${interaction}\n${requestSummary}`,
       display: true,
@@ -5381,6 +5469,7 @@ export async function handleProxyRequest(
             .map((name) => taskIndexByName.get(name))
             .filter((dependency): dependency is number => dependency !== undefined),
           status: "pending",
+          requestedModel: task.model,
         });
       });
       const progressSnapshot = (): AgentProgressSnapshot[] =>
@@ -5397,6 +5486,7 @@ export async function handleProxyRequest(
         inbox: [],
         outputLog: [],
         lastActivityAt: Date.now(),
+        requestedModel: normalizedTasks ? undefined : singleTask.model,
         spawnedBy: parentCid,
         depth: dispatchDepth,
         status: "running",
@@ -5462,6 +5552,7 @@ export async function handleProxyRequest(
           inbox: [],
           outputLog: [],
           lastActivityAt: Date.now(),
+          requestedModel: task.model,
           spawnedBy: cid,
           depth: dispatchDepth,
           status: "pending",
@@ -5477,7 +5568,8 @@ export async function handleProxyRequest(
 
       const spawnerAgent = parentCid ? state.activeRuns.get(parentCid) : undefined;
       const spawnerLabel = spawnerAgent?.name ?? spawnerAgent?.agent ?? "proxy";
-      pi.sendMessage(
+      safeSendMessage(
+        pi,
         {
           customType: "teammate-started",
           content: `● @${spawnerLabel} spawned @${singleTask.name ?? activeAgent.agent}`,
@@ -5509,6 +5601,9 @@ export async function handleProxyRequest(
           durationMs: data.durationMs,
           lastActivityAt: data.lastActivityAt,
           resultReadyAt: data.resultReadyAt,
+          requestedModel: data.requestedModel ?? existing?.requestedModel,
+          resolvedModel: data.resolvedModel ?? existing?.resolvedModel,
+          attemptedModels: data.attemptedModels ?? existing?.attemptedModels,
           ...(data.lastMessage
             ? { lastMessage: truncateUtf8Tail(data.lastMessage, AGENT_BUFFER_LIMITS.lastResultBytes) }
             : {}),
@@ -5528,6 +5623,11 @@ export async function handleProxyRequest(
         activeAgent.lastActivityAt = Date.now();
 
         const childAgent = state.activeRuns.get(correlationId);
+        if (childAgent) {
+          childAgent.requestedModel = entry.requestedModel ?? childAgent.requestedModel;
+          childAgent.resolvedModel = entry.resolvedModel ?? childAgent.resolvedModel;
+          childAgent.attemptedModels = entry.attemptedModels ?? childAgent.attemptedModels;
+        }
         if (childAgent && childAgent !== activeAgent) {
           childAgent.lastActivityAt = Date.now();
           childAgent.status = data.status === "completed" ? "sleeping" : data.status;
@@ -5632,6 +5732,9 @@ export async function handleProxyRequest(
           );
         },
         onTurnComplete: (result) => {
+          const target = state.activeRuns.get(result.correlationId) ?? activeAgent;
+          target.resolvedModel = target.resolvedModel ?? result.model;
+          if (result.attemptedModels) target.attemptedModels = [...result.attemptedModels];
           const lastMessage = displayMessageForResult(result);
           const settle = normalizedTasks ? settleGraphTaskAgent : settleAgent;
           settle(
@@ -5773,7 +5876,8 @@ export async function handleProxyRequest(
             reportChildStatus(completed.exitCode === 0 ? "completed" : "failed");
             emitNestedComplete(completed.exitCode);
           }
-          pi.sendMessage(
+          safeSendMessage(
+            pi,
             {
               customType: "teammate-complete",
               content: completed.summary,
@@ -5983,7 +6087,8 @@ export async function handleProxyRequest(
       // Notify main session TUI
       const senderAgent = spawnedBy ? state.activeRuns.get(spawnedBy) : undefined;
       const senderLabel = senderAgent?.name ?? senderAgent?.agent ?? "agent";
-      pi.sendMessage(
+      safeSendMessage(
+        pi,
         {
           customType: "teammate-message",
           content: `● @${senderLabel} → @${to} (${mode}): ${message.slice(0, 120)}`,

package/src/quiet-state.ts

@@ -0,0 +1,35 @@
+// Quiet-mode mirror for pi-maestro-teammate tool rendering.
+//
+// Cockpit owns the config and broadcasts it on cockpit:ui-ownership. Teammate
+// mirrors both the enable flag and lifecycle glyph set so its compact tool rows
+// stay visually aligned with Cockpit and Flow without a cross-package import.
+
+export type QuietSymbolMode = "check" | "dot";
+export type QuietStatus = "running" | "success" | "failure";
+
+let quietMode = false;
+let quietSymbols: QuietSymbolMode = "check";
+
+export function setQuietMode(value: boolean, symbols?: unknown): void {
+	quietMode = value;
+	if (symbols === "check" || symbols === "dot") quietSymbols = symbols;
+}
+
+export function isQuietMode(): boolean {
+	return quietMode;
+}
+
+export function getQuietSymbols(): QuietSymbolMode {
+	return quietSymbols;
+}
+
+export function quietStatusMark(status: QuietStatus): string {
+	if (quietSymbols === "dot") {
+		if (status === "running") return "○";
+		if (status === "success") return "●";
+		return "!";
+	}
+	if (status === "running") return "…";
+	if (status === "success") return "✓";
+	return "✕";
+}

package/src/runs/execution.ts

@@ -244,15 +244,15 @@ export function isPiResultReadyTurn(event: Record<string, unknown>): boolean {
   ));
 }
 
-/**
- * Captures a schema-valid structured_output call from Pi's assistant event.
- * This is a fallback for the small window before the child output file becomes
- * observable to the parent runner.
- */
-export function extractValidatedStructuredOutput(
+interface StructuredOutputCandidate {
+  value: unknown;
+  toolCallId?: string;
+}
+
+function extractStructuredOutputCandidate(
   event: Record<string, unknown>,
   schema: Record<string, unknown>,
-): unknown | undefined {
+): StructuredOutputCandidate | undefined {
   const message = event.message as Record<string, unknown> | undefined;
   const content = message?.content;
   if (!Array.isArray(content)) return undefined;
@@ -266,11 +266,28 @@ export function extractValidatedStructuredOutput(
     if (typeof raw === "string") {
       try { value = JSON.parse(raw); } catch { return undefined; }
     }
-    return validateStructuredOutputValue(value, schema) ? value : undefined;
+    if (!validateStructuredOutputValue(value, schema)) return undefined;
+    const toolCallId = typeof block.toolCallId === "string"
+      ? block.toolCallId
+      : typeof block.id === "string"
+        ? block.id
+        : undefined;
+    return { value, ...(toolCallId ? { toolCallId } : {}) };
   }
   return undefined;
 }
 
+/**
+ * Extracts a schema-valid structured_output payload from a Pi assistant event.
+ * Execution code treats this as pending until the tool execution succeeds.
+ */
+export function extractValidatedStructuredOutput(
+  event: Record<string, unknown>,
+  schema: Record<string, unknown>,
+): unknown | undefined {
+  return extractStructuredOutputCandidate(event, schema)?.value;
+}
+
 export function describeStructuredOutputValidationFailure(
   event: Record<string, unknown>,
   schema: Record<string, unknown>,
@@ -1694,14 +1711,29 @@ export async function runSingleTeammate(
   }
 
   const breaker = options.modelCircuitBreaker ?? sharedModelCircuitBreaker;
-  const modelCandidates: Array<string | undefined> = candidates.length > 0 ? candidates : [undefined];
+  // When no explicit model or fallbacks are configured, try the pi default
+  // first (undefined), then each authenticated model as an implicit fallback.
+  // This prevents a terminal failure when the default provider has no quota.
+  const implicitFallbacks = candidates.length === 0
+    ? (options.modelCapabilities ?? []).map((capability) => capability.id)
+    : [];
+  const modelCandidates: Array<string | undefined> = candidates.length > 0
+    ? candidates
+    : [undefined, ...implicitFallbacks];
   const attemptedModels: string[] = [];
   let lastResult: SingleResult | undefined;
 
+  const publishTurnComplete = (result: SingleResult): void => {
+    try {
+      options.onTurnComplete?.(result);
+    } catch {
+      // Completion observers must not change the model fallback outcome.
+    }
+  };
+
   for (const modelToUse of modelCandidates) {
     const acquisition = modelToUse ? breaker.acquireCandidate(modelToUse) : undefined;
     if (acquisition && !acquisition.allowed) continue;
-    if (modelToUse && !attemptedModels.includes(modelToUse)) attemptedModels.push(modelToUse);
 
     let settled = false;
     try {
@@ -1710,9 +1742,40 @@ export async function runSingleTeammate(
       let candidateResult: SingleResult | undefined;
 
       while (!options.signal?.aborted) {
-        candidateResult = await runSingleAttempt(
-          params, agentConfig, cwd, correlationId, replyTo, startTime, modelToUse, options,
-        );
+        if (modelToUse && !attemptedModels.includes(modelToUse)) attemptedModels.push(modelToUse);
+
+        // A failed candidate is not terminal while retry or fallback remains.
+        // Buffer lifecycle completion until the outer policy selects the
+        // authoritative attempt; successful wakeable children then stay open
+        // for later turn-complete callbacks.
+        let completionState: "buffering" | "forwarding" | "discarded" = "buffering";
+        const pendingCompletions: SingleResult[] = [];
+        const attemptOptions: RunTeammateOptions = options.onTurnComplete
+          ? {
+              ...options,
+              onTurnComplete(result) {
+                if (completionState === "forwarding") publishTurnComplete(result);
+                else if (completionState === "buffering") pendingCompletions.push(result);
+              },
+            }
+          : options;
+        const commitCompletion = (): void => {
+          completionState = "forwarding";
+          for (const result of pendingCompletions.splice(0)) publishTurnComplete(result);
+        };
+        const discardCompletion = (): void => {
+          completionState = "discarded";
+          pendingCompletions.length = 0;
+        };
+
+        try {
+          candidateResult = await runSingleAttempt(
+            params, agentConfig, cwd, correlationId, replyTo, startTime, modelToUse, attemptOptions,
+          );
+        } catch (error) {
+          discardCompletion();
+          throw error;
+        }
         lastResult = candidateResult;
         const error = resultFailureMessage(candidateResult.messages);
         const retryable = candidateResult.exitCode !== 0 && isRetryableProviderError(error);
@@ -1721,13 +1784,22 @@ export async function runSingleTeammate(
         if (candidateResult.exitCode === 0) {
           if (acquisition?.allowed) { breaker.recordSuccess(acquisition); settled = true; }
           candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
+          commitCompletion();
           return candidateResult;
         }
         if (!retryable || retryCount >= maxRetries) {
           if (fallbackEligible && acquisition?.allowed) { breaker.recordRetryableFailure(acquisition); settled = true; }
+          if (!fallbackEligible) {
+            if (acquisition?.allowed) { breaker.releaseCandidate(acquisition); settled = true; }
+            candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
+            commitCompletion();
+            return candidateResult;
+          }
+          discardCompletion();
           break;
         }
 
+        discardCompletion();
         retryCount += 1;
         const delayMs = retryDelayMs(retryCount);
         options.onRetry?.({
@@ -1749,6 +1821,7 @@ export async function runSingleTeammate(
       if (!isFallbackModelError(candidateResult.messages)) {
         if (acquisition?.allowed) { breaker.releaseCandidate(acquisition); settled = true; }
         candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
+        publishTurnComplete(candidateResult);
         return candidateResult;
       }
     } finally {
@@ -1763,6 +1836,7 @@ export async function runSingleTeammate(
 
   if (lastResult) {
     lastResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
+    publishTurnComplete(lastResult);
     return lastResult;
   }
   return rejectWith(
@@ -1818,6 +1892,7 @@ interface AttemptState {
   lastContent: string;
   streamingText: string;
   stderrBuffer: string;
+  pendingStructuredOutput?: StructuredOutputCandidate;
   capturedStructuredOutput: unknown;
   structuredOutputValidationFailure?: string;
   reportedRuntimeErrors: Set<string>;
@@ -1960,6 +2035,7 @@ async function runSingleAttempt(
     lastContent: "",
     streamingText: "",
     stderrBuffer: "",
+    pendingStructuredOutput: undefined,
     capturedStructuredOutput: undefined,
     structuredOutputValidationFailure: undefined,
     reportedRuntimeErrors: new Set(),
@@ -1976,6 +2052,7 @@ async function runSingleAttempt(
 
   // AC8: Rich progress tracking
   const progress = createProgress(params.agent, startTime);
+  progress.requestedModel = modelOverride ?? params.model ?? agentConfig.model;
 
   const updateProgressUsage = (): void => {
     const inputTokens = state.completedInputTokens + usage.inputTokens + pendingMessageUsage.inputTokens;
@@ -2167,6 +2244,7 @@ async function runSingleAttempt(
         state.lastContent = "";
         state.streamingText = "";
         state.stderrBuffer = "";
+        state.pendingStructuredOutput = undefined;
         state.capturedStructuredOutput = undefined;
         state.structuredOutputValidationFailure = undefined;
         state.reportedRuntimeErrors.clear();
@@ -2289,6 +2367,9 @@ async function runSingleAttempt(
       progress.resultReadyAt = undefined;
       progress.recentTools = [];
       state.turnToolCount = 0;
+      state.pendingStructuredOutput = undefined;
+      state.capturedStructuredOutput = undefined;
+      state.structuredOutputValidationFailure = undefined;
       options.onProgress?.(progress);
     }
 
@@ -2331,6 +2412,7 @@ async function runSingleAttempt(
       const messageModel = typeof msg?.model === "string" ? msg.model : event.model;
       if (messageModel) {
         state.resolvedModel = messageModel;
+        progress.resolvedModel = messageModel;
       }
       recordRuntimeEventError(event, event.type);
       options.onProgress?.(progress);
@@ -2405,10 +2487,25 @@ async function runSingleAttempt(
       if (
         event.type === "tool_execution_end"
         && completedTool === "structured_output"
-        && event.isError !== true
       ) {
+        const pending = state.pendingStructuredOutput;
+        const completedToolCallId = typeof event.toolCallId === "string"
+          ? event.toolCallId
+          : typeof event.id === "string"
+            ? event.id
+            : undefined;
+        const idsMatch = !pending?.toolCallId
+          || !completedToolCallId
+          || pending.toolCallId === completedToolCallId;
+        if (event.isError !== true && pending && idsMatch) {
+          state.capturedStructuredOutput = pending.value;
+        } else if (event.isError === true && idsMatch) {
+          state.pendingStructuredOutput = undefined;
+        }
         const structuredOutput = readStructuredOutput(false);
-        if (structuredOutput !== undefined) completeTurn(structuredOutput, true);
+        if (event.isError !== true && structuredOutput !== undefined) {
+          completeTurn(structuredOutput, true);
+        }
       }
     }
 
@@ -2435,7 +2532,10 @@ async function runSingleAttempt(
         }
       }
       const messageModel = typeof msg?.model === "string" ? msg.model : event.model;
-      if (messageModel) state.resolvedModel = messageModel;
+      if (messageModel) {
+        state.resolvedModel = messageModel;
+        progress.resolvedModel = messageModel;
+      }
       recordRuntimeEventError(event, "turn_end");
       if (isPiResultReadyTurn(event)) {
         progress.resultReadyAt = Date.now();
@@ -2510,7 +2610,8 @@ async function runSingleAttempt(
       // those buffered lines from reawakening the published agent loop.
       if (state.terminal) return;
       if (state.capturedStructuredOutput === undefined && params.outputSchema) {
-        state.capturedStructuredOutput = extractValidatedStructuredOutput(event, params.outputSchema);
+        const candidate = extractStructuredOutputCandidate(event, params.outputSchema);
+        if (candidate) state.pendingStructuredOutput = candidate;
         state.structuredOutputValidationFailure = describeStructuredOutputValidationFailure(event, params.outputSchema)
           ?? state.structuredOutputValidationFailure;
       }

package/src/shared/types.ts

@@ -51,6 +51,9 @@ export interface AgentProgress {
   /** Pi emitted a final no-tool assistant turn; agent_end has not necessarily arrived yet. */
   resultReadyAt?: number;
   lastMessage?: string;
+  requestedModel?: string;
+  resolvedModel?: string;
+  attemptedModels?: string[];
 }
 
 export interface AgentProgressSnapshot {
@@ -73,6 +76,9 @@ export interface AgentProgressSnapshot {
   resultReadyAt?: number;
   lastMessage?: string;
   error?: string;
+  requestedModel?: string;
+  resolvedModel?: string;
+  attemptedModels?: string[];
 }
 
 export interface ChildAgentCallSnapshot {
@@ -160,6 +166,9 @@ export interface ActiveAgent {
   outputLog: string[];
   pendingResolve?: (result: SingleResult) => void;
   lastActivityAt: number;
+  requestedModel?: string;
+  resolvedModel?: string;
+  attemptedModels?: string[];
   /**
    * When this agent failed. Set alongside `status: "failed"`, mirroring
    * `sleptAt` for retired agents, and read by the retention sweep that
@@ -237,6 +246,9 @@ export interface SettledAgentRecord {
   status: "completed" | "failed" | "terminated";
   settledAt: number;
   lastResult?: string;
+  requestedModel?: string;
+  resolvedModel?: string;
+  attemptedModels?: string[];
 }
 
 export const TEAMMATE_COMPLETE_EVENT = "teammate:complete";

package/src/tui/render.ts

@@ -19,6 +19,7 @@ import {
 } from "../shared/agent-status.ts";
 import type { AgentProgressSnapshot, ChildAgentCallSnapshot, Details, SingleResult } from "../shared/types.ts";
 import { extractDependencies } from "../runs/execution.ts";
+import { isQuietMode, quietStatusMark } from "../quiet-state.ts";
 import {
   buildProgressTree,
   focusTaskIndex,
@@ -139,6 +140,7 @@ export function renderTeammateCall(
   theme: Theme,
   context?: { expanded?: boolean },
 ): Component {
+  if (isQuietMode()) return renderQuietTeammateCall(args, theme);
   const tasks = (args.tasks as Array<Omit<TaskArg, "agent"> & { agent?: string }> | undefined)
     ?.map((task) => ({ ...task, agent: task.agent ?? (args.agent as string | undefined) ?? "general" }));
   const isBg = args.background === true;
@@ -244,6 +246,7 @@ export function renderTeammateResult(
   options: { expanded: boolean },
   theme: Theme,
 ): Component {
+  if (isQuietMode()) return renderQuietTeammateResult(result, theme);
   const details = result.details;
 
   // No results yet — streaming progress or background ack
@@ -576,3 +579,114 @@ function renderMultiResult(
     return [...box.render(w)];
   });
 }
+
+// ---------------------------------------------------------------------------
+// Quiet mode — single-line summaries for the teammate tool stream
+// ---------------------------------------------------------------------------
+//
+// When cockpit quiet mode is on the whole tool surface collapses to one line
+// per call/result. The teammate tool is the noisy one (full progress tree,
+// child subtree, streaming tail, key hints); here it becomes:
+//   call:      "  ⋯ teammate @name (agent)" / "  ⋯ teammate N agents chain"
+//   streaming: "  ■ teammate 2/3 running · @focus using read"
+//   done:      "  ✓ teammate 3/3 done · 9.4k tokens"  (✗ + first error on fail)
+// The tree/dependency detail dropped here is still fully shown by cockpit's
+// Agents widget, which quiet mode never compresses, so no information is lost.
+
+function qLine(theme: Theme, markedGlyph: string, name: string, rest: string): string {
+  const parts = [
+    theme.fg("toolTitle", theme.bold ? theme.bold(name) : name),
+    rest ? theme.fg("muted", rest) : "",
+  ].filter(Boolean);
+  return `  ${markedGlyph} ${parts.join(" ")}`;
+}
+
+function quietFirstError(r: SingleResult): string {
+  const text = r.messages[r.messages.length - 1]?.content ?? "";
+  const line = (text.split("\n").find((l) => l.trim()) ?? "").trim();
+  if (!line) return "failed";
+  return line.length > 60 ? `${line.slice(0, 59)}…` : line;
+}
+
+function quietTopoLabel(tasks: TaskArg[]): string {
+  const taskNames = new Set(tasks.filter((t) => t.name).map((t) => t.name!));
+  if (!tasks.some((t) => extractDependencies(t.prompt, taskNames).length > 0)) return "";
+  return isLinearChain(tasks, taskNames) ? "chain" : "graph";
+}
+
+function renderQuietTeammateCall(args: Record<string, unknown>, theme: Theme): Component {
+  const glyph = theme.fg("warning", quietStatusMark("running"));
+  const tasks = (args.tasks as Array<Omit<TaskArg, "agent"> & { agent?: string }> | undefined)
+    ?.map((task) => ({ ...task, agent: task.agent ?? (args.agent as string | undefined) ?? "general" }));
+  if (tasks?.length) {
+    const topo = quietTopoLabel(tasks);
+    const rest = `${tasks.length} agents${topo ? ` ${topo}` : ""}`;
+    return dynamicComponent((w) => [truncateToWidth(qLine(theme, glyph, "teammate", rest), Math.max(1, w), "…")]);
+  }
+  const agent = (args.agent as string | undefined) ?? "general";
+  const name = args.name as string | undefined;
+  const rest = name ? `@${name} (${agent})` : agent;
+  return dynamicComponent((w) => [truncateToWidth(qLine(theme, glyph, "teammate", rest), Math.max(1, w), "…")]);
+}
+
+function renderQuietTeammateResult(result: AgentToolResult<Details>, theme: Theme): Component {
+  const details = result.details;
+  const isError = (result as { isError?: boolean }).isError === true;
+
+  // Terminal results: one line, ✓/✗, done/failed counts + tokens or first error.
+  if (details && details.results.length > 0) {
+    const results = details.results;
+    const ok = results.filter((r) => r.exitCode === 0).length;
+    const total = results.length;
+    const failed = total - ok;
+    const totalTokens = results.reduce((sum, r) => sum + r.usage.inputTokens + r.usage.outputTokens, 0);
+    if (failed > 0 || isError) {
+      const firstFailed = results.find((r) => r.exitCode !== 0);
+      const err = firstFailed ? quietFirstError(firstFailed) : "failed";
+      const rest = total === 1
+        ? `${firstFailed?.agent ?? "agent"} failed · ${err}`
+        : `${failed}/${total} failed · ${err}`;
+      const glyph = theme.fg("error", quietStatusMark("failure"));
+      return dynamicComponent((w) => [truncateToWidth(qLine(theme, glyph, "teammate", rest), Math.max(1, w), "…")]);
+    }
+    const tokens = totalTokens > 0 ? ` · ${formatTokens(totalTokens)} tokens` : "";
+    const rest = total === 1 ? `${results[0].agent} done${tokens}` : `${ok}/${total} done${tokens}`;
+    const glyph = theme.fg("success", quietStatusMark("success"));
+    return dynamicComponent((w) => [truncateToWidth(qLine(theme, glyph, "teammate", rest), Math.max(1, w), "…")]);
+  }
+
+  // Streaming: one aggregate line — no tree, no child subtree, no stream tail.
+  const entries = details?.progress ?? [];
+  const childCalls = details?.childCalls ?? [];
+  const running = entries.filter((e) => e.status === "running" || e.status === "retrying").length
+    + childCalls.filter((c) => c.status === "running" || c.status === "retrying").length;
+  const failed = entries.filter((e) => e.status === "failed").length
+    + childCalls.filter((c) => c.status === "failed").length;
+  const completed = entries.filter((e) => e.status === "completed").length;
+  const glyph = failed > 0
+    ? theme.fg("error", quietStatusMark("failure"))
+    : running > 0
+      ? theme.fg("warning", quietStatusMark("running"))
+      : theme.fg("success", quietStatusMark("success"));
+  const stateText = entries.length === 0
+    ? `${running || childCalls.length} child agent${(running || childCalls.length) === 1 ? "" : "s"}`
+    : failed > 0
+      ? `${failed}/${entries.length} failed`
+      : running > 0
+        ? `${running}/${entries.length} running`
+        : `${completed}/${entries.length} done`;
+
+  return dynamicComponent((w) => {
+    const focus = entries.length > 0
+      ? entries.find((e) => e.taskIndex === focusTaskIndex(entries)) ?? entries[0]
+      : undefined;
+    const parts = [stateText];
+    if (focus && w >= 20) {
+      parts.push(`@${focus.name ?? focus.agent}`);
+      const activeTool = focus.recentTools?.find((t) => t.status === "running");
+      if (activeTool) parts.push(`using ${activeTool.name}`);
+      else if (focus.lastMessage) parts.push("streaming");
+    }
+    return [truncateToWidth(qLine(theme, glyph, "teammate", parts.join(" · ")), Math.max(1, w), "…")];
+  });
+}

package/types/extension/index.d.ts

@@ -196,6 +196,9 @@ interface ListedAgent {
     resultReadyAt?: number;
     /** Relayed permission/question requests this agent is blocked on. */
     pendingInteractions?: number;
+    requestedModel?: string;
+    resolvedModel?: string;
+    attemptedModels?: string[];
 }
 export declare function buildRoleList(cwd: string): {
     entries: AgentSummary[];
@@ -230,6 +233,16 @@ export declare function waitForTeammate(state: TeammateState, params: {
     timeoutMs?: number;
     waitMs?: number;
 }, signal?: AbortSignal): Promise<TeammateWaitResult>;
+/**
+ * Deferred background and IPC callbacks routinely outlive session replacement:
+ * after ctx.newSession()/fork()/switchSession()/reload() the host invalidates
+ * the captured ExtensionAPI and every action method throws synchronously via
+ * assertActive. The notification target no longer exists, and agent state has
+ * already settled via settleAgent/killAgent plus eventBus emit (which is not
+ * guarded), so drop the send instead of letting the throw escape into an
+ * unhandled rejection that kills the pi process.
+ */
+export declare function safeSendMessage(pi: ExtensionAPI, message: Parameters<ExtensionAPI["sendMessage"]>[0], options?: Parameters<ExtensionAPI["sendMessage"]>[1]): void;
 export declare function notifyBackgroundFailure(pi: ExtensionAPI, id: string, agent: string, correlationId: string, error: unknown): void;
 export declare function applyAgentRetryState(state: TeammateState, retry: {
     correlationId: string;

package/types/quiet-state.d.ts

@@ -0,0 +1,6 @@
+export type QuietSymbolMode = "check" | "dot";
+export type QuietStatus = "running" | "success" | "failure";
+export declare function setQuietMode(value: boolean, symbols?: unknown): void;
+export declare function isQuietMode(): boolean;
+export declare function getQuietSymbols(): QuietSymbolMode;
+export declare function quietStatusMark(status: QuietStatus): string;

package/types/runs/execution.d.ts

@@ -134,9 +134,8 @@ export declare function correlationSessionDirectoryName(correlationId: string):
  */
 export declare function isPiResultReadyTurn(event: Record<string, unknown>): boolean;
 /**
- * Captures a schema-valid structured_output call from Pi's assistant event.
- * This is a fallback for the small window before the child output file becomes
- * observable to the parent runner.
+ * Extracts a schema-valid structured_output payload from a Pi assistant event.
+ * Execution code treats this as pending until the tool execution succeeds.
  */
 export declare function extractValidatedStructuredOutput(event: Record<string, unknown>, schema: Record<string, unknown>): unknown | undefined;
 export declare function describeStructuredOutputValidationFailure(event: Record<string, unknown>, schema: Record<string, unknown>): string | undefined;

package/types/shared/types.d.ts

@@ -53,6 +53,9 @@ export interface AgentProgress {
     /** Pi emitted a final no-tool assistant turn; agent_end has not necessarily arrived yet. */
     resultReadyAt?: number;
     lastMessage?: string;
+    requestedModel?: string;
+    resolvedModel?: string;
+    attemptedModels?: string[];
 }
 export interface AgentProgressSnapshot {
     agent: string;
@@ -77,6 +80,9 @@ export interface AgentProgressSnapshot {
     resultReadyAt?: number;
     lastMessage?: string;
     error?: string;
+    requestedModel?: string;
+    resolvedModel?: string;
+    attemptedModels?: string[];
 }
 export interface ChildAgentCallSnapshot {
     agent: string;
@@ -162,6 +168,9 @@ export interface ActiveAgent {
     outputLog: string[];
     pendingResolve?: (result: SingleResult) => void;
     lastActivityAt: number;
+    requestedModel?: string;
+    resolvedModel?: string;
+    attemptedModels?: string[];
     /**
      * When this agent failed. Set alongside `status: "failed"`, mirroring
      * `sleptAt` for retired agents, and read by the retention sweep that
@@ -237,6 +246,9 @@ export interface SettledAgentRecord {
     status: "completed" | "failed" | "terminated";
     settledAt: number;
     lastResult?: string;
+    requestedModel?: string;
+    resolvedModel?: string;
+    attemptedModels?: string[];
 }
 export declare const TEAMMATE_COMPLETE_EVENT = "teammate:complete";
 export declare const TEAMMATE_STARTED_EVENT = "teammate:started";