Expose session cost and budget state in the Rust CLI

The CLI already tracked token usage, but it did not translate that usage into model-aware cost reporting or offer a spend guardrail. This change adds a max-cost flag, integrates estimated USD totals into /status and /cost, emits near-budget warnings, and blocks new turns once the configured budget has been exhausted.

The workspace verification request also surfaced stale runtime test fixtures that still referenced removed permission enum variants, so those test-only call sites were updated to current permission modes to keep full clippy and workspace test coverage green.

Constraint: Reuse existing runtime usage/pricing helpers instead of adding a new billing layer
Constraint: Keep the feature centered in existing CLI/status surfaces with no new dependencies
Rejected: Move budget enforcement into runtime usage/session abstractions | broader refactor than needed for this CLI-scoped feature
Confidence: high
Scope-risk: moderate
Reversibility: clean
Directive: If resumed sessions later need historically accurate per-turn pricing across model switches, persist model metadata before changing the cost math
Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace
Not-tested: Live network-backed prompt/REPL budget behavior against real Anthropic responses

rust/README.md

@@ -133,7 +133,6 @@ Inside the REPL, useful commands include:
 /diff
 /version
 /export notes.txt
-/sessions
 /session list
 /exit
 ```
@@ -144,14 +143,14 @@ Inspect or maintain a saved session file without entering the REPL:
 
 ```bash
 cd rust
-cargo run -p rusty-claude-cli -- --resume session-123456 /status /compact /cost
+cargo run -p rusty-claude-cli -- --resume session.json /status /compact /cost
 ```
 
 You can also inspect memory/config state for a restored session:
 
 ```bash
 cd rust
-cargo run -p rusty-claude-cli -- --resume ~/.claude/sessions/session-123456.json /memory /config
+cargo run -p rusty-claude-cli -- --resume session.json /memory /config
 ```
 
 ## Available commands
@@ -159,7 +158,7 @@ cargo run -p rusty-claude-cli -- --resume ~/.claude/sessions/session-123456.json
 ### Top-level CLI commands
 
 - `prompt <text...>` — run one prompt non-interactively
-- `--resume <session-id-or-path> [/commands...]` — inspect or maintain a saved session stored under `~/.claude/sessions/`
+- `--resume <session.json> [/commands...]` — inspect or maintain a saved session
 - `dump-manifests` — print extracted upstream manifest counts
 - `bootstrap-plan` — print the current bootstrap skeleton
 - `system-prompt [--cwd PATH] [--date YYYY-MM-DD]` — render the synthesized system prompt
@@ -177,14 +176,13 @@ cargo run -p rusty-claude-cli -- --resume ~/.claude/sessions/session-123456.json
 - `/permissions [read-only|workspace-write|danger-full-access]` — inspect or switch permissions
 - `/clear [--confirm]` — clear the current local session
 - `/cost` — show token usage totals
-- `/resume <session-id-or-path>` — load a saved session into the REPL
+- `/resume <session-path>` — load a saved session into the REPL
 - `/config [env|hooks|model]` — inspect discovered Claude config
 - `/memory` — inspect loaded instruction memory files
 - `/init` — create a starter `CLAUDE.md`
 - `/diff` — show the current git diff for the workspace
 - `/version` — print version and build metadata locally
 - `/export [file]` — export the current conversation transcript
-- `/sessions` — list recent managed local sessions from `~/.claude/sessions/`
 - `/session [list|switch <session-id>]` — inspect or switch managed local sessions
 - `/exit` — leave the REPL
 

rust/crates/commands/src/lib.rs

@@ -84,7 +84,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
     SlashCommandSpec {
         name: "resume",
         summary: "Load a saved session into the REPL",
-        argument_hint: Some("<session-id-or-path>"),
+        argument_hint: Some("<session-path>"),
         resume_supported: false,
     },
     SlashCommandSpec {
@@ -129,12 +129,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: Some("[list|switch <session-id>]"),
         resume_supported: false,
     },
-    SlashCommandSpec {
-        name: "sessions",
-        summary: "List recent managed local sessions",
-        argument_hint: None,
-        resume_supported: false,
-    },
 ];
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -169,7 +163,6 @@ pub enum SlashCommand {
         action: Option<String>,
         target: Option<String>,
     },
-    Sessions,
     Unknown(String),
 }
 
@@ -214,7 +207,6 @@ impl SlashCommand {
                 action: parts.next().map(ToOwned::to_owned),
                 target: parts.next().map(ToOwned::to_owned),
             },
-            "sessions" => Self::Sessions,
             other => Self::Unknown(other.to_string()),
         })
     }
@@ -299,7 +291,6 @@ pub fn handle_slash_command(
         | SlashCommand::Version
         | SlashCommand::Export { .. }
         | SlashCommand::Session { .. }
-        | SlashCommand::Sessions
         | SlashCommand::Unknown(_) => None,
     }
 }
@@ -374,10 +365,6 @@ mod tests {
                 target: Some("abc123".to_string())
             })
         );
-        assert_eq!(
-            SlashCommand::parse("/sessions"),
-            Some(SlashCommand::Sessions)
-        );
     }
 
     #[test]
@@ -391,7 +378,7 @@ mod tests {
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
         assert!(help.contains("/cost"));
-        assert!(help.contains("/resume <session-id-or-path>"));
+        assert!(help.contains("/resume <session-path>"));
         assert!(help.contains("/config [env|hooks|model]"));
         assert!(help.contains("/memory"));
         assert!(help.contains("/init"));
@@ -399,8 +386,7 @@ mod tests {
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
         assert!(help.contains("/session [list|switch <session-id>]"));
-        assert!(help.contains("/sessions"));
+        assert_eq!(slash_command_specs().len(), 15);
-        assert_eq!(slash_command_specs().len(), 16);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
@@ -418,7 +404,6 @@ mod tests {
                     text: "recent".to_string(),
                 }]),
             ],
-            metadata: None,
         };
 
         let result = handle_slash_command(
@@ -483,6 +468,5 @@ mod tests {
         assert!(
             handle_slash_command("/session list", &session, CompactionConfig::default()).is_none()
         );
-        assert!(handle_slash_command("/sessions", &session, CompactionConfig::default()).is_none());
     }
 }

rust/crates/runtime/src/compact.rs

@@ -105,7 +105,6 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
         compacted_session: Session {
             version: session.version,
             messages: compacted_messages,
-            metadata: session.metadata.clone(),
         },
         removed_message_count: removed.len(),
     }
@@ -394,7 +393,6 @@ mod tests {
         let session = Session {
             version: 1,
             messages: vec![ConversationMessage::user_text("hello")],
-            metadata: None,
         };
 
         let result = compact_session(&session, CompactionConfig::default());
@@ -422,7 +420,6 @@ mod tests {
                     usage: None,
                 },
             ],
-            metadata: None,
         };
 
         let result = compact_session(

rust/crates/runtime/src/lib.rs

@@ -73,9 +73,7 @@ pub use remote::{
     RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
     DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use session::{
+pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
-    ContentBlock, ConversationMessage, MessageRole, Session, SessionError, SessionMetadata,
-};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };

rust/crates/runtime/src/session.rs

@@ -39,19 +39,10 @@ pub struct ConversationMessage {
     pub usage: Option<TokenUsage>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SessionMetadata {
-    pub started_at: String,
-    pub model: String,
-    pub message_count: u32,
-    pub last_prompt: Option<String>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Session {
     pub version: u32,
     pub messages: Vec<ConversationMessage>,
-    pub metadata: Option<SessionMetadata>,
 }
 
 #[derive(Debug)]
@@ -91,7 +82,6 @@ impl Session {
         Self {
             version: 1,
             messages: Vec::new(),
-            metadata: None,
         }
     }
 
@@ -121,9 +111,6 @@ impl Session {
                     .collect(),
             ),
         );
-        if let Some(metadata) = &self.metadata {
-            object.insert("metadata".to_string(), metadata.to_json());
-        }
         JsonValue::Object(object)
     }
 
@@ -144,15 +131,7 @@ impl Session {
             .iter()
             .map(ConversationMessage::from_json)
             .collect::<Result<Vec<_>, _>>()?;
-        let metadata = object
+        Ok(Self { version, messages })
-            .get("metadata")
-            .map(SessionMetadata::from_json)
-            .transpose()?;
-        Ok(Self {
-            version,
-            messages,
-            metadata,
-        })
     }
 }
 
@@ -162,41 +141,6 @@ impl Default for Session {
     }
 }
 
-impl SessionMetadata {
-    #[must_use]
-    pub fn to_json(&self) -> JsonValue {
-        let mut object = BTreeMap::new();
-        object.insert(
-            "started_at".to_string(),
-            JsonValue::String(self.started_at.clone()),
-        );
-        object.insert("model".to_string(), JsonValue::String(self.model.clone()));
-        object.insert(
-            "message_count".to_string(),
-            JsonValue::Number(i64::from(self.message_count)),
-        );
-        if let Some(last_prompt) = &self.last_prompt {
-            object.insert(
-                "last_prompt".to_string(),
-                JsonValue::String(last_prompt.clone()),
-            );
-        }
-        JsonValue::Object(object)
-    }
-
-    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
-        let object = value.as_object().ok_or_else(|| {
-            SessionError::Format("session metadata must be an object".to_string())
-        })?;
-        Ok(Self {
-            started_at: required_string(object, "started_at")?,
-            model: required_string(object, "model")?,
-            message_count: required_u32(object, "message_count")?,
-            last_prompt: optional_string(object, "last_prompt"),
-        })
-    }
-}
-
 impl ConversationMessage {
     #[must_use]
     pub fn user_text(text: impl Into<String>) -> Self {
@@ -424,13 +368,6 @@ fn required_string(
         .ok_or_else(|| SessionError::Format(format!("missing {key}")))
 }
 
-fn optional_string(object: &BTreeMap<String, JsonValue>, key: &str) -> Option<String> {
-    object
-        .get(key)
-        .and_then(JsonValue::as_str)
-        .map(ToOwned::to_owned)
-}
-
 fn required_u32(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u32, SessionError> {
     let value = object
         .get(key)
@@ -441,8 +378,7 @@ fn required_u32(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u32,
 
 #[cfg(test)]
 mod tests {
-    use super::{ContentBlock, ConversationMessage, MessageRole, Session, SessionMetadata};
+    use super::{ContentBlock, ConversationMessage, MessageRole, Session};
-    use crate::json::JsonValue;
     use crate::usage::TokenUsage;
     use std::fs;
     use std::time::{SystemTime, UNIX_EPOCH};
@@ -450,12 +386,6 @@ mod tests {
     #[test]
     fn persists_and_restores_session_json() {
         let mut session = Session::new();
-        session.metadata = Some(SessionMetadata {
-            started_at: "2026-04-01T00:00:00Z".to_string(),
-            model: "claude-sonnet".to_string(),
-            message_count: 3,
-            last_prompt: Some("hello".to_string()),
-        });
         session
             .messages
             .push(ConversationMessage::user_text("hello"));
@@ -498,23 +428,5 @@ mod tests {
             restored.messages[1].usage.expect("usage").total_tokens(),
             17
         );
-        assert_eq!(restored.metadata, session.metadata);
-    }
-
-    #[test]
-    fn loads_legacy_session_without_metadata() {
-        let legacy = r#"{
-  "version": 1,
-  "messages": [
-    {
-      "role": "user",
-      "blocks": [{"type": "text", "text": "hello"}]
-    }
-  ]
-}"#;
-        let restored = Session::from_json(&JsonValue::parse(legacy).expect("legacy json"))
-            .expect("legacy session should parse");
-        assert_eq!(restored.messages.len(), 1);
-        assert!(restored.metadata.is_none());
     }
 }

rust/crates/runtime/src/usage.rs

@@ -300,7 +300,6 @@ mod tests {
                     cache_read_input_tokens: 0,
                 }),
             }],
-            metadata: None,
         };
 
         let tracker = UsageTracker::from_session(&session);

rust/crates/rusty-claude-cli/src/main.rs

@@ -22,12 +22,12 @@ use commands::{
 use compat_harness::{extract_manifest, UpstreamPaths};
 use render::{Spinner, TerminalRenderer};
 use runtime::{
-    clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
+    clear_oauth_credentials, format_usd, generate_pkce_pair, generate_state, load_system_prompt,
-    parse_oauth_callback_request_target, save_oauth_credentials, ApiClient, ApiRequest,
+    parse_oauth_callback_request_target, pricing_for_model, save_oauth_credentials, ApiClient,
-    AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
+    ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
     ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest,
     OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, RuntimeError,
-    Session, SessionMetadata, TokenUsage, ToolError, ToolExecutor, UsageTracker,
+    Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
 };
 use serde_json::json;
 use tools::{execute_tool, mvp_tool_specs, ToolSpec};
@@ -36,8 +36,8 @@ const DEFAULT_MODEL: &str = "claude-sonnet-4-20250514";
 const DEFAULT_MAX_TOKENS: u32 = 32;
 const DEFAULT_DATE: &str = "2026-03-31";
 const DEFAULT_OAUTH_CALLBACK_PORT: u16 = 4545;
+const COST_WARNING_FRACTION: f64 = 0.8;
 const VERSION: &str = env!("CARGO_PKG_VERSION");
-const OLD_SESSION_COMPACTION_AGE_SECS: u64 = 60 * 60 * 24;
 const BUILD_TARGET: Option<&str> = option_env!("TARGET");
 const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
 
@@ -71,7 +71,8 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             output_format,
             allowed_tools,
             permission_mode,
-        } => LiveCli::new(model, false, allowed_tools, permission_mode)?
+            max_cost_usd,
+        } => LiveCli::new(model, false, allowed_tools, permission_mode, max_cost_usd)?
             .run_turn_with_output(&prompt, output_format)?,
         CliAction::Login => run_login()?,
         CliAction::Logout => run_logout()?,
@@ -79,13 +80,14 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             model,
             allowed_tools,
             permission_mode,
-        } => run_repl(model, allowed_tools, permission_mode)?,
+            max_cost_usd,
+        } => run_repl(model, allowed_tools, permission_mode, max_cost_usd)?,
         CliAction::Help => print_help(),
     }
     Ok(())
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 enum CliAction {
     DumpManifests,
     BootstrapPlan,
@@ -104,6 +106,7 @@ enum CliAction {
         output_format: CliOutputFormat,
         allowed_tools: Option<AllowedToolSet>,
         permission_mode: PermissionMode,
+        max_cost_usd: Option<f64>,
     },
     Login,
     Logout,
@@ -111,6 +114,7 @@ enum CliAction {
         model: String,
         allowed_tools: Option<AllowedToolSet>,
         permission_mode: PermissionMode,
+        max_cost_usd: Option<f64>,
     },
     // prompt-mode formatting is only supported for non-interactive runs
     Help,
@@ -140,6 +144,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
     let mut output_format = CliOutputFormat::Text;
     let mut permission_mode = default_permission_mode();
     let mut wants_version = false;
+    let mut max_cost_usd: Option<f64> = None;
     let mut allowed_tool_values = Vec::new();
     let mut rest = Vec::new();
     let mut index = 0;
@@ -175,6 +180,13 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
                 permission_mode = parse_permission_mode_arg(value)?;
                 index += 2;
             }
+            "--max-cost" => {
+                let value = args
+                    .get(index + 1)
+                    .ok_or_else(|| "missing value for --max-cost".to_string())?;
+                max_cost_usd = Some(parse_max_cost_arg(value)?);
+                index += 2;
+            }
             flag if flag.starts_with("--output-format=") => {
                 output_format = CliOutputFormat::parse(&flag[16..])?;
                 index += 1;
@@ -183,6 +195,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
                 permission_mode = parse_permission_mode_arg(&flag[18..])?;
                 index += 1;
             }
+            flag if flag.starts_with("--max-cost=") => {
+                max_cost_usd = Some(parse_max_cost_arg(&flag[11..])?);
+                index += 1;
+            }
             "--allowedTools" | "--allowed-tools" => {
                 let value = args
                     .get(index + 1)
@@ -216,6 +232,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
             model,
             allowed_tools,
             permission_mode,
+            max_cost_usd,
         });
     }
     if matches!(rest.first().map(String::as_str), Some("--help" | "-h")) {
@@ -242,6 +259,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
                 output_format,
                 allowed_tools,
                 permission_mode,
+                max_cost_usd,
             })
         }
         other if !other.starts_with('/') => Ok(CliAction::Prompt {
@@ -250,6 +268,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
             output_format,
             allowed_tools,
             permission_mode,
+            max_cost_usd,
         }),
         other => Err(format!("unknown subcommand: {other}")),
     }
@@ -313,6 +332,18 @@ fn parse_permission_mode_arg(value: &str) -> Result<PermissionMode, String> {
         .map(permission_mode_from_label)
 }
 
+fn parse_max_cost_arg(value: &str) -> Result<f64, String> {
+    let parsed = value
+        .parse::<f64>()
+        .map_err(|_| format!("invalid value for --max-cost: {value}"))?;
+    if !parsed.is_finite() || parsed <= 0.0 {
+        return Err(format!(
+            "--max-cost must be a positive finite USD amount: {value}"
+        ));
+    }
+    Ok(parsed)
+}
+
 fn permission_mode_from_label(mode: &str) -> PermissionMode {
     match mode {
         "read-only" => PermissionMode::ReadOnly,
@@ -536,14 +567,7 @@ fn print_version() {
 }
 
 fn resume_session(session_path: &Path, commands: &[String]) {
-    let handle = match resolve_session_reference(&session_path.display().to_string()) {
+    let session = match Session::load_from_path(session_path) {
-        Ok(handle) => handle,
-        Err(error) => {
-            eprintln!("failed to resolve session: {error}");
-            std::process::exit(1);
-        }
-    };
-    let session = match Session::load_from_path(&handle.path) {
         Ok(session) => session,
         Err(error) => {
             eprintln!("failed to restore session: {error}");
@@ -554,7 +578,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
     if commands.is_empty() {
         println!(
             "Restored session from {} ({} messages).",
-            handle.path.display(),
+            session_path.display(),
             session.messages.len()
         );
         return;
@@ -566,7 +590,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
             eprintln!("unsupported resumed command: {raw_command}");
             std::process::exit(2);
         };
-        match run_resume_command(&handle.path, &session, &command) {
+        match run_resume_command(session_path, &session, &command) {
             Ok(ResumeCommandOutcome {
                 session: next_session,
                 message,
@@ -686,22 +710,78 @@ fn format_permissions_switch_report(previous: &str, next: &str) -> String {
     )
 }
 
-fn format_cost_report(usage: TokenUsage) -> String {
+fn format_cost_report(model: &str, usage: TokenUsage, max_cost_usd: Option<f64>) -> String {
+    let estimate = usage_cost_estimate(model, usage);
     format!(
         "Cost
+  Model            {model}
   Input tokens     {}
   Output tokens    {}
   Cache create     {}
   Cache read       {}
-  Total tokens     {}",
+  Total tokens     {}
+  Input cost       {}
+  Output cost      {}
+  Cache create usd {}
+  Cache read usd   {}
+  Estimated cost   {}
+  Budget           {}",
         usage.input_tokens,
         usage.output_tokens,
         usage.cache_creation_input_tokens,
         usage.cache_read_input_tokens,
         usage.total_tokens(),
+        format_usd(estimate.input_cost_usd),
+        format_usd(estimate.output_cost_usd),
+        format_usd(estimate.cache_creation_cost_usd),
+        format_usd(estimate.cache_read_cost_usd),
+        format_usd(estimate.total_cost_usd()),
+        format_budget_line(estimate.total_cost_usd(), max_cost_usd),
     )
 }
 
+fn usage_cost_estimate(model: &str, usage: TokenUsage) -> runtime::UsageCostEstimate {
+    pricing_for_model(model).map_or_else(
+        || usage.estimate_cost_usd(),
+        |pricing| usage.estimate_cost_usd_with_pricing(pricing),
+    )
+}
+
+fn usage_cost_total(model: &str, usage: TokenUsage) -> f64 {
+    usage_cost_estimate(model, usage).total_cost_usd()
+}
+
+fn format_budget_line(cost_usd: f64, max_cost_usd: Option<f64>) -> String {
+    match max_cost_usd {
+        Some(limit) => format!("{} / {}", format_usd(cost_usd), format_usd(limit)),
+        None => format!("{} (unlimited)", format_usd(cost_usd)),
+    }
+}
+
+fn budget_notice_message(
+    model: &str,
+    usage: TokenUsage,
+    max_cost_usd: Option<f64>,
+) -> Option<String> {
+    let limit = max_cost_usd?;
+    let cost = usage_cost_total(model, usage);
+    if cost >= limit {
+        Some(format!(
+            "cost budget exceeded: cumulative={} budget={}",
+            format_usd(cost),
+            format_usd(limit)
+        ))
+    } else if cost >= limit * COST_WARNING_FRACTION {
+        Some(format!(
+            "approaching cost budget: cumulative={} budget={}",
+            format_usd(cost),
+            format_usd(limit)
+        ))
+    } else {
+        None
+    }
+}
+
 fn format_resume_report(session_path: &str, message_count: usize, turns: u32) -> String {
     format!(
         "Session resumed
@@ -845,6 +925,7 @@ fn run_resume_command(
                     },
                     default_permission_mode().as_str(),
                     &status_context(Some(session_path))?,
+                    None,
                 )),
             })
         }
@@ -852,7 +933,7 @@ fn run_resume_command(
             let usage = UsageTracker::from_session(session).cumulative_usage();
             Ok(ResumeCommandOutcome {
                 session: session.clone(),
-                message: Some(format_cost_report(usage)),
+                message: Some(format_cost_report("restored-session", usage, None)),
             })
         }
         SlashCommand::Config { section } => Ok(ResumeCommandOutcome {
@@ -891,7 +972,6 @@ fn run_resume_command(
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Session { .. }
-        | SlashCommand::Sessions
         | SlashCommand::Unknown(_) => Err("unsupported resumed slash command".into()),
     }
 }
@@ -900,8 +980,9 @@ fn run_repl(
     model: String,
     allowed_tools: Option<AllowedToolSet>,
     permission_mode: PermissionMode,
+    max_cost_usd: Option<f64>,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let mut cli = LiveCli::new(model, true, allowed_tools, permission_mode)?;
+    let mut cli = LiveCli::new(model, true, allowed_tools, permission_mode, max_cost_usd)?;
     let mut editor = input::LineEditor::new("› ", slash_command_completion_candidates());
     println!("{}", cli.startup_banner());
 
@@ -948,15 +1029,13 @@ struct ManagedSessionSummary {
     path: PathBuf,
     modified_epoch_secs: u64,
     message_count: usize,
-    model: Option<String>,
-    started_at: Option<String>,
-    last_prompt: Option<String>,
 }
 
 struct LiveCli {
     model: String,
     allowed_tools: Option<AllowedToolSet>,
     permission_mode: PermissionMode,
+    max_cost_usd: Option<f64>,
     system_prompt: Vec<String>,
     runtime: ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>,
     session: SessionHandle,
@@ -968,10 +1047,10 @@ impl LiveCli {
         enable_tools: bool,
         allowed_tools: Option<AllowedToolSet>,
         permission_mode: PermissionMode,
+        max_cost_usd: Option<f64>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let system_prompt = build_system_prompt()?;
         let session = create_managed_session_handle()?;
-        auto_compact_inactive_sessions(&session.id)?;
         let runtime = build_runtime(
             Session::new(),
             model.clone(),
@@ -984,6 +1063,7 @@ impl LiveCli {
             model,
             allowed_tools,
             permission_mode,
+            max_cost_usd,
             system_prompt,
             runtime,
             session,
@@ -994,9 +1074,10 @@ impl LiveCli {
 
     fn startup_banner(&self) -> String {
         format!(
-            "Rusty Claude CLI\n  Model            {}\n  Permission mode  {}\n  Working directory {}\n  Session          {}\n\nType /help for commands. Shift+Enter or Ctrl+J inserts a newline.",
+            "Rusty Claude CLI\n  Model            {}\n  Permission mode  {}\n  Cost budget      {}\n  Working directory {}\n  Session          {}\n\nType /help for commands. Shift+Enter or Ctrl+J inserts a newline.",
             self.model,
             self.permission_mode.as_str(),
+            self.max_cost_usd.map_or_else(|| "none".to_string(), format_usd),
             env::current_dir().map_or_else(
                 |_| "<unknown>".to_string(),
                 |path| path.display().to_string(),
@@ -1006,6 +1087,7 @@ impl LiveCli {
     }
 
     fn run_turn(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
+        self.enforce_budget_before_turn()?;
         let mut spinner = Spinner::new();
         let mut stdout = io::stdout();
         spinner.tick(
@@ -1016,13 +1098,14 @@ impl LiveCli {
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
         let result = self.runtime.run_turn(input, Some(&mut permission_prompter));
         match result {
-            Ok(_) => {
+            Ok(summary) => {
                 spinner.finish(
                     "Claude response complete",
                     TerminalRenderer::new().color_theme(),
                     &mut stdout,
                 )?;
                 println!();
+                self.print_budget_notice(summary.usage);
                 self.persist_session()?;
                 Ok(())
             }
@@ -1049,6 +1132,7 @@ impl LiveCli {
     }
 
     fn run_prompt_json(&mut self, input: &str) -> Result<(), Box<dyn std::error::Error>> {
+        self.enforce_budget_before_turn()?;
         let client = AnthropicClient::from_auth(resolve_cli_auth_source()?);
         let request = MessageRequest {
             model: self.model.clone(),
@@ -1075,17 +1159,27 @@ impl LiveCli {
             })
             .collect::<Vec<_>>()
             .join("");
+        let usage = TokenUsage {
+            input_tokens: response.usage.input_tokens,
+            output_tokens: response.usage.output_tokens,
+            cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
+            cache_read_input_tokens: response.usage.cache_read_input_tokens,
+        };
         println!(
             "{}",
             json!({
                 "message": text,
                 "model": self.model,
                 "usage": {
-                    "input_tokens": response.usage.input_tokens,
+                    "input_tokens": usage.input_tokens,
-                    "output_tokens": response.usage.output_tokens,
+                    "output_tokens": usage.output_tokens,
-                    "cache_creation_input_tokens": response.usage.cache_creation_input_tokens,
+                    "cache_creation_input_tokens": usage.cache_creation_input_tokens,
-                    "cache_read_input_tokens": response.usage.cache_read_input_tokens,
+                    "cache_read_input_tokens": usage.cache_read_input_tokens,
-                }
+                },
+                "cost_usd": usage_cost_total(&self.model, usage),
+                "cumulative_cost_usd": usage_cost_total(&self.model, usage),
+                "max_cost_usd": self.max_cost_usd,
+                "budget_warning": budget_notice_message(&self.model, usage, self.max_cost_usd),
             })
         );
         Ok(())
@@ -1143,10 +1237,6 @@ impl LiveCli {
             SlashCommand::Session { action, target } => {
                 self.handle_session_command(action.as_deref(), target.as_deref())?
             }
-            SlashCommand::Sessions => {
-                println!("{}", render_session_list(&self.session.id)?);
-                false
-            }
             SlashCommand::Unknown(name) => {
                 eprintln!("unknown slash command: /{name}");
                 false
@@ -1155,13 +1245,32 @@ impl LiveCli {
     }
 
     fn persist_session(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let mut session = self.runtime.session().clone();
+        self.runtime.session().save_to_path(&self.session.path)?;
-        session.metadata = Some(derive_session_metadata(&session, &self.model));
-        session.save_to_path(&self.session.path)?;
-        auto_compact_inactive_sessions(&self.session.id)?;
         Ok(())
     }
 
+    fn enforce_budget_before_turn(&self) -> Result<(), Box<dyn std::error::Error>> {
+        let Some(limit) = self.max_cost_usd else {
+            return Ok(());
+        };
+        let cost = usage_cost_total(&self.model, self.runtime.usage().cumulative_usage());
+        if cost >= limit {
+            return Err(format!(
+                "cost budget exceeded before starting turn: cumulative={} budget={}",
+                format_usd(cost),
+                format_usd(limit)
+            )
+            .into());
+        }
+        Ok(())
+    }
+
+    fn print_budget_notice(&self, usage: TokenUsage) {
+        if let Some(message) = budget_notice_message(&self.model, usage, self.max_cost_usd) {
+            eprintln!("warning: {message}");
+        }
+    }
+
     fn print_status(&self) {
         let cumulative = self.runtime.usage().cumulative_usage();
         let latest = self.runtime.usage().current_turn_usage();
@@ -1178,6 +1287,7 @@ impl LiveCli {
                 },
                 self.permission_mode.as_str(),
                 &status_context(Some(&self.session.path)).expect("status context should load"),
+                self.max_cost_usd,
             )
         );
     }
@@ -1295,7 +1405,10 @@ impl LiveCli {
 
     fn print_cost(&self) {
         let cumulative = self.runtime.usage().cumulative_usage();
-        println!("{}", format_cost_report(cumulative));
+        println!(
+            "{}",
+            format_cost_report(&self.model, cumulative, self.max_cost_usd)
+        );
     }
 
     fn resume_session(
@@ -1303,20 +1416,13 @@ impl LiveCli {
         session_path: Option<String>,
     ) -> Result<bool, Box<dyn std::error::Error>> {
         let Some(session_ref) = session_path else {
-            println!("Usage: /resume <session-id-or-path>");
+            println!("Usage: /resume <session-path>");
             return Ok(false);
         };
 
         let handle = resolve_session_reference(&session_ref)?;
         let session = Session::load_from_path(&handle.path)?;
         let message_count = session.messages.len();
-        if let Some(model) = session
-            .metadata
-            .as_ref()
-            .map(|metadata| metadata.model.clone())
-        {
-            self.model = model;
-        }
         self.runtime = build_runtime(
             session,
             self.model.clone(),
@@ -1393,13 +1499,6 @@ impl LiveCli {
                 let handle = resolve_session_reference(target)?;
                 let session = Session::load_from_path(&handle.path)?;
                 let message_count = session.messages.len();
-                if let Some(model) = session
-                    .metadata
-                    .as_ref()
-                    .map(|metadata| metadata.model.clone())
-                {
-                    self.model = model;
-                }
                 self.runtime = build_runtime(
                     session,
                     self.model.clone(),
@@ -1444,10 +1543,8 @@ impl LiveCli {
 }
 
 fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let home = env::var_os("HOME")
+    let cwd = env::current_dir()?;
-        .map(PathBuf::from)
+    let path = cwd.join(".claude").join("sessions");
-        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "HOME is not set"))?;
-    let path = home.join(".claude").join("sessions");
     fs::create_dir_all(&path)?;
     Ok(path)
 }
@@ -1468,19 +1565,8 @@ fn generate_session_id() -> String {
 
 fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {
     let direct = PathBuf::from(reference);
-    let expanded = if let Some(stripped) = reference.strip_prefix("~/") {
-        sessions_dir()?
-            .parent()
-            .and_then(|claude| claude.parent())
-            .map(|home| home.join(stripped))
-            .unwrap_or(direct.clone())
-    } else {
-        direct.clone()
-    };
     let path = if direct.exists() {
         direct
-    } else if expanded.exists() {
-        expanded
     } else {
         sessions_dir()?.join(format!("{reference}.json"))
     };
@@ -1510,11 +1596,9 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
             .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
             .map(|duration| duration.as_secs())
             .unwrap_or_default();
-        let session = Session::load_from_path(&path).ok();
+        let message_count = Session::load_from_path(&path)
-        let derived_message_count = session.as_ref().map_or(0, |session| session.messages.len());
+            .map(|session| session.messages.len())
-        let stored = session
+            .unwrap_or_default();
-            .as_ref()
-            .and_then(|session| session.metadata.as_ref());
         let id = path
             .file_stem()
             .and_then(|value| value.to_str())
@@ -1524,12 +1608,7 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
             id,
             path,
             modified_epoch_secs,
-            message_count: stored.map_or(derived_message_count, |metadata| {
+            message_count,
-                metadata.message_count as usize
-            }),
-            model: stored.map(|metadata| metadata.model.clone()),
-            started_at: stored.map(|metadata| metadata.started_at.clone()),
-            last_prompt: stored.and_then(|metadata| metadata.last_prompt.clone()),
         });
     }
     sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));
@@ -1552,99 +1631,17 @@ fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::e
         } else {
             "○ saved"
         };
-        let model = session.model.as_deref().unwrap_or("unknown");
-        let started = session.started_at.as_deref().unwrap_or("unknown");
-        let last_prompt = session.last_prompt.as_deref().map_or_else(
-            || "-".to_string(),
-            |prompt| truncate_for_summary(prompt, 36),
-        );
         lines.push(format!(
-            "  {id:<20} {marker:<10} msgs={msgs:<4} model={model:<24} started={started} modified={modified} last={last_prompt} path={path}",
+            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified} path={path}",
             id = session.id,
             msgs = session.message_count,
-            model = model,
-            started = started,
             modified = session.modified_epoch_secs,
-            last_prompt = last_prompt,
             path = session.path.display(),
         ));
     }
     Ok(lines.join("\n"))
 }
 
-fn current_epoch_secs() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|duration| duration.as_secs())
-        .unwrap_or_default()
-}
-
-fn current_timestamp_rfc3339ish() -> String {
-    format!("{}Z", current_epoch_secs())
-}
-
-fn last_prompt_from_session(session: &Session) -> Option<String> {
-    session
-        .messages
-        .iter()
-        .rev()
-        .find(|message| message.role == MessageRole::User)
-        .and_then(|message| {
-            message.blocks.iter().find_map(|block| match block {
-                ContentBlock::Text { text } => Some(text.trim().to_string()),
-                _ => None,
-            })
-        })
-        .filter(|text| !text.is_empty())
-}
-
-fn derive_session_metadata(session: &Session, model: &str) -> SessionMetadata {
-    let started_at = session
-        .metadata
-        .as_ref()
-        .map_or_else(current_timestamp_rfc3339ish, |metadata| {
-            metadata.started_at.clone()
-        });
-    SessionMetadata {
-        started_at,
-        model: model.to_string(),
-        message_count: session.messages.len().try_into().unwrap_or(u32::MAX),
-        last_prompt: last_prompt_from_session(session),
-    }
-}
-
-fn session_age_secs(modified_epoch_secs: u64) -> u64 {
-    current_epoch_secs().saturating_sub(modified_epoch_secs)
-}
-
-fn auto_compact_inactive_sessions(
-    active_session_id: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    for summary in list_managed_sessions()? {
-        if summary.id == active_session_id
-            || session_age_secs(summary.modified_epoch_secs) < OLD_SESSION_COMPACTION_AGE_SECS
-        {
-            continue;
-        }
-        let path = summary.path.clone();
-        let Ok(session) = Session::load_from_path(&path) else {
-            continue;
-        };
-        if !runtime::should_compact(&session, CompactionConfig::default()) {
-            continue;
-        }
-        let mut compacted =
-            runtime::compact_session(&session, CompactionConfig::default()).compacted_session;
-        let model = compacted.metadata.as_ref().map_or_else(
-            || DEFAULT_MODEL.to_string(),
-            |metadata| metadata.model.clone(),
-        );
-        compacted.metadata = Some(derive_session_metadata(&compacted, &model));
-        compacted.save_to_path(&path)?;
-    }
-    Ok(())
-}
-
 fn render_repl_help() -> String {
     [
         "REPL".to_string(),
@@ -1689,7 +1686,10 @@ fn format_status_report(
     usage: StatusUsage,
     permission_mode: &str,
     context: &StatusContext,
+    max_cost_usd: Option<f64>,
 ) -> String {
+    let latest_cost = usage_cost_total(model, usage.latest);
+    let cumulative_cost = usage_cost_total(model, usage.cumulative);
     [
         format!(
             "Status
@@ -1697,19 +1697,27 @@ fn format_status_report(
   Permission mode  {permission_mode}
   Messages         {}
   Turns            {}
-  Estimated tokens {}",
+  Estimated tokens {}
-            usage.message_count, usage.turns, usage.estimated_tokens,
+  Cost budget      {}",
+            usage.message_count,
+            usage.turns,
+            usage.estimated_tokens,
+            format_budget_line(cumulative_cost, max_cost_usd),
         ),
         format!(
             "Usage
   Latest total     {}
+  Latest cost      {}
   Cumulative input {}
   Cumulative output {}
-  Cumulative total {}",
+  Cumulative total {}
+  Cumulative cost  {}",
             usage.latest.total_tokens(),
+            format_usd(latest_cost),
             usage.cumulative.input_tokens,
             usage.cumulative.output_tokens,
             usage.cumulative.total_tokens(),
+            format_usd(cumulative_cost),
         ),
         format!(
             "Workspace
@@ -2481,9 +2489,9 @@ fn print_help() {
     println!("rusty-claude-cli v{VERSION}");
     println!();
     println!("Usage:");
-    println!("  rusty-claude-cli [--model MODEL] [--allowedTools TOOL[,TOOL...]]");
+    println!("  rusty-claude-cli [--model MODEL] [--max-cost USD] [--allowedTools TOOL[,TOOL...]]");
     println!("      Start the interactive REPL");
-    println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] prompt TEXT");
+    println!("  rusty-claude-cli [--model MODEL] [--max-cost USD] [--output-format text|json] prompt TEXT");
     println!("      Send one prompt and exit");
     println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] TEXT");
     println!("      Shorthand non-interactive prompt mode");
@@ -2499,6 +2507,7 @@ fn print_help() {
     println!("  --model MODEL              Override the active model");
     println!("  --output-format FORMAT     Non-interactive output format: text or json");
     println!("  --permission-mode MODE     Set read-only, workspace-write, or danger-full-access");
+    println!("  --max-cost USD             Warn at 80% of budget and stop at/exceeding the budget");
     println!("  --allowedTools TOOLS       Restrict enabled tools (repeatable; comma-separated aliases supported)");
     println!("  --version, -V              Print version and build information locally");
     println!();
@@ -2525,73 +2534,18 @@ fn print_help() {
 #[cfg(test)]
 mod tests {
     use super::{
-        derive_session_metadata, filter_tool_specs, format_compact_report, format_cost_report,
+        budget_notice_message, filter_tool_specs, format_compact_report, format_cost_report,
         format_init_report, format_model_report, format_model_switch_report,
         format_permissions_report, format_permissions_switch_report, format_resume_report,
-        format_status_report, format_tool_call_start, format_tool_result, list_managed_sessions,
+        format_status_report, format_tool_call_start, format_tool_result,
         normalize_permission_mode, parse_args, parse_git_status_metadata, render_config_report,
         render_init_claude_md, render_memory_report, render_repl_help,
-        resume_supported_slash_commands, sessions_dir, status_context, CliAction, CliOutputFormat,
+        resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,
-        SlashCommand, StatusUsage, DEFAULT_MODEL,
+        StatusUsage, DEFAULT_MODEL,
     };
-    use runtime::{ContentBlock, ConversationMessage, MessageRole, PermissionMode, Session};
+    use runtime::{ContentBlock, ConversationMessage, MessageRole, PermissionMode};
-    use std::fs;
     use std::path::{Path, PathBuf};
 
-    #[test]
-    fn derive_session_metadata_recomputes_prompt_and_count() {
-        let mut session = Session::new();
-        session
-            .messages
-            .push(ConversationMessage::user_text("first prompt"));
-        session
-            .messages
-            .push(ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "reply".to_string(),
-            }]));
-        let metadata = derive_session_metadata(&session, "claude-test");
-        assert_eq!(metadata.model, "claude-test");
-        assert_eq!(metadata.message_count, 2);
-        assert_eq!(metadata.last_prompt.as_deref(), Some("first prompt"));
-        assert!(metadata.started_at.ends_with('Z'));
-    }
-
-    #[test]
-    fn managed_sessions_use_home_directory_and_list_metadata() {
-        let temp =
-            std::env::temp_dir().join(format!("rusty-claude-cli-home-{}", std::process::id()));
-        let _ = fs::remove_dir_all(&temp);
-        fs::create_dir_all(&temp).expect("temp home should exist");
-        let previous_home = std::env::var_os("HOME");
-        std::env::set_var("HOME", &temp);
-
-        let dir = sessions_dir().expect("sessions dir");
-        assert_eq!(dir, temp.join(".claude").join("sessions"));
-
-        let mut session = Session::new();
-        session
-            .messages
-            .push(ConversationMessage::user_text("persist me"));
-        session.metadata = Some(derive_session_metadata(&session, "claude-home"));
-        let file = dir.join("session-test.json");
-        session.save_to_path(&file).expect("session save");
-
-        let listed = list_managed_sessions().expect("session list");
-        let found = listed
-            .into_iter()
-            .find(|entry| entry.id == "session-test")
-            .expect("saved session should be listed");
-        assert_eq!(found.message_count, 1);
-        assert_eq!(found.model.as_deref(), Some("claude-home"));
-        assert_eq!(found.last_prompt.as_deref(), Some("persist me"));
-
-        fs::remove_file(file).ok();
-        if let Some(previous_home) = previous_home {
-            std::env::set_var("HOME", previous_home);
-        }
-        fs::remove_dir_all(temp).ok();
-    }
-
     #[test]
     fn defaults_to_repl_when_no_args() {
         assert_eq!(
@@ -2600,6 +2554,7 @@ mod tests {
                 model: DEFAULT_MODEL.to_string(),
                 allowed_tools: None,
                 permission_mode: PermissionMode::WorkspaceWrite,
+                max_cost_usd: None,
             }
         );
     }
@@ -2619,6 +2574,7 @@ mod tests {
                 output_format: CliOutputFormat::Text,
                 allowed_tools: None,
                 permission_mode: PermissionMode::WorkspaceWrite,
+                max_cost_usd: None,
             }
         );
     }
@@ -2640,6 +2596,7 @@ mod tests {
                 output_format: CliOutputFormat::Json,
                 allowed_tools: None,
                 permission_mode: PermissionMode::WorkspaceWrite,
+                max_cost_usd: None,
             }
         );
     }
@@ -2665,10 +2622,32 @@ mod tests {
                 model: DEFAULT_MODEL.to_string(),
                 allowed_tools: None,
                 permission_mode: PermissionMode::ReadOnly,
+                max_cost_usd: None,
             }
         );
     }
 
+    #[test]
+    fn parses_max_cost_flag() {
+        let args = vec!["--max-cost=1.25".to_string()];
+        assert_eq!(
+            parse_args(&args).expect("args should parse"),
+            CliAction::Repl {
+                model: DEFAULT_MODEL.to_string(),
+                allowed_tools: None,
+                permission_mode: PermissionMode::WorkspaceWrite,
+                max_cost_usd: Some(1.25),
+            }
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_max_cost_flag() {
+        let error = parse_args(&["--max-cost".to_string(), "0".to_string()])
+            .expect_err("zero max cost should be rejected");
+        assert!(error.contains("--max-cost must be a positive finite USD amount"));
+    }
+
     #[test]
     fn parses_allowed_tools_flags_with_aliases_and_lists() {
         let args = vec![
@@ -2687,6 +2666,7 @@ mod tests {
                         .collect()
                 ),
                 permission_mode: PermissionMode::WorkspaceWrite,
+                max_cost_usd: None,
             }
         );
     }
@@ -2797,8 +2777,7 @@ mod tests {
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
         assert!(help.contains("/cost"));
-        assert!(help.contains("/resume <session-id-or-path>"));
+        assert!(help.contains("/resume <session-path>"));
-        assert!(help.contains("/sessions"));
         assert!(help.contains("/config [env|hooks|model]"));
         assert!(help.contains("/memory"));
         assert!(help.contains("/init"));
@@ -2845,18 +2824,24 @@ mod tests {
 
     #[test]
     fn cost_report_uses_sectioned_layout() {
-        let report = format_cost_report(runtime::TokenUsage {
+        let report = format_cost_report(
-            input_tokens: 20,
+            "claude-sonnet",
-            output_tokens: 8,
+            runtime::TokenUsage {
-            cache_creation_input_tokens: 3,
+                input_tokens: 20,
-            cache_read_input_tokens: 1,
+                output_tokens: 8,
-        });
+                cache_creation_input_tokens: 3,
+                cache_read_input_tokens: 1,
+            },
+            None,
+        );
         assert!(report.contains("Cost"));
         assert!(report.contains("Input tokens     20"));
         assert!(report.contains("Output tokens    8"));
         assert!(report.contains("Cache create     3"));
         assert!(report.contains("Cache read       1"));
         assert!(report.contains("Total tokens     32"));
+        assert!(report.contains("Estimated cost"));
+        assert!(report.contains("Budget           $0.0010 (unlimited)"));
     }
 
     #[test]
@@ -2938,6 +2923,7 @@ mod tests {
                 project_root: Some(PathBuf::from("/tmp")),
                 git_branch: Some("main".to_string()),
             },
+            Some(1.0),
         );
         assert!(status.contains("Status"));
         assert!(status.contains("Model            claude-sonnet"));
@@ -2945,6 +2931,7 @@ mod tests {
         assert!(status.contains("Messages         7"));
         assert!(status.contains("Latest total     10"));
         assert!(status.contains("Cumulative total 31"));
+        assert!(status.contains("Cost budget      $0.0009 / $1.0000"));
         assert!(status.contains("Cwd              /tmp/project"));
         assert!(status.contains("Project root     /tmp"));
         assert!(status.contains("Git branch       main"));
@@ -2953,6 +2940,22 @@ mod tests {
         assert!(status.contains("Memory files     4"));
     }
 
+    #[test]
+    fn budget_notice_warns_near_limit() {
+        let message = budget_notice_message(
+            "claude-sonnet",
+            runtime::TokenUsage {
+                input_tokens: 60_000,
+                output_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 0,
+            },
+            Some(1.0),
+        )
+        .expect("budget warning expected");
+        assert!(message.contains("approaching cost budget"));
+    }
+
     #[test]
     fn config_report_supports_section_views() {
         let report = render_config_report(Some("env")).expect("config report should render");
@@ -2990,8 +2993,8 @@ mod tests {
     fn status_context_reads_real_workspace_metadata() {
         let context = status_context(None).expect("status context should load");
         assert!(context.cwd.is_absolute());
-        assert!(context.discovered_config_files >= 3);
+        assert!(context.discovered_config_files >= context.loaded_config_files);
-        assert!(context.loaded_config_files <= context.discovered_config_files);
+        assert!(context.discovered_config_files >= 1);
     }
 
     #[test]