iosm-cli 0.2.17 → 0.3.0

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

@@ -15,7 +15,6 @@ import { parseSkillBlock, } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage, INTERNAL_UI_META_CUSTOM_TYPE, isInternalUiMetaDetails, } from "../../core/messages.js";
-import { MAX_ORCHESTRATION_AGENTS, MAX_ORCHESTRATION_PARALLEL, MAX_SUBAGENT_DELEGATE_PARALLEL, } from "../../core/orchestration-limits.js";
 import { loadModelsDevProviderCatalog, } from "../../core/models-dev-provider-catalog.js";
 import { ModelRegistry } from "../../core/model-registry.js";
 import { MODELS_DEV_PROVIDERS } from "../../core/models-dev-providers.js";
@@ -67,6 +66,7 @@ import { ExtensionSelectorComponent } from "./components/extension-selector.js";
 import { FooterComponent } from "./components/footer.js";
 import { appKey, appKeyHint, editorKey } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
+import { MessageWindow } from "./components/message-window.js";
 import { McpSelectorComponent } from "./components/mcp-selector.js";
 import { ModelSelectorComponent } from "./components/model-selector.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
@@ -74,7 +74,6 @@ import { ScopedModelsSelectorComponent } from "./components/scoped-models-select
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
-import { SubagentMessageComponent, } from "./components/subagent-message.js";
 import { TaskPlanMessageComponent } from "./components/task-plan-message.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
@@ -94,16 +93,16 @@ export function resolveStreamingSubmissionMode(input) {
 }
 function parseRequestedParallelAgentCount(text) {
     const patterns = [
-        /(\d+)\s+(?:parallel|concurrent)\s+agents?/i,
-        /(\d+)\s+agents?/i,
-        /(\d+)\s+паралл[\p{L}\p{N}_-]*\s+агент[\p{L}\p{N}_-]*/iu,
-        /(\d+)\s+агент[\p{L}\p{N}_-]*/iu,
+        /--agents\s+(\d+)\b/i,
+        /(?:^|\s)agents\s*[:=]\s*(\d+)\b/i,
+        /<orchestrate[^>]*\bagents\s*=\s*["']?(\d+)["']?/i,
+        /"agents"\s*:\s*(\d+)/i,
     ];
     for (const pattern of patterns) {
         const match = text.match(pattern);
         const parsed = match?.[1] ? Number.parseInt(match[1], 10) : Number.NaN;
         if (Number.isInteger(parsed) && parsed >= 1) {
-            return Math.max(1, Math.min(MAX_ORCHESTRATION_AGENTS, parsed));
+            return parsed;
         }
     }
     return undefined;
@@ -871,11 +870,125 @@ function parseSubagentDelegateItems(value) {
         if (!index || !description || !profile || !status)
             continue;
         parsed.push({ index, description, profile, status });
-        if (parsed.length >= 20)
-            break;
     }
     return parsed;
 }
+function summarizeDelegateProgress(input) {
+    if (Array.isArray(input.delegateItems) && input.delegateItems.length > 0) {
+        let done = 0;
+        let failed = 0;
+        let running = 0;
+        let pending = 0;
+        for (const item of input.delegateItems) {
+            switch (item.status) {
+                case "done":
+                    done += 1;
+                    break;
+                case "failed":
+                    failed += 1;
+                    break;
+                case "running":
+                    running += 1;
+                    break;
+                default:
+                    pending += 1;
+                    break;
+            }
+        }
+        return { total: input.delegateItems.length, done, failed, running, pending };
+    }
+    if (typeof input.delegatedTasks === "number" && Number.isFinite(input.delegatedTasks) && input.delegatedTasks > 0) {
+        const total = Math.max(0, Math.floor(input.delegatedTasks));
+        const done = typeof input.delegatedSucceeded === "number" && Number.isFinite(input.delegatedSucceeded)
+            ? Math.max(0, Math.floor(input.delegatedSucceeded))
+            : 0;
+        const failed = typeof input.delegatedFailed === "number" && Number.isFinite(input.delegatedFailed)
+            ? Math.max(0, Math.floor(input.delegatedFailed))
+            : 0;
+        const running = Math.max(0, total - done - failed);
+        return { total, done, failed, running, pending: 0 };
+    }
+    return { total: 0, done: 0, failed: 0, running: 0, pending: 0 };
+}
+function formatOrchestrationToolProgress(started, completed) {
+    if (started <= 0)
+        return "tools -";
+    return `tools ${Math.max(0, completed)}/${Math.max(0, started)}`;
+}
+function formatDelegateStatusMarker(status) {
+    switch (status) {
+        case "done":
+            return "[x]";
+        case "running":
+            return "[>]";
+        case "failed":
+            return "[!]";
+        default:
+            return "[ ]";
+    }
+}
+function compactOneLineText(text, maxLength = 96) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+function appendDelegateTreeRows(rows, input, options = {}) {
+    const indent = options.indent ?? "   ";
+    if (Array.isArray(input.delegateItems) && input.delegateItems.length > 0) {
+        const hasRowLimit = typeof options.maxRows === "number" && Number.isFinite(options.maxRows) && options.maxRows > 0;
+        const visibleItems = hasRowLimit
+            ? input.delegateItems.slice(0, Math.max(1, Math.floor(options.maxRows)))
+            : input.delegateItems;
+        for (const [index, item] of visibleItems.entries()) {
+            const isLastVisible = index === visibleItems.length - 1;
+            const hasMoreHidden = input.delegateItems.length > visibleItems.length;
+            const branch = isLastVisible && !hasMoreHidden ? "└─" : "├─";
+            rows.push(`${indent}${branch} ${formatDelegateStatusMarker(item.status)} #${item.index} ${compactOneLineText(item.description, 56)} (${item.profile})`);
+        }
+        if (input.delegateItems.length > visibleItems.length) {
+            rows.push(`${indent}└─ … +${input.delegateItems.length - visibleItems.length} more delegate(s)`);
+        }
+        return;
+    }
+    const summary = summarizeDelegateProgress({
+        delegateItems: input.delegateItems,
+        delegatedTasks: input.delegatedTasks,
+        delegatedSucceeded: input.delegatedSucceeded,
+        delegatedFailed: input.delegatedFailed,
+    });
+    if (summary.total === 0)
+        return;
+    const summaryParts = [`${summary.done}/${summary.total} done`];
+    if (summary.failed > 0)
+        summaryParts.push(`${summary.failed} failed`);
+    if (summary.running > 0)
+        summaryParts.push(`${summary.running} running`);
+    if (summary.pending > 0)
+        summaryParts.push(`${summary.pending} pending`);
+    rows.push(`${indent}└─ delegates ${summaryParts.join(", ")}`);
+    if (typeof input.delegateIndex === "number" &&
+        input.delegateIndex > 0 &&
+        typeof input.delegateDescription === "string" &&
+        input.delegateDescription.trim().length > 0) {
+        const totalText = typeof input.delegateTotal === "number" && input.delegateTotal > 0 ? `/${Math.floor(input.delegateTotal)}` : "";
+        const profileText = typeof input.delegateProfile === "string" && input.delegateProfile.trim().length > 0
+            ? ` (${input.delegateProfile.trim()})`
+            : "";
+        rows.push(`${indent}   └─ [>] active #${Math.floor(input.delegateIndex)}${totalText} ${compactOneLineText(input.delegateDescription, 56)}${profileText}`);
+    }
+}
+function formatElapsedClock(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const pad2 = (value) => value.toString().padStart(2, "0");
+    if (hours > 0) {
+        return `${pad2(hours)}:${pad2(minutes)}:${pad2(seconds)}`;
+    }
+    return `${pad2(minutes)}:${pad2(seconds)}`;
+}
 function hasDependencyCycle(agents, dependencies) {
     const graph = new Map();
     for (let agent = 1; agent <= agents; agent++) {
@@ -925,6 +1038,16 @@ export class InteractiveMode {
     get settingsManager() {
         return this.session.settingsManager;
     }
+    getCompactFooterSetting() {
+        const manager = this.settingsManager;
+        return typeof manager.getCompactFooter === "function" ? manager.getCompactFooter() : false;
+    }
+    setCompactFooterSetting(enabled) {
+        const manager = this.settingsManager;
+        if (typeof manager.setCompactFooter === "function") {
+            manager.setCompactFooter(enabled);
+        }
+    }
     constructor(session, options = {}) {
         this.options = options;
         this.isInitialized = false;
@@ -959,6 +1082,8 @@ export class InteractiveMode {
         // Subagent execution tracking with live progress/metadata for task tool calls.
         this.subagentComponents = new Map();
         this.subagentElapsedTimer = undefined;
+        this.orchestrationCompletedSubagents = [];
+        this.orchestrationArchivedForTurn = false;
         // Internal UI metadata emitted by runtime for orchestration rendering.
         this.pendingInternalUserDisplayAliases = [];
         this.pendingAssistantOrchestrationContexts = 0;
@@ -1031,6 +1156,7 @@ export class InteractiveMode {
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
         this.chatContainer = new Container();
+        this.orchestrationContainer = new Container();
         this.pendingMessagesContainer = new Container();
         this.statusContainer = new Container();
         this.widgetContainerAbove = new Container();
@@ -1048,6 +1174,7 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider();
         this.footer = new FooterComponent(session, this.footerDataProvider);
         this.footer.setAutoCompactEnabled(session.autoCompactionEnabled);
+        this.footer.setCompactModeEnabled(this.getCompactFooterSetting());
         const profile = getAgentProfile(options.profile);
         this.activeProfileName = profile.name;
         this.profilePromptSuffix = profile.systemPromptAppend || undefined;
@@ -1967,6 +2094,7 @@ export class InteractiveMode {
         this.ui.addChild(this.chatContainer);
         this.ui.addChild(this.pendingMessagesContainer);
         this.ui.addChild(this.statusContainer);
+        this.ui.addChild(this.orchestrationContainer);
         this.renderWidgets(); // Initialize with default spacer
         this.ui.addChild(this.widgetContainerAbove);
         this.ui.addChild(this.editorContainer);
@@ -3653,31 +3781,210 @@ export class InteractiveMode {
             this.editor.addToHistory?.(text);
         };
     }
-    updateRunningSubagentDisplay(subagent) {
-        subagent.component.update({
-            description: subagent.description,
-            profile: subagent.profile,
-            status: "running",
-            phase: subagent.phase ?? "running",
-            phaseState: subagent.phaseState,
-            cwd: subagent.cwd,
-            agent: subagent.agent,
-            lockKey: subagent.lockKey,
-            isolation: subagent.isolation,
-            activeTool: subagent.activeTool,
-            toolCallsStarted: subagent.toolCallsStarted,
-            toolCallsCompleted: subagent.toolCallsCompleted,
-            assistantMessages: subagent.assistantMessages,
-            delegatedTasks: subagent.delegatedTasks,
-            delegatedSucceeded: subagent.delegatedSucceeded,
-            delegatedFailed: subagent.delegatedFailed,
-            delegateIndex: subagent.delegateIndex,
-            delegateTotal: subagent.delegateTotal,
-            delegateDescription: subagent.delegateDescription,
-            delegateProfile: subagent.delegateProfile,
-            delegateItems: subagent.delegateItems,
-            durationMs: Date.now() - subagent.startTime,
-        });
+    resetOrchestrationSummary() {
+        this.orchestrationCompletedSubagents = [];
+        this.orchestrationArchivedForTurn = false;
+        this.refreshOrchestrationSummaryDisplay();
+    }
+    refreshOrchestrationSummaryDisplay() {
+        this.orchestrationContainer.clear();
+        const runningStates = [...this.subagentComponents.values()].sort((a, b) => a.startTime - b.startTime);
+        const completedStates = [...this.orchestrationCompletedSubagents].sort((a, b) => b.finishedAt - a.finishedAt);
+        const now = Date.now();
+        const sectionTaskLimit = Number.POSITIVE_INFINITY;
+        const runningRows = [];
+        const queuedRows = [];
+        const completedRows = [];
+        const failedRows = [];
+        const criticalPath = [];
+        const sectionCounters = {
+            running: { shown: 0, hidden: 0 },
+            queued: { shown: 0, hidden: 0 },
+            completed: { shown: 0, hidden: 0 },
+            failed: { shown: 0, hidden: 0 },
+        };
+        const pushTaskBlock = (target, lines, counter) => {
+            if (counter.shown >= sectionTaskLimit) {
+                counter.hidden += 1;
+                return;
+            }
+            target.push(...lines);
+            counter.shown += 1;
+        };
+        for (const state of runningStates) {
+            const elapsed = formatElapsedClock(now - state.startTime);
+            const phase = compactOneLineText(state.phase?.trim() || "running", 56);
+            const toolProgress = formatOrchestrationToolProgress(state.toolCallsStarted, state.toolCallsCompleted);
+            const msgCount = Math.max(0, state.assistantMessages ?? 0);
+            const isQueuedTask = state.phaseState === "queued";
+            const delegateRows = [];
+            appendDelegateTreeRows(delegateRows, state, { indent: "   " });
+            if (isQueuedTask) {
+                pushTaskBlock(queuedRows, [
+                    `• ${state.profile}  ${compactOneLineText(state.description, 52)}  reason: ${phase}`,
+                    ...delegateRows,
+                ], sectionCounters.queued);
+            }
+            else {
+                if (criticalPath.length < 3) {
+                    criticalPath.push(state.profile);
+                }
+                pushTaskBlock(runningRows, [
+                    `▶ ${state.profile}  ${compactOneLineText(state.description, 52)}  ${elapsed}  ${toolProgress}  msgs ${msgCount}  last: ${phase}`,
+                    ...delegateRows,
+                ], sectionCounters.running);
+            }
+        }
+        for (const state of completedStates) {
+            const elapsed = formatElapsedClock(state.durationMs);
+            const toolProgress = formatOrchestrationToolProgress(state.toolCallsStarted, state.toolCallsCompleted);
+            const msgCount = Math.max(0, state.assistantMessages ?? 0);
+            const delegateRows = [];
+            appendDelegateTreeRows(delegateRows, state, { indent: "   " });
+            if (state.status === "error") {
+                const row = `[!] ${state.profile}  ${compactOneLineText(state.description, 46)}  ${elapsed}  ${toolProgress}  msgs ${msgCount}  error: ${compactOneLineText(state.errorMessage || "error", 46)}`;
+                pushTaskBlock(failedRows, [row, ...delegateRows], sectionCounters.failed);
+                continue;
+            }
+            const outputText = typeof state.outputLength === "number" && Number.isFinite(state.outputLength) && state.outputLength >= 0
+                ? `${(state.outputLength / 1024).toFixed(1)}KB`
+                : "-";
+            const queueText = typeof state.waitMs === "number" && Number.isFinite(state.waitMs) && state.waitMs >= 0
+                ? `queue ${Math.max(0, Math.floor(state.waitMs))}ms`
+                : "queue -";
+            const row = `[x] ${state.profile}  ${compactOneLineText(state.description, 46)}  ${elapsed}  ${toolProgress}  msgs ${msgCount}  out ${outputText}  ${queueText}`;
+            pushTaskBlock(completedRows, [row, ...delegateRows], sectionCounters.completed);
+        }
+        if (sectionCounters.running.hidden > 0) {
+            runningRows.push(`• … +${sectionCounters.running.hidden} more task(s)`);
+        }
+        if (sectionCounters.queued.hidden > 0) {
+            queuedRows.push(`• … +${sectionCounters.queued.hidden} more task(s)`);
+        }
+        if (sectionCounters.completed.hidden > 0) {
+            completedRows.push(`• … +${sectionCounters.completed.hidden} more task(s)`);
+        }
+        if (sectionCounters.failed.hidden > 0) {
+            failedRows.push(`• … +${sectionCounters.failed.hidden} more task(s)`);
+        }
+        const runningCount = runningStates.filter((state) => state.phaseState !== "queued").length;
+        const queuedCount = runningStates.filter((state) => state.phaseState === "queued").length;
+        const doneCount = completedStates.filter((state) => state.status === "done").length;
+        const failedCount = completedStates.filter((state) => state.status === "error").length;
+        const totalCount = doneCount + runningCount + queuedCount + failedCount;
+        if (totalCount === 0) {
+            return;
+        }
+        const etaText = runningCount > 0 || queuedCount > 0 ? "--:--" : "done";
+        const header = theme.fg("warning", "ORCH") +
+            theme.fg("customMessageText", ` ${doneCount}/${totalCount} done`) +
+            theme.fg("dim", " | ") +
+            theme.fg("customMessageText", `${runningCount} running`) +
+            theme.fg("dim", " | ") +
+            theme.fg("customMessageText", `${queuedCount} queued`) +
+            theme.fg("dim", " | ") +
+            (failedCount > 0
+                ? theme.fg("warning", `${failedCount} failed`)
+                : theme.fg("customMessageText", `${failedCount} failed`)) +
+            theme.fg("dim", " | ") +
+            theme.fg("muted", `ETA ${etaText}`);
+        const panelContent = new Container();
+        panelContent.addChild(new Text(header, 0, 0));
+        if (criticalPath.length > 0) {
+            panelContent.addChild(new Text(theme.fg("muted", `CP: ${criticalPath.join(" -> ")}`), 0, 0));
+        }
+        const renderSection = (title, rows, color = "customMessageText") => {
+            panelContent.addChild(new Spacer(1));
+            panelContent.addChild(new Text(theme.fg("warning", title), 0, 0));
+            if (rows.length === 0) {
+                panelContent.addChild(new Text(theme.fg("muted", "• none"), 0, 0));
+                return;
+            }
+            for (const row of rows) {
+                panelContent.addChild(new Text(theme.fg(color, row), 0, 0));
+            }
+        };
+        renderSection("RUNNING", runningRows);
+        renderSection("QUEUED", queuedRows);
+        renderSection("COMPLETED", completedRows, "success");
+        renderSection("FAILED", failedRows, "warning");
+        this.orchestrationContainer.addChild(new MessageWindow(panelContent, {
+            label: "IOSM Orchestration",
+            lineColor: "warning",
+            labelColor: "warning",
+            paddingY: 1,
+        }));
+        this.orchestrationContainer.addChild(new Spacer(1));
+    }
+    pushOrchestrationCompletedSubagent(state) {
+        this.orchestrationCompletedSubagents.push(state);
+    }
+    archiveOrchestrationPanelToChatIfComplete() {
+        if (this.orchestrationArchivedForTurn)
+            return;
+        if (this.subagentComponents.size > 0)
+            return;
+        if (this.orchestrationCompletedSubagents.length === 0)
+            return;
+        if (this.orchestrationContainer.children.length === 0)
+            return;
+        const snapshot = [...this.orchestrationContainer.children];
+        this.orchestrationContainer.clear();
+        const trailingNode = this.chatContainer.children.length > 0
+            ? this.chatContainer.children[this.chatContainer.children.length - 1]
+            : undefined;
+        if (trailingNode) {
+            this.chatContainer.removeChild(trailingNode);
+        }
+        this.chatContainer.addChild(new Spacer(1));
+        for (const child of snapshot) {
+            this.chatContainer.addChild(child);
+        }
+        if (trailingNode) {
+            this.chatContainer.addChild(trailingNode);
+        }
+        this.orchestrationArchivedForTurn = true;
+    }
+    hasCompletedSubagentForToolCall(toolCallId) {
+        return this.orchestrationCompletedSubagents.some((item) => item.toolCallId === toolCallId);
+    }
+    queuePendingTaskCallsFromAssistantMessage(message) {
+        let changed = false;
+        for (const content of message.content) {
+            if (content.type !== "toolCall" || content.name !== "task")
+                continue;
+            if (typeof content.id !== "string" || content.id.trim().length === 0)
+                continue;
+            const toolCallId = content.id;
+            const alreadyCompleted = typeof this.hasCompletedSubagentForToolCall === "function"
+                ? this.hasCompletedSubagentForToolCall(toolCallId)
+                : Array.isArray(this.orchestrationCompletedSubagents)
+                    ? this.orchestrationCompletedSubagents.some((item) => item?.toolCallId === toolCallId)
+                    : false;
+            if (this.subagentComponents.has(toolCallId) || alreadyCompleted) {
+                continue;
+            }
+            const args = content.arguments;
+            this.subagentComponents.set(toolCallId, {
+                startTime: Date.now(),
+                profile: args.profile ?? "explore",
+                description: args.description ?? "Running subtask",
+                cwd: args.cwd,
+                agent: args.agent,
+                lockKey: args.lock_key,
+                isolation: args.isolation,
+                phase: "queued for execution",
+                phaseState: "queued",
+                toolCallsStarted: 0,
+                toolCallsCompleted: 0,
+                assistantMessages: 0,
+            });
+            changed = true;
+        }
+        if (!changed)
+            return;
+        this.ensureSubagentElapsedTimer();
+        this.refreshOrchestrationSummaryDisplay();
     }
     getSwarmSubagentKey(runId, taskId) {
         return `swarm:${runId}:${taskId}`;
@@ -3688,14 +3995,13 @@ export class InteractiveMode {
         if (existing) {
             return existing;
         }
-        const profile = (input.profile?.trim() || this.resolveSwarmTaskProfile(input.task)).trim();
-        const info = {
+        const state = {
+            startTime: Date.now(),
+            profile: (input.profile?.trim() || this.resolveSwarmTaskProfile(input.task)).trim(),
             description: input.task.brief || input.task.id,
-            profile,
-            status: "running",
+            cwd: this.sessionManager.getCwd(),
             phase: "starting subagent",
             phaseState: "starting",
-            cwd: this.sessionManager.getCwd(),
             toolCallsStarted: 0,
             toolCallsCompleted: 0,
             assistantMessages: 0,
@@ -3703,34 +4009,9 @@ export class InteractiveMode {
             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.refreshOrchestrationSummaryDisplay();
         this.ui.requestRender();
         return state;
     }
@@ -3800,9 +4081,12 @@ export class InteractiveMode {
                     : undefined;
         }
         if ("delegateItems" in progress) {
-            state.delegateItems = Array.isArray(progress.delegateItems) ? progress.delegateItems : undefined;
+            const parsed = parseSubagentDelegateItems(progress.delegateItems);
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                state.delegateItems = parsed;
+            }
         }
-        this.updateRunningSubagentDisplay(state);
+        this.refreshOrchestrationSummaryDisplay();
         this.ui.requestRender();
     }
     finalizeSwarmSubagentDisplay(input) {
@@ -3811,26 +4095,35 @@ export class InteractiveMode {
         if (!state)
             return;
         const durationMs = Date.now() - state.startTime;
-        state.component.update({
-            description: state.description,
-            profile: state.profile,
+        this.pushOrchestrationCompletedSubagent({
+            toolCallId: key,
+            finishedAt: Date.now(),
             status: input.status,
+            profile: state.profile,
+            description: state.description,
             durationMs,
-            phaseState: state.phaseState,
             cwd: state.cwd,
             agent: state.agent,
             lockKey: state.lockKey,
             isolation: state.isolation,
+            phase: state.phase,
+            phaseState: state.phaseState,
             toolCallsStarted: state.toolCallsStarted,
             toolCallsCompleted: state.toolCallsCompleted,
             assistantMessages: state.assistantMessages,
             delegatedTasks: state.delegatedTasks,
             delegatedSucceeded: state.delegatedSucceeded,
             delegatedFailed: state.delegatedFailed,
+            delegateIndex: state.delegateIndex,
+            delegateTotal: state.delegateTotal,
+            delegateDescription: state.delegateDescription,
+            delegateProfile: state.delegateProfile,
+            delegateItems: state.delegateItems,
             errorMessage: input.status === "error" ? input.errorMessage ?? "error" : undefined,
         });
         this.subagentComponents.delete(key);
         this.stopSubagentElapsedTimerIfIdle();
+        this.refreshOrchestrationSummaryDisplay();
         this.ui.requestRender();
     }
     finalizeSwarmRunSubagentDisplays(runId, errorMessage) {
@@ -3855,9 +4148,7 @@ export class InteractiveMode {
                 this.clearSubagentElapsedTimer();
                 return;
             }
-            for (const subagent of this.subagentComponents.values()) {
-                this.updateRunningSubagentDisplay(subagent);
-            }
+            this.refreshOrchestrationSummaryDisplay();
             this.ui.requestRender();
         }, 1000);
     }
@@ -3888,6 +4179,19 @@ export class InteractiveMode {
                 this.currentTurnSawAssistantMessage = false;
                 this.currentTurnSawTaskToolCall = false;
                 this.turnAllowedToolSignatures.clear();
+                this.orchestrationArchivedForTurn = false;
+                if (typeof this.resetOrchestrationSummary === "function") {
+                    this.resetOrchestrationSummary();
+                }
+                else {
+                    this.orchestrationCompletedSubagents = [];
+                    if (typeof this.refreshOrchestrationSummaryDisplay === "function") {
+                        this.refreshOrchestrationSummaryDisplay();
+                    }
+                    else if (this.orchestrationContainer?.clear) {
+                        this.orchestrationContainer.clear();
+                    }
+                }
                 // Restore main escape handler if retry handler is still active
                 // (retry success event fires later, but we need main handler now)
                 if (this.retryEscapeHandler) {
@@ -3930,6 +4234,8 @@ export class InteractiveMode {
                         this.pendingAssistantOrchestrationContexts -= 1;
                     }
                     this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                    this.streamingComponent.setExpanded(this.toolOutputExpanded);
+                    this.streamingComponent.setStreaming(true);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
                     this.streamingComponent.updateContent(this.sanitizeAssistantDisplayMessage(this.streamingMessage));
@@ -3974,6 +4280,10 @@ export class InteractiveMode {
                     break;
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
+                    this.streamingComponent.setStreaming(false);
+                    if (typeof this.queuePendingTaskCallsFromAssistantMessage === "function") {
+                        this.queuePendingTaskCallsFromAssistantMessage(event.message);
+                    }
                     let errorMessage;
                     let interruptedStopReason;
                     if (this.streamingMessage.stopReason === "aborted") {
@@ -4021,55 +4331,42 @@ export class InteractiveMode {
                 if (event.toolName === "task") {
                     this.currentTurnSawTaskToolCall = true;
                 }
-                if (event.toolName === "task" && !this.subagentComponents.has(event.toolCallId)) {
+                if (event.toolName === "task") {
                     const staleTaskComponent = this.pendingTools.get(event.toolCallId);
                     if (staleTaskComponent) {
                         this.chatContainer.removeChild(staleTaskComponent);
                         this.pendingTools.delete(event.toolCallId);
                     }
                     const args = event.args;
-                    const description = args.description ?? "Running subtask";
-                    const info = {
-                        description,
-                        profile: args.profile ?? "explore",
-                        status: "running",
-                        phase: "starting subagent",
-                        phaseState: "starting",
-                        cwd: args.cwd,
-                        agent: args.agent,
-                        lockKey: args.lock_key,
-                        isolation: args.isolation,
-                        toolCallsStarted: 0,
-                        toolCallsCompleted: 0,
-                        assistantMessages: 0,
-                    };
-                    const component = new SubagentMessageComponent(info);
-                    this.chatContainer.addChild(component);
-                    this.subagentComponents.set(event.toolCallId, {
-                        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,
-                    });
+                    const existing = this.subagentComponents.get(event.toolCallId);
+                    if (existing) {
+                        existing.profile = args.profile ?? existing.profile;
+                        existing.description = args.description ?? existing.description;
+                        existing.cwd = args.cwd ?? existing.cwd;
+                        existing.agent = args.agent ?? existing.agent;
+                        existing.lockKey = args.lock_key ?? existing.lockKey;
+                        existing.isolation = args.isolation ?? existing.isolation;
+                        existing.phase = "starting subagent";
+                        existing.phaseState = "starting";
+                    }
+                    else {
+                        this.subagentComponents.set(event.toolCallId, {
+                            startTime: Date.now(),
+                            profile: args.profile ?? "explore",
+                            description: args.description ?? "Running subtask",
+                            cwd: args.cwd,
+                            agent: args.agent,
+                            lockKey: args.lock_key,
+                            isolation: args.isolation,
+                            phase: "starting subagent",
+                            phaseState: "starting",
+                            toolCallsStarted: 0,
+                            toolCallsCompleted: 0,
+                            assistantMessages: 0,
+                        });
+                    }
                     this.ensureSubagentElapsedTimer();
+                    this.refreshOrchestrationSummaryDisplay();
                     this.ui.requestRender();
                 }
                 else if (event.toolName !== "task" && !this.pendingTools.has(event.toolCallId)) {
@@ -4121,6 +4418,15 @@ export class InteractiveMode {
                         if (typeof progress.assistantMessages === "number") {
                             subagent.assistantMessages = progress.assistantMessages;
                         }
+                        if (typeof progress.delegatedTasks === "number") {
+                            subagent.delegatedTasks = Math.max(0, progress.delegatedTasks);
+                        }
+                        if (typeof progress.delegatedSucceeded === "number") {
+                            subagent.delegatedSucceeded = Math.max(0, progress.delegatedSucceeded);
+                        }
+                        if (typeof progress.delegatedFailed === "number") {
+                            subagent.delegatedFailed = Math.max(0, progress.delegatedFailed);
+                        }
                         if ("delegateIndex" in progress) {
                             subagent.delegateIndex =
                                 typeof progress.delegateIndex === "number" && progress.delegateIndex > 0
@@ -4146,7 +4452,10 @@ export class InteractiveMode {
                                     : undefined;
                         }
                         if ("delegateItems" in progress) {
-                            subagent.delegateItems = parseSubagentDelegateItems(progress.delegateItems);
+                            const parsedDelegateItems = parseSubagentDelegateItems(progress.delegateItems);
+                            if (Array.isArray(parsedDelegateItems) && parsedDelegateItems.length > 0) {
+                                subagent.delegateItems = parsedDelegateItems;
+                            }
                         }
                     }
                     else {
@@ -4155,7 +4464,7 @@ export class InteractiveMode {
                             subagent.phase = text.trim();
                         }
                     }
-                    this.updateRunningSubagentDisplay(subagent);
+                    this.refreshOrchestrationSummaryDisplay();
                     this.ui.requestRender();
                     break;
                 }
@@ -4191,24 +4500,32 @@ export class InteractiveMode {
                     subagent.delegatedTasks = delegatedTasks;
                     subagent.delegatedSucceeded = delegatedSucceeded;
                     subagent.delegatedFailed = delegatedFailed;
-                    subagent.component.update({
-                        description: subagent.description,
-                        profile: subagent.profile,
+                    this.pushOrchestrationCompletedSubagent({
+                        toolCallId: event.toolCallId,
+                        finishedAt: Date.now(),
                         status: event.isError ? "error" : "done",
-                        outputLength,
+                        profile: subagent.profile,
+                        description: subagent.description,
                         durationMs,
-                        waitMs,
-                        phaseState: subagent.phaseState,
                         cwd: subagent.cwd,
                         agent: subagent.agent,
                         lockKey: subagent.lockKey,
                         isolation: subagent.isolation,
+                        phase: subagent.phase,
+                        phaseState: subagent.phaseState,
                         toolCallsStarted,
                         toolCallsCompleted,
                         assistantMessages,
                         delegatedTasks,
                         delegatedSucceeded,
                         delegatedFailed,
+                        delegateIndex: subagent.delegateIndex,
+                        delegateTotal: subagent.delegateTotal,
+                        delegateDescription: subagent.delegateDescription,
+                        delegateProfile: subagent.delegateProfile,
+                        delegateItems: subagent.delegateItems,
+                        outputLength,
+                        waitMs,
                         errorMessage: event.isError
                             ? event.result?.content?.[0]?.text ?? "error"
                             : undefined,
@@ -4220,6 +4537,7 @@ export class InteractiveMode {
                     }
                     this.subagentComponents.delete(event.toolCallId);
                     this.stopSubagentElapsedTimerIfIdle();
+                    this.refreshOrchestrationSummaryDisplay();
                     this.ui.requestRender();
                     break;
                 }
@@ -4248,6 +4566,15 @@ export class InteractiveMode {
                 this.pendingTools.clear();
                 this.subagentComponents.clear();
                 this.clearSubagentElapsedTimer();
+                if (typeof this.refreshOrchestrationSummaryDisplay === "function") {
+                    this.refreshOrchestrationSummaryDisplay();
+                    if (typeof this.archiveOrchestrationPanelToChatIfComplete === "function") {
+                        this.archiveOrchestrationPanelToChatIfComplete();
+                    }
+                }
+                else if (this.orchestrationContainer?.clear) {
+                    this.orchestrationContainer.clear();
+                }
                 this.currentTurnSawAssistantMessage = false;
                 await this.checkShutdownRequested();
                 this.ui.requestRender();
@@ -4515,6 +4842,7 @@ export class InteractiveMode {
                 const displayMessage = this.sanitizeAssistantDisplayMessage(message);
                 this.activeAssistantOrchestrationContext = previousOrchestrationContext;
                 const assistantComponent = new AssistantMessageComponent(displayMessage, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
+                assistantComponent.setExpanded(this.toolOutputExpanded);
                 this.chatContainer.addChild(assistantComponent);
                 break;
             }
@@ -4535,6 +4863,7 @@ export class InteractiveMode {
      */
     renderSessionContext(sessionContext, options = {}) {
         this.pendingTools.clear();
+        this.resetOrchestrationSummary();
         this.pendingInternalUserDisplayAliases = [];
         this.pendingAssistantOrchestrationContexts = 0;
         this.activeAssistantOrchestrationContext = false;
@@ -4552,17 +4881,14 @@ export class InteractiveMode {
                     if (content.type === "toolCall") {
                         if (content.name === "task") {
                             const args = content.arguments;
-                            const subagent = new SubagentMessageComponent({
+                            pendingSubagentHistory.set(content.id, {
                                 description: args.description ?? "Running subtask",
                                 profile: args.profile ?? "explore",
-                                status: "running",
                                 cwd: args.cwd,
                                 agent: args.agent,
                                 lockKey: args.lock_key,
                                 isolation: args.isolation,
                             });
-                            this.chatContainer.addChild(subagent);
-                            pendingSubagentHistory.set(content.id, subagent);
                             continue;
                         }
                         const component = new ToolExecutionComponent(content.name, content.arguments, { showImages: this.settingsManager.getShowImages() }, this.getRegisteredToolDefinition(content.name), this.ui);
@@ -4592,18 +4918,36 @@ export class InteractiveMode {
                 const subagent = pendingSubagentHistory.get(message.toolCallId);
                 if (subagent) {
                     const details = message.details;
-                    subagent.update({
-                        description: typeof details?.description === "string" ? details.description : "Running subtask",
-                        profile: typeof details?.profile === "string" ? details.profile : "explore",
+                    this.pushOrchestrationCompletedSubagent({
+                        toolCallId: message.toolCallId,
+                        finishedAt: Date.now(),
                         status: message.isError ? "error" : "done",
+                        description: typeof details?.description === "string"
+                            ? details.description
+                            : subagent.description ?? "Running subtask",
+                        profile: typeof details?.profile === "string"
+                            ? details.profile
+                            : subagent.profile ?? "explore",
+                        durationMs: typeof details?.durationMs === "number" && Number.isFinite(details.durationMs)
+                            ? Math.max(0, Math.floor(details.durationMs))
+                            : 0,
+                        cwd: subagent.cwd,
+                        agent: subagent.agent,
+                        lockKey: subagent.lockKey,
+                        isolation: subagent.isolation,
                         outputLength: typeof details?.outputLength === "number" ? details.outputLength : undefined,
                         waitMs: typeof details?.waitMs === "number" ? details.waitMs : undefined,
-                        toolCallsStarted: typeof details?.toolCallsStarted === "number" ? details.toolCallsStarted : undefined,
-                        toolCallsCompleted: typeof details?.toolCallsCompleted === "number" ? details.toolCallsCompleted : undefined,
-                        assistantMessages: typeof details?.assistantMessages === "number" ? details.assistantMessages : undefined,
+                        toolCallsStarted: typeof details?.toolCallsStarted === "number" ? details.toolCallsStarted : 0,
+                        toolCallsCompleted: typeof details?.toolCallsCompleted === "number" ? details.toolCallsCompleted : 0,
+                        assistantMessages: typeof details?.assistantMessages === "number" ? details.assistantMessages : 0,
                         delegatedTasks: typeof details?.delegatedTasks === "number" ? details.delegatedTasks : undefined,
                         delegatedSucceeded: typeof details?.delegatedSucceeded === "number" ? details.delegatedSucceeded : undefined,
                         delegatedFailed: typeof details?.delegatedFailed === "number" ? details.delegatedFailed : undefined,
+                        delegateIndex: typeof details?.delegateIndex === "number" ? details.delegateIndex : undefined,
+                        delegateTotal: typeof details?.delegateTotal === "number" ? details.delegateTotal : undefined,
+                        delegateDescription: typeof details?.delegateDescription === "string" ? details.delegateDescription : undefined,
+                        delegateProfile: typeof details?.delegateProfile === "string" ? details.delegateProfile : undefined,
+                        delegateItems: parseSubagentDelegateItems(details?.delegateItems),
                         errorMessage: message.isError
                             ? message.content?.[0]?.text ?? "error"
                             : undefined,
@@ -5795,6 +6139,7 @@ export class InteractiveMode {
                 autocompleteMaxVisible: this.settingsManager.getAutocompleteMaxVisible(),
                 quietStartup: this.settingsManager.getQuietStartup(),
                 clearOnShrink: this.settingsManager.getClearOnShrink(),
+                compactFooter: this.getCompactFooterSetting(),
                 webSearchEnabled: this.settingsManager.getWebSearchEnabled(),
                 webSearchProviderMode: this.settingsManager.getWebSearchProviderMode(),
                 webSearchFallbackMode: this.settingsManager.getWebSearchFallbackMode(),
@@ -6003,6 +6348,11 @@ export class InteractiveMode {
                     this.settingsManager.setClearOnShrink(enabled);
                     this.ui.setClearOnShrink(enabled);
                 },
+                onCompactFooterChange: (enabled) => {
+                    this.setCompactFooterSetting(enabled);
+                    this.footer.setCompactModeEnabled?.(enabled);
+                    this.ui.requestRender();
+                },
                 onCancel: () => {
                     done();
                     this.ui.requestRender();
@@ -9975,9 +10325,8 @@ export class InteractiveMode {
             const mentionTask = cleaned.length > 0 ? cleaned : userInput;
             const orchestrationAwareAgent = /orchestrator/i.test(mentionedAgent);
             const mentionMode = orchestrationAwareAgent ? "parallel" : "sequential";
-            const mentionMaxParallel = orchestrationAwareAgent ? MAX_ORCHESTRATION_PARALLEL : undefined;
             const mentionPrompt = [
-                `<orchestrate mode="${mentionMode}" agents="1"${mentionMaxParallel ? ` max_parallel="${mentionMaxParallel}"` : ""}>`,
+                `<orchestrate mode="${mentionMode}" agents="1">`,
                 `- agent 1: profile=${this.activeProfileName} cwd=${this.sessionManager.getCwd()} agent=${mentionedAgent}`,
                 `task: ${mentionTask}`,
                 "constraints:",
@@ -9986,8 +10335,8 @@ export class InteractiveMode {
                 ...(orchestrationAwareAgent
                     ? [
                         "- Include delegate_parallel_hint in the task call.",
-                        `- If user explicitly requested an agent count, set delegate_parallel_hint to that count (clamp 1..${MAX_SUBAGENT_DELEGATE_PARALLEL}).`,
-                        `- Otherwise set delegate_parallel_hint based on complexity: simple=1, medium=3-6, complex/risky=7-${MAX_SUBAGENT_DELEGATE_PARALLEL}.`,
+                        "- If user explicitly requested an agent count, set delegate_parallel_hint to that count.",
+                        "- Otherwise set delegate_parallel_hint based on complexity: simple=1, medium=3-6, complex/risky=7+.",
                         "- For non-trivial tasks, prefer delegate_parallel_hint >= 2 and split into independent <delegate_task> workstreams.",
                         '- Prefer existing custom agents for delegated work when suitable (use <delegate_task agent="name" ...>).',
                         "- If no existing custom agent fits, create focused delegate streams via profile-based <delegate_task> blocks.",
@@ -10019,10 +10368,10 @@ export class InteractiveMode {
                     }
                     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 ??
+                    const fallbackParallel = Math.max(1, explicitRequested ??
                         (hasComplexSignal
                             ? Math.max(details.requiredTopLevelTasks, 6)
-                            : Math.max(details.requiredTopLevelTasks, 3))));
+                            : 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 });
                 },
@@ -10050,6 +10399,8 @@ export class InteractiveMode {
                 case "message_start":
                     if (event.message.role === "assistant" && !hideAssistantText) {
                         verifyStreamingComponent = new AssistantMessageComponent(undefined, false, this.getMarkdownThemeWithSettings());
+                        verifyStreamingComponent.setExpanded(this.toolOutputExpanded);
+                        verifyStreamingComponent.setStreaming(true);
                         verifyStreamingMessage = event.message;
                         this.chatContainer.addChild(verifyStreamingComponent);
                         verifyStreamingComponent.updateContent(verifyStreamingMessage);
@@ -10072,6 +10423,7 @@ export class InteractiveMode {
                 case "message_end":
                     if (verifyStreamingComponent && event.message.role === "assistant") {
                         verifyStreamingMessage = event.message;
+                        verifyStreamingComponent.setStreaming(false);
                         verifyStreamingComponent.updateContent(verifyStreamingMessage);
                         verifyStreamingComponent = undefined;
                         verifyStreamingMessage = undefined;
@@ -10278,7 +10630,7 @@ export class InteractiveMode {
         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))
+            ? Math.max(2, input.maxParallel ?? input.agents)
             : 1;
         if (highRisk) {
             hint = Math.max(hint, 7);
@@ -10290,12 +10642,12 @@ export class InteractiveMode {
             hint = Math.max(hint, 6);
         }
         if (input.hasDependencies) {
-            hint = Math.max(2, Math.min(hint, 6));
+            hint = Math.max(2, hint);
         }
         if (input.hasLock) {
-            hint = Math.max(1, Math.min(hint, 4));
+            hint = Math.max(1, hint);
         }
-        return Math.max(1, Math.min(MAX_SUBAGENT_DELEGATE_PARALLEL, hint));
+        return Math.max(1, hint);
     }
     isEffectiveContractReady(contract) {
         const hasText = (value) => typeof value === "string" && value.trim().length > 0;
@@ -10518,8 +10870,8 @@ export class InteractiveMode {
             if (token === "--max-parallel") {
                 const next = rest[index + 1];
                 const parsed = next ? Number.parseInt(next, 10) : Number.NaN;
-                if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_ORCHESTRATION_PARALLEL) {
-                    this.showWarning(`Invalid --max-parallel value (expected 1..${MAX_ORCHESTRATION_PARALLEL}).`);
+                if (!Number.isInteger(parsed) || parsed < 1) {
+                    this.showWarning("Invalid --max-parallel value (expected integer >= 1).");
                     return undefined;
                 }
                 maxParallel = parsed;
@@ -10692,16 +11044,15 @@ export class InteractiveMode {
     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)));
+            return Math.max(1, 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));
+        return Math.max(1, heuristic);
     }
     resolveSwarmDispatchTimeoutMs() {
         const dispatchTimeoutRaw = Number.parseInt(process.env.IOSM_SWARM_DISPATCH_TIMEOUT_MS ?? "", 10);
@@ -11803,8 +12154,8 @@ export class InteractiveMode {
             if (arg === "--agents") {
                 const value = args[index + 1];
                 const parsed = value ? Number.parseInt(value, 10) : Number.NaN;
-                if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_ORCHESTRATION_AGENTS) {
-                    this.showWarning(`Invalid --agents value (expected 1..${MAX_ORCHESTRATION_AGENTS}).`);
+                if (!Number.isInteger(parsed) || parsed < 1) {
+                    this.showWarning("Invalid --agents value (expected integer >= 1).");
                     return undefined;
                 }
                 agents = parsed;
@@ -11814,8 +12165,8 @@ export class InteractiveMode {
             if (arg === "--max-parallel") {
                 const value = args[index + 1];
                 const parsed = value ? Number.parseInt(value, 10) : Number.NaN;
-                if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_ORCHESTRATION_PARALLEL) {
-                    this.showWarning(`Invalid --max-parallel value (expected 1..${MAX_ORCHESTRATION_PARALLEL}).`);
+                if (!Number.isInteger(parsed) || parsed < 1) {
+                    this.showWarning("Invalid --max-parallel value (expected integer >= 1).");
                     return undefined;
                 }
                 maxParallel = parsed;
@@ -11935,7 +12286,7 @@ export class InteractiveMode {
             return undefined;
         }
         if (mode === "parallel" && maxParallel === undefined) {
-            maxParallel = Math.max(1, Math.min(MAX_ORCHESTRATION_PARALLEL, agents));
+            maxParallel = Math.max(1, agents);
         }
         if (maxParallel !== undefined && maxParallel > agents) {
             maxParallel = agents;
@@ -12068,6 +12419,8 @@ export class InteractiveMode {
             "- 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",
+            "- treat delegates strictly as child task calls; do not count plain tool invocations as delegated agents",
+            "- assign explicit ownership domains per top-level agent to minimize overlap and duplicate findings",
             "- 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",
@@ -14573,6 +14926,7 @@ The agent will automatically receive IOSM context on every turn.`;
             }
             setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
             this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+            this.footer.setCompactModeEnabled(this.getCompactFooterSetting());
             const themeName = this.settingsManager.getTheme();
             const themeResult = themeName ? setTheme(themeName, true) : { success: true };
             if (!themeResult.success) {
@@ -14911,7 +15265,7 @@ The agent will automatically receive IOSM context on every turn.`;
 | \`${cycleThinkingLevel}\` | Cycle thinking level |
 | \`${cycleModelForward}\` | Cycle models |
 | \`${selectModel}\` | Open model selector |
-| \`${expandTools}\` | Toggle tool output expansion |
+| \`${expandTools}\` | Toggle tool/reasoning output expansion |
 | \`${toggleThinking}\` | Toggle thinking block visibility |
 | \`${externalEditor}\` | Edit message in external editor |
 | \`${steer}\` | Queue steer message |