pi-subagents 0.80.0 → 0.81.0

package/src/agents/frontmatter.js

@@ -39,6 +39,8 @@ function foldBlock(block) {
 /**
  * Normalize a simple-scalar frontmatter list from comma-separated or block-list syntax.
  * Only the standard `- item` marker is removed; ordinary hyphenated values stay intact.
+ * A trailing ` #...` comment is dropped from unquoted `- item` lines. Single-line values are left
+ * alone because parseFrontmatter has already removed their quotes, so `"notes #1.md"` must survive.
  */
 export function parseFrontmatterList(raw) {
     if (raw === undefined)
@@ -47,8 +49,9 @@ export function parseFrontmatterList(raw) {
         .split("\n")
         .flatMap((line) => {
         const value = line.trim();
-        const listItem = value.match(/^-\s+(.+)$/);
-        return (listItem?.[1] ?? value).split(",");
+        const listItem = value.match(/^-\s+(.+)$/)?.[1];
+        const item = listItem === undefined || /^["']/.test(listItem) ? listItem ?? value : listItem.replace(/(?:^|\s)#.*$/, "");
+        return item.split(",");
     })
         .map((value) => value.trim())
         .filter(Boolean);
@@ -80,6 +83,10 @@ export function parseFrontmatter(content) {
     for (const line of lines) {
         const indent = line.search(/\S|$/); // position of first non-whitespace char
         const trimmed = line.trim();
+        // Comment lines are content only inside a | or > block scalar. Elsewhere they must
+        // neither end a pending list block nor become part of its value.
+        if (trimmed.startsWith("#") && !currentFolded && !currentLiteral)
+            continue;
         if (currentKey !== null && currentBlockLines !== null && (indent > (currentIndent ?? 0) || ((currentFolded || currentLiteral) && trimmed === ""))) {
             // This line is part of the current block value
             currentBlockLines.push(line);

package/src/api/delegation.d.ts

@@ -53,7 +53,26 @@ export interface SubagentDelegationUpdateUsage {
     cacheWrite: number;
     turns: number;
 }
+/** Observed assistant-request errors and Pi retries, not provider-internal HTTP attempts. */
+export interface SubagentDelegationProviderDiagnostics {
+    errorCount: number;
+    lastError?: {
+        kind: "rate_limited" | "transient_other" | "unknown";
+        /** Fixed safe description; never the raw provider error/body. */
+        message: string;
+        at: number;
+    };
+    retry?: {
+        phase: "backoff" | "in_flight";
+        attempt: number;
+        maxAttempts: number;
+        delayMs: number;
+        /** Observation time of auto_retry_start; delayMs is Pi's planned delay. */
+        scheduledAt: number;
+    };
+}
 export interface SubagentDelegationUpdate extends SubagentDelegationStarted {
+    providerDiagnostics?: SubagentDelegationProviderDiagnostics;
     runId?: string;
     currentTool?: string;
     currentToolArgs?: string;
@@ -88,6 +107,7 @@ export interface SubagentDelegationUsage {
     durationMs: number;
 }
 export interface SubagentDelegationTerminalResponse extends SubagentDelegationStarted {
+    providerDiagnostics?: SubagentDelegationProviderDiagnostics;
     status: Exclude<SubagentDelegationStatus, "invalid_request">;
     error?: string;
     runId?: string;

package/src/extension/index.js

@@ -43,6 +43,7 @@ import { createResultWatcher } from "../runs/background/result-watcher.js";
 import { createResultDeliveryOwnership } from "../runs/background/result-delivery-ownership.js";
 import { createScheduledRunManager } from "../runs/background/scheduled-runs.js";
 import { registerSlashCommands } from "../slash/slash-commands.js";
+import { ADMIN_MESSAGE_TYPE } from "../slash/subagents-admin.js";
 import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.js";
 import { registerMainWatchdog } from "../watchdog/register-main.js";
 import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
@@ -557,13 +558,32 @@ export default function registerSubagentExtension(pi) {
             return undefined;
         return createSlashResultComponent(details, options, theme, config.mainWindowRenderer, foregroundDetachShortcut, () => state.lastUiContext?.ui.theme ?? theme);
     });
-    // Keep view-only reports in the transcript/RPC stream, but out of model context.
-    // SLASH_RESULT_TYPE carries delegated work and must remain model-visible.
-    pi.on("context", (event) => ({
-        messages: event.messages.filter((message) => message.role !== "custom"
-            || message.customType !== SLASH_TEXT_RESULT_TYPE
-            || message.details?.viewOnly !== true),
-    }));
+    // Pi sends custom messages to the model as plain user messages, so every model-visible
+    // pi-subagents message is wrapped in a marker naming its source. The marker depends only on
+    // the message, so history renders the same bytes every turn and cached prefixes stay valid.
+    const markedMessageTypes = new Set([...SUBAGENT_MESSAGE_TYPES, "subagent-compaction-resume", SLASH_RESULT_TYPE, SLASH_TEXT_RESULT_TYPE, ADMIN_MESSAGE_TYPE]);
+    pi.on("context", (event) => {
+        const messages = [];
+        for (const message of event.messages) {
+            if (message.role !== "custom" || !markedMessageTypes.has(message.customType)) {
+                messages.push(message);
+                continue;
+            }
+            // Keep view-only reports in the transcript/RPC stream, but out of model context.
+            // SLASH_RESULT_TYPE carries delegated work and must remain model-visible.
+            if (message.customType === SLASH_TEXT_RESULT_TYPE && message.details?.viewOnly === true)
+                continue;
+            const open = `<pi_subagents_notice type="${message.customType}" origin="automated message from the pi-subagents extension, not typed by the user">`;
+            const close = "</pi_subagents_notice>";
+            messages.push({
+                ...message,
+                content: typeof message.content === "string"
+                    ? `${open}\n${message.content}\n${close}`
+                    : [{ type: "text", text: `${open}\n` }, ...message.content, { type: "text", text: `\n${close}` }],
+            });
+        }
+        return { messages };
+    });
     pi.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
         const content = typeof message.content === "string"
             ? message.content

package/src/runs/background/run-child-session.js

@@ -10,6 +10,8 @@ import { createReportedChildSessionInput } from "../shared/child-launch.js";
 import { createPartialOutputTracker, formatPartialOutput } from "../shared/partial-output.js";
 import { childSessionHasQueuedMessages, projectChildSessionEventForJson } from "../shared/child-session.js";
 import { reconcileAttemptUsage } from "../shared/usage-reconciliation.js";
+import { isOrdinaryToolForMidToolExit } from "../shared/process-signal.js";
+import { STRUCTURED_OUTPUT_FOLLOW_UP } from "../shared/structured-output.js";
 import { formatSteerMessage } from "../shared/subagent-prompt-runtime.js";
 import { takeMatchingAcceptedSteer, unconsumedSteerReason } from "./steering.js";
 /** Events the child emits while the model streams; not persisted into the diagnostic log. */
@@ -616,6 +618,22 @@ export function runChildSession(input) {
                     abortChild();
                 messageBaseline = created.messages.length;
                 await created.prompt(input.prompt);
+                // A structured child that finished normally without calling structured_output gets one more turn (#2997).
+                if (input.launch.session.runtime.structuredOutput
+                    && !structuredOutputToolInvoked
+                    && !settled
+                    && !created.shutDown
+                    && !interrupted
+                    && !timedOut
+                    && !stopped
+                    && !forcedTermination
+                    && !error
+                    && !assistantError
+                    && !input.launch.capture.toolDiagnostic()
+                    && !(currentTool && isOrdinaryToolForMidToolExit(currentTool))) {
+                    applyChildLifecycle("cancel-drain");
+                    await created.prompt(STRUCTURED_OUTPUT_FOLLOW_UP);
+                }
                 promptSettled = true;
                 settle(undefined);
             }

package/src/runs/background/stale-run-reconciler.js

@@ -273,6 +273,8 @@ function buildFailedRepair(status, asyncDir, now, reason) {
             agent: resultAgent,
             mode: status.mode,
             ...(status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {}),
+            ...(status.parentWorkflowRunId ? { parentWorkflowRunId: status.parentWorkflowRunId } : {}),
+            ...(status.workflowKey ? { workflowKey: status.workflowKey } : {}),
             success: false,
             state: "failed",
             summary: message,

package/src/runs/foreground/execution.js

@@ -24,7 +24,7 @@ import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { qualifyModelWithProvider, resolveEffectiveThinking } from "../../shared/model-info.js";
 import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
-import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.js";
+import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR, STRUCTURED_OUTPUT_FOLLOW_UP } from "../shared/structured-output.js";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.js";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
 import { formatChildModelResolutionDiagnostic, formatInheritedProviderDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
@@ -45,6 +45,7 @@ import { acceptChildWatchdogEvent, applyChildWatchdogMessage, childWatchdogIsAct
 import { buildInProcessChildLaunch, createReportedChildSessionInput } from "../shared/child-launch.js";
 import { childSessionFactory, childSessionHasQueuedMessages, projectChildSessionEventForJson } from "../shared/child-session.js";
 import { reconcileAttemptUsage } from "../shared/usage-reconciliation.js";
+import { clearProviderRetry, observeProviderDiagnostics, snapshotProviderDiagnostics } from "../../shared/provider-diagnostics.js";
 const artifactOutputByResult = new WeakMap();
 const acceptanceOutputByResult = new WeakMap();
 function emptyUsage() {
@@ -165,6 +166,7 @@ function snapshotProgress(progress) {
         ...progress,
         task: PROMPT_REDACTED,
         skills: progress.skills ? [...progress.skills] : undefined,
+        providerDiagnostics: snapshotProviderDiagnostics(progress.providerDiagnostics),
         recentTools: boundStreamedRecentTools(progress.recentTools),
         recentOutput: boundStreamedRecentOutput(progress.recentOutput),
     };
@@ -175,6 +177,7 @@ function snapshotResult(result, progress) {
         task: PROMPT_REDACTED,
         messages: result.outputMode === "file-only" && result.savedOutputPath ? undefined : result.messages ? [...result.messages] : undefined,
         usage: { ...result.usage },
+        providerDiagnostics: snapshotProviderDiagnostics(result.providerDiagnostics),
         skills: result.skills ? [...result.skills] : undefined,
         controlEvents: result.controlEvents ? result.controlEvents.map((event) => ({ ...event })) : undefined,
         progress,
@@ -198,6 +201,7 @@ function snapshotStreamResult(result, progress) {
 }
 function captureStructuredDelegationProgressState(progress, result) {
     return {
+        providerDiagnostics: progress.providerDiagnostics,
         currentTool: progress.currentTool,
         currentToolArgs: progress.currentToolArgs,
         recentOutput: [...progress.recentOutput],
@@ -210,7 +214,9 @@ function captureStructuredDelegationProgressState(progress, result) {
     };
 }
 function structuredDelegationProgressChanged(previous, progress, result) {
-    if (previous.currentTool !== progress.currentTool
+    // Observations replace internal diagnostics; no transcript walk or serialization on heartbeats.
+    if (previous.providerDiagnostics !== progress.providerDiagnostics
+        || previous.currentTool !== progress.currentTool
         || previous.currentToolArgs !== progress.currentToolArgs
         || previous.activityState !== progress.activityState
         || previous.model !== (progress.model ?? result.model)
@@ -352,6 +358,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         exitCode: 0,
         outputState: "absent",
         messages: [],
+        providerDiagnostics: shared.providerDiagnostics,
         usage: emptyUsage(),
         model: modelArg,
         ...(resolvedThinking ? { thinking: resolvedThinking } : {}),
@@ -383,6 +390,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     let cacheReadUsageComplete = true;
     let cacheWriteUsageComplete = true;
     const progress = {
+        providerDiagnostics: result.providerDiagnostics,
         index: options.index ?? 0,
         agent: agent.name,
         ...(childSessionName ? { sessionName: childSessionName } : {}),
@@ -972,6 +980,14 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 return;
             }
             const now = Date.now();
+            const providerDiagnostics = observeProviderDiagnostics(result.providerDiagnostics, evt, now);
+            if (providerDiagnostics !== result.providerDiagnostics) {
+                result.providerDiagnostics = providerDiagnostics;
+                progress.providerDiagnostics = providerDiagnostics;
+                // message_end already emits synchronously below; retry-only transitions need their own update.
+                if (evt.type !== "message_end")
+                    fireUpdate();
+            }
             progress.durationMs = now - startTime;
             progress.lastActivityAt = now;
             updateActivityState(now);
@@ -1396,6 +1412,24 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 // A runtime replacement can stop a child that detached while it was still being created.
                 if (!hostStopReason)
                     await created.prompt(`Task: ${task}`);
+                // A structured child that finished normally without calling structured_output gets one more turn (#2997).
+                if (options.structuredOutput
+                    && !structuredOutputToolInvoked
+                    && !sessionSettled
+                    && !lifecycleFinished
+                    && !hostStopReason
+                    && !created.shutDown
+                    && !abortedBySignal
+                    && !interruptedByControl
+                    && !result.timedOut
+                    && !forcedTermination
+                    && !result.error
+                    && !assistantError
+                    && !capture.toolDiagnostic()
+                    && !(progress.currentTool && isOrdinaryToolForMidToolExit(progress.currentTool))) {
+                    applyChildLifecycle("cancel-drain");
+                    await created.prompt(STRUCTURED_OUTPUT_FOLLOW_UP);
+                }
                 settle(undefined);
             }
             catch (error) {
@@ -1404,6 +1438,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         })();
     });
     result.exitCode = exitCode;
+    result.providerDiagnostics = clearProviderRetry(result.providerDiagnostics);
+    progress.providerDiagnostics = result.providerDiagnostics;
     if (afterCompactionSettlement) {
         result[AFTER_COMPACTION_SETTLEMENT] = true;
     }
@@ -1855,6 +1891,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
             orcaProgressTab,
             launchWarnings,
             verifyModel,
+            providerDiagnostics: lastResult?.providerDiagnostics,
         });
         lastResult = attemptResult;
         sumUsage(aggregateUsage, attemptResult.usage);

package/src/runs/shared/structured-output.d.ts

@@ -2,6 +2,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 import type { ResolvedAcceptanceReportMode } from "./acceptance.ts";
 export declare const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
+export declare const STRUCTURED_OUTPUT_FOLLOW_UP = "You ended without calling `structured_output`. Call it now with your result. Do not repeat the work.";
 export declare const MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR = "Missing acceptanceReport in structured_output call; acceptance.report is \"on\".";
 export declare const STRUCTURED_OUTPUT_REJECTION_ERROR = "structured_output was invoked but no valid output was captured.";
 export declare const INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR = "Structured output invocation was rejected: invalid outputSchema.";

package/src/runs/shared/structured-output.js

@@ -14,6 +14,7 @@ import { pathToFileURL } from "node:url";
 import { PI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.js";
 import { resolveInstalledPiPackageRoot, resolvePiPackageRoot } from "./pi-spawn.js";
 export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
+export const STRUCTURED_OUTPUT_FOLLOW_UP = "You ended without calling `structured_output`. Call it now with your result. Do not repeat the work.";
 export const MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR = "Missing acceptanceReport in structured_output call; acceptance.report is \"on\".";
 export const STRUCTURED_OUTPUT_REJECTION_ERROR = "structured_output was invoked but no valid output was captured.";
 export const INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR = "Structured output invocation was rejected: invalid outputSchema.";

package/src/shared/accessible-dir.js

@@ -4,7 +4,10 @@ export function ensureAccessibleDir(dirPath, options = {}) {
     const fsImpl = options.fs ?? fs;
     const pid = options.pid ?? process.pid;
     const retryDirectoryErrors = options.retryDirectoryErrors ?? process.platform === "win32";
-    const retryDelaysMs = retryDirectoryErrors ? options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS : [];
+    // Runs synchronously at extension registration. The full ladder would block
+    // every Pi start for ~7.9 s on a directory with broken ACLs before reaching
+    // the pid fallback, so only its first steps (85 ms per operation) are used here.
+    const retryDelaysMs = retryDirectoryErrors ? options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS.slice(0, 3) : [];
     const wait = options.wait ?? waitForFileSystemRetry;
     const mkdirWithRetry = (target) => {
         runFileSystemOperationWithRetry(() => {

package/src/shared/provider-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { SubagentDelegationProviderDiagnostics } from "../api/delegation.ts";
+import type { ChildSessionEvent } from "../runs/shared/child-session.ts";
+type Diagnostics = SubagentDelegationProviderDiagnostics;
+/** Immutable, bounded observations only. This never decides whether to retry. */
+export declare function observeProviderDiagnostics(current: Diagnostics | undefined, event: ChildSessionEvent, at: number): Diagnostics | undefined;
+export declare function clearProviderRetry(current: Diagnostics | undefined): Diagnostics | undefined;
+export declare function snapshotProviderDiagnostics(current: Diagnostics | undefined): Diagnostics | undefined;
+export declare function sameProviderDiagnostics(left: Diagnostics | undefined, right: Diagnostics | undefined): boolean;
+export {};

package/src/shared/provider-diagnostics.js

@@ -0,0 +1,75 @@
+import { isRetryableAssistantError } from "@earendil-works/pi-ai";
+// Account exhaustion can also carry 429. Do not present it as transient throttling.
+// Pi's classifier supplies its own provider-specific quota/billing exclusions too.
+const ACCOUNT_LIMIT = /quota|billing|out of budget|available balance|(?:account|subscription|credits?|balance|usage)[\s_-]*(?:(?:is|are|has been|have been)[\s_-]*)?(?:limit|exhaust|deplet|exceed)|(?:insufficient|exhausted|depleted|low|no(?:[\s_-]+remaining)?)[\s_-]*(?:credits?|balance|fund)/i;
+const RATE_LIMIT = /\brate[\s_-]*limit(?:ed|ing|s|_(?:exceeded|error))?\b|\btoo[\s_-]+many[\s_-]+requests\b|\b(?:HTTP(?:\/\d(?:\.\d)?)?\s*[:=]?\s*429|(?:status|statusCode|status_code)["']?\s*[:=]?\s*429)\b|^\s*429\b/i;
+function classifyError(message) {
+    const text = message.errorMessage;
+    if (!text || ACCOUNT_LIMIT.test(text) || !isRetryableAssistantError(message))
+        return "unknown";
+    return RATE_LIMIT.test(text) ? "rate_limited" : "transient_other";
+}
+const SAFE_ERROR_MESSAGES = {
+    rate_limited: "Assistant request was rate limited.",
+    transient_other: "Assistant request encountered a transient provider or transport error.",
+    unknown: "Assistant request failed.",
+};
+/** Immutable, bounded observations only. This never decides whether to retry. */
+export function observeProviderDiagnostics(current, event, at) {
+    if (event.type === "message_end") {
+        const message = event.message;
+        if (message?.role === "assistant" && message.stopReason === "error") {
+            const kind = classifyError(message);
+            return {
+                ...current,
+                errorCount: (current?.errorCount ?? 0) + 1,
+                lastError: { kind, message: SAFE_ERROR_MESSAGES[kind], at },
+            };
+        }
+    }
+    else if (event.type === "auto_retry_start") {
+        const { attempt, maxAttempts, delayMs } = event;
+        if (typeof attempt === "number" && Number.isSafeInteger(attempt) && attempt > 0
+            && typeof maxAttempts === "number" && Number.isSafeInteger(maxAttempts) && maxAttempts >= attempt
+            && typeof delayMs === "number" && Number.isFinite(delayMs) && delayMs >= 0) {
+            return { ...current, errorCount: current?.errorCount ?? 0, retry: { phase: "backoff", attempt, maxAttempts, delayMs, scheduledAt: at } };
+        }
+    }
+    else if ((event.type === "agent_start" || event.type === "turn_start") && current?.retry?.phase === "backoff") {
+        return { ...current, retry: { ...current.retry, phase: "in_flight" } };
+    }
+    else if (event.type === "auto_retry_end" || event.type === "agent_settled") {
+        return clearProviderRetry(current);
+    }
+    return current;
+}
+export function clearProviderRetry(current) {
+    if (!current?.retry)
+        return current;
+    const { retry: _retry, ...history } = current;
+    return history;
+}
+export function snapshotProviderDiagnostics(current) {
+    if (!current)
+        return undefined;
+    return {
+        errorCount: current.errorCount,
+        ...(current.lastError ? { lastError: { ...current.lastError } } : {}),
+        ...(current.retry ? { retry: { ...current.retry } } : {}),
+    };
+}
+export function sameProviderDiagnostics(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right)
+        return false;
+    return left.errorCount === right.errorCount
+        && left.lastError?.kind === right.lastError?.kind
+        && left.lastError?.message === right.lastError?.message
+        && left.lastError?.at === right.lastError?.at
+        && left.retry?.phase === right.retry?.phase
+        && left.retry?.attempt === right.retry?.attempt
+        && left.retry?.maxAttempts === right.retry?.maxAttempts
+        && left.retry?.delayMs === right.retry?.delayMs
+        && left.retry?.scheduledAt === right.retry?.scheduledAt;
+}

package/src/shared/types.d.ts

@@ -2,6 +2,7 @@
  * Type definitions for the subagent extension
  */
 import type { Message } from "@earendil-works/pi-ai";
+import type { SubagentDelegationProviderDiagnostics } from "../api/delegation.ts";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { FSWatcher } from "node:fs";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -864,6 +865,7 @@ export interface ChildWatchdogProgress {
     warnings?: ChildWatchdogWarningSummary[];
 }
 export interface AgentProgress {
+    providerDiagnostics?: SubagentDelegationProviderDiagnostics;
     index: number;
     agent: string;
     /** Human-readable display name for the child's session, when derived at launch. */
@@ -1159,6 +1161,7 @@ export interface SingleResult {
     toolBudget?: ToolBudgetState;
     toolBudgetBlocked?: boolean;
     messages?: Message[];
+    providerDiagnostics?: SubagentDelegationProviderDiagnostics;
     usage: Usage;
     model?: string;
     /** Authoritative before/after Git evidence captured by a pane-native remote machine. */

package/src/slash/delegation-adapters.d.ts

@@ -1,4 +1,4 @@
-import { type SubagentDelegationRequest, type SubagentDelegationResponse, type SubagentDelegationThinking, type SubagentDelegationUpdate, type SubagentDelegationUpdateUsage } from "../api/delegation.ts";
+import { type SubagentDelegationProviderDiagnostics, type SubagentDelegationRequest, type SubagentDelegationResponse, type SubagentDelegationThinking, type SubagentDelegationUpdate, type SubagentDelegationUpdateUsage } from "../api/delegation.ts";
 import type { AcceptanceInput, AgentContract, EffectsProjection, ExecutionProjection, IntercomBridgeConfig, JsonSchemaObject, ReviewProjection, ToolBudgetConfig, Usage } from "../shared/types.ts";
 export interface PromptTemplateDelegationRequest {
     requestId: string;
@@ -88,6 +88,7 @@ export interface PromptTemplateBridgeResult {
             review?: ReviewProjection;
             effects?: EffectsProjection;
             usage?: Usage;
+            providerDiagnostics?: SubagentDelegationProviderDiagnostics;
             progressSummary?: {
                 toolCount?: number;
                 durationMs?: number;
@@ -116,6 +117,7 @@ export interface PromptTemplateBridgeResult {
             cacheRead?: number;
             cacheWrite?: number;
             turnCount?: number;
+            providerDiagnostics?: SubagentDelegationProviderDiagnostics;
         }>;
     };
 }

package/src/slash/delegation-adapters.js

@@ -1,4 +1,5 @@
 import { cloneJsonWithinByteLimit } from "./delegation-json.js";
+import { clearProviderRetry, snapshotProviderDiagnostics } from "../shared/provider-diagnostics.js";
 export function parsePromptTemplateRequest(data) {
     if (!data || typeof data !== "object")
         return undefined;
@@ -207,6 +208,9 @@ export function toSubagentDelegationUpdate(request, result) {
         ...(typeof legacy.durationMs === "number" ? { durationMs: legacy.durationMs } : {}),
         ...(typeof legacy.tokens === "number" ? { tokens: legacy.tokens } : {}),
         ...(legacy.usage ? { usage: legacy.usage } : {}),
+        ...(result.details?.progress?.[0]?.providerDiagnostics ? {
+            providerDiagnostics: snapshotProviderDiagnostics(result.details.progress[0].providerDiagnostics),
+        } : {}),
     };
 }
 function resolveSubagentDelegationStatus(result, aborted) {
@@ -282,6 +286,9 @@ export function toSubagentDelegationResponse(request, result, aborted) {
         ...(typeof child?.exitCode === "number" ? { exitCode: child.exitCode } : {}),
         ...(childLaunchContractDigest ? { launchContractDigest: childLaunchContractDigest } : {}),
         ...(projectedResult ? { result: projectedResult } : {}),
+        ...(child?.providerDiagnostics ? {
+            providerDiagnostics: snapshotProviderDiagnostics(clearProviderRetry(child.providerDiagnostics)),
+        } : {}),
         ...(usage ? {
             usage: {
                 input: usage.input,

package/src/slash/prompt-template-bridge.js

@@ -1,5 +1,6 @@
 import { SUBAGENT_DELEGATION_CANCEL_EVENT, SUBAGENT_DELEGATION_REQUEST_EVENT, SUBAGENT_DELEGATION_RESPONSE_EVENT, SUBAGENT_DELEGATION_STARTED_EVENT, SUBAGENT_DELEGATION_UPDATE_EVENT, } from "../api/delegation.js";
 import { parseSubagentDelegationRequest } from "./delegation-request.js";
+import { sameProviderDiagnostics } from "../shared/provider-diagnostics.js";
 import { parsePromptTemplateRequest, toDelegationUpdate, toPromptTemplateResponse, toSubagentDelegationExecutionParams, toSubagentDelegationResponse, toSubagentDelegationUpdate, } from "./delegation-adapters.js";
 export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = SUBAGENT_DELEGATION_REQUEST_EVENT;
 export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = SUBAGENT_DELEGATION_STARTED_EVENT;
@@ -58,7 +59,8 @@ function sameStructuredDelegationUpdateProgress(left, right) {
         && left.model === right.model
         && left.toolCount === right.toolCount
         && left.tokens === right.tokens
-        && sameUpdateUsage(left.usage, right.usage);
+        && sameUpdateUsage(left.usage, right.usage)
+        && sameProviderDiagnostics(left.providerDiagnostics, right.providerDiagnostics);
 }
 export function registerPromptTemplateDelegationBridge(options) {
     const legacyControllers = new Map();

package/src/slash/subagents-admin.d.ts

@@ -1,2 +1,3 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+export declare const ADMIN_MESSAGE_TYPE = "subagents-admin";
 export declare function openSubagentsAdmin(pi: ExtensionAPI, ctx: ExtensionContext, args?: string): Promise<void>;

package/src/slash/subagents-admin.js

@@ -7,7 +7,7 @@ import { editableAgentConfig, preservedAgentFrontmatterFields } from "../agents/
 import { findModelInfo, getSupportedThinkingLevels, toModelInfo } from "../shared/model-info.js";
 import { SelectorComponent } from "./selector.js";
 import { canRenderComponents } from "../shared/extension-context.js";
-const ADMIN_MESSAGE_TYPE = "subagents-admin";
+export const ADMIN_MESSAGE_TYPE = "subagents-admin";
 const INHERIT_MODEL_CHOICE = "Default / inherit session model";
 const INHERIT_THINKING_CHOICE = "Default / inherit session thinking";
 function sourceRank(source) {

package/src/tui/fleet-layout.d.ts

@@ -0,0 +1,20 @@
+export interface FleetRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface FleetLayout {
+    width: number;
+    rows: number;
+    bodyHeight: number;
+    roster: FleetRect;
+    output: FleetRect;
+    rosterStart: number;
+    rosterKeys: string[];
+}
+/** Coordinates are overlay-local, matching Pi's normalized input contract. */
+export declare function fleetLayout(width: number, rows: number, selected: number, items: readonly {
+    key: string;
+}[]): FleetLayout | undefined;
+export declare function fleetContains(rect: FleetRect, x: number, y: number): boolean;

package/src/tui/fleet-layout.js

@@ -0,0 +1,17 @@
+/** Coordinates are overlay-local, matching Pi's normalized input contract. */
+export function fleetLayout(width, rows, selected, items) {
+    if (width < 36)
+        return undefined;
+    const bodyHeight = Math.max(2, Math.floor(rows * 0.85) - 6);
+    const rosterWidth = Math.max(22, Math.min(46, Math.floor((width - 3) * 0.38)));
+    const rosterStart = Math.max(0, Math.min(selected - bodyHeight + 1, Math.max(0, items.length - bodyHeight)));
+    return {
+        width, rows, bodyHeight, rosterStart,
+        roster: { x: 1, y: 3, width: rosterWidth, height: bodyHeight },
+        output: { x: rosterWidth + 2, y: 3, width: Math.max(1, width - rosterWidth - 3), height: bodyHeight },
+        rosterKeys: items.slice(rosterStart, rosterStart + bodyHeight).map((item) => item.key),
+    };
+}
+export function fleetContains(rect, x, y) {
+    return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}

package/src/tui/fleet-viewport.d.ts

@@ -0,0 +1,12 @@
+import { ScrollView } from "@earendil-works/pi-tui";
+/** Overlay-local clipping: ordinary overlays do not enter Pi's scroll layout traversal. */
+export declare class FleetViewport {
+    private readonly body;
+    readonly scroll: ScrollView;
+    private readonly requestRender;
+    private resetTopOnLayout;
+    constructor(requestRender: () => void);
+    render(lines: string[], width: number, height: number): string[];
+    resetTop(): void;
+    follow(): void;
+}

package/src/tui/fleet-viewport.js

@@ -0,0 +1,35 @@
+import { ScrollView } from "@earendil-works/pi-tui";
+/** Overlay-local clipping: ordinary overlays do not enter Pi's scroll layout traversal. */
+export class FleetViewport {
+    body = {
+        lines: [],
+        render() { return this.lines; },
+        invalidate() { },
+    };
+    scroll = new ScrollView(this.body, { follow: "end", overscroll: "contain" });
+    requestRender;
+    resetTopOnLayout = false;
+    constructor(requestRender) {
+        this.requestRender = requestRender;
+    }
+    render(lines, width, height) {
+        this.body.lines = lines;
+        const rendered = this.scroll.render(width);
+        this.scroll.updateLayout(rendered.length, height, this.requestRender);
+        if (this.resetTopOnLayout) {
+            this.resetTopOnLayout = false;
+            this.scroll.scrollTo(0, { disableFollow: true });
+        }
+        return rendered.slice(this.scroll.scrollTop, this.scroll.scrollTop + this.scroll.viewportHeight);
+    }
+    resetTop() {
+        // Apply again after the new view's dimensions arrive: disableFollow suppresses following
+        // at the actual content end, which may differ from the previous view's end.
+        this.resetTopOnLayout = true;
+        this.scroll.scrollTo(0, { disableFollow: true });
+    }
+    follow() {
+        this.resetTopOnLayout = false;
+        this.scroll.scrollToEnd();
+    }
+}

package/src/tui/fleet.d.ts

@@ -1,5 +1,5 @@
 import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type Component, type MarkdownTheme } from "@earendil-works/pi-tui";
+import { type Component, type MarkdownTheme, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { type ExternalRun } from "../api/external-runs.ts";
 import { type FleetKeybindingAction, type FleetKeybindingsConfig, type ForegroundChildControl, type ForegroundResumeChild, type ForegroundResumeRun, type ForegroundRunControl, type SubagentState } from "../shared/types.ts";
 import { type AsyncRunSummary } from "../runs/background/async-status.ts";
@@ -111,11 +111,8 @@ export declare class SubagentFleetComponent implements Component {
     private snapshot;
     private selected;
     private selectedKey;
-    private detailScroll;
-    private detailAutoFollow;
-    private detailLineCount;
-    private detailViewportHeight;
-    private bodyHeight;
+    private readonly viewport;
+    private renderedLayout;
     private expandedTools;
     private promptAuditOpen;
     private promptAuditView;
@@ -141,6 +138,7 @@ export declare class SubagentFleetComponent implements Component {
     private stopRefresh;
     private refresh;
     private moveSelection;
+    private selectItem;
     private selectedPromptAudit;
     private promptAuditItems;
     private selectedPromptText;
@@ -155,6 +153,7 @@ export declare class SubagentFleetComponent implements Component {
     private setActionNotice;
     private runAction;
     private scrollDetail;
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
     handleInput(data: string): void;
     private rosterLines;
     private renderedTranscript;