iosm-cli 0.2.4 → 0.2.6

package/dist/core/tools/task.js

@@ -5,6 +5,8 @@ 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";
+import { readSharedMemory, summarizeSharedMemoryUsage, writeSharedMemory, } from "../shared-memory.js";
 const taskSchema = Type.Object({
     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.",
@@ -22,7 +24,7 @@ const taskSchema = Type.Object({
         description: "Optional custom subagent name loaded from .iosm/agents or global agents directory.",
     })),
     profile: Type.Optional(Type.String({
-        description: "Optional subagent capability profile. Defaults to full when omitted. Recommended values: explore, plan, iosm, meta, iosm_analyst, iosm_verifier, cycle_planner, full. For custom agents, pass the agent name via `agent`, not `profile`.",
+        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.",
@@ -51,29 +53,26 @@ const taskSchema = Type.Object({
         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"],
-    meta: ["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. 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.",
+    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. For any metrics (speedup, compliance, conflict counts, quality scores), report only values backed by observed runtime evidence; if evidence is missing, mark the metric as unknown. Do not claim report files/artifacts unless they were produced in this run or verified on disk.",
     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", "meta", "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) {
@@ -132,7 +131,7 @@ class Mutex {
 }
 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, MAX_SUBAGENT_DELEGATION_DEPTH);
+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);
@@ -179,6 +178,9 @@ function deriveAutoDelegateParallelHint(profile, agentName, hostProfile, descrip
     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;
@@ -196,15 +198,32 @@ function deriveAutoDelegateParallelHint(profile, agentName, hostProfile, descrip
         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 ((isMetaProfile || isMetaHost) && score > 0) {
-        // Meta profile is intentionally parallel-biased for non-trivial work.
-        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;
@@ -320,6 +339,9 @@ function buildDelegationProtocolPrompt(depthRemaining, maxDelegations, minDelega
             `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 [
@@ -329,8 +351,270 @@ function buildDelegationProtocolPrompt(depthRemaining, maxDelegations, minDelega
         `</${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 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 stripDelegatedSectionHeading(section) {
+    return section.replace(/^####\s+[^\n]*\n?/i, "").trim();
+}
+function normalizeDelegatedSectionBody(section) {
+    return stripDelegatedSectionHeading(section)
+        .toLowerCase()
+        .replace(/[`"'*_#~[\](){}<>\\|]/g, " ")
+        .replace(/[^\w\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function detectDuplicateDelegatedSections(sections) {
+    const duplicatePairs = [];
+    const normalizedSections = sections.map((section) => normalizeDelegatedSectionBody(section));
+    for (let index = 0; index < normalizedSections.length; index += 1) {
+        const current = normalizedSections[index] ?? "";
+        if (current.length < 60)
+            continue;
+        for (let previous = 0; previous < index; previous += 1) {
+            const baseline = normalizedSections[previous] ?? "";
+            if (baseline.length < 60)
+                continue;
+            if (current === baseline) {
+                duplicatePairs.push({ duplicate: index + 1, original: previous + 1 });
+                break;
+            }
+            const shorter = current.length <= baseline.length ? current : baseline;
+            const longer = current.length > baseline.length ? current : baseline;
+            if (shorter.length >= 100 && longer.includes(shorter)) {
+                const coverage = shorter.length / Math.max(1, longer.length);
+                if (coverage >= 0.92) {
+                    duplicatePairs.push({ duplicate: index + 1, original: previous + 1 });
+                    break;
+                }
+            }
+        }
+    }
+    return {
+        duplicates: duplicatePairs.length,
+        duplicatePairs,
+    };
+}
+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 uniquifyWorkstreamTitles(titles) {
+    const counts = new Map();
+    return titles.map((title) => {
+        const key = title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, " ")
+            .trim();
+        const next = (counts.get(key) ?? 0) + 1;
+        counts.set(key, next);
+        if (next <= 1)
+            return title;
+        return `${title} (${next})`;
+    });
+}
+function semanticallyDeduplicateWorkstreamTitles(titles) {
+    const kept = [];
+    const tokenized = (value) => new Set(value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3));
+    const jaccard = (left, right) => {
+        if (left.size === 0 || right.size === 0)
+            return 0;
+        let intersection = 0;
+        for (const token of left) {
+            if (right.has(token))
+                intersection += 1;
+        }
+        const union = left.size + right.size - intersection;
+        return union > 0 ? intersection / union : 0;
+    };
+    for (const candidate of titles) {
+        const candidateTokens = tokenized(candidate);
+        const duplicate = kept.some((existing) => {
+            const existingTokens = tokenized(existing);
+            const similarity = jaccard(existingTokens, candidateTokens);
+            return similarity >= 0.82;
+        });
+        if (!duplicate) {
+            kept.push(candidate);
+        }
+    }
+    return kept;
+}
+function deriveAutoSynthLockKey(streamTitle, ordinal) {
+    const pathLike = streamTitle.match(/\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\b/)?.[0];
+    if (pathLike) {
+        const normalizedPath = pathLike
+            .replace(/^[./]+/, "")
+            .split("/")
+            .filter((segment) => segment.length > 0)
+            .slice(0, 2)
+            .join("/");
+        return `auto-synth:${toSharedMemoryKeySegment(normalizedPath, `stream-${ordinal}`)}`;
+    }
+    if (/\b(auth|rbac|acl|permission)\b/i.test(streamTitle))
+        return "auto-synth:auth";
+    if (/\b(db|database|sql|storage|schema)\b/i.test(streamTitle))
+        return "auto-synth:data";
+    if (/\b(ui|ux|frontend|view|component)\b/i.test(streamTitle))
+        return "auto-synth:ui";
+    if (/\b(test|qa|verification|coverage)\b/i.test(streamTitle))
+        return "auto-synth:test";
+    if (/\b(api|gateway|route|http)\b/i.test(streamTitle))
+        return "auto-synth:api";
+    return `auto-synth:${toSharedMemoryKeySegment(streamTitle, `stream-${ordinal}`)}`;
+}
+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 semanticallyDeduped = semanticallyDeduplicateWorkstreamTitles(titles);
+    while (semanticallyDeduped.length < missing) {
+        semanticallyDeduped.push(`Independent workstream ${semanticallyDeduped.length + 1}`);
+    }
+    const uniqueTitles = uniquifyWorkstreamTitles(semanticallyDeduped);
+    const defaultProfile = deriveAutoDelegateProfile(input.baseProfile, input.description, input.prompt);
+    return uniqueTitles.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 + uniqueTitles.length,
+        }),
+        cwd: undefined,
+        lockKey: writeCapableProfiles.has(defaultProfile) ? deriveAutoSynthLockKey(streamTitle, index + 1) : undefined,
+        model: undefined,
+        isolation: undefined,
+        dependsOn: undefined,
+    }));
+}
 function withDelegationPrompt(basePrompt, depthRemaining, maxDelegations, minDelegationsPreferred = 0) {
     const protocol = buildDelegationProtocolPrompt(depthRemaining, maxDelegations, minDelegationsPreferred);
     return `${basePrompt}\n\n${protocol}`;
@@ -348,10 +632,78 @@ 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");
 }
+function toSharedMemoryKeySegment(raw, fallback) {
+    const normalized = (raw ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized)
+        return fallback;
+    return normalized.slice(0, 64);
+}
+function buildTaskPlanSharedMemoryKey(taskId) {
+    return `plan/${toSharedMemoryKeySegment(taskId, "task")}`;
+}
+function buildDelegateFindingSharedMemoryKey(taskId, delegateLabel) {
+    return `findings/${toSharedMemoryKeySegment(taskId, "task")}/${toSharedMemoryKeySegment(delegateLabel, "stream")}`;
+}
+function extractClaimCandidates(text, maxItems = 3) {
+    const matches = text.match(/\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\b/g) ?? [];
+    const normalized = new Set();
+    for (const match of matches) {
+        const cleaned = match
+            .replace(/^[./]+/, "")
+            .replace(/\/+/g, "/")
+            .trim();
+        if (!cleaned)
+            continue;
+        normalized.add(cleaned);
+        if (normalized.size >= maxItems)
+            break;
+    }
+    return Array.from(normalized);
+}
+function buildClaimKey(pathLike) {
+    const segments = pathLike
+        .split("/")
+        .map((segment) => toSharedMemoryKeySegment(segment, "segment"))
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return "claims/unknown";
+    }
+    return `claims/${segments.slice(0, 6).join("/")}`;
+}
+function buildDelegateCoordinationGuidance(input) {
+    const planKey = buildTaskPlanSharedMemoryKey(input.taskId);
+    const findingKey = buildDelegateFindingSharedMemoryKey(input.taskId, input.delegateLabel);
+    return [
+        "[DELEGATE_COORDINATION]",
+        `delegate_label: ${input.delegateLabel}`,
+        `delegate_description: ${input.delegateDescription}`,
+        `read_first_key: ${planKey}`,
+        `publish_key: ${findingKey}`,
+        "Before heavy repository reads, check current coordination state via shared_memory_read.",
+        "Use claims/<path> run-scoped keys with CAS (if_version) to announce file ownership and reduce duplicate reads.",
+        "Before responding, publish concise stream findings via shared_memory_write.",
+        "Keep ownership strict: do not duplicate sibling streams.",
+        "[/DELEGATE_COORDINATION]",
+    ].join("\n");
+}
+function createSharedMemoryExcerpt(value, maxChars = 1200) {
+    const normalized = normalizeSpacing(value);
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, Math.max(120, maxChars - 3)).trimEnd()}...`;
+}
 function parseDelegationRequests(output, maxRequests) {
     const requests = [];
     const warnings = [];
@@ -366,19 +718,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) {
@@ -409,6 +763,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();
@@ -694,12 +1051,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 customSubagent = resolveCustom(normalizedAgentName);
-            let normalizedProfile = profile?.trim().toLowerCase() || customSubagent?.profile?.trim().toLowerCase() || "full";
+            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}`);
@@ -713,17 +1084,24 @@ 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 effectiveProfile = customSubagent?.profile ?? normalizedProfile;
+            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 = 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(MAX_SUBAGENT_DELEGATE_PARALLEL, delegateParallelHint))
@@ -735,13 +1113,22 @@ export function createTaskTool(cwd, runner, options) {
             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 preferredDelegationFloor = effectiveProfile === "meta" || normalizedHostProfile === "meta" ? 3 : 2;
+            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, preferredDelegationFloor));
+                effectiveMaxDelegations = Math.max(effectiveMaxDelegations, Math.min(maxDelegationsPerTaskFromEnv, metaDelegationCapacityFloor));
                 effectiveMaxDelegateParallel = Math.max(effectiveMaxDelegateParallel, Math.min(maxDelegatedParallelFromEnv, preferredDelegationFloor));
             }
             const minDelegationsPreferred = (effectiveDelegateParallelHint ?? 0) >= 2 && effectiveMaxDelegations >= 2
@@ -764,8 +1151,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();
@@ -821,6 +1210,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) {
@@ -882,8 +1307,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) {
@@ -923,6 +1347,131 @@ export function createTaskTool(cwd, runner, options) {
                         taskId: sharedMemoryTaskId,
                         profile: effectiveProfile,
                     };
+                    const publishTaskCoordinationPlan = async () => {
+                        const key = buildTaskPlanSharedMemoryKey(sharedMemoryTaskId);
+                        const payload = JSON.stringify({
+                            taskId: sharedMemoryTaskId,
+                            description,
+                            profile: effectiveProfile,
+                            objective: createSharedMemoryExcerpt(prompt, 900),
+                        });
+                        try {
+                            await writeSharedMemory(rootSharedMemoryContext, {
+                                key,
+                                value: payload,
+                                scope: "run",
+                                mode: "set",
+                            }, _signal);
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            delegationWarnings.push(`Shared memory plan publish skipped: ${message}`);
+                        }
+                    };
+                    const publishDelegateFinding = async (input) => {
+                        const key = buildDelegateFindingSharedMemoryKey(sharedMemoryTaskId, input.delegateLabel);
+                        const payload = JSON.stringify({
+                            taskId: sharedMemoryTaskId,
+                            delegate: input.delegateLabel,
+                            description: input.delegateDescription,
+                            profile: input.delegateProfile,
+                            status: input.status,
+                            summary: createSharedMemoryExcerpt(input.content, 1000),
+                        });
+                        try {
+                            await writeSharedMemory({
+                                rootCwd: cwd,
+                                runId: sharedMemoryRunId,
+                                taskId: sharedMemoryTaskId,
+                                delegateId: input.delegateLabel,
+                                profile: input.delegateProfile,
+                            }, {
+                                key,
+                                value: payload,
+                                scope: "run",
+                                mode: "set",
+                            }, _signal);
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            delegationWarnings.push(`Shared memory finding publish skipped for delegate ${input.delegateLabel}: ${message}`);
+                        }
+                    };
+                    const publishStreamClaims = async (input) => {
+                        const claimPaths = extractClaimCandidates(`${input.description}\n${input.promptText}`, 3);
+                        if (claimPaths.length === 0)
+                            return;
+                        for (const claimPath of claimPaths) {
+                            const key = buildClaimKey(claimPath);
+                            let lastError;
+                            for (let attempt = 0; attempt < 2; attempt += 1) {
+                                try {
+                                    const snapshot = await readSharedMemory(rootSharedMemoryContext, {
+                                        scope: "run",
+                                        key,
+                                        includeValues: true,
+                                    }, _signal);
+                                    const current = snapshot.items[0];
+                                    if (!current) {
+                                        await writeSharedMemory(rootSharedMemoryContext, {
+                                            key,
+                                            value: JSON.stringify({
+                                                path: claimPath,
+                                                owners: [input.owner],
+                                                updatedAt: new Date().toISOString(),
+                                            }),
+                                            scope: "run",
+                                            mode: "set",
+                                        }, _signal);
+                                        lastError = undefined;
+                                        break;
+                                    }
+                                    let existingOwners = [];
+                                    if (current.value) {
+                                        try {
+                                            const parsed = JSON.parse(current.value);
+                                            if (Array.isArray(parsed.owners)) {
+                                                existingOwners = parsed.owners
+                                                    .filter((value) => typeof value === "string" && value.trim().length > 0)
+                                                    .slice(0, 12);
+                                            }
+                                        }
+                                        catch {
+                                            // tolerate malformed payload and overwrite with normalized shape
+                                        }
+                                    }
+                                    if (existingOwners.includes(input.owner)) {
+                                        lastError = undefined;
+                                        break;
+                                    }
+                                    const nextOwners = [...existingOwners, input.owner].slice(0, 12);
+                                    await writeSharedMemory(rootSharedMemoryContext, {
+                                        key,
+                                        value: JSON.stringify({
+                                            path: claimPath,
+                                            owners: nextOwners,
+                                            updatedAt: new Date().toISOString(),
+                                        }),
+                                        scope: "run",
+                                        mode: "set",
+                                        ifVersion: current.version,
+                                    }, _signal);
+                                    lastError = undefined;
+                                    break;
+                                }
+                                catch (error) {
+                                    const message = error instanceof Error ? error.message : String(error);
+                                    lastError = message;
+                                    if (!/version mismatch/i.test(message)) {
+                                        break;
+                                    }
+                                }
+                            }
+                            if (lastError) {
+                                delegationWarnings.push(`Shared memory claim publish skipped (${key}) for ${input.owner}: ${lastError}`);
+                            }
+                        }
+                    };
                     try {
                         const runRootPass = async (runPrompt) => {
                             let emptyAttempt = 0;
@@ -1023,6 +1572,12 @@ export function createTaskTool(cwd, runner, options) {
                                 activeTool: undefined,
                             });
                         }
+                        await publishTaskCoordinationPlan();
+                        await publishStreamClaims({
+                            owner: "root",
+                            description,
+                            promptText: prompt,
+                        });
                         const firstPass = await runRootPass(rootPrompt);
                         output = firstPass.output;
                         subagentSessionId = firstPass.sessionId;
@@ -1052,8 +1607,33 @@ export function createTaskTool(cwd, runner, options) {
                             runStats = secondPass.stats ?? runStats;
                             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;
@@ -1109,6 +1689,13 @@ export function createTaskTool(cwd, runner, options) {
                             }
                             const causeLabel = cause ? ` [cause=${cause}]` : "";
                             delegatedSections[index] = `#### ${index + 1}. ${request.description} (${formatDelegateTarget(request)})\nERROR${causeLabel}: ${message}`;
+                            void publishDelegateFinding({
+                                delegateLabel: String(index + 1),
+                                delegateDescription: request.description,
+                                delegateProfile: formatDelegateTarget(request),
+                                status: "failed",
+                                content: message,
+                            });
                             emitProgress({
                                 kind: "subagent_progress",
                                 phase: "running",
@@ -1127,25 +1714,67 @@ export function createTaskTool(cwd, runner, options) {
                                 return { sections: [], warnings: [] };
                             }
                             const nestedWarnings = [];
-                            const sections = [];
-                            for (const [nestedIndex, nestedRequest] of requests.entries()) {
+                            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}`;
+                                void publishDelegateFinding({
+                                    delegateLabel: requestLabel,
+                                    delegateDescription: nestedRequest.description,
+                                    delegateProfile: nestedProfileLabel,
+                                    status: "failed",
+                                    content: message,
+                                });
+                            };
+                            const runNestedDelegate = async (nestedIndex) => {
+                                const nestedRequest = requests[nestedIndex];
                                 const requestLabel = `${lineage}${nestedIndex + 1}`;
-                                const requestedNestedAgent = nestedRequest.agent?.trim() || undefined;
-                                const nestedCustomSubagent = resolveCustom(requestedNestedAgent);
+                                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 nestedProfileRaw = nestedCustomSubagent?.profile ?? nestedRequest.profile;
-                                const normalizedNestedProfile = nestedProfileRaw.trim().toLowerCase();
-                                const nestedProfile = normalizedNestedProfile && toolsByProfile[normalizedNestedProfile]
-                                    ? normalizedNestedProfile
-                                    : "full";
+                                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] ?? toolsByProfile.explore)];
+                                    : [...toolsByProfile[nestedProfile]];
                                 if (nestedCustomSubagent?.disallowedTools?.length) {
                                     const blocked = new Set(nestedCustomSubagent.disallowedTools);
                                     nestedTools = nestedTools.filter((tool) => !blocked.has(tool));
@@ -1158,19 +1787,15 @@ export function createTaskTool(cwd, runner, options) {
                                     ? path.resolve(parentCwd, nestedRequest.cwd)
                                     : nestedCustomSubagent?.cwd ?? parentCwd;
                                 if (!existsSync(requestedNestedCwd) || !statSync(requestedNestedCwd).isDirectory()) {
-                                    recordFailureCause("dependency_env");
-                                    delegatedFailed += 1;
-                                    delegatedTasks += 1;
-                                    sections.push(`###### ${requestLabel}. ${nestedRequest.description} (${nestedProfileLabel})\nERROR [cause=dependency_env]: nested delegate skipped: missing cwd`);
-                                    continue;
+                                    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()) {
-                                        const lock = getOrCreateWriteLock(nestedRequest.lockKey.trim());
-                                        nestedReleaseLock = await lock.acquire();
+                                        nestedReleaseLock = await acquireLocalWriteLock(nestedRequest.lockKey.trim());
                                     }
                                     if (nestedRequest.isolation === "worktree") {
                                         const isolated = provisionWorktree(cwd, requestedNestedCwd, `${runId}_nested_${requestLabel.replace(/\./g, "_")}`);
@@ -1179,7 +1804,17 @@ export function createTaskTool(cwd, runner, options) {
                                     }
                                     const nestedPromptWithInstructions = nestedRequest.prompt;
                                     const nestedSharedMemoryGuidance = buildSharedMemoryGuidance(sharedMemoryRunId, sharedMemoryTaskId);
-                                    const nestedPrompt = `${nestedPromptWithInstructions}\n\n${nestedSharedMemoryGuidance}`;
+                                    const nestedCoordinationGuidance = buildDelegateCoordinationGuidance({
+                                        taskId: sharedMemoryTaskId,
+                                        delegateLabel: requestLabel,
+                                        delegateDescription: nestedRequest.description,
+                                    });
+                                    const nestedPrompt = `${nestedPromptWithInstructions}\n\n${nestedSharedMemoryGuidance}\n\n${nestedCoordinationGuidance}`;
+                                    await publishStreamClaims({
+                                        owner: requestLabel,
+                                        description: nestedRequest.description,
+                                        promptText: nestedRequest.prompt,
+                                    });
                                     const nestedModelOverride = nestedRequest.model?.trim() || nestedCustomSubagent?.model?.trim() || undefined;
                                     const nestedSharedMemoryContext = {
                                         rootCwd: cwd,
@@ -1212,6 +1847,7 @@ export function createTaskTool(cwd, runner, options) {
                                     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;
@@ -1226,37 +1862,112 @@ export function createTaskTool(cwd, runner, options) {
                                             nestedSection = `${nestedSection}\n\n##### Nested Delegated Subtasks\n\n${deeper.sections.join("\n\n")}`;
                                         }
                                     }
-                                    sections.push(nestedSection);
+                                    await publishDelegateFinding({
+                                        delegateLabel: requestLabel,
+                                        delegateDescription: nestedRequest.description,
+                                        delegateProfile: nestedProfileLabel,
+                                        status: "done",
+                                        content: nestedSection,
+                                    });
+                                    sectionsByIndex[nestedIndex] = nestedSection;
                                 }
                                 catch (error) {
                                     const message = error instanceof Error ? error.message : String(error);
                                     const cause = classifyFailureCause(message);
-                                    recordFailureCause(cause);
-                                    delegatedTasks += 1;
-                                    delegatedFailed += 1;
-                                    sections.push(`###### ${requestLabel}. ${nestedRequest.description} (${nestedProfileLabel})\nERROR [cause=${cause}]: ${message}`);
+                                    markNestedFailed(nestedIndex, requestLabel, nestedRequest, nestedProfileLabel, message, cause);
                                 }
                                 finally {
                                     nestedReleaseIsolation?.();
                                     nestedReleaseLock?.();
-                                    cleanupWriteLock(nestedRequest.lockKey?.trim());
                                 }
+                            };
+                            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;
@@ -1277,7 +1988,7 @@ 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));
@@ -1306,8 +2017,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") {
@@ -1318,7 +2028,12 @@ export function createTaskTool(cwd, runner, options) {
                                 const delegateMeta = formatMetaCheckpoint(options?.getMetaMessages?.());
                                 const childPromptWithInstructions = request.prompt;
                                 const delegateSharedMemoryGuidance = buildSharedMemoryGuidance(sharedMemoryRunId, sharedMemoryTaskId);
-                                const delegatePromptBase = `${childPromptWithInstructions}\n\n${delegateSharedMemoryGuidance}`;
+                                const delegateCoordinationGuidance = buildDelegateCoordinationGuidance({
+                                    taskId: sharedMemoryTaskId,
+                                    delegateLabel: String(index + 1),
+                                    delegateDescription: request.description,
+                                });
+                                const delegatePromptBase = `${childPromptWithInstructions}\n\n${delegateSharedMemoryGuidance}\n\n${delegateCoordinationGuidance}`;
                                 const delegatePrompt = delegateMeta.section && delegateMeta.appliedCount > 0
                                     ? `${delegatePromptBase}\n\n${delegateMeta.section}`
                                     : delegatePromptBase;
@@ -1336,6 +2051,11 @@ export function createTaskTool(cwd, runner, options) {
                                         delegateItems,
                                     });
                                 }
+                                await publishStreamClaims({
+                                    owner: String(index + 1),
+                                    description: request.description,
+                                    promptText: request.prompt,
+                                });
                                 const childModelOverride = request.model?.trim() || childCustomSubagent?.model?.trim() || undefined;
                                 const childSharedMemoryContext = {
                                     rootCwd: cwd,
@@ -1477,10 +2197,36 @@ export function createTaskTool(cwd, runner, options) {
                                     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).`);
+                                        }
+                                    }
+                                }
                                 if (childMinDelegationsPreferred > 0 &&
                                     parsedChildDelegation.requests.length < childMinDelegationsPreferred) {
-                                    const impossibleReason = childOutput.match(/^\s*DELEGATION_IMPOSSIBLE\s*:\s*(.+)$/im)?.[1]?.trim() ??
-                                        "not provided";
+                                    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;
@@ -1506,6 +2252,13 @@ export function createTaskTool(cwd, runner, options) {
                                     : normalizedChildOutput;
                                 delegatedSections[index] =
                                     `#### ${index + 1}. ${request.description} (${childProfileLabel})\n${childOutputExcerpt}${nestedSection}`;
+                                await publishDelegateFinding({
+                                    delegateLabel: String(index + 1),
+                                    delegateDescription: request.description,
+                                    delegateProfile: childProfileLabel,
+                                    status: "done",
+                                    content: `${childOutputExcerpt}${nestedSection}`,
+                                });
                                 emitProgress({
                                     kind: "subagent_progress",
                                     phase: "running",
@@ -1535,7 +2288,6 @@ export function createTaskTool(cwd, runner, options) {
                             finally {
                                 childReleaseIsolation?.();
                                 childReleaseLock?.();
-                                cleanupWriteLock(explicitChildLock);
                             }
                         };
                         const resolveBlockedByFailedDependencies = () => {
@@ -1667,11 +2419,205 @@ export function createTaskTool(cwd, runner, options) {
                     }
                     const normalizedOutput = output.trim().length > 0 ? output.trim() : "(Subagent completed with no output)";
                     const finalSections = [normalizedOutput];
+                    const delegatedBlocks = delegatedSections.filter((section) => typeof section === "string" && section.trim().length > 0);
+                    let duplicateDelegatedOutputs = 0;
                     if (delegatedTasks > 0) {
                         const header = `### Delegated Subtasks (${delegatedSucceeded}/${delegatedTasks} done)`;
-                        const delegatedBlocks = delegatedSections.filter((section) => typeof section === "string" && section.trim().length > 0);
+                        if (delegatedBlocks.length > 1) {
+                            const duplicateReport = detectDuplicateDelegatedSections(delegatedBlocks);
+                            duplicateDelegatedOutputs = duplicateReport.duplicates;
+                            if (duplicateReport.duplicates > 0) {
+                                const duplicateHints = duplicateReport.duplicatePairs
+                                    .slice(0, 5)
+                                    .map((pair) => `${pair.duplicate}->${pair.original}`)
+                                    .join(", ");
+                                delegationWarnings.push(`Delegation quality: detected ${duplicateReport.duplicates} near-duplicate delegated output(s) (${duplicateHints}). Consider stricter stream partitioning or stronger shared-memory coordination keys.`);
+                            }
+                        }
                         finalSections.push([header, ...delegatedBlocks].join("\n\n"));
                     }
+                    let sharedMemorySummaryKey;
+                    if (orchestrationRunId && orchestrationTaskId) {
+                        const summaryExcerpt = normalizedOutput.length > 1200
+                            ? `${normalizedOutput.slice(0, 1197).trimEnd()}...`
+                            : normalizedOutput;
+                        const summaryPayload = JSON.stringify({
+                            taskId: orchestrationTaskId,
+                            description,
+                            profile: effectiveProfile,
+                            delegated: {
+                                total: delegatedTasks,
+                                succeeded: delegatedSucceeded,
+                                failed: delegatedFailed,
+                                duplicatesDetected: duplicateDelegatedOutputs,
+                            },
+                            retrospective: {
+                                attempts: retrospectiveAttempts,
+                                recovered: retrospectiveRecovered,
+                                failureCauses: failureCauses,
+                            },
+                            summary: summaryExcerpt,
+                        });
+                        try {
+                            const summaryWrite = await writeSharedMemory({
+                                rootCwd: cwd,
+                                runId: sharedMemoryRunId,
+                                taskId: sharedMemoryTaskId,
+                                profile: effectiveProfile,
+                            }, {
+                                key: `results/${orchestrationTaskId}`,
+                                value: summaryPayload,
+                                scope: "run",
+                                mode: "set",
+                            }, _signal);
+                            sharedMemorySummaryKey = summaryWrite.key;
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            delegationWarnings.push(`Shared memory summary write skipped: ${message}`);
+                        }
+                    }
+                    let coordinationSummary;
+                    let claimSummary;
+                    let sharedFindingsSnapshot;
+                    if (delegatedTasks > 0 || (orchestrationRunId && orchestrationTaskId)) {
+                        try {
+                            const usage = await summarizeSharedMemoryUsage({
+                                rootCwd: cwd,
+                                runId: sharedMemoryRunId,
+                                taskId: sharedMemoryTaskId,
+                            }, _signal);
+                            if (delegatedTasks > 1 && usage.currentTaskDelegateWrites === 0) {
+                                delegationWarnings.push("No shared_memory writes detected from delegates in this task. Cross-stream coordination may be weak; use stable keys (findings/<stream>, risks/<stream>, plan/<stream>).");
+                            }
+                            coordinationSummary = {
+                                sharedMemoryWrites: usage.totalWrites,
+                                currentTaskWrites: usage.currentTaskWrites,
+                                currentTaskDelegateWrites: usage.currentTaskDelegateWrites,
+                                runScopeWrites: usage.runScopeWrites,
+                                taskScopeWrites: usage.taskScopeWrites,
+                                duplicatesDetected: duplicateDelegatedOutputs,
+                                claimKeysMatched: 0,
+                                claimCollisions: 0,
+                            };
+                        }
+                        catch {
+                            // shared-memory summary is advisory; never fail task completion on analytics path.
+                        }
+                    }
+                    if (delegatedTasks > 0) {
+                        try {
+                            const claims = await readSharedMemory({
+                                rootCwd: cwd,
+                                runId: sharedMemoryRunId,
+                                taskId: sharedMemoryTaskId,
+                            }, {
+                                scope: "run",
+                                prefix: "claims/",
+                                includeValues: true,
+                                limit: Math.max(40, delegatedTasks * 8),
+                            }, _signal);
+                            const collisions = [];
+                            for (const item of claims.items) {
+                                if (!item.value)
+                                    continue;
+                                try {
+                                    const parsed = JSON.parse(item.value);
+                                    if (!Array.isArray(parsed.owners))
+                                        continue;
+                                    const owners = Array.from(new Set(parsed.owners
+                                        .filter((value) => typeof value === "string" && value.trim().length > 0)
+                                        .map((value) => value.trim())));
+                                    if (owners.length > 1) {
+                                        collisions.push({ key: item.key, owners: owners.slice(0, 8) });
+                                    }
+                                }
+                                catch {
+                                    // ignore malformed claim entries and continue best-effort aggregation
+                                }
+                            }
+                            claimSummary = {
+                                keysMatched: claims.totalMatched,
+                                collisions: collisions.length,
+                                examples: collisions.slice(0, 6).map((item) => `${item.key}: ${item.owners.join(", ")}`),
+                            };
+                            if (coordinationSummary) {
+                                coordinationSummary.claimKeysMatched = claimSummary.keysMatched;
+                                coordinationSummary.claimCollisions = claimSummary.collisions;
+                            }
+                        }
+                        catch {
+                            // advisory only
+                        }
+                    }
+                    if (delegatedTasks > 0) {
+                        try {
+                            const findingsPrefix = `findings/${toSharedMemoryKeySegment(sharedMemoryTaskId, "task")}/`;
+                            const findings = await readSharedMemory({
+                                rootCwd: cwd,
+                                runId: sharedMemoryRunId,
+                                taskId: sharedMemoryTaskId,
+                            }, {
+                                scope: "run",
+                                prefix: findingsPrefix,
+                                includeValues: true,
+                                limit: Math.max(20, delegatedTasks * 4),
+                            }, _signal);
+                            const examples = findings.items.slice(0, 6).map((item) => {
+                                let excerpt = "";
+                                if (item.value) {
+                                    try {
+                                        const parsed = JSON.parse(item.value);
+                                        if (typeof parsed.summary === "string" && parsed.summary.trim().length > 0) {
+                                            excerpt = parsed.summary.trim().replace(/\s+/g, " ").slice(0, 120);
+                                        }
+                                    }
+                                    catch {
+                                        excerpt = item.value.trim().replace(/\s+/g, " ").slice(0, 120);
+                                    }
+                                }
+                                return excerpt.length > 0 ? `${item.key}: ${excerpt}` : item.key;
+                            });
+                            sharedFindingsSnapshot = {
+                                keysMatched: findings.totalMatched,
+                                examples,
+                            };
+                        }
+                        catch {
+                            // advisory only
+                        }
+                    }
+                    if (coordinationSummary && delegatedTasks > 0) {
+                        finalSections.push([
+                            "### Orchestration Summary",
+                            `- delegated: ${delegatedSucceeded}/${delegatedTasks} succeeded (${delegatedFailed} failed)`,
+                            `- duplicate_delegated_outputs: ${coordinationSummary.duplicatesDetected}`,
+                            `- shared_memory_writes_total: ${coordinationSummary.sharedMemoryWrites}`,
+                            `- shared_memory_writes_current_task: ${coordinationSummary.currentTaskWrites}`,
+                            `- shared_memory_delegate_writes_current_task: ${coordinationSummary.currentTaskDelegateWrites}`,
+                            `- shared_memory_scope_distribution: run=${coordinationSummary.runScopeWrites}, task=${coordinationSummary.taskScopeWrites}`,
+                            `- claims_keys_matched: ${coordinationSummary.claimKeysMatched}`,
+                            `- claims_collisions: ${coordinationSummary.claimCollisions}`,
+                            sharedMemorySummaryKey ? `- shared_memory_summary_key: ${sharedMemorySummaryKey}` : undefined,
+                        ]
+                            .filter((line) => typeof line === "string" && line.trim().length > 0)
+                            .join("\n"));
+                    }
+                    if (claimSummary && delegatedTasks > 0) {
+                        finalSections.push([
+                            "### Claim Overlap Snapshot",
+                            `- matched_keys: ${claimSummary.keysMatched}`,
+                            `- collisions: ${claimSummary.collisions}`,
+                            ...claimSummary.examples.map((line) => `- ${line}`),
+                        ].join("\n"));
+                    }
+                    if (sharedFindingsSnapshot && delegatedTasks > 0) {
+                        finalSections.push([
+                            "### Shared Findings Snapshot",
+                            `- matched_keys: ${sharedFindingsSnapshot.keysMatched}`,
+                            ...sharedFindingsSnapshot.examples.map((line) => `- ${line}`),
+                        ].join("\n"));
+                    }
                     if (delegationWarnings.length > 0) {
                         finalSections.push(`### Delegation Notes\n${delegationWarnings.map((w) => `- ${w}`).join("\n")}`);
                     }
@@ -1753,6 +2699,8 @@ export function createTaskTool(cwd, runner, options) {
                         retrospectiveAttempts: retrospectiveAttempts > 0 ? retrospectiveAttempts : undefined,
                         retrospectiveRecovered: retrospectiveRecovered > 0 ? retrospectiveRecovered : undefined,
                         failureCauses: hasFailureCauses ? { ...failureCauses } : undefined,
+                        coordination: coordinationSummary,
+                        sharedMemorySummaryKey,
                     };
                     updateTrackedTaskStatus("done");
                     return { text, details };
@@ -1760,7 +2708,6 @@ export function createTaskTool(cwd, runner, options) {
                 finally {
                     releaseIsolation?.();
                     releaseWriteLock?.();
-                    cleanupWriteLock(explicitRootLockKey);
                     releaseSlot?.();
                     releaseRunSlot?.();
                     if (orchestrationRunId) {