@xrkseek/harness 0.5.14 → 0.5.19

package/node_modules/@xrkseek/server-face/dist/subagent-tools.js

@@ -1,5 +1,6 @@
 import { SUBAGENT_ROUTING_PROMPT_TEXT } from "@xrkseek/core-tools";
 import { listPendingAdmits, readSessionEvents, } from "@xrkseek/core-session";
+import { forgetRequestHeaderCache } from "@xrkseek/core-agent-loop";
 import { dispatchFaceMethod } from "./dispatch.js";
 import { formatChildOutcome, lastAssistantBodyText, lastModelRetryNotice, } from "./adapt/subagent-notice.js";
 import { boundChildAnswer, SUBAGENT_ANSWER_INLINE_BYTES, } from "./adapt/subagent-answer-bound.js";
@@ -42,7 +43,7 @@ export function resolveSubagentQuota(runtime, sessionId) {
     const profile = resolveAgentPresetProfile(presetId);
     if (profile.subagents.mode === "off") {
         const depth = subagentDepth(runtime, sessionId);
-        const active = countActiveChildren(runtime, sessionId);
+        const active = countActiveChildren(runtime, sessionId) + pendingSpawnCount(sessionId);
         const delegated = runtime.subagents.listDelegated(sessionId).length;
         return {
             depth,
@@ -60,7 +61,7 @@ export function resolveSubagentQuota(runtime, sessionId) {
         ? Math.min(faceActive, profile.subagents.maxActiveChildren)
         : faceActive;
     const depth = subagentDepth(runtime, sessionId);
-    const active = countActiveChildren(runtime, sessionId);
+    const active = countActiveChildren(runtime, sessionId) + pendingSpawnCount(sessionId);
     const delegated = runtime.subagents.listDelegated(sessionId).length;
     return {
         depth,
@@ -243,6 +244,25 @@ function countActiveChildren(runtime, parentSessionId) {
     }
     return n;
 }
+/**
+ * In-flight spawn reservations (sync). Two parallel `subagent` settles both
+ * read `countActiveChildren` before either child's drain latches — without
+ * this, both can pass `active < maxActive` and overshoot the cap.
+ */
+const pendingSpawnSlots = new Map();
+function pendingSpawnCount(parentSessionId) {
+    return pendingSpawnSlots.get(parentSessionId) ?? 0;
+}
+function reserveSpawnSlot(parentSessionId) {
+    pendingSpawnSlots.set(parentSessionId, pendingSpawnCount(parentSessionId) + 1);
+}
+function releaseSpawnSlot(parentSessionId) {
+    const n = pendingSpawnCount(parentSessionId);
+    if (n <= 1)
+        pendingSpawnSlots.delete(parentSessionId);
+    else
+        pendingSpawnSlots.set(parentSessionId, n - 1);
+}
 /**
  * Undo a half-made spawn. `session.create` / `session.fork` already made the
  * child durable and registered its link, so any failure between there and a
@@ -266,6 +286,7 @@ async function discardUnstartedChild(runtime, childSessionId) {
     catch {
         /* store without delete / already gone */
     }
+    forgetRequestHeaderCache(childSessionId);
     await Promise.resolve(runtime.invalidateAgent?.(childSessionId)).catch(() => undefined);
 }
 /**
@@ -455,6 +476,10 @@ function createSubagentTool(options) {
             },
             required: ["prompt"],
         },
+        // Without this, settle-batch treats every `subagent` call as an exclusive
+        // barrier — two tool calls in one turn run one-after-another, so Status
+        // shows "1 subagent" even when the model asked for parallel siblings.
+        isConcurrencySafe: () => true,
         presentCall: (args) => ({
             card: "generic",
             title: String(args.description?.trim() || "Subagent"),
@@ -558,6 +583,14 @@ function createSubagentTool(options) {
                         isError: true,
                     };
                 }
+                reserveSpawnSlot(options.parentSessionId);
+                let externalSlotHeld = true;
+                const dropExternalSlot = () => {
+                    if (!externalSlotHeld)
+                        return;
+                    externalSlotHeld = false;
+                    releaseSpawnSlot(options.parentSessionId);
+                };
                 try {
                     const product = parseExternalAgentProduct(options.runtime.settingsNamespaces.view("external-agent").value);
                     if (background && supportsExternalContinuable(runtimeKind)) {
@@ -632,6 +665,8 @@ function createSubagentTool(options) {
                                 ? { spawnImpl: options.externalSpawn }
                                 : {}),
                         });
+                        // Child is busy in externalAgents; pending slot no longer needed.
+                        dropExternalSlot();
                         return {
                             content: [
                                 `Started background external subagent \`${childId}\` (${label} · ${runtimeKind}).`,
@@ -644,6 +679,9 @@ function createSubagentTool(options) {
                             ].join("\n"),
                         };
                     }
+                    // One-shot external has no Face child latch — do not hold the slot
+                    // for the whole print turn (would starve parallel in-process spawns).
+                    dropExternalSlot();
                     const result = await runExternalAgentTurn({
                         kind: runtimeKind,
                         cwd: externalCwd,
@@ -667,6 +705,9 @@ function createSubagentTool(options) {
                             : String(err);
                     return { content: `subagent external: ${msg}`, isError: true };
                 }
+                finally {
+                    dropExternalSlot();
+                }
             }
             const depth = subagentDepth(options.runtime, options.parentSessionId);
             const { maxDepth, maxActive: maxActiveChildren, active } = caps();
@@ -682,426 +723,442 @@ function createSubagentTool(options) {
                     isError: true,
                 };
             }
-            const background = a.run_in_background === true;
-            const inherit = a.inherit_context === true;
-            const label = String(a.description ?? "").trim() ||
-                String(a.task_name ?? "").trim() ||
-                (background ? "subagent" : "subagent-task");
-            const linkMode = background ? "continuable" : "one-shot";
-            const parentCwd = resolveSessionCwd(options.runtime, options.parentSessionId);
-            const taskTitle = String(a.task_name ?? "").trim() || label;
-            const taskIdHint = String(a.task_id ?? "").trim() || undefined;
-            // Before anything is allocated: reusing a task_id another child owns
-            // must not leave a worktree or a session behind.
-            const taskIdError = taskIdConflict(options.runtime, taskIdHint);
-            if (taskIdError) {
-                return { content: taskIdError, isError: true };
-            }
-            let isolated = null;
-            let managedLease = null;
-            let worktreeSkip = "";
-            if (a.worktree === true) {
-                if (worktreeSkippedForRemote(options.runtime.remoteExecution)) {
-                    worktreeSkip = "worktree skipped: not a local terminal";
+            reserveSpawnSlot(options.parentSessionId);
+            let spawnSlotHeld = true;
+            const dropSpawnSlot = () => {
+                if (!spawnSlotHeld)
+                    return;
+                spawnSlotHeld = false;
+                releaseSpawnSlot(options.parentSessionId);
+            };
+            try {
+                const background = a.run_in_background === true;
+                const inherit = a.inherit_context === true;
+                const label = String(a.description ?? "").trim() ||
+                    String(a.task_name ?? "").trim() ||
+                    (background ? "subagent" : "subagent-task");
+                const linkMode = background ? "continuable" : "one-shot";
+                const parentCwd = resolveSessionCwd(options.runtime, options.parentSessionId);
+                const taskTitle = String(a.task_name ?? "").trim() || label;
+                const taskIdHint = String(a.task_id ?? "").trim() || undefined;
+                // Before anything is allocated: reusing a task_id another child owns
+                // must not leave a worktree or a session behind.
+                const taskIdError = taskIdConflict(options.runtime, taskIdHint);
+                if (taskIdError) {
+                    return { content: taskIdError, isError: true };
                 }
-                else {
-                    managedLease =
-                        options.runtime.managedWorktrees.allocate({
-                            parentCwd,
-                            parentSessionId: options.parentSessionId,
-                        }) ?? null;
-                    if (managedLease) {
-                        isolated = {
-                            path: managedLease.path,
-                            branch: managedLease.branch,
-                            repoRoot: managedLease.repoRoot,
-                            baseCommit: managedLease.baseCommit,
-                        };
+                let isolated = null;
+                let managedLease = null;
+                let worktreeSkip = "";
+                if (a.worktree === true) {
+                    if (worktreeSkippedForRemote(options.runtime.remoteExecution)) {
+                        worktreeSkip = "worktree skipped: not a local terminal";
                     }
                     else {
-                        // Fall back to one-shot create when the registry path fails.
-                        isolated = createSubagentWorktree(parentCwd);
-                        if (!isolated) {
-                            worktreeSkip =
-                                "worktree skipped: not a git repository or worktree add failed";
+                        managedLease =
+                            options.runtime.managedWorktrees.allocate({
+                                parentCwd,
+                                parentSessionId: options.parentSessionId,
+                            }) ?? null;
+                        if (managedLease) {
+                            isolated = {
+                                path: managedLease.path,
+                                branch: managedLease.branch,
+                                repoRoot: managedLease.repoRoot,
+                                baseCommit: managedLease.baseCommit,
+                            };
+                        }
+                        else {
+                            // Fall back to one-shot create when the registry path fails.
+                            isolated = createSubagentWorktree(parentCwd);
+                            if (!isolated) {
+                                worktreeSkip =
+                                    "worktree skipped: not a git repository or worktree add failed";
+                            }
                         }
                     }
                 }
-            }
-            let taskBody = prompt;
-            if (outputSchema) {
-                taskBody = appendOutputContract(taskBody, outputSchema);
-            }
-            taskBody = isolated
-                ? `${taskBody}\n\n${worktreeContextNote(isolated)}`
-                : taskBody;
-            const openTask = (childSessionId) => {
-                const task = options.runtime.agentTeamTasks.open({
-                    parentSessionId: options.parentSessionId,
-                    title: taskTitle,
-                    childSessionId,
-                    ...(spawnRole && spawnRole !== "default" ? { role: spawnRole } : {}),
-                    ...(taskIdHint ? { taskId: taskIdHint } : {}),
-                });
+                let taskBody = prompt;
                 if (outputSchema) {
-                    options.runtime.agentTeamTasks.setOutputSchema(task.id, outputSchema);
+                    taskBody = appendOutputContract(taskBody, outputSchema);
                 }
-                if (managedLease) {
-                    options.runtime.managedWorktrees.bind(managedLease.id, {
+                taskBody = isolated
+                    ? `${taskBody}\n\n${worktreeContextNote(isolated)}`
+                    : taskBody;
+                const openTask = (childSessionId) => {
+                    const task = options.runtime.agentTeamTasks.open({
+                        parentSessionId: options.parentSessionId,
+                        title: taskTitle,
                         childSessionId,
-                        teamTaskId: task.id,
-                    });
-                    options.runtime.agentTeamTasks.bindWorktree(task.id, {
-                        path: managedLease.path,
-                        branch: managedLease.branch,
-                        id: managedLease.id,
-                    });
-                }
-                else if (isolated) {
-                    options.runtime.agentTeamTasks.bindWorktree(task.id, {
-                        path: isolated.path,
-                        branch: isolated.branch,
-                    });
-                }
-                return task;
-            };
-            const reclaimIsolated = (keep) => {
-                if (worktreeSkip)
-                    return worktreeSkip;
-                if (!isolated)
-                    return "";
-                if (keep) {
-                    return `[worktree] ${isolated.path}\nbranch ${isolated.branch}\nleft in place (child still running)`;
-                }
-                if (managedLease) {
-                    return formatWorktreeResult(options.runtime.managedWorktrees.reclaim(managedLease.id) ??
-                        finalizeSubagentWorktree(isolated));
-                }
-                return formatWorktreeResult(finalizeSubagentWorktree(isolated));
-            };
-            const dropIsolated = () => {
-                if (!isolated)
-                    return;
-                if (managedLease) {
-                    options.runtime.managedWorktrees.reclaim(managedLease.id);
-                }
-                else {
-                    finalizeSubagentWorktree(isolated);
-                }
-            };
-            /**
-             * Codex `spawn_guard.rs` (RAII): a half-made spawn is torn down on
-             * EVERY exit path, including an unexpected throw. Explicit
-             * `discardUnstartedChild` calls cover the known failure branches; this
-             * flag + finally is the backstop for anything they miss.
-             */
-            let started = false;
-            const discardIfUnstarted = async () => {
-                if (started || !childId)
-                    return;
-                started = true;
-                dropIsolated();
-                await discardUnstartedChild(options.runtime, childId);
-            };
-            let childId;
-            /** Fork seed size — bounds the root-evidence slice below. */
-            let seedCut = 0;
-            if (inherit) {
-                // A transport reject (not an RpcResult error) here would strand the
-                // worktree lease allocated above; catch keeps the cleanup total.
-                let forked;
-                try {
-                    forked = await dispatchFaceMethod(options.runtime, "session.fork", `tool-sa-fork-${Date.now()}`, {
-                        sessionId: options.parentSessionId,
-                        linkMode,
-                        label,
-                        ...(spawnRole && spawnRole !== "default"
-                            ? { role: spawnRole }
-                            : {}),
+                        ...(spawnRole && spawnRole !== "default" ? { role: spawnRole } : {}),
+                        ...(taskIdHint ? { taskId: taskIdHint } : {}),
                     });
-                }
-                catch {
+                    if (outputSchema) {
+                        options.runtime.agentTeamTasks.setOutputSchema(task.id, outputSchema);
+                    }
+                    if (managedLease) {
+                        options.runtime.managedWorktrees.bind(managedLease.id, {
+                            childSessionId,
+                            teamTaskId: task.id,
+                        });
+                        options.runtime.agentTeamTasks.bindWorktree(task.id, {
+                            path: managedLease.path,
+                            branch: managedLease.branch,
+                            id: managedLease.id,
+                        });
+                    }
+                    else if (isolated) {
+                        options.runtime.agentTeamTasks.bindWorktree(task.id, {
+                            path: isolated.path,
+                            branch: isolated.branch,
+                        });
+                    }
+                    return task;
+                };
+                const reclaimIsolated = (keep) => {
+                    if (worktreeSkip)
+                        return worktreeSkip;
+                    if (!isolated)
+                        return "";
+                    if (keep) {
+                        return `[worktree] ${isolated.path}\nbranch ${isolated.branch}\nleft in place (child still running)`;
+                    }
+                    if (managedLease) {
+                        return formatWorktreeResult(options.runtime.managedWorktrees.reclaim(managedLease.id) ??
+                            finalizeSubagentWorktree(isolated));
+                    }
+                    return formatWorktreeResult(finalizeSubagentWorktree(isolated));
+                };
+                const dropIsolated = () => {
+                    if (!isolated)
+                        return;
+                    if (managedLease) {
+                        options.runtime.managedWorktrees.reclaim(managedLease.id);
+                    }
+                    else {
+                        finalizeSubagentWorktree(isolated);
+                    }
+                };
+                /**
+                 * Codex `spawn_guard.rs` (RAII): a half-made spawn is torn down on
+                 * EVERY exit path, including an unexpected throw. Explicit
+                 * `discardUnstartedChild` calls cover the known failure branches; this
+                 * flag + finally is the backstop for anything they miss.
+                 */
+                let started = false;
+                const discardIfUnstarted = async () => {
+                    if (started || !childId)
+                        return;
+                    started = true;
                     dropIsolated();
-                    return {
-                        content: "subagent seed failed: fork request errored",
-                        isError: true,
-                    };
-                }
-                if (!forked.result.ok) {
-                    // No completed turn yet — fall back to a fresh child (DSH fork omits seed).
-                    if (forked.result.error.code === "fork-unavailable") {
-                        const created = await dispatchFaceMethod(options.runtime, "session.create", `tool-sa-${Date.now()}`, {
-                            parentSessionId: options.parentSessionId,
+                    await discardUnstartedChild(options.runtime, childId);
+                };
+                let childId;
+                /** Fork seed size — bounds the root-evidence slice below. */
+                let seedCut = 0;
+                if (inherit) {
+                    // A transport reject (not an RpcResult error) here would strand the
+                    // worktree lease allocated above; catch keeps the cleanup total.
+                    let forked;
+                    try {
+                        forked = await dispatchFaceMethod(options.runtime, "session.fork", `tool-sa-fork-${Date.now()}`, {
+                            sessionId: options.parentSessionId,
+                            linkMode,
                             label,
-                            mode: linkMode,
-                            ...memberSpawn,
                             ...(spawnRole && spawnRole !== "default"
                                 ? { role: spawnRole }
                                 : {}),
                         });
-                        if (!created.result.ok) {
+                    }
+                    catch {
+                        dropIsolated();
+                        return {
+                            content: "subagent seed failed: fork request errored",
+                            isError: true,
+                        };
+                    }
+                    if (!forked.result.ok) {
+                        // No completed turn yet — fall back to a fresh child (DSH fork omits seed).
+                        if (forked.result.error.code === "fork-unavailable") {
+                            const created = await dispatchFaceMethod(options.runtime, "session.create", `tool-sa-${Date.now()}`, {
+                                parentSessionId: options.parentSessionId,
+                                label,
+                                mode: linkMode,
+                                ...memberSpawn,
+                                ...(spawnRole && spawnRole !== "default"
+                                    ? { role: spawnRole }
+                                    : {}),
+                            });
+                            if (!created.result.ok) {
+                                dropIsolated();
+                                return {
+                                    content: `subagent create failed: ${created.result.error.message}`,
+                                    isError: true,
+                                };
+                            }
+                            childId = String(created.result.value.sessionId);
+                        }
+                        else {
                             dropIsolated();
                             return {
-                                content: `subagent create failed: ${created.result.error.message}`,
+                                content: `subagent seed failed: ${forked.result.error.message}`,
                                 isError: true,
                             };
                         }
-                        childId = String(created.result.value.sessionId);
                     }
                     else {
+                        childId = String(forked.result.value.sessionId);
+                        // Durable seed boundary: every answer read of this child must
+                        // slice from here, or the parent's last reply reads as its answer.
+                        seedCut = Number(forked.result.value.eventCount ?? 0);
+                        options.runtime.subagents.setSeedEventCount(childId, seedCut);
+                    }
+                }
+                else {
+                    const created = await dispatchFaceMethod(options.runtime, "session.create", `tool-sa-${Date.now()}`, {
+                        parentSessionId: options.parentSessionId,
+                        label,
+                        mode: linkMode,
+                        ...memberSpawn,
+                        ...(spawnRole && spawnRole !== "default"
+                            ? { role: spawnRole }
+                            : {}),
+                    });
+                    if (!created.result.ok) {
                         dropIsolated();
                         return {
-                            content: `subagent seed failed: ${forked.result.error.message}`,
+                            content: `subagent create failed: ${created.result.error.message}`,
                             isError: true,
                         };
                     }
+                    childId = String(created.result.value.sessionId);
                 }
-                else {
-                    childId = String(forked.result.value.sessionId);
-                    // Durable seed boundary: every answer read of this child must
-                    // slice from here, or the parent's last reply reads as its answer.
-                    seedCut = Number(forked.result.value.eventCount ?? 0);
-                    options.runtime.subagents.setSeedEventCount(childId, seedCut);
+                const modelPin = await applySubagentModelOverride(options.runtime, {
+                    parentSessionId: options.parentSessionId,
+                    childSessionId: childId,
+                    ...(typeof a.provider === "string" ? { provider: a.provider } : {}),
+                    ...(typeof a.model === "string" ? { model: a.model } : {}),
+                    ...(typeof a.reasoning_effort === "string"
+                        ? { reasoningEffort: a.reasoning_effort }
+                        : {}),
+                });
+                if (!modelPin.ok) {
+                    await discardIfUnstarted();
+                    return { content: modelPin.message, isError: true };
                 }
-            }
-            else {
-                const created = await dispatchFaceMethod(options.runtime, "session.create", `tool-sa-${Date.now()}`, {
+                if (isolated) {
+                    options.runtime.sessionCwds.set(childId, isolated.path);
+                    // Worktree bind failure must not leak the child: swallow and let the
+                    // prompt below decide the spawn's fate (or the catch backstop).
+                    await Promise.resolve(options.runtime.invalidateAgent?.(childId)).catch(() => undefined);
+                }
+                const childPrompt = applySubagentSpawnPreamble({
+                    prompt: taskBody,
                     parentSessionId: options.parentSessionId,
-                    label,
+                    childSessionId: childId,
                     mode: linkMode,
-                    ...memberSpawn,
-                    ...(spawnRole && spawnRole !== "default"
-                        ? { role: spawnRole }
+                    label,
+                    ...(spawnRole ? { role: spawnRole } : {}),
+                    inheritContext: inherit,
+                    cwd: isolated?.path ?? parentCwd,
+                    isolatedWorktree: isolated !== null,
+                    ...(rosterMember
+                        ? { memberId: rosterMember.id, inject: rosterMember.inject }
                         : {}),
+                    // The human's own asks: a child that only sees the parent's paraphrase
+                    // drifts from what was actually authorized (Codex
+                    // `control/user_authorization.rs`). A forked child already carries
+                    // these in its seeded transcript, so only add them beyond the cut.
+                    ...(() => {
+                        const block = rootUserAuthorizationBlock({
+                            parentEvents: readSessionEvents(options.runtime.store, options.parentSessionId),
+                            ...(seedCut > 0 ? { sinceEventCount: seedCut } : {}),
+                        });
+                        return block ? { userAuthorization: block } : {};
+                    })(),
                 });
-                if (!created.result.ok) {
-                    dropIsolated();
+                const task = openTask(childId);
+                const worktreeLine = reclaimIsolated;
+                // A transport-level reject (not an RpcResult error) must not leak the
+                // child: the catch backstop tears the half-made spawn down.
+                let prompted;
+                try {
+                    prompted = await dispatchFaceMethod(options.runtime, "session.prompt", `tool-sa-p-${childId}`, {
+                        sessionId: childId,
+                        mode: "queue",
+                        content: [{ type: "text", text: childPrompt }],
+                    });
+                }
+                catch (err) {
+                    await discardIfUnstarted();
+                    const extra = worktreeLine(false);
+                    const message = err instanceof Error ? err.message : String(err);
                     return {
-                        content: `subagent create failed: ${created.result.error.message}`,
+                        content: [`subagent prompt failed: ${message}`, extra]
+                            .filter(Boolean)
+                            .join("\n"),
                         isError: true,
                     };
                 }
-                childId = String(created.result.value.sessionId);
-            }
-            const modelPin = await applySubagentModelOverride(options.runtime, {
-                parentSessionId: options.parentSessionId,
-                childSessionId: childId,
-                ...(typeof a.provider === "string" ? { provider: a.provider } : {}),
-                ...(typeof a.model === "string" ? { model: a.model } : {}),
-                ...(typeof a.reasoning_effort === "string"
-                    ? { reasoningEffort: a.reasoning_effort }
-                    : {}),
-            });
-            if (!modelPin.ok) {
-                await discardIfUnstarted();
-                return { content: modelPin.message, isError: true };
-            }
-            if (isolated) {
-                options.runtime.sessionCwds.set(childId, isolated.path);
-                // Worktree bind failure must not leak the child: swallow and let the
-                // prompt below decide the spawn's fate (or the catch backstop).
-                await Promise.resolve(options.runtime.invalidateAgent?.(childId)).catch(() => undefined);
-            }
-            const childPrompt = applySubagentSpawnPreamble({
-                prompt: taskBody,
-                parentSessionId: options.parentSessionId,
-                childSessionId: childId,
-                mode: linkMode,
-                label,
-                ...(spawnRole ? { role: spawnRole } : {}),
-                inheritContext: inherit,
-                cwd: isolated?.path ?? parentCwd,
-                isolatedWorktree: isolated !== null,
-                ...(rosterMember
-                    ? { memberId: rosterMember.id, inject: rosterMember.inject }
-                    : {}),
-                // The human's own asks: a child that only sees the parent's paraphrase
-                // drifts from what was actually authorized (Codex
-                // `control/user_authorization.rs`). A forked child already carries
-                // these in its seeded transcript, so only add them beyond the cut.
-                ...(() => {
-                    const block = rootUserAuthorizationBlock({
-                        parentEvents: readSessionEvents(options.runtime.store, options.parentSessionId),
-                        ...(seedCut > 0 ? { sinceEventCount: seedCut } : {}),
+                if (!prompted.result.ok) {
+                    await discardIfUnstarted();
+                    const extra = worktreeLine(false);
+                    return {
+                        content: [`subagent prompt failed: ${prompted.result.error.message}`, extra]
+                            .filter(Boolean)
+                            .join("\n"),
+                        isError: true,
+                    };
+                }
+                // Spawn accepted — the child is no longer a half-made shell.
+                started = true;
+                // Drain (or busy latch) now counts in active; drop the pending slot so
+                // a sibling parallel `subagent` is not double-charged during wait.
+                dropSpawnSlot();
+                if (background) {
+                    return {
+                        content: [
+                            `Started background subagent \`${childId}\` (${label}).`,
+                            `task ${task.id}` +
+                                (spawnRole && spawnRole !== "default" ? ` · role ${spawnRole}` : ""),
+                            inherit
+                                ? "Seeded with this session's completed turns (open turn excluded)."
+                                : undefined,
+                            outputSchema
+                                ? "OUTPUT CONTRACT attached; result will be schema-checked on idle."
+                                : undefined,
+                            childResumeHint(childId),
+                            "Use followup_task to wake a new task, send_message (delivery queue|steer) to continue, wait_agent for results, interrupt_agent (takeover true to pause for human) to stop, analytics for quota.",
+                            "Keep working; do not busy-poll.",
+                            worktreeLine(true) || undefined,
+                        ]
+                            .filter(Boolean)
+                            .join("\n"),
+                    };
+                }
+                try {
+                    await waitDrainIdle(options.runtime, childId, signal, foregroundWaitMs);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const timedOut = /timed out waiting/i.test(message);
+                    // Salvage before cancelling: `session.cancel` drops the chain, so a
+                    // child that had already written its answer would bill the parent for
+                    // nothing. A child that produced nothing is stuck, so it still gets
+                    // cancelled instead of left dangling.
+                    const owned = childOwnedEvents(options.runtime, childId);
+                    const salvaged = lastAssistantBodyText(owned);
+                    const retrying = timedOut
+                        ? lastModelRetryNotice(owned)
+                        : undefined;
+                    if (!salvaged) {
+                        await dispatchFaceMethod(options.runtime, "session.cancel", `tool-sa-c-${childId}`, 
+                        // `parent`, not the default `user`: a parent that gave up waiting
+                        // is not a human hitting Stop. The old default stamped
+                        // turn/end `reason: user`, so every timed-out child read as "stopped
+                        // by the user" in the child log and in the completion notice.
+                        { sessionId: childId, cause: { kind: "parent" } }).catch(() => undefined);
+                    }
+                    options.runtime.agentTeamTasks.complete(task.id, {
+                        ok: false,
+                        preview: message,
                     });
-                    return block ? { userAuthorization: block } : {};
-                })(),
-            });
-            const task = openTask(childId);
-            const worktreeLine = reclaimIsolated;
-            // A transport-level reject (not an RpcResult error) must not leak the
-            // child: the catch backstop tears the half-made spawn down.
-            let prompted;
-            try {
-                prompted = await dispatchFaceMethod(options.runtime, "session.prompt", `tool-sa-p-${childId}`, {
-                    sessionId: childId,
-                    mode: "queue",
-                    content: [{ type: "text", text: childPrompt }],
-                });
-            }
-            catch (err) {
-                await discardIfUnstarted();
-                const extra = worktreeLine(false);
-                const message = err instanceof Error ? err.message : String(err);
-                return {
-                    content: [`subagent prompt failed: ${message}`, extra]
-                        .filter(Boolean)
-                        .join("\n"),
-                    isError: true,
-                };
-            }
-            if (!prompted.result.ok) {
-                await discardIfUnstarted();
-                const extra = worktreeLine(false);
-                return {
-                    content: [`subagent prompt failed: ${prompted.result.error.message}`, extra]
-                        .filter(Boolean)
-                        .join("\n"),
-                    isError: true,
-                };
-            }
-            // Spawn accepted — the child is no longer a half-made shell.
-            started = true;
-            if (background) {
-                return {
-                    content: [
-                        `Started background subagent \`${childId}\` (${label}).`,
-                        `task ${task.id}` +
-                            (spawnRole && spawnRole !== "default" ? ` · role ${spawnRole}` : ""),
-                        inherit
-                            ? "Seeded with this session's completed turns (open turn excluded)."
-                            : undefined,
-                        outputSchema
-                            ? "OUTPUT CONTRACT attached; result will be schema-checked on idle."
-                            : undefined,
-                        childResumeHint(childId),
-                        "Use followup_task to wake a new task, send_message (delivery queue|steer) to continue, wait_agent for results, interrupt_agent (takeover true to pause for human) to stop, analytics for quota.",
-                        "Keep working; do not busy-poll.",
-                        worktreeLine(true) || undefined,
-                    ]
-                        .filter(Boolean)
-                        .join("\n"),
-                };
-            }
-            try {
-                await waitDrainIdle(options.runtime, childId, signal, foregroundWaitMs);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                const timedOut = /timed out waiting/i.test(message);
-                // Salvage before cancelling: `session.cancel` drops the chain, so a
-                // child that had already written its answer would bill the parent for
-                // nothing. A child that produced nothing is stuck, so it still gets
-                // cancelled instead of left dangling.
-                const owned = childOwnedEvents(options.runtime, childId);
-                const salvaged = lastAssistantBodyText(owned);
-                const retrying = timedOut
-                    ? lastModelRetryNotice(owned)
-                    : undefined;
-                if (!salvaged) {
-                    await dispatchFaceMethod(options.runtime, "session.cancel", `tool-sa-c-${childId}`, 
-                    // `parent`, not the default `user`: a parent that gave up waiting
-                    // is not a human hitting Stop. The old default stamped
-                    // turn/end `reason: user`, so every timed-out child read as "stopped
-                    // by the user" in the child log and in the completion notice.
-                    { sessionId: childId, cause: { kind: "parent" } }).catch(() => undefined);
+                    const extra = worktreeLine(false);
+                    return {
+                        content: [
+                            salvaged
+                                ? `${message}, but the child finished work before the wait expired — its last answer is salvaged below.`
+                                : `subagent failed: ${message}`,
+                            salvaged || undefined,
+                            timedOut ? childResumeHint(childId) : undefined,
+                            retrying,
+                            extra,
+                        ]
+                            .filter(Boolean)
+                            .join("\n"),
+                        isError: true,
+                    };
+                }
+                const all = readSessionEvents(options.runtime.store, childId);
+                // Never return seeded parent assistant text as the child's result.
+                const link = options.runtime.subagents.getByChild(childId);
+                const readOwned = () => subagentOwnedEvents(link, readSessionEvents(options.runtime.store, childId));
+                let owned = subagentOwnedEvents(link, all);
+                let text = lastAssistantBodyText(owned);
+                let schemaValid;
+                let schemaErrors;
+                if (outputSchema) {
+                    // An empty body cannot satisfy the contract either: a silent skip
+                    // would hand the parent `ok: true` with an unvalidated (missing)
+                    // answer, so treat "no text" as one more schema failure.
+                    let checked = text
+                        ? validateOutputAgainstSchema(text, outputSchema)
+                        : { valid: false, errors: ["child produced no assistant text"] };
+                    if (!checked.valid) {
+                        const retry = await dispatchFaceMethod(options.runtime, "session.prompt", `tool-sa-schema-${childId}`, {
+                            sessionId: childId,
+                            mode: "queue",
+                            content: [
+                                {
+                                    type: "text",
+                                    text: buildOutputSchemaRetryMessage(checked.errors),
+                                },
+                            ],
+                        });
+                        if (retry.result.ok) {
+                            try {
+                                await waitDrainIdle(options.runtime, childId, signal);
+                            }
+                            catch {
+                                /* keep first answer */
+                            }
+                            owned = readOwned();
+                            text = lastAssistantBodyText(owned) || text;
+                            checked = text
+                                ? validateOutputAgainstSchema(text, outputSchema)
+                                : { valid: false, errors: ["child produced no assistant text"] };
+                        }
+                    }
+                    schemaValid = checked.valid;
+                    schemaErrors = checked.errors;
                 }
                 options.runtime.agentTeamTasks.complete(task.id, {
-                    ok: false,
-                    preview: message,
+                    // An unvalidated answer is not a successful delegation: the task
+                    // board must not read `completed` when the contract was skipped.
+                    ok: schemaValid !== false,
+                    ...(text ? { preview: text } : {}),
+                    ...(schemaValid !== undefined ? { schemaValid } : {}),
+                    ...(schemaErrors && schemaErrors.length > 0
+                        ? { schemaErrors }
+                        : {}),
                 });
                 const extra = worktreeLine(false);
+                if (!text) {
+                    return {
+                        content: [`(subagent ${childId} finished with no assistant text)`, extra]
+                            .filter(Boolean)
+                            .join("\n"),
+                    };
+                }
+                const schemaLine = schemaValid === undefined
+                    ? undefined
+                    : schemaValid
+                        ? "schema_valid=true"
+                        : `schema_valid=false\n${(schemaErrors ?? []).map((e) => `- ${e}`).join("\n")}`;
                 return {
                     content: [
-                        salvaged
-                            ? `${message}, but the child finished work before the wait expired — its last answer is salvaged below.`
-                            : `subagent failed: ${message}`,
-                        salvaged || undefined,
-                        timedOut ? childResumeHint(childId) : undefined,
-                        retrying,
+                        boundChildAnswer(options.parentSessionId, childId, text),
+                        schemaLine,
                         extra,
                     ]
                         .filter(Boolean)
                         .join("\n"),
-                    isError: true,
+                    ...(schemaValid === false ? { isError: true } : {}),
                 };
             }
-            const all = readSessionEvents(options.runtime.store, childId);
-            // Never return seeded parent assistant text as the child's result.
-            const link = options.runtime.subagents.getByChild(childId);
-            const readOwned = () => subagentOwnedEvents(link, readSessionEvents(options.runtime.store, childId));
-            let owned = subagentOwnedEvents(link, all);
-            let text = lastAssistantBodyText(owned);
-            let schemaValid;
-            let schemaErrors;
-            if (outputSchema) {
-                // An empty body cannot satisfy the contract either: a silent skip
-                // would hand the parent `ok: true` with an unvalidated (missing)
-                // answer, so treat "no text" as one more schema failure.
-                let checked = text
-                    ? validateOutputAgainstSchema(text, outputSchema)
-                    : { valid: false, errors: ["child produced no assistant text"] };
-                if (!checked.valid) {
-                    const retry = await dispatchFaceMethod(options.runtime, "session.prompt", `tool-sa-schema-${childId}`, {
-                        sessionId: childId,
-                        mode: "queue",
-                        content: [
-                            {
-                                type: "text",
-                                text: buildOutputSchemaRetryMessage(checked.errors),
-                            },
-                        ],
-                    });
-                    if (retry.result.ok) {
-                        try {
-                            await waitDrainIdle(options.runtime, childId, signal);
-                        }
-                        catch {
-                            /* keep first answer */
-                        }
-                        owned = readOwned();
-                        text = lastAssistantBodyText(owned) || text;
-                        checked = text
-                            ? validateOutputAgainstSchema(text, outputSchema)
-                            : { valid: false, errors: ["child produced no assistant text"] };
-                    }
-                }
-                schemaValid = checked.valid;
-                schemaErrors = checked.errors;
-            }
-            options.runtime.agentTeamTasks.complete(task.id, {
-                // An unvalidated answer is not a successful delegation: the task
-                // board must not read `completed` when the contract was skipped.
-                ok: schemaValid !== false,
-                ...(text ? { preview: text } : {}),
-                ...(schemaValid !== undefined ? { schemaValid } : {}),
-                ...(schemaErrors && schemaErrors.length > 0
-                    ? { schemaErrors }
-                    : {}),
-            });
-            const extra = worktreeLine(false);
-            if (!text) {
-                return {
-                    content: [`(subagent ${childId} finished with no assistant text)`, extra]
-                        .filter(Boolean)
-                        .join("\n"),
-                };
+            finally {
+                dropSpawnSlot();
             }
-            const schemaLine = schemaValid === undefined
-                ? undefined
-                : schemaValid
-                    ? "schema_valid=true"
-                    : `schema_valid=false\n${(schemaErrors ?? []).map((e) => `- ${e}`).join("\n")}`;
-            return {
-                content: [
-                    boundChildAnswer(options.parentSessionId, childId, text),
-                    schemaLine,
-                    extra,
-                ]
-                    .filter(Boolean)
-                    .join("\n"),
-                ...(schemaValid === false ? { isError: true } : {}),
-            };
         },
     };
 }