Slash completion lists each /login provider exactly once by its provider id; numbered selector aliases remain accepted but are not shown as duplicate login choices. Planning is conversational rather than a separate mode: ask Dext to inspect and propose a plan without editing, revise it in the same thread, then tell it to proceed. The retired /plan command is no longer intercepted, so equivalent text is handled as an ordinary prompt. When a prompt reads as planning/analysis-only (for example “plan …”, “review …”, “don’t change anything”), Dext injects an advisory-only turn policy into the volatile runtime status directing read-only tools and a structured Goal/Findings/Steps/Risks answer; a bare approval such as “go” or “proceed with the plan” injects an implementation policy directing the agreed plan into todos before editing. Explicit mutation requests always win over scoping clauses, question-phrased prompts (ending in ?) are never treated as approvals, and mid-turn queued user updates re-evaluate the policy so a steering approval or hold-off takes effect immediately. The policy note steers rather than blocks — approval prompts and /sandbox-profile read-only remain the deterministic enforcement layers for untrusted or weaker models.
-
Structured listings from /help, /tools, /system, packs, shelves, and sessions follow the established /sessions presentation: a compact count header, bold section labels, two-space entry names, four-space details, blank-separated blocks, and a detached Use: footer. Long descriptions and prompt/list bodies wrap to the terminal width minus a two-cell gutter, capped at 100 columns, without reflowing the compact session header, metadata, and footer lines. Dynamic names, descriptions, metadata, and commands have terminal escapes and controls removed before layout; interactive output then adds only renderer-owned ANSI styling, which the TUI preserves while removing unsupported escape and control sequences.
+
Structured listings from /help, /tools, /system, packs, shelves, and sessions retain the established /sessions hierarchy: compact count headers, bold section labels, two-space names, four-space details, and detached Use: footers. Dense name/description catalogs such as /help use aligned rows at 64 columns and wider, with hanging description wraps, and fall back to stacked rows on narrow panes. The TUI passes its actual transcript-pane width into slash rendering; output keeps a two-cell gutter and a 120-column readability cap. /system preserves prompt paragraphs, blank lines, and leading indentation while wrapping prose rather than hard-splitting every display-width chunk. Dynamic fields have terminal escapes, controls, line separators, and bidi formatting controls removed before layout. Every physical row is bounded by Unicode display cells; only a grapheme that cannot fit in an otherwise impossible one-cell measure is replaced with ?. An explicit structured-slash event keeps listings free of dim bullet prefixes when ANSI color is disabled; generic confirmations such as /model and thinking-effort status retain the faded info treatment.
| Command | Description |
|---|
/help | Show available commands as a grouped listing in the established /sessions presentation |
diff --git a/src/events.rs b/src/events.rs
index 0e873d6..c23b961 100644
--- a/src/events.rs
+++ b/src/events.rs
@@ -119,6 +119,7 @@ pub(crate) enum AgentEvent {
Warn(String),
Error(String),
Slash(String),
+ StructuredSlash(String),
TurnEnd {
usage: Usage,
failed: bool,
diff --git a/src/list_render.rs b/src/list_render.rs
index f6e6137..065fd99 100644
--- a/src/list_render.rs
+++ b/src/list_render.rs
@@ -13,6 +13,7 @@ use std::path::Path;
use crate::session::user_home_dir;
const DEFAULT_WIDTH: usize = 100;
+const MAX_WIDTH: usize = 120;
// Keep wrapped text off the terminal's right edge and cap the measure for
// readability on wide terminals.
const RIGHT_GUTTER: usize = 2;
@@ -27,10 +28,10 @@ pub(crate) struct ListOptions {
}
impl ListOptions {
- pub(crate) fn detect(verbose: bool) -> Self {
+ pub(crate) fn detect_with_width(verbose: bool, width: Option) -> Self {
Self {
color: use_color(),
- width: terminal_width(),
+ width: width.map_or_else(terminal_width, width_for_terminal_cols),
verbose,
}
}
@@ -63,7 +64,7 @@ pub(crate) fn use_color() -> bool {
/// clamped to a readable maximum measure. Non-TTY output (pipes, redirects,
/// tests) keeps the fixed default.
pub(crate) fn width_for_terminal_cols(cols: usize) -> usize {
- cols.saturating_sub(RIGHT_GUTTER).clamp(1, DEFAULT_WIDTH)
+ cols.saturating_sub(RIGHT_GUTTER).clamp(1, MAX_WIDTH)
}
pub(crate) fn terminal_width() -> usize {
@@ -111,6 +112,17 @@ fn terminal_escape_end(text: &str, start: usize) -> usize {
i.min(bytes.len())
}
+fn is_bidi_format_control(ch: char) -> bool {
+ matches!(
+ ch,
+ '\u{061c}'
+ | '\u{200e}'
+ | '\u{200f}'
+ | '\u{202a}'..='\u{202e}'
+ | '\u{2066}'..='\u{2069}'
+ )
+}
+
fn terminal_safe_text(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut i = 0usize;
@@ -129,9 +141,9 @@ fn terminal_safe_text(text: &str) -> String {
out.push('\n');
}
}
- '\n' => out.push(ch),
+ '\n' | '\u{2028}' | '\u{2029}' => out.push('\n'),
'\t' => out.push_str(" "),
- _ if ch.is_control() => {}
+ _ if ch.is_control() || is_bidi_format_control(ch) => {}
_ => out.push(ch),
}
}
@@ -204,23 +216,29 @@ pub(crate) fn display_path(path: &Path, opts: &ListOptions, root: &Path) -> Stri
// --- word wrap --------------------------------------------------------------
-fn word_chunks(word: &str, width: usize) -> Vec<&str> {
+fn word_chunks(word: &str, width: usize) -> Vec {
let mut chunks = Vec::new();
- let mut start = 0usize;
+ let mut chunk = String::new();
let mut cells = 0usize;
- for c in crate::tui::display_clusters(word) {
- if cells > 0 && cells + c.width > width {
- chunks.push(&word[start..c.byte_start]);
- start = c.byte_start;
+ for cluster in crate::tui::display_clusters(word) {
+ let source = &word[cluster.byte_start..cluster.byte_start + cluster.byte_len];
+ let (text, cluster_width) = if cluster.width > width {
+ ("?", 1)
+ } else {
+ (source, cluster.width)
+ };
+ if cells > 0 && cells + cluster_width > width {
+ chunks.push(std::mem::take(&mut chunk));
cells = 0;
}
- cells += c.width;
+ chunk.push_str(text);
+ cells += cluster_width;
}
- if start < word.len() {
- chunks.push(&word[start..]);
+ if !chunk.is_empty() {
+ chunks.push(chunk);
}
if chunks.is_empty() {
- chunks.push(word);
+ chunks.push(word.to_string());
}
chunks
}
@@ -242,17 +260,17 @@ pub(crate) fn wrap_lines(text: &str, width: usize) -> Vec {
let mut line_w = 0usize;
for word in words {
for chunk in word_chunks(word, width) {
- let w = unicode_width::UnicodeWidthStr::width(chunk);
+ let w = unicode_width::UnicodeWidthStr::width(chunk.as_str());
if line.is_empty() {
- line.push_str(chunk);
+ line.push_str(&chunk);
line_w = w;
} else if line_w + 1 + w > width {
out.push(std::mem::take(&mut line));
- line.push_str(chunk);
+ line.push_str(&chunk);
line_w = w;
} else {
line.push(' ');
- line.push_str(chunk);
+ line.push_str(&chunk);
line_w += 1 + w;
}
}
@@ -278,18 +296,42 @@ pub(crate) fn write_wrapped(out: &mut String, text: &str, hang: usize, width: us
}
}
-/// Preserve input line boundaries while hard-wrapping each line to the display
-/// width. Terminal controls are removed before rendering.
+/// Preserve input line and indentation boundaries while word-wrapping prose.
+/// Oversized tokens are split only when they cannot fit on an otherwise empty line.
pub(crate) fn write_preformatted_wrapped(out: &mut String, text: &str, width: usize) {
let safe = terminal_safe_text(text);
let width = width.max(1);
for line in safe.split('\n') {
- if line.is_empty() {
+ if line.trim().is_empty() {
out.push('\n');
- } else {
- for chunk in word_chunks(line, width) {
- let _ = writeln!(out, "{chunk}");
- }
+ continue;
+ }
+ let body = line.trim_start_matches(' ');
+ let indent = line
+ .len()
+ .saturating_sub(body.len())
+ .min(width.saturating_sub(1));
+ let padding = " ".repeat(indent);
+ for wrapped in wrap_lines(body, width.saturating_sub(indent).max(1)) {
+ let _ = writeln!(out, "{padding}{wrapped}");
+ }
+ }
+}
+
+fn write_indented_preformatted(
+ out: &mut String,
+ text: &str,
+ indent: usize,
+ width: usize,
+ color: bool,
+) {
+ let width = width.max(1);
+ let indent = indent.min(width.saturating_sub(1));
+ let body_width = width.saturating_sub(indent).max(1);
+ let padding = " ".repeat(indent);
+ for source_line in text.split('\n') {
+ for chunk in word_chunks(source_line, body_width) {
+ let _ = writeln!(out, "{padding}{}", bold(&chunk, color));
}
}
}
@@ -299,13 +341,119 @@ pub(crate) fn write_preformatted_wrapped(out: &mut String, text: &str, width: us
/// Render one compact four-space-indented metadata line. Embedded line breaks
/// remain indented so untrusted values cannot escape the detail column.
pub(crate) fn render_metadata(meta: &[(&str, String)], opts: &ListOptions) -> String {
- let pairs: Vec = meta
+ let width = opts.effective_width();
+ let safe_pairs: Vec<(String, String)> = meta
+ .iter()
+ .map(|(key, value)| {
+ (
+ terminal_safe_text(key).trim().to_string(),
+ terminal_safe_text(value),
+ )
+ })
+ .collect();
+ if safe_pairs.is_empty() {
+ return String::new();
+ }
+ let metadata_indent = 4.min(width.saturating_sub(1));
+ let metadata_padding = " ".repeat(metadata_indent);
+ let inline_plain = safe_pairs
+ .iter()
+ .map(|(key, value)| format!("{key}: {value}"))
+ .collect::>()
+ .join(" ");
+ let mut out = String::new();
+ if !inline_plain.contains('\n')
+ && metadata_indent
+ .saturating_add(unicode_width::UnicodeWidthStr::width(inline_plain.as_str()))
+ <= width
+ {
+ let inline_styled = safe_pairs
+ .iter()
+ .map(|(key, value)| label(&format!("{key}:"), value, opts.color))
+ .collect::>()
+ .join(" ");
+ let _ = writeln!(out, "{metadata_padding}{inline_styled}");
+ return out;
+ }
+
+ let body_width = width.saturating_sub(metadata_indent).max(1);
+ for (key, value) in safe_pairs {
+ let key = format!("{key}:");
+ let pair = if value.is_empty() {
+ key.clone()
+ } else {
+ format!("{key} {value}")
+ };
+ for (index, row) in wrap_lines(&pair, body_width).into_iter().enumerate() {
+ if index == 0
+ && let Some(rest) = row.strip_prefix(&key)
+ {
+ let _ = writeln!(
+ out,
+ "{metadata_padding}{}",
+ label(&key, rest.trim_start(), opts.color)
+ );
+ } else {
+ let _ = writeln!(out, "{metadata_padding}{row}");
+ }
+ }
+ }
+ out
+}
+
+/// Render compact name/description rows. Wide views align descriptions into a
+/// shared column; narrow views retain the familiar stacked session hierarchy.
+pub(crate) fn render_entry_rows(entries: &[(&str, &str)], opts: &ListOptions) -> String {
+ const MIN_COLUMNS_WIDTH: usize = 64;
+ const MAX_NAME_WIDTH: usize = 38;
+ const DESCRIPTION_GAP: usize = 3;
+
+ let width = opts.effective_width();
+ let safe_entries: Vec<(String, String)> = entries
.iter()
- .map(|(k, v)| label(&format!("{k}:"), v, opts.color))
+ .map(|(name, description)| {
+ (
+ terminal_safe_text(name).trim().to_string(),
+ terminal_safe_text(description).trim().to_string(),
+ )
+ })
.collect();
+ let name_width = safe_entries
+ .iter()
+ .map(|(name, _)| unicode_width::UnicodeWidthStr::width(name.as_str()))
+ .max()
+ .unwrap_or(0)
+ .min(MAX_NAME_WIDTH);
+ let description_indent = 2 + name_width + DESCRIPTION_GAP;
+ let use_columns = width >= MIN_COLUMNS_WIDTH
+ && description_indent.saturating_add(20) <= width
+ && safe_entries.iter().all(|(name, _)| {
+ !name.contains('\n')
+ && unicode_width::UnicodeWidthStr::width(name.as_str()) <= name_width
+ });
+
let mut out = String::new();
- for line in pairs.join(" ").split('\n') {
- let _ = writeln!(out, " {line}");
+ for (name, description) in safe_entries {
+ if !use_columns {
+ write_indented_preformatted(&mut out, &name, 2, width, opts.color);
+ if !description.is_empty() {
+ write_wrapped(&mut out, &description, 4, width);
+ }
+ continue;
+ }
+
+ let display_width = unicode_width::UnicodeWidthStr::width(name.as_str());
+ let padding = " ".repeat(name_width.saturating_sub(display_width) + DESCRIPTION_GAP);
+ let wrapped = wrap_lines(
+ &description,
+ width.saturating_sub(description_indent).max(1),
+ );
+ let first = wrapped.first().map_or("", String::as_str);
+ let _ = writeln!(out, " {}{padding}{first}", bold(&name, opts.color));
+ let continuation_padding = " ".repeat(description_indent);
+ for line in wrapped.iter().skip(1) {
+ let _ = writeln!(out, "{continuation_padding}{line}");
+ }
}
out
}
@@ -322,9 +470,7 @@ pub(crate) fn render_entry(
let mut out = String::new();
let hang = 4;
let safe_name = terminal_safe_text(name);
- for line in safe_name.split('\n') {
- let _ = writeln!(out, " {}", bold(line, opts.color));
- }
+ write_indented_preformatted(&mut out, &safe_name, 2, opts.effective_width(), opts.color);
let safe_description = terminal_safe_text(description);
if !safe_description.trim().is_empty() {
write_wrapped(
@@ -345,9 +491,7 @@ pub(crate) fn render_entry(
pub(crate) fn render_section_header(title: &str, opts: &ListOptions) -> String {
let mut out = String::new();
let safe_title = terminal_safe_text(title);
- for line in safe_title.split('\n') {
- let _ = writeln!(out, "{}", bold(line, opts.color));
- }
+ write_indented_preformatted(&mut out, &safe_title, 0, opts.effective_width(), opts.color);
out
}
@@ -356,9 +500,7 @@ pub(crate) fn render_footer(commands: &[&str], opts: &ListOptions) -> String {
let mut out = render_section_header("Use:", opts);
for cmd in commands {
let safe_cmd = terminal_safe_text(cmd);
- for line in safe_cmd.split('\n') {
- let _ = writeln!(out, " {line}");
- }
+ write_indented_preformatted(&mut out, &safe_cmd, 2, opts.effective_width(), false);
}
out
}
@@ -370,11 +512,27 @@ pub(crate) fn render_count_header(
noun: &str,
opts: &ListOptions,
) -> String {
- format!(
- "{} {}\n",
- bold(title, opts.color),
- dim(&format!("{count} {noun}"), opts.color),
- )
+ let safe_title = terminal_safe_text(title);
+ let count_label = terminal_safe_text(&format!("{count} {noun}"));
+ let compact = format!("{safe_title} {count_label}");
+ if !compact.contains('\n')
+ && unicode_width::UnicodeWidthStr::width(compact.as_str()) <= opts.effective_width()
+ {
+ return format!(
+ "{} {}\n",
+ bold(&safe_title, opts.color),
+ dim(&count_label, opts.color),
+ );
+ }
+
+ let mut out = String::new();
+ write_indented_preformatted(&mut out, &safe_title, 0, opts.effective_width(), opts.color);
+ for source_line in count_label.split('\n') {
+ for chunk in word_chunks(source_line, opts.effective_width()) {
+ let _ = writeln!(out, "{}", dim(&chunk, opts.color));
+ }
+ }
+ out
}
/// Discovery-list header line: `Title found`.
diff --git a/src/main.rs b/src/main.rs
index dce4d72..8c5d703 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1563,6 +1563,12 @@ impl OutputMode {
}
}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SlashPresentation {
+ Faded,
+ Structured,
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SlashUiUpdate {
None,
@@ -1761,7 +1767,7 @@ impl EventSink for ConsoleSink {
AgentEvent::Info(s) => println!("{s}"),
AgentEvent::Warn(s) => eprintln!("{s}"),
AgentEvent::Error(s) => eprintln!("{s}"),
- AgentEvent::Slash(s) => println!("{s}"),
+ AgentEvent::Slash(s) | AgentEvent::StructuredSlash(s) => println!("{s}"),
AgentEvent::TurnEnd { usage, .. } => {
println!(
"{}",
@@ -11107,7 +11113,7 @@ struct ToolsCommandResult {
fn render_tools_status(agent: &Agent) -> String {
use std::fmt::Write as _;
- let opts = list_render::ListOptions::detect(false);
+ let opts = list_render::ListOptions::detect_with_width(false, agent.slash_render_width);
let header = agent.session_header();
let mut out = String::new();
let _ = write!(
@@ -11192,7 +11198,7 @@ fn render_tools_status(agent: &Agent) -> String {
fn render_system_prompt_view(agent: &Agent) -> String {
use std::fmt::Write as _;
- let opts = list_render::ListOptions::detect(false);
+ let opts = list_render::ListOptions::detect_with_width(false, agent.slash_render_width);
let details = agent.compose_system_details();
let composed = format!("{}\n\n{}", details.stable, details.env);
let mut out = String::new();
@@ -11274,12 +11280,12 @@ const HELP_GROUPS: &[(&str, &[(&str, &str)])] = &[
),
(
"/approval [profile]",
- "ask|auto-read|auto-write|never|always",
+ "ask · auto-read · auto-write · never · always",
),
("/preview [mode]", "off|simple|git mutation previews"),
(
"/sandbox-profile [profile]",
- "read-only|workspace-write|danger-full-access",
+ "read-only · workspace-write · danger-full-access",
),
("/budget [cap|off]", "show/set budget cap ($ or tokens)"),
],
@@ -11328,11 +11334,11 @@ const HELP_GROUPS: &[(&str, &[(&str, &str)])] = &[
&[
(
"/effort [level]",
- "model reasoning depth/tool persistence: off|minimal|low|medium|high|xhigh|max",
+ "model reasoning depth/tool persistence: off · minimal · low · medium · high · xhigh · max",
),
(
"/reasoning-mode [mode]",
- "standard|pro (official OpenAI GPT-5.6 Responses only)",
+ "standard · pro (official OpenAI GPT-5.6 Responses only)",
),
(
"/context [standard|frugal]",
@@ -11372,7 +11378,7 @@ const HELP_GROUPS: &[(&str, &[(&str, &str)])] = &[
),
(
"/sessions",
- "list sessions; also analyze|brief|grep|failures|verify-log|decisions",
+ "list sessions; also analyze · brief · grep · failures · verify-log · decisions",
),
("/session", "alias for /sessions"),
("/hooks [reload]", "show hook config or reload from disk"),
@@ -11385,10 +11391,10 @@ const HELP_GROUPS: &[(&str, &[(&str, &str)])] = &[
),
];
-fn render_help_listing() -> String {
+fn render_help_listing(width: Option) -> String {
use std::fmt::Write as _;
- let opts = list_render::ListOptions::detect(false);
+ let opts = list_render::ListOptions::detect_with_width(false, width);
let total: usize = HELP_GROUPS.iter().map(|(_, entries)| entries.len()).sum();
let mut out = String::new();
let _ = write!(
@@ -11398,9 +11404,8 @@ fn render_help_listing() -> String {
);
for (group, entries) in HELP_GROUPS {
out.push_str(&list_render::render_section_header(group, &opts));
- for (cmd, desc) in *entries {
- out.push_str(&list_render::render_entry(cmd, desc, &[], &opts));
- }
+ out.push_str(&list_render::render_entry_rows(entries, &opts));
+ out.push('\n');
}
let _ = write!(
out,
@@ -13402,6 +13407,7 @@ struct Agent {
git_context: Option,
silent: bool,
pretty: bool,
+ slash_render_width: Option,
max_iterations: Option,
session_usage: Usage,
// Usage of the most recent provider request. This is the context-pressure
@@ -13621,6 +13627,7 @@ impl Agent {
git_context,
silent: false,
pretty,
+ slash_render_width: None,
max_iterations: None,
session_usage: Usage::default(),
last_request_usage: Usage::default(),
@@ -19073,8 +19080,12 @@ fn render_session_entry(
}
fn render_session_listing(root: &Path) -> String {
+ render_session_listing_width(root, None)
+}
+
+fn render_session_listing_width(root: &Path, width: Option) -> String {
use std::fmt::Write as _;
- let opts = list_render::ListOptions::detect(false);
+ let opts = list_render::ListOptions::detect_with_width(false, width);
let latest_path = latest_session_path(root);
let sessions_root = named_sessions_dir_for_root(root);
@@ -19109,7 +19120,7 @@ fn render_session_listing(root: &Path) -> String {
list_render::render_header("Sessions", total, &opts)
);
- let _ = writeln!(out, "{}", list_render::bold("Latest", opts.color));
+ out.push_str(&list_render::render_section_header("Latest", &opts));
if latest_exists {
let modified = latest_path.metadata().ok().and_then(|m| m.modified().ok());
out.push_str(&render_session_entry(
@@ -19120,42 +19131,58 @@ fn render_session_listing(root: &Path) -> String {
root,
));
} else {
- let _ = writeln!(
- out,
- " (none yet; send a message to create {})",
- list_render::display_path(&latest_path, &opts, root)
+ list_render::write_wrapped(
+ &mut out,
+ &format!(
+ "(none yet; send a message to create {})",
+ list_render::display_path(&latest_path, &opts, root)
+ ),
+ 4,
+ opts.effective_width(),
);
}
out.push('\n');
- let _ = writeln!(out, "{}", list_render::bold("Autosaved", opts.color));
+ out.push_str(&list_render::render_section_header("Autosaved", &opts));
if autosaved_sessions.is_empty() {
- let _ = writeln!(
- out,
- " (none in {})",
- list_render::display_path(&sessions_root, &opts, root)
+ list_render::write_wrapped(
+ &mut out,
+ &format!(
+ "(none in {})",
+ list_render::display_path(&sessions_root, &opts, root)
+ ),
+ 4,
+ opts.effective_width(),
);
} else {
for (name, path, modified) in autosaved_sessions.iter().take(SLASH_LIST_LIMIT) {
out.push_str(&render_session_entry(path, name, *modified, &opts, root));
}
if autosaved_sessions.len() > SLASH_LIST_LIMIT {
- let _ = writeln!(
- out,
- " … [{} more session dirs omitted]",
- autosaved_sessions.len() - SLASH_LIST_LIMIT
+ list_render::write_wrapped(
+ &mut out,
+ &format!(
+ "… [{} more session dirs omitted]",
+ autosaved_sessions.len() - SLASH_LIST_LIMIT
+ ),
+ 2,
+ opts.effective_width(),
);
}
}
out.push('\n');
- let _ = writeln!(out, "{}", list_render::bold("Named", opts.color));
+ out.push_str(&list_render::render_section_header("Named", &opts));
match &named_records {
Ok(records) if records.is_empty() => {
- let _ = writeln!(
- out,
- " (none in {}; use /save )",
- list_render::display_path(&named_sessions_dir_for_root(root), &opts, root)
+ list_render::write_wrapped(
+ &mut out,
+ &format!(
+ "(none in {}; use /save )",
+ list_render::display_path(&named_sessions_dir_for_root(root), &opts, root)
+ ),
+ 4,
+ opts.effective_width(),
);
}
Ok(records) => {
@@ -19169,15 +19196,24 @@ fn render_session_listing(root: &Path) -> String {
));
}
if records.len() > SLASH_LIST_LIMIT {
- let _ = writeln!(
- out,
- " … [{} more named sessions omitted]",
- records.len() - SLASH_LIST_LIMIT
+ list_render::write_wrapped(
+ &mut out,
+ &format!(
+ "… [{} more named sessions omitted]",
+ records.len() - SLASH_LIST_LIMIT
+ ),
+ 2,
+ opts.effective_width(),
);
}
}
Err(e) => {
- let _ = writeln!(out, " [err] {e:#}");
+ list_render::write_wrapped(
+ &mut out,
+ &format!("[err] {e:#}"),
+ 2,
+ opts.effective_width(),
+ );
}
}
@@ -21137,6 +21173,7 @@ fn diagnostics_approved(agent: &mut Agent) -> bool {
fn handle_slash(line: &str, agent: &mut Agent) -> Option {
use std::fmt::Write as _;
let mut ui_update = SlashUiUpdate::None;
+ let mut presentation = SlashPresentation::Faded;
let line = line.trim();
if !is_slash_command(line) {
return None;
@@ -21171,15 +21208,21 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
} else {
match sub {
"" | "list" | "ls" => {
+ presentation = SlashPresentation::Structured;
let (_, inline_verbose) = list_render::take_verbose(pack_arg);
let verbose = leading_verbose || inline_verbose;
let _ = write!(
w,
"{}",
- packs::render_pack_listing_opts(&agent.sandbox_root, verbose)
+ packs::render_pack_listing_opts_width(
+ &agent.sandbox_root,
+ verbose,
+ agent.slash_render_width,
+ )
);
}
"inspect" | "info" | "show" => {
+ presentation = SlashPresentation::Structured;
let selector = parts.next().unwrap_or("").trim();
if selector.is_empty() {
let _ = writeln!(w, "usage: /pack inspect ");
@@ -21236,14 +21279,19 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
}
}
"shelf" | "shelves" => {
+ presentation = SlashPresentation::Structured;
let _ = write!(
w,
"{}",
- shelves::render_registry_listing(&agent.shelf_registry)
+ shelves::render_registry_listing_width(
+ &agent.shelf_registry,
+ agent.slash_render_width,
+ )
);
}
"help" | "?" => {
- let _ = writeln!(w, "{}", render_help_listing());
+ presentation = SlashPresentation::Structured;
+ let _ = writeln!(w, "{}", render_help_listing(agent.slash_render_width));
}
"version" => {
let _ = writeln!(w, "dext {}", env!("CARGO_PKG_VERSION"));
@@ -21278,6 +21326,12 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
let _ = writeln!(w, "cleared {n} messages");
}
"tools" => {
+ if matches!(
+ arg.to_ascii_lowercase().as_str(),
+ "" | "status" | "list" | "ls"
+ ) {
+ presentation = SlashPresentation::Structured;
+ }
let result = handle_tools_command(agent, arg);
let _ = writeln!(w, "{}", result.output);
}
@@ -21303,6 +21357,7 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
}
"system" => {
if arg.is_empty() {
+ presentation = SlashPresentation::Structured;
let _ = writeln!(w, "{}", render_system_prompt_view(agent));
} else {
agent.system = arg.to_string();
@@ -21566,19 +21621,22 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
let _ = writeln!(w, "[err] {e:#}");
}
},
- "providers" => match (load_provider_catalog(), load_auth_store()) {
- (Ok(catalog), Ok(store)) => {
- let active = resolve_active_provider_id(&catalog);
- let _ = writeln!(w, "active provider: {active}");
- let _ = writeln!(w, "{}", render_provider_list(&catalog, &store, &active));
- let _ = writeln!(w, "provider catalog: {}", provider_catalog_path().display());
- let _ = writeln!(w, "auth store: {}", auth_store_path().display());
- let _ = writeln!(w, "runtime: {}", agent.provider_status_line());
- }
- (Err(e), _) | (_, Err(e)) => {
- let _ = writeln!(w, "[err] {e:#}");
+ "providers" => {
+ presentation = SlashPresentation::Structured;
+ match (load_provider_catalog(), load_auth_store()) {
+ (Ok(catalog), Ok(store)) => {
+ let active = resolve_active_provider_id(&catalog);
+ let _ = writeln!(w, "active provider: {active}");
+ let _ = writeln!(w, "{}", render_provider_list(&catalog, &store, &active));
+ let _ = writeln!(w, "provider catalog: {}", provider_catalog_path().display());
+ let _ = writeln!(w, "auth store: {}", auth_store_path().display());
+ let _ = writeln!(w, "runtime: {}", agent.provider_status_line());
+ }
+ (Err(e), _) | (_, Err(e)) => {
+ let _ = writeln!(w, "[err] {e:#}");
+ }
}
- },
+ }
"provider" => {
if arg.is_empty() {
let _ = writeln!(w, "{}", agent.provider_status_line());
@@ -21606,27 +21664,32 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
}
}
}
- "models" => match (load_provider_catalog(), load_auth_store()) {
- (Ok(catalog), Ok(store)) => {
- let active = resolve_active_provider_id(&catalog);
- let list = match arg {
- "" | "all" => list_models_for_available_providers(&catalog, &store, &active),
- _ => provider_id_from_selector(&catalog, arg)
- .and_then(|target| list_models_for_provider(&catalog, &target)),
- };
- match list {
- Ok(list) => {
- let _ = writeln!(w, "{list}");
- }
- Err(e) => {
- let _ = writeln!(w, "[err] {e:#}");
+ "models" => {
+ presentation = SlashPresentation::Structured;
+ match (load_provider_catalog(), load_auth_store()) {
+ (Ok(catalog), Ok(store)) => {
+ let active = resolve_active_provider_id(&catalog);
+ let list = match arg {
+ "" | "all" => {
+ list_models_for_available_providers(&catalog, &store, &active)
+ }
+ _ => provider_id_from_selector(&catalog, arg)
+ .and_then(|target| list_models_for_provider(&catalog, &target)),
+ };
+ match list {
+ Ok(list) => {
+ let _ = writeln!(w, "{list}");
+ }
+ Err(e) => {
+ let _ = writeln!(w, "[err] {e:#}");
+ }
}
}
+ (Err(e), _) | (_, Err(e)) => {
+ let _ = writeln!(w, "[err] {e:#}");
+ }
}
- (Err(e), _) | (_, Err(e)) => {
- let _ = writeln!(w, "[err] {e:#}");
- }
- },
+ }
"login" => {
if arg.eq_ignore_ascii_case("cancel") {
let cancelled_oauth = cancel_pending_oauth_login();
@@ -21638,6 +21701,7 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
let _ = writeln!(w, "no login is waiting for credentials");
}
} else if arg.is_empty() {
+ presentation = SlashPresentation::Structured;
match (load_provider_catalog(), load_auth_store()) {
(Ok(catalog), Ok(store)) => {
let active = resolve_active_provider_id(&catalog);
@@ -22062,12 +22126,17 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
}
}
"sessions" | "session" => {
+ presentation = SlashPresentation::Structured;
let mut parts = arg.splitn(2, char::is_whitespace);
let sub = parts.next().unwrap_or("");
let rest = parts.next().unwrap_or("").trim();
match sub {
"" | "list" => {
- let _ = write!(w, "{}", render_session_listing(&agent.sandbox_root));
+ let _ = write!(
+ w,
+ "{}",
+ render_session_listing_width(&agent.sandbox_root, agent.slash_render_width,)
+ );
}
"analyze" | "analysis" => {
let selector = if rest.is_empty() { "latest" } else { rest };
@@ -22298,7 +22367,10 @@ fn handle_slash(line: &str, agent: &mut Agent) -> Option {
if out.ends_with('\n') {
out.pop();
}
- agent.sink.emit(AgentEvent::Slash(out));
+ match presentation {
+ SlashPresentation::Faded => agent.sink.emit(AgentEvent::Slash(out)),
+ SlashPresentation::Structured => agent.sink.emit(AgentEvent::StructuredSlash(out)),
+ }
}
match ui_update {
SlashUiUpdate::None => {}
diff --git a/src/main_tests.rs b/src/main_tests.rs
index 6722e26..b47a01b 100644
--- a/src/main_tests.rs
+++ b/src/main_tests.rs
@@ -97,6 +97,7 @@ fn test_agent(root: &Path) -> Agent {
git_context: None,
silent: true,
pretty: false,
+ slash_render_width: None,
max_iterations: Some(1),
session_usage: Usage::default(),
last_request_usage: Usage::default(),
@@ -7314,8 +7315,9 @@ fn sessions_listing_includes_project_latest_without_named_sessions() -> Result<(
assert!(listing.contains("latest"), "{listing}");
assert!(listing.contains("Named"), "{listing}");
let project_named_dir = named_sessions_dir_for_root(&project);
+ let compact = listing.split_whitespace().collect::();
assert!(
- listing.contains(&format!("none in {}", project_named_dir.display())),
+ compact.contains(&format!("nonein{}", project_named_dir.display())),
"{listing}"
);
assert!(listing.contains("use /save "), "{listing}");
@@ -7370,8 +7372,17 @@ fn named_sessions_are_project_scoped_by_default() -> Result<()> {
assert_ne!(alpha_path, beta_path);
assert_eq!(resolve_session_selector(&alpha, "shared")?, alpha_path);
assert_eq!(resolve_session_selector(&beta, "shared")?, beta_path);
- assert!(render_session_listing(&alpha).contains(&alpha_path.display().to_string()));
- assert!(render_session_listing(&beta).contains(&beta_path.display().to_string()));
+ for (project, path) in [(&alpha, &alpha_path), (&beta, &beta_path)] {
+ let listing = render_session_listing_width(project, Some(40));
+ let compact = listing.split_whitespace().collect::();
+ assert!(compact.contains(&path.display().to_string()), "{listing}");
+ assert!(
+ listing
+ .lines()
+ .all(|line| unicode_width::UnicodeWidthStr::width(line) <= 40),
+ "{listing}"
+ );
+ }
Ok(())
})();
@@ -17385,6 +17396,28 @@ fn slash_tools_switches_specialized_tool_visibility() {
let _ = std::fs::remove_dir_all(&root);
}
+#[test]
+fn slash_presentation_distinguishes_structured_views_and_faded_confirmations() {
+ let root = temp_test_dir("slash-presentation");
+ let root = std::fs::canonicalize(root).expect("canonical temp dir");
+ let mut agent = test_agent(&root);
+ let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+ agent.set_sink(Box::new(ChannelSink { tx }));
+
+ assert_eq!(handle_slash("/help", &mut agent), Some(true));
+ assert_eq!(handle_slash("/effort high", &mut agent), Some(true));
+
+ let events = drain_events(&mut rx);
+ assert!(events.iter().any(
+ |event| matches!(event, AgentEvent::StructuredSlash(text) if text.contains("Commands"))
+ ));
+ assert!(events.iter().any(
+ |event| matches!(event, AgentEvent::Slash(text) if text.contains("thinking effort: high"))
+ ));
+
+ let _ = std::fs::remove_dir_all(&root);
+}
+
#[test]
fn slash_allow_and_allowed_include_active_runtime_tools() {
let root = temp_test_dir("slash-runtime-allow");
@@ -17442,7 +17475,7 @@ fn slash_system_displays_composed_prompt_with_project_context() {
let slash = drain_events(&mut rx)
.into_iter()
.find_map(|event| match event {
- AgentEvent::Slash(text) => Some(text),
+ AgentEvent::StructuredSlash(text) => Some(text),
_ => None,
})
.unwrap_or_default();
@@ -17526,6 +17559,7 @@ fn recall_prompt_injection_has_one_aggregate_four_kib_payload_budget() {
#[test]
fn recall_journal_digest_uses_redacted_input() {
+ let _guard = env_lock();
let root = temp_test_dir("recall-journal-redaction");
let mut agent = test_agent(&root);
agent.set_approval_profile(ApprovalProfile::Always);
@@ -26798,7 +26832,7 @@ fn slash_shelves_lists_typed_manifest_registry() {
let slash = drain_events(&mut rx)
.into_iter()
.find_map(|event| match event {
- AgentEvent::Slash(text) => Some(text),
+ AgentEvent::StructuredSlash(text) => Some(text),
_ => None,
})
.unwrap_or_default();
@@ -26877,7 +26911,7 @@ fn slash_pack_list_and_inspect_use_discovered_packs() -> Result<()> {
let slash_text = drain_events(&mut rx)
.into_iter()
.filter_map(|event| match event {
- AgentEvent::Slash(text) => Some(text),
+ AgentEvent::StructuredSlash(text) => Some(text),
_ => None,
})
.collect::>()
@@ -26917,7 +26951,7 @@ fn slash_pack_verbose_flag_lists_with_paths() -> Result<()> {
let slash_text = drain_events(&mut rx)
.into_iter()
.find_map(|event| match event {
- AgentEvent::Slash(text) => Some(text),
+ AgentEvent::StructuredSlash(text) => Some(text),
_ => None,
})
.unwrap_or_default();
@@ -26936,7 +26970,7 @@ fn slash_pack_verbose_flag_lists_with_paths() -> Result<()> {
let followup = drain_events(&mut rx)
.into_iter()
.filter_map(|event| match event {
- AgentEvent::Slash(text) => Some(text),
+ AgentEvent::Slash(text) | AgentEvent::StructuredSlash(text) => Some(text),
_ => None,
})
.collect::>()
@@ -27118,12 +27152,12 @@ fn list_render_keeps_session_blueprint_and_sanitizes_controls() {
assert_eq!(list_render::width_for_terminal_cols(1), 1);
assert_eq!(list_render::width_for_terminal_cols(2), 1);
assert_eq!(list_render::width_for_terminal_cols(19), 17);
- assert_eq!(list_render::width_for_terminal_cols(500), 100);
+ assert_eq!(list_render::width_for_terminal_cols(500), 120);
let opts = list_render::ListOptions::fixed(false, 80);
let mut out = list_render::render_count_header("Items", 1, "found", &opts);
out.push_str(&list_render::render_section_header(
- "Unsafe\rsection\u{0007}\x1b]0;hidden\u{0007}",
+ "Unsafe\rsection\u{2028}next\u{2029}last\u{202e}spoof\u{2066}isolated\u{0007}\x1b]0;hidden\u{0007}",
&opts,
));
out.push_str(&list_render::render_entry(
@@ -27141,7 +27175,77 @@ fn list_render_keeps_session_blueprint_and_sanitizes_controls() {
assert!(!out.contains("hidden"), "{out:?}");
assert_eq!(
out,
- "Items 1 found\nUnsafe\nsection\n entry name!\n description with controls\n source: project\n spoofedred\n\nUse:\n /command \n"
+ "Items 1 found\nUnsafe\nsection\nnext\nlastspoofisolated\n entry name!\n description with controls\n source: project\n spoofedred\n\nUse:\n /command \n"
+ );
+}
+
+#[test]
+fn list_render_bounds_every_structured_row_by_display_cells() {
+ let width = 12;
+ let opts = list_render::ListOptions::fixed(false, width);
+ let mut out = list_render::render_count_header("界界界界界界界", 123, "found", &opts);
+ out.push_str(&list_render::render_section_header("分類\r見出し", &opts));
+ out.push_str(&list_render::render_entry(
+ "項目 名前界界界",
+ "説明 界界界界界 長い説明",
+ &[("metadata-key", "値界界界界界界".to_string())],
+ &opts,
+ ));
+ out.push_str(&list_render::render_footer(
+ &["/command-with-a-long-name "],
+ &opts,
+ ));
+
+ assert!(!out.contains(['\x1b', '\r', '\t', '\u{0007}']), "{out:?}");
+ for line in out.lines() {
+ assert!(
+ unicode_width::UnicodeWidthStr::width(line) <= width,
+ "line exceeds {width} cells: {line:?}\n{out}"
+ );
+ }
+ assert!(
+ out.contains("項目 "),
+ "preformatted spacing was lost: {out}"
+ );
+
+ let wide_opts = list_render::ListOptions::fixed(false, 80);
+ let multiline =
+ list_render::render_entry_rows(&[("unsafe\rname", "description\rcontinued")], &wide_opts);
+ assert_eq!(
+ multiline,
+ " unsafe\n name\n description\n continued\n"
+ );
+}
+
+#[test]
+fn list_render_one_cell_rows_replace_only_impossible_wide_clusters() {
+ let one_cell = list_render::ListOptions::fixed(false, 1);
+ let mut out = list_render::render_count_header("界", 1, "件", &one_cell);
+ out.push_str(&list_render::render_entry(
+ "🙂",
+ "界 🙂",
+ &[("界", "🙂".to_string())],
+ &one_cell,
+ ));
+ out.push_str(&list_render::render_footer(&["/界🙂"], &one_cell));
+
+ assert!(
+ out.lines()
+ .all(|line| unicode_width::UnicodeWidthStr::width(line) <= 1),
+ "{out:?}"
+ );
+ assert!(!out.contains(['界', '🙂']), "{out:?}");
+ assert!(out.contains('?'), "{out:?}");
+
+ let two_cells = list_render::ListOptions::fixed(false, 2);
+ let preserved = list_render::render_section_header("界🙂", &two_cells);
+ assert!(preserved.contains('界'), "{preserved:?}");
+ assert!(preserved.contains('🙂'), "{preserved:?}");
+ assert!(
+ preserved
+ .lines()
+ .all(|line| unicode_width::UnicodeWidthStr::width(line) <= 2),
+ "{preserved:?}"
);
}
@@ -27150,10 +27254,10 @@ fn structured_slash_renderers_follow_session_blueprint() {
let root = temp_test_dir("structured-slash-session-blueprint");
let agent = test_agent(&root);
- let help = render_help_listing();
+ let help = render_help_listing(Some(100));
assert!(help.starts_with("Commands "), "{help}");
assert!(
- help.contains("\nCore\n /help\n show this list\n\n /quit, /exit\n"),
+ help.contains("\nCore\n /help show this list\n /quit, /exit exit dext\n"),
"{help}"
);
assert!(
@@ -27198,7 +27302,12 @@ fn empty_pack_listing_uses_session_style_header_and_search_section() {
let opts = list_render::ListOptions::fixed(false, 12);
let out = packs::render_pack_list(&[], &opts, &root);
- assert!(out.starts_with("Packs 0 found\nSearch paths\n"), "{out}");
+ assert!(out.starts_with("Packs\n0 found\nSearch paths\n"), "{out}");
+ assert!(
+ out.lines()
+ .all(|line| unicode_width::UnicodeWidthStr::width(line) <= 12),
+ "{out}"
+ );
let compact = out.split_whitespace().collect::();
assert!(compact.contains(".dext/shelves/*/packs"), "{out}");
diff --git a/src/packs.rs b/src/packs.rs
index 8c8f610..4ba3227 100644
--- a/src/packs.rs
+++ b/src/packs.rs
@@ -472,9 +472,17 @@ pub(crate) fn render_pack_listing(root: &Path) -> String {
}
pub(crate) fn render_pack_listing_opts(root: &Path, verbose: bool) -> String {
+ render_pack_listing_opts_width(root, verbose, None)
+}
+
+pub(crate) fn render_pack_listing_opts_width(
+ root: &Path,
+ verbose: bool,
+ width: Option,
+) -> String {
render_pack_list(
&discover_packs(root),
- &list_render::ListOptions::detect(verbose),
+ &list_render::ListOptions::detect_with_width(verbose, width),
root,
)
}
diff --git a/src/shelves.rs b/src/shelves.rs
index 7ebc9f5..2e71517 100644
--- a/src/shelves.rs
+++ b/src/shelves.rs
@@ -779,8 +779,15 @@ fn push_shelf_manifest_dir(
}
pub(crate) fn render_registry_listing(registry: &ShelfRegistry) -> String {
+ render_registry_listing_width(registry, None)
+}
+
+pub(crate) fn render_registry_listing_width(
+ registry: &ShelfRegistry,
+ width: Option,
+) -> String {
use std::fmt::Write as _;
- let opts = crate::list_render::ListOptions::detect(false);
+ let opts = crate::list_render::ListOptions::detect_with_width(false, width);
if registry.is_empty() {
let mut out = crate::list_render::render_header("Shelves", 0, &opts);
diff --git a/src/tui.rs b/src/tui.rs
index bccd1f5..735678e 100644
--- a/src/tui.rs
+++ b/src/tui.rs
@@ -4,7 +4,10 @@ use crossterm::event::{
KeyModifiers, KeyboardEnhancementFlags, MouseEvent, MouseEventKind,
PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
};
-use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode};
+use crossterm::terminal::{
+ BeginSynchronizedUpdate, Clear as CrosstermClear, ClearType as CrosstermClearType,
+ EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode,
+};
use ratatui::Terminal;
use ratatui::backend::{Backend, CrosstermBackend};
use ratatui::layout::{Constraint, Direction, Layout, Rect};
@@ -149,8 +152,6 @@ const SPINNER_FRAMES: [char; 10] = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '
const LIVE_BACKEND_RING_CAP: usize = 256_000;
const LIVE_BACKEND_MAX_TOOLS: usize = 8;
const LIVE_OUTPUT_DRAIN_BATCH: usize = 32;
-const RESIZE_REPLAY_QUIET: Duration = Duration::from_millis(120);
-const RESIZE_REPLAY_MAX_LATENCY: Duration = Duration::from_millis(360);
const WELCOME_RIGHT_MIN_WIDTH: usize = 80;
const WELCOME_LABEL_GUTTER: usize = 14;
const TIPS: &[&str] = &[
@@ -272,6 +273,7 @@ enum Line_ {
message: String,
},
Info(String),
+ Slash(String),
RuntimeView {
pack: String,
title: String,
@@ -306,7 +308,7 @@ enum ToTui {
}
enum FromTui {
- Submit(String),
+ Submit { text: String, pane_width: u16 },
LoginInput(String),
LoginCancel,
CycleEffort(i8),
@@ -887,11 +889,11 @@ struct TranscriptLayoutState {
struct TuiState {
pending_insert: Vec,
+ prepared_insert_retry: Vec,
transcript: Vec,
render_cache: HashMap,
render_cache_weight: usize,
transcript_rendered_width: u16,
- transcript_rendered_rows: u16,
transcript_scroll_offset: usize,
transcript_hover_expandable: Option,
transcript_area: Rect,
@@ -1017,11 +1019,11 @@ impl TuiState {
) -> Self {
Self {
pending_insert: Vec::new(),
+ prepared_insert_retry: Vec::new(),
transcript: Vec::new(),
render_cache: HashMap::new(),
render_cache_weight: 0,
transcript_rendered_width: 0,
- transcript_rendered_rows: 0,
transcript_scroll_offset: 0,
transcript_hover_expandable: None,
transcript_area: Rect::default(),
@@ -1488,6 +1490,7 @@ impl TuiState {
fn last_line_needs_history_spacing(&self) -> bool {
self.pending_insert
.last()
+ .or_else(|| self.prepared_insert_retry.last())
.or_else(|| self.transcript.last())
.is_some_and(|line| {
Self::line_needs_history_spacing(line)
@@ -1783,6 +1786,24 @@ impl TuiState {
pseudo_tool_protocol_text_for_context(text, self.context_mode)
}
+ fn apply_slash_output(&mut self, output: String, structured: bool) {
+ self.push_debug_event(format!("slash/system · {}", sanitize_display_text(&output)));
+ self.compacting = false;
+ self.compacting_resume_busy = false;
+ self.streaming_text.clear();
+ self.streaming_thinking.clear();
+ self.stream_started_at = None;
+ self.stream_chars = 0;
+ self.live_tools.clear();
+ self.set_agent_busy(false);
+ self.status = phase_status_text(&output).unwrap_or_else(|| "ready".into());
+ if structured {
+ self.queue(Line_::Slash(output));
+ } else {
+ self.queue(Line_::Info(output));
+ }
+ }
+
fn apply_event(&mut self, ev: AgentEvent) {
match ev {
AgentEvent::TurnStart => {
@@ -2202,19 +2223,8 @@ impl TuiState {
self.push_debug_event(format!("error · {}", sanitize_display_text(&s)));
self.queue(Line_::Error(s));
}
- AgentEvent::Slash(s) => {
- self.push_debug_event(format!("slash/system · {}", sanitize_display_text(&s)));
- self.compacting = false;
- self.compacting_resume_busy = false;
- self.streaming_text.clear();
- self.streaming_thinking.clear();
- self.stream_started_at = None;
- self.stream_chars = 0;
- self.live_tools.clear();
- self.set_agent_busy(false);
- self.status = phase_status_text(&s).unwrap_or_else(|| "ready".into());
- self.queue(Line_::Info(s));
- }
+ AgentEvent::Slash(s) => self.apply_slash_output(s, false),
+ AgentEvent::StructuredSlash(s) => self.apply_slash_output(s, true),
AgentEvent::TurnEnd { failed, .. } => {
self.push_debug_event(if failed {
"turn end · failed"
@@ -3561,12 +3571,14 @@ fn merge_consecutive_tools(items: Vec) -> Vec {
summary,
ok,
content,
+ group_count: new_count,
group_chunks: new_chunks,
group_lines: new_lines,
duration_secs: new_duration,
denied: new_denied,
dim: new_dim,
- ..
+ density_rank: new_density_rank,
+ expanded: new_expanded,
} = item
else {
unreachable!()
@@ -3582,14 +3594,14 @@ fn merge_consecutive_tools(items: Vec) -> Vec {
summary,
ok,
content,
- group_count: 1,
+ group_count: new_count,
group_lines: new_lines,
group_chunks: new_chunks,
duration_secs: new_duration,
denied: new_denied,
- dim: false,
- density_rank: 1,
- expanded: false,
+ dim: new_dim,
+ density_rank: new_density_rank,
+ expanded: new_expanded,
});
continue;
}
@@ -3597,8 +3609,8 @@ fn merge_consecutive_tools(items: Vec) -> Vec {
*l_duration = l_duration.saturating_add(new_duration);
*l_denied = *l_denied || new_denied;
*l_dim = *l_dim || new_dim;
- *group_count += 1;
- *group_lines += new_lines;
+ *group_count = group_count.saturating_add(new_count);
+ *group_lines = group_lines.saturating_add(new_lines);
group_chunks.extend(new_chunks);
*ls = grouped_tool_summary(ln, *lok, *group_count, *group_lines, group_chunks);
// Keep the first chunk as the preview content; expansion shows all.
@@ -3874,20 +3886,42 @@ fn has_ansi(text: &str) -> bool {
text.as_bytes().windows(2).any(|w| w == b"\x1b[")
}
-fn sanitize_display_text(text: &str) -> String {
- let text = strip_ansi_escapes(text);
+fn is_bidi_format_control(ch: char) -> bool {
+ matches!(
+ ch,
+ '\u{061c}'
+ | '\u{200e}'
+ | '\u{200f}'
+ | '\u{202a}'..='\u{202e}'
+ | '\u{2066}'..='\u{2069}'
+ )
+}
+
+fn normalize_display_line_breaks(text: &str) -> String {
let mut out = String::with_capacity(text.len());
let mut chars = text.chars().peekable();
while let Some(ch) = chars.next() {
match ch {
'\r' => {
- if chars.peek() == Some(&'\n') {
- continue;
+ if chars.peek() != Some(&'\n') {
+ out.push('\n');
}
- out.push('\n');
}
+ '\n' | '\u{2028}' | '\u{2029}' => out.push('\n'),
+ _ => out.push(ch),
+ }
+ }
+ out
+}
+
+fn sanitize_display_text(text: &str) -> String {
+ let text = strip_ansi_escapes(text);
+ let text = normalize_display_line_breaks(&text);
+ let mut out = String::with_capacity(text.len());
+ for ch in text.chars() {
+ match ch {
'\n' | '\t' => out.push(ch),
- _ if ch.is_control() => {}
+ _ if ch.is_control() || is_bidi_format_control(ch) => {}
_ => out.push(ch),
}
}
@@ -6259,6 +6293,12 @@ fn line_to_text(item: &Line_, width: u16) -> Text<'static> {
width,
);
}
+ Line_::Slash(s) => {
+ let normalized = normalize_display_line_breaks(s);
+ for seg in normalized.split('\n') {
+ lines.push(Line::from(ansi_to_spans(seg)));
+ }
+ }
Line_::Info(s) => {
let trimmed = s.trim_start();
if let Some(rest) = trimmed.strip_prefix("[sub]") {
@@ -6318,7 +6358,7 @@ fn line_to_text(item: &Line_, width: u16) -> Text<'static> {
} else if has_ansi(s) {
// List output (packs/sessions/shelves) styled with ANSI codes:
// render as styled spans without the dim-italic bullet treatment.
- let normalized = s.replace("\r\n", "\n").replace('\r', "\n");
+ let normalized = normalize_display_line_breaks(s);
for seg in normalized.split('\n') {
lines.push(Line::from(ansi_to_spans(seg)));
}
@@ -6705,61 +6745,6 @@ fn next_transcript_tint(item: &Line_, tool_tint_parity: &mut bool) -> Option,
- last_change: Instant,
- last_replay: Instant,
- burst_active: bool,
-}
-
-impl TranscriptResizeReplay {
- fn new(now: Instant) -> Self {
- Self {
- observed_width: None,
- last_change: now,
- last_replay: now,
- burst_active: false,
- }
- }
-
- fn should_replay(
- &mut self,
- width: u16,
- rendered_width: u16,
- has_transcript: bool,
- now: Instant,
- ) -> bool {
- if !has_transcript {
- self.observed_width = Some(width);
- self.last_change = now;
- self.last_replay = now;
- self.burst_active = false;
- return true;
- }
-
- if self.observed_width != Some(width) {
- let leading_edge = !self.burst_active;
- self.observed_width = Some(width);
- self.last_change = now;
- self.burst_active = true;
- if leading_edge || now.duration_since(self.last_replay) >= RESIZE_REPLAY_MAX_LATENCY {
- self.last_replay = now;
- return true;
- }
- return false;
- }
-
- if self.burst_active && now.duration_since(self.last_change) >= RESIZE_REPLAY_QUIET {
- self.burst_active = false;
- if rendered_width != width {
- self.last_replay = now;
- return true;
- }
- }
- false
- }
-}
-
struct PreparedTranscriptRender {
text: Arc>,
line_start: usize,
@@ -6832,21 +6817,19 @@ fn insert_transcript_items(
state: &mut TuiState,
items: &[Line_],
width: u16,
+ chunk_rows: u16,
tool_tint_parity: &mut bool,
-) -> Result {
+) -> Result<(), B::Error> {
if items.is_empty() {
- return Ok(0);
+ return Ok(());
}
let render_width = transcript_render_width(width);
- let chunk_rows = terminal.size()?.height.max(1);
let mut chunk = Vec::new();
let mut chunk_height = 0u16;
- let mut inserted_rows = 0u32;
for item in items {
let (text, height) = cached_transcript_render(state, item, width);
- inserted_rows = inserted_rows.saturating_add(u32::from(height));
let tint_bg = match item {
Line_::Thinking(_) => Some(thinking_bg()),
Line_::Steering(_) => Some(steering_bg()),
@@ -6918,58 +6901,39 @@ fn insert_transcript_items(
}
}
- flush_prepared_transcript(terminal, &mut chunk, render_width, &mut chunk_height)?;
- Ok(inserted_rows)
+ flush_prepared_transcript(terminal, &mut chunk, render_width, &mut chunk_height)
}
-fn prepare_transcript_tail(
+#[cfg(test)]
+fn rebuild_transcript_from_origin(
+ terminal: &mut Terminal,
state: &mut TuiState,
- items: &[Line_],
width: u16,
- row_budget: u16,
-) -> (Vec, u16) {
- let mut tool_tint_parity = state.tool_tint_parity;
- let mut reverse_tail: Vec = Vec::new();
- let mut retained_rows = 0u16;
+) -> Result<(), B::Error> {
+ terminal.reset_inline_viewport()?;
+ rebuild_transcript(terminal, state, width)
+}
- for item in items.iter().rev() {
- if retained_rows >= row_budget {
- break;
+fn purge_and_rebuild_transcript(
+ terminal: &mut Terminal>,
+ state: &mut TuiState,
+ width: u16,
+) -> io::Result<()> {
+ crossterm::execute!(terminal.backend_mut(), BeginSynchronizedUpdate)?;
+ let rebuild = (|| {
+ if renderable_transcript_chunk_rows(terminal, state, width)?.is_none() {
+ state.transcript_needs_rebuild = true;
+ return Ok(());
}
- let (text, height) = cached_transcript_render(state, item, width);
- let tint_bg = match item {
- Line_::Thinking(_) => Some(thinking_bg()),
- Line_::Steering(_) => Some(steering_bg()),
- Line_::Tool {
- name, group_count, ..
- } => {
- tool_tint_parity = !tool_tint_parity;
- if name == "read_file" && *group_count > 1 {
- Some(Color::Indexed(235))
- } else if tool_tint_parity {
- Some(Color::Indexed(236))
- } else {
- None
- }
- }
- _ => None,
- };
- let take = height.min(row_budget.saturating_sub(retained_rows));
- let scroll = height.saturating_sub(take);
- let text = Arc::new(text);
- let line_end = text.lines.len();
- reverse_tail.push(PreparedTranscriptRender {
- text,
- line_start: 0,
- line_end,
- scroll,
- height: take,
- tint_bg,
- });
- retained_rows = retained_rows.saturating_add(take);
- }
- reverse_tail.reverse();
- (reverse_tail, retained_rows)
+ terminal.reset_inline_viewport()?;
+ crossterm::execute!(
+ terminal.backend_mut(),
+ CrosstermClear(CrosstermClearType::Purge)
+ )?;
+ rebuild_transcript(terminal, state, width)
+ })();
+ let end = crossterm::execute!(terminal.backend_mut(), EndSynchronizedUpdate);
+ rebuild.and(end)
}
fn rebuild_transcript(
@@ -6977,84 +6941,38 @@ fn rebuild_transcript(
state: &mut TuiState,
width: u16,
) -> Result<(), B::Error> {
- terminal.clear()?;
+ let Some(chunk_rows) = renderable_transcript_chunk_rows(terminal, state, width)? else {
+ state.transcript_needs_rebuild = true;
+ return Ok(());
+ };
+
// mem::take avoids cloning a potentially large transcript during explicit
// expand/collapse and error-recovery rebuilds. Nothing in the insert path
// reads state.transcript, so loaning it out is safe.
let items = std::mem::take(&mut state.transcript);
sync_last_expandable(state, &items);
let mut tool_tint_parity = false;
- let rebuild_result =
- insert_transcript_items(terminal, state, &items, width, &mut tool_tint_parity);
+ let rebuild_result = insert_transcript_items(
+ terminal,
+ state,
+ &items,
+ width,
+ chunk_rows,
+ &mut tool_tint_parity,
+ );
state.transcript = items;
- let inserted_rows = match rebuild_result {
- Ok(inserted_rows) => inserted_rows,
- Err(err) => {
- state.transcript_needs_rebuild = true;
- return Err(err);
+ match rebuild_result {
+ Ok(()) => {
+ state.tool_tint_parity = tool_tint_parity;
+ state.transcript_rendered_width = width;
+ state.transcript_needs_rebuild = false;
+ Ok(())
}
- };
- state.tool_tint_parity = tool_tint_parity;
- state.transcript_rendered_width = width;
- state.transcript_rendered_rows = inserted_rows
- .min(u32::from(terminal.get_frame().area().top()))
- .min(u32::from(u16::MAX)) as u16;
- state.transcript_needs_rebuild = false;
- Ok(())
-}
-
-// Width-change replay repaints only rows owned by the transcript. Inline
-// scrollback is append-only: replaying through insert_before would append a
-// second content copy. When narrower wrapping needs more visible rows, insert
-// only the blank row delta to allocate space, then overwrite the resulting
-// bounded tail. Wider wrapping keeps the existing allocation and clears its
-// unused leading rows, avoiding destructive scrollback deletion.
-fn overwrite_transcript_tail(
- terminal: &mut Terminal,
- state: &mut TuiState,
- width: u16,
-) -> Result<(), B::Error> {
- let screen_rows = terminal.size()?.height;
- let viewport = terminal.get_frame().area();
- let viewport_top = viewport.top();
- let available_rows = screen_rows.saturating_sub(viewport.height);
- let owned_rows = state.transcript_rendered_rows.min(viewport_top);
- if screen_rows == 0 || viewport.height == screen_rows {
- state.transcript_rendered_width = width;
- state.transcript_rendered_rows = 0;
- return Ok(());
- }
-
- let items = std::mem::take(&mut state.transcript);
- let render_width = transcript_render_width(width);
- let (tail, retained_rows) = prepare_transcript_tail(state, &items, width, available_rows);
- let allocated_rows = owned_rows.max(retained_rows);
- let additional_rows = allocated_rows.saturating_sub(owned_rows);
- let allocation = if additional_rows > 0 {
- terminal.insert_before(additional_rows, |_| {})
- } else {
- Ok(())
- };
- if let Err(err) = allocation {
- state.transcript = items;
- state.transcript_needs_rebuild = true;
- return Err(err);
- }
- let top_padding = allocated_rows.saturating_sub(retained_rows);
- let overwrite = terminal.overwrite_before(allocated_rows, move |buf| {
- render_prepared_transcript(buf, tail, render_width, top_padding);
- });
- state.transcript = items;
- let overwritten_rows = match overwrite {
- Ok(overwritten_rows) => overwritten_rows,
Err(err) => {
state.transcript_needs_rebuild = true;
- return Err(err);
+ Err(err)
}
- };
- state.transcript_rendered_width = width;
- state.transcript_rendered_rows = overwritten_rows;
- Ok(())
+ }
}
fn transcript_pane_width(area_width: u16, area_height: u16, state: &TuiState) -> u16 {
@@ -7063,6 +6981,24 @@ fn transcript_pane_width(area_width: u16, area_height: u16, state: &TuiState) ->
.width
}
+fn renderable_transcript_chunk_rows(
+ terminal: &mut Terminal,
+ state: &TuiState,
+ expected_width: u16,
+) -> Result, B::Error> {
+ if expected_width == 0 {
+ return Ok(None);
+ }
+ terminal.autoresize()?;
+ let size = terminal.size()?;
+ let current_width = transcript_pane_width(size.width, size.height, state);
+ if size.width == 0 || size.height == 0 || current_width == 0 || current_width != expected_width
+ {
+ return Ok(None);
+ }
+ Ok(Some(size.height))
+}
+
fn terminal_has_render_area(terminal: &Terminal) -> Result {
let size = terminal.size()?;
Ok(size.width > 0 && size.height > 0)
@@ -7072,58 +7008,60 @@ fn current_transcript_pane_width(
terminal: &mut Terminal,
state: &TuiState,
) -> Result {
- if !terminal_has_render_area(terminal)? {
+ let size = terminal.size()?;
+ if size.width == 0 || size.height == 0 {
return Ok(0);
}
- terminal.autoresize()?;
- let size = terminal.size()?;
Ok(transcript_pane_width(size.width, size.height, state))
}
-fn flush_pending_insert_for_width(
+fn transcript_requires_rebuild(state: &TuiState, width: u16) -> bool {
+ width > 0
+ && !state.transcript.is_empty()
+ && (state.transcript_needs_rebuild || state.transcript_rendered_width != width)
+}
+
+fn flush_pending_insert(
terminal: &mut Terminal,
state: &mut TuiState,
width: u16,
- replay_width_change: bool,
) -> Result<(), B::Error> {
- if !terminal_has_render_area(terminal)? {
- return Ok(());
- }
- let width_changed = state.transcript_rendered_width != width && !state.transcript.is_empty();
- if state.transcript_needs_rebuild {
- // Explicit rebuilds (expand/collapse, error recovery) intentionally
- // re-emit: their new content must become scrollable scrollback.
- rebuild_transcript(terminal, state, width)?;
- } else if width_changed && replay_width_change {
- overwrite_transcript_tail(terminal, state, width)?;
- }
- if width_changed && state.transcript_rendered_width != width {
+ if renderable_transcript_chunk_rows(terminal, state, width)?.is_none() {
return Ok(());
}
- let raw: Vec = std::mem::take(&mut state.pending_insert);
- let mut items: Vec = merge_consecutive_tools(raw);
- if let Err(err) = flush_prepared_items(terminal, state, &mut items, width) {
- state.pending_insert = items;
- return Err(err);
+ if !state.prepared_insert_retry.is_empty() {
+ let mut retry = std::mem::take(&mut state.prepared_insert_retry);
+ match flush_prepared_items(terminal, state, &mut retry, width) {
+ Ok(true) => {}
+ Ok(false) => {
+ state.prepared_insert_retry = retry;
+ return Ok(());
+ }
+ Err(err) => {
+ state.prepared_insert_retry = retry;
+ return Err(err);
+ }
+ }
}
- Ok(())
-}
-fn flush_pending_insert(
- terminal: &mut Terminal,
- state: &mut TuiState,
- width: u16,
-) -> Result<(), B::Error> {
- flush_pending_insert_for_width(terminal, state, width, true)
+ let mut items = std::mem::take(&mut state.pending_insert);
+ prepare_pending_items(state, &mut items);
+ match flush_prepared_items(terminal, state, &mut items, width) {
+ Ok(true) => Ok(()),
+ Ok(false) => {
+ state.prepared_insert_retry = items;
+ Ok(())
+ }
+ Err(err) => {
+ state.prepared_insert_retry = items;
+ Err(err)
+ }
+ }
}
-fn flush_prepared_items(
- terminal: &mut Terminal,
- state: &mut TuiState,
- items: &mut Vec,
- width: u16,
-) -> Result<(), B::Error> {
+fn prepare_pending_items(state: &mut TuiState, items: &mut Vec) {
+ *items = merge_consecutive_tools(std::mem::take(items));
mark_retry_cycles(items);
// Inline viewport output is real terminal scrollback: already-inserted lines cannot be
// rewritten without appending another copy of the transcript. Keep grouping within the
@@ -7146,22 +7084,35 @@ fn flush_prepared_items(
if !expansion_active {
sync_last_expandable(state, items);
}
+}
+
+fn flush_prepared_items(
+ terminal: &mut Terminal,
+ state: &mut TuiState,
+ items: &mut Vec,
+ width: u16,
+) -> Result {
+ let Some(chunk_rows) = renderable_transcript_chunk_rows(terminal, state, width)? else {
+ return Ok(false);
+ };
if items.is_empty() {
- return Ok(());
+ return Ok(true);
}
let mut tool_tint_parity = state.tool_tint_parity;
- let inserted_rows =
- insert_transcript_items(terminal, state, items, width, &mut tool_tint_parity)?;
+ insert_transcript_items(
+ terminal,
+ state,
+ items,
+ width,
+ chunk_rows,
+ &mut tool_tint_parity,
+ )?;
state.tool_tint_parity = tool_tint_parity;
state.transcript.append(items);
state.transcript_rendered_width = width;
- state.transcript_rendered_rows = state
- .transcript_rendered_rows
- .saturating_add(inserted_rows.min(u32::from(u16::MAX)) as u16)
- .min(terminal.get_frame().area().top());
- Ok(())
+ Ok(true)
}
fn set_last_tool_expanded(items: &mut [Line_], name: &str, expanded: bool) -> bool {
@@ -8672,7 +8623,10 @@ fn handle_login_input_key(
};
state.clear_slash_completion_selection();
if non_secret_command {
- let _ = agent_input.send(FromTui::Submit(text));
+ let _ = agent_input.send(FromTui::Submit {
+ text,
+ pane_width: state.transcript_area.width,
+ });
} else {
let _ = agent_input.send(FromTui::LoginInput(text));
}
@@ -8940,10 +8894,12 @@ fn handle_key(
let next_expanded = !block.expanded;
let updated_pending =
set_last_tool_expanded(&mut state.pending_insert, &name, next_expanded);
+ let updated_retry =
+ set_last_tool_expanded(&mut state.prepared_insert_retry, &name, next_expanded);
let updated_transcript =
set_last_tool_expanded(&mut state.transcript, &name, next_expanded);
- if updated_pending || updated_transcript {
- state.transcript_needs_rebuild = true;
+ if updated_pending || updated_retry || updated_transcript {
+ state.transcript_needs_rebuild |= updated_transcript;
state.jump_transcript_to_bottom();
state.status = if next_expanded {
"expanded".to_string()
@@ -9106,7 +9062,10 @@ fn handle_key(
state.history_idx = None;
state.clear_input();
state.clear_slash_completion_selection();
- let _ = agent_input.send(FromTui::Submit(text));
+ let _ = agent_input.send(FromTui::Submit {
+ text,
+ pane_width: state.transcript_area.width,
+ });
}
(KeyCode::PageUp, _) => {
let step = state.transcript_visible_lines.saturating_sub(2).max(1) as isize;
@@ -9550,7 +9509,10 @@ pub async fn run(mut agent: Agent, initial_task: Option) -> Result<()> {
queue_welcome_banner(&mut state, banner);
if let Some(task) = initial_task {
state.queue(Line_::User(task.clone()));
- let _ = in_tx.send(FromTui::Submit(task));
+ let _ = in_tx.send(FromTui::Submit {
+ text: task,
+ pane_width: 0,
+ });
}
// Move agent into a task; communicate via channels
@@ -9564,7 +9526,8 @@ pub async fn run(mut agent: Agent, initial_task: Option) -> Result<()> {
let handle = tokio::spawn(async move {
while let Some(cmd) = cmd_rx.recv().await {
match cmd {
- FromTui::Submit(text) => {
+ FromTui::Submit { text, pane_width } => {
+ agent.slash_render_width = (pane_width > 0).then_some(usize::from(pane_width));
if crate::is_slash_command(&text) {
let trimmed = text.trim();
if let Some(parsed) = parse_compact_slash(trimmed) {
@@ -9710,7 +9673,6 @@ pub async fn run(mut agent: Agent, initial_task: Option) -> Result<()> {
let tick = Duration::from_millis(80);
let mut last_tick = Instant::now();
- let mut resize_replay = TranscriptResizeReplay::new(last_tick);
while !state.quit {
if state.backend_viewer_open {
@@ -9740,13 +9702,12 @@ pub async fn run(mut agent: Agent, initial_task: Option) -> Result<()> {
}
if terminal_has_render_area(&terminal)? {
let width = current_transcript_pane_width(&mut terminal, &state)?;
- let replay_width_change = resize_replay.should_replay(
- width,
- state.transcript_rendered_width,
- !state.transcript.is_empty(),
- Instant::now(),
- );
- flush_pending_insert_for_width(&mut terminal, &mut state, width, replay_width_change)?;
+ if transcript_requires_rebuild(&state, width) {
+ purge_and_rebuild_transcript(&mut terminal, &mut state, width)?;
+ }
+ if !transcript_requires_rebuild(&state, width) {
+ flush_pending_insert(&mut terminal, &mut state, width)?;
+ }
terminal.draw(|f| draw(f, &mut state))?;
state.frame_count = state.frame_count.wrapping_add(1);
}
@@ -9829,7 +9790,12 @@ pub async fn run(mut agent: Agent, initial_task: Option) -> Result<()> {
}
if terminal_has_render_area(&terminal).unwrap_or(false) {
if let Ok(width) = current_transcript_pane_width(&mut terminal, &state) {
- let _ = flush_pending_insert(&mut terminal, &mut state, width);
+ if transcript_requires_rebuild(&state, width) {
+ let _ = purge_and_rebuild_transcript(&mut terminal, &mut state, width);
+ }
+ if !transcript_requires_rebuild(&state, width) {
+ let _ = flush_pending_insert(&mut terminal, &mut state, width);
+ }
}
let _ = terminal.draw(|f| draw(f, &mut state));
}
@@ -12474,6 +12440,49 @@ mod tests {
assert!(summary.contains("lines 6410-6413"), "{summary}");
}
+ #[test]
+ fn merge_consecutive_tools_is_idempotent_for_prepared_retry_batches() {
+ let mut items = merge_consecutive_tools(vec![
+ tool_line(
+ "#1.44",
+ "read_file",
+ "read_file: src/main.rs (offset=6410, limit=2)",
+ Some(true),
+ "6410\talpha\n6411\tbravo\n",
+ ),
+ tool_line(
+ "#1.45",
+ "read_file",
+ "read_file: src/main.rs (offset=6412, limit=2)",
+ Some(true),
+ "6412\tcharlie\n6413\tdelta\n",
+ ),
+ ]);
+ let prepared = items.clone();
+ assert!(merge_consecutive_tools(prepared.clone()) == prepared);
+
+ items.push(tool_line(
+ "#1.46",
+ "read_file",
+ "read_file: src/main.rs (offset=6414, limit=2)",
+ Some(true),
+ "6414\techo\n6415\tfoxtrot\n",
+ ));
+ let merged = merge_consecutive_tools(items);
+ let Line_::Tool {
+ group_count,
+ group_lines,
+ group_chunks,
+ ..
+ } = &merged[0]
+ else {
+ panic!("expected grouped tool");
+ };
+ assert_eq!(*group_count, 3);
+ assert_eq!(*group_lines, 6);
+ assert_eq!(group_chunks.len(), 3);
+ }
+
#[test]
fn density_separator_renders_every_tenth_tool_call() {
let mut item = tool_line("#1.10", "bash", "bash: true", Some(true), "ok");
@@ -12567,7 +12576,7 @@ mod tests {
}
#[test]
- fn slash_event_clears_live_preview_state() {
+ fn generic_slash_event_clears_live_preview_state_and_uses_faded_info() {
let mut state = TuiState::new(
"test-model".to_string(),
model_context_window("test-model"),
@@ -12607,6 +12616,25 @@ mod tests {
);
}
+ #[test]
+ fn structured_slash_event_keeps_unadorned_layout_line() {
+ let mut state = TuiState::new(
+ "test-model".to_string(),
+ model_context_window("test-model"),
+ ".".to_string(),
+ ApprovalProfile::Ask,
+ ThinkingEffort::Medium,
+ );
+
+ state.apply_event(AgentEvent::StructuredSlash(
+ "Heading\n /help show help".to_string(),
+ ));
+
+ assert!(state.pending_insert.last().is_some_and(
+ |line| matches!(line, Line_::Slash(msg) if msg == "Heading\n /help show help")
+ ));
+ }
+
#[test]
fn user_cards_render_markdown() {
let text = line_to_text(&Line_::User("# Heading\n- item".to_string()), 120);
@@ -13965,7 +13993,10 @@ mod tests {
);
match submit_rx.try_recv() {
- Ok(FromTui::Submit(text)) => assert_eq!(text, command),
+ Ok(FromTui::Submit { text, pane_width }) => {
+ assert_eq!(text, command);
+ assert_eq!(pane_width, state.transcript_area.width);
+ }
_ => panic!("expected ordinary slash-command submission"),
}
assert!(submit_rx.try_recv().is_err());
@@ -14680,17 +14711,18 @@ mod tests {
}
#[test]
- fn failed_pending_insert_keeps_logical_transcript_state() {
+ fn failed_pending_insert_retries_prepared_batch_without_merging_new_output() {
use ratatui::backend::{ClearType, TestBackend, WindowSize};
use ratatui::buffer::Cell;
use ratatui::layout::{Position, Size};
use ratatui::{Terminal, TerminalOptions, Viewport};
- struct FailClearBackend {
+ struct FailOnceClearBackend {
inner: TestBackend,
+ fail_clear: bool,
}
- impl Backend for FailClearBackend {
+ impl Backend for FailOnceClearBackend {
type Error = io::Error;
fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
@@ -14728,8 +14760,14 @@ mod tests {
self.inner.clear().map_err(|error| match error {})
}
- fn clear_region(&mut self, _clear_type: ClearType) -> io::Result<()> {
- Err(io::Error::other("injected clear failure"))
+ fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
+ if std::mem::replace(&mut self.fail_clear, false) {
+ Err(io::Error::other("injected clear failure"))
+ } else {
+ self.inner
+ .clear_region(clear_type)
+ .map_err(|error| match error {})
+ }
}
fn size(&self) -> io::Result {
@@ -14745,8 +14783,9 @@ mod tests {
}
}
- let backend = FailClearBackend {
+ let backend = FailOnceClearBackend {
inner: TestBackend::new(80, 20),
+ fail_clear: true,
};
let mut terminal = Terminal::with_options(
backend,
@@ -14762,28 +14801,121 @@ mod tests {
ApprovalProfile::Ask,
ThinkingEffort::Medium,
);
- state.queue(Line_::Assistant {
- text: "must remain pending".to_string(),
- dim_prefix: false,
- });
+ state.pending_insert = vec![
+ tool_line(
+ "#1.44",
+ "read_file",
+ "read_file: src/main.rs (offset=6410, limit=2)",
+ Some(true),
+ "6410\talpha\n6411\tbravo\n",
+ ),
+ tool_line(
+ "#1.45",
+ "read_file",
+ "read_file: src/main.rs (offset=6412, limit=2)",
+ Some(true),
+ "6412\tcharlie\n6413\tdelta\n",
+ ),
+ ];
let error = flush_pending_insert(&mut terminal, &mut state, 80)
.expect_err("injected clear failure must escape");
assert!(error.to_string().contains("injected clear failure"));
assert!(state.transcript.is_empty());
+ assert!(state.pending_insert.is_empty());
+ assert!(matches!(
+ state.prepared_insert_retry.as_slice(),
+ [Line_::Tool {
+ group_count: 2,
+ group_chunks,
+ ..
+ }] if group_chunks.len() == 2
+ ));
+
+ state.queue(tool_line(
+ "#1.46",
+ "read_file",
+ "read_file: src/main.rs (offset=6414, limit=2)",
+ Some(true),
+ "6414\techo\n6415\tfoxtrot\n",
+ ));
+ assert_eq!(state.prepared_insert_retry.len(), 1);
assert!(matches!(
state.pending_insert.as_slice(),
- [Line_::Assistant { text, .. }] if text == "must remain pending"
+ [Line_::Blank, Line_::Tool { group_count: 1, .. }]
+ ));
+
+ flush_pending_insert(&mut terminal, &mut state, 80).expect("retry prepared batch");
+
+ assert!(state.prepared_insert_retry.is_empty());
+ assert!(state.pending_insert.is_empty());
+ assert!(matches!(
+ state.transcript.as_slice(),
+ [
+ Line_::Tool { group_count: 2, .. },
+ Line_::Blank,
+ Line_::Tool { group_count: 1, .. }
+ ]
));
}
#[test]
- fn zero_sized_terminal_defers_pending_insert_until_recovery() {
+ fn zero_sized_or_status_only_terminal_defers_pending_insert_until_recovery() {
use ratatui::backend::TestBackend;
use ratatui::{Terminal, TerminalOptions, Viewport};
- let backend = TestBackend::new(80, 0);
+ for minimized_height in [0, 1] {
+ let backend = TestBackend::new(80, minimized_height);
+ let mut terminal = Terminal::with_options(
+ backend,
+ TerminalOptions {
+ viewport: Viewport::Inline(8),
+ },
+ )
+ .expect("terminal");
+ let mut state = TuiState::new(
+ "test-model".to_string(),
+ model_context_window("test-model"),
+ ".".to_string(),
+ ApprovalProfile::Ask,
+ ThinkingEffort::Medium,
+ );
+ state.queue(Line_::Assistant {
+ text: "defer while minimized".to_string(),
+ dim_prefix: false,
+ });
+
+ let width =
+ current_transcript_pane_width(&mut terminal, &state).expect("minimized pane width");
+ assert_eq!(width, 0);
+ flush_pending_insert(&mut terminal, &mut state, width)
+ .expect("minimized flush must defer");
+ assert!(state.transcript.is_empty());
+ assert!(matches!(
+ state.pending_insert.as_slice(),
+ [Line_::Assistant { text, .. }] if text == "defer while minimized"
+ ));
+
+ terminal.backend_mut().resize(80, 20);
+ terminal.autoresize().expect("restore terminal size");
+ let width =
+ current_transcript_pane_width(&mut terminal, &state).expect("restored width");
+ flush_pending_insert(&mut terminal, &mut state, width).expect("flush after restore");
+ assert!(state.pending_insert.is_empty());
+ assert!(matches!(
+ state.transcript.as_slice(),
+ [Line_::Assistant { text, .. }] if text == "defer while minimized"
+ ));
+ }
+ }
+
+ #[test]
+ fn replay_deferred_after_mid_frame_minimize_remains_required() {
+ use ratatui::backend::TestBackend;
+ use ratatui::{Terminal, TerminalOptions, Viewport};
+
+ let backend = TestBackend::new(80, 20);
let mut terminal = Terminal::with_options(
backend,
TerminalOptions {
@@ -14799,28 +14931,27 @@ mod tests {
ThinkingEffort::Medium,
);
state.queue(Line_::Assistant {
- text: "defer while minimized".to_string(),
+ text: "logical history survives minimize".to_string(),
dim_prefix: false,
});
+ let width = current_transcript_pane_width(&mut terminal, &state).expect("initial width");
+ flush_pending_insert(&mut terminal, &mut state, width).expect("initial flush");
+ state.transcript_needs_rebuild = true;
- flush_pending_insert_for_width(&mut terminal, &mut state, 1, true)
- .expect("zero-sized flush must defer");
- assert!(state.transcript.is_empty());
- assert!(matches!(
- state.pending_insert.as_slice(),
- [Line_::Assistant { text, .. }] if text == "defer while minimized"
- ));
+ terminal.backend_mut().resize(80, 0);
+ rebuild_transcript_from_origin(&mut terminal, &mut state, width)
+ .expect("zero-height replay must defer");
+
+ assert_eq!(state.transcript_rendered_width, width);
+ assert!(state.transcript_needs_rebuild);
+ assert!(transcript_requires_rebuild(&state, width));
+ assert_eq!(state.transcript.len(), 1);
terminal.backend_mut().resize(80, 20);
terminal.autoresize().expect("restore terminal size");
- let width = current_transcript_pane_width(&mut terminal, &state).expect("restored width");
- flush_pending_insert_for_width(&mut terminal, &mut state, width, true)
- .expect("flush after restore");
- assert!(state.pending_insert.is_empty());
- assert!(matches!(
- state.transcript.as_slice(),
- [Line_::Assistant { text, .. }] if text == "defer while minimized"
- ));
+ rebuild_transcript_from_origin(&mut terminal, &mut state, width).expect("restored replay");
+ assert!(!state.transcript_needs_rebuild);
+ assert!(!transcript_requires_rebuild(&state, width));
}
#[test]
@@ -14890,11 +15021,13 @@ mod tests {
ThinkingEffort::Medium,
);
let mut tint = false;
+ let chunk_rows = chunked_terminal.size().expect("chunk terminal size").height;
insert_transcript_items(
&mut chunked_terminal,
&mut chunked_state,
std::slice::from_ref(&item),
width,
+ chunk_rows,
&mut tint,
)
.expect("chunked insert");
@@ -14911,52 +15044,7 @@ mod tests {
}
#[test]
- fn resize_replay_uses_leading_trailing_and_forced_bounds() {
- let start = Instant::now();
- let mut replay = TranscriptResizeReplay::new(start);
-
- assert!(replay.should_replay(100, 120, true, start));
- assert!(!replay.should_replay(90, 100, true, start + Duration::from_millis(25)));
- assert!(!replay.should_replay(80, 100, true, start + Duration::from_millis(80)));
- assert!(!replay.should_replay(80, 100, true, start + Duration::from_millis(150)));
- assert!(replay.should_replay(80, 100, true, start + Duration::from_millis(200)));
-
- let mut continuous = TranscriptResizeReplay::new(start);
- assert!(continuous.should_replay(100, 120, true, start));
- assert!(!continuous.should_replay(90, 100, true, start + Duration::from_millis(100)));
- assert!(!continuous.should_replay(80, 100, true, start + Duration::from_millis(200)));
- assert!(continuous.should_replay(70, 100, true, start + RESIZE_REPLAY_MAX_LATENCY));
- assert!(!continuous.should_replay(
- 60,
- 70,
- true,
- start + RESIZE_REPLAY_MAX_LATENCY + Duration::from_millis(25),
- ));
- }
-
- #[test]
- fn resize_replay_without_history_never_defers_viewport_work() {
- let start = Instant::now();
- let mut replay = TranscriptResizeReplay::new(start);
-
- assert!(replay.should_replay(80, 0, false, start));
- assert!(replay.should_replay(70, 0, false, start + Duration::from_millis(10)));
- assert!(!replay.burst_active);
- }
-
- #[test]
- fn resize_rebuilds_existing_transcript_for_current_pane_width() {
- use ratatui::backend::TestBackend;
- use ratatui::{Terminal, TerminalOptions, Viewport};
-
- let backend = TestBackend::new(90, 20);
- let mut terminal = Terminal::with_options(
- backend,
- TerminalOptions {
- viewport: Viewport::Inline(8),
- },
- )
- .expect("terminal");
+ fn every_effective_transcript_width_change_requires_rebuild() {
let mut state = TuiState::new(
"test-model".to_string(),
model_context_window("test-model"),
@@ -14964,130 +15052,23 @@ mod tests {
ApprovalProfile::Ask,
ThinkingEffort::Medium,
);
- state.queue(Line_::Assistant {
- text: "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu ".repeat(5),
- dim_prefix: false,
- });
-
- let wide = current_transcript_pane_width(&mut terminal, &state).expect("wide width");
- flush_pending_insert(&mut terminal, &mut state, wide).expect("wide flush");
- assert_eq!(state.transcript.len(), 1);
- assert_eq!(state.transcript_rendered_width, wide);
-
- terminal.backend_mut().resize(38, 20);
- let narrow = current_transcript_pane_width(&mut terminal, &state).expect("narrow width");
- assert!(narrow < wide);
- flush_pending_insert(&mut terminal, &mut state, narrow).expect("narrow flush");
- assert_eq!(state.transcript.len(), 1);
- assert_eq!(state.transcript_rendered_width, narrow);
- assert!(!state.transcript_needs_rebuild);
-
- let item = state.transcript[0].clone();
- let key = line_cache_key(&item);
- let wide_render_width = transcript_render_width(wide);
- let narrow_render_width = transcript_render_width(narrow);
- {
- let entry = state.render_cache.get(&key).expect("cache entry");
- assert!(entry.renders.contains_key(&wide_render_width));
- assert!(entry.renders.contains_key(&narrow_render_width));
- assert!(
- entry.renders[&narrow_render_width].height
- >= entry.renders[&wide_render_width].height
- );
- }
-
- terminal.backend_mut().resize(110, 20);
- let wider = current_transcript_pane_width(&mut terminal, &state).expect("wider width");
- assert!(wider > narrow);
- flush_pending_insert(&mut terminal, &mut state, wider).expect("wider flush");
- assert_eq!(state.transcript.len(), 1);
- assert_eq!(state.transcript_rendered_width, wider);
- assert!(!state.transcript_needs_rebuild);
- let wider_render_width = transcript_render_width(wider);
- let entry = state.render_cache.get(&key).expect("cache entry");
- assert!(entry.renders.contains_key(&wider_render_width));
- }
-
- #[test]
- fn short_transcript_resize_replay_does_not_grow_scrollback() {
- use ratatui::backend::TestBackend;
- use ratatui::{Terminal, TerminalOptions, Viewport};
-
- let backend = TestBackend::new(90, 20);
- let mut terminal = Terminal::with_options(
- backend,
- TerminalOptions {
- viewport: Viewport::Inline(8),
- },
- )
- .expect("terminal");
- let mut state = TuiState::new(
- "test-model".to_string(),
- model_context_window("test-model"),
- ".".to_string(),
- ApprovalProfile::Ask,
- ThinkingEffort::Medium,
- );
- state.queue(Line_::Assistant {
- text: "x".repeat(120),
+ assert!(!transcript_requires_rebuild(&state, 60));
+ state.transcript.push(Line_::Assistant {
+ text: "history".to_string(),
dim_prefix: false,
});
- let wide = current_transcript_pane_width(&mut terminal, &state).expect("wide width");
- flush_pending_insert(&mut terminal, &mut state, wide).expect("wide flush");
- let owned_rows = state.transcript_rendered_rows;
- assert!(owned_rows > 0 && owned_rows < terminal.size().unwrap().height);
-
- terminal.backend_mut().resize(28, 20);
- let narrow = current_transcript_pane_width(&mut terminal, &state).expect("narrow width");
- let item = state.transcript[0].clone();
- let (_, narrow_rows) = cached_transcript_render(&mut state, &item, narrow);
- assert!(
- narrow_rows > owned_rows,
- "test fixture must grow on narrow wrap: wide_rows={owned_rows} narrow_rows={narrow_rows} wide={wide} narrow={narrow} viewport_top={}",
- terminal.get_frame().area().top()
- );
- let scrollback_before = terminal.backend().scrollback().clone();
- flush_pending_insert(&mut terminal, &mut state, narrow).expect("narrow flush");
-
- assert_eq!(state.transcript_rendered_width, narrow);
- assert!(
- state.transcript_rendered_rows > owned_rows,
- "resize allocation did not grow: wide_rows={owned_rows} narrow_rows={narrow_rows} allocated={} viewport_top={}",
- state.transcript_rendered_rows,
- terminal.get_frame().area().top()
- );
- assert_eq!(*terminal.backend().scrollback(), scrollback_before);
- }
-
- #[test]
- fn resize_tail_preparation_renders_only_screen_bounded_suffix() {
- let mut state = TuiState::new(
- "test-model".to_string(),
- model_context_window("test-model"),
- ".".to_string(),
- ApprovalProfile::Ask,
- ThinkingEffort::Medium,
- );
- let items: Vec