iosm-cli 0.2.5 → 0.2.7

package/dist/core/tools/task.js

@@ -6,6 +6,7 @@ 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.",
@@ -62,13 +63,13 @@ const systemPromptByProfile = {
     explore: "You are a fast read-only codebase explorer. Answer concisely. Never write or edit files.",
     plan: "You are a technical architect. Analyze the codebase and produce a clear implementation plan. Do not write or edit files.",
     iosm: "You are an IOSM execution agent. Use IOSM methodology and keep IOSM artifacts synchronized with implementation.",
-    meta: "You are a meta orchestration agent. Your main job is to maximize safe parallel execution through delegates, not to personally do most of the implementation. Start with bounded read-only recon, then form a concrete execution graph: subtasks, delegate subtasks, dependencies, lock domains, and verification steps. The parent agent remains responsible for orchestration and synthesis, so decompose work aggressively instead of collapsing complex work into one worker. For any non-trivial task, orchestration is required: after recon, launch multiple focused delegates instead of continuing manual implementation in the parent agent, avoid direct write/edit work in the parent agent before delegation unless the task is clearly trivial, and do not hand the whole task to one specialist child when independent workstreams exist. If a delegated workstream still contains multiple independent slices, split it again with nested <delegate_task> blocks. Default to aggressive safe parallelism. If the user requested a specific degree of parallelism, honor it when feasible or explain the exact blocker. Use shared_memory as the default coordination channel between delegates: use stable namespaced keys, prefer read-before-write, and use CAS (if_version) for contested updates; reserve append mode for timeline/log keys. When delegation is not used for non-trivial work, explain why in one line and include DELEGATION_IMPOSSIBLE. Enforce test verification for code changes, complete only after all delegated branches are resolved, and explicitly justify any no-code path where tests are skipped.",
+    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 writeCapableTools = new Set(["bash", "edit", "write"]);
+const writeCapableTools = new Set(["bash", "edit", "write", "fs_ops"]);
 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)));
@@ -360,6 +361,48 @@ function truncateForDelegationContext(text, maxChars = 2200) {
         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 [];
@@ -453,6 +496,75 @@ function buildAutoDelegationPrompt(input) {
         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);
@@ -479,9 +591,13 @@ function synthesizeDelegationRequests(input) {
     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);
-    const synthesizedLockKey = writeCapableProfiles.has(defaultProfile) ? "auto-synth-write-lock" : undefined;
-    return titles.map((streamTitle, index) => ({
+    return uniqueTitles.map((streamTitle, index) => ({
         description: `Auto: ${streamTitle}`,
         profile: defaultProfile,
         agent: pickAutoDelegateAgent(streamTitle, input.availableCustomNames),
@@ -490,10 +606,10 @@ function synthesizeDelegationRequests(input) {
             rootDescription: input.description,
             rootPrompt: input.prompt,
             ordinal: input.currentDelegates + index + 1,
-            total: input.currentDelegates + titles.length,
+            total: input.currentDelegates + uniqueTitles.length,
         }),
         cwd: undefined,
-        lockKey: synthesizedLockKey,
+        lockKey: writeCapableProfiles.has(defaultProfile) ? deriveAutoSynthLockKey(streamTitle, index + 1) : undefined,
         model: undefined,
         isolation: undefined,
         dependsOn: undefined,
@@ -523,6 +639,71 @@ function buildSharedMemoryGuidance(runId, taskId) {
         "[/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 = [];
@@ -1166,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;
@@ -1266,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;
@@ -1377,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",
@@ -1419,6 +1738,13 @@ export function createTaskTool(cwd, runner, options) {
                                 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];
@@ -1478,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,
@@ -1526,6 +1862,13 @@ export function createTaskTool(cwd, runner, options) {
                                             nestedSection = `${nestedSection}\n\n##### Nested Delegated Subtasks\n\n${deeper.sections.join("\n\n")}`;
                                         }
                                     }
+                                    await publishDelegateFinding({
+                                        delegateLabel: requestLabel,
+                                        delegateDescription: nestedRequest.description,
+                                        delegateProfile: nestedProfileLabel,
+                                        status: "done",
+                                        content: nestedSection,
+                                    });
                                     sectionsByIndex[nestedIndex] = nestedSection;
                                 }
                                 catch (error) {
@@ -1685,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;
@@ -1703,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,
@@ -1899,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",
@@ -2059,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")}`);
                     }
@@ -2145,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 };