bkutasi
diff --git a/‎.gitignore‎
Lines changed: 3 additions & 0 deletions b/‎.gitignore‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎scripts/coverage.sh‎
Lines changed: 101 additions & 0 deletions b/‎scripts/coverage.sh‎
Lines changed: 101 additions & 0 deletions
diff --git a/‎src/agent/agent_loop.rs‎
Lines changed: 2 additions & 0 deletions b/‎src/agent/agent_loop.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎src/agent/dispatcher.rs‎
Lines changed: 6 additions & 1 deletion b/‎src/agent/dispatcher.rs‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎src/agent/thread_ops.rs‎
Lines changed: 2 additions & 1 deletion b/‎src/agent/thread_ops.rs‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎src/app.rs‎
Lines changed: 37 additions & 5 deletions b/‎src/app.rs‎
Lines changed: 37 additions & 5 deletions
diff --git a/‎src/config/agent.rs‎
Lines changed: 20 additions & 0 deletions b/‎src/config/agent.rs‎
Lines changed: 20 additions & 0 deletions
diff --git a/‎src/config/llm.rs‎
Lines changed: 34 additions & 0 deletions b/‎src/config/llm.rs‎
Lines changed: 34 additions & 0 deletions
@@ -16,6 +16,9 @@ target/
 # Benchmark results (local runs, not committed)
 bench-results/
 
+# Coverage reports (local runs, not committed)
+coverage/
+
 # WASM build artifacts (loaded from disk, not bundled)
 *.wasm
 
@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+# Generate an HTML coverage report for a given set of tests.
+#
+# Usage:
+#   ./scripts/coverage.sh                          # all tests (lib only)
+#   ./scripts/coverage.sh safety                   # tests matching "safety"
+#   ./scripts/coverage.sh safety::sanitizer        # specific module tests
+#   ./scripts/coverage.sh test_a test_b test_c     # multiple test filters
+#
+# Options (env vars):
+#   COV_OPEN=1          Auto-open the report in a browser (default: 1)
+#   COV_FORMAT=html     Output format: html, text, json, lcov (default: html)
+#   COV_OUT=coverage    Output directory (default: coverage/)
+#   COV_FEATURES=""     Extra --features to pass (default: none)
+#   COV_ALL_TARGETS=0   Set to 1 to include integration tests (default: lib only)
+#
+# Requires: cargo-llvm-cov (install: cargo install cargo-llvm-cov)
+
+set -euo pipefail
+
+COV_OPEN="${COV_OPEN:-1}"
+COV_FORMAT="${COV_FORMAT:-html}"
+COV_OUT="${COV_OUT:-coverage}"
+COV_FEATURES="${COV_FEATURES:-}"
+COV_ALL_TARGETS="${COV_ALL_TARGETS:-0}"
+
+cd "$(git rev-parse --show-toplevel)"
+
+if ! command -v cargo-llvm-cov &>/dev/null; then
+    echo "ERROR: cargo-llvm-cov not found. Install with: cargo install cargo-llvm-cov"
+    exit 1
+fi
+
+# Clean stale profiling data to avoid "mismatched data" warnings.
+cargo llvm-cov clean --workspace 2>/dev/null || true
+
+# Build the cargo llvm-cov command
+cmd=(cargo llvm-cov)
+
+# Features
+if [[ -n "$COV_FEATURES" ]]; then
+    cmd+=(--features "$COV_FEATURES")
+else
+    cmd+=(--all-features)
+fi
+
+# By default, only run the lib unit tests (fast, no integration test compilation).
+# Set COV_ALL_TARGETS=1 to include integration tests.
+if [[ "$COV_ALL_TARGETS" != "1" ]]; then
+    cmd+=(--lib)
+fi
+
+# Output format
+case "$COV_FORMAT" in
+    html)
+        cmd+=(--html --output-dir "$COV_OUT")
+        ;;
+    text)
+        cmd+=(--text)
+        ;;
+    json)
+        cmd+=(--json --output-path "$COV_OUT/coverage.json")
+        ;;
+    lcov)
+        cmd+=(--lcov --output-path "$COV_OUT/lcov.info")
+        ;;
+    *)
+        echo "ERROR: Unknown format '$COV_FORMAT'. Use: html, text, json, lcov"
+        exit 1
+        ;;
+esac
+
+# Test name filters (passed after -- to cargo test)
+if [[ $# -gt 0 ]]; then
+    if [[ $# -eq 1 ]]; then
+        cmd+=(-- "$1")
+    else
+        # Join filters with | for regex matching
+        filter=$(IFS='|'; echo "$*")
+        cmd+=(-- "$filter")
+    fi
+fi
+
+echo "Running: ${cmd[*]}"
+echo ""
+
+"${cmd[@]}"
+
+# Open report
+if [[ "$COV_FORMAT" == "html" && "$COV_OPEN" == "1" ]]; then
+    index="$COV_OUT/html/index.html"
+    if [[ -f "$index" ]]; then
+        echo ""
+        echo "Report: $index"
+        if command -v open &>/dev/null; then
+            open "$index"
+        elif command -v xdg-open &>/dev/null; then
+            xdg-open "$index"
+        fi
+    fi
+fi
@@ -75,6 +75,8 @@ pub struct AgentDeps {
     pub cost_guard: Arc<crate::agent::cost_guard::CostGuard>,
     /// SSE broadcast sender for live job event streaming to the web gateway.
     pub sse_tx: Option<tokio::sync::broadcast::Sender<crate::channels::web::types::SseEvent>>,
+    /// HTTP interceptor for trace recording/replay.
+    pub http_interceptor: Option<Arc<dyn crate::llm::recording::HttpInterceptor>>,
 }
 
 /// The main agent that coordinates all components.
 
@@ -127,7 +127,9 @@ impl Agent {
         let mut context_messages = initial_messages;
 
         // Create a JobContext for tool execution (chat doesn't have a real job)
-        let job_ctx = JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+        let mut job_ctx =
+            JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+        job_ctx.http_interceptor = self.deps.http_interceptor.clone();
 
         let max_tool_iterations = self.config.max_tool_iterations;
         // Force a text-only response on the last iteration to guarantee termination
@@ -1066,6 +1068,7 @@ mod tests {
             hooks: Arc::new(HookRegistry::new()),
             cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
             sse_tx: None,
+            http_interceptor: None,
         };
 
         Agent::new(
@@ -1805,6 +1808,7 @@ mod tests {
             hooks: Arc::new(HookRegistry::new()),
             cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
             sse_tx: None,
+            http_interceptor: None,
         };
 
         Agent::new(
@@ -1917,6 +1921,7 @@ mod tests {
                 hooks: Arc::new(HookRegistry::new()),
                 cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
                 sse_tx: None,
+                http_interceptor: None,
             };
 
             Agent::new(
 
@@ -734,8 +734,9 @@ impl Agent {
             }
 
             // Execute the approved tool and continue the loop
-            let job_ctx =
+            let mut job_ctx =
                 JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+            job_ctx.http_interceptor = self.deps.http_interceptor.clone();
 
             let _ = self
                 .channels
 
@@ -15,7 +15,7 @@ use crate::context::ContextManager;
 use crate::db::Database;
 use crate::extensions::ExtensionManager;
 use crate::hooks::HookRegistry;
-use crate::llm::{LlmProvider, SessionManager};
+use crate::llm::{LlmProvider, RecordingLlm, SessionManager};
 use crate::safety::SafetyLayer;
 use crate::secrets::SecretsStore;
 use crate::skills::SkillRegistry;
@@ -48,6 +48,7 @@ pub struct AppComponents {
     pub skill_registry: Option<Arc<std::sync::RwLock<SkillRegistry>>>,
     pub skill_catalog: Option<Arc<SkillCatalog>>,
     pub cost_guard: Arc<crate::agent::cost_guard::CostGuard>,
+    pub recording_handle: Option<Arc<RecordingLlm>>,
     pub session: Arc<SessionManager>,
     pub catalog_entries: Vec<crate::extensions::RegistryEntry>,
     pub dev_loaded_tool_names: Vec<String>,
@@ -71,6 +72,9 @@ pub struct AppBuilder {
     db: Option<Arc<dyn Database>>,
     secrets_store: Option<Arc<dyn SecretsStore + Send + Sync>>,
 
+    // Test overrides
+    llm_override: Option<Arc<dyn LlmProvider>>,
+
     // Backend-specific handles needed by secrets store
     #[cfg(feature = "postgres")]
     pg_pool: Option<deadpool_postgres::Pool>,
@@ -99,18 +103,34 @@ impl AppBuilder {
             log_broadcaster,
             db: None,
             secrets_store: None,
+            llm_override: None,
             #[cfg(feature = "postgres")]
             pg_pool: None,
             #[cfg(feature = "libsql")]
             libsql_db: None,
         }
     }
 
+    /// Inject a pre-created database, skipping `init_database()`.
+    pub fn with_database(&mut self, db: Arc<dyn Database>) {
+        self.db = Some(db);
+    }
+
+    /// Inject a pre-created LLM provider, skipping `init_llm()`.
+    pub fn with_llm(&mut self, llm: Arc<dyn LlmProvider>) {
+        self.llm_override = Some(llm);
+    }
+
     /// Phase 1: Initialize database backend.
     ///
     /// Creates the database connection, runs migrations, reloads config
     /// from DB, attaches DB to session manager, and cleans up stale jobs.
     pub async fn init_database(&mut self) -> Result<(), anyhow::Error> {
+        if self.db.is_some() {
+            tracing::debug!("Database already provided, skipping init_database()");
+            return Ok(());
+        }
+
         if self.flags.no_db {
             tracing::warn!("Running without database connection");
             return Ok(());
@@ -297,10 +317,17 @@ impl AppBuilder {
     #[allow(clippy::type_complexity)]
     pub fn init_llm(
         &self,
-    ) -> Result<(Arc<dyn LlmProvider>, Option<Arc<dyn LlmProvider>>), anyhow::Error> {
-        let (llm, cheap_llm) =
+    ) -> Result<
+        (
+            Arc<dyn LlmProvider>,
+            Option<Arc<dyn LlmProvider>>,
+            Option<Arc<RecordingLlm>>,
+        ),
+        anyhow::Error,
+    > {
+        let (llm, cheap_llm, recording_handle) =
             crate::llm::build_provider_chain(&self.config.llm, self.session.clone())?;
-        Ok((llm, cheap_llm))
+        Ok((llm, cheap_llm, recording_handle))
     }
 
     /// Phase 4: Initialize safety, tools, embeddings, and workspace.
@@ -653,7 +680,11 @@ impl AppBuilder {
         self.init_database().await?;
         self.init_secrets().await?;
 
-        let (llm, cheap_llm) = self.init_llm()?;
+        let (llm, cheap_llm, recording_handle) = if let Some(llm) = self.llm_override.take() {
+            (llm, None, None)
+        } else {
+            self.init_llm()?
+        };
         let (safety, tools, embeddings, workspace) = self.init_tools(&llm).await?;
 
         // Create hook registry early so runtime extension activation can register hooks.
@@ -765,6 +796,7 @@ impl AppBuilder {
             skill_registry,
             skill_catalog,
             cost_guard,
+            recording_handle,
             session: self.session,
             catalog_entries,
             dev_loaded_tool_names,
 
@@ -30,6 +30,26 @@ pub struct AgentConfig {
 }
 
 impl AgentConfig {
+    /// Create a test-friendly config without reading env vars.
+    #[cfg(feature = "libsql")]
+    pub fn for_testing() -> Self {
+        Self {
+            name: "test-rig".to_string(),
+            max_parallel_jobs: 1,
+            job_timeout: Duration::from_secs(30),
+            stuck_threshold: Duration::from_secs(300),
+            repair_check_interval: Duration::from_secs(3600),
+            max_repair_attempts: 0,
+            use_planning: false,
+            session_idle_timeout: Duration::from_secs(3600),
+            allow_local_tools: true,
+            max_cost_per_day_cents: None,
+            max_actions_per_hour: None,
+            max_tool_iterations: 10,
+            auto_approve_tools: true,
+        }
+    }
+
     pub(crate) fn resolve(settings: &Settings) -> Result<Self, ConfigError> {
         Ok(Self {
             name: parse_optional_env("AGENT_NAME", settings.agent.name.clone())?,
 
@@ -195,6 +195,40 @@ pub struct NearAiConfig {
 }
 
 impl LlmConfig {
+    /// Create a test-friendly config without reading env vars.
+    ///
+    /// Uses NearAi backend with dummy values. The LLM provider is replaced
+    /// by `TraceLlm` via `AppBuilder::with_llm()`, so these values are unused.
+    #[cfg(feature = "libsql")]
+    pub fn for_testing() -> Self {
+        Self {
+            backend: LlmBackend::NearAi,
+            nearai: NearAiConfig {
+                model: "test-model".to_string(),
+                cheap_model: None,
+                base_url: "http://localhost:0".to_string(),
+                auth_base_url: "http://localhost:0".to_string(),
+                session_path: PathBuf::from("/tmp/ironclaw-test-session.json"),
+                api_key: None,
+                fallback_model: None,
+                max_retries: 0,
+                circuit_breaker_threshold: None,
+                circuit_breaker_recovery_secs: 30,
+                response_cache_enabled: false,
+                response_cache_ttl_secs: 3600,
+                response_cache_max_entries: 100,
+                failover_cooldown_secs: 300,
+                failover_cooldown_threshold: 3,
+                smart_routing_cascade: false,
+            },
+            openai: None,
+            anthropic: None,
+            ollama: None,
+            openai_compatible: None,
+            tinfoil: None,
+        }
+    }
+
     /// Resolve a model name from env var → settings.selected_model → hardcoded default.
     fn resolve_model(
         env_var: &str,
Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,8 @@ pub struct AgentDeps {`
`75`	`75`	`pub cost_guard: Arc<crate::agent::cost_guard::CostGuard>,`
`76`	`76`	`/// SSE broadcast sender for live job event streaming to the web gateway.`
`77`	`77`	`pub sse_tx: Option<tokio::sync::broadcast::Sender<crate::channels::web::types::SseEvent>>,`
	`78`	`+ /// HTTP interceptor for trace recording/replay.`
	`79`	`+ pub http_interceptor: Option<Arc<dyn crate::llm::recording::HttpInterceptor>>,`
`78`	`80`	`}`
`79`	`81`
`80`	`82`	`/// The main agent that coordinates all components.`
Original file line number	Diff line number	Diff line change
`@@ -734,8 +734,9 @@ impl Agent {`
`734`	`734`	`}`
`735`	`735`
`736`	`736`	`// Execute the approved tool and continue the loop`
`737`		`- let job_ctx =`
	`737`	`+ let mut job_ctx =`
`738`	`738`	`JobContext::with_user(&message.user_id, "chat", "Interactive chat session");`
	`739`	`+ job_ctx.http_interceptor = self.deps.http_interceptor.clone();`
`739`	`740`
`740`	`741`	`let _ = self`
`741`	`742`	`.channels`