pi-agent-flow 2.0.2 → 2.0.6

package/dist/index.js

@@ -6,185 +6,164 @@
  */
 import { Type } from "@sinclair/typebox";
 import { setupNotify } from "./notify/notify.js";
-import { discoverFlows, getFlowTier } from "./core/agents.js";
+import { discoverFlows, getFlowTier } from "./flow/agents.js";
 import { getInheritedCliArgs } from "./snapshot/cli-args.js";
 import { renderFlowCall, renderFlowResult } from "./tui/render.js";
-import { terminateAllChildGroups } from "./core/flow.js";
-import { executeFlows, evictCacheOverflow } from "./core/executor.js";
+import { DEFAULT_FLOW_COLORS } from "./tui/flow-colors.js";
+import { terminateAllChildGroups } from "./flow/runner.js";
+import { executeFlows } from "./flow/executor.js";
 import { appendDirectiveOnce, resetDirectiveTracker, configureDirective, stripDirectivesFromMessages } from "./steering/tool-utils.js";
-import { createBatchTool, createBatchReadTool, BashProcessTracker, createBatchBashPollTool, } from "./batch/index.js";
-import { createWebTool } from "./tools/web-tool.js";
+import { createBatchTool, createBatchReadTool, BashProcessTracker, createBatchBashPollTool, runBashWithLimits, } from "./batch/index.js";
 import { createAskUserTool } from "./tools/ask-user.js";
 import { stripSteeringHintText, stripSteeringHintsFromMessages, makeSteeringHintMessage, configureSteering, } from "./steering/sliding-prompt.js";
 import { registerFlow, getGoal, getGoalForSession, recordFlowCompletion, addTokens, shutdownWakeup } from "./flow/index.js";
-import * as sessionRegistry from "./core/session-registry.js";
+import * as sessionRegistry from "./flow/session-registry.js";
 import { createTimedBashToolDefinition } from "./tools/timed-bash.js";
-import { resolveFlowDepthConfig, } from "./core/depth.js";
-import { buildForkSessionSnapshotJsonl, sanitizeForkSnapshot, } from "./snapshot/snapshot.js";
+import { createTraceTool } from "./tools/trace.js";
+import { executeOperations } from "./batch/execute.js";
+import { runWebOps } from "./tools/web-ops.js";
+import { resolveFlowDepthConfig, } from "./flow/depth.js";
+import { buildCore2Snapshot } from "./core2/snapshot.js";
 import { resolveSettings, } from "./config/settings-resolver.js";
 import { scrambleManager } from "./tui/scramble/index.js";
 import { logWarn, logError } from "./config/log.js";
 export { logWarn, logError };
-// ---------------------------------------------------------------------------
-// Persistent flow result cache — shared across execute() calls so historical
-// flow results are compressed properly in fork snapshots.
-// ---------------------------------------------------------------------------
-const flowResultCache = new Map();
-/**
- * Reconstruct flowResultCache from an existing session branch after restart.
- * Scans tool results for the "flow" tool and rebuilds CompressedFlowResult
- * entries so child-fork compression works immediately without waiting for
- * new flows to complete.
- */
-function reconstructFlowResultCache(sessionManager, cache) {
-    const branch = sessionManager.getBranch();
-    if (!Array.isArray(branch) || branch.length === 0)
-        return;
-    // Pass 1: map toolCallId -> "flow" from assistant messages
-    const toolCallIdToName = new Map();
-    for (const entry of branch) {
-        if (!entry || typeof entry !== "object")
-            continue;
-        const e = entry;
-        if (e.type !== "message")
-            continue;
-        const msg = e.message;
-        if (!msg || msg.role !== "assistant")
-            continue;
-        const content = msg.content;
-        if (!Array.isArray(content))
-            continue;
-        for (const part of content) {
-            if (!part || typeof part !== "object")
-                continue;
-            const p = part;
-            if (p.type === "toolCall" && p.name === "flow") {
-                const tcId = (p.id ?? p.toolCallId);
-                if (tcId)
-                    toolCallIdToName.set(tcId, "flow");
-            }
-        }
-    }
-    // Pass 2: scan tool/toolResult messages and rebuild cache
-    for (const entry of branch) {
-        if (!entry || typeof entry !== "object")
-            continue;
-        const e = entry;
-        if (e.type !== "message")
-            continue;
-        const msg = e.message;
-        if (!msg || (msg.role !== "tool" && msg.role !== "toolResult"))
-            continue;
-        let toolCallId;
-        if (typeof msg.toolCallId === "string" && msg.toolCallId.trim()) {
-            toolCallId = msg.toolCallId;
-        }
-        else if (Array.isArray(msg.content)) {
-            for (const part of msg.content) {
-                if (!part || typeof part !== "object")
-                    continue;
-                const p = part;
-                if (p.type === "toolResult" && typeof p.toolCallId === "string" && p.toolCallId.trim()) {
-                    toolCallId = p.toolCallId;
-                    break;
-                }
-            }
-        }
-        if (!toolCallId || toolCallIdToName.get(toolCallId) !== "flow")
-            continue;
-        const details = msg.details;
-        if (!details || !Array.isArray(details.results))
-            continue;
-        const results = details.results;
-        const compressed = [];
-        for (const r of results) {
-            const so = r.structuredOutput;
-            if (!so)
-                continue;
-            const c = {
-                type: typeof r.type === "string" ? r.type : "unknown",
-                status: typeof r.exitCode === "number" && r.exitCode === 0 ? "accomplished" : "failed",
-            };
-            if (typeof r.intent === "string")
-                c.intent = r.intent;
-            if (typeof r.aim === "string")
-                c.aim = r.aim;
-            if (typeof so.summary === "string")
-                c.summary = so.summary;
-            if (Array.isArray(so.files))
-                c.files = so.files;
-            if (Array.isArray(so.actions))
-                c.actions = so.actions;
-            if (Array.isArray(so.commands))
-                c.commands = so.commands;
-            if (Array.isArray(so.notDone))
-                c.notDone = so.notDone;
-            if (Array.isArray(so.nextSteps))
-                c.nextSteps = so.nextSteps;
-            if (Array.isArray(so.reasoning))
-                c.reasoning = so.reasoning;
-            if (Array.isArray(so.notes))
-                c.notes = so.notes;
-            if (typeof r.errorMessage === "string")
-                c.error = r.errorMessage;
-            compressed.push(c);
-        }
-        if (compressed.length > 0) {
-            const existing = cache.get(toolCallId) ?? [];
-            existing.push(...compressed);
-            cache.set(toolCallId, existing);
-        }
-    }
-    evictCacheOverflow(cache);
-}
 import { computeActiveTools, buildBeforeAgentStartPrompt, } from "./steering/flow-prompt.js";
 // ---------------------------------------------------------------------------
 // Tool parameter schema
 // ---------------------------------------------------------------------------
+const BatchDispatchOp = Type.Object({
+    tool: Type.Literal("batch"),
+    ops: Type.Array(Type.Object({
+        o: Type.String(),
+        p: Type.String(),
+        c: Type.Optional(Type.String()),
+        e: Type.Optional(Type.Array(Type.Object({ f: Type.String(), r: Type.String() }))),
+        s: Type.Optional(Type.Number()),
+        l: Type.Optional(Type.Union([Type.Number(), Type.Boolean()])),
+        i: Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
+        t: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+        h: Type.Optional(Type.String()),
+        q: Type.Optional(Type.String()),
+        n: Type.Optional(Type.Number()),
+        u: Type.Optional(Type.Number()),
+    }), { description: "File/batch operations matching the batch tool schema." }),
+});
+const BashDispatchOp = Type.Object({
+    tool: Type.Literal("bash"),
+    ops: Type.Array(Type.Object({
+        c: Type.String({ description: "Shell command" }),
+        h: Type.Optional(Type.String({ description: "Working directory override" })),
+        t: Type.Optional(Type.Number({ description: "Timeout in ms" })),
+    }), { description: "Bash command objects." }),
+});
+const WebDispatchOp = Type.Object({
+    tool: Type.Literal("web"),
+    ops: Type.Array(Type.Object({
+        o: Type.Union([Type.Literal("search"), Type.Literal("fetch")]),
+        q: Type.Optional(Type.String()),
+        u: Type.Optional(Type.String()),
+        f: Type.Optional(Type.String()),
+    }), { description: "Web operations matching the web tool schema." }),
+});
+const DispatchOpSchema = Type.Union([BatchDispatchOp, BashDispatchOp, WebDispatchOp], {
+    description: "Pre-dispatch tool call with discriminated tool type and typed ops array.",
+});
 const FlowItem = Type.Object({
     type: Type.String({
-        description: "Flow type. Matching is case-insensitive. Must correspond to an available flow name such as scout, debug, build, craft, audit, or ideas.",
+        description: "Flow type (scout, debug, build, craft, audit, ideas).",
     }),
     intent: Type.String({
-        description: "Specific mission for this flow — target concrete files, folders, or code patterns. Be precise in final outcome/expectation and common sense, but avoid over-specifying implementation details or assuming current state that may have shifted.",
+        description: "Detailed mission for this flow.",
     }),
     aim: Type.String({
-        description: "Extreme short intent — one sentence, 5-7 words, headline-style summary of what this flow does.",
+        description: "Short (5-7 words) headline summary.",
     }),
-    acceptance: Type.Optional(Type.String({ description: "Short success criteria — one sentence stating what done looks like." })),
-    cwd: Type.Optional(Type.String({ description: "Working directory override for this flow." })),
-    sessionMode: Type.Optional(Type.Union([
+    acceptance: Type.Optional(Type.String({ description: "Success criteria for the task." })),
+    cwd: Type.Optional(Type.String({ description: "Working directory override." })),
+    complexity: Type.Union([
         Type.Literal("snap"),
-        Type.Literal("fast"),
-        Type.Literal("default"),
-        Type.Literal("long"),
-        Type.Literal("extreme_long"),
+        Type.Literal("simple"),
+        Type.Literal("moderate"),
+        Type.Literal("complex"),
+        Type.Literal("intricate"),
     ], {
-        description: "Agent session budget for this flow: snap=90s, fast=300s, default=600s, long=900s, extreme_long=1200s. Use long or extreme_long only when the work genuinely needs the larger budget.",
+        description: "Budget/Audit level: snap (120s), simple (300s), moderate (600s), complex (900s), intricate (1200s).",
+    }),
+    dispatch: Type.Optional(Type.Array(DispatchOpSchema, {
+        description: "Tools to run before the flow starts (results are injected into the prompt).",
     })),
 }, {
     title: "FlowTask",
-    description: "A single flow task — must be a JSON object, NOT a string.",
+    description: "A single flow task object.",
 });
 const FlowParams = Type.Object({
     flow: Type.Array(FlowItem, {
-        description: "Array of flow tasks to execute. Each runs in its own forked process. " +
-            "Optional sessionMode selects the flow state budget: fast=300s, default=600s, long=900s, extreme_long=1200s.",
-        examples: [
-            { type: "scout", intent: "Map auth module files and trace JWT validation path", aim: "Map auth and trace JWT" },
-            { type: "audit", intent: "Audit input validation and SQL injection risks in user routes", aim: "Audit user route security" },
-        ],
+        description: "Specialized flow tasks to dive into.",
         minItems: 1,
     }),
     confirmProjectFlows: Type.Optional(Type.Boolean({
-        description: "Whether to prompt the user before running project-local flows. Default: true.",
+        description: "Prompt before running local flows. Default: true.",
         default: true,
     })),
+    auditLoop: Type.Optional(Type.Number({
+        description: "Override audit cycles (0-3).",
+        default: 0,
+        minimum: 0,
+        maximum: 3,
+    })),
+}, {
+    title: "FlowToolParams",
+    description: "The root object MUST contain a 'flow' array. Never flatten fields to the root.",
+    examples: [{
+            flow: [{ type: "scout", intent: "Map auth module files", aim: "Map auth module", complexity: "moderate" }],
+        }],
 });
 const inheritedCliArgs = getInheritedCliArgs();
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+async function executeDispatchOps(dispatch, cwd, ctx, signal) {
+    const parts = [];
+    let toolCallIndex = 0;
+    for (const group of dispatch) {
+        if (signal?.aborted)
+            break;
+        const toolCallId = `pre_dispatch_${group.tool}_${toolCallIndex++}`;
+        try {
+            if (group.tool === "batch") {
+                // Separate file ops from bash ops
+                const fileOps = group.ops.filter((op) => op.o !== "bash");
+                const bashOps = group.ops.filter((op) => op.o === "bash");
+                if (fileOps.length > 0) {
+                    const fileOutput = await executeOperations(fileOps, cwd, signal, { includeLimitWarnings: true });
+                    parts.push(`### batch (file ops)\n\ntool_call_id: ${toolCallId}\n\n${fileOutput.contentText}`);
+                }
+                if (bashOps.length > 0) {
+                    for (const op of bashOps) {
+                        const { stdout, stderr, exitCode } = await runBashWithLimits(op.c ?? "", op.h ?? cwd, op.t ?? 30000, signal);
+                        parts.push(`### bash [${op.i ?? "auto"}] exit ${exitCode}\n\ntool_call_id: ${toolCallId}\n\n${stdout}${stderr ? `\n[stderr]\n${stderr}` : ""}`);
+                    }
+                }
+            }
+            else if (group.tool === "bash") {
+                for (const cmd of group.ops) {
+                    const { stdout, stderr, exitCode } = await runBashWithLimits(cmd.c, cmd.h ?? cwd, cmd.t ?? 30000, signal);
+                    parts.push(`### bash\n\ntool_call_id: ${toolCallId}\n\n--- bash exit ${exitCode} ---\n${stdout}${stderr ? `\n[stderr]\n${stderr}` : ""}`);
+                }
+            }
+            else if (group.tool === "web") {
+                const webOutput = await runWebOps({ op: group.ops }, ctx, signal);
+                parts.push(`### web\n\ntool_call_id: ${toolCallId}\n\n${webOutput.content[0].text}`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            parts.push(`### ${group.tool} (error)\n\ntool_call_id: ${toolCallId}\n\nPre-dispatch failed: ${message}`);
+        }
+    }
+    return parts.join("\n\n---\n\n");
+}
 function makeFlowDetailsFactory(projectFlowsDir) {
     return (results) => ({
         mode: "flow",
@@ -193,8 +172,6 @@ function makeFlowDetailsFactory(projectFlowsDir) {
         results,
     });
 }
-// Re-export compressToolResults and stripBatchReadToolCalls for tests
-export { compressToolResults, stripBatchReadToolCalls } from "./snapshot/snapshot.js";
 // ---------------------------------------------------------------------------
 // Extension entry point
 // ---------------------------------------------------------------------------
@@ -231,8 +208,8 @@ export default function (pi) {
         description: "Maximum number of flows to execute in parallel (default: 4).",
         type: "string",
     });
-    pi.registerFlag("flow-session-mode", {
-        description: "Default child-flow session mode: snap (90s), fast (300s), default (600s), long (900s), or extreme_long (1200s).",
+    pi.registerFlag("flow-complexity", {
+        description: "Default child-flow complexity: snap (120s no review), simple (300s no review), moderate (600s 1x audit), complex (900s 2x audit), or intricate (1200s 3x audit).",
         type: "string",
     });
     pi.registerFlag("tool-optimize", {
@@ -259,6 +236,14 @@ export default function (pi) {
         description: "Disable glitch/scramble effect.",
         type: "boolean",
     });
+    pi.registerFlag("body-lite", {
+        description: "Use lite collapsed body mode (aim + cmd only).",
+        type: "boolean",
+    });
+    pi.registerFlag("body-full", {
+        description: "Use full collapsed body mode (aim + cmd + msg).",
+        type: "boolean",
+    });
     // Wire up bundled notification channel
     setupNotify(pi);
     // Wire up /flow command and continuation hooks
@@ -273,11 +258,6 @@ export default function (pi) {
         sessionRegistry.register(ctx.cwd, ctx.sessionManager.getSessionId());
         _sessionCtx = ctx;
         resolved = resolveSettings(pi, ctx.cwd);
-        // Reconstruct historical flow result cache so fork snapshots can compress
-        // past flow results immediately (instead of showing placeholder text until
-        // new flows complete). bashTracker is created fresh below — pending OS
-        // processes are inherently lost across restarts, which is expected.
-        reconstructFlowResultCache(ctx.sessionManager, flowResultCache);
         // Wire resolved settings to modules
         configureSteering({ enabled: resolved.steeringEnabled, customPrompt: resolved.steeringCustomPrompt });
         configureDirective(resolved.steeringStrategicHint);
@@ -289,17 +269,14 @@ export default function (pi) {
             pi.setActiveTools(computeActiveTools(resolved.toolOptimize));
         }
         // Register tools based on depth.
-        // Depth 0 (main root state): only batch_read — no bash ops, only reads + flow tool.
+        // Depth 0 (main root state): batch_read + no bash ops.
         // Depth > 0 (child flows): batch (with bash), batch_bash_poll — they need bash ops.
-        // Children use batch for reads (which includes read ops), so batch_read is NOT
-        // registered for depth > 0 to avoid confusion and keep the tool set minimal.
+        // batch_read is registered at all depths for trace and read-only child operations.
         // The bashProcessTracker is shared between the batch tool (launches bash ops)
         // and the batch_bash_poll tool (checks on pending bash ops).
         if (resolved.toolOptimize) {
-            if (currentDepth === 0) {
-                pi.registerTool(createBatchReadTool());
-            }
-            else {
+            pi.registerTool(createBatchReadTool());
+            if (currentDepth > 0) {
                 bashTracker = new BashProcessTracker();
                 pi.registerTool(createBatchTool(bashTracker, resolved.toolOptimize));
                 pi.registerTool(createBatchBashPollTool(bashTracker));
@@ -316,7 +293,6 @@ export default function (pi) {
     });
     // Clean up global mutable state on session shutdown
     pi.on("session_shutdown", () => {
-        flowResultCache.clear();
         _sessionCtx = undefined;
         // bashTracker and its pending OS processes are discarded on restart.
         // This is expected — child process state is not serializable.
@@ -342,11 +318,34 @@ export default function (pi) {
     pi.on("before_agent_start", async (event) => {
         if (currentDepth > 0 || !resolved)
             return undefined;
-        const augmented = buildBeforeAgentStartPrompt(event, resolved.toolOptimize, canTransition, resolved.discoveredFlows, depthConfig);
+        const augmented = buildBeforeAgentStartPrompt(event, resolved.toolOptimize);
         if (augmented === undefined)
             return undefined;
         return { systemPrompt: augmented };
     });
+    // Compaction: inject flow context into the summarization prompt.
+    pi.on("session_before_compact", async (event, ctx) => {
+        const goal = getGoal(ctx.cwd);
+        if (!goal)
+            return undefined;
+        const completed = goal.completedFlows.slice(-3);
+        const flowSummary = completed.length > 0
+            ? `\nRecently completed flows:\n${completed.map(f => `- [${f.type}] ${f.aim}`).join("\n")}`
+            : "";
+        const injection = `\n\n[Flow Context]\nCurrent Goal: ${goal.objective}${goal.acceptance ? `\nAcceptance: ${goal.acceptance}` : ""}${flowSummary}\nMaintain this goal and status in the summary.`;
+        return { prompt: (event.prompt || "") + injection };
+    });
+    // Compaction: re-anchor flow context after summarization.
+    pi.on("session_compact", async (_event, ctx) => {
+        const goal = getGoal(ctx.cwd);
+        if (!goal)
+            return;
+        // Send a non-displaying message to re-anchor the agent to its goal.
+        pi.sendMessage({
+            content: `[Flow Re-anchor] Compaction completed. Current Goal: ${goal.objective}. Continue execution.`,
+            display: false,
+        }, { triggerTurn: false });
+    });
     // Steering hint: insert as a separate system message immediately
     // before the latest user message each turn. The steering hint is never
     // part of the static systemPrompt — it is injected dynamically here only.
@@ -413,31 +412,25 @@ export default function (pi) {
         }
         return result;
     });
-    // Register the web tool
-    pi.registerTool(createWebTool());
     // Register the ask_user tool
     pi.registerTool(createAskUserTool());
+    // Register the trace tool (available at all depths — spawns a lightweight child reflection flow)
+    pi.registerTool(createTraceTool({
+        getSettings: () => resolved ? { toolOptimize: resolved.toolOptimize, structuredOutput: resolved.structuredOutput, bodyVerbosity: resolved.bodyVerbosity } : undefined,
+        getDepthConfig: () => depthConfig,
+    }));
     // Register the flow tool
     if (canTransition) {
         pi.registerTool({
             name: "flow",
             label: "Flow",
-            promptSnippet: "Transition to specialized agent flows running in isolated forked processes",
+            promptSnippet: "Dive into specialized flows (scout, debug, build, craft, audit, ideas) via a `flow` array.",
             promptGuidelines: [
-                "Use `flow` when the task requires skills beyond your current context (scout, debug, build, craft, audit, ideas).",
-                "Combine multiple related tasks into a single `flow` call with an array of flow items.",
-                "Always provide a concrete intent, aim, and optional acceptance criteria.",
+                "Combine multiple tasks into a single `flow` array call.",
+                "Each task requires `type`, `intent`, `aim`, and `complexity`.",
+                "All tasks MUST be nested inside the `flow` array.",
             ],
-            description: [
-                "If you cannot answer from your current context, you are forbidden from guessing.",
-                "You MUST enter to the following flow states, with tool call method.",
-                "",
-                "Flow states are isolated π processes with forked session snapshots. They run in parallel.",
-                'Invoke: { "flow": [{ "type": "scout", "intent": "...", "aim": "...", "sessionMode": "default" }, ...] }',
-                "Session modes: fast=300s, default=600s, long=900s, extreme_long=1200s. Use long or extreme_long only when the work genuinely needs the larger budget.",
-                "States: scout, debug, build, craft, audit, ideas.",
-                "Custom states configs in (create if not exists): .md files in .pi/agents/ or ~/.pi/agent/agents/.",
-            ].join("\n"),
+            description: "Dives into specialized flow states. Requires a `flow` array of tasks with specific `complexity` (snap, simple, moderate, complex, intricate).",
             parameters: FlowParams,
             async execute(toolCallId, params, signal, onUpdate, ctx) {
                 if (!resolved) {
@@ -446,16 +439,10 @@ export default function (pi) {
                 const discovery = discoverFlows(ctx.cwd, "all");
                 const { flows } = discovery;
                 const makeDetails = makeFlowDetailsFactory(discovery.projectFlowsDir);
-                // Build the full fork session snapshot and sanitize only non-inheritable
-                // artifacts before passing it to child flows.
-                // Uses the persistent module-level cache so historical flow results
-                // are properly compressed (not passed through verbatim).
-                const { result: forkSessionSnapshotJsonl, stats: forkSessionSnapshotStats } = sanitizeForkSnapshot(buildForkSessionSnapshotJsonl(ctx.sessionManager), flowResultCache, {
-                    forkedFrom: ctx.sessionManager.getSessionId(),
-                    forkedAt: new Date().toISOString(),
-                    depth: currentDepth + 1,
-                    ...(ancestorFlowStack.length > 0 ? { parentFlow: ancestorFlowStack[ancestorFlowStack.length - 1] } : {}),
-                });
+                // Build the fork session snapshot. Core-2 preserves all conversation
+                // verbatim in chronological order, stripping only batch read/write/edit
+                // bodies (keeping first 3 + last 3 lines as orientation).
+                const forkSessionSnapshotJsonl = buildCore2Snapshot(ctx.sessionManager);
                 const getTierOverride = (tier) => {
                     const flagName = tier === "lite"
                         ? "flow-lite-model"
@@ -481,7 +468,13 @@ export default function (pi) {
                     acceptance: activeGoal.acceptance,
                     flowCount: activeGoal.completedFlows.length,
                     maxFlows: activeGoal.maxFlows,
+                    completedFlows: activeGoal.completedFlows.map(f => ({ type: f.type, aim: f.aim })),
                 } : undefined;
+                const preDispatchResults = await Promise.all(params.flow.map(async (f) => {
+                    if (!f.dispatch || f.dispatch.length === 0)
+                        return undefined;
+                    return executeDispatchOps(f.dispatch, f.cwd ?? ctx.cwd, ctx, signal);
+                }));
                 const result = await executeFlows({
                     flows,
                     currentDepth,
@@ -493,7 +486,7 @@ export default function (pi) {
                     cwd: ctx.cwd,
                     loadedFlowModelConfigs: resolved.loadedFlowModelConfigs,
                     maxConcurrency: resolved.maxConcurrency,
-                    defaultSessionMode: resolved.defaultSessionMode,
+                    defaultComplexity: resolved.defaultComplexity,
                     signal,
                     onUpdate,
                     makeDetails,
@@ -501,8 +494,6 @@ export default function (pi) {
                     tierOverrideResolver: getTierOverride,
                     fallbackModel: inheritedCliArgs.fallbackModel,
                     forkSessionSnapshotJsonl,
-                    forkSessionSnapshotStats,
-                    flowResultCache,
                     projectFlowsDir: discovery.projectFlowsDir,
                     sessionManager: ctx.sessionManager,
                     hasUI: ctx.hasUI,
@@ -520,7 +511,15 @@ export default function (pi) {
                             addTokens(ctx.cwd, r.usage.input + r.usage.output);
                         }
                     },
-                }, params.flow.map((f) => ({ type: f.type, intent: f.intent, aim: f.aim, acceptance: f.acceptance, cwd: f.cwd, sessionMode: f.sessionMode })), toolCallId);
+                }, params.flow.map((f, i) => ({
+                    type: f.type,
+                    intent: f.intent,
+                    aim: f.aim,
+                    acceptance: f.acceptance,
+                    cwd: f.cwd,
+                    complexity: f.complexity,
+                    preDispatchResults: preDispatchResults[i],
+                })), toolCallId, params.auditLoop ?? 0);
                 if (result.failed) {
                     const text = result.content?.[0]?.text ?? "Flow execution failed";
                     throw new Error(text);
@@ -546,8 +545,8 @@ export default function (pi) {
                 appendDirectiveOnce(flowToolResult, hintContext);
                 return flowToolResult;
             },
-            renderCall: (args, theme) => renderFlowCall(args, theme),
-            renderResult: (result, { expanded }, theme, args) => renderFlowResult(result, expanded, theme, args),
+            renderCall: (args, theme) => renderFlowCall(args, theme, { ...DEFAULT_FLOW_COLORS, bodyVerbosity: resolved?.bodyVerbosity }),
+            renderResult: (result, { expanded }, theme, args) => renderFlowResult(result, expanded, theme, args, { ...DEFAULT_FLOW_COLORS, bodyVerbosity: resolved?.bodyVerbosity }),
         });
     }
     // -------------------------------------------------------------------------
@@ -567,6 +566,7 @@ export default function (pi) {
                 steeringStrategicHint: resolved.steeringStrategicHint,
                 animationEnabled: resolved.animationEnabled,
                 animationGlitch: resolved.animationGlitch,
+                bodyVerbosity: resolved.bodyVerbosity,
             }
             : {
                 toolOptimize: true,
@@ -577,6 +577,7 @@ export default function (pi) {
                 steeringStrategicHint: true,
                 animationEnabled: true,
                 animationGlitch: true,
+                bodyVerbosity: "lite",
             },
     };
     if (typeof pi.emit === "function") {