iosm-cli 0.2.3 → 0.2.5

package/dist/core/tools/task.js

@@ -4,19 +4,27 @@ import { spawnSync } from "node:child_process";
 import { Type } from "@sinclair/typebox";
 import { getTeamRun, updateTeamTaskStatus } from "../agent-teams.js";
 import { buildRetrospectiveDirective, classifyFailureCause, formatFailureCauseCounts, isRetrospectiveRetryable, } from "../failure-retrospective.js";
+import { MAX_ORCHESTRATION_AGENTS, MAX_ORCHESTRATION_PARALLEL, MAX_SUBAGENT_DELEGATE_PARALLEL, MAX_SUBAGENT_DELEGATION_DEPTH, MAX_SUBAGENT_DELEGATIONS_PER_TASK, } from "../orchestration-limits.js";
+import { AGENT_PROFILES, isReadOnlyProfileName, isValidProfileName, } from "../agent-profiles.js";
 const taskSchema = Type.Object({
-    description: Type.String({
-        description: "Short 3-5 word description of what the subagent will do",
-    }),
-    prompt: Type.String({
-        description: "Full task prompt for the subagent",
-    }),
+    description: Type.Optional(Type.String({
+        description: "Optional short 3-5 word description of what the subagent will do. If omitted, it is derived from prompt.",
+    })),
+    task: Type.Optional(Type.String({
+        description: "Legacy alias for prompt. If provided, it is treated as the subagent prompt when prompt is omitted.",
+    })),
+    args: Type.Optional(Type.String({
+        description: "Legacy alias for prompt used by some models. If provided, it is treated as the subagent prompt when prompt/task are omitted.",
+    })),
+    prompt: Type.Optional(Type.String({
+        description: "Optional full task prompt for the subagent. If omitted, the description is used as the prompt.",
+    })),
     agent: Type.Optional(Type.String({
         description: "Optional custom subagent name loaded from .iosm/agents or global agents directory.",
     })),
-    profile: Type.String({
-        description: "Subagent capability profile. Recommended values: explore, plan, iosm, iosm_analyst, iosm_verifier, cycle_planner, full. For custom agents, pass the agent name via `agent`, not `profile`.",
-    }),
+    profile: Type.Optional(Type.String({
+        description: "Optional subagent capability profile. Defaults to the current host profile when omitted (or full if host profile is unavailable). Recommended values: explore, plan, iosm, meta, iosm_analyst, iosm_verifier, cycle_planner, full. For custom agents, pass the agent name via `agent`, not `profile`.",
+    })),
     cwd: Type.Optional(Type.String({
         description: "Optional working directory for this subagent. Relative paths are resolved from the current workspace.",
     })),
@@ -40,31 +48,30 @@ const taskSchema = Type.Object({
     })),
     delegate_parallel_hint: Type.Optional(Type.Integer({
         minimum: 1,
-        maximum: 10,
+        maximum: MAX_SUBAGENT_DELEGATE_PARALLEL,
         description: "Optional hint for intra-task delegation fan-out. Higher value allows more delegated subtasks to run in parallel inside a single task execution.",
     })),
 });
-/** Tool names available per profile */
-const toolsByProfile = {
-    explore: ["read", "grep", "find", "ls"],
-    plan: ["read", "bash", "grep", "find", "ls"],
-    iosm: ["read", "bash", "edit", "write", "grep", "find", "ls"],
-    iosm_analyst: ["read", "bash", "grep", "find", "ls"],
-    iosm_verifier: ["read", "bash", "write"],
-    cycle_planner: ["read", "bash", "write"],
-    full: ["read", "bash", "edit", "write", "grep", "find", "ls"],
-};
+/** Tool names available per profile (kept in sync with AGENT_PROFILES). */
+const toolsByProfile = Object.values(AGENT_PROFILES).reduce((acc, profile) => {
+    acc[profile.name] = [...profile.tools];
+    return acc;
+}, {});
 /** System prompt injected per profile */
 const systemPromptByProfile = {
     explore: "You are a fast read-only codebase explorer. Answer concisely. Never write or edit files.",
     plan: "You are a technical architect. Analyze the codebase and produce a clear implementation plan. Do not write or edit files.",
     iosm: "You are an IOSM execution agent. Use IOSM methodology and keep IOSM artifacts synchronized with implementation.",
+    meta: "You are a meta orchestration agent. Your main job is to maximize safe parallel execution through delegates, not to personally do most of the implementation. Start with bounded read-only recon, then form a concrete execution graph: subtasks, delegate subtasks, dependencies, lock domains, and verification steps. The parent agent remains responsible for orchestration and synthesis, so decompose work aggressively instead of collapsing complex work into one worker. For any non-trivial task, orchestration is required: after recon, launch multiple focused delegates instead of continuing manual implementation in the parent agent, avoid direct write/edit work in the parent agent before delegation unless the task is clearly trivial, and do not hand the whole task to one specialist child when independent workstreams exist. If a delegated workstream still contains multiple independent slices, split it again with nested <delegate_task> blocks. Default to aggressive safe parallelism. If the user requested a specific degree of parallelism, honor it when feasible or explain the exact blocker. Use shared_memory as the default coordination channel between delegates: use stable namespaced keys, prefer read-before-write, and use CAS (if_version) for contested updates; reserve append mode for timeline/log keys. When delegation is not used for non-trivial work, explain why in one line and include DELEGATION_IMPOSSIBLE. Enforce test verification for code changes, complete only after all delegated branches are resolved, and explicitly justify any no-code path where tests are skipped.",
     iosm_analyst: "You are an IOSM metrics analyst. Analyze .iosm/ artifacts and codebase metrics. Be precise and evidence-based.",
     iosm_verifier: "You are an IOSM verifier. Validate checks and update only required IOSM artifacts with deterministic reasoning.",
     cycle_planner: "You are an IOSM cycle planner. Propose and align cycle goals with measurable outcomes and concrete risks.",
     full: "You are a software engineering agent. Execute the task end-to-end.",
 };
-const writeCapableProfiles = new Set(["full", "iosm_verifier", "cycle_planner"]);
+const writeCapableTools = new Set(["bash", "edit", "write"]);
+const backgroundUnsafeTools = new Set(writeCapableTools);
+const writeCapableProfiles = new Set(Object.keys(toolsByProfile).filter((profileName) => toolsByProfile[profileName].some((tool) => writeCapableTools.has(tool))));
+const backgroundSafeProfiles = Object.keys(toolsByProfile).filter((profileName) => toolsByProfile[profileName].every((tool) => !backgroundUnsafeTools.has(tool)));
 const delegationTagName = "delegate_task";
 class Semaphore {
     constructor(limit) {
@@ -121,11 +128,11 @@ class Mutex {
         return !this.locked && this.waiters.length === 0;
     }
 }
-const maxParallelFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_PARALLEL, 20, 1, 20);
+const maxParallelFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_PARALLEL, MAX_ORCHESTRATION_PARALLEL, 1, MAX_ORCHESTRATION_PARALLEL);
 const subagentSemaphore = new Semaphore(maxParallelFromEnv);
-const maxDelegationDepthFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATION_DEPTH, 1, 0, 3);
-const maxDelegationsPerTaskFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATIONS_PER_TASK, 10, 0, 10);
-const maxDelegatedParallelFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATE_PARALLEL, 10, 1, 10);
+const maxDelegationDepthFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATION_DEPTH, 2, 0, MAX_SUBAGENT_DELEGATION_DEPTH);
+const maxDelegationsPerTaskFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATIONS_PER_TASK, MAX_SUBAGENT_DELEGATIONS_PER_TASK, 0, MAX_SUBAGENT_DELEGATIONS_PER_TASK);
+const maxDelegatedParallelFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_MAX_DELEGATE_PARALLEL, MAX_SUBAGENT_DELEGATE_PARALLEL, 1, MAX_SUBAGENT_DELEGATE_PARALLEL);
 const emptyOutputRetriesFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_EMPTY_OUTPUT_RETRIES, 1, 0, 2);
 const retrospectiveRetriesFromEnv = parseBoundedInt(process.env.IOSM_SUBAGENT_RETRO_RETRIES, 1, 0, 1);
 const orchestrationDependencyWaitTimeoutMsFromEnv = parseBoundedInt(process.env.IOSM_ORCHESTRATION_DEPENDENCY_WAIT_TIMEOUT_MS, 120_000, 5_000, 900_000);
@@ -141,14 +148,21 @@ function parseBoundedInt(raw, fallback, min, max) {
         return fallback;
     return Math.max(min, Math.min(max, parsed));
 }
-function shouldAutoDelegateByAgent(agentName) {
-    if (!agentName)
-        return false;
-    const normalized = agentName.trim().toLowerCase();
-    return normalized.includes("orchestrator");
+function shouldAutoDelegate(input) {
+    const profile = input.profile?.trim().toLowerCase();
+    if (profile === "meta")
+        return true;
+    const hostProfile = input.hostProfile?.trim().toLowerCase();
+    if (hostProfile === "meta")
+        return true;
+    const agentName = input.agentName?.trim().toLowerCase();
+    return !!agentName && agentName.includes("orchestrator");
 }
-function deriveAutoDelegateParallelHint(agentName, description, prompt) {
-    if (!shouldAutoDelegateByAgent(agentName))
+function deriveAutoDelegateParallelHint(profile, agentName, hostProfile, description, prompt) {
+    const normalizedProfile = profile?.trim().toLowerCase();
+    const isMetaProfile = normalizedProfile === "meta";
+    const isMetaHost = hostProfile?.trim().toLowerCase() === "meta";
+    if (!shouldAutoDelegate({ profile: normalizedProfile, agentName, hostProfile }))
         return undefined;
     const text = `${description}\n${prompt}`.trim();
     if (!text)
@@ -163,6 +177,9 @@ function deriveAutoDelegateParallelHint(agentName, description, prompt) {
     const fileLikeMatches = normalized.match(/\b[A-Za-z0-9_.-]+\.[A-Za-z0-9]{1,8}\b/g) ?? [];
     const listMarkers = text.match(/(?:^|\n)\s*(?:[-*]|\d+[.)])\s+/g)?.length ?? 0;
     const hasCodeBlock = text.includes("```");
+    const actionTokenMatches = normalized.match(/\b(?:audit|security|auth|rbac|sqli|sql|injection|fix|implement|refactor|migrat|harden|verify|test|scan|orchestrate|parallel|delegate|bug|vulnerab)\w*/gi) ?? [];
+    const strongActionSignal = new Set(actionTokenMatches.map((token) => token.toLowerCase())).size >= 2;
+    const metaOrchestratorContext = isMetaProfile || isMetaHost;
     let score = 0;
     if (words >= 40) {
         score += 2;
@@ -180,12 +197,33 @@ function deriveAutoDelegateParallelHint(agentName, description, prompt) {
         score += 1;
     }
     const referenceCount = pathLikeMatches.length + fileLikeMatches.length;
+    const metaNonTrivialSignal = words >= 12 ||
+        clauses >= 3 ||
+        listMarkers >= 1 ||
+        referenceCount >= 1 ||
+        hasCodeBlock ||
+        (strongActionSignal && words >= 4);
     if (referenceCount >= 3 || (referenceCount >= 1 && words >= 20)) {
         score += 1;
     }
     if (hasCodeBlock) {
         score += 1;
     }
+    if (metaOrchestratorContext) {
+        // In meta orchestration, require delegation pressure for non-trivial prompts
+        // even when lexical scoring is still low.
+        if (score === 0) {
+            if (strongActionSignal && words >= 4) {
+                score = 1;
+            }
+            else if (metaNonTrivialSignal) {
+                score = 2;
+            }
+        }
+        else if (score > 0) {
+            score += 1;
+        }
+    }
     if (score >= 6)
         return 10;
     if (score >= 5)
@@ -203,6 +241,40 @@ function deriveAutoDelegateParallelHint(agentName, description, prompt) {
 function normalizeSpacing(text) {
     return text.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
 }
+function deriveTaskDescriptionFromPrompt(prompt) {
+    const firstMeaningfulLine = prompt
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0) ?? "Run subtask";
+    const normalized = firstMeaningfulLine
+        .replace(/^[-*]\s+/, "")
+        .replace(/^\d+[.)]\s+/, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (normalized.length <= 80) {
+        return normalized;
+    }
+    return `${normalized.slice(0, 77).trimEnd()}...`;
+}
+function normalizeTaskPayload(input) {
+    const rawDescription = input.description?.trim();
+    const rawTask = input.task?.trim();
+    const rawArgs = input.args?.trim();
+    const rawPrompt = input.prompt?.trim() || rawTask || rawArgs;
+    if (rawDescription && rawPrompt) {
+        return { description: rawDescription, prompt: rawPrompt };
+    }
+    if (rawDescription) {
+        return { description: rawDescription, prompt: rawDescription };
+    }
+    if (rawPrompt) {
+        return {
+            description: deriveTaskDescriptionFromPrompt(rawPrompt),
+            prompt: rawPrompt,
+        };
+    }
+    throw new Error('Task tool requires at least one of "description", "task", "args", or "prompt".');
+}
 function cloneDelegateItems(items) {
     return items ? items.map((item) => ({ ...item })) : undefined;
 }
@@ -248,26 +320,193 @@ function mergeRunStats(base, next) {
         assistantMessages: (base?.assistantMessages ?? 0) + (next?.assistantMessages ?? 0),
     };
 }
-function buildDelegationProtocolPrompt(depthRemaining, maxDelegations) {
+function buildDelegationProtocolPrompt(depthRemaining, maxDelegations, minDelegationsPreferred = 0) {
     if (depthRemaining <= 0) {
         return [
             `Delegation protocol: depth limit reached.`,
             `Do not emit <${delegationTagName}> blocks.`,
         ].join("\n");
     }
+    if (minDelegationsPreferred > 0) {
+        const required = Math.min(Math.max(1, minDelegationsPreferred), maxDelegations);
+        return [
+            `Delegation protocol (required for this run): emit at least ${required} XML block(s) when the assigned work still contains independent slices.`,
+            `For broad audit, implementation, or verification tasks, split by subsystem, file family, or verification stream instead of producing one monolithic answer.`,
+            `<${delegationTagName} profile="explore|plan|iosm|meta|iosm_analyst|iosm_verifier|cycle_planner|full" agent="optional custom subagent name" description="short title" cwd="optional relative path" lock_key="optional lock key" model="optional model override" isolation="none|worktree" depends_on="optional indices like 1|3">`,
+            "Detailed delegated task prompt",
+            `</${delegationTagName}>`,
+            `Keep a brief coordinator note outside the blocks, but do not collapse the full workload into one monolithic answer.`,
+            `If safe decomposition is truly impossible, output exactly one line: DELEGATION_IMPOSSIBLE: <precise reason>.`,
+            `When shared_memory tools are available, exchange intermediate state through shared_memory_write/shared_memory_read instead of repeating large context.`,
+            `Shared-memory protocol: use stable namespaced keys (findings/<stream>, plan/<stream>, risks/<stream>).`,
+            `Use scope=run for cross-stream coordination, scope=task for local scratch state, read before overwrite, and use if_version for contested updates.`,
+            `Reserve mode=append for timeline/log keys only; avoid append on canonical state keys.`,
+        ].join("\n");
+    }
     return [
         `Delegation protocol (optional): if you discover concrete independent follow-ups, emit up to ${maxDelegations} XML block(s):`,
-        `<${delegationTagName} profile="explore|plan|iosm|iosm_analyst|iosm_verifier|cycle_planner|full" agent="optional custom subagent name" description="short title" cwd="optional relative path" lock_key="optional lock key" model="optional model override" isolation="none|worktree" depends_on="optional indices like 1|3">`,
+        `<${delegationTagName} profile="explore|plan|iosm|meta|iosm_analyst|iosm_verifier|cycle_planner|full" agent="optional custom subagent name" description="short title" cwd="optional relative path" lock_key="optional lock key" model="optional model override" isolation="none|worktree" depends_on="optional indices like 1|3">`,
         "Detailed delegated task prompt",
         `</${delegationTagName}>`,
         `Only emit blocks when necessary. Keep normal analysis/answer text outside those blocks.`,
         `When shared_memory tools are available, exchange intermediate state through shared_memory_write/shared_memory_read instead of repeating large context.`,
+        `Shared-memory protocol: prefer namespaced keys and read-before-write discipline; use CAS (if_version) on shared state updates.`,
+        `Reserve mode=append for timeline/log keys only.`,
     ].join("\n");
 }
-function withDelegationPrompt(basePrompt, depthRemaining, maxDelegations) {
-    const protocol = buildDelegationProtocolPrompt(depthRemaining, maxDelegations);
+function truncateForDelegationContext(text, maxChars = 2200) {
+    const normalized = normalizeSpacing(text);
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, Math.max(100, maxChars - 3)).trimEnd()}...`;
+}
+function extractDelegationWorkstreams(text, maxItems) {
+    if (maxItems <= 0)
+        return [];
+    const seen = new Set();
+    const pushUnique = (raw) => {
+        const cleaned = raw
+            .replace(/^[-*]\s+/, "")
+            .replace(/^\d+[.)]\s+/, "")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (cleaned.length < 5)
+            return;
+        const key = cleaned.toLowerCase();
+        if (seen.has(key))
+            return;
+        seen.add(key);
+    };
+    for (const line of text.split("\n")) {
+        if (!/^\s*(?:[-*]|\d+[.)])\s+/.test(line))
+            continue;
+        pushUnique(line);
+        if (seen.size >= maxItems)
+            break;
+    }
+    if (seen.size < maxItems) {
+        const fragments = text
+            .split(/[\n.;:]+/g)
+            .map((fragment) => fragment.trim())
+            .filter((fragment) => fragment.length >= 10)
+            .slice(0, maxItems * 3);
+        for (const fragment of fragments) {
+            pushUnique(fragment);
+            if (seen.size >= maxItems)
+                break;
+        }
+    }
+    return Array.from(seen).slice(0, maxItems);
+}
+function deriveAutoDelegateProfile(baseProfile, description, prompt) {
+    const signal = `${description}\n${prompt}`.toLowerCase();
+    const writeIntent = /\b(?:implement|fix|patch|refactor|rewrite|edit|update|migrate|change|write|apply)\b/.test(signal);
+    if (baseProfile === "full")
+        return writeIntent ? "full" : "explore";
+    if (baseProfile === "meta")
+        return writeIntent ? "full" : "explore";
+    if (baseProfile === "iosm")
+        return writeIntent ? "full" : "explore";
+    if (baseProfile === "iosm_verifier")
+        return "iosm_verifier";
+    if (baseProfile === "cycle_planner")
+        return "cycle_planner";
+    if (baseProfile === "plan" || baseProfile === "iosm_analyst")
+        return "explore";
+    return "explore";
+}
+function pickAutoDelegateAgent(workstream, availableCustomNames) {
+    if (availableCustomNames.length === 0)
+        return undefined;
+    const normalizedWorkstream = workstream.toLowerCase();
+    const names = availableCustomNames.map((name) => ({ raw: name, normalized: name.toLowerCase() }));
+    const findByHint = (hints) => {
+        for (const hint of hints) {
+            const exact = names.find((item) => item.normalized === hint);
+            if (exact)
+                return exact.raw;
+            const contains = names.find((item) => item.normalized.includes(hint));
+            if (contains)
+                return contains.raw;
+        }
+        return undefined;
+    };
+    if (/\b(?:test|qa|coverage|verification|regression)\b/.test(normalizedWorkstream)) {
+        return findByHint(["qa_test_engineer", "qa", "tester", "verification"]);
+    }
+    if (/\b(?:ui|ux|design|layout|accessibility)\b/.test(normalizedWorkstream)) {
+        return findByHint(["uiux_top_senior", "uiux", "ui", "ux", "design"]);
+    }
+    if (/\b(?:architecture|codebase|refactor|security|rbac|auth|database|api)\b/.test(normalizedWorkstream)) {
+        return findByHint(["codebase_auditor", "architect", "security", "backend"]);
+    }
+    return undefined;
+}
+function buildAutoDelegationPrompt(input) {
+    const objective = truncateForDelegationContext(`${input.rootDescription}\n\n${input.rootPrompt}`);
+    return normalizeSpacing([
+        `Workstream ${input.ordinal}/${input.total}: ${input.streamTitle}`,
+        "Scope:",
+        `- Own this stream end-to-end and avoid duplicating sibling streams.`,
+        `- Produce concrete findings/changes for this stream only.`,
+        "Coordinator objective:",
+        objective,
+    ].join("\n"));
+}
+function synthesizeDelegationRequests(input) {
+    const desiredTotal = Math.max(0, Math.min(input.maxDelegations, input.minDelegationsPreferred));
+    const missing = Math.max(0, desiredTotal - input.currentDelegates);
+    if (missing <= 0)
+        return [];
+    const combined = `${input.description}\n${input.prompt}`.trim();
+    const extracted = extractDelegationWorkstreams(combined, Math.max(missing, desiredTotal));
+    const fallbackByIndex = [
+        "Architecture and structure analysis",
+        "Behavioral verification and tests",
+        "Risk, regressions, and remediation",
+        "Integration and dependency checks",
+        "Delivery summary and rollout constraints",
+    ];
+    const titles = [];
+    for (const stream of extracted) {
+        titles.push(stream);
+        if (titles.length >= missing)
+            break;
+    }
+    for (let index = 0; titles.length < missing && index < fallbackByIndex.length; index += 1) {
+        titles.push(fallbackByIndex[index]);
+    }
+    while (titles.length < missing) {
+        titles.push(`Independent workstream ${titles.length + 1}`);
+    }
+    const defaultProfile = deriveAutoDelegateProfile(input.baseProfile, input.description, input.prompt);
+    const synthesizedLockKey = writeCapableProfiles.has(defaultProfile) ? "auto-synth-write-lock" : undefined;
+    return titles.map((streamTitle, index) => ({
+        description: `Auto: ${streamTitle}`,
+        profile: defaultProfile,
+        agent: pickAutoDelegateAgent(streamTitle, input.availableCustomNames),
+        prompt: buildAutoDelegationPrompt({
+            streamTitle,
+            rootDescription: input.description,
+            rootPrompt: input.prompt,
+            ordinal: input.currentDelegates + index + 1,
+            total: input.currentDelegates + titles.length,
+        }),
+        cwd: undefined,
+        lockKey: synthesizedLockKey,
+        model: undefined,
+        isolation: undefined,
+        dependsOn: undefined,
+    }));
+}
+function withDelegationPrompt(basePrompt, depthRemaining, maxDelegations, minDelegationsPreferred = 0) {
+    const protocol = buildDelegationProtocolPrompt(depthRemaining, maxDelegations, minDelegationsPreferred);
     return `${basePrompt}\n\n${protocol}`;
 }
+function withSubagentInstructions(basePrompt, instructions) {
+    const trimmed = instructions?.trim();
+    return trimmed ? `${basePrompt}\n\n${trimmed}` : basePrompt;
+}
 function buildSharedMemoryGuidance(runId, taskId) {
     return [
         "[SHARED_MEMORY]",
@@ -277,7 +516,10 @@ function buildSharedMemoryGuidance(runId, taskId) {
         "Guidelines:",
         "- Use scope=run for cross-agent data and scope=task for task-local notes.",
         "- Keep entries compact and key-based (for example: findings/auth, plan/step-1, risks/session).",
+        "- Prefer one canonical key per stream and deduplicate updates; avoid redundant writes in loops.",
         "- Read before overwrite when collaborating on the same key.",
+        "- Use if_version CAS for contested updates on shared keys.",
+        "- Use mode=append only for log/timeline keys; use mode=set for canonical state.",
         "[/SHARED_MEMORY]",
     ].join("\n");
 }
@@ -295,19 +537,21 @@ function parseDelegationRequests(output, maxRequests) {
             return "";
         }
         const attrs = {};
-        for (const match of attrsRaw.matchAll(/([A-Za-z_][A-Za-z0-9_-]*)="([^"]*)"/g)) {
-            attrs[match[1].toLowerCase()] = match[2];
+        for (const match of attrsRaw.matchAll(/([A-Za-z_][A-Za-z0-9_-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) {
+            attrs[match[1].toLowerCase()] = (match[2] ?? match[3] ?? "").trim();
         }
         const prompt = normalizeSpacing(bodyRaw ?? "");
         if (!prompt) {
             warnings.push(`Ignored delegation block with empty prompt.`);
             return "";
         }
-        const profile = (attrs.profile ?? "explore").trim();
-        if (!(profile in toolsByProfile)) {
-            warnings.push(`Ignored delegation block with unknown profile "${profile}".`);
+        const profileRaw = (attrs.profile ?? "explore").trim();
+        if (!profileRaw) {
+            warnings.push(`Ignored delegation block with empty profile.`);
             return "";
         }
+        const normalizedProfile = profileRaw.toLowerCase();
+        const profile = isValidProfileName(normalizedProfile) ? normalizedProfile : profileRaw;
         const isolationRaw = (attrs.isolation ?? "").trim().toLowerCase();
         const isolation = isolationRaw === "worktree" ? "worktree" : isolationRaw === "none" ? "none" : undefined;
         if (isolationRaw && !isolation) {
@@ -338,6 +582,9 @@ function parseDelegationRequests(output, maxRequests) {
         cleanedOutput: normalizeSpacing(cleaned),
     };
 }
+function isBackgroundSafeToolset(tools) {
+    return tools.every((toolName) => !backgroundUnsafeTools.has(toolName));
+}
 function getCwdLockKey(cwd) {
     // Normalize lock key to keep behavior consistent across path aliases.
     return path.resolve(cwd).toLowerCase();
@@ -368,9 +615,9 @@ function getRunParallelLimit(cwd, runId) {
         return 1;
     const maxParallel = teamRun.maxParallel;
     if (!Number.isInteger(maxParallel) || !maxParallel || maxParallel < 1) {
-        return Math.max(1, Math.min(teamRun.agents, 20));
+        return Math.max(1, Math.min(teamRun.agents, MAX_ORCHESTRATION_AGENTS));
     }
-    return Math.max(1, Math.min(maxParallel, 20));
+    return Math.max(1, Math.min(maxParallel, MAX_ORCHESTRATION_PARALLEL));
 }
 function getOrCreateOrchestrationSemaphore(cwd, runId) {
     const limit = getRunParallelLimit(cwd, runId);
@@ -587,13 +834,13 @@ export function createTaskTool(cwd, runner, options) {
         label: "task",
         description: "Launch a specialized subagent to handle a subtask in isolation. " +
             "Use for: codebase exploration (profile=explore), architectural planning (profile=plan), " +
-            "IOSM artifact analysis (profile=iosm_analyst/iosm_verifier/cycle_planner), or end-to-end implementation (profile=full). " +
+            "IOSM artifact analysis (profile=iosm_analyst/iosm_verifier/cycle_planner), orchestration-first execution (profile=meta), or end-to-end implementation (profile=full). " +
             "Set cwd to isolate subagents into different project areas when orchestrating parallel work. " +
             "The subagent runs to completion and returns its full text output. " +
             "It may request bounded follow-up delegation via <delegate_task> blocks that are executed by the parent task tool." +
             customAgentsSnippet,
         parameters: taskSchema,
-        execute: async (_toolCallId, { description, prompt, agent: agentName, profile, cwd: targetCwd, lock_key: lockKey, run_id: orchestrationRunId, task_id: orchestrationTaskId, model: requestedModel, background, isolation, delegate_parallel_hint: delegateParallelHint, }, _signal, onUpdate) => {
+        execute: async (_toolCallId, { description: rawDescription, task: rawTask, args: rawArgs, prompt: rawPrompt, agent: agentName, profile, cwd: targetCwd, lock_key: lockKey, run_id: orchestrationRunId, task_id: orchestrationTaskId, model: requestedModel, background, isolation, delegate_parallel_hint: delegateParallelHint, }, _signal, onUpdate) => {
             const updateTrackedTaskStatus = (status) => {
                 if (!orchestrationRunId || !orchestrationTaskId)
                     return;
@@ -610,6 +857,12 @@ export function createTaskTool(cwd, runner, options) {
                     throw new Error("Operation aborted");
                 }
             };
+            const { description, prompt } = normalizeTaskPayload({
+                description: rawDescription,
+                task: rawTask,
+                args: rawArgs,
+                prompt: rawPrompt,
+            });
             const runId = `subagent_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
             const sharedMemoryRunId = orchestrationRunId?.trim() || runId;
             const sharedMemoryTaskId = orchestrationTaskId?.trim() || runId;
@@ -617,13 +870,26 @@ export function createTaskTool(cwd, runner, options) {
             const resolveCustom = (name) => {
                 if (!name || !options?.resolveCustomSubagent)
                     return undefined;
-                return options.resolveCustomSubagent(name);
+                const trimmed = name.trim();
+                if (!trimmed)
+                    return undefined;
+                const resolved = options.resolveCustomSubagent(trimmed);
+                if (resolved)
+                    return resolved;
+                const lowered = trimmed.toLowerCase();
+                if (lowered !== trimmed) {
+                    return options.resolveCustomSubagent(lowered);
+                }
+                return undefined;
             };
             let normalizedAgentName = agentName?.trim() || undefined;
-            let normalizedProfile = profile.trim().toLowerCase();
-            if (!normalizedProfile)
-                normalizedProfile = "full";
             let customSubagent = resolveCustom(normalizedAgentName);
+            const requestedProfileRaw = profile?.trim() || undefined;
+            const normalizedHostProfile = options?.getHostProfileName?.()?.trim().toLowerCase() ?? options?.hostProfileName?.trim().toLowerCase();
+            const hostProfileFallback = normalizedHostProfile && isValidProfileName(normalizedHostProfile) ? normalizedHostProfile : "full";
+            let normalizedProfile = requestedProfileRaw?.toLowerCase() ||
+                customSubagent?.profile?.trim().toLowerCase() ||
+                hostProfileFallback;
             if (normalizedAgentName && !customSubagent) {
                 const available = availableCustomNames.length > 0 ? ` Available custom agents: ${availableCustomNames.join(", ")}.` : "";
                 throw new Error(`Unknown subagent: ${normalizedAgentName}.${available}`);
@@ -637,37 +903,61 @@ export function createTaskTool(cwd, runner, options) {
                     normalizedProfile = (profileAsAgent.profile ?? "full").trim().toLowerCase();
                 }
             }
-            if (!toolsByProfile[normalizedProfile]) {
-                normalizedProfile = "full";
+            if (!customSubagent && !isValidProfileName(normalizedProfile)) {
+                throw new Error(`Unknown profile "${requestedProfileRaw ?? normalizedProfile}". Valid profiles: ${Object.keys(toolsByProfile).join(", ")}.`);
+            }
+            const effectiveProfileCandidate = (customSubagent?.profile ?? normalizedProfile).trim().toLowerCase();
+            if (!isValidProfileName(effectiveProfileCandidate)) {
+                throw new Error(`Invalid resolved profile "${effectiveProfileCandidate}". Valid profiles: ${Object.keys(toolsByProfile).join(", ")}.`);
             }
-            const effectiveProfile = customSubagent?.profile ?? normalizedProfile;
+            const effectiveProfile = effectiveProfileCandidate;
             let tools = customSubagent?.tools
                 ? [...customSubagent.tools]
-                : [...(toolsByProfile[effectiveProfile] ?? toolsByProfile.explore)];
+                : [...toolsByProfile[effectiveProfile]];
             if (customSubagent?.disallowedTools?.length) {
                 const blocked = new Set(customSubagent.disallowedTools);
                 tools = tools.filter((tool) => !blocked.has(tool));
             }
+            if (isReadOnlyProfileName(normalizedHostProfile) && tools.some((tool) => writeCapableTools.has(tool))) {
+                throw new Error(`Host profile "${normalizedHostProfile}" is read-only. Switch to full/meta/iosm to launch write-capable subtasks.`);
+            }
             const delegationDepth = maxDelegationDepthFromEnv;
             const requestedDelegateParallelHint = typeof delegateParallelHint === "number" && Number.isInteger(delegateParallelHint)
-                ? Math.max(1, Math.min(10, delegateParallelHint))
+                ? Math.max(1, Math.min(MAX_SUBAGENT_DELEGATE_PARALLEL, delegateParallelHint))
                 : undefined;
             const autoDelegateParallelHint = requestedDelegateParallelHint === undefined
-                ? deriveAutoDelegateParallelHint(normalizedAgentName, description, prompt)
+                ? deriveAutoDelegateParallelHint(effectiveProfile, normalizedAgentName, normalizedHostProfile, description, prompt)
                 : undefined;
-            const effectiveDelegateParallelHint = requestedDelegateParallelHint ?? autoDelegateParallelHint;
-            const effectiveMaxDelegations = Math.max(0, Math.min(maxDelegationsPerTaskFromEnv, effectiveDelegateParallelHint ?? maxDelegationsPerTaskFromEnv));
-            const effectiveMaxDelegateParallel = Math.max(1, Math.min(maxDelegatedParallelFromEnv, effectiveDelegateParallelHint ?? maxDelegatedParallelFromEnv));
+            let effectiveDelegateParallelHint = requestedDelegateParallelHint ?? autoDelegateParallelHint;
+            const effectiveDelegationDepth = effectiveProfile === "meta" || normalizedHostProfile === "meta" || normalizedAgentName?.toLowerCase().includes("orchestrator")
+                ? Math.max(delegationDepth, 2)
+                : delegationDepth;
+            const orchestratedRunContext = !!(orchestrationRunId && orchestrationTaskId);
+            const strictDelegationContract = effectiveProfile === "meta" ||
+                normalizedHostProfile === "meta" ||
+                normalizedAgentName?.toLowerCase().includes("orchestrator") ||
+                (orchestratedRunContext && (effectiveDelegateParallelHint ?? 0) >= 2);
+            let effectiveMaxDelegations = Math.max(0, Math.min(maxDelegationsPerTaskFromEnv, effectiveDelegateParallelHint ?? maxDelegationsPerTaskFromEnv));
+            let effectiveMaxDelegateParallel = Math.max(1, Math.min(maxDelegatedParallelFromEnv, effectiveDelegateParallelHint ?? maxDelegatedParallelFromEnv));
+            const isMetaDelegationContext = effectiveProfile === "meta" || normalizedHostProfile === "meta";
+            const preferredDelegationFloorBase = isMetaDelegationContext ? 3 : 2;
+            const preferredDelegationFloorMin = isMetaDelegationContext ? 2 : 1;
+            const metaDelegationCapacityFloor = 3;
+            const preferredDelegationFloor = Math.max(preferredDelegationFloorMin, Math.min(preferredDelegationFloorBase, effectiveDelegateParallelHint ?? preferredDelegationFloorBase));
+            const applyMetaDelegationFloor = requestedDelegateParallelHint === undefined &&
+                (effectiveProfile === "meta" || normalizedHostProfile === "meta");
+            if (applyMetaDelegationFloor) {
+                effectiveMaxDelegations = Math.max(effectiveMaxDelegations, Math.min(maxDelegationsPerTaskFromEnv, metaDelegationCapacityFloor));
+                effectiveMaxDelegateParallel = Math.max(effectiveMaxDelegateParallel, Math.min(maxDelegatedParallelFromEnv, preferredDelegationFloor));
+            }
             const minDelegationsPreferred = (effectiveDelegateParallelHint ?? 0) >= 2 && effectiveMaxDelegations >= 2
-                ? Math.min(2, effectiveMaxDelegations)
+                ? Math.min(preferredDelegationFloor, effectiveMaxDelegations, effectiveDelegateParallelHint ?? preferredDelegationFloor)
                 : 0;
-            const baseSystemPrompt = customSubagent?.systemPrompt ??
+            const baseSystemPrompt = withSubagentInstructions(customSubagent?.systemPrompt ??
                 systemPromptByProfile[effectiveProfile] ??
-                systemPromptByProfile.full;
-            const systemPrompt = withDelegationPrompt(baseSystemPrompt, delegationDepth, effectiveMaxDelegations);
-            const promptWithInstructions = customSubagent?.instructions && customSubagent.instructions.trim().length > 0
-                ? `${customSubagent.instructions.trim()}\n\nUser task:\n${prompt}`
-                : prompt;
+                systemPromptByProfile.full, customSubagent?.instructions);
+            const systemPrompt = withDelegationPrompt(baseSystemPrompt, effectiveDelegationDepth, effectiveMaxDelegations, minDelegationsPreferred);
+            const promptWithInstructions = prompt;
             const effectiveModelOverride = requestedModel?.trim() || customSubagent?.model?.trim() || undefined;
             const requestedBackground = background === true || customSubagent?.background === true;
             const trackedOrchestrationRun = orchestrationRunId && orchestrationTaskId ? getTeamRun(cwd, orchestrationRunId) : undefined;
@@ -680,8 +970,10 @@ export function createTaskTool(cwd, runner, options) {
             if (!existsSync(requestedSubagentCwd) || !statSync(requestedSubagentCwd).isDirectory()) {
                 throw new Error(`Subagent cwd does not exist or is not a directory: ${requestedSubagentCwd}`);
             }
-            if (runInBackground && writeCapableProfiles.has(effectiveProfile)) {
-                throw new Error(`Background policy violation: profile "${effectiveProfile}" is write-capable. Use explore/plan/iosm_analyst for background mode.`);
+            if (runInBackground && !isBackgroundSafeToolset(tools)) {
+                throw new Error(`Background policy violation: profile "${effectiveProfile}" has mutable tools (${tools
+                    .filter((toolName) => backgroundUnsafeTools.has(toolName))
+                    .join(", ")}). Background mode requires read-only toolsets. Safe baseline profiles: ${backgroundSafeProfiles.join(", ")}.`);
             }
             const useWorktree = isolation === "worktree";
             const queuedAt = Date.now();
@@ -737,6 +1029,42 @@ export function createTaskTool(cwd, runner, options) {
                 let subagentCwd = requestedSubagentCwd;
                 let worktreePath;
                 let runStats;
+                const heldWriteLocks = new Map();
+                const acquireLocalWriteLock = async (rawLockKey) => {
+                    const trimmed = rawLockKey?.trim();
+                    if (!trimmed)
+                        return undefined;
+                    const normalizedKey = getCwdLockKey(trimmed);
+                    const existing = heldWriteLocks.get(normalizedKey);
+                    if (existing) {
+                        existing.count += 1;
+                        return () => {
+                            const current = heldWriteLocks.get(normalizedKey);
+                            if (!current)
+                                return;
+                            current.count -= 1;
+                            if (current.count <= 0) {
+                                heldWriteLocks.delete(normalizedKey);
+                                current.release();
+                                cleanupWriteLock(trimmed);
+                            }
+                        };
+                    }
+                    const lock = getOrCreateWriteLock(trimmed);
+                    const release = await lock.acquire();
+                    heldWriteLocks.set(normalizedKey, { count: 1, release });
+                    return () => {
+                        const current = heldWriteLocks.get(normalizedKey);
+                        if (!current)
+                            return;
+                        current.count -= 1;
+                        if (current.count <= 0) {
+                            heldWriteLocks.delete(normalizedKey);
+                            current.release();
+                            cleanupWriteLock(trimmed);
+                        }
+                    };
+                };
                 try {
                     throwIfAborted();
                     if (orchestrationRunId && orchestrationTaskId) {
@@ -798,8 +1126,7 @@ export function createTaskTool(cwd, runner, options) {
                         // Parallel orchestration should remain truly parallel by default.
                         // Serialize write-capable agents only when an explicit lock_key is provided.
                         if (explicitRootLockKey) {
-                            const lock = getOrCreateWriteLock(explicitRootLockKey);
-                            releaseWriteLock = await lock.acquire();
+                            releaseWriteLock = await acquireLocalWriteLock(explicitRootLockKey);
                         }
                     }
                     if (useWorktree) {
@@ -850,6 +1177,7 @@ export function createTaskTool(cwd, runner, options) {
                                 try {
                                     const result = await runner({
                                         systemPrompt,
+                                        profileName: effectiveProfile,
                                         tools,
                                         prompt: promptForAttempt,
                                         cwd: subagentCwd,
@@ -942,7 +1270,7 @@ export function createTaskTool(cwd, runner, options) {
                         output = firstPass.output;
                         subagentSessionId = firstPass.sessionId;
                         runStats = firstPass.stats;
-                        let parsedDelegation = parseDelegationRequests(output, delegationDepth > 0 ? effectiveMaxDelegations : 0);
+                        let parsedDelegation = parseDelegationRequests(output, effectiveDelegationDepth > 0 ? effectiveMaxDelegations : 0);
                         if (minDelegationsPreferred > 0 && parsedDelegation.requests.length < minDelegationsPreferred) {
                             emitProgress({
                                 kind: "subagent_progress",
@@ -965,10 +1293,35 @@ export function createTaskTool(cwd, runner, options) {
                             output = secondPass.output;
                             subagentSessionId = secondPass.sessionId ?? subagentSessionId;
                             runStats = secondPass.stats ?? runStats;
-                            parsedDelegation = parseDelegationRequests(output, delegationDepth > 0 ? effectiveMaxDelegations : 0);
+                            parsedDelegation = parseDelegationRequests(output, effectiveDelegationDepth > 0 ? effectiveMaxDelegations : 0);
+                        }
+                        if (minDelegationsPreferred > 0 &&
+                            parsedDelegation.requests.length === 0 &&
+                            strictDelegationContract) {
+                            const impossibleMatch = output.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im);
+                            if (!impossibleMatch) {
+                                const synthesizedRequests = synthesizeDelegationRequests({
+                                    description,
+                                    prompt,
+                                    baseProfile: effectiveProfile,
+                                    currentDelegates: parsedDelegation.requests.length,
+                                    minDelegationsPreferred,
+                                    maxDelegations: effectiveMaxDelegations,
+                                    availableCustomNames,
+                                });
+                                if (synthesizedRequests.length > 0) {
+                                    parsedDelegation.requests.push(...synthesizedRequests);
+                                    delegationWarnings.push(`Delegation auto-fanout: synthesized ${synthesizedRequests.length} delegate(s) to satisfy parallelism contract.`);
+                                }
+                            }
                         }
                         if (minDelegationsPreferred > 0 && parsedDelegation.requests.length < minDelegationsPreferred) {
-                            const impossibleReason = output.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im)?.[1]?.trim() ?? "not provided";
+                            const impossibleMatch = output.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im);
+                            const impossibleReason = impossibleMatch?.[1]?.trim() ?? "not provided";
+                            if (strictDelegationContract && parsedDelegation.requests.length === 0 && !impossibleMatch) {
+                                throw new Error(`Delegation contract violated: expected >=${minDelegationsPreferred} delegates, got ${parsedDelegation.requests.length}. ` +
+                                    `Provide nested <delegate_task> fan-out or an explicit "DELEGATION_IMPOSSIBLE: <reason>" line.`);
+                            }
                             delegationWarnings.push(`Delegation fallback: kept single-agent execution (preferred >=${minDelegationsPreferred} delegates, got ${parsedDelegation.requests.length}). Reason: ${impossibleReason}.`);
                         }
                         output = parsedDelegation.cleanedOutput;
@@ -1037,19 +1390,241 @@ export function createTaskTool(cwd, runner, options) {
                                 delegateItems,
                             });
                         };
+                        const executeNestedDelegates = async (requests, parentCwd, depthRemaining, lineage) => {
+                            if (requests.length === 0 || depthRemaining <= 0) {
+                                return { sections: [], warnings: [] };
+                            }
+                            const nestedWarnings = [];
+                            const sectionsByIndex = new Array(requests.length);
+                            const statuses = Array.from({ length: requests.length }, () => "pending");
+                            const totalNested = requests.length;
+                            const normalizedDependsOn = requests.map((request, index) => {
+                                const current = index + 1;
+                                const raw = request.dependsOn ?? [];
+                                const unique = new Set();
+                                for (const dep of raw) {
+                                    if (!Number.isInteger(dep) || dep <= 0 || dep > totalNested || dep === current) {
+                                        nestedWarnings.push(`Nested delegated task ${lineage}${current} has invalid depends_on reference "${dep}" and it was ignored.`);
+                                        continue;
+                                    }
+                                    unique.add(dep);
+                                }
+                                return Array.from(unique).sort((a, b) => a - b);
+                            });
+                            const statusOf = (index) => statuses[index] ?? "pending";
+                            const markNestedFailed = (nestedIndex, requestLabel, nestedRequest, nestedProfileLabel, message, cause) => {
+                                statuses[nestedIndex] = "failed";
+                                recordFailureCause(cause);
+                                delegatedTasks += 1;
+                                delegatedFailed += 1;
+                                sectionsByIndex[nestedIndex] =
+                                    `###### ${requestLabel}. ${nestedRequest.description} (${nestedProfileLabel})\nERROR [cause=${cause}]: ${message}`;
+                            };
+                            const runNestedDelegate = async (nestedIndex) => {
+                                const nestedRequest = requests[nestedIndex];
+                                const requestLabel = `${lineage}${nestedIndex + 1}`;
+                                statuses[nestedIndex] = "running";
+                                let requestedNestedAgent = nestedRequest.agent?.trim() || undefined;
+                                let nestedCustomSubagent = resolveCustom(requestedNestedAgent);
+                                if (!nestedCustomSubagent && !requestedNestedAgent) {
+                                    const profileAsAgent = resolveCustom(nestedRequest.profile);
+                                    if (profileAsAgent) {
+                                        nestedCustomSubagent = profileAsAgent;
+                                        requestedNestedAgent = profileAsAgent.name;
+                                    }
+                                }
+                                if (requestedNestedAgent && !nestedCustomSubagent) {
+                                    nestedWarnings.push(`Nested delegated task "${nestedRequest.description}" requested unknown agent "${requestedNestedAgent}". Falling back to profile "${nestedRequest.profile}".`);
+                                }
+                                const nestedProfileCandidate = (nestedCustomSubagent?.profile ?? nestedRequest.profile).trim();
+                                const normalizedNestedProfile = nestedProfileCandidate.toLowerCase();
+                                if (!isValidProfileName(normalizedNestedProfile)) {
+                                    markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedProfileCandidate || "unknown", `nested delegate skipped: unknown profile "${nestedProfileCandidate || nestedRequest.profile}"`, "logic_error");
+                                    return;
+                                }
+                                const nestedProfile = normalizedNestedProfile;
+                                const nestedProfileLabel = nestedCustomSubagent?.name
+                                    ? `${nestedCustomSubagent.name}/${nestedProfile}`
+                                    : nestedProfile;
+                                let nestedTools = nestedCustomSubagent?.tools
+                                    ? [...nestedCustomSubagent.tools]
+                                    : [...toolsByProfile[nestedProfile]];
+                                if (nestedCustomSubagent?.disallowedTools?.length) {
+                                    const blocked = new Set(nestedCustomSubagent.disallowedTools);
+                                    nestedTools = nestedTools.filter((tool) => !blocked.has(tool));
+                                }
+                                const nestedBaseSystemPrompt = withSubagentInstructions(nestedCustomSubagent?.systemPrompt ??
+                                    systemPromptByProfile[nestedProfile] ??
+                                    systemPromptByProfile.full, nestedCustomSubagent?.instructions);
+                                const nestedSystemPrompt = withDelegationPrompt(nestedBaseSystemPrompt, Math.max(0, depthRemaining - 1), effectiveMaxDelegations);
+                                const requestedNestedCwd = nestedRequest.cwd
+                                    ? path.resolve(parentCwd, nestedRequest.cwd)
+                                    : nestedCustomSubagent?.cwd ?? parentCwd;
+                                if (!existsSync(requestedNestedCwd) || !statSync(requestedNestedCwd).isDirectory()) {
+                                    markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedProfileLabel, "nested delegate skipped: missing cwd", "dependency_env");
+                                    return;
+                                }
+                                let nestedReleaseLock;
+                                let nestedReleaseIsolation;
+                                let nestedCwd = requestedNestedCwd;
+                                try {
+                                    if (writeCapableProfiles.has(nestedProfile) && nestedRequest.lockKey?.trim()) {
+                                        nestedReleaseLock = await acquireLocalWriteLock(nestedRequest.lockKey.trim());
+                                    }
+                                    if (nestedRequest.isolation === "worktree") {
+                                        const isolated = provisionWorktree(cwd, requestedNestedCwd, `${runId}_nested_${requestLabel.replace(/\./g, "_")}`);
+                                        nestedCwd = isolated.runCwd;
+                                        nestedReleaseIsolation = isolated.cleanup;
+                                    }
+                                    const nestedPromptWithInstructions = nestedRequest.prompt;
+                                    const nestedSharedMemoryGuidance = buildSharedMemoryGuidance(sharedMemoryRunId, sharedMemoryTaskId);
+                                    const nestedPrompt = `${nestedPromptWithInstructions}\n\n${nestedSharedMemoryGuidance}`;
+                                    const nestedModelOverride = nestedRequest.model?.trim() || nestedCustomSubagent?.model?.trim() || undefined;
+                                    const nestedSharedMemoryContext = {
+                                        rootCwd: cwd,
+                                        runId: sharedMemoryRunId,
+                                        taskId: sharedMemoryTaskId,
+                                        delegateId: requestLabel,
+                                        profile: nestedProfile,
+                                    };
+                                    const nestedResult = await runner({
+                                        systemPrompt: nestedSystemPrompt,
+                                        profileName: nestedProfile,
+                                        tools: nestedTools,
+                                        prompt: nestedPrompt,
+                                        cwd: nestedCwd,
+                                        modelOverride: nestedModelOverride,
+                                        sharedMemoryContext: nestedSharedMemoryContext,
+                                        signal: _signal,
+                                        onProgress: (progress) => {
+                                            emitProgress({
+                                                kind: "subagent_progress",
+                                                phase: "running",
+                                                message: `delegate ${requestLabel}: ${progress.message}`,
+                                                cwd: progress.cwd ?? nestedCwd,
+                                                activeTool: progress.activeTool,
+                                            });
+                                        },
+                                    });
+                                    throwIfAborted();
+                                    let nestedOutput = typeof nestedResult === "string" ? nestedResult : nestedResult.output;
+                                    const nestedStats = typeof nestedResult === "string" ? undefined : nestedResult.stats;
+                                    delegatedTasks += 1;
+                                    delegatedSucceeded += 1;
+                                    statuses[nestedIndex] = "done";
+                                    delegatedStats.toolCallsStarted += nestedStats?.toolCallsStarted ?? 0;
+                                    delegatedStats.toolCallsCompleted += nestedStats?.toolCallsCompleted ?? 0;
+                                    delegatedStats.assistantMessages += nestedStats?.assistantMessages ?? 0;
+                                    const parsedNestedDelegation = parseDelegationRequests(nestedOutput, depthRemaining > 1 ? effectiveMaxDelegations : 0);
+                                    nestedOutput = parsedNestedDelegation.cleanedOutput;
+                                    nestedWarnings.push(...parsedNestedDelegation.warnings.map((warning) => `Nested child ${requestLabel}: ${warning}`));
+                                    let nestedSection = `###### ${requestLabel}. ${nestedRequest.description} (${nestedProfileLabel})\n${nestedOutput.trim() || "(no output)"}`;
+                                    if (parsedNestedDelegation.requests.length > 0 && depthRemaining > 1) {
+                                        const deeper = await executeNestedDelegates(parsedNestedDelegation.requests, nestedCwd, depthRemaining - 1, `${requestLabel}.`);
+                                        nestedWarnings.push(...deeper.warnings);
+                                        if (deeper.sections.length > 0) {
+                                            nestedSection = `${nestedSection}\n\n##### Nested Delegated Subtasks\n\n${deeper.sections.join("\n\n")}`;
+                                        }
+                                    }
+                                    sectionsByIndex[nestedIndex] = nestedSection;
+                                }
+                                catch (error) {
+                                    const message = error instanceof Error ? error.message : String(error);
+                                    const cause = classifyFailureCause(message);
+                                    markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedProfileLabel, message, cause);
+                                }
+                                finally {
+                                    nestedReleaseIsolation?.();
+                                    nestedReleaseLock?.();
+                                }
+                            };
+                            const pendingIndices = new Set(Array.from({ length: totalNested }, (_v, i) => i));
+                            const runningNested = new Map();
+                            const maxNestedParallel = Math.max(1, Math.min(totalNested, effectiveMaxDelegateParallel));
+                            const resolveBlockedByFailedDependencies = () => {
+                                let changed = false;
+                                for (const nestedIndex of Array.from(pendingIndices)) {
+                                    const deps = normalizedDependsOn[nestedIndex] ?? [];
+                                    if (deps.length === 0)
+                                        continue;
+                                    const failedDep = deps.find((dep) => statusOf(dep - 1) === "failed");
+                                    if (!failedDep)
+                                        continue;
+                                    pendingIndices.delete(nestedIndex);
+                                    const nestedRequest = requests[nestedIndex];
+                                    const requestLabel = `${lineage}${nestedIndex + 1}`;
+                                    markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedRequest.profile, `nested delegate skipped: dependency ${lineage}${failedDep} failed`, "logic_error");
+                                    changed = true;
+                                }
+                                return changed;
+                            };
+                            const launchReadyNested = () => {
+                                let launched = false;
+                                while (runningNested.size < maxNestedParallel) {
+                                    let nextIndex;
+                                    for (const nestedIndex of pendingIndices) {
+                                        const deps = normalizedDependsOn[nestedIndex] ?? [];
+                                        const allDone = deps.every((dep) => statusOf(dep - 1) === "done");
+                                        if (allDone) {
+                                            nextIndex = nestedIndex;
+                                            break;
+                                        }
+                                    }
+                                    if (nextIndex === undefined)
+                                        break;
+                                    pendingIndices.delete(nextIndex);
+                                    const promise = runNestedDelegate(nextIndex).finally(() => {
+                                        runningNested.delete(nextIndex);
+                                    });
+                                    runningNested.set(nextIndex, promise);
+                                    launched = true;
+                                }
+                                return launched;
+                            };
+                            while (pendingIndices.size > 0 || runningNested.size > 0) {
+                                throwIfAborted();
+                                const changed = resolveBlockedByFailedDependencies();
+                                const launched = launchReadyNested();
+                                if (runningNested.size === 0) {
+                                    if (pendingIndices.size > 0 && !changed && !launched) {
+                                        for (const nestedIndex of Array.from(pendingIndices)) {
+                                            pendingIndices.delete(nestedIndex);
+                                            const nestedRequest = requests[nestedIndex];
+                                            const deps = normalizedDependsOn[nestedIndex] ?? [];
+                                            const requestLabel = `${lineage}${nestedIndex + 1}`;
+                                            markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedRequest.profile, `nested delegate blocked: unresolved depends_on (${deps.join(", ") || "unknown"})`, "logic_error");
+                                        }
+                                    }
+                                    break;
+                                }
+                                await Promise.race(Array.from(runningNested.values()));
+                            }
+                            const sections = sectionsByIndex.filter((section) => typeof section === "string" && section.trim().length > 0);
+                            return { sections, warnings: nestedWarnings };
+                        };
                         const runDelegate = async (index) => {
                             throwIfAborted();
                             const request = parsedDelegation.requests[index];
-                            const requestedChildAgent = request.agent?.trim() || undefined;
-                            const childCustomSubagent = resolveCustom(requestedChildAgent);
+                            let requestedChildAgent = request.agent?.trim() || undefined;
+                            let childCustomSubagent = resolveCustom(requestedChildAgent);
+                            if (!childCustomSubagent && !requestedChildAgent) {
+                                const profileAsAgent = resolveCustom(request.profile);
+                                if (profileAsAgent) {
+                                    childCustomSubagent = profileAsAgent;
+                                    requestedChildAgent = profileAsAgent.name;
+                                }
+                            }
                             if (requestedChildAgent && !childCustomSubagent) {
                                 delegationWarnings.push(`Delegated task "${request.description}" requested unknown agent "${requestedChildAgent}". Falling back to profile "${request.profile}".`);
                             }
-                            const childProfileRaw = childCustomSubagent?.profile ?? request.profile;
-                            const normalizedChildProfile = childProfileRaw.trim().toLowerCase();
-                            const childProfile = normalizedChildProfile && toolsByProfile[normalizedChildProfile]
-                                ? normalizedChildProfile
-                                : "full";
+                            const childProfileRaw = (childCustomSubagent?.profile ?? request.profile).trim();
+                            const normalizedChildProfile = childProfileRaw.toLowerCase();
+                            if (!isValidProfileName(normalizedChildProfile)) {
+                                recordFailureCause("logic_error");
+                                markDelegateFailed(index, `delegate ${index + 1}/${delegateTotal} skipped: unknown profile "${childProfileRaw || request.profile}"`, `Delegated task "${request.description}" requested unknown profile "${childProfileRaw || request.profile}".`, "logic_error");
+                                return;
+                            }
+                            const childProfile = normalizedChildProfile;
                             const childProfileLabel = childCustomSubagent?.name
                                 ? `${childCustomSubagent.name}/${childProfile}`
                                 : childProfile;
@@ -1070,15 +1645,20 @@ export function createTaskTool(cwd, runner, options) {
                             });
                             let childTools = childCustomSubagent?.tools
                                 ? [...childCustomSubagent.tools]
-                                : [...(toolsByProfile[childProfile] ?? toolsByProfile.explore)];
+                                : [...toolsByProfile[childProfile]];
                             if (childCustomSubagent?.disallowedTools?.length) {
                                 const blocked = new Set(childCustomSubagent.disallowedTools);
                                 childTools = childTools.filter((tool) => !blocked.has(tool));
                             }
-                            const childBaseSystemPrompt = childCustomSubagent?.systemPrompt ??
+                            const childBaseSystemPrompt = withSubagentInstructions(childCustomSubagent?.systemPrompt ??
                                 systemPromptByProfile[childProfile] ??
-                                systemPromptByProfile.full;
-                            const childSystemPrompt = withDelegationPrompt(childBaseSystemPrompt, Math.max(0, delegationDepth - 1), effectiveMaxDelegations);
+                                systemPromptByProfile.full, childCustomSubagent?.instructions);
+                            const childAutoDelegateParallelHint = deriveAutoDelegateParallelHint(childProfile, requestedChildAgent, normalizedHostProfile, request.description, request.prompt);
+                            const childMinDelegationsPreferred = Math.max(0, effectiveDelegationDepth - 1) > 0 &&
+                                (childAutoDelegateParallelHint ?? 0) >= 2
+                                ? Math.min(preferredDelegationFloor, effectiveMaxDelegations, childAutoDelegateParallelHint ?? preferredDelegationFloor)
+                                : 0;
+                            const childSystemPrompt = withDelegationPrompt(childBaseSystemPrompt, Math.max(0, effectiveDelegationDepth - 1), effectiveMaxDelegations, childMinDelegationsPreferred);
                             const requestedChildCwd = request.cwd
                                 ? path.resolve(subagentCwd, request.cwd)
                                 : childCustomSubagent?.cwd ?? subagentCwd;
@@ -1094,8 +1674,7 @@ export function createTaskTool(cwd, runner, options) {
                             try {
                                 throwIfAborted();
                                 if (writeCapableProfiles.has(childProfile) && explicitChildLock) {
-                                    const lock = getOrCreateWriteLock(explicitChildLock);
-                                    childReleaseLock = await lock.acquire();
+                                    childReleaseLock = await acquireLocalWriteLock(explicitChildLock);
                                     throwIfAborted();
                                 }
                                 if (request.isolation === "worktree") {
@@ -1104,9 +1683,7 @@ export function createTaskTool(cwd, runner, options) {
                                     childReleaseIsolation = isolated.cleanup;
                                 }
                                 const delegateMeta = formatMetaCheckpoint(options?.getMetaMessages?.());
-                                const childPromptWithInstructions = childCustomSubagent?.instructions && childCustomSubagent.instructions.trim().length > 0
-                                    ? `${childCustomSubagent.instructions.trim()}\n\nUser task:\n${request.prompt}`
-                                    : request.prompt;
+                                const childPromptWithInstructions = request.prompt;
                                 const delegateSharedMemoryGuidance = buildSharedMemoryGuidance(sharedMemoryRunId, sharedMemoryTaskId);
                                 const delegatePromptBase = `${childPromptWithInstructions}\n\n${delegateSharedMemoryGuidance}`;
                                 const delegatePrompt = delegateMeta.section && delegateMeta.appliedCount > 0
@@ -1136,108 +1713,179 @@ export function createTaskTool(cwd, runner, options) {
                                 };
                                 let childOutput = "";
                                 let childStats;
-                                let childEmptyAttempt = 0;
-                                let childRetrospectiveAttempt = 0;
-                                let childPromptForAttempt = delegatePrompt;
-                                while (true) {
-                                    try {
-                                        const childResult = await runner({
-                                            systemPrompt: childSystemPrompt,
-                                            tools: childTools,
-                                            prompt: childPromptForAttempt,
-                                            cwd: childCwd,
-                                            modelOverride: childModelOverride,
-                                            sharedMemoryContext: childSharedMemoryContext,
-                                            signal: _signal,
-                                            onProgress: (progress) => {
-                                                emitProgress({
-                                                    kind: "subagent_progress",
-                                                    phase: "running",
-                                                    message: `delegate ${index + 1}/${delegateTotal}: ${progress.message}`,
-                                                    cwd: progress.cwd ?? childCwd,
-                                                    activeTool: progress.activeTool,
-                                                    delegateIndex: index + 1,
-                                                    delegateTotal,
-                                                    delegateDescription: request.description,
-                                                    delegateProfile: childProfileLabel,
-                                                    delegateItems,
-                                                });
-                                            },
-                                        });
-                                        throwIfAborted();
-                                        let attemptOutput;
-                                        let attemptStats;
-                                        if (typeof childResult === "string") {
-                                            attemptOutput = childResult;
-                                        }
-                                        else {
-                                            attemptOutput = childResult.output;
-                                            attemptStats = childResult.stats;
-                                        }
-                                        childStats = mergeRunStats(childStats, attemptStats);
-                                        if (attemptOutput.trim().length > 0) {
-                                            childOutput = attemptOutput;
-                                            if (childRetrospectiveAttempt > 0) {
-                                                retrospectiveRecovered += 1;
+                                const runChildPass = async (runPrompt) => {
+                                    let childEmptyAttempt = 0;
+                                    let childRetrospectiveAttempt = 0;
+                                    let childPromptForAttempt = runPrompt;
+                                    while (true) {
+                                        try {
+                                            const childResult = await runner({
+                                                systemPrompt: childSystemPrompt,
+                                                profileName: childProfile,
+                                                tools: childTools,
+                                                prompt: childPromptForAttempt,
+                                                cwd: childCwd,
+                                                modelOverride: childModelOverride,
+                                                sharedMemoryContext: childSharedMemoryContext,
+                                                signal: _signal,
+                                                onProgress: (progress) => {
+                                                    emitProgress({
+                                                        kind: "subagent_progress",
+                                                        phase: "running",
+                                                        message: `delegate ${index + 1}/${delegateTotal}: ${progress.message}`,
+                                                        cwd: progress.cwd ?? childCwd,
+                                                        activeTool: progress.activeTool,
+                                                        delegateIndex: index + 1,
+                                                        delegateTotal,
+                                                        delegateDescription: request.description,
+                                                        delegateProfile: childProfileLabel,
+                                                        delegateItems,
+                                                    });
+                                                },
+                                            });
+                                            throwIfAborted();
+                                            let attemptOutput;
+                                            let attemptStats;
+                                            if (typeof childResult === "string") {
+                                                attemptOutput = childResult;
                                             }
-                                            break;
+                                            else {
+                                                attemptOutput = childResult.output;
+                                                attemptStats = childResult.stats;
+                                            }
+                                            childStats = mergeRunStats(childStats, attemptStats);
+                                            if (attemptOutput.trim().length > 0) {
+                                                if (childRetrospectiveAttempt > 0) {
+                                                    retrospectiveRecovered += 1;
+                                                }
+                                                return attemptOutput;
+                                            }
+                                            if (childEmptyAttempt >= emptyOutputRetriesFromEnv) {
+                                                const totalAttempts = childEmptyAttempt + 1;
+                                                throw new Error(`delegate ${index + 1}/${delegateTotal} returned empty output after ${totalAttempts} attempt${totalAttempts === 1 ? "" : "s"}.`);
+                                            }
+                                            childEmptyAttempt += 1;
+                                            emitProgress({
+                                                kind: "subagent_progress",
+                                                phase: "running",
+                                                message: `delegate ${index + 1}/${delegateTotal}: empty output, retry ${childEmptyAttempt}/${emptyOutputRetriesFromEnv}`,
+                                                cwd: childCwd,
+                                                activeTool: undefined,
+                                                delegateIndex: index + 1,
+                                                delegateTotal,
+                                                delegateDescription: request.description,
+                                                delegateProfile: childProfileLabel,
+                                                delegateItems,
+                                            });
                                         }
-                                        if (childEmptyAttempt >= emptyOutputRetriesFromEnv) {
-                                            const totalAttempts = childEmptyAttempt + 1;
-                                            throw new Error(`delegate ${index + 1}/${delegateTotal} returned empty output after ${totalAttempts} attempt${totalAttempts === 1 ? "" : "s"}.`);
+                                        catch (error) {
+                                            if (_signal?.aborted || isAbortError(error)) {
+                                                throw new Error("Operation aborted");
+                                            }
+                                            const message = error instanceof Error ? error.message : String(error);
+                                            const cause = classifyFailureCause(message);
+                                            recordFailureCause(cause);
+                                            const canRetryRetrospective = childRetrospectiveAttempt < retrospectiveRetriesFromEnv &&
+                                                isRetrospectiveRetryable(cause);
+                                            if (!canRetryRetrospective) {
+                                                throw Object.assign(new Error(message), { failureCause: cause });
+                                            }
+                                            childRetrospectiveAttempt += 1;
+                                            retrospectiveAttempts += 1;
+                                            const directive = buildRetrospectiveDirective({
+                                                cause,
+                                                errorMessage: message,
+                                                attempt: childRetrospectiveAttempt,
+                                                target: "delegate",
+                                            });
+                                            childPromptForAttempt = `${runPrompt}\n\n${directive}`;
+                                            emitProgress({
+                                                kind: "subagent_progress",
+                                                phase: "running",
+                                                message: `delegate ${index + 1}/${delegateTotal}: retrospective retry ${childRetrospectiveAttempt}/${retrospectiveRetriesFromEnv} (${cause})`,
+                                                cwd: childCwd,
+                                                activeTool: undefined,
+                                                delegateIndex: index + 1,
+                                                delegateTotal,
+                                                delegateDescription: request.description,
+                                                delegateProfile: childProfileLabel,
+                                                delegateItems,
+                                            });
                                         }
-                                        childEmptyAttempt += 1;
-                                        emitProgress({
-                                            kind: "subagent_progress",
-                                            phase: "running",
-                                            message: `delegate ${index + 1}/${delegateTotal}: empty output, retry ${childEmptyAttempt}/${emptyOutputRetriesFromEnv}`,
-                                            cwd: childCwd,
-                                            activeTool: undefined,
-                                            delegateIndex: index + 1,
-                                            delegateTotal,
-                                            delegateDescription: request.description,
-                                            delegateProfile: childProfileLabel,
-                                            delegateItems,
-                                        });
                                     }
-                                    catch (error) {
-                                        if (_signal?.aborted || isAbortError(error)) {
-                                            throw new Error("Operation aborted");
-                                        }
-                                        const message = error instanceof Error ? error.message : String(error);
-                                        const cause = classifyFailureCause(message);
-                                        recordFailureCause(cause);
-                                        const canRetryRetrospective = childRetrospectiveAttempt < retrospectiveRetriesFromEnv &&
-                                            isRetrospectiveRetryable(cause);
-                                        if (!canRetryRetrospective) {
-                                            throw Object.assign(new Error(message), { failureCause: cause });
-                                        }
-                                        childRetrospectiveAttempt += 1;
-                                        retrospectiveAttempts += 1;
-                                        const directive = buildRetrospectiveDirective({
-                                            cause,
-                                            errorMessage: message,
-                                            attempt: childRetrospectiveAttempt,
-                                            target: "delegate",
-                                        });
-                                        childPromptForAttempt = `${delegatePrompt}\n\n${directive}`;
-                                        emitProgress({
-                                            kind: "subagent_progress",
-                                            phase: "running",
-                                            message: `delegate ${index + 1}/${delegateTotal}: retrospective retry ${childRetrospectiveAttempt}/${retrospectiveRetriesFromEnv} (${cause})`,
-                                            cwd: childCwd,
-                                            activeTool: undefined,
-                                            delegateIndex: index + 1,
-                                            delegateTotal,
-                                            delegateDescription: request.description,
-                                            delegateProfile: childProfileLabel,
-                                            delegateItems,
+                                };
+                                childOutput = await runChildPass(delegatePrompt);
+                                let parsedChildDelegation = parseDelegationRequests(childOutput, effectiveDelegationDepth > 1 ? effectiveMaxDelegations : 0);
+                                if (childMinDelegationsPreferred > 0 &&
+                                    parsedChildDelegation.requests.length < childMinDelegationsPreferred) {
+                                    emitProgress({
+                                        kind: "subagent_progress",
+                                        phase: "running",
+                                        message: `delegate ${index + 1}/${delegateTotal}: nested delegation preference unmet (${parsedChildDelegation.requests.length}/${childMinDelegationsPreferred}), retrying with stronger split guidance`,
+                                        cwd: childCwd,
+                                        activeTool: undefined,
+                                        delegateIndex: index + 1,
+                                        delegateTotal,
+                                        delegateDescription: request.description,
+                                        delegateProfile: childProfileLabel,
+                                        delegateItems,
+                                    });
+                                    const enforcedChildPrompt = [
+                                        delegatePrompt,
+                                        "",
+                                        "[DELEGATION_ENFORCEMENT]",
+                                        `This delegated workstream must emit at least ${childMinDelegationsPreferred} <delegate_task> blocks for independent sub-work when beneficial.`,
+                                        `Target parallel fan-out: up to ${Math.min(effectiveMaxDelegateParallel, effectiveMaxDelegations)}.`,
+                                        "For broad audits or implementations, split by subsystem / file cluster / verification stream instead of doing everything in one pass.",
+                                        "If safe decomposition is impossible, output exactly one line:",
+                                        "DELEGATION_IMPOSSIBLE: <reason>",
+                                        "[/DELEGATION_ENFORCEMENT]",
+                                    ].join("\n");
+                                    childOutput = await runChildPass(enforcedChildPrompt);
+                                    parsedChildDelegation = parseDelegationRequests(childOutput, effectiveDelegationDepth > 1 ? effectiveMaxDelegations : 0);
+                                }
+                                if (childMinDelegationsPreferred > 0 &&
+                                    parsedChildDelegation.requests.length === 0 &&
+                                    strictDelegationContract) {
+                                    const impossibleMatch = childOutput.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im);
+                                    if (!impossibleMatch) {
+                                        const synthesizedChildRequests = synthesizeDelegationRequests({
+                                            description: request.description,
+                                            prompt: request.prompt,
+                                            baseProfile: childProfile,
+                                            currentDelegates: parsedChildDelegation.requests.length,
+                                            minDelegationsPreferred: childMinDelegationsPreferred,
+                                            maxDelegations: effectiveMaxDelegations,
+                                            availableCustomNames,
                                         });
+                                        if (synthesizedChildRequests.length > 0) {
+                                            parsedChildDelegation.requests.push(...synthesizedChildRequests);
+                                            delegationWarnings.push(`Child ${index + 1}: delegation auto-fanout synthesized ${synthesizedChildRequests.length} nested delegate(s).`);
+                                        }
                                     }
                                 }
-                                const parsedChildDelegation = parseDelegationRequests(childOutput, 0);
+                                if (childMinDelegationsPreferred > 0 &&
+                                    parsedChildDelegation.requests.length < childMinDelegationsPreferred) {
+                                    const impossibleMatch = childOutput.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im);
+                                    const impossibleReason = impossibleMatch?.[1]?.trim() ?? "not provided";
+                                    if (strictDelegationContract &&
+                                        parsedChildDelegation.requests.length === 0 &&
+                                        !impossibleMatch) {
+                                        throw new Error(`Delegation contract violated for child ${index + 1}: expected >=${childMinDelegationsPreferred} nested delegates, got ${parsedChildDelegation.requests.length}. ` +
+                                            `Provide nested <delegate_task> fan-out or "DELEGATION_IMPOSSIBLE: <reason>".`);
+                                    }
+                                    delegationWarnings.push(`Child ${index + 1}: delegation fallback (preferred >=${childMinDelegationsPreferred}, got ${parsedChildDelegation.requests.length}). Reason: ${impossibleReason}.`);
+                                }
                                 childOutput = parsedChildDelegation.cleanedOutput;
                                 delegationWarnings.push(...parsedChildDelegation.warnings.map((warning) => `Child ${index + 1}: ${warning}`));
+                                let nestedSection = "";
+                                if (parsedChildDelegation.requests.length > 0 && effectiveDelegationDepth > 1) {
+                                    const nested = await executeNestedDelegates(parsedChildDelegation.requests, childCwd, effectiveDelegationDepth - 1, `${index + 1}.`);
+                                    delegationWarnings.push(...nested.warnings);
+                                    if (nested.sections.length > 0) {
+                                        nestedSection = `\n\n##### Nested Delegated Subtasks\n\n${nested.sections.join("\n\n")}`;
+                                    }
+                                }
                                 delegatedSucceeded += 1;
                                 if (delegateItems[index]) {
                                     delegateItems[index].status = "done";
@@ -1250,7 +1898,7 @@ export function createTaskTool(cwd, runner, options) {
                                     ? `${normalizedChildOutput.slice(0, Math.max(1, maxDelegatedOutputCharsFromEnv - 3))}...`
                                     : normalizedChildOutput;
                                 delegatedSections[index] =
-                                    `#### ${index + 1}. ${request.description} (${childProfileLabel})\n${childOutputExcerpt}`;
+                                    `#### ${index + 1}. ${request.description} (${childProfileLabel})\n${childOutputExcerpt}${nestedSection}`;
                                 emitProgress({
                                     kind: "subagent_progress",
                                     phase: "running",
@@ -1280,7 +1928,6 @@ export function createTaskTool(cwd, runner, options) {
                             finally {
                                 childReleaseIsolation?.();
                                 childReleaseLock?.();
-                                cleanupWriteLock(explicitChildLock);
                             }
                         };
                         const resolveBlockedByFailedDependencies = () => {
@@ -1505,7 +2152,6 @@ export function createTaskTool(cwd, runner, options) {
                 finally {
                     releaseIsolation?.();
                     releaseWriteLock?.();
-                    cleanupWriteLock(explicitRootLockKey);
                     releaseSlot?.();
                     releaseRunSlot?.();
                     if (orchestrationRunId) {