@compilr-dev/cli 0.7.4 → 0.7.6

package/dist/repl-v2.js

@@ -20,7 +20,7 @@ import { initSessionRegistry, getSessionRegistry, setActiveTerminalSessionId, ge
 import { initFileLockManager } from './multi-agent/file-locks.js';
 import { initNotificationManager, getNotificationManager } from './multi-agent/notification-manager.js';
 import { getSessionsPath } from './settings/paths.js';
-import { setMetaToolFilter, isMetaToolSilent, todoStore } from './tools.js';
+import { todoStore } from './tools.js';
 import { getCurrentProject } from './tools/project-db.js';
 import { TerminalUI } from './ui/terminal-ui.js';
 import * as terminal from './ui/terminal.js';
@@ -31,7 +31,8 @@ import { renderMascotWithLogo } from './ui/mascot/renderer.js';
 import { getStartupHighlights } from './changelog/index.js';
 import { registerCommands, executeCommand, allCommands, getAutocompleteCommands, setSkillCommandLoader, saveCurrentSession, saveCurrentTeam, loadProjectSession, archiveCurrentSession, convertMessagesToItems, } from './commands-v2/index.js';
 import { getCustomCommandRegistry } from './commands/custom-registry.js';
-import { getPlanModePrompt } from '@compilr-dev/sdk';
+import { getPlanModePrompt, createHandoffTool, createConsultTool, createDelegateTool, createDelegateBackgroundTool, } from '@compilr-dev/sdk';
+import { getHandoffHandler, getConsultHandler, getDelegateHandler, getDelegateBackgroundHandler, } from './shared-handlers.js';
 import { planRepository } from './db/repositories/index.js';
 import { PlanApprovalOverlayV2, } from './ui/overlay/impl/plan-approval-overlay-v2.js';
 import { PermissionOverlayV2, } from './ui/overlay/impl/permission-overlay-v2.js';
@@ -40,6 +41,8 @@ import { truncate } from './ui/base/index.js';
 import { AskUserSimpleOverlayV2, } from './ui/overlay/impl/ask-user-simple-overlay-v2.js';
 import { GuardrailOverlayV2, } from './ui/overlay/impl/guardrail-overlay-v2.js';
 import { AskUserOverlayV2, } from './ui/overlay/impl/ask-user-overlay-v2.js';
+import { ProposeAlternativesOverlayV2, } from './ui/overlay/impl/propose-alternatives-overlay-v2.js';
+import { InteractiveFlowOverlayV2, } from './ui/overlay/impl/interactive-flow-overlay-v2.js';
 import { IterationLimitOverlayV2, } from './ui/overlay/impl/iteration-limit-overlay-v2.js';
 import { OnboardingWizardOverlayV2, } from './ui/overlay/impl/onboarding-wizard-overlay-v2.js';
 import { LoginOverlayV2, } from './ui/overlay/impl/login-overlay-v2.js';
@@ -68,9 +71,10 @@ const MAX_QUEUE_SIZE = 10;
 const DEBUG_LOG_FILE = '/tmp/compilr-agent-debug.log';
 const DEBUG_ENABLED = process.env.DEBUG_AGENT_REQUESTS === '1';
 let debugRequestCount = 0;
-// Import tool registry functions for debug logging
-import { getDirectTools, getMetaTools, getToolStats } from './tools.js';
-import { getRegisteredMetaTools } from './tools/meta-tools.js';
+// Debug logging fetches tool definitions live from the agent (the SDK's
+// internal meta-registry is fed via the agent's capability config and
+// isn't separately accessible from the CLI; the CLI's old parallel
+// `MetaToolsRegistry` was removed in audit TODO-15).
 /**
  * Write debug info to log file before agent request.
  * Enable with: DEBUG_AGENT_REQUESTS=1 compilr
@@ -87,26 +91,18 @@ function debugLogAgentRequest(agent, message) {
         const systemPromptTokens = estimateTokens(state.systemPrompt);
         const messagesJson = JSON.stringify(state.messages);
         const messagesTokens = estimateTokens(messagesJson);
-        // Get tool definitions for logging
-        const directTools = getDirectTools();
-        const metaTools = getMetaTools();
-        const metaRegistryTools = getRegisteredMetaTools();
-        const toolStats = getToolStats();
-        // Calculate tool definition sizes
-        const directToolsJson = JSON.stringify(directTools.map(t => ({
-            name: t.definition.name,
-            description: t.definition.description,
-            inputSchema: t.definition.inputSchema,
-        })));
-        const metaToolsJson = JSON.stringify(metaTools.map(t => ({
-            name: t.definition.name,
-            description: t.definition.description,
-            inputSchema: t.definition.inputSchema,
+        // Tool definitions come live from the agent. The SDK's internal
+        // meta-registry isn't separately accessible — its tools are routed
+        // transparently via use_tool() and `get_tool_info` already lives in
+        // the agent's direct list (so it's counted here).
+        const directTools = agent.getToolDefinitions();
+        const directToolsJson = JSON.stringify(directTools.map(d => ({
+            name: d.name,
+            description: d.description,
+            inputSchema: d.inputSchema,
         })));
         const directToolsTokens = estimateTokens(directToolsJson);
-        const metaToolsTokens = estimateTokens(metaToolsJson);
-        const totalToolTokens = directToolsTokens + metaToolsTokens;
-        const totalEstimate = systemPromptTokens + messagesTokens + totalToolTokens;
+        const totalEstimate = systemPromptTokens + messagesTokens + directToolsTokens;
         const logEntry = `
 ################################################################################
 # REQUEST #${String(debugRequestCount)} @ ${timestamp}
@@ -120,13 +116,9 @@ CONTEXT SIZES:
 - Messages:       ${messagesJson.length.toLocaleString()} chars (~${messagesTokens.toLocaleString()} tokens)
 - Message Count:  ${String(state.messages.length)}
 - Direct Tools:   ${directToolsJson.length.toLocaleString()} chars (~${directToolsTokens.toLocaleString()} tokens) [${String(directTools.length)} tools]
-- Meta Tools:     ${metaToolsJson.length.toLocaleString()} chars (~${metaToolsTokens.toLocaleString()} tokens) [${String(metaTools.length)} tools]
-- Meta Registry:  ${String(metaRegistryTools.length)} tools (accessed via use_tool)
 --------------------------------------------------------------------------------
 ESTIMATED TOTAL: ~${totalEstimate.toLocaleString()} tokens
-  (prompt: ${systemPromptTokens.toLocaleString()} + messages: ${messagesTokens.toLocaleString()} + tools: ${totalToolTokens.toLocaleString()})
-
-Tool Stats: Direct=${String(toolStats.directTools)}, MetaRegistry=${String(toolStats.metaRegistryTools)}, Savings=~${String(toolStats.tokenSavings)}
+  (prompt: ${systemPromptTokens.toLocaleString()} + messages: ${messagesTokens.toLocaleString()} + tools: ${directToolsTokens.toLocaleString()})
 
 ================================================================================
 FULL SYSTEM PROMPT (${systemPromptChars.toLocaleString()} chars):
@@ -136,17 +128,7 @@ ${state.systemPrompt}
 ================================================================================
 DIRECT TOOLS (${String(directTools.length)} tools, ~${directToolsTokens.toLocaleString()} tokens):
 ================================================================================
-${directTools.map(t => `- ${t.definition.name}: ${t.definition.description.slice(0, 100)}...`).join('\n')}
-
-================================================================================
-META TOOLS (${String(metaTools.length)} tools, ~${metaToolsTokens.toLocaleString()} tokens):
-================================================================================
-${metaTools.map(t => `- ${t.definition.name}: ${t.definition.description.slice(0, 100)}...`).join('\n')}
-
-================================================================================
-META REGISTRY TOOLS (${String(metaRegistryTools.length)} tools, accessed via use_tool):
-================================================================================
-${metaRegistryTools.map(t => `- ${t.definition.name}`).join('\n')}
+${directTools.map(d => `- ${d.name}: ${d.description.slice(0, 100)}...`).join('\n')}
 
 ================================================================================
 MESSAGES HISTORY (${String(state.messages.length)} messages):
@@ -156,7 +138,7 @@ ${JSON.stringify(state.messages, null, 2)}
 `;
         appendFileSync(DEBUG_LOG_FILE, logEntry);
         log.debug({ component: 'repl', requestNum: debugRequestCount, file: DEBUG_LOG_FILE }, 'Debug request logged');
-        log.debug({ component: 'repl', systemPromptTokens, messagesTokens, totalToolTokens, totalEstimate }, 'Token estimate');
+        log.debug({ component: 'repl', systemPromptTokens, messagesTokens, directToolsTokens, totalEstimate }, 'Token estimate');
     }
     catch (error) {
         log.error({ component: 'repl', err: error }, 'Failed to log agent request');
@@ -187,6 +169,8 @@ export class ReplV2 {
     onAskUserSimpleReady;
     onGuardrailReady;
     onAskUserReady;
+    onProposeAlternativesReady;
+    onInteractiveFlowReady;
     onIterationLimitReady;
     onAgentFinish;
     onSuggestionReady;
@@ -222,6 +206,11 @@ export class ReplV2 {
     // Bash abort controllers for Ctrl+B backgrounding feature
     // Maps toolUseId -> AbortController for each running bash command
     bashAbortControllers = new Map();
+    // Dedupe set for specialist multi-agent tool registration (handoff/consult).
+    // Keyed by agentId — once we've registered these tools on a specialist
+    // agent's underlying Agent instance we don't do it again on subsequent
+    // switches. Mirrors Desktop's `delegateToolsRegistered` set.
+    specialistToolsRegistered = new Set();
     constructor(options = {}) {
         this.agent = options.agent;
         this.team = options.team;
@@ -236,6 +225,8 @@ export class ReplV2 {
         this.onAskUserSimpleReady = options.onAskUserSimpleReady;
         this.onGuardrailReady = options.onGuardrailReady;
         this.onAskUserReady = options.onAskUserReady;
+        this.onProposeAlternativesReady = options.onProposeAlternativesReady;
+        this.onInteractiveFlowReady = options.onInteractiveFlowReady;
         this.onIterationLimitReady = options.onIterationLimitReady;
         this.onAgentFinish = options.onAgentFinish;
         this.onSuggestionReady = options.onSuggestionReady;
@@ -485,8 +476,16 @@ export class ReplV2 {
         if (teamAgent.agent) {
             this.agent = teamAgent.agent;
         }
-        // 4. Update meta-tool filter
-        setMetaToolFilter(teamAgent.toolFilter ?? null);
+        // 3b. Register multi-agent tools (consult always, handoff for
+        // specialists) using SDK factories. Coordinator path also fires here
+        // when a user explicitly switches to $default; the startup path
+        // covers it via restoreTeamForPrefix.
+        this.registerMultiAgentTools(teamAgent);
+        // Tool filtering for the new agent is already in effect — each team
+        // agent gets its own capability profile baked in at factory time via
+        // `agent.ts:467` (`capabilities.profile`). No runtime filter change
+        // needed here (audit TODO-15 removed the dead `setMetaToolFilter`
+        // call that used to live at this spot).
         // 5. Update footer UI
         if (agentId !== 'default') {
             this.ui.setActiveTeamAgent({
@@ -550,6 +549,171 @@ export class ReplV2 {
             demotedAgentId,
         };
     }
+    /**
+     * Register multi-agent tools (consult always, handoff for specialists)
+     * on the agent's underlying Agent using SDK factories.
+     *
+     * Tool grants:
+     * - **consult**: everyone (coordinator AND specialists). Lightweight
+     *   "ask another agent a focused question" tool. Originally specced as
+     *   specialist-only, but empirical evidence (session 220) showed the
+     *   coordinator's LLM grabs the wrong tool (e.g. `suggest`) when the
+     *   user says "consult $pm" because no tool by that name was in its
+     *   registry. delegate is too heavyweight for a quick question.
+     * - **handoff**: specialists only. Coordinators delegate, they don't
+     *   pass the baton. $default → specialist already has delegate.
+     * - **delegate / delegate_background**: coordinator only, via the
+     *   existing CLI tool-array path. Not touched here.
+     *
+     * Why lazy: the SDK factories need `team` + `currentAgentId` at
+     * construction time. The CLI's tool array is built at module load
+     * when neither is known.
+     *
+     * Dedupe via `specialistToolsRegistered` set — tools are registered
+     * once per agent for the lifetime of the REPL. Mirrors Desktop's
+     * pattern in `agent-manager.ts:registerDelegateToolsIfNeeded`.
+     *
+     * Called from:
+     * - `switchAgent` (every agent switch — covers specialists).
+     * - `restoreTeamForPrefix` (team restoration — covers $default at
+     *   startup, since the coordinator is never switchTo'd from outside).
+     */
+    /**
+     * Called whenever `this.team` is reassigned (project switch, team
+     * restoration). The SDK's createConsultTool factory captures the `team`
+     * argument in its closure at construction time, so a tool registered
+     * against the old team has a stale roster view. We must:
+     *   1. Unregister the stale consult/handoff tools from $default's
+     *      registry (Agent.registerTools throws on duplicate-name, it
+     *      does not replace).
+     *   2. Re-register fresh tools bound to the new team.
+     *
+     * $default's underlying Agent is preserved across team swaps (the new
+     * team is set as default via setDefaultAgent), so its tool registry
+     * accumulates stale tools. Specialists' Agents are fresh after a swap,
+     * so they don't have stale tools to clean up — clearing the dedupe set
+     * is enough; they'll re-register on demand via switchAgent.
+     *
+     * Without this, `consult($pm)` from $default reports "no specialists
+     * available" because the closure references the fresh-startup team
+     * (which only had $default) instead of the restored/built team.
+     */
+    rebindMultiAgentToolsAfterTeamSwap() {
+        this.specialistToolsRegistered.clear();
+        const defaultTeamAgent = this.team?.get('default');
+        if (defaultTeamAgent?.agent) {
+            // Cast to access the unregister method — it's on
+            // DefaultToolRegistry but not on the public ToolRegistry interface.
+            const registry = defaultTeamAgent.agent.getToolRegistry();
+            // Unregister every tool registerMultiAgentTools may have added to
+            // the coordinator on a previous call. Re-registration would fail
+            // with "Tool already registered" otherwise.
+            registry.unregister?.('consult');
+            registry.unregister?.('handoff');
+            registry.unregister?.('delegate');
+            registry.unregister?.('delegate_background');
+            this.registerMultiAgentTools(defaultTeamAgent);
+        }
+    }
+    registerMultiAgentTools(teamAgent) {
+        if (!teamAgent.agent)
+            return;
+        if (!this.team)
+            return;
+        if (this.specialistToolsRegistered.has(teamAgent.id))
+            return;
+        const team = this.team;
+        const currentAgentId = teamAgent.id;
+        const tools = [];
+        // Consult — available to everyone.
+        tools.push(createConsultTool({
+            team,
+            currentAgentId,
+            onConsult: async (targetId, question, context) => {
+                const handler = getConsultHandler();
+                if (!handler) {
+                    return {
+                        answer: '',
+                        error: 'Consult handler not initialised. This shouldn\'t happen in normal use.',
+                    };
+                }
+                const result = await handler({ agentId: targetId, question, context });
+                return { answer: result.answer, error: result.error };
+            },
+        }));
+        // Handoff — specialists only (per multi-agent-tools-taxonomy-spec.md §2:
+        // handoff is the specialist's vocabulary for passing the baton).
+        if (teamAgent.id !== 'default') {
+            tools.push(createHandoffTool({
+                team,
+                currentAgentId,
+                onHandoff: async (targetId, task, reason) => {
+                    const handler = getHandoffHandler();
+                    if (!handler) {
+                        return {
+                            success: false,
+                            error: 'Handoff handler not initialised. This shouldn\'t happen in normal use.',
+                        };
+                    }
+                    const result = await handler({ agentId: targetId, task, reason });
+                    return {
+                        success: result.success,
+                        declined: result.declined,
+                        error: result.error,
+                    };
+                },
+            }));
+        }
+        // Delegate + delegate_background — coordinator only (per taxonomy spec
+        // §2: coordinators push work down, specialists pass the baton). Built
+        // via the SDK factories (same pattern as consult/handoff above) and
+        // bridged to the existing shared-handlers registry where the actual
+        // approval-overlay + specialist-run code lives.
+        if (teamAgent.id === 'default') {
+            tools.push(createDelegateTool({
+                team,
+                currentAgentId,
+                onDelegate: async (targetId, task, reason) => {
+                    const handler = getDelegateHandler();
+                    if (!handler) {
+                        return {
+                            success: false,
+                            error: "Delegate handler not initialised. This shouldn't happen in normal use.",
+                        };
+                    }
+                    const result = await handler({ agentId: targetId, task, reason });
+                    return {
+                        success: result.success,
+                        declined: result.declined,
+                        response: result.response,
+                        error: result.error,
+                    };
+                },
+            }));
+            tools.push(createDelegateBackgroundTool({
+                team,
+                currentAgentId,
+                onDelegateBackground: async (args) => {
+                    const handler = getDelegateBackgroundHandler();
+                    if (!handler) {
+                        return {
+                            delegationId: '',
+                            status: 'running',
+                            error: "delegate_background handler not initialised. This shouldn't happen in normal use.",
+                        };
+                    }
+                    return await handler({
+                        agentId: args.targetAgentId,
+                        task: args.task,
+                        todoIndex: args.todoIndex,
+                        expectedOutput: args.expectedOutput,
+                    });
+                },
+            }));
+        }
+        teamAgent.agent.registerTools(tools);
+        this.specialistToolsRegistered.add(teamAgent.id);
+    }
     /**
      * Bring a background agent to foreground.
      * Validates the agent has a background session, then delegates to switchAgent().
@@ -798,6 +962,16 @@ export class ReplV2 {
                     displayName: a.displayName,
                     mascot: a.mascot,
                 })));
+                // Register multi-agent tools on $default so it has consult available
+                // from the first message — covers brand-new projects where the team
+                // has only $default and restoreTeamForPrefix early-returns before
+                // hitting its registration block (size <= 1 check).
+                // Dedupe via specialistToolsRegistered set, so this is safe to call
+                // alongside the restoreTeamForPrefix path.
+                const defaultTeamAgent = this.team.get('default');
+                if (defaultTeamAgent) {
+                    this.registerMultiAgentTools(defaultTeamAgent);
+                }
             }
         }
         catch {
@@ -885,6 +1059,37 @@ export class ReplV2 {
                 return result ?? { answers: {}, skipped: options.questions.map((q) => q.id) };
             });
         }
+        // Provide the propose_alternatives overlay function to the caller
+        if (this.onProposeAlternativesReady) {
+            const ui = this.ui;
+            this.onProposeAlternativesReady(async (options) => {
+                const overlay = new ProposeAlternativesOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                // No-overlay-result (Esc to dismiss overlay outside our key handler)
+                // → treat as rejected so the agent gets a defined shape.
+                return (result ?? {
+                    chosenIndex: 0,
+                    chosenTitle: options.alternatives[0]?.title ?? '',
+                    rejected: true,
+                });
+            });
+        }
+        // Provide the build_interactive_flow overlay function to the caller
+        if (this.onInteractiveFlowReady) {
+            const ui = this.ui;
+            this.onInteractiveFlowReady(async (options) => {
+                const overlay = new InteractiveFlowOverlayV2(options);
+                const result = await ui.showOverlay(overlay);
+                return (result ?? {
+                    completed: false,
+                    path: [],
+                    answers: {},
+                    answerLabels: {},
+                    abortReason: 'unknown',
+                    durationMs: 0,
+                });
+            });
+        }
         // Provide the iteration_limit overlay function to the caller
         if (this.onIterationLimitReady) {
             const ui = this.ui;
@@ -1218,6 +1423,26 @@ export class ReplV2 {
                 scope: 'session',
             });
         }
+        // Rebind multi-agent tools to the freshly restored team. Without this,
+        // any consult tool previously registered on $default (in start()) is
+        // bound to the pre-restoration team and reports a stale roster.
+        this.rebindMultiAgentToolsAfterTeamSwap();
+        // Update the footer to show the restored active agent's badge.
+        // start() set the footer to the pre-restore default during its sync
+        // path (line ~1437) — handleStartupSequence then ran asynchronously
+        // and got here. If the team was saved with a specialist active, the
+        // footer would otherwise still show "no specialist active" (blank).
+        const restoredActive = persistedTeam.getActive();
+        if (restoredActive.id !== 'default') {
+            this.ui.setActiveTeamAgent({
+                id: restoredActive.id,
+                displayName: restoredActive.displayName,
+                mascot: restoredActive.mascot,
+            });
+        }
+        else {
+            this.ui.setActiveTeamAgent(null);
+        }
         // Sync roster to session registry
         const registry = getSessionRegistry();
         if (registry) {
@@ -1745,6 +1970,9 @@ export class ReplV2 {
                         mascot: agent.mascot,
                     }));
                 });
+                // Rebind multi-agent tools so consult/handoff closures point at
+                // the new team's roster instead of the pre-swap team.
+                this.rebindMultiAgentToolsAfterTeamSwap();
                 return oldTeam;
             },
             restoreAgent: (newAgent) => {
@@ -2312,6 +2540,13 @@ export class ReplV2 {
                     this.textAccumulator = '';
                     let lastToolInput = null;
                     let pendingDiffLines;
+                    // Track what was actually rendered to the user this turn. Some models
+                    // (Gemini Flash Lite, occasionally) end a turn with zero text output,
+                    // which looks like a hang/failure on the terminal. We surface a
+                    // diagnostic in that case so the user knows the turn completed even
+                    // though nothing was said.
+                    let hasRenderedAgentText = false;
+                    let hasToolCalls = false;
                     // Stream agent events (agent is guaranteed to exist in this method)
                     const agent = this.agent;
                     if (!agent)
@@ -2411,9 +2646,11 @@ export class ReplV2 {
                                     agentId: activeAgentId,
                                 });
                                 this.textAccumulator = '';
+                                hasRenderedAgentText = true;
                             }
                             // Track tool calls for per-turn metrics
                             this.ui.incrementToolCalls();
+                            hasToolCalls = true;
                             // Record tool usage for telemetry
                             if (event.name) {
                                 getAuthManager().recordTool(event.name);
@@ -2455,7 +2692,7 @@ export class ReplV2 {
                                 this.ui.addBashCommand(event.toolUseId, command);
                             }
                             // Update spinner with tool name (skip silent tools)
-                            if (!this.agent?.isToolSilent(event.name) && !isMetaToolSilent(event.name)) {
+                            if (!this.agent?.isToolSilent(event.name)) {
                                 if (event.name === 'task' && event.toolUseId) {
                                     const subagentType = typeof lastToolInput.subagent_type === 'string'
                                         ? lastToolInput.subagent_type
@@ -2532,10 +2769,12 @@ export class ReplV2 {
                                 this.ui.setCurrentTool(null);
                                 continue;
                             }
-                            // Handle todo_write - update UI state from todoStore
-                            // (store is already updated by the tool's execute handler, regardless of
-                            // whether the tool was called directly or via the meta-registry fallback)
-                            if (toolName === 'todo_write') {
+                            // Handle todo_write / todo_claim / todo_handoff — all three
+                            // mutate the same store, so the UI's todos snapshot needs to
+                            // refresh on any of them. Previously only todo_write did this,
+                            // so the owner badge (@agent-id) silently never appeared
+                            // after a claim/handoff even though the renderer supports it.
+                            if (toolName === 'todo_write' || toolName === 'todo_claim' || toolName === 'todo_handoff') {
                                 // Get todos in creation order (getAll() sorts by status which breaks
                                 // task numbering — the footer renderer handles status sorting itself)
                                 const storeTodos = todoStore.getAll()
@@ -2560,9 +2799,10 @@ export class ReplV2 {
                                 this.ui.setCurrentTool(null);
                                 continue;
                             }
-                            // Skip silent tools (no output needed)
-                            // Check both direct registry and meta-registry for the silent flag
-                            if (this.agent?.isToolSilent(toolName) || isMetaToolSilent(toolName)) {
+                            // Skip silent tools (no output needed). The agent's
+                            // tool registry is the single source of truth post-TODO-15
+                            // (the CLI's parallel MetaToolsRegistry was dead).
+                            if (this.agent?.isToolSilent(toolName)) {
                                 this.ui.setCurrentTool(null);
                                 continue;
                             }
@@ -2611,7 +2851,7 @@ export class ReplV2 {
                                 this.ui.print({
                                     type: 'tool-result',
                                     name: innerToolName,
-                                    params: this.formatToolParams(innerArgs),
+                                    params: this.formatToolParams(innerArgs, innerToolName),
                                     summary,
                                     content: content || undefined,
                                     diffLines: innerDiffLines,
@@ -2686,7 +2926,7 @@ export class ReplV2 {
                             this.ui.print({
                                 type: 'tool-result',
                                 name: toolName,
-                                params: this.formatToolParams(toolInput),
+                                params: this.formatToolParams(toolInput, toolName),
                                 summary,
                                 content: content || undefined,
                                 diffLines,
@@ -2763,6 +3003,21 @@ export class ReplV2 {
                     // Flush remaining text (PLAN_READY marker detection removed — plan_submit tool handles approval)
                     if (this.textAccumulator.trim()) {
                         this.ui.print({ type: 'agent-text', text: this.textAccumulator.trim(), expression: this.getActiveAgentMascot(), agentId: activeAgentId });
+                        hasRenderedAgentText = true;
+                    }
+                    // Diagnostic for silent turns — some models occasionally finish a
+                    // turn without emitting any user-facing text. Without this, the
+                    // terminal just shows the metrics line under the user's input
+                    // (e.g. `── 1s · ↓ 20.4k ↑ 15 ──`) and the user is left guessing
+                    // whether the agent crashed, is still thinking, or just decided
+                    // not to respond. Surface a clear status line instead.
+                    if (!hasRenderedAgentText && !signal.aborted) {
+                        this.ui.print({
+                            type: 'info',
+                            message: hasToolCalls
+                                ? '(no follow-up text after tool calls — the tool result above is the response)'
+                                : '(silent turn — the model produced no output. Re-ask, or try a different model.)',
+                        });
                     }
                     // Print per-turn summary before stopping agent
                     this.printTurnSummary();
@@ -3163,7 +3418,7 @@ export class ReplV2 {
             // Silently fail - session/team saving is best-effort
         }
     }
-    formatToolParams(input) {
+    formatToolParams(input, toolName) {
         if (!input)
             return '';
         // Format common params
@@ -3175,6 +3430,80 @@ export class ReplV2 {
             return String(input.pattern);
         if ('command' in input)
             return truncate(String(input.command), 50);
+        // ask_user: show the question headers (or first-question-text fallback)
+        // instead of the raw JSON array. Some providers (Gemini Flash via
+        // OpenAI compat, etc.) ship the questions field as a JSON-stringified
+        // string rather than a parsed array, so try parsing if needed.
+        if (toolName === 'ask_user') {
+            const rawQuestions = input.questions;
+            let questions = null;
+            if (Array.isArray(rawQuestions)) {
+                questions = rawQuestions;
+            }
+            else if (typeof rawQuestions === 'string') {
+                try {
+                    const parsed = JSON.parse(rawQuestions);
+                    if (Array.isArray(parsed)) {
+                        questions = parsed;
+                    }
+                }
+                catch {
+                    /* fall through to default */
+                }
+            }
+            if (questions) {
+                const headers = questions.map((q) => {
+                    if (typeof q.header === 'string' && q.header.length > 0)
+                        return q.header;
+                    if (typeof q.question === 'string')
+                        return q.question;
+                    return '?';
+                });
+                return truncate(headers.join(', '), 50);
+            }
+        }
+        // build_interactive_flow: show flow.title (same JSON-string fallback)
+        if (toolName === 'build_interactive_flow') {
+            let flow = input.flow;
+            if (typeof flow === 'string') {
+                try {
+                    flow = JSON.parse(flow);
+                }
+                catch {
+                    /* fall through */
+                }
+            }
+            if (flow && typeof flow === 'object' && 'title' in flow) {
+                const f = flow;
+                if (typeof f.title === 'string') {
+                    return truncate(f.title, 50);
+                }
+            }
+        }
+        // propose_alternatives: show alternative titles. Same defensive JSON
+        // parse as ask_user above — some providers JSON-stringify nested arrays.
+        if (toolName === 'propose_alternatives') {
+            const raw = input.alternatives;
+            let alternatives = null;
+            if (Array.isArray(raw)) {
+                alternatives = raw;
+            }
+            else if (typeof raw === 'string') {
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed)) {
+                        alternatives = parsed;
+                    }
+                }
+                catch {
+                    /* fall through to default */
+                }
+            }
+            if (alternatives) {
+                const titles = alternatives.map((a) => typeof a.title === 'string' ? a.title : '?');
+                return truncate(titles.join(', '), 50);
+            }
+        }
         // Default: show first param
         const keys = Object.keys(input);
         if (keys.length > 0) {