pi-agent-flow 2.2.14 → 2.2.16

package/dist/flow/executor.js

@@ -5,43 +5,24 @@
  * project-flow confirmation, parallel execution with failover, caching,
  * and telemetry.
  */
-import { isFlowSuccess, isFlowError, isFlowComplete, emptyFlowUsage } from "../types/flow.js";
-// ~6 KB limit to keep grouped audit intent under typical prompt budget while preserving enough context for meaningful audit
-const MAX_AUDIT_OUTPUT_SLICE = 6000;
-import { mapFlowConcurrent, runFlow } from "./runner.js";
+import { isFlowSuccess, isFlowError, emptyFlowUsage } from "../types/flow.js";
+import { mapFlowConcurrent } from "./runner.js";
 import { getFlowSummaryText } from "../snapshot/runner-events.js";
-import { normalizeFlowModeName, resolveFlowModelCandidates, resolveModelContextWindow, selectFlowModelStrategy } from "../config/config.js";
-import { getComplexityTimeoutMs, resolveComplexity, getImpliedAuditLoop } from "./complexity.js";
+import { normalizeFlowModeName, selectFlowModelStrategy } from "../config/config.js";
+import { getImpliedAuditLoop } from "./complexity.js";
 import { setFlowComplete } from "../notify/notify-state.js";
 import { setLiveText, clearLiveText } from '../tui/scramble/index.js';
+import { publishFlowLiveText, publishFlowLiveTextAtIndex } from './flow-live.js';
 import { logWarn } from '../config/log.js';
 import { markFlowCompleted } from '../flow/index.js';
-/**
- * Shallow-merge helper: copies audit-loop metadata fields from `source`
- * onto `target` without mutating the target's identity reference.
- * Used whenever a fresh SingleResult overwrites a slot that may already
- * carry ping-pong or parent-type metadata.
- */
-export function preserveMetadata(target, source) {
-    if (source?.pingPongMeta) {
-        target.pingPongMeta = source.pingPongMeta;
-    }
-    if (source?.auditParentType) {
-        target.auditParentType = source.auditParentType;
-    }
-    if (source?.auditLoopGroupId !== undefined) {
-        target.auditLoopGroupId = source.auditLoopGroupId;
-    }
-}
+import { preserveMetadata, getFlowCycleViolations, createGhostResult, } from "./cycle-guard.js";
+import { resolveAuditModel, buildReworkIntent, buildGroupAuditIntent, } from "./audit-formatters.js";
+import { executeSingleFlow } from "./execute-single.js";
+export { preserveMetadata, createGhostResult, shouldFailover } from "./cycle-guard.js";
+export { buildReworkIntent, buildGroupAuditIntent, formatPriorAuditHistory, formatPriorBuildOutputs } from "./audit-formatters.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function getFlowCycleViolations(requestedNames, ancestorFlowStack) {
-    if (requestedNames.size === 0 || ancestorFlowStack.length === 0)
-        return [];
-    const stackSet = new Set(ancestorFlowStack);
-    return Array.from(requestedNames).filter((name) => stackSet.has(name));
-}
 function getRequestedProjectFlows(flows, requestedNames) {
     return Array.from(requestedNames)
         .map((name) => flows.find((f) => f.name === name.toLowerCase()))
@@ -61,274 +42,6 @@ async function confirmProjectFlowsIfNeeded(projectFlows, projectFlowsDir, hasUI,
         blocked: `Blocked: project-local flow confirmation required in non-UI mode.\nFlows: ${names}\nRe-run with confirmProjectFlows: false if trusted.`,
     };
 }
-function shouldFailover(result) {
-    if (result.stopReason === "aborted")
-        return false;
-    const text = `${result.errorMessage ?? ""}\n${result.stderr ?? ""}`.toLowerCase();
-    if (!text.trim())
-        return false;
-    if (text.includes("permission") || text.includes("invalid tool") || text.includes("bad settings")) {
-        return false;
-    }
-    if (result.exitCode > 0)
-        return true;
-    // Some child runs log HTTP 400 / "Param Incorrect" to stderr while exiting 0
-    // without completing a turn — treat as retryable for model failover.
-    if (!isFlowComplete(result) && (text.includes("400") && text.includes("param"))) {
-        return true;
-    }
-    return false;
-}
-export function createGhostResult(type, intent, aim, model, maxContextTokens) {
-    return {
-        type,
-        agentSource: "unknown",
-        intent,
-        aim,
-        exitCode: -1,
-        messages: [],
-        stderr: "",
-        usage: emptyFlowUsage(),
-        ...(model ? { model } : {}),
-        ...(maxContextTokens !== undefined ? { maxContextTokens } : {}),
-    };
-}
-export function resolveAuditModel(flows, tierOverrideResolver, strategy, fallbackModel) {
-    const auditFlow = flows.find((f) => f.name === "audit");
-    const tier = auditFlow?.tier ?? "flash";
-    const { candidates } = resolveFlowModelCandidates({
-        tier,
-        flowModel: auditFlow?.model,
-        cliTierOverride: tierOverrideResolver(tier),
-        strategy,
-        fallbackModel,
-    });
-    const model = candidates[0];
-    const maxContextTokens = resolveModelContextWindow(model);
-    return { model, maxContextTokens };
-}
-export function buildReworkIntent(originalIntent, buildAim, acceptance, auditFeedback, cycleHistory) {
-    const parts = [
-        `## Original Intent`,
-        originalIntent,
-        ``,
-        `## Build Aim`,
-        buildAim,
-        ``,
-    ];
-    if (acceptance) {
-        parts.push(`## Acceptance Criteria`, acceptance, ``);
-    }
-    parts.push(`## Audit Feedback`, auditFeedback, ``);
-    if (cycleHistory && cycleHistory.length > 0) {
-        // Show all prior build outputs (deep-loop: every cycle, not just latest)
-        const buildOutputs = formatPriorBuildOutputs(cycleHistory);
-        if (buildOutputs) {
-            parts.push(buildOutputs, ``);
-        }
-        // Show all prior audit verdicts/feedbacks
-        const auditHistory = formatPriorAuditHistory(cycleHistory);
-        if (auditHistory) {
-            parts.push(auditHistory, ``);
-        }
-    }
-    parts.push(`Fix the above issues, preserving the Original Intent and incorporating all prior cycle feedback.`);
-    return parts.join("\n");
-}
-async function executeSingleFlow(deps, item, allResults, resultIndex, toolCallId, emitProgress, selectedFlowModelConfig) {
-    const { flows, currentDepth, maxDepth, ancestorFlowStack, preventCycles, toolOptimize, structuredOutput, cwd, defaultComplexity, signal, makeDetails, tierOverrideResolver, fallbackModel, forkSessionSnapshotJsonl, onFlowMetrics, goalContext, } = deps;
-    const normalizedType = item.type.toLowerCase();
-    const complexity = resolveComplexity(item.complexity, defaultComplexity);
-    const lookupName = normalizedType;
-    const targetFlow = flows.find((f) => f.name === lookupName);
-    const effectiveMaxDepth = targetFlow?.maxDepth !== undefined ? targetFlow.maxDepth : maxDepth;
-    const shouldInheritContext = targetFlow?.inheritContext !== false;
-    const tier = targetFlow?.tier ?? "flash";
-    const { candidates } = resolveFlowModelCandidates({
-        tier,
-        flowModel: targetFlow?.model,
-        cliTierOverride: tierOverrideResolver(tier),
-        strategy: selectedFlowModelConfig.strategy,
-        fallbackModel,
-    });
-    const attemptModels = candidates.length > 0 ? candidates : [undefined];
-    const attemptedModels = [];
-    let result = allResults[resultIndex];
-    const flowStart = Date.now();
-    for (let attempt = 0; attempt < attemptModels.length; attempt++) {
-        const candidateModel = attemptModels[attempt];
-        if (candidateModel)
-            attemptedModels.push(candidateModel);
-        const attemptStartMs = Date.now();
-        const attemptTimeoutMs = getComplexityTimeoutMs(complexity);
-        const maxContextTokens = resolveModelContextWindow(candidateModel);
-        const previous = allResults[resultIndex];
-        allResults[resultIndex] = {
-            type: normalizedType,
-            agentSource: targetFlow?.source ?? "unknown",
-            intent: item.intent,
-            aim: item.aim,
-            exitCode: -1,
-            messages: [],
-            stderr: "",
-            usage: emptyFlowUsage(),
-            model: candidateModel,
-            startedAtMs: attemptStartMs,
-            deadlineAtMs: attemptStartMs + attemptTimeoutMs,
-            ...(maxContextTokens !== undefined ? { maxContextTokens } : {}),
-        };
-        preserveMetadata(allResults[resultIndex], previous);
-        emitProgress();
-        result = await runFlow({
-            cwd,
-            flows,
-            flowName: lookupName,
-            intent: item.intent,
-            aim: item.aim,
-            acceptance: item.acceptance,
-            taskCwd: item.cwd,
-            forkSessionSnapshotJsonl: shouldInheritContext ? forkSessionSnapshotJsonl : null,
-            parentDepth: currentDepth,
-            parentFlowStack: ancestorFlowStack,
-            maxDepth: effectiveMaxDepth,
-            preventCycles,
-            toolOptimize,
-            structuredOutput,
-            complexity,
-            model: candidateModel,
-            maxContextTokens,
-            goalContext,
-            debugMode: deps.debugMode,
-            tools: item._childTools,
-            preDispatchResults: item.preDispatchResults,
-            signal,
-            onUpdate: (partial) => {
-                if (partial.details?.results[0]) {
-                    const previous = allResults[resultIndex];
-                    allResults[resultIndex] = partial.details.results[0];
-                    preserveMetadata(allResults[resultIndex], previous);
-                    const flowText = partial.content?.[0]?.text;
-                    if (flowText !== undefined) {
-                        setLiveText(`${toolCallId || 'collapsed'}#${resultIndex}`, flowText);
-                        setLiveText(`collapsed#${resultIndex}`, flowText);
-                    }
-                    emitProgress(partial.content?.[0]?.text);
-                }
-            },
-            makeDetails,
-        });
-        const previous2 = allResults[resultIndex];
-        allResults[resultIndex] = result;
-        preserveMetadata(allResults[resultIndex], previous2);
-        emitProgress();
-        if (isFlowSuccess(result) || signal?.aborted)
-            break;
-        if (attempt < attemptModels.length - 1 && shouldFailover(result)) {
-            continue;
-        }
-        break;
-    }
-    if (result && !isFlowSuccess(result) && attemptedModels.length > 1) {
-        const summary = `Model failover attempts: ${attemptedModels.join(" -> ")}`;
-        const baseStderr = result.stderr.trim();
-        result.stderr = baseStderr ? `${baseStderr}\n\n${summary}` : summary;
-        const previous3 = allResults[resultIndex];
-        allResults[resultIndex] = result;
-        preserveMetadata(allResults[resultIndex], previous3);
-        emitProgress();
-    }
-    if (onFlowMetrics) {
-        const flowDuration = Date.now() - flowStart;
-        onFlowMetrics({
-            type: normalizedType,
-            durationMs: flowDuration,
-            exitCode: result.exitCode,
-            success: isFlowSuccess(result),
-            model: result.model,
-            failoverCount: Math.max(0, attemptedModels.length - 1),
-            usage: result.usage,
-            source: result.agentSource,
-            depth: currentDepth + 1,
-        });
-    }
-    return result;
-}
-export function formatPriorAuditHistory(entries) {
-    if (entries.length === 0)
-        return "";
-    const lines = entries.map((e) => {
-        const parts = [
-            `**Cycle ${e.cycle + 1}**`,
-            `- Verdict: ${e.verdict}`,
-        ];
-        if (e.feedback) {
-            parts.push(`- Feedback: ${e.feedback.slice(0, 2000)}`);
-        }
-        if (e.buildFeedbacks && e.buildFeedbacks.length > 0) {
-            parts.push(`- Per-Build Feedback:`);
-            e.buildFeedbacks.forEach((fb, i) => {
-                if (fb) {
-                    parts.push(`  - Build ${i + 1}: ${fb.slice(0, 1500)}`);
-                }
-                else {
-                    parts.push(`  - Build ${i + 1}: pass`);
-                }
-            });
-        }
-        return parts.join("\n");
-    });
-    return `## Prior Audit History\n\n${lines.join("\n\n")}`;
-}
-export function formatPriorBuildOutputs(entries) {
-    if (entries.length === 0)
-        return "";
-    const lines = entries.map((e) => {
-        const parts = [`**Cycle ${e.cycle + 1}**`];
-        if (e.buildOutputs.length > 0) {
-            parts.push(`- Build Outputs:`);
-            e.buildOutputs.forEach((bo, i) => {
-                parts.push(`  - Build ${i + 1}: ${bo.slice(0, 3000)}`);
-            });
-        }
-        return parts.join("\n");
-    });
-    return `## Prior Build Outputs\n\n${lines.join("\n\n")}`;
-}
-export function buildGroupAuditIntent(builds, cycleHistory) {
-    const sections = builds.map((b, i) => {
-        const section = [
-            `### Build ${i + 1}`,
-            ``,
-            `## Build Aim`,
-            b.aim,
-            ``,
-        ];
-        if (b.acceptance) {
-            section.push(`## Acceptance Criteria`, b.acceptance, ``);
-        }
-        if (b.intent) {
-            section.push(`## Build Intent`, b.intent, ``);
-        }
-        section.push(`## Build Output`, b.output.slice(0, MAX_AUDIT_OUTPUT_SLICE));
-        return section.join("\n");
-    });
-    const parts = [
-        ...sections,
-        ``,
-    ];
-    if (cycleHistory && cycleHistory.length > 0) {
-        const auditHistory = formatPriorAuditHistory(cycleHistory);
-        if (auditHistory) {
-            parts.push(auditHistory, ``);
-        }
-        const buildOutputs = formatPriorBuildOutputs(cycleHistory);
-        if (buildOutputs) {
-            parts.push(buildOutputs, ``);
-        }
-    }
-    parts.push(`Check for: security issues, correctness, completeness, edge cases, and any overlooked requirements per build. For each build, indicate whether it passes or needs rework with specific actionable feedback.`);
-    return parts.join("\n\n");
-}
 async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitProgress, selectedFlowModelConfig) {
     const { items, auditLoop, buildIndices, auditIndex } = group;
     const maxCycles = (auditLoop ?? 0) + 1;
@@ -336,8 +49,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
     const verdictHistory = [];
     const cycleHistory = [];
     const auditFeedbacks = new Array(items.length).fill(null);
-    // Initialize all slots (re-creates ghosts; must stamp auditLoopGroupId
-    // because executeFlows pre-allocation gets overwritten here).
     for (let i = 0; i < items.length; i++) {
         allResults[buildIndices[i]] = createGhostResult(items[i].type, items[i].intent, items[i].aim);
         allResults[buildIndices[i]].status = "running";
@@ -352,7 +63,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
     const key = toolCallId || 'collapsed';
     const buildResults = new Array(items.length);
     while (cycle < maxCycles) {
-        // ─── Phase A: Run all builds in parallel ───
         for (let i = 0; i < items.length; i++) {
             allResults[buildIndices[i]].status = "running";
             allResults[buildIndices[i]].exitCode = -1;
@@ -366,7 +76,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
         setLiveText(`${key}#${auditIndex}`, "[awaiting...]");
         setLiveText(`collapsed#${auditIndex}`, "[awaiting...]");
         emitProgress();
-        // Run all builds in parallel
         const buildPromises = items.map((item, i) => {
             const buildInput = cycle > 0
                 ? buildReworkIntent(item.intent, item.aim, item.acceptance, auditFeedbacks[i] ?? "No issues found.", cycleHistory)
@@ -385,7 +94,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
             allResults[buildIndices[i]].deadlineAtMs = undefined;
         }
         emitProgress();
-        // Check if any build failed
         const anyBuildFailed = buildResults.some(r => !isFlowSuccess(r));
         if (anyBuildFailed) {
             const { model: skipAuditModel, maxContextTokens: skipAuditMaxCtx } = resolveAuditModel(deps.flows, deps.tierOverrideResolver, selectedFlowModelConfig.strategy, deps.fallbackModel);
@@ -400,7 +108,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
             emitProgress();
             break;
         }
-        // ─── Phase B: Run ONE audit that reviews all builds ───
         for (let i = 0; i < items.length; i++) {
             allResults[buildIndices[i]].status = "awaiting";
             clearLiveText(`${key}#${buildIndices[i]}`);
@@ -429,7 +136,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
         const auditResult = await executeSingleFlow(deps, auditItem, allResults, auditIndex, toolCallId, emitProgress, selectedFlowModelConfig);
         auditResult.auditParentType = items[0].type;
         allResults[auditIndex] = auditResult;
-        // Parse per-build verdicts
         const perBuildVerdicts = auditResult.structuredOutput?.builds;
         const topLevelVerdict = auditResult.structuredOutput?.verdict ?? "pass";
         const topLevelFeedback = auditResult.structuredOutput?.feedback;
@@ -447,7 +153,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
             }
         }
         else {
-            // Fallback: top-level verdict applies to all builds
             if (topLevelVerdict === "rework") {
                 for (let i = 0; i < items.length; i++) {
                     auditFeedbacks[i] = topLevelFeedback ?? "Fix issues found in audit.";
@@ -480,12 +185,10 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
             break;
         }
         if (cycle + 1 >= maxCycles) {
-            break; // Loop exhausted
+            break;
         }
         cycle++;
-        // Continue loop — builds needing rework will re-run
     }
-    // Finalize: set real exit codes
     for (let i = 0; i < items.length; i++) {
         allResults[buildIndices[i]].exitCode = isFlowSuccess(buildResults[i]) ? 0 : (buildResults[i].exitCode > 0 ? buildResults[i].exitCode : 1);
         allResults[buildIndices[i]].status = isFlowSuccess(buildResults[i]) ? "done" : "error";
@@ -497,7 +200,6 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
         allResults[auditIndex].exitCode = isFlowSuccess(allResults[auditIndex]) ? 0 : (allResults[auditIndex].exitCode > 0 ? allResults[auditIndex].exitCode : 1);
         allResults[auditIndex].status = "done";
     }
-    // Populate pingPongMeta on each build result
     for (let i = 0; i < items.length; i++) {
         allResults[buildIndices[i]].pingPongMeta = {
             cycles: cycle + 1,
@@ -505,20 +207,22 @@ async function executeGroupedPingPong(deps, group, allResults, toolCallId, emitP
             finalVerdict: allResults[auditIndex].structuredOutput?.verdict ?? (allResults[auditIndex].status === "skipped" ? "fail" : "pass"),
         };
     }
+    if (allResults[auditIndex].status !== "skipped") {
+        allResults[auditIndex].pingPongMeta = {
+            cycles: cycle + 1,
+            verdicts: verdictHistory,
+            finalVerdict: allResults[auditIndex].structuredOutput?.verdict ?? "pass",
+        };
+    }
     emitProgress();
     return buildResults;
 }
 // ---------------------------------------------------------------------------
 // FlowExecutor
 // ---------------------------------------------------------------------------
-/**
- * Execute a set of flow tasks with full orchestration: cycle detection,
- * project confirmation, parallel execution with model failover, and telemetry.
- */
 export async function executeFlows(deps, params, toolCallId, auditLoop) {
     const { flows, currentDepth, maxDepth, ancestorFlowStack, preventCycles, toolOptimize, structuredOutput, cwd, loadedFlowModelConfigs, maxConcurrency, defaultComplexity, signal, onUpdate, makeDetails, getFlag, tierOverrideResolver, fallbackModel, forkSessionSnapshotJsonl, projectFlowsDir, hasUI, uiConfirm, onFlowMetrics, confirmProjectFlows, goalContext, } = deps;
     const requested = new Set(params.map((f) => f.type.toLowerCase()));
-    // Cycle check
     if (preventCycles) {
         const violations = getFlowCycleViolations(requested, ancestorFlowStack);
         if (violations.length > 0) {
@@ -533,7 +237,6 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
             };
         }
     }
-    // Project flow confirmation
     const projectFlows = getRequestedProjectFlows(flows, requested);
     if (projectFlows.length > 0 && confirmProjectFlows !== false) {
         const { ok, blocked } = await confirmProjectFlowsIfNeeded(projectFlows, projectFlowsDir, hasUI, uiConfirm);
@@ -545,18 +248,15 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
             };
         }
     }
-    // Resolve model strategy
     const cliFlowMode = normalizeFlowModeName(getFlag("flow-mode"));
     const cliFlowModelConfig = normalizeFlowModeName(getFlag("flow-model-config"));
     if (cliFlowMode !== undefined && cliFlowModelConfig !== undefined && cliFlowMode !== cliFlowModelConfig) {
         logWarn(`[pi-agent-flow] Both --flow-mode "${cliFlowMode}" and --flow-model-config "${cliFlowModelConfig}" were provided. Using --flow-mode.`);
     }
     const selectedFlowModelConfig = selectFlowModelStrategy(loadedFlowModelConfigs.configs, cliFlowMode ?? cliFlowModelConfig ?? loadedFlowModelConfigs.selectedName);
-    // Partition params into regular and grouped ping-pong flows
     const regularParams = [];
     const regularIndices = [];
     const groups = [];
-    // Compute effective audit loop per build = max(explicit override, complexity-implied)
     const effectiveAuditLoops = params.map((p) => {
         if (p.type.toLowerCase() === "build") {
             return Math.max(auditLoop ?? 0, getImpliedAuditLoop(p.complexity));
@@ -583,8 +283,8 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
                     items: [params[i]],
                     auditLoop: effectiveAuditLoops[i],
                     buildIndices: [buildIndex],
-                    auditIndex: -1, // placeholder; assigned after all builds
-                    groupId: -1, // placeholder; set after auditIndex is assigned
+                    auditIndex: -1,
+                    groupId: -1,
                 };
                 groups.push(buildGroup);
             }
@@ -593,17 +293,14 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
             regularIndices.push(nextIndex);
             regularParams.push(params[i]);
             nextIndex++;
-            // Non-build param breaks contiguity — reset so later builds start a new group
             buildGroup = undefined;
         }
     }
-    // Assign audit indices after all builds are allocated
     let groupCounter = 0;
     for (const group of groups) {
         group.auditIndex = nextIndex++;
         group.groupId = groupCounter++;
     }
-    // Pre-allocate results array
     const allResults = new Array(nextIndex);
     for (let i = 0; i < regularParams.length; i++) {
         const idx = regularIndices[i];
@@ -633,7 +330,6 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
         allResults[group.auditIndex].auditParentType = "build";
         allResults[group.auditIndex].auditLoopGroupId = group.groupId;
     }
-    // Streaming progress
     let lastEmittedSignature;
     const emitProgress = (streamingText) => {
         const activeStreamingText = allResults
@@ -642,18 +338,24 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
             .filter((text) => Boolean(text))
             .at(-1);
         const text = streamingText ?? activeStreamingText ?? "";
-        // Update live text store FIRST — always
-        const key = toolCallId || 'collapsed';
-        setLiveText(key, text);
-        setLiveText('collapsed', text);
-        for (let i = 0; i < allResults.length; i++) {
-            const r = allResults[i];
-            if (r.streamingText) {
-                setLiveText(`${key}#${i}`, r.streamingText);
-                setLiveText(`collapsed#${i}`, r.streamingText);
+        if (toolCallId) {
+            publishFlowLiveText(toolCallId, text);
+            for (let i = 0; i < allResults.length; i++) {
+                const r = allResults[i];
+                if (r.streamingText) {
+                    publishFlowLiveTextAtIndex(toolCallId, i, r.streamingText);
+                }
+            }
+        }
+        else {
+            setLiveText("collapsed", text);
+            for (let i = 0; i < allResults.length; i++) {
+                const r = allResults[i];
+                if (r.streamingText) {
+                    setLiveText(`collapsed#${i}`, r.streamingText);
+                }
             }
         }
-        // Now check onUpdate for host callback
         if (!onUpdate)
             return;
         const signature = text +
@@ -678,15 +380,12 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
         }
         catch (err) {
             if (err instanceof Error && err.message.includes("outside active run")) {
-                // Agent listener invoked from async callback (child stdout handler)
-                // after the active run context ended. Safe to drop this update.
                 return;
             }
             throw err;
         }
     };
     emitProgress();
-    // Execute all flows
     const executionStart = Date.now();
     const regularPromise = regularParams.length > 0
         ? mapFlowConcurrent(regularParams, maxConcurrency, async (item, localIndex) => {
@@ -697,19 +396,14 @@ export async function executeFlows(deps, params, toolCallId, auditLoop) {
     const groupPromises = groups.map((group) => executeGroupedPingPong(deps, group, allResults, toolCallId, emitProgress, selectedFlowModelConfig));
     await Promise.all([regularPromise, ...groupPromises]);
     const results = [...allResults];
-    // Record last flow completion for dynamic notifications
     const lastResult = results[results.length - 1];
     if (lastResult) {
         setFlowComplete(lastResult.type, lastResult.acceptance, results.length - 1, results.length);
     }
-    // Mark flow completion for the continuation hold — gives the user
-    // time to read the result before the next flow auto-spawns.
     markFlowCompleted(deps.sessionManager.getSessionId());
-    // Goal continuation callback
     if (deps.goalContinuationCallback) {
         await deps.goalContinuationCallback(results);
     }
-    // Build tool result
     const successCount = results.filter((r) => isFlowSuccess(r)).length;
     const flowReports = results.map((r) => {
         const output = getFlowSummaryText(r);