@ashx-j/lunr 0.2.11 → 0.2.13

package/dist/builtin-extensions/pi-subagents/src/runs/background/async-execution.js

@@ -7,6 +7,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
+import { normalizeChildSpec } from "../../shared/child-spec.js";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
 import { applyThinkingSuffix } from "../shared/pi-args.js";
 import { snapshotParentPermissionMode } from "../../../../../core/subagent-permission-inherit.js";
@@ -14,7 +15,6 @@ import { injectOutputPathSystemPrompt, injectSingleOutputInstruction, normalizeS
 import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile } from "../../shared/settings.js";
 import { resolvePiPackageRoot } from "../shared/pi-spawn.js";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.js";
-import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
 import { PI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveChildCwd } from "../../shared/utils.js";
 import { buildModelCandidates, resolveEffectiveSubagentModel, resolveSubagentModelOverride } from "../shared/model-fallback.js";
 import { resolveEffectiveThinking } from "../../shared/model-info.js";
@@ -23,7 +23,7 @@ import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.js";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.js";
 import { createStructuredOutputRuntime } from "../shared/structured-output.js";
 import { resolveEffectiveAcceptance } from "../shared/acceptance.js";
-import { ASYNC_DIR, RESULTS_DIR, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, TEMP_ROOT_DIR, getAsyncConfigPath, resolveChildMaxSubagentDepth, } from "../../shared/types.js";
+import { ASYNC_DIR, RESULTS_DIR, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, TEMP_ROOT_DIR, getAsyncConfigPath, } from "../../shared/types.js";
 import { nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.js";
 import { initialTurnBudgetState } from "../shared/turn-budget.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
@@ -333,8 +333,11 @@ class UnavailableSubagentSkillError extends Error {
 }
 class AsyncStartValidationError extends Error {
 }
+function childDescription(step) {
+    return step.description || step.label || step.agent || "child";
+}
 export function buildAsyncRunnerSteps(id, params) {
-    const { chain, agents, ctx, cwd, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeBaseDir, asyncDir, } = params;
+    const { chain, ctx, cwd, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeBaseDir, asyncDir, } = params;
     const outputBaseDir = params.outputBaseDir;
     const resultMode = params.resultMode ?? "chain";
     const chainSkills = params.chainSkills ?? [];
@@ -368,18 +371,6 @@ export function buildAsyncRunnerSteps(id, params) {
         throw error;
     }
     const workflowGraph = buildWorkflowGraphSnapshot({ runId: id, mode: resultMode, steps: graphChain });
-    for (const s of chain) {
-        const stepAgents = isParallelStep(s)
-            ? s.parallel.map((t) => t.agent)
-            : isDynamicParallelStep(s)
-                ? [s.parallel.agent]
-                : [s.agent];
-        for (const agentName of stepAgents) {
-            if (!agents.find((x) => x.name === agentName)) {
-                return { error: `Unknown agent: ${agentName}` };
-            }
-        }
-    }
     let progressInstructionCreated = false;
     const buildStepOverrides = (s) => {
         const stepSkillInput = normalizeSkillInput(s.skill);
@@ -393,35 +384,39 @@ export function buildAsyncRunnerSteps(id, params) {
         };
     };
     const buildSeqStep = (s, sessionFile, behaviorCwd, progressPrecreated = false, resolvedBehavior, flatIndex, parallelOutputNamespace) => {
-        const a = agents.find((x) => x.name === s.agent);
-        const toolBudgetInput = s.toolBudget ?? params.toolBudget ?? a.toolBudget ?? params.configToolBudget;
-        const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, s.toolBudget ? "toolBudget" : a.toolBudget ? "agent.toolBudget" : "config.toolBudget");
+        const childIndex = flatIndex ?? parallelOutputNamespace?.stepIndex ?? 0;
+        const spec = normalizeChildSpec(s, {
+            parentMode: snapshotParentPermissionMode(ctx.parentSessionId ?? ctx.currentSessionId),
+            runId: params.childIdRunId ?? id,
+            index: childIndex,
+            childId: s.childId ?? (s.agent?.trim() ? s.agent : undefined),
+            defaultTask: "{previous}",
+            fanoutAuthorized: false,
+        });
+        const toolBudgetInput = spec.toolBudget ?? params.toolBudget ?? params.configToolBudget;
+        const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, spec.toolBudget ? "toolBudget" : "config.toolBudget");
         if (resolvedToolBudget.error)
             throw new AsyncStartValidationError(resolvedToolBudget.error);
         const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
         const instructionCwd = behaviorCwd ?? stepCwd;
-        let behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(a, buildStepOverrides(s), chainSkills), s.task, originalTask);
+        let behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(buildStepOverrides(s), chainSkills), s.task, originalTask);
         const inheritedRelativeParallelOutput = parallelOutputNamespace && s.output === undefined && typeof behavior.output === "string" && !path.isAbsolute(behavior.output);
         if (inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex !== undefined) {
             behavior = {
                 ...behavior,
-                output: path.join(`parallel-${parallelOutputNamespace.stepIndex}`, `${parallelOutputNamespace.taskIndex}-${s.agent}`, behavior.output),
+                output: path.join(`parallel-${parallelOutputNamespace.stepIndex}`, String(parallelOutputNamespace.taskIndex), behavior.output),
             };
         }
         const namespaceOutputPath = Boolean(inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex === undefined);
         const skillNames = behavior.skills === false ? [] : behavior.skills;
-        const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd, a.skillPath, a.filePath ? path.dirname(a.filePath) : stepCwd);
+        const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd, undefined, stepCwd);
         if (missingSkills.includes("pi-subagents"))
             throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-        let systemPrompt = a.systemPrompt?.trim() ?? "";
+        let systemPrompt = "";
         if (resolvedSkills.length > 0) {
             const injection = buildSkillInjection(resolvedSkills);
             systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
         }
-        const memoryInjection = buildAgentMemoryInjection(a, stepCwd);
-        if (memoryInjection) {
-            systemPrompt = systemPrompt ? `${systemPrompt}\n\n${memoryInjection}` : memoryInjection;
-        }
         const readInstructions = buildChainInstructions({ ...behavior, output: false, progress: false }, instructionCwd, false);
         const isFirstProgressAgent = behavior.progress && !progressPrecreated && !progressInstructionCreated;
         if (behavior.progress)
@@ -429,23 +424,30 @@ export function buildAsyncRunnerSteps(id, params) {
         const progressInstructions = buildChainInstructions({ ...behavior, output: false, reads: false }, progressDir, isFirstProgressAgent);
         const outputPath = resolveSingleOutputPath(behavior.output, ctx.cwd, instructionCwd, outputBaseDir);
         if (!namespaceOutputPath)
-            systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, a);
-        const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Async step (${s.agent})`);
+            systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, {
+                tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : undefined,
+            });
+        const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Async step (${spec.description})`);
         if (validationError)
             throw new AsyncStartValidationError(validationError);
         let taskTemplate = s.task ?? "{previous}";
         taskTemplate = taskTemplate.replace(/\{task\}/g, originalTask ?? "");
         taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
         const taskText = `${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`;
-        const task = namespaceOutputPath ? taskText : injectSingleOutputInstruction(taskText, outputPath, a);
-        const primaryModel = resolveEffectiveSubagentModel(s.model, a.model, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope });
+        const task = namespaceOutputPath ? taskText : injectSingleOutputInstruction(taskText, outputPath, {
+            tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : undefined,
+        });
+        const primaryModel = resolveEffectiveSubagentModel(spec.model, undefined, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope });
         const thinkingOverride = flatIndex === undefined ? undefined : thinkingOverridesByFlatIndex?.[flatIndex];
-        const effectiveThinking = thinkingOverride ?? a.thinking;
+        const effectiveThinking = thinkingOverride;
         const model = applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== undefined);
         return {
             parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
             parentPermissionMode: snapshotParentPermissionMode(ctx.parentSessionId ?? ctx.currentSessionId),
-            agent: s.agent,
+            childId: spec.childId,
+            description: spec.description,
+            permissions: spec.effectivePermissions,
+            agent: spec.description,
             task,
             phase: s.phase,
             label: s.label,
@@ -454,34 +456,29 @@ export function buildAsyncRunnerSteps(id, params) {
             cwd: stepCwd,
             model,
             thinking: resolveEffectiveThinking(model, effectiveThinking),
-            modelCandidates: buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined)),
-            tools: a.tools,
-            extensions: a.extensions,
-            subagentOnlyExtensions: a.subagentOnlyExtensions,
-            mcpDirectTools: a.mcpDirectTools,
-            completionGuard: a.completionGuard,
+            modelCandidates: buildModelCandidates(primaryModel, undefined, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined)),
             systemPrompt,
-            systemPromptMode: a.systemPromptMode,
-            inheritProjectContext: a.inheritProjectContext,
-            inheritSkills: a.inheritSkills,
+            systemPromptMode: "append",
+            inheritProjectContext: true,
+            inheritSkills: false,
             skills: resolvedSkills.map((r) => r.name),
             outputPath,
             ...(namespaceOutputPath ? { namespaceOutputPath: true } : {}),
             outputMode: behavior.outputMode,
             sessionFile,
-            maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, a.maxSubagentDepth),
+            maxSubagentDepth,
             waitToolEnabled: params.waitToolEnabled,
             effectiveAcceptance: resolveEffectiveAcceptance({
                 explicit: s.acceptance,
-                agentName: s.agent,
-                acceptanceRole: a.acceptanceRole,
+                agentName: spec.description,
+                permissions: spec.effectivePermissions,
                 task,
                 mode: resultMode,
                 async: true,
                 dynamic: false,
             }),
             acceptanceInput: s.acceptance,
-            acceptanceRole: a.acceptanceRole,
+            acceptanceRole: spec.effectivePermissions === "read-only" ? "read-only" : "writer",
             ...(s.outputSchema ? { structuredOutputSchema: s.outputSchema } : {}),
             ...(s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path.join(asyncDir, "structured-output")) } : {}),
             ...(resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}),
@@ -503,8 +500,7 @@ export function buildAsyncRunnerSteps(id, params) {
         const builtSteps = chain.map((s, stepIndex) => {
             if (isParallelStep(s)) {
                 const parallelBehaviors = s.parallel.map((task) => {
-                    const agent = agents.find((candidate) => candidate.name === task.agent);
-                    return suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(task), chainSkills), task.task, originalTask);
+                    return suppressProgressForReadOnlyTask(resolveStepBehavior(buildStepOverrides(task), chainSkills), task.task, originalTask);
                 });
                 const progressPrecreated = parallelBehaviors.some((behavior) => behavior.progress);
                 if (progressPrecreated) {
@@ -532,8 +528,7 @@ export function buildAsyncRunnerSteps(id, params) {
                 };
             }
             if (isDynamicParallelStep(s)) {
-                const agent = agents.find((candidate) => candidate.name === s.parallel.agent);
-                const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(s.parallel), chainSkills), s.parallel.task, originalTask);
+                const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(buildStepOverrides(s.parallel), chainSkills), s.parallel.task, originalTask);
                 const progressPrecreated = behavior.progress;
                 if (progressPrecreated) {
                     writeInitialProgressFile(progressDir);
@@ -554,15 +549,15 @@ export function buildAsyncRunnerSteps(id, params) {
                     thinkingOverrides: dynamicFlatSteps.map((step) => step.thinkingOverride),
                     effectiveAcceptance: resolveEffectiveAcceptance({
                         explicit: s.acceptance,
-                        agentName: s.parallel.agent,
-                        acceptanceRole: agent.acceptanceRole,
+                        agentName: s.parallel.description,
+                        permissions: s.parallel.permissions === "read-only" ? "read-only" : "full",
                         task: parallel.task,
                         mode: resultMode,
                         async: true,
                         dynamicGroup: true,
                     }),
                     acceptanceInput: s.acceptance,
-                    acceptanceRole: agent.acceptanceRole,
+                    acceptanceRole: s.parallel.permissions === "read-only" ? "read-only" : "writer",
                 };
             }
             const staticStep = nextFlatStep();
@@ -611,7 +606,7 @@ export function buildAsyncRunnerSteps(id, params) {
  * Execute a chain asynchronously
  */
 export function executeAsyncChain(id, params) {
-    const { chain, agents, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
+    const { chain, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
     const resultMode = params.resultMode ?? "chain";
     const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
     const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
@@ -634,7 +629,6 @@ export function executeAsyncChain(id, params) {
         task: params.task,
         attachRoot: params.attachRoot,
         resultMode,
-        agents,
         ctx,
         availableModels: params.availableModels,
         cwd,
@@ -674,9 +668,9 @@ export function executeAsyncChain(id, params) {
                 childTargetIndex++;
                 return [undefined];
             }
-            return step.parallel.map((task) => childIntercomTarget(task.agent, childTargetIndex++));
+            return step.parallel.map((task) => childIntercomTarget(task.childId ?? task.agent, childTargetIndex++));
         }
-        return [childIntercomTarget(step.agent, childTargetIndex++)];
+        return [childIntercomTarget(step.childId ?? step.agent, childTargetIndex++)];
     }) : undefined;
     let spawnResult = {};
     try {
@@ -728,10 +722,10 @@ export function executeAsyncChain(id, params) {
     if (spawnResult.pid) {
         const eventFirstStep = eventChain[0];
         const firstAgents = isParallelStep(eventFirstStep)
-            ? eventFirstStep.parallel.map((t) => t.agent)
+            ? eventFirstStep.parallel.map(childDescription)
             : isDynamicParallelStep(eventFirstStep)
-                ? [eventFirstStep.parallel.agent]
-                : [eventFirstStep.agent];
+                ? [childDescription(eventFirstStep.parallel)]
+                : [childDescription(eventFirstStep)];
         const firstTask = isParallelStep(eventFirstStep)
             ? eventFirstStep.parallel[0]?.task
             : isDynamicParallelStep(eventFirstStep)
@@ -745,16 +739,16 @@ export function executeAsyncChain(id, params) {
             const step = eventChain[stepIndex];
             if (isParallelStep(step)) {
                 parallelGroups.push({ start: flatStepStart, count: step.parallel.length, stepIndex });
-                flatAgents.push(...step.parallel.map((task) => task.agent));
+                flatAgents.push(...step.parallel.map(childDescription));
                 flatStepStart += step.parallel.length;
             }
             else if (isDynamicParallelStep(step)) {
                 parallelGroups.push({ start: flatStepStart, count: 1, stepIndex });
-                flatAgents.push(step.parallel.agent);
+                flatAgents.push(childDescription(step.parallel));
                 flatStepStart++;
             }
             else {
-                flatAgents.push(step.agent);
+                flatAgents.push(childDescription(step));
                 flatStepStart++;
             }
         }
@@ -805,7 +799,7 @@ export function executeAsyncChain(id, params) {
             agents: flatAgents,
             task: firstTask?.slice(0, 50),
             goal: workflowGoal?.slice(0, 120),
-            chain: eventChain.map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent),
+            chain: eventChain.map((s) => isParallelStep(s) ? `[${s.parallel.map(childDescription).join("+")}]` : isDynamicParallelStep(s) ? `expand:${childDescription(s.parallel)}` : childDescription(s)),
             chainStepCount: eventChain.length,
             parallelGroups,
             workflowGraph,
@@ -817,7 +811,7 @@ export function executeAsyncChain(id, params) {
         });
     }
     const chainDesc = chain
-        .map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent)
+        .map((s) => isParallelStep(s) ? `[${s.parallel.map(childDescription).join("+")}]` : isDynamicParallelStep(s) ? `expand:${childDescription(s.parallel)}` : childDescription(s))
         .join(" -> ");
     return {
         content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`) }],
@@ -828,23 +822,20 @@ export function executeAsyncChain(id, params) {
  * Execute a single agent asynchronously
  */
 export function executeAsyncSingle(id, params) {
-    const { agent, agentConfig, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFile, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
-    const task = params.task ?? "";
+    const { spec, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFile, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
+    const agent = spec.description;
+    const task = spec.task;
     const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
-    const skillNames = params.skills ?? agentConfig.skills ?? [];
+    const skillNames = params.skills ?? (spec.skill === false ? [] : normalizeSkillInput(spec.skill) ?? []);
     const availableModels = params.availableModels;
-    const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd, agentConfig.skillPath, agentConfig.filePath ? path.dirname(agentConfig.filePath) : runnerCwd);
+    const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd, undefined, runnerCwd);
     if (missingSkills.includes("pi-subagents"))
         return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-    let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
+    let systemPrompt = "";
     if (resolvedSkills.length > 0) {
         const injection = buildSkillInjection(resolvedSkills);
         systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
     }
-    const memoryInjection = buildAgentMemoryInjection(agentConfig, runnerCwd);
-    if (memoryInjection) {
-        systemPrompt = systemPrompt ? `${systemPrompt}\n\n${memoryInjection}` : memoryInjection;
-    }
     const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
     const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
     const asyncDir = inheritedNestedRoute
@@ -861,19 +852,20 @@ export function executeAsyncSingle(id, params) {
             details: { mode: "single", results: [] },
         };
     }
-    const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
+    const effectiveOutput = normalizeSingleOutputOverride(params.output ?? spec.output, typeof spec.output === "string" ? spec.output : undefined);
     const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd, params.outputBaseDir ?? (artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined));
-    systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, agentConfig);
-    const outputMode = params.outputMode ?? "inline";
+    const childToolShape = { tools: spec.effectivePermissions === "read-only" ? ["read", "grep", "find", "ls", "bash"] : undefined };
+    systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, childToolShape);
+    const outputMode = params.outputMode ?? spec.outputMode ?? "inline";
     const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
     if (validationError)
         return formatAsyncStartError("single", validationError);
-    const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, agentConfig);
-    const primaryModel = resolveSubagentModelOverride(params.modelOverride ?? agentConfig.model, ctx.currentModel, availableModels, ctx.currentModelProvider);
-    const effectiveThinking = params.thinkingOverride ?? agentConfig.thinking;
+    const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, childToolShape);
+    const primaryModel = resolveSubagentModelOverride(params.modelOverride ?? spec.model, ctx.currentModel, availableModels, ctx.currentModelProvider);
+    const effectiveThinking = params.thinkingOverride;
     const model = applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
-    const toolBudgetInput = params.toolBudget ?? agentConfig.toolBudget ?? params.configToolBudget;
-    const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget ? "toolBudget" : agentConfig.toolBudget ? "agent.toolBudget" : "config.toolBudget");
+    const toolBudgetInput = params.toolBudget ?? spec.toolBudget ?? params.configToolBudget;
+    const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget || spec.toolBudget ? "toolBudget" : "config.toolBudget");
     if (resolvedToolBudget.error)
         return formatAsyncStartError("single", resolvedToolBudget.error);
     const deadlineAt = params.absoluteDeadlineAt ?? (params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined);
@@ -885,35 +877,26 @@ export function executeAsyncSingle(id, params) {
     const initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : undefined;
     const resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined);
     const resolvedAcceptance = resolveEffectiveAcceptance({
-        explicit: params.acceptance,
+        explicit: params.acceptance ?? spec.acceptance,
         agentName: agent,
-        acceptanceRole: agentConfig.acceptanceRole,
+        permissions: spec.effectivePermissions,
         task,
         mode: "single",
         async: true,
     });
     const recoveryDescriptor = {
-        version: 1,
+        version: 3,
+        lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
         sourceRunId: id,
+        childId: spec.childId,
+        description: spec.description,
+        permissions: spec.effectivePermissions,
         agent,
         ...(sessionFile ? { sessionFile } : {}),
         cwd: runnerCwd,
         ...(model ? { model } : {}),
-        ...(agentConfig.fallbackModels ? { fallbackModels: [...agentConfig.fallbackModels] } : {}),
         ...(effectiveThinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {}),
-        ...(agentConfig.tools ? { tools: [...agentConfig.tools] } : {}),
-        ...(agentConfig.extensions ? { extensions: [...agentConfig.extensions] } : {}),
-        ...(agentConfig.subagentOnlyExtensions ? { subagentOnlyExtensions: [...agentConfig.subagentOnlyExtensions] } : {}),
-        ...(agentConfig.mcpDirectTools ? { mcpDirectTools: [...agentConfig.mcpDirectTools] } : {}),
-        ...(agentConfig.systemPrompt ? { systemPrompt: agentConfig.systemPrompt } : {}),
-        systemPromptMode: agentConfig.systemPromptMode,
-        inheritProjectContext: agentConfig.inheritProjectContext,
-        inheritSkills: agentConfig.inheritSkills,
         ...(resolvedSkills.length ? { skills: resolvedSkills.map((skill) => skill.name) } : {}),
-        ...(agentConfig.skillPath ? { skillPath: [...agentConfig.skillPath] } : {}),
-        ...(agentConfig.filePath ? { agentFilePath: agentConfig.filePath } : {}),
-        ...(agentConfig.completionGuard !== undefined ? { completionGuard: agentConfig.completionGuard } : {}),
-        ...(agentConfig.memory ? { memory: { ...agentConfig.memory } } : {}),
         ...(outputPath ? { outputPath } : {}),
         outputMode,
         ...(resolvedAcceptance ? { acceptance: resolvedAcceptance } : {}),
@@ -921,7 +904,7 @@ export function executeAsyncSingle(id, params) {
         ...(deadlineAt !== undefined ? { absoluteDeadlineAt: deadlineAt } : {}),
         ...(params.turnBudget ? { initialTurnBudget: params.turnBudget } : {}),
         ...(resolvedToolBudget.budget ? { initialToolBudget: resolvedToolBudget.budget } : {}),
-        maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
+        maxSubagentDepth,
         ...(maxOutput ? { maxOutput } : {}),
         share: shareEnabled,
         ...(resolvedSessionDir ? { sessionDir: resolvedSessionDir } : {}),
@@ -942,26 +925,24 @@ export function executeAsyncSingle(id, params) {
                 {
                     parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
                     parentPermissionMode: snapshotParentPermissionMode(ctx.parentSessionId ?? ctx.currentSessionId),
+                    childId: spec.childId,
+                    description: spec.description,
+                    permissions: spec.effectivePermissions,
                     agent,
                     task: taskWithOutputInstruction,
                     cwd: runnerCwd,
                     model,
                     thinking: resolveEffectiveThinking(model, effectiveThinking),
-                    modelCandidates: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined)),
-                    tools: agentConfig.tools,
-                    extensions: agentConfig.extensions,
-                    subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
-                    mcpDirectTools: agentConfig.mcpDirectTools,
-                    completionGuard: agentConfig.completionGuard,
+                    modelCandidates: buildModelCandidates(primaryModel, undefined, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined)),
                     systemPrompt,
-                    systemPromptMode: agentConfig.systemPromptMode,
-                    inheritProjectContext: agentConfig.inheritProjectContext,
-                    inheritSkills: agentConfig.inheritSkills,
+                    systemPromptMode: "append",
+                    inheritProjectContext: true,
+                    inheritSkills: false,
                     skills: resolvedSkills.map((r) => r.name),
                     outputPath,
                     outputMode,
                     sessionFile,
-                    maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
+                    maxSubagentDepth,
                     waitToolEnabled: params.waitToolEnabled,
                     effectiveAcceptance: resolvedAcceptance,
                     ...(resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}),
@@ -988,7 +969,7 @@ export function executeAsyncSingle(id, params) {
             turnBudget: params.turnBudget,
             toolBudget: params.toolBudget,
             controlIntercomTarget,
-            childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
+            childIntercomTargets: childIntercomTarget ? [childIntercomTarget(spec.childId, 0)] : undefined,
             resultMode: "single",
             ...(params.revivalLease ? { revivalLease: params.revivalLease } : {}),
             nestedRoute: nestedRoute ?? inheritedNestedRoute,