@@ -113,6 +113,7 @@ import { formatSubAgentSpawnAuthFailureMessage } from "./inference-auth-failure.
 import {
   classifySubAgentFailure,
   isProviderFailureClass,
+  isSubAgentLoopGuardError,
   type SubAgentFailureRecord,
 } from "./terminal-failure.js";
 import { errorMessage } from "../agent/error-message.js";
@@ -1690,6 +1691,7 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
                 ...(settlement?.teardown_failed === true
                   ? { teardownFailed: true }
                   : {}),
+                ...(isSubAgentLoopGuardError(err) ? { cause: err.cause } : {}),
               });
             })
             .finally(() => {
 
@@ -15,6 +15,7 @@ import {
   waitUntilMailboxTerminal,
 } from "./fleet-test-harness.js";
 import { pollUntil } from "./run-test-harness.js";
+import { createSubAgentLoopGuardError } from "./terminal-failure.js";
 import type { RunSubAgentParams, RunSubAgentResult } from "./types.js";
 
 type Row = Record<string, unknown> & {
@@ -85,6 +86,38 @@ describe("failure_class drives the existing provider markers", () => {
     },
   );
 
+  test("a doom-loop over a retryable provider failure stays loop_guard and continuable", async () => {
+    const deps = createFleetDeps(async () => {
+      throw createSubAgentLoopGuardError(retryable());
+    });
+    const tools = fleetTools(deps);
+    const id = await spawnAgentId(tools.spawn, spawnArgs);
+    const [row] = await waitRows(tools, [id]);
+    expect(row?.status).toBe("failed");
+    expect(row?.failure?.failure_class).toBe("loop_guard");
+    expect(row?.failure?.recovery).toEqual({
+      available: true,
+      reason: "eligible",
+    });
+    expect(row?.provider_failure).toBeUndefined();
+    expect(row?.continuable).toBe(true);
+  });
+
+  test("a doom-loop without a retryable cause stays loop_guard and not continuable", async () => {
+    const deps = createFleetDeps(async () => {
+      throw createSubAgentLoopGuardError(new Error("reactor error: doom"));
+    });
+    const tools = fleetTools(deps);
+    const id = await spawnAgentId(tools.spawn, spawnArgs);
+    const [row] = await waitRows(tools, [id]);
+    expect(row?.failure?.failure_class).toBe("loop_guard");
+    expect(row?.failure?.recovery).toEqual({
+      available: false,
+      reason: "not_retryable",
+    });
+    expect(row?.continuable).toBeUndefined();
+  });
+
   test("a permission suspension after an observed inference.error is error, not provider", async () => {
     const deps = createFleetDeps(async (params) => {
       params.onEvent?.(inferenceError);
@@ -199,6 +232,39 @@ describe("terminal failure cleanup", () => {
     expect(deps.fleetRecords.peek(secondId)?.status).toBe("done");
   });
 
+  test("a failed spawn with a hanging close frees its admission slot before close", async () => {
+    const admission = createAdmissionQueue({ capacity: 1 });
+    let started = 0;
+    const deps = createFleetDeps(
+      async (params: RunSubAgentParams): Promise<RunSubAgentResult> => {
+        started += 1;
+        if (started > 1) return { report: "second done" };
+        params.onAgentReady?.({
+          close: () => new Promise<void>(() => undefined),
+          interrupt: () => undefined,
+          followup: async () => "",
+          deliver: () => undefined,
+        });
+        throw new Error("spawn failed");
+      },
+    );
+    deps.admission = admission;
+    const tools = fleetTools(deps);
+    const first = await spawnAgentId(tools.spawn, spawnArgs);
+    const second = await callFleetTool(tools.spawn, spawnArgs);
+    expect(second.status).toBe("queued");
+
+    await waitUntilMailboxTerminal(deps.fleetRecords, deps.sessions, first);
+    const [row] = await waitRows(tools, [first]);
+    expect(row?.status).toBe("failed");
+    expect(deps.sessions.get(first)?.lifecycle.state).toBe("failed");
+    await pollUntil(() => !admission.occupied(first));
+
+    const secondId = second.agent_id as string;
+    await waitUntilMailboxTerminal(deps.fleetRecords, deps.sessions, secondId);
+    expect(deps.fleetRecords.peek(secondId)?.status).toBe("done");
+  });
+
   test("a failure with an open ask releases the wait, the ask, and the admission slot once", async () => {
     const admission = createAdmissionQueue({ capacity: 1 });
     const failFirst = deferred<undefined>();
 
@@ -21,7 +21,10 @@ import {
   UNSTRUCTURED_DIGEST_CHARS,
 } from "./fleet-dry-drive.js";
 import { parseSubAgentReport } from "./report.js";
-import { classifySubAgentFailure } from "./terminal-failure.js";
+import {
+  classifySubAgentFailure,
+  isSubAgentLoopGuardError,
+} from "./terminal-failure.js";
 import {
   DEFAULT_MAX_ENTRY_CHARS,
   type AgentLifecycleStatus,
@@ -353,6 +356,7 @@ export function createResumeAgentTool(deps: ResumeAgentToolDeps): AgentTool {
         onFail: (err) =>
           deps.sessions.fail(target, errorMessage(err), {
             failure_class: classifySubAgentFailure(err),
+            ...(isSubAgentLoopGuardError(err) ? { cause: err.cause } : {}),
           }),
       });
       if (!outcome.ok) {
 
@@ -125,6 +125,36 @@ describe("terminal failure record", () => {
     expect(Object.isFrozen(snap?.failure)).toBe(true);
   });
 
+  test("a loop_guard with a retryable provider cause is recovery-eligible", () => {
+    const { sessions } = store();
+    const id = startRunning(sessions);
+    sessions.fail(id, "upstream overloaded", {
+      failure_class: "loop_guard",
+      cause: createResolvedProviderFailureError("test-provider", {
+        category: "retryable",
+        message: "upstream overloaded",
+      }),
+    });
+    const failure = sessions.get(id)?.failure;
+    expect(failure?.failure_class).toBe("loop_guard");
+    expect(failure?.recovery).toEqual({ available: true, reason: "eligible" });
+    expect("cause" in (failure ?? {})).toBe(false);
+  });
+
+  test("a loop_guard without a retryable cause is not recovery-eligible", () => {
+    const { sessions } = store();
+    const id = startRunning(sessions);
+    sessions.fail(id, "doom", {
+      failure_class: "loop_guard",
+      cause: new Error("doom"),
+    });
+    expect(sessions.get(id)?.failure?.failure_class).toBe("loop_guard");
+    expect(sessions.get(id)?.failure?.recovery).toEqual({
+      available: false,
+      reason: "not_retryable",
+    });
+  });
+
   test("fail without a classification records error", () => {
     const { sessions } = store();
     const id = startRunning(sessions);
@@ -415,30 +445,47 @@ describe("backstop close honesty", () => {
     expect(sessions.get(id)?.failure?.cleanup).toBe("released");
   });
 
-  test("a rejecting backstop close records partial cleanup", async () => {
+  test("a rejecting backstop close does not delay the failed lane", async () => {
     const { sessions } = store();
-    const id = retainedWithClose(sessions, async () => {
-      throw new Error("child still live");
-    });
-    await sessions.fail(id, "boom", { failure_class: "error" });
+    let rejectClose: (err: Error) => void = () => undefined;
+    const id = retainedWithClose(
+      sessions,
+      () =>
+        new Promise<void>((_resolve, reject) => {
+          rejectClose = reject;
+        }),
+    );
+    const failing = sessions.fail(id, "boom", { failure_class: "error" });
     expect(sessions.get(id)?.lifecycle.state).toBe("failed");
-    expect(sessions.get(id)?.failure?.cleanup).toBe("partial");
+    const record = sessions.get(id)?.failure;
+    expect(record?.cleanup).toBe("released");
+    rejectClose(new Error("child still live"));
+    await failing;
+    expect(sessions.get(id)?.failure).toBe(
+      record as NonNullable<typeof record>,
+    );
   });
 
-  test("a backstop close that hangs past its deadline records partial cleanup", async () => {
-    const sessions = createSubAgentSessionStore({
-      now: () => T0,
-      backstopCloseDeadlineMs: 20,
-    });
+  test("a hanging backstop close does not delay the failed lane", async () => {
+    const { sessions } = store();
     const id = retainedWithClose(
       sessions,
       () => new Promise<void>(() => undefined),
     );
-    await sessions.fail(id, "boom", { failure_class: "error" });
-    expect(sessions.get(id)?.failure?.cleanup).toBe("partial");
+    const settled = await Promise.race([
+      sessions
+        .fail(id, "boom", { failure_class: "error" })
+        .then(() => "settled" as const),
+      new Promise<"stalled">((resolve) =>
+        setTimeout(() => resolve("stalled"), 200),
+      ),
+    ]);
+    expect(settled).toBe("settled");
+    expect(sessions.get(id)?.lifecycle.state).toBe("failed");
+    expect(sessions.get(id)?.failure?.cleanup).toBe("released");
   });
 
-  test("the record is not written until the close settles, and never changes after", async () => {
+  test("the record is written before the close settles, and never changes after", async () => {
     const { sessions } = store();
     let finishClose: () => void = () => undefined;
     const id = retainedWithClose(
@@ -449,11 +496,11 @@ describe("backstop close honesty", () => {
         }),
     );
     const failing = sessions.fail(id, "boom", { failure_class: "error" });
-    expect(sessions.get(id)?.failure).toBeUndefined();
-    finishClose();
-    await failing;
+    expect(sessions.get(id)?.lifecycle.state).toBe("failed");
     const record = sessions.get(id)?.failure;
     expect(record?.cleanup).toBe("released");
+    finishClose();
+    await failing;
     await settleTick();
     expect(sessions.get(id)?.failure).toBe(
       record as NonNullable<typeof record>,
 
@@ -33,6 +33,7 @@ import { canonicalToolName } from "../agent/canonical-tool-name.js";
 import {
   classifySubAgentFailure,
   failureClassForStopReason,
+  isSubAgentLoopGuardError,
   recoveryFor,
   type SubAgentFailureClass,
   type SubAgentFailureInput,
@@ -193,9 +194,6 @@ export interface SubAgentSessionStoreOptions {
   createId?: () => string;
   /** When set, resume/followup inference is admitted through this queue. */
   admission?: AdmissionQueue;
-  // How long fail() waits on a live close before recording partial cleanup.
-  // Defaults to close_agent's deadline: the same teardown, so no tighter or
-  // looser bound is justified.
   backstopCloseDeadlineMs?: number;
 }
 
@@ -217,8 +215,6 @@ export interface SubAgentSessionStore {
     report: string,
     opts?: { agentRetained?: boolean; stopReason?: ForcedStopReason },
   ): void;
-  // Resolves once the lane is terminal and its failure record is written. A
-  // live backstop close is awaited first so the record's cleanup is true.
   fail(
     id: string,
     error: string,
@@ -846,6 +842,7 @@ export function createSubAgentSessionStore(
             failureClass,
             attempt,
             followupTurn: followupTurns.has(id),
+            cause: pendingFailures.get(id)?.cause,
           }),
         ),
         attempt,
@@ -951,8 +948,6 @@ export function createSubAgentSessionStore(
 
   const releaseHandles = (id: string): void => {
     cancelAskInternal(id, "session handles released");
-    // Eviction and prune have no record left to keep honest, so the close
-    // stays fire-and-forget here; fail() awaits it through detachClose.
     void detachClose(id)?.catch((err: unknown) => {
       log.warn("session close during handle release failed: {error}", {
         error: errorMessage(err),
@@ -1262,7 +1257,10 @@ export function createSubAgentSessionStore(
     // Only the interrupted restore stamps a record of its own; a completed
     // restore stays a clean lane, as before.
     if (failLifecycle === "interrupted") {
-      pendingFailures.set(id, { failure_class: classifySubAgentFailure(err) });
+      pendingFailures.set(id, {
+        failure_class: classifySubAgentFailure(err),
+        ...(isSubAgentLoopGuardError(err) ? { cause: err.cause } : {}),
+      });
     }
     endFollowupTurn(id, failLifecycle);
     pendingFailures.delete(id);
@@ -1732,39 +1730,13 @@ export function createSubAgentSessionStore(
       }
     },
 
-    async fail(
+    fail(
       id: string,
       error: string,
       failure?: SubAgentFailureInput,
     ): Promise<void> {
       if (failure !== undefined) pendingFailures.set(id, failure);
       settleCancelsAsks(id, "session failed");
-      const current = sessions.get(id);
-      const failable =
-        current !== undefined &&
-        isLiveStrip(current.lifecycle) &&
-        current.lifecycle.state !== "cancelled";
-      // The record is written once and never amended, so the close it reports
-      // on has to finish first. A close that rejects or outlives its deadline
-      // is a cleanup fault, not a released worker.
-      const closing = failable ? detachClose(id) : undefined;
-      if (closing !== undefined && failure?.teardownFailed === true) {
-        // The worker's own bounded teardown already timed out on this agent,
-        // so the record is partial either way; waiting on a second close
-        // would only hold the lane and its admission slot for another
-        // deadline.
-        void closing.catch((err: unknown) => {
-          log.warn("backstop close after failed teardown failed: {error}", {
-            error: errorMessage(err),
-          });
-        });
-      } else if (closing !== undefined) {
-        try {
-          await closing;
-        } catch {
-          releaseFaults.add(id);
-        }
-      }
       mutate(id, (session) => {
         if (
           !isLiveStrip(session.lifecycle) ||
@@ -1773,7 +1745,8 @@ export function createSubAgentSessionStore(
           return;
         // Spawn-path throws already dispose in run.ts's finally; a resumed
         // persisted agent does not, so the live close handle is the only
-        // teardown, awaited above. A disposed spawn close is idempotent.
+        // teardown. Invoke it fire-and-forget (as prune/evict) without
+        // marking shutdown — a disposed spawn close is idempotent.
         session.lifecycle = { state: "failed", error };
         session.retained = false;
         session.finishedAt = now();
@@ -1789,6 +1762,7 @@ export function createSubAgentSessionStore(
         pruneCompleted();
       });
       pendingFailures.delete(id);
+      return Promise.resolve();
     },
 
     registerCancel(id: string, abort: () => void): void {