Add way to hide tool calls/output in TUI

+1

+1

A useful refinement would be a latest-turn-only display mode rather than hiding all tool activity.

Desired behavior:

• Keep commands and tool output from the current/latest completed turn visible.
• Once a newer turn starts or completes, automatically collapse or hide tool cells from older turns.
• Keep the user prompts and assistant responses visible.
• Preserve the full transcript for the model and for explicit transcript inspection.

For example:

[tui]
tool_output_history = "latest-turn" # all | latest-turn | hidden

This would keep the current work inspectable without letting command output dominate scrollback during longer conversations. /clear is not an adequate workaround because it resets the task context instead of only cleaning up the presentation.

Environment: Codex CLI 0.144.1, Windows/PowerShell.

Please add a focus mode, similar to Claude Code’s /focus, that shows only user prompts and final responses while hiding tool calls and command output. Full details should remain accessible via Ctrl+T.

Another vote for this. In long interactive CLI sessions, repeated Ran ..., shell commands, find/git output, and similar tool activity quickly dominate the transcript and make the actual conversation hard to scan.

A configurable TUI mode such as tool_calls = "hidden" / "collapsed" would be very useful, while keeping approvals, errors, and safety-critical prompts visible. The complete tool transcript could remain accessible through Ctrl+T or an explicit transcript view.

The key requirement is to keep the interactive CLI workflow, not switch to codex exec just to get a cleaner display.

Another concrete use case is an MCP tool with a large generated code or query argument. Codex currently renders the full serialized invocation, for example:

* Called
  context-mode.ctx_execute({"language":"javascript","code":"<long generated program>"})
  <tool result>

For this case, fully hiding tool activity is not necessarily required. A compact, meaningful one-line description would be much more useful than displaying the complete payload.

A possible design (names only illustrative):

[tui]
tool_calls = "compact"          # full | compact | name-only | hidden
tool_argument_max_chars = 200
tool_result_max_chars = 1000

Per-MCP-server overrides would also help because tools have very different payload shapes:

[tui.mcp_servers.context-mode]
tool_calls = "compact"
tool_argument_max_chars = 0
tool_result_max_chars = 500

For compact mode, Codex could prefer an optional one-sentence invocation summary supplied with the call, for example summary: "Inspect worker completion state", or equivalent standardized MCP metadata. If no summary is supplied, it could fall back to server.tool(...) with bounded arguments.

The complete arguments and result should remain preserved in the transcript and available through an explicit expand/detail action. Approvals, errors, and safety-relevant messages should remain visible regardless of display mode.

Separate argument and result limits matter: code-execution and search tools can have a very large input but a small, useful result. This would preserve auditability while preventing generated source code or queries from dominating terminal scrollback.

This commit reduces the tool call output significantly and brings the TUI in line with the desktop app in terms of what is displayed for tool calls. You can still use Ctrl+T to show full tool outputs. This change will be in the 0.148.0 release. Let's see how that feels. I'm hoping that we can avoid adding another toggle or config option since we already have Ctrl+T.

Still reproducible on codex-cli 0.149.1 on macOS arm64, after the 0.148.0 display reduction referenced above.

In the normal TUI, successful app-backed tool calls still render as multi-line entries such as:

• Called
  └ codex_apps.github.fetch_pr({...})
    └ Action completed.

Calls such as codex_apps.github.fetch_file also display serialized arguments and status across multiple wrapped rows. A short read-only investigation can fill the viewport with these entries and separate the useful conversation from the final result. This is not raw-output mode.

The remaining gap appears especially noticeable for app/MCP calls. Ideally, completed successful calls would render as one compact line—or as a turn-level “N tool calls” group—with full arguments and results available through Ctrl+T or an explicit expand action. Active calls, failures, approvals, and security-relevant events should remain visible.

One implementation detail explains why this persists for ordinary MCP tools. In the current renderer:

let node_repl = self.result_kind() == McpResultKind::NodeRepl;
let compact = node_repl && mode == McpToolCallRenderMode::Display;

Therefore an ordinary MCP call such as context-mode.ctx_execute_file is classified as Standard, compact remains false, and normal TUI history uses format_mcp_invocation, which prints the full generated program and arguments.

Source: https://github.com/openai/codex/blob/main/codex-rs/tui/src/history_cell/mcp.rs#L123-L165

The desired change is presentation-only:

• normal TUI: • Called context-mode.ctx_execute_file (or a bounded summary);
• Ctrl+T transcript: complete invocation and result;
• MCP data available to the model: complete and unchanged.

A global or per-server compact / name-only display option would provide this without changing MCP behavior or model context.

@zzelner could someone please look into this? It would be very much appreciated. The cli output is polluted and unusable because of this limitation, and frankly becoming more annoying by the day.