pi-fast-subagent 0.9.2 → 0.9.4

package/README.md

@@ -272,14 +272,6 @@ Cancel a specific job directly:
 /fast-subagent:bg-cancel sa_ab12cd34
 ```
 
-### `/fast-subagent:debug-model`
-
-Show cached/inferred main-model state used for model inheritance troubleshooting.
-
-```
-/fast-subagent:debug-model
-```
-
 ## Keyboard Shortcuts
 
 | Shortcut | Action |

package/index.ts

@@ -27,7 +27,7 @@ import {
 } from "./format.js";
 import { defaultLoaderPool } from "./loader-pool.js";
 import { renderSubagentCall, renderSubagentResult } from "./render.js";
-import { DEPTH_ENV, getCurrentDepth, mapConcurrent, resolveModelObject, runAgent } from "./runner.js";
+import { mapConcurrent, runAgent } from "./runner.js";
 import { SubagentParams } from "./schemas.js";
 import type { AgentRowStatus, OnUpdate, RunResult, SubagentDetails, ToolCallEntry } from "./types.js";
 
@@ -36,9 +36,6 @@ import type { AgentRowStatus, OnUpdate, RunResult, SubagentDetails, ToolCallEntr
 let _bgManager: BackgroundJobManager | null = null;
 let _onBgJobComplete: ((job: BackgroundSubagentJob) => void) | null = null;
 let _setBgStatus: ((text: string | undefined) => void) | null = null;
-let _currentMainModel: string | undefined;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _currentMainModelObject: any | undefined;
 
 function getBgManager(): BackgroundJobManager {
   if (!_bgManager) _bgManager = new BackgroundJobManager({
@@ -52,53 +49,6 @@ function refreshBgStatus(): void {
   _setBgStatus?.(running.length > 0 ? `⧗ ${running.length} bg agent${running.length > 1 ? "s" : ""}` : undefined);
 }
 
-function rememberMainModel(model: ExtensionContext["model"]): void {
-  if (!model) return;
-  _currentMainModel = `${model.provider}/${model.id}`;
-  _currentMainModelObject = model;
-}
-
-function rememberMainModelReference(modelRef: string | undefined, ctx: ExtensionContext): void {
-  if (!modelRef) return;
-  _currentMainModel = modelRef;
-  _currentMainModelObject = resolveModelObject(ctx.modelRegistry, modelRef) ?? _currentMainModelObject;
-}
-
-function rememberPayloadModel(payload: unknown, ctx: ExtensionContext): void {
-  const modelId = typeof payload === "object" && payload && "model" in payload && typeof (payload as { model?: unknown }).model === "string"
-    ? (payload as { model: string }).model
-    : undefined;
-  if (!modelId) return;
-
-  const lower = modelId.toLowerCase();
-  const matches = ctx.modelRegistry.getAll().filter((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
-  if (matches.length === 1) rememberMainModel(matches[0]);
-}
-
-function isMainSessionEvent(): boolean {
-  return !process.env[DEPTH_ENV];
-}
-
-function rememberLatestSessionModel(ctx: ExtensionContext): void {
-  const scan = (entries: ReturnType<ExtensionContext["sessionManager"]["getEntries"]>): boolean => {
-    for (let i = entries.length - 1; i >= 0; i--) {
-      const e = entries[i]!;
-      if (e.type === "model_change") {
-        rememberMainModelReference(`${(e as any).provider}/${(e as any).modelId}`, ctx);
-        return true;
-      }
-    }
-    return false;
-  };
-  if (!scan(ctx.sessionManager.getEntries())) scan(ctx.sessionManager.getBranch());
-}
-
-function getInheritedMainModel(ctx: ExtensionContext): { modelRef?: string; deps: { modelRegistry: ExtensionContext["modelRegistry"]; modelObject?: unknown } } {
-  rememberMainModel(ctx.model);
-  if (!_currentMainModelObject && _currentMainModel) rememberMainModelReference(_currentMainModel, ctx);
-  if (_currentMainModelObject) return { modelRef: _currentMainModel, deps: { modelRegistry: ctx.modelRegistry, modelObject: _currentMainModelObject } };
-  return { modelRef: _currentMainModel, deps: { modelRegistry: ctx.modelRegistry } };
-}
 
 // ─── Foreground detach registry ─────────────────────────────────────────────
 
@@ -135,28 +85,8 @@ export default function (pi: ExtensionAPI) {
     );
   };
 
-  pi.on("model_select", async (event) => {
-    if (!isMainSessionEvent()) return;
-    rememberMainModel(event.model);
-  });
-
-  pi.on("before_provider_request", async (event, ctx) => {
-    if (!isMainSessionEvent()) return;
-    if (ctx.model) rememberMainModel(ctx.model);
-    else rememberPayloadModel(event.payload, ctx);
-  });
-
-  pi.on("turn_start", async (_event, ctx) => {
-    if (!isMainSessionEvent()) return;
-    rememberMainModel(ctx.model);
-  });
-
   pi.on("session_start", async (_event, ctx) => {
     _setBgStatus = (text) => ctx.ui.setStatus(BG_STATUS_KEY, text);
-    if (!isMainSessionEvent()) return;
-    // Seed _currentMainModel from ctx.model or session entries.
-    if (ctx.model) rememberMainModel(ctx.model);
-    else rememberLatestSessionModel(ctx);
 
     // Warm one extension-capable loader after startup so first `tools: all`
     // subagent call reuses loaded extensions instead of blocking.
@@ -171,8 +101,6 @@ export default function (pi: ExtensionAPI) {
     getBgManager().shutdown();
     _bgManager = null;
     _setBgStatus = null;
-    _currentMainModel = undefined;
-    _currentMainModelObject = undefined;
     defaultLoaderPool.clear();
   });
 
@@ -197,30 +125,6 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  // ─── /fast-subagent:debug-model ──────────────────────────────────────────
-  pi.registerCommand("fast-subagent:debug-model", {
-    description: "Debug: show cached main model and session entries.",
-    async handler(_args, ctx) {
-      const entries = ctx.sessionManager.getEntries();
-      const modelEntries = entries.filter((e) => e.type === "model_change");
-      const branch = ctx.sessionManager.getBranch();
-      const branchModelEntries = branch.filter((e) => e.type === "model_change");
-      if (!_currentMainModelObject && _currentMainModel) rememberMainModelReference(_currentMainModel, ctx);
-      const registryMatch = resolveModelObject(ctx.modelRegistry, _currentMainModel);
-      const lines = [
-        `_currentMainModel: ${_currentMainModel ?? "(undefined)"}`,
-        `_currentMainModelObject: ${_currentMainModelObject ? `${_currentMainModelObject.provider}/${_currentMainModelObject.id}` : "(undefined)"}`,
-        `ctx.model: ${ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "(undefined)"}`,
-        `resolveModelObject(_currentMainModel): ${registryMatch ? `${registryMatch.provider}/${registryMatch.id}` : "(undefined)"}`,
-        `getEntries() total: ${entries.length}`,
-        `getEntries() model_change: ${modelEntries.map((e) => `${(e as any).provider}/${(e as any).modelId}`).join(", ") || "none"}`,
-        `getBranch() total: ${branch.length}`,
-        `getBranch() model_change: ${branchModelEntries.map((e) => `${(e as any).provider}/${(e as any).modelId}`).join(", ") || "none"}`,
-      ];
-      ctx.ui.notify(lines.join("\n"), "info");
-    },
-  });
-
   // ─── /fast-subagent:agent ─────────────────────────────────────────────────
   pi.registerCommand("fast-subagent:agent", {
     description: "List available subagents. Usage: /fast-subagent:agent [name] — show details for a specific agent.",
@@ -514,26 +418,13 @@ export default function (pi: ExtensionAPI) {
         const { agent, error } = findAgent(params.agent);
         if (error || !agent) return { content: [{ type: "text", text: error ?? "Not found" }] };
 
-        // Determine if this agent should inherit the main session's model.
-        const shouldInherit = !params.model && (!agent.model || agent.model === "inherit");
-        let inheritedModel: string | undefined;
-        let inheritDeps: { modelRegistry: ExtensionContext["modelRegistry"]; modelObject?: unknown } = { modelRegistry: ctx.modelRegistry };
-        if (shouldInherit) {
-          let inherited = getInheritedMainModel(ctx);
-          if (!inherited.modelRef) {
-            rememberLatestSessionModel(ctx);
-            inherited = getInheritedMainModel(ctx);
-          }
-          inheritedModel = inherited.modelRef;
-          inheritDeps = inherited.deps;
-        }
-        const effectiveModel = params.model ?? (shouldInherit ? inheritedModel : (agent.model === "inherit" ? undefined : agent.model));
+        const effectiveModel = params.model;
 
         if (params.background) {
           const bgAbort = new AbortController();
           const handle: BackgroundHandleLike = { abort: () => bgAbort.abort() };
           const resultPromise: Promise<BackgroundJobResult> = runAgent(
-            agent, params.task, cwd, effectiveModel, bgAbort.signal, undefined, undefined, inheritDeps,
+            agent, params.task, cwd, effectiveModel, bgAbort.signal, undefined,
           ).then((r) => ({ summary: r.output, exitCode: r.exitCode, error: r.error, model: r.model }));
           const jobId = getBgManager().adoptHandle(agent.name, params.task, cwd, handle, resultPromise);
           return { content: [{ type: "text", text: `Background job started: ${jobId}\nTo check status, ask me to poll job ${jobId}.` }] };
@@ -553,7 +444,7 @@ export default function (pi: ExtensionAPI) {
           : undefined;
 
         const agentRunPromise: Promise<RunResult> = runAgent(
-          agent, params.task, cwd, effectiveModel, agentAbort.signal, wrappedOnUpdate, undefined, inheritDeps,
+          agent, params.task, cwd, effectiveModel, agentAbort.signal, wrappedOnUpdate,
         );
 
         const bgResultPromise: Promise<BackgroundJobResult> = agentRunPromise
@@ -641,7 +532,6 @@ export default function (pi: ExtensionAPI) {
 
         emitParallel(true);
 
-        const parentDepth = getCurrentDepth();
         const allResults = await mapConcurrent(expanded, concurrency, async (t, i) => {
           parallelAgents[i]!.status = "running";
           emitParallel(true);
@@ -658,17 +548,13 @@ export default function (pi: ExtensionAPI) {
             parallelAgents[i]!.responseText = (partial.content?.[0] as any)?.text || parallelAgents[i]!.responseText;
             emitParallel(true);
           };
-          const shouldInherit = !t.model && (!agent.model || agent.model === "inherit");
-          const inherited = shouldInherit ? getInheritedMainModel(ctx) : undefined;
           const result = await runAgent(
             agent,
             t.task,
             t.cwd ?? cwd,
-            t.model ?? inherited?.modelRef,
+            t.model,
             signal,
             agentOnUpdate,
-            parentDepth,
-            inherited?.deps ?? { modelRegistry: ctx.modelRegistry },
           );
           parallelAgents[i]!.status = result.exitCode === 0 ? "done" : "error";
           parallelAgents[i]!.durMs = Date.now() - agentStart;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-subagent",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "In-process subagent delegation for pi with single, parallel, and background modes",
   "type": "module",
   "keywords": [

package/render.ts

@@ -302,6 +302,16 @@ export function renderSubagentResult(
     promptSkipped?: number;
     responseLines?: string[];
     skipped?: number;
+    expandedWidth?: number;
+    expandedEventsLen?: number;
+    expandedLastEventTs?: number;
+    expandedTask?: string;
+    expandedAgentName?: string;
+    expandedToolCallsLen?: number;
+    expandedAgentTextLen?: number;
+    expandedBodyLines?: string[];
+    expandedFooterKey?: string;
+    expandedOutputLines?: string[];
   } = {};
 
   function renderExpandedChronological(width: number): string[] {
@@ -386,7 +396,19 @@ export function renderSubagentResult(
   }
 
   return {
-    invalidate() { cache.width = undefined; },
+    invalidate() {
+      cache.width = undefined;
+      cache.expandedWidth = undefined;
+      cache.expandedEventsLen = undefined;
+      cache.expandedLastEventTs = undefined;
+      cache.expandedTask = undefined;
+      cache.expandedAgentName = undefined;
+      cache.expandedToolCallsLen = undefined;
+      cache.expandedAgentTextLen = undefined;
+      cache.expandedBodyLines = undefined;
+      cache.expandedFooterKey = undefined;
+      cache.expandedOutputLines = undefined;
+    },
     render(width: number): string[] {
       const out: string[] = [];
       const indent = "  ";
@@ -394,15 +416,52 @@ export function renderSubagentResult(
         theme.fg("muted", `${indent}… (${count} more line${count === 1 ? "" : "s"})`);
 
       if (expanded) {
-        // Expanded: render chronologically from events
-        const expandedOut = renderExpandedChronological(width);
-        expandedOut.push("");
+        const events = details.executionEvents || [];
+        const lastEventTs = events.length ? events[events.length - 1]!.timestamp : undefined;
+        const taskKey = details.task ?? "";
+        const agentKey = details.agentName ?? "";
+        const bodyCacheHit =
+          cache.expandedWidth === width
+          && cache.expandedEventsLen === events.length
+          && cache.expandedLastEventTs === lastEventTs
+          && cache.expandedTask === taskKey
+          && cache.expandedAgentName === agentKey
+          && cache.expandedToolCallsLen === toolCalls.length
+          && cache.expandedAgentTextLen === agentText.length
+          && Array.isArray(cache.expandedBodyLines);
+
+        let bodyLines: string[];
+        if (bodyCacheHit) {
+          bodyLines = cache.expandedBodyLines!;
+        } else {
+          bodyLines = renderExpandedChronological(width);
+          cache.expandedWidth = width;
+          cache.expandedEventsLen = events.length;
+          cache.expandedLastEventTs = lastEventTs;
+          cache.expandedTask = taskKey;
+          cache.expandedAgentName = agentKey;
+          cache.expandedToolCallsLen = toolCalls.length;
+          cache.expandedAgentTextLen = agentText.length;
+          cache.expandedBodyLines = bodyLines;
+          cache.expandedFooterKey = undefined;
+          cache.expandedOutputLines = undefined;
+        }
+
         const status = statusLine();
-        if (status) expandedOut.push(truncateToWidth(status, width, "..."));
-        if (details.running && !details.backgroundJobId) {
-          expandedOut.push(truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "..."));
+        const bgHint = details.running && !details.backgroundJobId
+          ? truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "...")
+          : "";
+        const footerKey = `${status}__${bgHint}`;
+
+        if (cache.expandedFooterKey !== footerKey || !Array.isArray(cache.expandedOutputLines)) {
+          const expandedOut = [...bodyLines, ""];
+          if (status) expandedOut.push(truncateToWidth(status, width, "..."));
+          if (bgHint) expandedOut.push(bgHint);
+          cache.expandedFooterKey = footerKey;
+          cache.expandedOutputLines = expandedOut;
         }
-        return expandedOut;
+
+        return cache.expandedOutputLines!;
       }
 
       // Collapsed view

package/runner.ts

@@ -5,6 +5,8 @@
  * via `onUpdate`, and enforces the per-agent `maxDepth` gate on nested calls.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
+
 import {
   AuthStorage,
   createAgentSession,
@@ -32,8 +34,6 @@ export function getAuth() {
 // ─── Depth gating ────────────────────────────────────────────────────────────
 
 export const DEFAULT_MAX_DEPTH = 0;
-export const DEPTH_ENV = "PI_FAST_SUBAGENT_DEPTH";
-export const MAX_DEPTH_ENV = "PI_FAST_SUBAGENT_MAX_DEPTH";
 
 /**
  * Pure helper: given the current nesting depth and the allowed max depth,
@@ -53,75 +53,28 @@ export function checkDepthGate(depth: number, maxDepth: number): { allowed: bool
   return { allowed: true };
 }
 
-// Module-level depth counters for nested in-process subagent calls.
-let _currentDepth = 0;
-let _currentMaxDepth = DEFAULT_MAX_DEPTH;
-
-/** Read-only accessors for the current in-flight depth (used by parallel mode). */
-export function getCurrentDepth(): number {
-  return _currentDepth;
+export interface DepthState {
+  depth: number;
+  maxDepth: number;
 }
 
-// ─── runAgent ────────────────────────────────────────────────────────────────
+const TOP_LEVEL_DEPTH: DepthState = { depth: 0, maxDepth: DEFAULT_MAX_DEPTH };
+const _depthContext = new AsyncLocalStorage<DepthState>();
 
-export interface RunAgentDeps {
-  loaderPool?: LoaderPool;
-  modelRegistry?: ModelRegistry;
-  /** Pass a Model object directly to bypass registry lookup (used for model: inherit). */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  modelObject?: any;
+/** Read the depth/maxDepth in the current async context, or top-level defaults if none. */
+export function getDepthState(): DepthState {
+  return _depthContext.getStore() ?? TOP_LEVEL_DEPTH;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function modelRef(model: any): string {
-  return `${model.provider}/${model.id}`;
+/** Run `fn` with `state` set as the current async-scoped depth context. */
+export function runWithDepth<T>(state: DepthState, fn: () => Promise<T>): Promise<T> {
+  return _depthContext.run(state, fn);
 }
 
-/**
- * Resolve provider/modelId into a Model object.
- *
- * `ModelRegistry.find()` only returns bundled/custom registry entries. Pi itself
- * can run ad-hoc provider model IDs (for example via `--model
- * anthropic/claude-sonnet-4-6`) by cloning provider config from a known model.
- * Do same here so `model: inherit` can use main session's exact model ID even
- * before pi's bundled registry knows it.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function resolveModelObject(modelRegistry: ModelRegistry, modelReference: string | undefined): any | undefined {
-  const ref = modelReference?.trim();
-  if (!ref) return undefined;
-
-  const allModels = modelRegistry.getAll();
-  const lowerRef = ref.toLowerCase();
-  const exact = allModels.find((m) => modelRef(m).toLowerCase() === lowerRef || m.id.toLowerCase() === lowerRef);
-  if (exact) return exact;
-
-  const slash = ref.indexOf("/");
-  if (slash === -1) return undefined;
-
-  const providerRef = ref.slice(0, slash).trim();
-  const modelId = ref.slice(slash + 1).trim();
-  if (!providerRef || !modelId) return undefined;
-
-  const providerModels = allModels.filter((m) => m.provider.toLowerCase() === providerRef.toLowerCase());
-  if (providerModels.length === 0) return undefined;
-  const provider = providerModels[0]!.provider;
-
-  const found = modelRegistry.find(provider, modelId);
-  if (found) return found;
-
-  // Unknown model ID for known provider: clone closest provider model so auth,
-  // API, baseUrl, headers, compat, cost shape, and token defaults survive.
-  const idLower = modelId.toLowerCase();
-  const family = ["opus", "sonnet", "haiku", "gpt", "gemini", "kimi", "glm", "grok"].find((token) => idLower.includes(token));
-  const familyModels = family ? providerModels.filter((m) => m.id.toLowerCase().includes(family)) : [];
-  const base = (familyModels[0] ?? providerModels[0])!;
-  return {
-    ...base,
-    provider,
-    id: modelId,
-    name: modelId,
-  };
+// ─── runAgent ────────────────────────────────────────────────────────────────
+
+export interface RunAgentDeps {
+  loaderPool?: LoaderPool;
 }
 
 export async function runAgent(
@@ -131,12 +84,11 @@ export async function runAgent(
   modelOverride: string | undefined,
   signal: AbortSignal | undefined,
   onUpdate: OnUpdate | undefined,
-  parentDepth?: number,
   deps: RunAgentDeps = {},
 ): Promise<RunResult> {
   const pool = deps.loaderPool ?? defaultLoaderPool;
-  const depth = parentDepth ?? _currentDepth;
-  const gate = checkDepthGate(depth, _currentMaxDepth);
+  const { depth, maxDepth } = getDepthState();
+  const gate = checkDepthGate(depth, maxDepth);
   if (!gate.allowed) {
     return {
       output: "",
@@ -148,8 +100,7 @@ export async function runAgent(
   }
 
   const bootStartedAt = Date.now();
-  const { authStorage, modelRegistry: defaultRegistry } = getAuth();
-  const modelRegistry = deps.modelRegistry ?? defaultRegistry;
+  const { authStorage, modelRegistry } = getAuth();
   const agentDir = getAgentDir();
   const noExtensions = !agentNeedsExtensions(agent.tools);
   const coldLoader = !pool.isWarm(cwd, agentDir, noExtensions);
@@ -171,8 +122,6 @@ export async function runAgent(
   });
   await allowUiPaint(coldLoader);
 
-  const createPrevEnvDepth = process.env[DEPTH_ENV];
-  process.env[DEPTH_ENV] = String(depth + 1);
   const loaderLease = await pool.acquire(
     cwd,
     agentDir,
@@ -189,13 +138,10 @@ export async function runAgent(
       authStorage,
       modelRegistry,
       resourceLoader: loaderLease.loader,
-      ...(deps.modelObject ? { model: deps.modelObject } : {}),
     });
     session = created.session;
   } catch (e) {
     loaderLease.release();
-    if (createPrevEnvDepth === undefined) delete process.env[DEPTH_ENV];
-    else process.env[DEPTH_ENV] = createPrevEnvDepth;
     return {
       output: "",
       exitCode: 1,
@@ -204,14 +150,17 @@ export async function runAgent(
       usage: { input: 0, output: 0, cost: 0, turns: 0 },
     };
   }
-  if (createPrevEnvDepth === undefined) delete process.env[DEPTH_ENV];
-  else process.env[DEPTH_ENV] = createPrevEnvDepth;
 
-  // Resolve and apply model. Force this even when createAgentSession received
-  // modelObject so restore/default fallback cannot silently win.
-  const modelStr = modelOverride ?? (agent.model === "inherit" ? undefined : agent.model);
-  const model = deps.modelObject ?? resolveModelObject(modelRegistry, modelStr);
-  if (model) await session.setModel(model);
+  // Resolve and apply model
+  const modelStr = modelOverride ?? agent.model;
+  if (modelStr) {
+    const [provider, ...rest] = modelStr.split("/");
+    const modelId = rest.join("/");
+    if (provider && modelId) {
+      const model = modelRegistry.find(provider, modelId);
+      if (model) await session.setModel(model);
+    }
+  }
 
   // Apply tools allowlist.
   //   "all"    → no restriction (everything registered stays active)
@@ -361,17 +310,11 @@ export async function runAgent(
     });
   });
 
-  // Propagate depth to nested calls. `maxDepth` is per-agent and defaults to 0,
-  // so subagents cannot spawn subagents unless their frontmatter opts in.
-  const prevEnvDepth = process.env[DEPTH_ENV];
-  const prevEnvMaxDepth = process.env[MAX_DEPTH_ENV];
-  const prevDepth = _currentDepth;
-  const prevMaxDepth = _currentMaxDepth;
-  const maxDepth = Math.max(DEFAULT_MAX_DEPTH, agent.maxDepth ?? DEFAULT_MAX_DEPTH);
-  _currentDepth = depth + 1;
-  _currentMaxDepth = depth + maxDepth;
-  process.env[DEPTH_ENV] = String(_currentDepth);
-  process.env[MAX_DEPTH_ENV] = String(_currentMaxDepth);
+  // Per-agent maxDepth; defaults to 0 so subagents can't spawn subagents unless
+  // their frontmatter opts in. AsyncLocalStorage scopes this to the nested
+  // call, so overlapping parallel agents don't trample each other's state.
+  const agentMaxDepth = Math.max(DEFAULT_MAX_DEPTH, agent.maxDepth ?? DEFAULT_MAX_DEPTH);
+  const childState: DepthState = { depth: depth + 1, maxDepth: depth + agentMaxDepth };
 
   let exitCode = 0;
   let error: string | undefined;
@@ -382,7 +325,7 @@ export async function runAgent(
     const onAbort = () => void session.abort();
     signal?.addEventListener("abort", onAbort, { once: true });
     try {
-      await session.prompt(task);
+      await runWithDepth(childState, () => session.prompt(task));
     } finally {
       signal?.removeEventListener("abort", onAbort);
     }
@@ -395,12 +338,6 @@ export async function runAgent(
     unsubscribe();
     session.dispose();
     loaderLease.release();
-    if (prevEnvDepth === undefined) delete process.env[DEPTH_ENV];
-    else process.env[DEPTH_ENV] = prevEnvDepth;
-    if (prevEnvMaxDepth === undefined) delete process.env[MAX_DEPTH_ENV];
-    else process.env[MAX_DEPTH_ENV] = prevEnvMaxDepth;
-    _currentDepth = prevDepth;
-    _currentMaxDepth = prevMaxDepth;
   }
 
   return { output: lastOutput, exitCode, error, model: detectedModel, toolCalls, executionEvents, usage };