iosm-cli 0.2.4 → 0.2.6

package/dist/modes/interactive/interactive-mode.js

@@ -10,7 +10,7 @@ import { CombinedAutocompleteProvider, Container, fuzzyFilter, Loader, Markdown,
 import { spawn, spawnSync } from "child_process";
 import { APP_NAME, CHANGELOG_URL, ENV_SESSION_TRACE, ENV_OFFLINE, ENV_SKIP_VERSION_CHECK, getAgentDir, getAuthPath, getDebugLogPath, getModelsPath, getSessionTracePath, getShareViewerUrl, getUpdateInstruction, isSessionTraceEnabled, PACKAGE_NAME, VERSION, } from "../../config.js";
 import { AuthStorage } from "../../core/auth-storage.js";
-import { getAgentProfile, getMainProfileNames, getProfileNames, isValidProfileName, } from "../../core/agent-profiles.js";
+import { getAgentProfile, getMainProfileNames, getProfileNames, isReadOnlyProfileName, isValidProfileName, } from "../../core/agent-profiles.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -23,6 +23,7 @@ import { resolveModelScope } from "../../core/model-resolver.js";
 import { getMcpCommandHelp, parseMcpAddCommand, parseMcpTargetCommand, } from "../../core/mcp/index.js";
 import { addMemoryEntry, getMemoryFilePath, readMemoryEntries, removeMemoryEntry, updateMemoryEntry, } from "../../core/memory.js";
 import { ContractService, normalizeEngineeringContract, } from "../../core/contract.js";
+import { readSharedMemory } from "../../core/shared-memory.js";
 import { buildProjectIndex, collectChangedFilesSince, ensureProjectIndex, loadProjectIndex, queryProjectIndex, saveProjectIndex, } from "../../core/project-index/index.js";
 import { SingularService, } from "../../core/singular.js";
 import { getDefaultSemanticSearchConfig, getSemanticConfigPath, getSemanticIndexDir, isLikelyEmbeddingModelId, listOllamaLocalModels, listOpenRouterEmbeddingModels, loadMergedSemanticConfig, readScopedSemanticConfig, SemanticConfigMissingError, SemanticIndexRequiredError, SemanticRebuildRequiredError, SemanticSearchRuntime, upsertScopedSemanticSearchConfig, } from "../../core/semantic/index.js";
@@ -88,8 +89,8 @@ function parseRequestedParallelAgentCount(text) {
     const patterns = [
         /(\d+)\s+(?:parallel|concurrent)\s+agents?/i,
         /(\d+)\s+agents?/i,
-        /(\d+)\s+паралл\w*\s+агент\w*/i,
-        /(\d+)\s+агент\w*/i,
+        /(\d+)\s+паралл[\p{L}\p{N}_-]*\s+агент[\p{L}\p{N}_-]*/iu,
+        /(\d+)\s+агент[\p{L}\p{N}_-]*/iu,
     ];
     for (const pattern of patterns) {
         const match = text.match(pattern);
@@ -127,6 +128,12 @@ function buildMetaParallelismCorrection(input) {
         `Meta runtime correction: this run currently has ${input.launchedTopLevelTasks} top-level task call(s), but it should have at least ${input.requiredTopLevelTasks}.`,
         "Stop manual sequential execution in the main agent and convert the execution graph into parallel task calls now.",
         "Emit the missing top-level task calls in the same assistant response when branches are independent.",
+        input.workerDiversityMissing
+            ? `Top-level task fan-out currently targets only ${input.distinctWorkers ?? 1} worker identity. Use at least 2 focused worker identities (profile/agent) or force nested delegation inside each stream.`
+            : undefined,
+        input.nestedDelegationMissing
+            ? "Top-level fan-out exists, but no nested delegates were observed. For each broad top-level stream, emit nested <delegate_task> fan-out or one explicit line: DELEGATION_IMPOSSIBLE: <precise reason>."
+            : undefined,
         "Each task tool call MUST include description and prompt.",
         'If you want a custom subagent, pass it via agent="name"; keep profile set to the capability profile, not the custom subagent name.',
         input.rawRootDelegateBlocks && input.rawRootDelegateBlocks > 0
@@ -145,25 +152,44 @@ function buildMetaParallelismCorrection(input) {
 }
 async function promptMetaWithParallelismGuard(input) {
     let taskToolCalls = 0;
+    let completedTaskToolCalls = 0;
     let nonTaskToolCalls = 0;
     let taskPlanSnapshot;
     let taskToolError;
     let rawRootDelegateBlocks = 0;
     let delegationImpossibleDeclared = false;
     let correctionText;
-    const maybeScheduleCorrection = () => {
+    let distinctTaskWorkers = new Set();
+    let delegatedChildTasksSeen = 0;
+    const maybeScheduleCorrection = (options) => {
         const requiredTopLevelTasks = deriveMetaRequiredTopLevelTaskCalls(input.userInput, taskPlanSnapshot);
-        if (!requiredTopLevelTasks || taskToolCalls >= requiredTopLevelTasks || delegationImpossibleDeclared) {
+        if (!requiredTopLevelTasks || delegationImpossibleDeclared) {
+            return;
+        }
+        const canAssessNestedDelegation = options?.finalize || completedTaskToolCalls >= taskToolCalls;
+        const needsMoreTopLevelTasks = taskToolCalls < requiredTopLevelTasks;
+        const workerDiversityMissing = !needsMoreTopLevelTasks &&
+            requiredTopLevelTasks >= 2 &&
+            distinctTaskWorkers.size === 1 &&
+            delegatedChildTasksSeen === 0;
+        const nestedDelegationMissing = !needsMoreTopLevelTasks &&
+            !workerDiversityMissing &&
+            requiredTopLevelTasks >= 2 &&
+            taskToolCalls > 0 &&
+            delegatedChildTasksSeen === 0 &&
+            canAssessNestedDelegation &&
+            !taskToolError;
+        if (!needsMoreTopLevelTasks && !workerDiversityMissing && !nestedDelegationMissing) {
             return;
         }
         const hasComplexPlan = !!taskPlanSnapshot;
         const hasTaskFailure = !!taskToolError;
         const hasRawRootDelegates = rawRootDelegateBlocks > 0;
-        if (!hasTaskFailure && !hasRawRootDelegates && nonTaskToolCalls < 1) {
-            return;
-        }
-        if (!hasComplexPlan && !hasTaskFailure && !hasRawRootDelegates && nonTaskToolCalls < 2) {
-            return;
+        if (needsMoreTopLevelTasks && !hasTaskFailure && !hasRawRootDelegates && !nestedDelegationMissing) {
+            const minimumNonTaskCalls = hasComplexPlan ? 0 : 2;
+            if (!options?.finalize && nonTaskToolCalls < minimumNonTaskCalls) {
+                return;
+            }
         }
         correctionText = buildMetaParallelismCorrection({
             requiredTopLevelTasks,
@@ -171,6 +197,9 @@ async function promptMetaWithParallelismGuard(input) {
             taskPlanSnapshot,
             taskToolError,
             rawRootDelegateBlocks,
+            workerDiversityMissing,
+            distinctWorkers: distinctTaskWorkers.size,
+            nestedDelegationMissing,
         });
     };
     const unsubscribe = input.session.subscribe((event) => {
@@ -192,6 +221,17 @@ async function promptMetaWithParallelismGuard(input) {
         if (event.type === "tool_execution_start") {
             if (event.toolName === "task") {
                 taskToolCalls += 1;
+                const args = event.args && typeof event.args === "object" ? event.args : undefined;
+                const workerIdentityRaw = (typeof args?.agent === "string" && args.agent.trim()) ||
+                    (typeof args?.profile === "string" && args.profile.trim()) ||
+                    undefined;
+                if (workerIdentityRaw) {
+                    distinctTaskWorkers.add(workerIdentityRaw.toLowerCase());
+                }
+                else if (args) {
+                    // Distinguish "explicit task call with omitted identity" from missing event payload.
+                    distinctTaskWorkers.add("__default_profile__");
+                }
             }
             else {
                 nonTaskToolCalls += 1;
@@ -200,22 +240,76 @@ async function promptMetaWithParallelismGuard(input) {
             return;
         }
         if (event.type === "tool_execution_end" && event.toolName === "task" && event.isError) {
+            completedTaskToolCalls += 1;
             taskToolError = extractTaskToolErrorText(event.result) ?? taskToolError;
             maybeScheduleCorrection();
+            return;
+        }
+        if (event.type === "tool_execution_end" && event.toolName === "task" && !event.isError) {
+            completedTaskToolCalls += 1;
+            const result = event.result;
+            const delegatedTasks = result?.details?.delegatedTasks;
+            if (typeof delegatedTasks === "number" && Number.isFinite(delegatedTasks) && delegatedTasks > 0) {
+                delegatedChildTasksSeen += delegatedTasks;
+            }
+            maybeScheduleCorrection();
         }
     });
     try {
         await input.session.prompt(input.userInput);
-        const requiredTopLevelTasks = deriveMetaRequiredTopLevelTaskCalls(input.userInput, taskPlanSnapshot);
+        maybeScheduleCorrection({ finalize: true });
+        let requiredTopLevelTasks = deriveMetaRequiredTopLevelTaskCalls(input.userInput, taskPlanSnapshot);
+        let workerDiversityMissingAfterRun = !!requiredTopLevelTasks &&
+            requiredTopLevelTasks >= 2 &&
+            distinctTaskWorkers.size === 1 &&
+            delegatedChildTasksSeen === 0;
+        let nestedDelegationMissingAfterRun = !!requiredTopLevelTasks &&
+            requiredTopLevelTasks >= 2 &&
+            taskToolCalls >= requiredTopLevelTasks &&
+            taskToolCalls > 0 &&
+            delegatedChildTasksSeen === 0 &&
+            !workerDiversityMissingAfterRun &&
+            !taskToolError;
         if (correctionText &&
             requiredTopLevelTasks &&
-            taskToolCalls < requiredTopLevelTasks &&
+            (taskToolCalls < requiredTopLevelTasks || workerDiversityMissingAfterRun || nestedDelegationMissingAfterRun) &&
             !delegationImpossibleDeclared) {
             await input.session.prompt(correctionText, {
                 expandPromptTemplates: false,
                 skipOrchestrationDirective: true,
                 source: "interactive",
             });
+            maybeScheduleCorrection({ finalize: true });
+            requiredTopLevelTasks = deriveMetaRequiredTopLevelTaskCalls(input.userInput, taskPlanSnapshot);
+            workerDiversityMissingAfterRun =
+                !!requiredTopLevelTasks &&
+                    requiredTopLevelTasks >= 2 &&
+                    distinctTaskWorkers.size === 1 &&
+                    delegatedChildTasksSeen === 0;
+            nestedDelegationMissingAfterRun =
+                !!requiredTopLevelTasks &&
+                    requiredTopLevelTasks >= 2 &&
+                    taskToolCalls >= requiredTopLevelTasks &&
+                    taskToolCalls > 0 &&
+                    delegatedChildTasksSeen === 0 &&
+                    !workerDiversityMissingAfterRun &&
+                    !taskToolError;
+        }
+        if (requiredTopLevelTasks &&
+            (taskToolCalls < requiredTopLevelTasks ||
+                workerDiversityMissingAfterRun ||
+                nestedDelegationMissingAfterRun) &&
+            !delegationImpossibleDeclared &&
+            input.onPersistentNonCompliance) {
+            await input.onPersistentNonCompliance({
+                requiredTopLevelTasks,
+                launchedTopLevelTasks: taskToolCalls,
+                distinctWorkers: distinctTaskWorkers.size,
+                workerDiversityMissing: workerDiversityMissingAfterRun,
+                nestedDelegationMissing: nestedDelegationMissingAfterRun,
+                taskPlanSnapshot,
+                taskToolError,
+            });
         }
     }
     finally {
@@ -549,6 +643,8 @@ export class InteractiveMode {
         this.sessionAllowedToolSignatures = new Set();
         this.singularLastEffectiveContract = {};
         this.swarmActiveRunId = undefined;
+        this.swarmStopRequested = false;
+        this.swarmAbortController = undefined;
         this.lastSigintTime = 0;
         this.lastEscapeTime = 0;
         this.changelogMarkdown = undefined;
@@ -559,6 +655,7 @@ export class InteractiveMode {
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
         this.currentTurnSawAssistantMessage = false;
+        this.currentTurnSawTaskToolCall = false;
         // Tool execution tracking: toolCallId -> component
         this.pendingTools = new Map();
         // Subagent execution tracking with live progress/metadata for task tool calls.
@@ -737,6 +834,17 @@ export class InteractiveMode {
         }
     }
     async requestToolPermission(request) {
+        if (this.activeProfileName === "meta" &&
+            !this.currentTurnSawTaskToolCall &&
+            (request.toolName === "bash" || request.toolName === "edit" || request.toolName === "write")) {
+            this.showWarning(`META mode orchestration guard: direct ${request.toolName} is blocked before the first task call in a turn. Launch subagents via task or switch profile to full.`);
+            return false;
+        }
+        if (isReadOnlyProfileName(this.activeProfileName) &&
+            (request.toolName === "bash" || request.toolName === "edit" || request.toolName === "write")) {
+            this.showWarning(`Tool ${request.toolName} is disabled in ${this.activeProfileName} profile. Switch to full/meta/iosm for mutating operations.`);
+            return false;
+        }
         for (const rule of this.permissionDenyRules) {
             if (this.matchesPermissionRule(rule, request)) {
                 this.showWarning(`Denied by rule: ${rule}`);
@@ -2138,7 +2246,7 @@ export class InteractiveMode {
             sessionManager: this.sessionManager,
             modelRegistry: this.session.modelRegistry,
             model: this.session.model,
-            isIdle: () => !this.session.isStreaming,
+            isIdle: () => !this.session.isStreaming && this.swarmActiveRunId === undefined,
             abort: () => this.session.abort(),
             hasPendingMessages: () => this.session.pendingMessageCount > 0,
             shutdown: () => {
@@ -2710,6 +2818,7 @@ export class InteractiveMode {
                 this.session.isRetrying ||
                 this.iosmAutomationRun !== undefined ||
                 this.iosmVerificationSession !== undefined ||
+                this.swarmActiveRunId !== undefined ||
                 this.singularAnalysisSession !== undefined ||
                 queuedMessages.steering.length > 0 ||
                 queuedMessages.followUp.length > 0 ||
@@ -3116,6 +3225,173 @@ export class InteractiveMode {
             durationMs: Date.now() - subagent.startTime,
         });
     }
+    getSwarmSubagentKey(runId, taskId) {
+        return `swarm:${runId}:${taskId}`;
+    }
+    ensureSwarmSubagentDisplay(input) {
+        const key = this.getSwarmSubagentKey(input.runId, input.taskId);
+        const existing = this.subagentComponents.get(key);
+        if (existing) {
+            return existing;
+        }
+        const profile = (input.profile?.trim() || this.resolveSwarmTaskProfile(input.task)).trim();
+        const info = {
+            description: input.task.brief || input.task.id,
+            profile,
+            status: "running",
+            phase: "starting subagent",
+            phaseState: "starting",
+            cwd: this.sessionManager.getCwd(),
+            toolCallsStarted: 0,
+            toolCallsCompleted: 0,
+            assistantMessages: 0,
+            delegatedTasks: 0,
+            delegatedSucceeded: 0,
+            delegatedFailed: 0,
+        };
+        const component = new SubagentMessageComponent(info);
+        this.chatContainer.addChild(component);
+        const state = {
+            component,
+            startTime: Date.now(),
+            profile: info.profile,
+            description: info.description,
+            cwd: info.cwd,
+            agent: info.agent,
+            lockKey: info.lockKey,
+            isolation: info.isolation,
+            phase: info.phase,
+            phaseState: info.phaseState,
+            activeTool: info.activeTool,
+            toolCallsStarted: info.toolCallsStarted ?? 0,
+            toolCallsCompleted: info.toolCallsCompleted ?? 0,
+            assistantMessages: info.assistantMessages ?? 0,
+            delegatedTasks: info.delegatedTasks,
+            delegatedSucceeded: info.delegatedSucceeded,
+            delegatedFailed: info.delegatedFailed,
+            delegateIndex: info.delegateIndex,
+            delegateTotal: info.delegateTotal,
+            delegateDescription: info.delegateDescription,
+            delegateProfile: info.delegateProfile,
+            delegateItems: info.delegateItems,
+        };
+        this.subagentComponents.set(key, state);
+        this.ensureSubagentElapsedTimer();
+        this.ui.requestRender();
+        return state;
+    }
+    updateSwarmSubagentProgress(input) {
+        const state = this.ensureSwarmSubagentDisplay({
+            runId: input.runId,
+            taskId: input.taskId,
+            task: input.task,
+            profile: input.profile,
+        });
+        const progress = input.progress;
+        if (typeof progress.phase === "string" && progress.phase.trim()) {
+            state.phase = progress.phase.trim();
+        }
+        if (isSubagentPhaseState(progress.phaseState)) {
+            state.phaseState = progress.phaseState;
+        }
+        if (typeof progress.cwd === "string" && progress.cwd.trim()) {
+            state.cwd = progress.cwd.trim();
+        }
+        if ("activeTool" in progress) {
+            state.activeTool =
+                typeof progress.activeTool === "string" && progress.activeTool.trim().length > 0
+                    ? progress.activeTool.trim()
+                    : undefined;
+        }
+        if (typeof progress.toolCallsStarted === "number" && Number.isFinite(progress.toolCallsStarted)) {
+            state.toolCallsStarted = Math.max(0, progress.toolCallsStarted);
+        }
+        if (typeof progress.toolCallsCompleted === "number" && Number.isFinite(progress.toolCallsCompleted)) {
+            state.toolCallsCompleted = Math.max(0, progress.toolCallsCompleted);
+        }
+        if (typeof progress.assistantMessages === "number" && Number.isFinite(progress.assistantMessages)) {
+            state.assistantMessages = Math.max(0, progress.assistantMessages);
+        }
+        if (typeof progress.delegatedTasks === "number" && Number.isFinite(progress.delegatedTasks)) {
+            state.delegatedTasks = Math.max(0, progress.delegatedTasks);
+        }
+        if (typeof progress.delegatedSucceeded === "number" && Number.isFinite(progress.delegatedSucceeded)) {
+            state.delegatedSucceeded = Math.max(0, progress.delegatedSucceeded);
+        }
+        if (typeof progress.delegatedFailed === "number" && Number.isFinite(progress.delegatedFailed)) {
+            state.delegatedFailed = Math.max(0, progress.delegatedFailed);
+        }
+        if ("delegateIndex" in progress) {
+            state.delegateIndex =
+                typeof progress.delegateIndex === "number" && progress.delegateIndex > 0
+                    ? Math.floor(progress.delegateIndex)
+                    : undefined;
+        }
+        if ("delegateTotal" in progress) {
+            state.delegateTotal =
+                typeof progress.delegateTotal === "number" && progress.delegateTotal > 0
+                    ? Math.floor(progress.delegateTotal)
+                    : undefined;
+        }
+        if ("delegateDescription" in progress) {
+            state.delegateDescription =
+                typeof progress.delegateDescription === "string" && progress.delegateDescription.trim().length > 0
+                    ? progress.delegateDescription.trim()
+                    : undefined;
+        }
+        if ("delegateProfile" in progress) {
+            state.delegateProfile =
+                typeof progress.delegateProfile === "string" && progress.delegateProfile.trim().length > 0
+                    ? progress.delegateProfile.trim()
+                    : undefined;
+        }
+        if ("delegateItems" in progress) {
+            state.delegateItems = Array.isArray(progress.delegateItems) ? progress.delegateItems : undefined;
+        }
+        this.updateRunningSubagentDisplay(state);
+        this.ui.requestRender();
+    }
+    finalizeSwarmSubagentDisplay(input) {
+        const key = this.getSwarmSubagentKey(input.runId, input.taskId);
+        const state = this.subagentComponents.get(key);
+        if (!state)
+            return;
+        const durationMs = Date.now() - state.startTime;
+        state.component.update({
+            description: state.description,
+            profile: state.profile,
+            status: input.status,
+            durationMs,
+            phaseState: state.phaseState,
+            cwd: state.cwd,
+            agent: state.agent,
+            lockKey: state.lockKey,
+            isolation: state.isolation,
+            toolCallsStarted: state.toolCallsStarted,
+            toolCallsCompleted: state.toolCallsCompleted,
+            assistantMessages: state.assistantMessages,
+            delegatedTasks: state.delegatedTasks,
+            delegatedSucceeded: state.delegatedSucceeded,
+            delegatedFailed: state.delegatedFailed,
+            errorMessage: input.status === "error" ? input.errorMessage ?? "error" : undefined,
+        });
+        this.subagentComponents.delete(key);
+        this.stopSubagentElapsedTimerIfIdle();
+        this.ui.requestRender();
+    }
+    finalizeSwarmRunSubagentDisplays(runId, errorMessage) {
+        for (const [key] of this.subagentComponents.entries()) {
+            if (!key.startsWith(`swarm:${runId}:`))
+                continue;
+            const taskId = key.slice(`swarm:${runId}:`.length);
+            this.finalizeSwarmSubagentDisplay({
+                runId,
+                taskId,
+                status: "error",
+                errorMessage,
+            });
+        }
+    }
     ensureSubagentElapsedTimer() {
         if (this.subagentElapsedTimer || this.subagentComponents.size === 0) {
             return;
@@ -3156,6 +3432,7 @@ export class InteractiveMode {
         switch (event.type) {
             case "agent_start":
                 this.currentTurnSawAssistantMessage = false;
+                this.currentTurnSawTaskToolCall = false;
                 // Restore main escape handler if retry handler is still active
                 // (retry success event fires later, but we need main handler now)
                 if (this.retryEscapeHandler) {
@@ -3286,6 +3563,9 @@ export class InteractiveMode {
                 this.ui.requestRender();
                 break;
             case "tool_execution_start": {
+                if (event.toolName === "task") {
+                    this.currentTurnSawTaskToolCall = true;
+                }
                 if (event.toolName === "task" && !this.subagentComponents.has(event.toolCallId)) {
                     const staleTaskComponent = this.pendingTools.get(event.toolCallId);
                     if (staleTaskComponent) {
@@ -3922,6 +4202,15 @@ export class InteractiveMode {
     // =========================================================================
     handleCtrlC() {
         const now = Date.now();
+        if (this.swarmActiveRunId) {
+            if (this.swarmStopRequested && now - this.lastSigintTime < 500) {
+                void this.shutdown();
+                return;
+            }
+            this.lastSigintTime = now;
+            void this.interruptCurrentWork();
+            return;
+        }
         if (this.iosmAutomationRun) {
             if (this.iosmAutomationRun.cancelRequested && now - this.lastSigintTime < 500) {
                 void this.shutdown();
@@ -4329,6 +4618,7 @@ export class InteractiveMode {
         const hasAutomationWork = this.iosmAutomationRun !== undefined;
         const verificationSession = this.iosmVerificationSession;
         const hasVerificationWork = verificationSession !== undefined;
+        const hasSwarmWork = this.swarmActiveRunId !== undefined;
         const singularSession = this.singularAnalysisSession;
         const hasSingularWork = singularSession !== undefined;
         const hasMainStreaming = this.session.isStreaming;
@@ -4338,6 +4628,7 @@ export class InteractiveMode {
         if (!hasPendingQueuedMessages &&
             !hasAutomationWork &&
             !hasVerificationWork &&
+            !hasSwarmWork &&
             !hasSingularWork &&
             !hasMainStreaming &&
             !hasRetryWork &&
@@ -4351,6 +4642,10 @@ export class InteractiveMode {
         if (this.iosmAutomationRun) {
             this.iosmAutomationRun.cancelRequested = true;
         }
+        if (hasSwarmWork) {
+            this.swarmStopRequested = true;
+            this.swarmAbortController?.abort();
+        }
         if (hasPendingQueuedMessages) {
             this.restoreQueuedMessagesToEditor();
         }
@@ -4371,9 +4666,11 @@ export class InteractiveMode {
             ? "Stopping IOSM automation..."
             : hasVerificationWork
                 ? "Stopping IOSM verification..."
-                : hasSingularWork
-                    ? "Stopping /singular analysis..."
-                    : "Stopping current run...");
+                : hasSwarmWork
+                    ? "Stopping swarm run..."
+                    : hasSingularWork
+                        ? "Stopping /singular analysis..."
+                        : "Stopping current run...");
         const abortPromises = [];
         if (hasMainStreaming) {
             abortPromises.push(this.session.abort());
@@ -7866,8 +8163,10 @@ export class InteractiveMode {
         });
         options.push("Close without decision");
         const selected = await this.showExtensionSelector("/singular: choose next step", options);
-        if (!selected || selected === "Close without decision")
+        if (!selected || selected === "Close without decision") {
+            this.showStatus("Singular: decision closed without execution.");
             return;
+        }
         const match = selected.match(/^Option\s+(\d+)/);
         if (!match)
             return;
@@ -8879,6 +9178,26 @@ export class InteractiveMode {
             await promptMetaWithParallelismGuard({
                 session: this.session,
                 userInput,
+                onPersistentNonCompliance: async (details) => {
+                    if (typeof this.runSwarmFromTask !== "function")
+                        return;
+                    if (this.session.isStreaming || this.iosmAutomationRun || this.iosmVerificationSession)
+                        return;
+                    const topLevelSatisfied = details.launchedTopLevelTasks >= details.requiredTopLevelTasks;
+                    if (details.nestedDelegationMissing && topLevelSatisfied && !details.workerDiversityMissing) {
+                        this.showWarning("META quality warning: top-level fan-out completed, but nested delegate fan-out was not observed. " +
+                            "Repeat with explicit nested delegation requirements or include DELEGATION_IMPOSSIBLE for narrow streams.");
+                        return;
+                    }
+                    const explicitRequested = parseRequestedParallelAgentCount(userInput);
+                    const hasComplexSignal = /\b(audit|security|hardening|refactor|migration|orchestrat|parallel|delegate|multi[-\s]?agent)\b/i.test(userInput);
+                    const fallbackParallel = Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, explicitRequested ??
+                        (hasComplexSignal
+                            ? Math.max(details.requiredTopLevelTasks, 6)
+                            : Math.max(details.requiredTopLevelTasks, 3))));
+                    this.showWarning(`META enforcement fallback: orchestration contract not satisfied (${details.launchedTopLevelTasks}/${details.requiredTopLevelTasks} task calls). Launching /swarm run.`);
+                    await this.runSwarmFromTask(userInput, { maxParallel: fallbackParallel });
+                },
             });
             return;
         }
@@ -9116,6 +9435,40 @@ export class InteractiveMode {
             command: commandParts.join(" "),
         };
     }
+    resolveOrchestrateDefaultAssignmentProfile(parsed) {
+        const active = this.activeProfileName || "full";
+        if (parsed.mode !== "parallel")
+            return active;
+        if (parsed.profile || (parsed.profiles && parsed.profiles.length > 0))
+            return active;
+        if (isReadOnlyProfileName(active))
+            return active;
+        return "meta";
+    }
+    deriveOrchestrateDelegateParallelHint(input) {
+        const normalizedTask = input.task.toLowerCase();
+        const highRisk = /\b(refactor|rewrite|migration|migrate|breaking|rollback|security|auth|authentication|authorization|permission|payment|billing|schema|database|critical)\b/i.test(normalizedTask);
+        const mediumRisk = /\b(cross[-\s]?module|architecture|infra|platform|multi[-\s]?file|integration|audit|hardening)\b/i.test(normalizedTask);
+        let hint = input.mode === "parallel"
+            ? Math.max(2, Math.min(MAX_SUBAGENT_DELEGATE_PARALLEL, input.maxParallel ?? input.agents))
+            : 1;
+        if (highRisk) {
+            hint = Math.max(hint, 7);
+        }
+        else if (mediumRisk) {
+            hint = Math.max(hint, 5);
+        }
+        if (input.mode === "parallel" && input.dependencyEdges >= input.agents) {
+            hint = Math.max(hint, 6);
+        }
+        if (input.hasDependencies) {
+            hint = Math.max(2, Math.min(hint, 6));
+        }
+        if (input.hasLock) {
+            hint = Math.max(1, Math.min(hint, 4));
+        }
+        return Math.max(1, Math.min(MAX_SUBAGENT_DELEGATE_PARALLEL, hint));
+    }
     isEffectiveContractReady(contract) {
         const hasText = (value) => typeof value === "string" && value.trim().length > 0;
         const hasList = (value) => Array.isArray(value) && value.some((item) => item.trim().length > 0);
@@ -9452,12 +9805,15 @@ export class InteractiveMode {
         };
     }
     resolveSwarmTaskProfile(task) {
+        const hint = this.deriveSwarmTaskDelegateParallelHint(task);
+        if (task.concurrency_class === "docs")
+            return "plan";
+        if (hint >= 2)
+            return "meta";
         if (task.concurrency_class === "analysis")
             return "explore";
         if (task.concurrency_class === "verification" || task.concurrency_class === "tests")
             return "iosm_verifier";
-        if (task.concurrency_class === "docs")
-            return "plan";
         return "full";
     }
     estimateSwarmTaskCostUsd(task) {
@@ -9473,6 +9829,13 @@ export class InteractiveMode {
         const hasVeryComplexSignal = /(overhaul|major|system-wide|cross-cutting|multi-service|facet|registry)/i.test(brief) ||
             task.touches.length >= 5 ||
             task.scopes.length >= 4;
+        if (task.concurrency_class === "analysis" || task.concurrency_class === "docs") {
+            if (task.severity === "low")
+                return 1;
+            if (task.touches.length >= 6 || task.scopes.length >= 4 || hasComplexKeyword)
+                return 2;
+            return 1;
+        }
         if (task.severity === "low" && task.touches.length <= 2 && task.scopes.length <= 2 && !hasComplexKeyword) {
             return 1;
         }
@@ -9487,6 +9850,38 @@ export class InteractiveMode {
             return 5;
         return hasComplexKeyword ? 3 : 1;
     }
+    ensureSwarmModelReady(source) {
+        if (this.session.model)
+            return true;
+        if (source === "singular") {
+            this.showWarning("Cannot launch Swarm from /singular: no active model. Select one via /model and retry.");
+        }
+        else {
+            this.showWarning("Cannot run /swarm: no active model selected. Configure /model first.");
+        }
+        return false;
+    }
+    resolveSwarmMaxParallel(input) {
+        const requested = input.requested;
+        if (typeof requested === "number" && Number.isFinite(requested)) {
+            return Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, Math.floor(requested)));
+        }
+        const totalTasks = Math.max(1, input.plan.tasks.length);
+        const initialFanout = Math.max(1, input.plan.tasks.filter((task) => task.depends_on.length === 0).length);
+        const parallelizable = input.plan.tasks.filter((task) => task.concurrency_class === "implementation" || task.concurrency_class === "tests")
+            .length;
+        const sourceFloor = input.source === "singular" ? 4 : 3;
+        const autoCap = Math.min(MAX_ORCHESTRATION_PARALLEL, 10);
+        const heuristic = Math.max(sourceFloor, Math.ceil(totalTasks / 2), initialFanout, parallelizable >= 4 ? Math.ceil(parallelizable / 2) : 1);
+        return Math.max(1, Math.min(autoCap, heuristic));
+    }
+    resolveSwarmDispatchTimeoutMs() {
+        const dispatchTimeoutRaw = Number.parseInt(process.env.IOSM_SWARM_DISPATCH_TIMEOUT_MS ?? "", 10);
+        if (Number.isInteger(dispatchTimeoutRaw) && dispatchTimeoutRaw > 0) {
+            return Math.max(1_000, Math.min(1_800_000, dispatchTimeoutRaw));
+        }
+        return 180_000;
+    }
     parseSwarmSpawnCandidates(output, parentTaskId) {
         const lines = output.split(/\r?\n/);
         const results = [];
@@ -9530,6 +9925,16 @@ export class InteractiveMode {
         }
         const profile = this.resolveSwarmTaskProfile(input.task);
         const delegateParallelHint = this.deriveSwarmTaskDelegateParallelHint(input.task);
+        const requiresStrongDelegation = input.task.concurrency_class !== "analysis" &&
+            input.task.concurrency_class !== "docs" &&
+            (input.task.severity === "high" || delegateParallelHint >= 7);
+        const minDelegatesRequired = !requiresStrongDelegation
+            ? 0
+            : delegateParallelHint >= 8
+                ? 3
+                : delegateParallelHint >= 5
+                    ? 2
+                    : 1;
         const safeDescription = input.task.brief.replace(/\s+/g, " ").trim().slice(0, 120).replace(/"/g, "'");
         const prompt = [
             `<swarm_task run_id="${input.meta.runId}" task_id="${input.task.id}" profile_hint="${profile}">`,
@@ -9542,10 +9947,15 @@ export class InteractiveMode {
             "",
             "Execution requirements:",
             `- Use the task tool exactly once with description="${safeDescription || input.task.id}", profile="${profile}", delegate_parallel_hint=${delegateParallelHint}, run_id="${input.meta.runId}", task_id="${input.task.id}".`,
-            `- Inside this single task call, prefer decomposition into <delegate_task> subtasks when delegate_parallel_hint >= 2 (target parallel fan-out up to ${delegateParallelHint}).`,
-            "- If decomposition is not beneficial, continue with single-agent execution (optional note: DELEGATION_IMPOSSIBLE: <reason>).",
+            minDelegatesRequired > 0
+                ? `- Inside this single task call, emit at least ${minDelegatesRequired} independent <delegate_task> subtasks (target parallel fan-out up to ${delegateParallelHint}).`
+                : "- Delegation is optional for this task; keep execution focused.",
+            minDelegatesRequired > 0
+                ? '- If safe decomposition is impossible, output exactly one line: DELEGATION_IMPOSSIBLE: <reason>.'
+                : "- If decomposition is not beneficial, continue with single-agent execution.",
             "- Keep edits inside declared scopes/touches. If scope expansion is required, explain and stop.",
             "- If blocked, respond with line: BLOCKED: <reason>",
+            "- Return concise execution output; avoid long narrative if not needed.",
             "- Optional spawn candidates format: '- <description> | <path> | <change_type> | <low|medium|high>'",
             "</swarm_task>",
         ].join("\n");
@@ -9583,7 +9993,7 @@ export class InteractiveMode {
                 resourceLoader,
                 model,
                 thinkingLevel: this.session.thinkingLevel,
-                profile: "full",
+                profile: "meta",
                 enableTaskTool: true,
             });
             swarmSession = created.session;
@@ -9600,6 +10010,14 @@ export class InteractiveMode {
         const taskErrors = [];
         let delegatedFailed = 0;
         let delegatedTasks = 0;
+        let toolCallsStarted = 0;
+        let toolCallsCompleted = 0;
+        let assistantMessages = 0;
+        let activeTool;
+        const dispatchTimeoutMs = this.resolveSwarmDispatchTimeoutMs();
+        let timedOut = false;
+        let timeoutHandle;
+        let detachStopListener;
         const delegatedFailureCauses = new Map();
         const accumulateFailureCauses = (raw) => {
             if (!raw || typeof raw !== "object")
@@ -9613,13 +10031,71 @@ export class InteractiveMode {
                 delegatedFailureCauses.set(cause, (delegatedFailureCauses.get(cause) ?? 0) + numeric);
             }
         };
+        const emitProgress = (progress) => {
+            input.onProgress?.({
+                activeTool,
+                toolCallsStarted,
+                toolCallsCompleted,
+                assistantMessages,
+                delegatedTasks,
+                delegatedFailed,
+                ...progress,
+            });
+        };
         const chunks = [];
         const unsubscribe = swarmSession.subscribe((event) => {
-            if (event.type === "tool_execution_start" && event.toolName === "task") {
-                taskToolCalls += 1;
+            if (event.type === "tool_execution_start") {
+                toolCallsStarted += 1;
+                activeTool = event.toolName;
+                if (event.toolName === "task") {
+                    taskToolCalls += 1;
+                }
+                emitProgress({
+                    phase: event.toolName ? `running ${event.toolName}` : "running",
+                    phaseState: "running",
+                });
+                return;
+            }
+            if (event.type === "tool_execution_update" && event.toolName === "task") {
+                const partial = event.partialResult;
+                const progressCandidate = partial?.details?.progress;
+                if (progressCandidate && typeof progressCandidate === "object") {
+                    const progress = progressCandidate;
+                    const delegateItems = parseSubagentDelegateItems(progress.delegateItems);
+                    emitProgress({
+                        phase: typeof progress.message === "string" ? progress.message : undefined,
+                        phaseState: isSubagentPhaseState(progress.phase) ? progress.phase : undefined,
+                        cwd: typeof progress.cwd === "string" ? progress.cwd : undefined,
+                        activeTool: typeof progress.activeTool === "string" && progress.activeTool.trim().length > 0
+                            ? progress.activeTool.trim()
+                            : activeTool,
+                        toolCallsStarted: typeof progress.toolCallsStarted === "number" && Number.isFinite(progress.toolCallsStarted)
+                            ? progress.toolCallsStarted
+                            : undefined,
+                        toolCallsCompleted: typeof progress.toolCallsCompleted === "number" && Number.isFinite(progress.toolCallsCompleted)
+                            ? progress.toolCallsCompleted
+                            : undefined,
+                        assistantMessages: typeof progress.assistantMessages === "number" && Number.isFinite(progress.assistantMessages)
+                            ? progress.assistantMessages
+                            : undefined,
+                        delegateIndex: typeof progress.delegateIndex === "number" && Number.isFinite(progress.delegateIndex)
+                            ? progress.delegateIndex
+                            : undefined,
+                        delegateTotal: typeof progress.delegateTotal === "number" && Number.isFinite(progress.delegateTotal)
+                            ? progress.delegateTotal
+                            : undefined,
+                        delegateDescription: typeof progress.delegateDescription === "string" ? progress.delegateDescription : undefined,
+                        delegateProfile: typeof progress.delegateProfile === "string" ? progress.delegateProfile : undefined,
+                        delegateItems,
+                    });
+                }
                 return;
             }
             if (event.type === "tool_execution_end" && event.toolName === "task") {
+                toolCallsCompleted += 1;
+                if (activeTool === event.toolName) {
+                    activeTool = undefined;
+                }
                 const result = event.result;
                 const details = result?.details;
                 if (typeof details?.delegatedFailed === "number" && Number.isFinite(details.delegatedFailed)) {
@@ -9629,38 +10105,127 @@ export class InteractiveMode {
                     delegatedTasks += Math.max(0, details.delegatedTasks);
                 }
                 accumulateFailureCauses(details?.failureCauses);
+                emitProgress({
+                    phase: event.isError ? "task tool failed" : "task tool completed",
+                    phaseState: "running",
+                    delegatedTasks: typeof details?.delegatedTasks === "number" && Number.isFinite(details.delegatedTasks)
+                        ? details.delegatedTasks
+                        : undefined,
+                    delegatedSucceeded: typeof details?.delegatedSucceeded === "number" && Number.isFinite(details.delegatedSucceeded)
+                        ? details.delegatedSucceeded
+                        : undefined,
+                    delegatedFailed: typeof details?.delegatedFailed === "number" && Number.isFinite(details.delegatedFailed)
+                        ? details.delegatedFailed
+                        : undefined,
+                });
                 if (event.isError) {
                     taskErrors.push(result?.error ?? result?.output ?? "task tool failed");
                 }
                 return;
             }
+            if (event.type === "tool_execution_end") {
+                toolCallsCompleted += 1;
+                if (activeTool === event.toolName) {
+                    activeTool = undefined;
+                }
+                emitProgress({
+                    phase: event.toolName ? `completed ${event.toolName}` : "running",
+                    phaseState: "running",
+                });
+                return;
+            }
             if (event.type === "message_end" && event.message.role === "assistant") {
+                assistantMessages += 1;
                 for (const part of event.message.content) {
                     if (part.type === "text" && part.text.trim()) {
                         chunks.push(part.text.trim());
                     }
                 }
+                emitProgress({
+                    phase: "drafting response",
+                    phaseState: "responding",
+                });
             }
         });
         try {
-            await swarmSession.prompt(prompt, {
+            emitProgress({
+                phase: "booting subagent",
+                phaseState: "starting",
+            });
+            if (input.stopSignal?.aborted) {
+                return {
+                    taskId: input.task.id,
+                    status: "blocked",
+                    error: "Swarm run interrupted.",
+                    failureCause: "interrupted",
+                    costUsd: this.estimateSwarmTaskCostUsd(input.task),
+                };
+            }
+            const promptPromise = swarmSession.prompt(prompt, {
                 expandPromptTemplates: false,
                 skipIosmAutopilot: true,
                 skipOrchestrationDirective: true,
                 source: "interactive",
             });
+            // Guard against provider/model hangs in isolated swarm sessions.
+            void promptPromise.catch(() => {
+                // handled by race below
+            });
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    void swarmSession.abort().catch(() => {
+                        // best effort
+                    });
+                    emitProgress({
+                        phase: "dispatch timeout",
+                        phaseState: "responding",
+                    });
+                    reject(new Error(`Swarm task dispatch timed out after ${dispatchTimeoutMs}ms.`));
+                }, dispatchTimeoutMs);
+            });
+            const stopPromise = new Promise((_, reject) => {
+                if (!input.stopSignal)
+                    return;
+                const onAbort = () => {
+                    void swarmSession.abort().catch(() => {
+                        // best effort
+                    });
+                    emitProgress({
+                        phase: "dispatch interrupted",
+                        phaseState: "responding",
+                    });
+                    reject(new Error("Swarm task dispatch interrupted."));
+                };
+                if (input.stopSignal.aborted) {
+                    onAbort();
+                    return;
+                }
+                input.stopSignal.addEventListener("abort", onAbort, { once: true });
+                detachStopListener = () => input.stopSignal?.removeEventListener("abort", onAbort);
+            });
+            await Promise.race([promptPromise, timeoutPromise, stopPromise]);
         }
         catch (error) {
             return {
                 taskId: input.task.id,
                 status: "error",
                 error: error instanceof Error ? error.message : String(error),
+                failureCause: error instanceof Error && /interrupted/i.test(error.message)
+                    ? "interrupted"
+                    : timedOut
+                        ? "timeout"
+                        : undefined,
                 costUsd: this.estimateSwarmTaskCostUsd(input.task),
             };
         }
         finally {
+            detachStopListener?.();
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
             unsubscribe();
-            if (swarmSession.isStreaming) {
+            if (timedOut || swarmSession.isStreaming) {
                 await swarmSession.abort().catch(() => {
                     // best effort
                 });
@@ -9682,6 +10247,7 @@ export class InteractiveMode {
                 taskId: input.task.id,
                 status: "error",
                 error: "No task tool call executed by assistant.",
+                failureCause: "protocol_violation",
                 costUsd: this.estimateSwarmTaskCostUsd(input.task),
             };
         }
@@ -9723,6 +10289,7 @@ export class InteractiveMode {
         if (!input.resumeState) {
             store.init(input.meta, input.plan, initialState);
         }
+        const swarmTaskById = new Map(input.plan.tasks.map((task) => [task.id, task]));
         let rollingIndex = input.projectIndex;
         let localStopRequested = false;
         const refreshIncrementalIndex = () => {
@@ -9740,57 +10307,243 @@ export class InteractiveMode {
             rollingIndex = rebuilt;
         };
         this.swarmActiveRunId = input.runId;
+        this.swarmStopRequested = false;
+        this.swarmAbortController = new AbortController();
+        this.footerDataProvider.setSwarmBusy(true);
+        this.footer.invalidate();
         this.showStatus(`Swarm run started: ${input.runId}`);
-        const schedulerResult = await runSwarmScheduler({
-            runId: input.runId,
-            plan: input.plan,
-            contract: input.contract,
-            maxParallel: input.meta.maxParallel,
-            budgetUsd: input.budgetUsd,
-            existingState: initialState,
-            dispatchTask: async ({ task, runtime }) => this.dispatchSwarmTaskWithAgent({
-                meta: input.meta,
-                task,
-                runtime,
+        let schedulerResult;
+        try {
+            schedulerResult = await runSwarmScheduler({
+                runId: input.runId,
+                plan: input.plan,
                 contract: input.contract,
-            }),
-            confirmSpawn: async ({ candidate, parentTask }) => {
-                const requiresConfirmation = candidate.severity === "high" || parentTask.spawn_policy === "manual_high_risk";
-                if (!requiresConfirmation)
+                maxParallel: input.meta.maxParallel,
+                budgetUsd: input.budgetUsd,
+                existingState: initialState,
+                dispatchTask: async ({ task, runtime }) => this.dispatchSwarmTaskWithAgent({
+                    meta: input.meta,
+                    task,
+                    runtime,
+                    contract: input.contract,
+                    stopSignal: this.swarmAbortController?.signal,
+                    onProgress: (progress) => {
+                        this.updateSwarmSubagentProgress({
+                            runId: input.runId,
+                            taskId: task.id,
+                            task,
+                            profile: this.resolveSwarmTaskProfile(task),
+                            progress,
+                        });
+                    },
+                }),
+                confirmSpawn: async ({ candidate, parentTask }) => {
+                    const requiresConfirmation = candidate.severity === "high" || parentTask.spawn_policy === "manual_high_risk";
+                    if (!requiresConfirmation)
+                        return true;
+                    const choice = await this.showExtensionSelector([
+                        `/swarm spawn candidate requires confirmation`,
+                        `severity=${candidate.severity} task=${parentTask.id}`,
+                        `description=${candidate.description}`,
+                        `path=${candidate.path}`,
+                    ].join("\n"), ["Approve spawn", "Reject spawn (Recommended)", "Abort run"]);
+                    if (!choice || choice.startsWith("Reject")) {
+                        this.showStatus(`Swarm spawn rejected: ${candidate.description}`);
+                        return false;
+                    }
+                    if (choice === "Abort run") {
+                        localStopRequested = true;
+                        this.showWarning("Swarm run marked to stop after current scheduling step.");
+                        return false;
+                    }
                     return true;
-                const choice = await this.showExtensionSelector([
-                    `/swarm spawn candidate requires confirmation`,
-                    `severity=${candidate.severity} task=${parentTask.id}`,
-                    `description=${candidate.description}`,
-                    `path=${candidate.path}`,
-                ].join("\n"), ["Approve spawn", "Reject spawn (Recommended)", "Abort run"]);
-                if (!choice || choice.startsWith("Reject")) {
-                    this.showStatus(`Swarm spawn rejected: ${candidate.description}`);
-                    return false;
-                }
-                if (choice === "Abort run") {
-                    localStopRequested = true;
-                    this.showWarning("Swarm run marked to stop after current scheduling step.");
-                    return false;
-                }
-                return true;
-            },
-            onEvent: (event) => {
-                store.appendEvent(event);
-            },
-            onStateChanged: (state) => {
-                store.saveState(state);
-                store.saveCheckpoint(state);
-                refreshIncrementalIndex();
-            },
-            shouldStop: () => this.shutdownRequested || localStopRequested,
-        });
-        this.swarmActiveRunId = undefined;
+                },
+                dispatchTimeoutMs: Math.min(1_800_000, this.resolveSwarmDispatchTimeoutMs() + 5_000),
+                onEvent: (event) => {
+                    store.appendEvent(event);
+                    if (event.type === "task_running" && event.taskId) {
+                        const task = swarmTaskById.get(event.taskId);
+                        if (task) {
+                            this.updateSwarmSubagentProgress({
+                                runId: input.runId,
+                                taskId: task.id,
+                                task,
+                                profile: this.resolveSwarmTaskProfile(task),
+                                progress: {
+                                    phase: "starting subagent",
+                                    phaseState: "starting",
+                                },
+                            });
+                        }
+                        this.showStatus(`Swarm ${event.taskId}: running`);
+                    }
+                    if (event.type === "task_done" && event.taskId) {
+                        this.finalizeSwarmSubagentDisplay({
+                            runId: input.runId,
+                            taskId: event.taskId,
+                            status: "done",
+                        });
+                        this.showStatus(`Swarm ${event.taskId}: done`);
+                    }
+                    if (event.type === "task_retry" && event.taskId) {
+                        const task = swarmTaskById.get(event.taskId);
+                        if (task) {
+                            this.updateSwarmSubagentProgress({
+                                runId: input.runId,
+                                taskId: event.taskId,
+                                task,
+                                profile: this.resolveSwarmTaskProfile(task),
+                                progress: {
+                                    phase: event.message,
+                                    phaseState: "running",
+                                },
+                            });
+                        }
+                        this.showWarning(`Swarm ${event.taskId}: ${event.message}`);
+                    }
+                    if (event.type === "task_error" && event.taskId) {
+                        this.finalizeSwarmSubagentDisplay({
+                            runId: input.runId,
+                            taskId: event.taskId,
+                            status: "error",
+                            errorMessage: event.message,
+                        });
+                        this.showWarning(`Swarm ${event.taskId} failed: ${event.message}`);
+                    }
+                    if (event.type === "task_blocked" && event.taskId) {
+                        this.finalizeSwarmSubagentDisplay({
+                            runId: input.runId,
+                            taskId: event.taskId,
+                            status: "error",
+                            errorMessage: event.message,
+                        });
+                        this.showWarning(`Swarm ${event.taskId} blocked: ${event.message}`);
+                    }
+                    if ((event.type === "run_blocked" || event.type === "run_failed" || event.type === "run_stopped") && event.message) {
+                        this.showWarning(`Swarm ${event.type.replace("run_", "")}: ${event.message}`);
+                    }
+                },
+                onStateChanged: (state) => {
+                    store.saveState(state);
+                    store.saveCheckpoint(state);
+                    refreshIncrementalIndex();
+                },
+                shouldStop: () => this.shutdownRequested || localStopRequested || this.swarmStopRequested,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const failedState = store.loadState() ?? initialState;
+            failedState.status = "failed";
+            failedState.lastError = message;
+            failedState.updatedAt = new Date().toISOString();
+            store.appendEvent({
+                type: "run_failed",
+                timestamp: new Date().toISOString(),
+                runId: input.runId,
+                tick: failedState.tick,
+                message,
+            });
+            store.saveState(failedState);
+            store.saveCheckpoint(failedState);
+            this.finalizeSwarmRunSubagentDisplays(input.runId, message);
+            this.showWarning(`Swarm run failed unexpectedly: ${message}`);
+            return;
+        }
+        finally {
+            this.swarmActiveRunId = undefined;
+            this.swarmStopRequested = false;
+            this.swarmAbortController = undefined;
+            this.footerDataProvider.setSwarmBusy(false);
+            this.footer.invalidate();
+        }
+        if (schedulerResult.state.status !== "completed") {
+            this.finalizeSwarmRunSubagentDisplays(input.runId, schedulerResult.state.lastError ?? `Swarm run ${schedulerResult.state.status}`);
+        }
         const taskStates = Object.values(schedulerResult.state.tasks);
         const doneCount = taskStates.filter((task) => task.status === "done").length;
         const errorCount = taskStates.filter((task) => task.status === "error").length;
         const blockedCount = taskStates.filter((task) => task.status === "blocked").length;
         const total = taskStates.length;
+        const summaryByTask = new Map();
+        let summaryKeysMatched = 0;
+        let findingKeysMatched = 0;
+        try {
+            const summaryRead = await readSharedMemory({
+                rootCwd: cwd,
+                runId: input.runId,
+            }, {
+                scope: "run",
+                prefix: "results/",
+                includeValues: true,
+                limit: Math.max(50, total * 6),
+            });
+            summaryKeysMatched = summaryRead.totalMatched;
+            for (const item of summaryRead.items) {
+                const key = item.key.trim();
+                if (!key.startsWith("results/"))
+                    continue;
+                const taskId = key.slice("results/".length).trim();
+                if (!taskId)
+                    continue;
+                let parsedSummary;
+                if (item.value) {
+                    try {
+                        const parsed = JSON.parse(item.value);
+                        parsedSummary = {
+                            delegatedTotal: parsed.delegated?.total,
+                            delegatedSucceeded: parsed.delegated?.succeeded,
+                            delegatedFailed: parsed.delegated?.failed,
+                            summary: typeof parsed.summary === "string" ? parsed.summary : undefined,
+                        };
+                    }
+                    catch {
+                        // keep best-effort behavior for malformed summary payloads
+                    }
+                }
+                summaryByTask.set(taskId, parsedSummary ?? {});
+            }
+            const findingsRead = await readSharedMemory({
+                rootCwd: cwd,
+                runId: input.runId,
+            }, {
+                scope: "run",
+                prefix: "findings/",
+                includeValues: false,
+                limit: Math.max(100, total * 12),
+            });
+            findingKeysMatched = findingsRead.totalMatched;
+        }
+        catch {
+            // shared-memory aggregation is advisory, never fail swarm completion on it
+        }
+        const missingSummaryTasks = input.plan.tasks
+            .map((task) => task.id)
+            .filter((taskId) => !summaryByTask.has(taskId));
+        const sharedMemoryLines = [
+            "## Shared Memory Coordination",
+            `- result_keys: ${summaryKeysMatched}`,
+            `- finding_keys: ${findingKeysMatched}`,
+            `- task_summaries_found: ${summaryByTask.size}/${total}`,
+            missingSummaryTasks.length > 0
+                ? `- missing_task_summaries: ${missingSummaryTasks.slice(0, 12).join(", ")}`
+                : "- missing_task_summaries: none",
+            ...input.plan.tasks.slice(0, 12).map((task) => {
+                const summary = summaryByTask.get(task.id);
+                if (!summary)
+                    return `- ${task.id}: no summary key`;
+                const delegatedPart = typeof summary.delegatedTotal === "number" &&
+                    typeof summary.delegatedSucceeded === "number" &&
+                    typeof summary.delegatedFailed === "number"
+                    ? `delegated=${summary.delegatedSucceeded}/${summary.delegatedTotal} (failed=${summary.delegatedFailed})`
+                    : "delegated=n/a";
+                const summaryExcerpt = typeof summary.summary === "string" && summary.summary.trim().length > 0
+                    ? summary.summary.trim().replace(/\s+/g, " ").slice(0, 120)
+                    : "no summary excerpt";
+                return `- ${task.id}: ${delegatedPart}; ${summaryExcerpt}`;
+            }),
+            "",
+        ];
         const reportLines = [
             "# Swarm Integration Report",
             "",
@@ -9812,6 +10565,7 @@ export class InteractiveMode {
             ...schedulerResult.runGate.failures.map((item) => `- fail: ${item}`),
             ...schedulerResult.runGate.warnings.map((item) => `- warn: ${item}`),
             "",
+            ...sharedMemoryLines,
             "## Spawn Backlog",
             ...(schedulerResult.spawnBacklog.length > 0
                 ? schedulerResult.spawnBacklog.map((item) => `- ${item.description} | ${item.path} | ${item.changeType} | fp=${item.fingerprint}`)
@@ -9828,6 +10582,7 @@ export class InteractiveMode {
                 "# Shared Context",
                 "",
                 `Run ${input.runId} finished with status: ${schedulerResult.state.status}.`,
+                `Shared memory summaries: ${summaryByTask.size}/${total} task result key(s), findings=${findingKeysMatched}.`,
                 `Recommendation: ${schedulerResult.runGate.pass ? "proceed to /iosm for measurable optimization" : "resolve failed gates before /iosm"}.`,
             ].join("\n"),
         });
@@ -9836,11 +10591,14 @@ export class InteractiveMode {
             `status: ${schedulerResult.state.status}`,
             `tasks: ${doneCount}/${total} done · ${errorCount} error · ${blockedCount} blocked`,
             `budget_usd: ${schedulerResult.state.budget.spentUsd.toFixed(2)}${input.meta.budgetUsd ? `/${input.meta.budgetUsd.toFixed(2)}` : ""}`,
+            `shared_memory: summaries ${summaryByTask.size}/${total} · findings ${findingKeysMatched}`,
             `watch: /swarm watch ${input.runId}`,
             `resume: /swarm resume ${input.runId}`,
         ].join("\n"));
     }
     async runSwarmFromTask(task, options) {
+        if (!this.ensureSwarmModelReady("plain"))
+            return;
         const contract = await this.ensureSwarmEffectiveContract(task);
         if (!contract)
             return;
@@ -9855,7 +10613,11 @@ export class InteractiveMode {
             index: indexInfo.index,
         });
         const runId = `swarm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const maxParallel = Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, options.maxParallel ?? 3));
+        const maxParallel = this.resolveSwarmMaxParallel({
+            requested: options.maxParallel,
+            plan,
+            source: "plain",
+        });
         const meta = this.buildSwarmRunMeta({
             runId,
             source: "plain",
@@ -9877,6 +10639,8 @@ export class InteractiveMode {
         });
     }
     async runSwarmFromSingular(input) {
+        if (!this.ensureSwarmModelReady("singular"))
+            return;
         const analysis = this.loadSingularAnalysisByRunId(input.runId);
         if (!analysis) {
             this.showWarning(`Singular run not found: ${input.runId}`);
@@ -9899,7 +10663,11 @@ export class InteractiveMode {
             index: indexInfo.index,
         });
         const runId = `swarm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        const maxParallel = Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, input.maxParallel ?? 3));
+        const maxParallel = this.resolveSwarmMaxParallel({
+            requested: input.maxParallel,
+            plan,
+            source: "singular",
+        });
         const meta = this.buildSwarmRunMeta({
             runId,
             source: "singular",
@@ -10087,6 +10855,10 @@ export class InteractiveMode {
         });
     }
     async handleSwarmCommand(text) {
+        if (this.swarmActiveRunId) {
+            this.showWarning(`Swarm run already in progress: ${this.swarmActiveRunId}. Use /swarm watch.`);
+            return;
+        }
         if (this.session.isStreaming) {
             this.showWarning("Cannot run /swarm while the agent is processing another request.");
             return;
@@ -10300,6 +11072,9 @@ export class InteractiveMode {
             this.showWarning("--max-parallel is only valid with --parallel mode.");
             return undefined;
         }
+        if (mode === "parallel" && maxParallel === undefined) {
+            maxParallel = Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, agents));
+        }
         if (maxParallel !== undefined && maxParallel > agents) {
             maxParallel = agents;
         }
@@ -10366,11 +11141,24 @@ export class InteractiveMode {
         const currentCwd = this.sessionManager.getCwd();
         const assignments = [];
         const assignmentRecords = [];
+        const dependencyEdges = parsed.dependencies?.reduce((sum, entry) => sum + entry.dependsOn.length, 0) ?? 0;
+        const defaultAssignmentProfile = this.resolveOrchestrateDefaultAssignmentProfile(parsed);
+        const delegateParallelHints = [];
         for (let index = 0; index < parsed.agents; index++) {
-            const assignmentProfile = parsed.profiles?.[index] ?? parsed.profile ?? (this.activeProfileName || "full");
+            const assignmentProfile = parsed.profiles?.[index] ?? parsed.profile ?? defaultAssignmentProfile;
             const assignmentCwd = parsed.cwds?.[index] ?? ".";
             const assignmentLock = parsed.locks?.[index];
             const dependsOn = parsed.dependencies?.find((entry) => entry.agent === index + 1)?.dependsOn ?? [];
+            const delegateParallelHint = this.deriveOrchestrateDelegateParallelHint({
+                task: parsed.task,
+                mode: parsed.mode,
+                agents: parsed.agents,
+                maxParallel: parsed.maxParallel,
+                dependencyEdges,
+                hasLock: !!assignmentLock,
+                hasDependencies: dependsOn.length > 0,
+            });
+            delegateParallelHints.push(delegateParallelHint);
             const resolvedCwd = path.resolve(currentCwd, assignmentCwd);
             assignmentRecords.push({
                 profile: assignmentProfile,
@@ -10378,7 +11166,8 @@ export class InteractiveMode {
                 lockKey: assignmentLock,
                 dependsOn,
             });
-            assignments.push(`- agent ${index + 1}: profile=${assignmentProfile} cwd=${resolvedCwd}${assignmentLock ? ` lock_key=${assignmentLock}` : ""}${parsed.isolation === "worktree" ? " isolation=worktree" : ""}${dependsOn.length > 0 ? ` depends_on=${dependsOn.join("|")}` : ""}`);
+            assignments.push(`- agent ${index + 1}: profile=${assignmentProfile} cwd=${resolvedCwd}${assignmentLock ? ` lock_key=${assignmentLock}` : ""}${parsed.isolation === "worktree" ? " isolation=worktree" : ""}${dependsOn.length > 0 ? ` depends_on=${dependsOn.join("|")}` : ""} delegate_parallel_hint=${delegateParallelHint}
+				}`);
         }
         const teamRun = createTeamRun({
             cwd: currentCwd,
@@ -10391,8 +11180,16 @@ export class InteractiveMode {
         const runAssignments = teamRun.tasks.map((task, index) => `${assignments[index]} run_id=${teamRun.runId} task_id=${task.id}`);
         const taskCallHints = teamRun.tasks.map((task, index) => {
             const assignment = assignmentRecords[index];
-            return `- task_call_${index + 1}: description="agent ${index + 1} execution" profile="${assignment.profile}" cwd="${assignment.cwd}" run_id="${teamRun.runId}" task_id="${task.id}"${assignment.lockKey ? ` lock_key="${assignment.lockKey}"` : ""}${parsed.isolation === "worktree" ? ' isolation="worktree"' : ""}`;
+            const hint = delegateParallelHints[index] ?? 1;
+            return `- task_call_${index + 1}: description="agent ${index + 1} execution" profile="${assignment.profile}" cwd="${assignment.cwd}" run_id="${teamRun.runId}" task_id="${task.id}"${assignment.lockKey ? ` lock_key="${assignment.lockKey}"` : ""}${parsed.isolation === "worktree" ? ' isolation="worktree"' : ""} delegate_parallel_hint=${hint}`;
         });
+        if (parsed.mode === "parallel" &&
+            !parsed.profile &&
+            !(parsed.profiles && parsed.profiles.length > 0) &&
+            defaultAssignmentProfile === "meta" &&
+            this.activeProfileName !== "meta") {
+            this.showStatus("Orchestrate auto-profile: using `meta` workers for stronger fan-out and nested delegation.");
+        }
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "◆ ")) + theme.bold("/orchestrate") + theme.fg("muted", ` ${currentCwd}`), 1, 0));
         this.ui.requestRender();
@@ -10407,9 +11204,15 @@ export class InteractiveMode {
             "- for parallel mode, emit all independent task calls in one assistant response",
             "- in parallel mode, use parallel tool-call style (<use_parallel_tool_calls>)",
             "- when assignment lines include depends_on, still emit one task call per assignment; runtime enforces dependency gating",
+            "- include delegate_parallel_hint from each assignment/task_call hint in every corresponding task tool call",
+            "- for delegate_parallel_hint >= 2, split child work into nested <delegate_task> streams unless impossible",
+            "- if nested split is impossible for a non-trivial stream, emit one line: DELEGATION_IMPOSSIBLE: <reason>",
             "- keep required orchestration task calls in foreground; do not set background=true unless user explicitly requested detached async runs",
             "- do not poll .iosm/subagents/background via bash/read during orchestration; wait for task results and then synthesize",
             "- include run_id and task_id from each assignment in the task tool arguments",
+            "- publish one run-scoped shared-memory summary key per assignment (results/<task_id>) before final synthesis",
+            "- in final synthesis, only report metrics backed by observed run evidence (task details, shared-memory keys, test output, or verified files); otherwise mark them unknown",
+            "- never claim report/artifact files exist unless created in this run or verified on disk",
             "- keep each agent in its assigned cwd",
             "- avoid edit collisions; if two write-capable agents target same area, serialize those writes",
             "- aggregate outputs into one concise final synthesis",
@@ -12394,6 +13197,10 @@ The agent will automatically receive IOSM context on every turn.`;
         }
     }
     async handleBashCommand(command, excludeFromContext = false) {
+        if (isReadOnlyProfileName(this.activeProfileName)) {
+            this.showWarning(`Bash is disabled in ${this.activeProfileName} profile. Switch to full/meta/iosm (Shift+Tab).`);
+            return;
+        }
         const extensionRunner = this.session.extensionRunner;
         // Emit user_bash event to let extensions intercept
         const eventResult = extensionRunner