pi-maestro-teammate 1.0.0 → 1.2.0

package/package.json

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

package/src/extension/index.ts

@@ -886,6 +886,14 @@ function toolAction(name: string): string {
   return `using ${name}`;
 }
 
+function formatRetryDelay(delayMs: number): string {
+  const seconds = Math.max(0, Math.ceil(delayMs / 1_000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+
 function agentWidgetRows(agents: ActiveAgent[]): AgentWidgetRow[] {
   const rows = new Map<string, AgentWidgetRow>();
   const directAgents = new Map(agents.map((agent) => [agent.correlationId, agent]));
@@ -913,7 +921,11 @@ function agentWidgetRows(agents: ActiveAgent[]): AgentWidgetRow[] {
         : status === "sleeping"
           ? "sleeping"
           : status === "retrying"
-            ? `retry ${direct?.retry?.attempt ?? "?"}/${direct?.retry?.maxRetries ?? "?"}`
+            ? direct?.retry
+              ? `retry ${direct.retry.attempt}/${direct.retry.maxRetries} in ${formatRetryDelay(
+                direct.retry.nextRetryAt - Date.now(),
+              )}`
+              : "retrying"
           : status === "pending"
             ? "waiting for dependencies"
             : status === "failed"
@@ -1251,6 +1263,32 @@ export function rejectAllChildProxyRequests(
 }
 
 /** @internal Exported for lifecycle regression tests. */
+export type IpcSender = (
+  message: Record<string, unknown>,
+  callback: (error: Error | null) => void,
+) => boolean;
+
+/**
+ * Builds the IPC sender the teammate proxy uses to talk to its parent.
+ *
+ * Node's IPC `send` reads `this.connected` internally, so detaching it from its
+ * owner (`const send = proc.send`) leaves `this` undefined in module scope and
+ * throws "Cannot read properties of undefined (reading 'connected')" on the
+ * first call — which broke every proxied teammate tool in a nested child.
+ * Binding the owner keeps the proxied call working. Returns undefined when no
+ * live IPC channel exists.
+ */
+export function createIpcSender(
+  // Node's IPC process.send is a loosely-typed boundary (message: any); any[]
+  // is the signature both process.send and test fakes satisfy without casts.
+  proc: { connected?: boolean; send?: (...args: any[]) => boolean } = process,
+): IpcSender | undefined {
+  const rawSend = proc.send;
+  if (typeof rawSend !== "function" || proc.connected === false) return undefined;
+  const send = rawSend.bind(proc);
+  return (message, callback) => send(message, callback);
+}
+
 export function createChildProxyRequest(
   pendingRequests: ChildProxyPendingRequests,
   requestId: string,
@@ -1562,8 +1600,8 @@ export default function registerTeammateExtension(
       params: unknown,
       signal?: AbortSignal,
     ): Promise<TeammateToolResult<T>> {
-      const send = process.send;
-      if (typeof send !== "function" || process.connected === false) {
+      const send = createIpcSender();
+      if (!send) {
         throw new Error("IPC not available. Teammate proxy requires IPC channel.");
       }
       const requestId = randomUUID();
@@ -1577,7 +1615,7 @@ export default function registerTeammateExtension(
           params,
           correlationId: process.env.PI_TEAMMATE_CORRELATION_ID,
         },
-        (message, callback) => send(message, callback),
+        send,
         CHILD_PROXY_TIMEOUT_MS,
         signal,
       );
@@ -5378,6 +5416,7 @@ export async function handleProxyRequest(
       const reportChildStatus = (
         status: ChildAgentCallSnapshot["status"],
         progress?: AgentProgress,
+        retryMessage?: string,
       ): void => {
         onChildStatus?.({
           agent: activeAgent.agent,
@@ -5396,6 +5435,9 @@ export async function handleProxyRequest(
             outputTokens: progress.outputTokens,
             ...(progress.lastMessage ? { lastMessage: truncateUtf8Tail(progress.lastMessage, AGENT_BUFFER_LIMITS.lastResultBytes) } : {}),
           } : {}),
+          ...(!progress?.lastMessage && retryMessage
+            ? { lastMessage: truncateUtf8Tail(retryMessage, AGENT_BUFFER_LIMITS.lastResultBytes) }
+            : {}),
         });
       };
 
@@ -5583,7 +5625,11 @@ export async function handleProxyRequest(
         }),
         onRetry: (retry) => {
           applyAgentRetryState(state, retry);
-          reportChildStatus("retrying");
+          reportChildStatus(
+            "retrying",
+            undefined,
+            `retry ${retry.attempt}/${retry.maxRetries} in ${formatRetryDelay(retry.delayMs)}: ${retry.error}`,
+          );
         },
         onTurnComplete: (result) => {
           const lastMessage = displayMessageForResult(result);

package/src/models/model-circuit-breaker.ts

@@ -40,6 +40,8 @@ interface MutableModelCircuit {
   generation: number;
   openedAt?: number;
   halfOpenTrialInProgress: boolean;
+  /** Timestamp when the circuit entered HALF_OPEN; used as a watchdog deadline. */
+  halfOpenEnteredAt?: number;
 }
 
 export class ModelCircuitBreaker {
@@ -74,11 +76,23 @@ export class ModelCircuitBreaker {
     }
 
     if (circuit.state === "HALF_OPEN") {
-      return {
-        allowed: false,
-        model,
-        state: "HALF_OPEN",
-      };
+      // Watchdog: if the HALF_OPEN trial has not settled within cooldownMs,
+      // the trial holder likely crashed or leaked.  Re-open so the normal
+      // OPEN → cooldown → HALF_OPEN recovery cycle can proceed.
+      // Skipped when cooldownMs is 0 because the watchdog would fire
+      // immediately and break the single-trial invariant.
+      if (this.cooldownMs > 0
+        && circuit.halfOpenEnteredAt !== undefined
+        && this.now() >= circuit.halfOpenEnteredAt + this.cooldownMs) {
+        this.open(circuit);
+        // Fall through to the OPEN branch below (retryAt check).
+      } else {
+        return {
+          allowed: false,
+          model,
+          state: "HALF_OPEN",
+        };
+      }
     }
 
     const retryAt = this.retryAt(circuit);
@@ -93,6 +107,7 @@ export class ModelCircuitBreaker {
 
     circuit.state = "HALF_OPEN";
     circuit.halfOpenTrialInProgress = true;
+    circuit.halfOpenEnteredAt = this.now();
     return {
       allowed: true,
       model,
@@ -111,6 +126,7 @@ export class ModelCircuitBreaker {
     circuit.consecutiveFailures = 0;
     circuit.openedAt = undefined;
     circuit.halfOpenTrialInProgress = false;
+    circuit.halfOpenEnteredAt = undefined;
     if (acquisition.state === "HALF_OPEN") circuit.generation += 1;
   }
 
@@ -171,6 +187,7 @@ export class ModelCircuitBreaker {
     circuit.state = "OPEN";
     circuit.openedAt = this.now();
     circuit.halfOpenTrialInProgress = false;
+    circuit.halfOpenEnteredAt = undefined;
     circuit.generation += 1;
   }
 

package/src/runs/execution.ts

@@ -952,7 +952,9 @@ function isFallbackModelError(messages: Array<{ role: string; content: string }>
 }
 
 function resultFailureMessage(messages: Array<{ role: string; content: string }>): string {
-  return [...messages].reverse().find((message) => message.role === "system")?.content
+  const newestFirst = [...messages].reverse();
+  return newestFirst.find((message) => isRetryableProviderError(message.content))?.content
+    ?? newestFirst.find((message) => message.role === "system")?.content
     ?? messages.at(-1)?.content
     ?? "Unknown teammate failure";
 }
@@ -972,6 +974,102 @@ function waitForRetryDelay(delayMs: number, signal?: AbortSignal): Promise<boole
   });
 }
 
+interface RetrySettingSnapshot {
+  hadRetry: boolean;
+  hadEnabled: boolean;
+  enabled?: boolean;
+}
+
+interface RetryPersistenceGuard {
+  depth: number;
+  snapshot?: RetrySettingSnapshot;
+  restoreTimer?: ReturnType<typeof setTimeout>;
+}
+
+const retryPersistenceGuards = new Map<string, RetryPersistenceGuard>();
+
+/**
+ * Pi's RPC set_auto_retry command persists to settings.json even though the
+ * child only needs a session-local override. Restore the original value after
+ * every concurrently starting child has acknowledged that command.
+ */
+export function acquireRetryPersistenceGuard(settingsPath: string): () => void {
+  const existing = retryPersistenceGuards.get(settingsPath);
+  if (!existing) {
+    const snapshot = readRetrySettingSnapshot(settingsPath);
+    if (snapshot?.hadEnabled && snapshot.enabled === false) return () => {};
+  }
+  if (existing?.restoreTimer) {
+    clearTimeout(existing.restoreTimer);
+    existing.restoreTimer = undefined;
+  }
+  const guard = existing ?? {
+    depth: 0,
+    snapshot: readRetrySettingSnapshot(settingsPath),
+  };
+  guard.depth += 1;
+  retryPersistenceGuards.set(settingsPath, guard);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    guard.depth -= 1;
+    if (guard.depth > 0) return;
+    guard.restoreTimer = setTimeout(() => {
+      guard.restoreTimer = undefined;
+      if (guard.depth > 0) return;
+      retryPersistenceGuards.delete(settingsPath);
+      if (guard.snapshot) restoreRetrySettingSnapshot(settingsPath, guard.snapshot);
+    }, 250);
+  };
+}
+
+function readRetrySettingSnapshot(settingsPath: string): RetrySettingSnapshot | undefined {
+  try {
+    const root = JSON.parse(fs.readFileSync(settingsPath, "utf8")) as unknown;
+    if (!root || typeof root !== "object" || Array.isArray(root)) return undefined;
+    const retry = (root as Record<string, unknown>).retry;
+    const hadRetry = Boolean(retry && typeof retry === "object" && !Array.isArray(retry));
+    const record = hadRetry ? retry as Record<string, unknown> : undefined;
+    return {
+      hadRetry,
+      hadEnabled: typeof record?.enabled === "boolean",
+      ...(typeof record?.enabled === "boolean" ? { enabled: record.enabled } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function restoreRetrySettingSnapshot(settingsPath: string, snapshot: RetrySettingSnapshot): void {
+  try {
+    const root = JSON.parse(fs.readFileSync(settingsPath, "utf8")) as Record<string, unknown>;
+    if (!root || typeof root !== "object" || Array.isArray(root)) return;
+    const retry = root.retry && typeof root.retry === "object" && !Array.isArray(root.retry)
+      ? { ...root.retry as Record<string, unknown> }
+      : {};
+    const currentHadEnabled = typeof retry.enabled === "boolean";
+    if (
+      currentHadEnabled === snapshot.hadEnabled
+      && (!snapshot.hadEnabled || retry.enabled === snapshot.enabled)
+    ) return;
+    if (snapshot.hadEnabled) retry.enabled = snapshot.enabled;
+    else delete retry.enabled;
+    if (!snapshot.hadRetry && Object.keys(retry).length === 0) delete root.retry;
+    else root.retry = retry;
+    const temporary = `${settingsPath}.${process.pid}.${randomUUID()}.retry.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(root, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    fs.renameSync(temporary, settingsPath);
+  } catch {
+    // Best effort: a failed restore must not hide the child result.
+  }
+}
+
+function childSettingsPath(env: NodeJS.ProcessEnv): string {
+  const agentDir = env.PI_CODING_AGENT_DIR?.trim() || path.join(os.homedir(), ".pi", "agent");
+  return path.join(agentDir, "settings.json");
+}
+
 // ---------------------------------------------------------------------------
 // Build pi CLI arguments
 // ---------------------------------------------------------------------------
@@ -1605,51 +1703,61 @@ export async function runSingleTeammate(
     if (acquisition && !acquisition.allowed) continue;
     if (modelToUse && !attemptedModels.includes(modelToUse)) attemptedModels.push(modelToUse);
 
-    const maxRetries = acquisition?.state === "HALF_OPEN" ? 0 : NETWORK_RETRY_POLICY.maxRetries;
-    let retryCount = 0;
-    let candidateResult: SingleResult | undefined;
+    let settled = false;
+    try {
+      const maxRetries = acquisition?.state === "HALF_OPEN" ? 0 : NETWORK_RETRY_POLICY.maxRetries;
+      let retryCount = 0;
+      let candidateResult: SingleResult | undefined;
 
-    while (!options.signal?.aborted) {
-      candidateResult = await runSingleAttempt(
-        params, agentConfig, cwd, correlationId, replyTo, startTime, modelToUse, options,
-      );
-      lastResult = candidateResult;
-      const error = resultFailureMessage(candidateResult.messages);
-      const retryable = candidateResult.exitCode !== 0 && isRetryableProviderError(error);
-      const fallbackEligible = candidateResult.exitCode !== 0 && isFallbackProviderError(error);
+      while (!options.signal?.aborted) {
+        candidateResult = await runSingleAttempt(
+          params, agentConfig, cwd, correlationId, replyTo, startTime, modelToUse, options,
+        );
+        lastResult = candidateResult;
+        const error = resultFailureMessage(candidateResult.messages);
+        const retryable = candidateResult.exitCode !== 0 && isRetryableProviderError(error);
+        const fallbackEligible = candidateResult.exitCode !== 0 && isFallbackProviderError(error);
+
+        if (candidateResult.exitCode === 0) {
+          if (acquisition?.allowed) { breaker.recordSuccess(acquisition); settled = true; }
+          candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
+          return candidateResult;
+        }
+        if (!retryable || retryCount >= maxRetries) {
+          if (fallbackEligible && acquisition?.allowed) { breaker.recordRetryableFailure(acquisition); settled = true; }
+          break;
+        }
+
+        retryCount += 1;
+        const delayMs = retryDelayMs(retryCount);
+        options.onRetry?.({
+          correlationId,
+          attempt: retryCount,
+          maxRetries,
+          delayMs,
+          nextRetryAt: Date.now() + delayMs,
+          error,
+        });
+        const ready = await (options.waitForRetry?.(delayMs, options.signal) ?? waitForRetryDelay(delayMs, options.signal));
+        if (!ready) break;
+      }
 
-      if (candidateResult.exitCode === 0) {
-        if (acquisition?.allowed) breaker.recordSuccess(acquisition);
+      if (!candidateResult) {
+        if (acquisition?.allowed) { breaker.releaseCandidate(acquisition); settled = true; }
+        continue;
+      }
+      if (!isFallbackModelError(candidateResult.messages)) {
+        if (acquisition?.allowed) { breaker.releaseCandidate(acquisition); settled = true; }
         candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
         return candidateResult;
       }
-      if (!retryable || retryCount >= maxRetries) {
-        if (fallbackEligible && acquisition?.allowed) breaker.recordRetryableFailure(acquisition);
-        break;
+    } finally {
+      // Safety net: if a HALF_OPEN trial was acquired but never settled
+      // (e.g. runSingleAttempt threw, or error-classification diverged),
+      // release it so the circuit does not stay stuck in HALF_OPEN forever.
+      if (!settled && acquisition?.allowed && acquisition.state === "HALF_OPEN") {
+        breaker.releaseCandidate(acquisition);
       }
-
-      retryCount += 1;
-      const delayMs = retryDelayMs(retryCount);
-      options.onRetry?.({
-        correlationId,
-        attempt: retryCount,
-        maxRetries,
-        delayMs,
-        nextRetryAt: Date.now() + delayMs,
-        error,
-      });
-      const ready = await (options.waitForRetry?.(delayMs, options.signal) ?? waitForRetryDelay(delayMs, options.signal));
-      if (!ready) break;
-    }
-
-    if (!candidateResult) {
-      if (acquisition?.allowed) breaker.releaseCandidate(acquisition);
-      continue;
-    }
-    if (!isFallbackModelError(candidateResult.messages)) {
-      if (acquisition?.allowed) breaker.releaseCandidate(acquisition);
-      candidateResult.attemptedModels = attemptedModels.length > 1 ? attemptedModels : undefined;
-      return candidateResult;
     }
   }
 
@@ -1879,6 +1987,7 @@ async function runSingleAttempt(
 
   return new Promise<SingleResult>((resolve) => {
     let child: ChildProcess;
+    let releaseRetryPersistenceGuard = () => {};
 
     const spawnEnv = buildChildSpawnEnv(correlationId, replyTo, options, schemaFile, outputFile);
 
@@ -1891,6 +2000,7 @@ async function runSingleAttempt(
         stdio: useIpc ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"],
         env: spawnEnv,
         shell: spawnSpec.shell,
+        windowsHide: true,
       };
       child = (options.spawnChildProcess ?? crossSpawn)(spawnSpec.command, spawnSpec.args, spawnOpts);
     } catch (error) {
@@ -1921,6 +2031,7 @@ async function runSingleAttempt(
     // Teammate owns retry and model failover for child runs. Disable Pi's inner
     // retry loop first so one provider failure cannot multiply both budgets.
     if (child.stdin) {
+      releaseRetryPersistenceGuard = acquireRetryPersistenceGuard(childSettingsPath(spawnEnv));
       writeChildStdinLine(child.stdin, JSON.stringify({ type: "set_auto_retry", enabled: false }));
     }
 
@@ -2013,6 +2124,7 @@ async function runSingleAttempt(
       exitCode = 0,
     ): void {
       if (state.terminal || state.turnLifecycleSettled) return;
+      releaseRetryPersistenceGuard();
       state.turnLifecycleSettled = true;
       progress.status = exitCode === 0 ? "completed" : "failed";
       progress.resultReadyAt = undefined;
@@ -2374,8 +2486,9 @@ async function runSingleAttempt(
       ["message_end", onAssistantMessage],
       ["assistant", onAssistantMessage],
       ["message_update", onMessageUpdate],
-      // RPC acknowledgement — nothing to record.
-      ["response", () => {}],
+      ["response", (event) => {
+        if (event.command === "set_auto_retry") releaseRetryPersistenceGuard();
+      }],
       ["tool_execution_start", onToolStart],
       ["tool_execution_end", onToolCompleted],
       ["tool_result_end", onToolCompleted],
@@ -2418,6 +2531,7 @@ async function runSingleAttempt(
     });
 
     child.on("close", (code, signal) => {
+      releaseRetryPersistenceGuard();
       clearAllTimers();
       termination.cleanup();
       unbindTerminationSignal();
@@ -2502,6 +2616,7 @@ async function runSingleAttempt(
     });
 
     child.on("error", (error) => {
+      releaseRetryPersistenceGuard();
       clearAllTimers();
       unbindTerminationSignal();
 

package/src/runs/retry.ts

@@ -1,43 +1,43 @@
-export const NETWORK_RETRY_POLICY = Object.freeze({
-  maxRetries: 5,
-  initialDelayMs: 1_000,
-  maxDelayMs: 16_000,
-});
-
-export type RetryErrorKind = "network" | "provider" | "non-retryable";
-
-const NON_RETRYABLE_ERROR =
-  /usage[_\s-]*limit|multi-auth rotation failed|unauthori[sz]ed|invalid api key|forbidden|invalid model|unknown model|context[_\s-]*length[_\s-]*exceeded|input exceeds the context window|schema[-\s]*valid|validation (?:failed|error)/i;
-
-const NETWORK_ERROR =
-  /\b(?:econnreset|econnrefused|ehostunreach|enotfound|eai_again|etimedout|socket hang up|fetch failed|network(?: error| request)?|websocket closed|sse response headers timed out|headers timed out|tls|certificate)\b/i;
-
-const PROVIDER_ERROR =
-  /\b(?:429|5\d\d|rate limit(?:ed)?|capacity|overloaded|unavailable|provider returned error)\b/i;
-
-const FALLBACK_ONLY_ERROR =
-  /\b(?:402|insufficient (?:balance|credits?)|credits? exhausted|billing quota)\b/i;
-
-export function classifyRetryError(message: string | undefined): RetryErrorKind {
-  if (!message || NON_RETRYABLE_ERROR.test(message)) return "non-retryable";
-  if (NETWORK_ERROR.test(message)) return "network";
-  if (PROVIDER_ERROR.test(message)) return "provider";
-  return "non-retryable";
-}
-
-export function isRetryableProviderError(message: string | undefined): boolean {
-  return classifyRetryError(message) !== "non-retryable";
-}
-
-export function isFallbackProviderError(message: string | undefined): boolean {
-  if (!message || NON_RETRYABLE_ERROR.test(message)) return false;
-  return isRetryableProviderError(message) || FALLBACK_ONLY_ERROR.test(message);
-}
-
-export function retryDelayMs(retry: number): number {
-  const normalizedRetry = Math.max(1, Math.floor(retry));
-  return Math.min(
-    NETWORK_RETRY_POLICY.initialDelayMs * 2 ** (normalizedRetry - 1),
-    NETWORK_RETRY_POLICY.maxDelayMs,
-  );
-}
+export const NETWORK_RETRY_POLICY = Object.freeze({
+  maxRetries: 12,
+  initialDelayMs: 1_000,
+  maxDelayMs: 10 * 60_000,
+});
+
+export type RetryErrorKind = "network" | "provider" | "non-retryable";
+
+const NON_RETRYABLE_ERROR =
+  /usage[_\s-]*limit|multi-auth rotation failed|unauthori[sz]ed|invalid api key|forbidden|invalid model|unknown model|context[_\s-]*length[_\s-]*exceeded|input exceeds the context window|schema[-\s]*valid|validation (?:failed|error)/i;
+
+const NETWORK_ERROR =
+  /\b(?:econnreset|econnrefused|ehostunreach|enotfound|eai_again|etimedout|socket hang up|fetch failed|network(?: error| request)?|connection (?:error|failed|failure|reset|refused|timed out|timeout|closed)|websocket closed|sse response headers timed out|headers timed out|tls|certificate)\b/i;
+
+const PROVIDER_ERROR =
+  /\b(?:429|5\d\d|rate limit(?:ed)?|capacity|overloaded|unavailable|provider returned error)\b/i;
+
+const FALLBACK_ONLY_ERROR =
+  /\b(?:402|insufficient (?:balance|credits?)|credits? exhausted|billing quota)\b/i;
+
+export function classifyRetryError(message: string | undefined): RetryErrorKind {
+  if (!message || NON_RETRYABLE_ERROR.test(message)) return "non-retryable";
+  if (NETWORK_ERROR.test(message)) return "network";
+  if (PROVIDER_ERROR.test(message)) return "provider";
+  return "non-retryable";
+}
+
+export function isRetryableProviderError(message: string | undefined): boolean {
+  return classifyRetryError(message) !== "non-retryable";
+}
+
+export function isFallbackProviderError(message: string | undefined): boolean {
+  if (!message || NON_RETRYABLE_ERROR.test(message)) return false;
+  return isRetryableProviderError(message) || FALLBACK_ONLY_ERROR.test(message);
+}
+
+export function retryDelayMs(retry: number): number {
+  const normalizedRetry = Math.max(1, Math.floor(retry));
+  return Math.min(
+    NETWORK_RETRY_POLICY.initialDelayMs * 2 ** (normalizedRetry - 1),
+    NETWORK_RETRY_POLICY.maxDelayMs,
+  );
+}

package/src/tui/render.ts

@@ -217,27 +217,13 @@ function renderMultiTaskCall(
     return dynamicComponent((w) => [header, ...tree.map((row) => row.text)]
       .map((line) => truncateToWidth(line, Math.max(1, w), "…")));
   }
-  // 前台 progress 紧随调用行渲染，已包含同一任务拓扑及实时状态。
+  // 结果组件（前台流式 progress / 后台 ack 的 progress 快照）紧随调用行渲染，
+  // 已包含同一任务拓扑、依赖边与实时状态（后台还带 correlation id）。
   // collapsed 调用仅保留启动摘要，避免相邻组件重复显示任务行。
-  if (!isBg) {
-    return dynamicComponent((w) => [
-      truncateToWidth(header, Math.max(1, w), "…"),
-    ]);
-  }
-  // Collapsed: list every agent with its dependency edges so the DAG stays visible.
-  const agentLines = tasks.map((task, index) => {
-    const label = task.name
-      ? `${theme.fg("accent", `@${task.name}`)} ${theme.fg("dim", `(${task.agent})`)}`
-      : theme.fg("accent", task.agent);
-    const deps = dependenciesByIndex[index];
-    const flowMarker = deps.length > 0 ? "→" : "•";
-    const dependencyHint = deps.length > 0
-      ? theme.fg("dim", ` ← result${deps.length === 1 ? "" : "s"} ${deps.map((d) => `#${d + 1}`).join(", ")}`)
-      : "";
-    return `${theme.fg("dim", flowMarker)} ${theme.fg("accent", String(index + 1))} ${theme.fg("dim", "□")} ${label}${dependencyHint}`;
-  });
-  return dynamicComponent((w) => [header, ...agentLines]
-    .map((line) => truncateToWidth(line, Math.max(1, w), "…")));
+  // DAG 细节仍可在 expanded 调用视图与结果 progress 树中查看。
+  return dynamicComponent((w) => [
+    truncateToWidth(header, Math.max(1, w), "…"),
+  ]);
 }
 
 function isLinearChain(tasks: TaskArg[], taskNames: Set<string>): boolean {

package/types/extension/index.d.ts

@@ -155,6 +155,21 @@ export declare function rejectChildProxyRequest(pendingRequests: ChildProxyPendi
 /** @internal Exported for lifecycle regression tests. */
 export declare function rejectAllChildProxyRequests(pendingRequests: ChildProxyPendingRequests, error: Error): void;
 /** @internal Exported for lifecycle regression tests. */
+export type IpcSender = (message: Record<string, unknown>, callback: (error: Error | null) => void) => boolean;
+/**
+ * Builds the IPC sender the teammate proxy uses to talk to its parent.
+ *
+ * Node's IPC `send` reads `this.connected` internally, so detaching it from its
+ * owner (`const send = proc.send`) leaves `this` undefined in module scope and
+ * throws "Cannot read properties of undefined (reading 'connected')" on the
+ * first call — which broke every proxied teammate tool in a nested child.
+ * Binding the owner keeps the proxied call working. Returns undefined when no
+ * live IPC channel exists.
+ */
+export declare function createIpcSender(proc?: {
+    connected?: boolean;
+    send?: (...args: any[]) => boolean;
+}): IpcSender | undefined;
 export declare function createChildProxyRequest(pendingRequests: ChildProxyPendingRequests, requestId: string, message: Record<string, unknown>, send: (message: Record<string, unknown>, callback: (error: Error | null) => void) => boolean, timeoutMs?: number, signal?: AbortSignal): Promise<unknown>;
 export default function registerTeammateExtension(pi: ExtensionAPI, runtimeOptions?: TeammateRuntimeOptions): void;
 type AgentListView = "active" | "named" | "all";

package/types/runs/execution.d.ts

@@ -248,6 +248,12 @@ export declare function checkDepthGuard(depth: number): {
     current: number;
     max: number;
 };
+/**
+ * Pi's RPC set_auto_retry command persists to settings.json even though the
+ * child only needs a session-local override. Restore the original value after
+ * every concurrently starting child has acknowledged that command.
+ */
+export declare function acquireRetryPersistenceGuard(settingsPath: string): () => void;
 export declare function clampThinkingForModel(thinking: TeammateThinkingLevel, model: string | undefined, modelCapabilities?: readonly TeammateModelCapability[]): TeammateThinkingLevel;
 export declare function validateModelSpecifier(model: string): string;
 export declare function resolveModelSpecifier(model: string, modelCapabilities?: readonly TeammateModelCapability[]): string;

package/types/runs/retry.d.ts

@@ -1,7 +1,7 @@
 export declare const NETWORK_RETRY_POLICY: Readonly<{
-    maxRetries: 5;
+    maxRetries: 12;
     initialDelayMs: 1000;
-    maxDelayMs: 16000;
+    maxDelayMs: number;
 }>;
 export type RetryErrorKind = "network" | "provider" | "non-retryable";
 export declare function classifyRetryError(message: string | undefined): RetryErrorKind;