@namzu/cli 25.0.1 → 26.0.0

package/dist/tui/App.js

@@ -29,6 +29,8 @@ import { terminalNotificationEnabled, writeTerminalNotification, } from '../inte
 import { beginCodexDeviceLogin, beginSubscriptionLogin, clearAllStoredCredentials, clearStoredCodexCredential, clearStoredSubscriptionCredential, credentialsPath, parsePastedInput, primaryProvider, readStoredCodexCredential, readStoredSubscriptionCredential, signedInSubscriptionProviders, writePreferences, } from '../integrations/providers/index.js';
 import { appendMessages, archiveConversation, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, loadResumableConversation, openSessions, replaceConversation, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
 import { conversationMarkdown, writeConversationExport, } from '../integrations/sessions/transcript-export.js';
+import { liveOrchestrationRuns } from '../integrations/subagents/runs.js';
+import { NARRATION_TOOL_NAME } from '../integrations/subagents/runtime.js';
 import { isTrusted, trustDir } from '../integrations/trust/store.js';
 import { checkUpdates } from '../integrations/updates.js';
 import { renderMemoryReport, renderMemorySaveResult } from '../memory/presentation.js';
@@ -36,7 +38,7 @@ import { appendMemoryWithStatus, readMemory } from '../memory/store.js';
 import { effectivePermissionMode, permissionModeDescription, permissionModeLabel, } from '../permissions/mode.js';
 import { composeSkillsPrompt, discoverSkills, loadSkillBody } from '../skills/store.js';
 import { discoverUserCommands } from '../user-commands/store.js';
-import { AgentCockpit, AgentTaskPanel, AgentTranscript, activeSubagentCohorts, agentCockpitIsWide, agentPhasePageSize, agentPhases, agentPickerPageSize, agentTranscriptPageSize, agentWorkflowPageSize, agentWorkflows, maxAgentTranscriptTailOffset, } from './AgentExplorer.js';
+import { AgentCockpit, AgentNarrationBand, AgentTaskPanel, AgentTranscript, activeSubagentCohorts, agentCockpitIsWide, agentPhasePageSize, agentPhases, agentPickerPageSize, agentTranscriptPageSize, agentWorkflowPageSize, agentWorkflows, maxAgentTranscriptTailOffset, } from './AgentExplorer.js';
 import { BrandHeader } from './BrandHeader.js';
 import { ChoicePicker } from './ChoicePicker.js';
 import { emptyPluginReport, pluginDetails, pluginOption, pluginStartupState } from './plugin-view.js';
@@ -76,7 +78,7 @@ import { buildPermissionReview, buildPermissionSummary, permissionReviewPageRows
 import { describeRunInterruption, describeRunStop } from './run-interruption.js';
 import { moveSelection } from './selection-window.js';
 import { describeShellEscape, describeShellEscapeForModel, runShellEscape, shellEscapeCommand, } from './shell-escape.js';
-import { baseBranchReviewPrompt, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
+import { baseBranchReviewPrompt, combineOrchestrationRuns, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderAgentRuns, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
 import { splitCompleteBlocks, splitSafeCut } from './stream-blocks.js';
 import { terminalSupportsHyperlinks } from './terminal-hyperlinks.js';
 import { theme } from './theme.js';
@@ -387,6 +389,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         reasoningEffortRef.current = next;
         setReasoningEffortState(next);
     }, []);
+    // A session setting layered above effort, not a level a provider publishes
+    // — see docs/cli/slash-commands.md's /effort section. In-memory and
+    // per-session like reasoningEffort above; no preferences file involved.
+    const [orchestrateMode, setOrchestrateModeState] = useState(false);
+    const orchestrateModeRef = useRef(false);
+    const setOrchestrateMode = useCallback((next) => {
+        orchestrateModeRef.current = next;
+        setOrchestrateModeState(next);
+    }, []);
     const [activeSkills, setActiveSkills] = useState([]);
     // Read when the session comes up rather than on every keystroke: the
     // autocomplete dropdown consults this on each character, and a `readdirSync`
@@ -586,6 +597,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     /** Bounded child-run projection published by the current AgentSession. */
     const [subagents, setSubagentsState] = useState([]);
     const subagentsRef = useRef([]);
+    /**
+     * The parent's own commentary on the work it is coordinating, from the same
+     * monitor and the same subscription as the rows below it. Read through the
+     * optional reader, so a source that publishes no narration is simply a
+     * session with none.
+     */
+    const [narration, setNarration] = useState([]);
     const [agentSurface, setAgentSurfaceState] = useState(null);
     const agentSurfaceRef = useRef(null);
     const agentSurfaceCommittedRef = useRef(null);
@@ -604,7 +622,30 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     useEffect(() => {
         agentSurfaceCommittedRef.current = agentSurface;
     }, [agentSurface]);
-    const replaceSubagents = useCallback((next) => {
+    /**
+     * Children of this conversation's earlier runs, rebuilt from saved
+     * evidence, kept apart from the live monitor's own snapshot.
+     *
+     * A ref and not state because it is an input to `replaceSubagents`, which
+     * runs from the monitor's subscription: holding it as state would make
+     * every saved row arrive one render after the live rows it belongs beside.
+     */
+    const savedSubagentsRef = useRef([]);
+    /** Revokes an in-flight evidence read whose session or conversation is gone. */
+    const savedSubagentsTokenRef = useRef(0);
+    const withSavedSubagents = useCallback((live) => {
+        const saved = savedSubagentsRef.current;
+        if (saved.length === 0)
+            return live;
+        // A child the live monitor still holds wins over its own saved copy:
+        // both describe one run, and only one of the two is attached to
+        // anything. Saved rows land after the live ones, so a cohort that is
+        // still running keeps the top of the list.
+        const liveRunIds = new Set(live.map((agent) => agent.runId).filter((id) => id !== undefined));
+        return [...live, ...saved.filter((agent) => !agent.runId || !liveRunIds.has(agent.runId))];
+    }, []);
+    const replaceSubagents = useCallback((incoming) => {
+        const next = withSavedSubagents(incoming);
         const previous = subagentsRef.current;
         subagentsRef.current = next;
         setSubagentsState(next);
@@ -632,8 +673,40 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             selectedId: fallbackAgent.viewId,
             focus: surface.kind === 'cockpit' ? surface.focus : surface.returnFocus,
         });
-    }, [setAgentSurface]);
-    const openAgentCockpit = useCallback(() => {
+    }, [setAgentSurface, withSavedSubagents]);
+    /**
+     * Re-reads what this conversation's finished children left on disk.
+     *
+     * Called when a session is installed, whenever the conversation the scope
+     * names changes — a resume is the whole point of this: the children worth
+     * opening belong to the runs of the conversation just switched TO — and
+     * whenever the cockpit is opened, which is what recovers a child the live
+     * monitor's eighty-agent bound has since evicted. All three are reads of
+     * directories that are already there; nothing is created, and a failure
+     * leaves the live rows untouched.
+     */
+    const hydrateSavedChildren = useCallback(async () => {
+        const read = session?.savedChildren;
+        if (!read)
+            return;
+        const token = ++savedSubagentsTokenRef.current;
+        let saved;
+        try {
+            saved = await read();
+        }
+        catch {
+            // Saved evidence is an extra view over a directory that may not exist
+            // yet, or may not be readable. Not finding it is not a reason to
+            // disturb a session whose live children are fine.
+            return;
+        }
+        if (token !== savedSubagentsTokenRef.current)
+            return;
+        savedSubagentsRef.current = saved;
+        replaceSubagents(session?.subagents?.getSnapshot() ?? []);
+    }, [replaceSubagents, session]);
+    /** Opens the cockpit on the rows already on screen; false when there are none. */
+    const openCockpitFromCurrentRows = useCallback(() => {
         const agents = subagentsRef.current;
         const workflows = agentWorkflows(agents);
         const currentWorkflow = [...workflows].reverse().find((workflow) => workflow.agents.some((agent) => agent.status === 'starting' || agent.status === 'queued' || agent.status === 'working')) ?? workflows.at(-1);
@@ -649,6 +722,33 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         });
         return true;
     }, [setAgentSurface]);
+    /** The most recent cockpit request, so an older one cannot report on its behalf. */
+    const cockpitOpenTokenRef = useRef(0);
+    /**
+     * Ctrl+T and `/agents`: open the cockpit, and when nothing is on screen
+     * yet, WAIT for the saved evidence before answering.
+     *
+     * The waiting is the point. A conversation's children may exist only on
+     * disk — evicted by the eighty-agent bound, or written by a process that
+     * has since exited — and that read is asynchronous. Answering from the
+     * rows already up would make the first press after a resume report an
+     * absence that the read, still in flight, was about to disprove. Rows that
+     * ARE up open immediately and refresh the saved ones behind the screen, so
+     * the common case pays nothing for this.
+     */
+    const openAgentCockpit = useCallback(async () => {
+        if (openCockpitFromCurrentRows()) {
+            void hydrateSavedChildren();
+            return true;
+        }
+        const token = ++cockpitOpenTokenRef.current;
+        await hydrateSavedChildren();
+        // A later request owns the screen now. Reporting `false` here would put
+        // an empty-state line under a cockpit that request is about to open.
+        if (token !== cockpitOpenTokenRef.current)
+            return true;
+        return openCockpitFromCurrentRows();
+    }, [hydrateSavedChildren, openCockpitFromCurrentRows]);
     /** One git-backed review choice may be resolving while its visible picker remains authoritative. */
     const reviewChoiceInFlightRef = useRef(null);
     const exitArmedRef = useRef(false);
@@ -703,17 +803,32 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     useEffect(() => {
         const source = session?.subagents;
         setAgentSurface(null);
+        savedSubagentsRef.current = [];
+        void hydrateSavedChildren();
         if (!source) {
             replaceSubagents([]);
+            setNarration([]);
             return;
         }
-        const refresh = () => replaceSubagents(source.getSnapshot());
+        const refresh = () => {
+            replaceSubagents(source.getSnapshot());
+            setNarration(source.getNarration?.() ?? []);
+        };
         refresh();
         return source.subscribe(refresh);
-    }, [replaceSubagents, session, setAgentSurface]);
+    }, [hydrateSavedChildren, replaceSubagents, session, setAgentSurface]);
     const resetSubagentActivity = useCallback(() => {
         session?.subagents?.reset();
         setAgentSurface(null);
+        // The monitor clears its own commentary on reset; this drops the copy
+        // already on screen in the same pass as the rows, so the band cannot
+        // outlive the conversation it was written in.
+        setNarration([]);
+        // A new conversation starts with no children on screen, saved ones
+        // included: the evidence stays on disk, but it belongs to the runs of
+        // the conversation that was just left behind.
+        savedSubagentsTokenRef.current += 1;
+        savedSubagentsRef.current = [];
         replaceSubagents([]);
     }, [replaceSubagents, session, setAgentSurface]);
     // Source of truth for in-flight tools (the event loop runs across renders, so
@@ -1002,6 +1117,92 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         ]);
         return id;
     }, [nextId]);
+    /**
+     * `/agents runs`: opens a picker immediately with a disabled loading row,
+     * then replaces it once the live snapshot and the disk walk both resolve.
+     *
+     * The composer stays reachable the whole time — nothing here awaits before
+     * the first `setChoicePicker`. A stale read is dropped by comparing
+     * `choicePickerRef.current` against the exact loading-picker object this
+     * call put there (the idiom the `/review` pickers already use below),
+     * rather than a counter: Escape and every other picker-replacing path
+     * already route through `setChoicePicker`, so they retire this object as a
+     * side effect and need no separate token bump of their own. That covers
+     * both "the operator left this picker" (any other object is current now,
+     * `null` included) and "opened it again" (a second call's own object is
+     * current instead).
+     */
+    const openAgentRunsPicker = useCallback(() => {
+        setSelectedChoice(0);
+        const pending = {
+            kind: 'agent-runs',
+            title: 'Orchestration runs',
+            values: ['loading'],
+            options: [
+                { label: 'Loading…', description: 'Reading saved evidence…', disabledReason: 'Loading…' },
+            ],
+        };
+        setChoicePicker(pending);
+        void (async () => {
+            const live = liveOrchestrationRuns(subagentsRef.current, Date.now());
+            let finished = [];
+            try {
+                finished = (await session?.listOrchestrationRuns?.()) ?? [];
+            }
+            catch {
+                // Disk evidence is optional here: a live-only listing is still an
+                // honest answer, and the empty-history message below still applies
+                // if that live half turns out empty too.
+            }
+            if (appLifetime.signal.aborted || choicePickerRef.current !== pending)
+                return;
+            const listing = combineOrchestrationRuns(live, finished);
+            const empty = renderAgentRuns(listing);
+            if (empty) {
+                setChoicePicker(null);
+                pushMessage('system', empty);
+                return;
+            }
+            setChoicePicker({
+                kind: 'agent-runs',
+                title: 'Orchestration runs',
+                notice: listing.omitted > 0
+                    ? `${listing.omitted} older run${listing.omitted === 1 ? '' : 's'} not shown.`
+                    : undefined,
+                values: listing.runs,
+                options: listing.runs.map(agentRunOption),
+            });
+        })();
+    }, [appLifetime, pushMessage, session, setChoicePicker, setSelectedChoice]);
+    /**
+     * Opens an `/agents runs` selection straight into its first agent's
+     * transcript — where the replayed banner actually lives, for a finished
+     * run — rather than the phase/agent list Ctrl+T lands on.
+     *
+     * A finished run's evidence is hydrated first, since a run this operator
+     * has not opened the cockpit for yet may not be in `subagents` at all.
+     * A live run skips that: it is already there, and re-reading disk for a
+     * run this process is still writing would risk the very half-written
+     * evidence `listSavedOrchestrationRuns` exists to stay off of.
+     */
+    const openOrchestrationRun = useCallback(async (run) => {
+        if (!run.live)
+            await hydrateSavedChildren();
+        const workflow = agentWorkflows(subagentsRef.current).find((candidate) => candidate.agents.some((agent) => agent.workflowId === run.id));
+        const firstPhase = workflow?.phases[0];
+        const firstAgent = firstPhase?.agents[0];
+        if (!firstPhase || !firstAgent) {
+            pushMessage('system', `Could not open "${run.name}" — its saved evidence is no longer available.`);
+            return;
+        }
+        setAgentSurface({
+            kind: 'transcript',
+            selectedPhaseId: firstPhase.id,
+            selectedId: firstAgent.viewId,
+            returnFocus: 'agents',
+            tailOffset: 0,
+        });
+    }, [hydrateSavedChildren, pushMessage, setAgentSurface]);
     const reportedAgentsRef = useRef(new Set());
     useEffect(() => {
         reportedAgentsRef.current.clear();
@@ -1025,6 +1226,38 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('tool', `${agent.description} · ${status}`, false, completed ? '✓' : '✗', undefined, completed ? theme.status.ok : theme.status.error, 'ctrl+t · agent details');
         }
     }, [subagents, pushMessage, session]);
+    /**
+     * A delivered `send_message` correction already lands its own row inside
+     * the child's transcript (`SubagentActivityMonitor.recordMessage`); this
+     * mirrors it into the main conversation so the operator sees what was
+     * sent without drilling in. Deliberately a separate ref from
+     * `reportedAgentsRef` above: that gate is exactly-once per terminal
+     * agent, this one is exactly-once per delivered message, and folding the
+     * two together would let one gate's reset silently double-report the
+     * other's rows.
+     */
+    const reportedCorrectionsRef = useRef(new Set());
+    useEffect(() => {
+        reportedCorrectionsRef.current.clear();
+    }, [session]);
+    useEffect(() => {
+        const current = session?.subagents?.getSnapshot() ?? [];
+        for (const agent of subagents) {
+            const live = current.find((item) => item.viewId === agent.viewId && item.workflowId === agent.workflowId);
+            if (!live)
+                continue;
+            for (const row of agent.transcript) {
+                if (row.kind !== 'system' || row.direction !== 'to-child')
+                    continue;
+                if (!live.transcript.some((item) => item.id === row.id))
+                    continue;
+                if (reportedCorrectionsRef.current.has(row.id))
+                    continue;
+                reportedCorrectionsRef.current.add(row.id);
+                pushMessage('tool', `${agent.description} · correction sent`, false, '→', [row.text]);
+            }
+        }
+    }, [subagents, pushMessage, session]);
     const applyPermissionMode = useCallback((mode) => {
         if (!session?.hasProvider) {
             pushMessage('system', 'Choose a model before changing permissions.');
@@ -1079,6 +1312,47 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         setReasoningEffort(effort);
         pushMessage('system', `Reasoning: ${effort} (this session).`);
     }, [hasUnsettledTurn, pushMessage, session, setReasoningEffort, state]);
+    /**
+     * Turn the session's orchestrate mode on or off.
+     *
+     * On: pins effort to the model's highest published level (last entry of
+     * `reasoningEffortLevels`, which every provider publishes low-to-high) and
+     * strengthens delegation guidance for future turns via `SendOptions.orchestrate`
+     * — see `applyReasoningEffort` above for the mirrored guard shape. When the
+     * model publishes no exact menu, effort is left alone and the notice says
+     * so explicitly rather than silently doing nothing.
+     */
+    const applyOrchestrateMode = useCallback((enabled, selectedSession) => {
+        if (!session?.hasProvider) {
+            pushMessage('system', 'No active session — pick a provider before turning orchestrate mode on.');
+            return;
+        }
+        if (selectedSession !== undefined && selectedSession !== session) {
+            pushMessage('system', 'Orchestrate mode was not changed: the selected model is no longer active.');
+            return;
+        }
+        if (state !== 'idle' ||
+            abortRef.current !== null ||
+            hasUnsettledTurn() ||
+            (queuedRef.current.length > 0 && selectedSession !== session) ||
+            permissionResolveRef.current !== null ||
+            compactingRef.current) {
+            pushMessage('system', 'Orchestrate mode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+            return;
+        }
+        setOrchestrateMode(enabled);
+        if (!enabled) {
+            pushMessage('system', 'Orchestrate mode is off.');
+            return;
+        }
+        const highest = highestReasoningEffort(session.reasoningEffortLevels);
+        if (highest !== undefined) {
+            setReasoningEffort(highest);
+            pushMessage('system', `Orchestrate mode is on — effort pinned to ${highest} for ${session.modelSummary ?? 'this model'}, and delegation guidance is strengthened for this session.`);
+            return;
+        }
+        pushMessage('system', `Orchestrate mode is on — ${session.modelSummary ?? 'this model'} does not publish an exact effort menu, so effort was left as is. Delegation guidance is still strengthened for this session.`);
+    }, [hasUnsettledTurn, pushMessage, session, setOrchestrateMode, setReasoningEffort, state]);
     const stepReasoningEffort = useCallback((direction) => {
         const levels = session?.reasoningEffortLevels;
         if (!session?.hasProvider || levels === undefined || levels.length === 0) {
@@ -1583,6 +1857,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setChoicePicker({ ...child, back: picker });
             return;
         }
+        if (picker.kind === 'agent-runs') {
+            if (value === 'loading')
+                return;
+            void openOrchestrationRun(value);
+            return;
+        }
         if (picker.kind === 'archive-conversation') {
             if (value === 'archive')
                 archiveCurrentConversation();
@@ -1636,16 +1916,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             removeStoredCredential(value);
             return;
         }
+        if (picker.kind === 'reasoning-effort' && value === ORCHESTRATE_MODE_VALUE) {
+            applyOrchestrateMode(!orchestrateModeRef.current, picker.selectedSession);
+            return;
+        }
         applyReasoningEffort(value, picker.selectedSession);
     }, [
         activateSkill,
         advanceQueueContinuation,
         appLifetime.signal,
+        applyOrchestrateMode,
         applyPermissionMode,
         applyReasoningEffort,
         archiveCurrentConversation,
         ctx.cwd,
         enqueueQueued,
+        openOrchestrationRun,
         pushMessage,
         recordFeedback,
         removeStoredCredential,
@@ -1863,6 +2149,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             ...(activeCtx.memory ? { memory: activeCtx.memory } : {}),
             ...(activeCtx.limits ? { limits: activeCtx.limits } : {}),
             ...(activeCtx.sandbox ? { sandbox: activeCtx.sandbox } : {}),
+            // The operator's screens, on the same terms as every other
+            // config field the App forwards. `!== undefined` rather than a
+            // length test: `[]` is the off switch, and dropping it here
+            // would leave the kernel's default in force in the interactive
+            // session — always on, for the one operator who said otherwise.
+            ...(activeCtx.toolResultScreens !== undefined
+                ? { toolResultScreens: activeCtx.toolResultScreens }
+                : {}),
             // Somebody is at this terminal, so the model may ask them one
             // question when a decision is genuinely theirs.
             askUser: true,
@@ -1905,9 +2199,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // A picker-owned provider/model change is one state transition. Clear the
         // old model's effort selection before publishing the replacement session
         // or releasing any paused queue. Failed and superseded candidates returned
-        // above, so they leave the current session selection untouched.
-        if (signal !== undefined)
-            setReasoningEffort(undefined);
+        // above, so they leave the current session selection untouched. Orchestrate
+        // mode survives the switch: re-pin to the new model's highest published
+        // level instead of clearing, exactly as it pinned when first turned on.
+        if (signal !== undefined) {
+            setReasoningEffort(orchestrateModeRef.current ? highestReasoningEffort(s.reasoningEffortLevels) : undefined);
+        }
         // Re-hydration (a provider switch via /model) builds a second session;
         // without this the first one's tool-server child processes stay alive
         // for the rest of the TUI's life.
@@ -1915,7 +2212,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         void previousSessionRef.current?.close();
         previousSessionRef.current = s;
         setSession(s);
-        if (options.chooseReasoningEffort && s.reasoningEffortLevels?.length) {
+        // Orchestrate mode already re-pinned effort above; reopening this picker
+        // would ask the operator to redo a choice the mode just made for them.
+        if (!orchestrateModeRef.current && options.chooseReasoningEffort && s.reasoningEffortLevels?.length) {
             // Own input before publishing ready or releasing a paused queue. The
             // menu closes only after choosing an effort or keeping the new default.
             setSelectedChoice(0);
@@ -2603,6 +2902,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             : null;
         pendingGoalResumeRef.current = conv.id;
         scope.sessionId = conv.id; // new turns now attribute to the resumed session
+        // The scope now names the resumed conversation, so its finished
+        // children are readable. Without this the first Ctrl+T after a resume
+        // would have nothing to find.
+        void hydrateSavedChildren();
         conversationMaterializedRef.current = true;
         pushMessage('system', `Resumed: ${conv.title}`);
         if (discardedQueued > 0) {
@@ -2623,6 +2926,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         nextId,
         pushMessage,
         cancelPendingModelSwitch,
+        hydrateSavedChildren,
         resetSubagentActivity,
         session,
         resetTranscript,
@@ -2674,6 +2978,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             if (sourceScope && targetSessionId) {
                 sourceScope.sessionId = targetSessionId;
                 conversationMaterializedRef.current = true;
+                // A fresh conversation owns no runs yet, so this normally reads
+                // nothing. It runs anyway because the rule is "the scope changed,
+                // re-read", and an exception here is how the resume path lost
+                // its own re-read.
+                void hydrateSavedChildren();
             }
             if (clearScreen) {
                 setMessages([]);
@@ -2706,6 +3015,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         interruptTurn,
         pushMessage,
         cancelPendingModelSwitch,
+        hydrateSavedChildren,
         resetSubagentActivity,
         session,
         resetTranscript,
@@ -2858,6 +3168,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // is reloaded or reset. Only where the NEXT turn is written changes.
             scope.sessionId = forked.id;
             resetSubagentActivity();
+            void hydrateSavedChildren();
             session?.resetTaskStore?.();
             goalActivation.clear();
             wakeGoalDriver();
@@ -2875,6 +3186,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         hasUnsettledTurn,
         materializeConversation,
         pushMessage,
+        hydrateSavedChildren,
         resetSubagentActivity,
         session,
         wakeGoalDriver,
@@ -2968,6 +3280,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             goalActivation.clear();
             wakeGoalDriver();
             scope.sessionId = forked.id;
+            void hydrateSavedChildren();
             modelHistoryRef.current = forked.messages;
             lastAssistantMessage.current = null;
             const persistedOutput = latestAssistantOutput(forked.messages);
@@ -3005,6 +3318,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         nextId,
         pushMessage,
         cancelPendingModelSwitch,
+        hydrateSavedChildren,
         resetSubagentActivity,
         session,
         resetTranscript,
@@ -3229,6 +3543,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     event.toolName.toLowerCase() === 'agent' &&
                     subagentsRef.current.some((agent) => agent.toolUseId === event.toolUseId &&
                         (event.runId === undefined || agent.workflowId === event.runId));
+                // The band above the rail already carries a narrated line, in the
+                // parent's own words, from the moment it is written. Printing the
+                // call that wrote it would show the same sentence twice, the
+                // second time as protocol — the same duplicate-protocol case as
+                // the represented Agent call just below, and refused the same
+                // way. A REFUSED line keeps its row: nothing reached the screen,
+                // and that row is the only thing that says so.
+                if (!event.isError && event.toolName === NARRATION_TOOL_NAME) {
+                    setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                    break;
+                }
                 if (representedSuccessfulAgent) {
                     // The automatic panel already owned this successful child from
                     // start through settlement. Re-emitting its internal Agent call as
@@ -3684,6 +4009,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         activeTurnInboxRef.current = inbox;
         const turnPermissionMode = permissionModeRef.current;
         const turnReasoningEffort = reasoningEffortRef.current;
+        const turnOrchestrateMode = orchestrateModeRef.current;
         const turnRunLimits = resolveRunGuards(ctxRef.current.limits, runLimitsOverrideRef.current);
         // Always carry the guarded callback. `auto` and `strict` decide before
         // calling it in makeResumeHandler; retaining it is what lets a session
@@ -3744,6 +4070,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     permissionMode: turnPermissionMode,
                     limits: turnRunLimits,
                     ...(turnReasoningEffort !== undefined ? { effort: turnReasoningEffort } : {}),
+                    ...(turnOrchestrateMode ? { orchestrate: true } : {}),
                     ...(goalRound ? { goalRound } : {}),
                     // The mode above decides whether this callback is consulted.
                     onPermission: askPermission,
@@ -4224,9 +4551,20 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     return;
                 }
                 case 'agent-cockpit': {
-                    if (!openAgentCockpit()) {
-                        pushMessage('system', `No delegated agents in this conversation.${session?.agentIds.length ? `\nAvailable: ${session.agentIds.join(', ')}` : '\nNo agents are configured.'}`);
-                    }
+                    // Reported after the read, not before it: the answer to "are
+                    // there any" may be on disk, and a conversation whose evidence
+                    // is sitting in its own directory must never be told it
+                    // delegated nothing.
+                    const agentIds = session?.agentIds ?? [];
+                    void openAgentCockpit().then((opened) => {
+                        if (opened)
+                            return;
+                        pushMessage('system', `No delegated agents in this conversation.${agentIds.length ? `\nAvailable: ${agentIds.join(', ')}` : '\nNo agents are configured.'}`);
+                    });
+                    return;
+                }
+                case 'agent-runs': {
+                    openAgentRunsPicker();
                     return;
                 }
                 case 'provider-setup':
@@ -4563,7 +4901,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     const values = [undefined, ...levels];
                     const current = reasoningEffortRef.current;
                     setSelectedChoice(Math.max(0, values.findIndex((value) => value === current)));
-                    setChoicePicker(reasoningEffortPicker(session, current) ?? null);
+                    setChoicePicker(reasoningEffortPicker(session, current, false, orchestrateModeRef.current) ?? null);
                     return;
                 }
                 case 'login':
@@ -4981,6 +5319,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         : 'Raw output mode off — rich transcript rendering restored.');
                     return;
                 }
+                case 'orchestrate-mode': {
+                    const enabled = slash.enabled === 'toggle' ? !orchestrateModeRef.current : slash.enabled;
+                    applyOrchestrateMode(enabled);
+                    return;
+                }
                 case 'export-picker': {
                     if (!stableExportSource())
                         return;
@@ -5063,6 +5406,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         hostCommands,
         nextId,
         openAgentCockpit,
+        openAgentRunsPicker,
         pushMessage,
         rawOutput,
         removeStoredCredential,
@@ -5563,8 +5907,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setAgentSurface(null);
                 return;
             }
-            if (openAgentCockpit())
+            if (openCockpitFromCurrentRows()) {
+                void hydrateSavedChildren();
                 return;
+            }
+            // Nothing on screen yet. The conversation's children may exist only
+            // as saved evidence, so the request outlives that read rather than
+            // being answered by an empty snapshot.
+            void openAgentCockpit();
         }
         // Child observation owns navigation, but never outranks consent: the
         // permission branch above preempts it if a child or parent call asks.
@@ -5702,7 +6052,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 return;
             }
             if (key.home || key.end || key.pageUp || key.pageDown || key.upArrow || key.downArrow) {
-                const page = agentTranscriptPageSize(terminal.rows);
+                // Reserving the replayed banner's row here too keeps one PgDn a
+                // screenful of what is actually visible.
+                const page = agentTranscriptPageSize(terminal.rows, selected.replayed ? 1 : 0);
                 const max = maxAgentTranscriptTailOffset(selected, terminal.rows, terminal.columns);
                 const offset = Math.min(agentView.tailOffset, max);
                 const next = key.home
@@ -5976,6 +6328,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         ? permissionOwner ? `Agent: ${permissionOwner.description}` : `Run: ${permission.runId}`
         : undefined;
     const displayedPermissionMode = effectivePermissionMode(permissionMode, session?.approvalLatched() ?? false);
+    // True exactly when the phase ternary below renders its final branch — the
+    // normal composer view, as opposed to provider setup or a lifecycle
+    // picker/prompt. The agent rail is a feature of that view: computing this
+    // once here lets its render site sit after the footer, below, while still
+    // never appearing during trust/resume/edit/picker/setup phases.
+    const showComposerSurface = !providerSetup &&
+        phase !== 'trust' &&
+        phase !== 'unhealthy' &&
+        phase !== 'resume' &&
+        phase !== 'edit' &&
+        phase !== 'picker';
     return (_jsx(Box, { flexDirection: "column", display: externalEditorRequest ? 'none' : 'flex', children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: transcriptOwned ? renderedSettled : 0, resetKey: resetKey, raw: rawOutput, hyperlinks: hyperlinks, showLive: !lifecycleOwnsViewport, header: transcriptOwned ? (_jsx(BrandHeader, { version: ctx.version, permissionMode: displayedPermissionMode })) : undefined }) }), providerSetup ? (_jsx(ProviderSetup, { cwd: ctx.cwd, onClose: () => setProviderSetup(false), onConnect: () => {
                         setProviderSetup(false);
                         setPickerInitialView('providers');
@@ -6009,7 +6372,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                                 ? queuePause.outcome === 'paused'
                                                     ? 'held after a resumable run paused; wait for recovery, change model, or send a message to release it'
                                                     : `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
-                                                : 'sending when ready'] }) })) : null, _jsx(Composer, { reasoningEffortLevels: session?.reasoningEffortLevels, permissionMode: displayedPermissionMode, onCycleMode: cyclePermissionMode, disabled: outputViewer !== null ||
+                                                : 'sending when ready'] }) })) : null, _jsx(Composer, { reasoningEffortLevels: session?.reasoningEffortLevels, onCycleMode: cyclePermissionMode, disabled: outputViewer !== null ||
                                         phase !== 'ready' ||
                                         state === 'awaiting-permission' ||
                                         compacting ||
@@ -6026,13 +6389,23 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                         (state === 'thinking' || state === 'tool' || pendingModelSwitchRef.current !== null), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onStepReasoningEffort: stepReasoningEffort, onExternalEdit: requestExternalEditor, onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), onDraftPresenceChange: setComposerHasDraft, onOpenAgentPanel: openAgentCockpit, userCommands: userCommands, builtins: hostCommands.map((command) => ({
                                         ...command,
                                         description: command.unavailable?.(slashCtx) ?? command.description,
-                                    })), mentionCandidates: mentionCandidates, history: history })] }), permission === null && agentSurface === null && outputViewer === null && liveSubagents.length > 0 ? (_jsx(AgentTaskPanel, { agents: liveSubagents, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'cockpit' ? (_jsx(AgentCockpit, { agents: subagents, selectedPhaseId: agentSurface.selectedPhaseId, selectedId: agentSurface.selectedId, focus: agentSurface.focus, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : permission === null && agentSurface?.kind === 'transcript' && selectedSubagent ? (_jsx(AgentTranscript, { agent: selectedSubagent, tailOffset: agentSurface.tailOffset, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : null] })), outputViewer && permission === null ? (_jsx(ToolOutputViewer, { onPrevious: () => {
+                                    })), mentionCandidates: mentionCandidates, history: history })] })] })), _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort, orchestrate: orchestrateMode, goal: statusGoal, state: state, hint: statusHint, permissionMode: displayedPermissionMode, canCycleMode: true }), showComposerSurface &&
+                    permission === null &&
+                    agentSurface === null &&
+                    outputViewer === null ? (_jsx(AgentNarrationBand, { lines: narration })) : null, showComposerSurface &&
+                    permission === null &&
+                    agentSurface === null &&
+                    outputViewer === null &&
+                    liveSubagents.length > 0 ? (_jsx(AgentTaskPanel, { agents: liveSubagents, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : showComposerSurface && permission === null && agentSurface?.kind === 'cockpit' ? (_jsx(AgentCockpit, { agents: subagents, selectedPhaseId: agentSurface.selectedPhaseId, selectedId: agentSurface.selectedId, focus: agentSurface.focus, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : showComposerSurface &&
+                    permission === null &&
+                    agentSurface?.kind === 'transcript' &&
+                    selectedSubagent ? (_jsx(AgentTranscript, { agent: selectedSubagent, tailOffset: agentSurface.tailOffset, terminalRows: terminal.rows, terminalColumns: terminal.columns })) : null, outputViewer && permission === null ? (_jsx(ToolOutputViewer, { onPrevious: () => {
                         if (outputIndex > 0)
                             setOutputViewer(outputBlocks[outputIndex - 1]);
                     }, onNext: () => {
                         if (outputIndex >= 0 && outputIndex + 1 < outputBlocks.length)
                             setOutputViewer(outputBlocks[outputIndex + 1]);
-                    }, title: outputViewer.content, lines: outputViewer.detail ?? [], rows: terminal.rows, columns: terminal.columns, onClose: () => setOutputViewer(null) }, outputViewer.id)) : null, _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort ?? 'default', goal: statusGoal, state: state, hint: statusHint }) })] }) }));
+                    }, title: outputViewer.content, lines: outputViewer.detail ?? [], rows: terminal.rows, columns: terminal.columns, onClose: () => setOutputViewer(null) }, outputViewer.id)) : null] }) }));
 }
 /** One line for a background job that ended, for the transcript and the next turn. */
 function describeJobExit(job) {
@@ -6109,6 +6482,33 @@ function goalStatusLabel(goal, armed) {
 function labelOfOption(question, optionId) {
     return question.options.find((option) => option.id === optionId)?.label ?? optionId;
 }
+/** `/agents runs`' one-line-per-run text, mirroring `/jobs`' own column shape. */
+function agentRunOption(run) {
+    const agents = `${run.agentsDone}/${run.agentsTotal} agent${run.agentsTotal === 1 ? '' : 's'}`;
+    const tokens = `${run.tokensTotal.toLocaleString('en-US')} tokens`;
+    const columns = [
+        relativeRunStart(run.startedAt),
+        run.phases.join(', '),
+        agents,
+        tokens,
+        formatElapsed(run.elapsedMs),
+    ];
+    if (run.live)
+        columns.push('live');
+    return { label: run.name, description: columns.join(' · ') };
+}
+/** `just now` / `12m ago` / `3h ago` / `2d ago` — the same buckets a conversation's own resume picker shows. */
+function relativeRunStart(startedAt) {
+    const minutes = Math.round((Date.now() - startedAt) / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.round(hours / 24)}d ago`;
+}
 function choicePickerSearchable(picker) {
     return ['command', 'skill', 'plugin', 'review-branch', 'review-commit'].includes(picker.kind);
 }
@@ -6190,11 +6590,27 @@ function permissionPicker(mode, approvedAll, more = false) {
         }),
     };
 }
-function reasoningEffortPicker(session, current, afterModelSelection = false) {
+/**
+ * The picker's sentinel for the orchestrate-mode row, below the rule.
+ *
+ * A plain string outside the `ReasoningEffort` union by construction — never
+ * added to any model's published menu — so it can share the same picker
+ * without ever being mistaken for a level `/effort <token>` could select.
+ */
+const ORCHESTRATE_MODE_VALUE = 'orchestrate';
+/** Last entry of a low-to-high menu every provider publishes in that order; `undefined` when none is known. */
+function highestReasoningEffort(levels) {
+    return levels && levels.length > 0 ? levels[levels.length - 1] : undefined;
+}
+function reasoningEffortPicker(session, current, afterModelSelection = false, orchestrateOn = false) {
     const levels = session.reasoningEffortLevels;
     if (!session.hasProvider || levels === undefined)
         return undefined;
-    const values = [undefined, ...levels];
+    const effortValues = [undefined, ...levels];
+    const values = [
+        ...effortValues,
+        ORCHESTRATE_MODE_VALUE,
+    ];
     return {
         kind: 'reasoning-effort',
         title: `Select Reasoning Level for ${session.modelSummary ?? 'current model'}`,
@@ -6205,12 +6621,24 @@ function reasoningEffortPicker(session, current, afterModelSelection = false) {
             }
             : {}),
         values,
-        options: values.map((effort) => ({
-            label: effort ?? 'default',
-            description: reasoningEffortDescription(effort),
-            current: effort === current,
-            default: effort === undefined,
-        })),
+        options: [
+            ...effortValues.map((effort) => ({
+                label: effort ?? 'default',
+                description: reasoningEffortDescription(effort),
+                current: effort === current,
+                default: effort === undefined,
+            })),
+            {
+                // Below a rule, visually apart from the levels above: a session
+                // setting, not a sixth level the provider published.
+                label: 'orchestrate',
+                description: orchestrateOn
+                    ? 'On · highest level and delegate by default'
+                    : 'Off · highest level and delegate by default',
+                current: orchestrateOn,
+                ruleBefore: true,
+            },
+        ],
     };
 }
 function reasoningEffortDescription(effort) {