fn name(&self) -> &'static str;

fn text(&self, ctx: &DirectiveCtx) -> String;

fn channels(&self) -> &'static [Channel];

fn name(&self) -> &'static str {

"terse-output"

}

fn text(&self, _ctx: &DirectiveCtx) -> String {

TERSE_OUTPUT_TEXT.to_string()

}

fn channels(&self) -> &'static [Channel] {

&[Channel::AwarenessFile, Channel::SessionStart]

}

if tasks.is_empty() {

return String::new();

}

let mut out = String::from(

"Delegation commands (they hand work to a cheaper model; the files never \

);

for (name, kind) in tasks {

let usage = crate::task::find_kind(kind)

.map(|k| k.usage().replace("<task>", name))

.unwrap_or_else(|| format!("rtk {name} ..."));

out.push_str(&format!("\n- `{usage}`"));

}

out

texts

.iter()

.map(|t| t.trim_end())

.filter(|t| !t.is_empty())

.collect::<Vec<_>>()

.join("\n\n")

use super::*;

#[test]

fn terse_output_is_registered_and_costed() {

let directive = find("terse-output").expect("registered");

let text = directive.text(&DirectiveCtx { level: None });

assert!(

text.contains("Never shorten code"),

"terseness must never apply to code, paths, commands or error text"

);

assert!(

text.contains("security warnings"),

"terseness must never apply to a destructive-action warning"

);

assert!(cost_tokens(&text) > 0);

assert!(directive.channels().contains(&Channel::AwarenessFile));

}

/// The properties this wording depends on to make the agent shorter rather

/// than longer.

#[test]

fn terse_output_keeps_the_guards_that_earned_their_place() {

let text = find("terse-output")

.expect("registered")

.text(&DirectiveCtx { level: None });

// The model has to be told which words to drop, not asked to infer a

// register.

assert!(

text.contains("Drop articles") && text.contains("filler"),

"name the word classes; \"be terse\" alone is not enough"

);

assert!(

text.contains("Example."),

"a worked before/after calibrates the target register"

);

assert!(

text.contains("not actually shorter"),

"without a never-longer rule the model pays tokens to look brief"

);

assert!(

text.contains("Keep every negation"),

"dropping a `not` inverts the instruction it appears in"

);

// Forbidding an agent's closing summary suppresses the interstitial notes it keeps as working

// memory, and a coding agent re-reads its own output every turn.

assert!(

!text.contains("closing summaries") && !text.contains("restating tool output"),

"do not add behavioural suppression clauses: they make the agent \

);

}

#[test]

fn unknown_directive_is_not_found() {

assert!(find("mystery").is_none());

}

#[test]

fn merge_concatenates_in_order_and_drops_empties() {

let merged = merge(&[

"first block\n".to_string(),

String::new(),

"second block".to_string(),

]);

assert_eq!(merged, "first block\n\nsecond block");

}