M2: TUI — EngineHandle, ratatui app, markdown renderer, permission modal, session picker, snapshot tests

Builds the ratatui TUI: EngineHandle bridging the async engine to the render loop, chat viewport rendering with a markdown renderer, input handling, a permission modal wired to the real oneshot ask path, and a session picker. Adds TestBackend snapshot tests covering empty session, tool cards (running/completed/error), permission modal, session picker, and message rendering.

Cargo.lock

@@ -669,20 +669,16 @@ dependencies = [
 name = "harness-app"
 version = "0.1.0"
 dependencies = [
- "async-trait",
  "dirs",
- "futures",
  "harness-core",
  "harness-lsp",
  "harness-mcp",
  "harness-providers",
  "harness-tools",
- "serde_json",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
  "tokio-util",
- "tracing",
 ]
 
 [[package]]
@@ -698,7 +694,6 @@ dependencies = [
  "schemars",
  "serde",
  "serde_json",
- "serde_yaml_ng",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
@@ -711,12 +706,7 @@ dependencies = [
 name = "harness-lsp"
 version = "0.1.0"
 dependencies = [
- "async-trait",
  "harness-core",
- "serde_json",
- "tempfile",
- "tokio",
- "tracing",
 ]
 
 [[package]]
@@ -733,14 +723,12 @@ dependencies = [
  "async-stream",
  "async-trait",
  "bytes",
- "dirs",
  "eventsource-stream",
  "futures",
  "harness-core",
  "reqwest",
  "serde",
  "serde_json",
- "tempfile",
  "thiserror 2.0.18",
  "tokio",
  "tokio-util",
@@ -812,12 +800,6 @@ dependencies = [
  "foldhash",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
-
 [[package]]
 name = "hashlink"
 version = "0.9.1"
@@ -1056,16 +1038,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "indexmap"
-version = "2.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
-dependencies = [
- "equivalent",
- "hashbrown 0.17.1",
-]
-
 [[package]]
 name = "indoc"
 version = "2.0.7"
@@ -1852,19 +1824,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_yaml_ng"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4db627b98b36d4203a7b458cf3573730f2bb591b28871d916dfa9efabfd41f"
-dependencies = [
- "indexmap",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -2395,12 +2354,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"

crates/harness-app/Cargo.toml

@@ -12,15 +12,11 @@ harness-mcp = { workspace = true }
 harness-lsp = { workspace = true }
 tokio = { workspace = true }
 tokio-util = { workspace = true }
-async-trait = { workspace = true }
 dirs = { workspace = true }
 thiserror = { workspace = true }
-tracing = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
-futures = { workspace = true }
-serde_json = { workspace = true }
 
 [lints]
 workspace = true

crates/harness-core/Cargo.toml

@@ -11,7 +11,6 @@ futures = { workspace = true }
 async-trait = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_yaml_ng = { workspace = true }
 schemars = { workspace = true }
 rusqlite = { workspace = true }
 globset = { workspace = true }

crates/harness-core/assets/agents/designer.md

@@ -1,12 +0,0 @@
----
-description: UI and interaction design specialist for user-facing surfaces
-mode: subagent
-temperature: 0.4
-tools: { task: false }
----
-You are Designer, a UI and interaction design specialist. You handle user-facing surfaces:
-layout, component structure, styling, and interaction details.
-
-- Understand the existing design language before proposing changes; stay consistent with it.
-- When implementing, make focused edits and describe the visual/interaction effect.
-- Call out accessibility and responsive concerns relevant to the change.

crates/harness-core/assets/agents/explorer.md

@@ -1,16 +0,0 @@
----
-description: Read-only reconnaissance specialist for mapping code and finding relevant files
-mode: subagent
-temperature: 0.1
-tools: { write: false, edit: false, task: false }
-permission:
-  - { permission: "edit", pattern: "*", action: deny }
-  - { permission: "write", pattern: "*", action: deny }
----
-You are Explorer, a read-only reconnaissance specialist. You locate the code, files, and
-facts the orchestrator needs and report back concisely.
-
-- Use read, glob, grep, and bash (read-only commands) to investigate.
-- Never modify files. Return a focused summary with concrete `path:line` references, not
-  file dumps.
-- State what you found and, briefly, what you could not find.

crates/harness-core/assets/agents/fixer.md

@@ -1,13 +0,0 @@
----
-description: Implementation specialist that makes focused code changes and verifies them
-mode: subagent
-temperature: 0.2
-tools: { task: false }
----
-You are Fixer, an implementation specialist. You take a well-scoped change, implement it,
-and verify it compiles/tests.
-
-- Make the smallest change that satisfies the request; match the surrounding code's style.
-- Use read/grep to understand context before editing; use bash to build and run tests.
-- Report exactly what you changed (files and the essence of the diff) and the result of any
-  verification you ran.

crates/harness-core/assets/agents/librarian.md

@@ -1,15 +0,0 @@
----
-description: Documentation and knowledge lookup specialist
-mode: subagent
-temperature: 0.1
-tools: { write: false, edit: false, task: false }
-permission:
-  - { permission: "edit", pattern: "*", action: deny }
-  - { permission: "write", pattern: "*", action: deny }
----
-You are Librarian. You find and summarize documentation, comments, READMEs, config, and
-other in-repo knowledge on request.
-
-- Search docs and source for the relevant material with read, glob, and grep.
-- Quote the authoritative source with its `path:line`; do not invent details.
-- Return a concise, well-organized summary with pointers back to the sources.

crates/harness-core/assets/agents/oracle.md

@@ -1,15 +0,0 @@
----
-description: Deep-reasoning analyst for architecture, debugging, and design trade-offs
-mode: subagent
-temperature: 0.3
-tools: { write: false, edit: false, task: false }
-permission:
-  - { permission: "edit", pattern: "*", action: deny }
-  - { permission: "write", pattern: "*", action: deny }
----
-You are Oracle, a deep-reasoning analyst. You are consulted for hard questions:
-root-causing bugs, weighing architectural trade-offs, and reviewing designs.
-
-- Read whatever code and context you need, but do not modify anything.
-- Reason carefully and explicitly; state assumptions and the evidence behind conclusions.
-- Return a decisive recommendation with the reasoning that supports it.

crates/harness-core/assets/agents/orchestrator.md

@@ -1,19 +0,0 @@
----
-description: Primary coordinator that plans work and delegates to specialists
-mode: primary
-temperature: 0.2
----
-You are the orchestrator. You plan the work, delegate focused pieces to specialist
-subagents via the `task` tool, and synthesize their results into a final answer.
-
-Guidelines:
-- Break the request into concrete, independently-verifiable pieces.
-- Prefer delegating reconnaissance and analysis to subagents so your own context stays
-  focused; do the integration and final write-up yourself.
-- Launch background tasks for long-running independent work, then continue planning.
-  Do not poll running jobs — wait for completion and reconcile terminal jobs before your
-  final response.
-- Reuse a completed specialist session (by its job alias) when following up on the same
-  thread of work.
-
-{{SUBAGENTS}}

crates/harness-core/src/agent/mod.rs

@@ -1,496 +0,0 @@
-//! Agent definitions and registry.
-//!
-//! All agent *behavior* lives in markdown + config — the engine only understands `mode`, tool
-//! filters, permissions, model, and depth. Definitions are layered (bundled → global → project
-//! → config patch); later layers win by name. See `docs/04-multiagent.md`.
-
-use std::collections::HashMap;
-use std::path::Path;
-
-use serde::Deserialize;
-
-use crate::config::AgentPatch;
-use crate::permission::{Rule, Ruleset};
-use crate::types::ModelRef;
-
-/// Marker in a primary agent's prompt replaced at load time with the routing list of enabled
-/// subagents (name + description). Keeps routing text in sync with the enabled agent set.
-const SUBAGENTS_MARKER: &str = "{{SUBAGENTS}}";
-
-const BUNDLED: &[(&str, &str)] = &[
-    (
-        "orchestrator",
-        include_str!("../../assets/agents/orchestrator.md"),
-    ),
-    ("explorer", include_str!("../../assets/agents/explorer.md")),
-    ("oracle", include_str!("../../assets/agents/oracle.md")),
-    (
-        "librarian",
-        include_str!("../../assets/agents/librarian.md"),
-    ),
-    ("fixer", include_str!("../../assets/agents/fixer.md")),
-    ("designer", include_str!("../../assets/agents/designer.md")),
-];
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum AgentMode {
-    Primary,
-    #[default]
-    Subagent,
-    All,
-}
-
-impl AgentMode {
-    fn parse(s: &str) -> Option<Self> {
-        match s.trim().to_ascii_lowercase().as_str() {
-            "primary" => Some(Self::Primary),
-            "subagent" => Some(Self::Subagent),
-            "all" => Some(Self::All),
-            _ => None,
-        }
-    }
-
-    /// Whether this agent can be invoked as a subagent via the `task` tool.
-    pub fn is_subagent(self) -> bool {
-        matches!(self, Self::Subagent | Self::All)
-    }
-
-    /// Whether this agent can drive a top-level (primary) session.
-    pub fn is_primary(self) -> bool {
-        matches!(self, Self::Primary | Self::All)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AgentSource {
-    Bundled,
-    Global,
-    Project,
-    Config,
-}
-
-#[derive(Debug, Clone)]
-pub struct AgentDef {
-    pub name: String,
-    pub description: String,
-    pub mode: AgentMode,
-    /// `None` = follow the session model.
-    pub model: Option<ModelRef>,
-    pub temperature: Option<f32>,
-    pub prompt: String,
-    pub permissions: Ruleset,
-    /// Tool enable/disable overrides (wildcard keys allowed); absent = inherit default.
-    pub tools: HashMap<String, bool>,
-    pub max_steps: Option<u32>,
-    pub source: AgentSource,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum AgentError {
-    #[error("agent {0}: {1}")]
-    Frontmatter(String, String),
-}
-
-/// YAML frontmatter shape (opencode-compatible).
-#[derive(Debug, Default, Deserialize)]
-#[serde(default)]
-struct Frontmatter {
-    description: Option<String>,
-    mode: Option<String>,
-    model: Option<String>,
-    temperature: Option<f32>,
-    tools: Option<HashMap<String, bool>>,
-    permission: Option<Vec<Rule>>,
-    max_steps: Option<u32>,
-    disable: Option<bool>,
-}
-
-fn parse_model_ref(s: &str) -> Option<ModelRef> {
-    s.split_once('/')
-        .map(|(p, m)| ModelRef::new(p.trim(), m.trim()))
-}
-
-/// Splits a markdown agent file into (frontmatter, body). A file without a leading `---`
-/// fence is treated as an all-body prompt with empty frontmatter.
-fn split_frontmatter(content: &str) -> (&str, &str) {
-    let rest = match content
-        .strip_prefix("---\n")
-        .or_else(|| content.strip_prefix("---\r\n"))
-    {
-        Some(r) => r,
-        None => return ("", content),
-    };
-    // Find the closing fence line.
-    for delim in ["\n---\n", "\n---\r\n"] {
-        if let Some(idx) = rest.find(delim) {
-            let body_start = idx + delim.len();
-            return (&rest[..idx], &rest[body_start..]);
-        }
-    }
-    // Trailing fence with no body / no trailing newline.
-    if let Some(fm) = rest.strip_suffix("\n---").or(Some(rest)) {
-        if rest.ends_with("\n---") {
-            return (fm, "");
-        }
-    }
-    ("", content)
-}
-
-/// Parses one markdown agent definition. Returns `Ok(None)` when the file marks itself
-/// `disable: true`.
-fn parse_agent(
-    name: &str,
-    source: AgentSource,
-    content: &str,
-) -> Result<Option<AgentDef>, AgentError> {
-    let (fm_raw, body) = split_frontmatter(content);
-    let fm: Frontmatter = if fm_raw.trim().is_empty() {
-        Frontmatter::default()
-    } else {
-        serde_yaml_ng::from_str(fm_raw)
-            .map_err(|e| AgentError::Frontmatter(name.to_string(), e.to_string()))?
-    };
-
-    if fm.disable == Some(true) {
-        return Ok(None);
-    }
-
-    Ok(Some(AgentDef {
-        name: name.to_string(),
-        description: fm.description.unwrap_or_default(),
-        mode: fm
-            .mode
-            .as_deref()
-            .and_then(AgentMode::parse)
-            .unwrap_or_default(),
-        model: fm.model.as_deref().and_then(parse_model_ref),
-        temperature: fm.temperature,
-        prompt: body.trim_end().to_string(),
-        permissions: fm.permission.unwrap_or_default(),
-        tools: fm.tools.unwrap_or_default(),
-        max_steps: fm.max_steps,
-        source,
-    }))
-}
-
-/// Applies a config `AgentPatch` onto an existing definition (only set fields override).
-fn apply_patch(def: &mut AgentDef, patch: &AgentPatch) {
-    if let Some(mode) = patch.mode.as_deref().and_then(AgentMode::parse) {
-        def.mode = mode;
-    }
-    if let Some(model) = patch.model.as_deref().and_then(parse_model_ref) {
-        def.model = Some(model);
-    }
-    if let Some(temp) = patch.temperature {
-        def.temperature = Some(temp);
-    }
-    if let Some(prompt) = &patch.prompt {
-        def.prompt = prompt.clone();
-    }
-    if let Some(tools) = &patch.tools {
-        def.tools.extend(tools.clone());
-    }
-    if let Some(permission) = &patch.permission {
-        def.permissions = permission.clone();
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct AgentRegistry {
-    agents: HashMap<String, AgentDef>,
-}
-
-impl AgentRegistry {
-    pub fn get(&self, name: &str) -> Option<&AgentDef> {
-        self.agents.get(name)
-    }
-
-    pub fn all(&self) -> Vec<&AgentDef> {
-        self.agents.values().collect()
-    }
-
-    pub fn len(&self) -> usize {
-        self.agents.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.agents.is_empty()
-    }
-
-    /// Just the bundled agents — the default when no overrides are configured (tests, headless).
-    pub fn bundled() -> Self {
-        let mut reg = Self::default();
-        reg.load_markdown_layer(
-            BUNDLED.iter().map(|(n, c)| (n.to_string(), *c)),
-            AgentSource::Bundled,
-        );
-        reg.generate_routing();
-        reg
-    }
-
-    /// Full layered load: bundled → global dir → project dir → config patches.
-    pub fn load(
-        config_agents: &HashMap<String, AgentPatch>,
-        global_dir: Option<&Path>,
-        project_dir: Option<&Path>,
-    ) -> Self {
-        let mut reg = Self::default();
-        reg.load_markdown_layer(
-            BUNDLED.iter().map(|(n, c)| (n.to_string(), *c)),
-            AgentSource::Bundled,
-        );
-        if let Some(dir) = global_dir {
-            reg.load_dir(dir, AgentSource::Global);
-        }
-        if let Some(dir) = project_dir {
-            reg.load_dir(dir, AgentSource::Project);
-        }
-        reg.apply_config(config_agents);
-        reg.generate_routing();
-        reg
-    }
-
-    fn load_markdown_layer<I, S>(&mut self, files: I, source: AgentSource)
-    where
-        I: IntoIterator<Item = (String, S)>,
-        S: AsRef<str>,
-    {
-        for (name, content) in files {
-            match parse_agent(&name, source, content.as_ref()) {
-                Ok(Some(def)) => {
-                    self.agents.insert(name, def);
-                }
-                Ok(None) => {
-                    self.agents.remove(&name); // disable: true removes an earlier layer
-                }
-                Err(e) => tracing::warn!(error = %e, "skipping malformed agent"),
-            }
-        }
-    }
-
-    fn load_dir(&mut self, dir: &Path, source: AgentSource) {
-        let Ok(entries) = std::fs::read_dir(dir) else {
-            return;
-        };
-        let mut files: Vec<(String, String)> = Vec::new();
-        for entry in entries.flatten() {
-            let path = entry.path();
-            if path.extension().and_then(|e| e.to_str()) != Some("md") {
-                continue;
-            }
-            let Some(name) = path.file_stem().and_then(|s| s.to_str()) else {
-                continue;
-            };
-            if let Ok(content) = std::fs::read_to_string(&path) {
-                files.push((name.to_string(), content));
-            }
-        }
-        files.sort();
-        self.load_markdown_layer(files, source);
-    }
-
-    fn apply_config(&mut self, config_agents: &HashMap<String, AgentPatch>) {
-        for (name, patch) in config_agents {
-            if patch.disable == Some(true) {
-                self.agents.remove(name);
-                continue;
-            }
-            if let Some(def) = self.agents.get_mut(name) {
-                apply_patch(def, patch);
-            } else if patch.model.is_some() || patch.prompt.is_some() {
-                // Unknown name with enough to stand on its own → custom agent.
-                let mut def = AgentDef {
-                    name: name.clone(),
-                    description: String::new(),
-                    mode: AgentMode::default(),
-                    model: None,
-                    temperature: None,
-                    prompt: String::new(),
-                    permissions: Vec::new(),
-                    tools: HashMap::new(),
-                    max_steps: None,
-                    source: AgentSource::Config,
-                };
-                apply_patch(&mut def, patch);
-                self.agents.insert(name.clone(), def);
-            }
-        }
-    }
-
-    /// Replaces `{{SUBAGENTS}}` in every primary agent's prompt with a generated routing list
-    /// of the enabled subagents (so disabling an agent removes it from routing text).
-    fn generate_routing(&mut self) {
-        let mut subagents: Vec<(String, String)> = self
-            .agents
-            .values()
-            .filter(|a| a.mode.is_subagent())
-            .map(|a| (a.name.clone(), a.description.clone()))
-            .collect();
-        subagents.sort();
-
-        let routing = if subagents.is_empty() {
-            "## Agents\n\nNo specialist subagents are available.".to_string()
-        } else {
-            let mut s = String::from("## Agents\n\nDelegate to these specialists via `task`:\n");
-            for (name, desc) in &subagents {
-                s.push_str(&format!("- **{name}** — {desc}\n"));
-            }
-            s
-        };
-
-        for agent in self.agents.values_mut() {
-            if agent.prompt.contains(SUBAGENTS_MARKER) {
-                agent.prompt = agent.prompt.replace(SUBAGENTS_MARKER, routing.trim_end());
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::permission::Action;
-
-    #[test]
-    fn bundled_loads_all_six_agents() {
-        let reg = AgentRegistry::bundled();
-        for name in [
-            "orchestrator",
-            "explorer",
-            "oracle",
-            "librarian",
-            "fixer",
-            "designer",
-        ] {
-            assert!(reg.get(name).is_some(), "missing {name}");
-        }
-        assert_eq!(reg.len(), 6);
-    }
-
-    #[test]
-    fn parses_mode_model_temperature_tools_and_permissions() {
-        let md = "---\n\
-            description: test agent\n\
-            mode: subagent\n\
-            model: anthropic/claude-haiku-4-5\n\
-            temperature: 0.1\n\
-            tools: { write: false, bash: true }\n\
-            permission:\n\
-            \x20 - { permission: \"edit\", pattern: \"*\", action: deny }\n\
-            ---\n\
-            You are a test agent.\n";
-        let def = parse_agent("tester", AgentSource::Bundled, md)
-            .unwrap()
-            .unwrap();
-        assert_eq!(def.description, "test agent");
-        assert_eq!(def.mode, AgentMode::Subagent);
-        assert_eq!(
-            def.model,
-            Some(ModelRef::new("anthropic", "claude-haiku-4-5"))
-        );
-        assert_eq!(def.temperature, Some(0.1));
-        assert_eq!(def.tools.get("write"), Some(&false));
-        assert_eq!(def.tools.get("bash"), Some(&true));
-        assert_eq!(def.permissions.len(), 1);
-        assert_eq!(def.permissions[0].action, Action::Deny);
-        assert_eq!(def.prompt, "You are a test agent.");
-    }
-
-    #[test]
-    fn body_without_frontmatter_is_all_prompt() {
-        let def = parse_agent("x", AgentSource::Global, "just a prompt")
-            .unwrap()
-            .unwrap();
-        assert_eq!(def.prompt, "just a prompt");
-        assert_eq!(def.mode, AgentMode::Subagent); // default
-    }
-
-    #[test]
-    fn disable_true_removes_agent() {
-        assert!(
-            parse_agent("x", AgentSource::Config, "---\ndisable: true\n---\nbody")
-                .unwrap()
-                .is_none()
-        );
-    }
-
-    #[test]
-    fn explorer_denies_writes_and_disables_edit_tool() {
-        let reg = AgentRegistry::bundled();
-        let explorer = reg.get("explorer").unwrap();
-        assert_eq!(explorer.mode, AgentMode::Subagent);
-        assert_eq!(explorer.tools.get("edit"), Some(&false));
-        assert!(explorer
-            .permissions
-            .iter()
-            .any(|r| r.permission == "write" && r.action == Action::Deny));
-    }
-
-    #[test]
-    fn orchestrator_routing_lists_subagents_and_drops_marker() {
-        let reg = AgentRegistry::bundled();
-        let prompt = &reg.get("orchestrator").unwrap().prompt;
-        assert!(!prompt.contains("{{SUBAGENTS}}"));
-        assert!(prompt.contains("explorer"));
-        assert!(prompt.contains("fixer"));
-        // The orchestrator itself is primary and must not list itself.
-        assert!(!prompt.contains("- **orchestrator**"));
-    }
-
-    #[test]
-    fn config_patch_overrides_only_set_fields() {
-        let mut patches = HashMap::new();
-        patches.insert(
-            "explorer".to_string(),
-            AgentPatch {
-                temperature: Some(0.9),
-                ..Default::default()
-            },
-        );
-        let reg = AgentRegistry::load(&patches, None, None);
-        let explorer = reg.get("explorer").unwrap();
-        assert_eq!(explorer.temperature, Some(0.9)); // overridden
-        assert_eq!(explorer.mode, AgentMode::Subagent); // untouched
-        assert_eq!(explorer.tools.get("edit"), Some(&false)); // untouched
-    }
-
-    #[test]
-    fn config_disable_removes_and_unknown_with_model_creates() {
-        let mut patches = HashMap::new();
-        patches.insert(
-            "designer".to_string(),
-            AgentPatch {
-                disable: Some(true),
-                ..Default::default()
-            },
-        );
-        patches.insert(
-            "custom".to_string(),
-            AgentPatch {
-                model: Some("openai/gpt-5".into()),
-                prompt: Some("custom prompt".into()),
-                ..Default::default()
-            },
-        );
-        let reg = AgentRegistry::load(&patches, None, None);
-        assert!(reg.get("designer").is_none());
-        let custom = reg.get("custom").unwrap();
-        assert_eq!(custom.source, AgentSource::Config);
-        assert_eq!(custom.model, Some(ModelRef::new("openai", "gpt-5")));
-        assert_eq!(custom.prompt, "custom prompt");
-    }
-
-    #[test]
-    fn unknown_config_agent_without_model_or_prompt_is_ignored() {
-        let mut patches = HashMap::new();
-        patches.insert(
-            "ghost".to_string(),
-            AgentPatch {
-                temperature: Some(0.5),
-                ..Default::default()
-            },
-        );
-        let reg = AgentRegistry::load(&patches, None, None);
-        assert!(reg.get("ghost").is_none());
-    }
-}

crates/harness-core/src/config/load.rs

@@ -29,7 +29,6 @@ const ENV_CONFIG_PATH: &str = "AI_HARNESS_CONFIG";
 const PROVIDER_ENV_KEYS: &[(&str, &str)] = &[
     ("anthropic", "ANTHROPIC_API_KEY"),
     ("openai", "OPENAI_API_KEY"),
-    ("opencode", "OPENCODE_API_KEY"),
 ];
 
 fn read_jsonc(path: &Path) -> Result<Value, ConfigError> {

crates/harness-core/src/engine/jobs.rs

@@ -1,579 +0,0 @@
-//! Background job board — tracks subagent tasks spawned via the `task` tool so the
-//! orchestrator can see running work, reconcile terminal results, and reuse completed
-//! child sessions by alias. Simplified native port of oh-my-opencode-slim's
-//! `background-job-board.ts`. See `docs/04-multiagent.md`.
-//!
-//! The board is an in-memory `RwLock<HashMap>` mirrored to the `job` table so it survives a
-//! resume. All mutations persist through the passed-in `Store`.
-
-use std::collections::HashMap;
-use std::sync::RwLock;
-
-use serde::{Deserialize, Serialize};
-
-use crate::event::{AppEvent, EventBus, JobRecordEvent};
-use crate::store::{Store, StoreError};
-use crate::types::SessionId;
-
-/// A file a child session read, surfaced on the board so the orchestrator knows what a
-/// completed specialist already looked at.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ContextFile {
-    pub path: String,
-    pub lines: u32,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum JobState {
-    Running,
-    Completed,
-    Error,
-    Cancelled,
-}
-
-impl JobState {
-    /// Terminal jobs are candidates for reconciliation; a completed one is reusable.
-    pub fn is_terminal(self) -> bool {
-        !matches!(self, JobState::Running)
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JobRecord {
-    pub task_id: String,
-    /// Human-friendly handle: first 3 chars of the agent name + a per-agent counter (`exp-1`).
-    pub alias: String,
-    pub parent_session: SessionId,
-    pub child_session: SessionId,
-    pub agent: String,
-    pub description: String,
-    pub objective: Option<String>,
-    pub state: JobState,
-    /// Whether the orchestrator has already seen this job's terminal result.
-    pub reconciled: bool,
-    pub result_summary: Option<String>,
-    pub context_files: Vec<ContextFile>,
-    pub launched_at: i64,
-    pub updated_at: i64,
-    pub last_used_at: i64,
-}
-
-/// Parameters for registering a newly launched task on the board.
-pub struct LaunchSpec {
-    pub task_id: String,
-    pub parent_session: SessionId,
-    pub child_session: SessionId,
-    pub agent: String,
-    pub description: String,
-    pub objective: Option<String>,
-}
-
-/// Result summaries are truncated to this many chars on the board.
-const SUMMARY_MAX: usize = 2000;
-/// Context files shown per job in the prompt injection.
-const CONTEXT_FILES_SHOWN: usize = 8;
-/// A read must cover at least this many lines to be worth reporting to the board.
-pub const MIN_REPORTED_LINES: u32 = 10;
-
-pub struct JobBoard {
-    store: Store,
-    bus: EventBus,
-    jobs: RwLock<HashMap<String, JobRecord>>,
-    max_reusable_per_agent: u32,
-}
-
-impl JobBoard {
-    /// Builds a board and loads any persisted jobs for `parent_session`'s tree from the store.
-    pub async fn load(
-        store: Store,
-        bus: EventBus,
-        parent_session: &SessionId,
-        max_reusable_per_agent: u32,
-    ) -> Result<Self, StoreError> {
-        let existing = store.jobs_for_parent(parent_session.clone()).await?;
-        let mut jobs = HashMap::new();
-        for job in existing {
-            jobs.insert(job.task_id.clone(), job);
-        }
-        Ok(Self {
-            store,
-            bus,
-            jobs: RwLock::new(jobs),
-            max_reusable_per_agent,
-        })
-    }
-
-    /// Assigns the next alias for `agent` under this board: `<3-char-prefix>-<n>`.
-    fn next_alias(&self, agent: &str) -> String {
-        let prefix: String = agent.chars().take(3).collect();
-        let prefix = if prefix.is_empty() {
-            "job".to_string()
-        } else {
-            prefix.to_ascii_lowercase()
-        };
-        let n = self
-            .jobs
-            .read()
-            .unwrap()
-            .values()
-            .filter(|j| j.agent == agent)
-            .count()
-            + 1;
-        format!("{prefix}-{n}")
-    }
-
-    /// Registers a freshly launched task and returns its assigned alias.
-    pub async fn register_launch(&self, spec: LaunchSpec, now: i64) -> Result<String, StoreError> {
-        let alias = self.next_alias(&spec.agent);
-        let record = JobRecord {
-            task_id: spec.task_id,
-            alias: alias.clone(),
-            parent_session: spec.parent_session,
-            child_session: spec.child_session,
-            agent: spec.agent,
-            description: spec.description,
-            objective: spec.objective,
-            state: JobState::Running,
-            reconciled: false,
-            result_summary: None,
-            context_files: Vec::new(),
-            launched_at: now,
-            updated_at: now,
-            last_used_at: now,
-        };
-        self.upsert(record).await?;
-        Ok(alias)
-    }
-
-    /// Marks a job terminal with an optional result summary (truncated).
-    pub async fn finish(
-        &self,
-        task_id: &str,
-        state: JobState,
-        result_summary: Option<String>,
-        now: i64,
-    ) -> Result<(), StoreError> {
-        let Some(mut record) = self.get(task_id) else {
-            return Ok(());
-        };
-        record.state = state;
-        record.result_summary = result_summary.map(|s| truncate_summary(&s));
-        record.updated_at = now;
-        record.last_used_at = now;
-        self.upsert(record).await?;
-        if state == JobState::Completed {
-            self.trim_reusable(now).await?;
-        }
-        Ok(())
-    }
-
-    /// Records a file a child session read (deduping by path, keeping the largest read).
-    pub async fn report_context_file(
-        &self,
-        task_id: &str,
-        path: String,
-        lines: u32,
-        now: i64,
-    ) -> Result<(), StoreError> {
-        if lines < MIN_REPORTED_LINES {
-            return Ok(());
-        }
-        let Some(mut record) = self.get(task_id) else {
-            return Ok(());
-        };
-        match record.context_files.iter_mut().find(|f| f.path == path) {
-            Some(existing) => existing.lines = existing.lines.max(lines),
-            None => record.context_files.push(ContextFile { path, lines }),
-        }
-        record.updated_at = now;
-        self.upsert(record).await
-    }
-
-    /// Resolves an alias or task id to a job for the given parent (reuse lookup). Only
-    /// completed (reusable) jobs match.
-    pub fn resolve_reusable(&self, parent: &SessionId, alias_or_id: &str) -> Option<JobRecord> {
-        self.jobs
-            .read()
-            .unwrap()
-            .values()
-            .find(|j| {
-                &j.parent_session == parent
-                    && j.state == JobState::Completed
-                    && (j.alias == alias_or_id || j.task_id == alias_or_id)
-            })
-            .cloned()
-    }
-
-    /// Bumps `last_used_at` when a completed session is reused, keeping it fresh in the LRU.
-    pub async fn touch(&self, task_id: &str, now: i64) -> Result<(), StoreError> {
-        let Some(mut record) = self.get(task_id) else {
-            return Ok(());
-        };
-        record.last_used_at = now;
-        self.upsert(record).await
-    }
-
-    /// Marks all terminal jobs `reconciled` — the orchestrator has now seen them.
-    pub async fn reconcile_terminal(&self, now: i64) -> Result<(), StoreError> {
-        let to_update: Vec<JobRecord> = {
-            let jobs = self.jobs.read().unwrap();
-            jobs.values()
-                .filter(|j| j.state.is_terminal() && !j.reconciled)
-                .cloned()
-                .collect()
-        };
-        for mut record in to_update {
-            record.reconciled = true;
-            record.updated_at = now;
-            self.upsert(record).await?;
-        }
-        Ok(())
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.jobs.read().unwrap().is_empty()
-    }
-
-    pub fn snapshot(&self) -> Vec<JobRecord> {
-        self.jobs.read().unwrap().values().cloned().collect()
-    }
-
-    /// Renders the board as a synthetic prompt block, or `None` when there is nothing to show.
-    /// Mirrors slim's `formatForPrompt`.
-    pub fn format_for_prompt(&self) -> Option<String> {
-        let jobs = self.jobs.read().unwrap();
-        if jobs.is_empty() {
-            return None;
-        }
-
-        let mut active: Vec<&JobRecord> = jobs
-            .values()
-            .filter(|j| !j.state.is_terminal() || !j.reconciled)
-            .collect();
-        let mut reusable: Vec<&JobRecord> = jobs
-            .values()
-            .filter(|j| j.state == JobState::Completed && j.reconciled)
-            .collect();
-        active.sort_by(|a, b| a.alias.cmp(&b.alias));
-        reusable.sort_by(|a, b| a.alias.cmp(&b.alias));
-
-        if active.is_empty() && reusable.is_empty() {
-            return None;
-        }
-
-        let mut out = String::from(
-            "### Background Job Board\n\
-             Do not poll running jobs; wait for completion. Reconcile terminal jobs before your \
-             final response.\nCompleted sessions are reusable by alias for the same specialist.\n",
-        );
-
-        if !active.is_empty() {
-            out.push_str("\n#### Active / Unreconciled\n");
-            for job in &active {
-                let state = state_label(job.state);
-                out.push_str(&format!(
-                    "- {} / {} / {} / {state}",
-                    job.alias, job.child_session, job.agent
-                ));
-                if let Some(obj) = &job.objective {
-                    out.push_str(&format!(" — Objective: {obj}"));
-                }
-                out.push('\n');
-                if let Some(summary) = &job.result_summary {
-                    out.push_str(&format!("    Result: {summary}\n"));
-                }
-            }
-        }
-
-        if !reusable.is_empty() {
-            out.push_str("\n#### Reusable Sessions\n");
-            for job in &reusable {
-                out.push_str(&format!(
-                    "- {} / {} / {} / completed\n",
-                    job.alias, job.child_session, job.agent
-                ));
-                if let Some(obj) = &job.objective {
-                    out.push_str(&format!("    Objective: {obj}\n"));
-                }
-                if !job.context_files.is_empty() {
-                    let files: Vec<&str> = job
-                        .context_files
-                        .iter()
-                        .take(CONTEXT_FILES_SHOWN)
-                        .map(|f| f.path.as_str())
-                        .collect();
-                    out.push_str(&format!("    Context read: {}\n", files.join(", ")));
-                }
-            }
-        }
-
-        Some(out)
-    }
-
-    fn get(&self, task_id: &str) -> Option<JobRecord> {
-        self.jobs.read().unwrap().get(task_id).cloned()
-    }
-
-    async fn upsert(&self, record: JobRecord) -> Result<(), StoreError> {
-        self.store.upsert_job(record.clone()).await?;
-        self.jobs
-            .write()
-            .unwrap()
-            .insert(record.task_id.clone(), record.clone());
-        self.bus.publish(AppEvent::JobUpdated {
-            job: JobRecordEvent(serde_json::to_value(&record).unwrap_or(serde_json::Value::Null)),
-        });
-        Ok(())
-    }
-
-    /// Keeps at most `max_reusable_per_agent` completed jobs per agent (LRU by `last_used_at`);
-    /// older completed jobs are dropped from the board and the store.
-    async fn trim_reusable(&self, _now: i64) -> Result<(), StoreError> {
-        let to_remove: Vec<String> = {
-            let jobs = self.jobs.read().unwrap();
-            let mut by_agent: HashMap<&str, Vec<&JobRecord>> = HashMap::new();
-            for job in jobs.values().filter(|j| j.state == JobState::Completed) {
-                by_agent.entry(job.agent.as_str()).or_default().push(job);
-            }
-            let mut remove = Vec::new();
-            for group in by_agent.values_mut() {
-                if group.len() as u32 <= self.max_reusable_per_agent {
-                    continue;
-                }
-                // Oldest last_used_at first; drop the excess from the front.
-                group.sort_by_key(|j| j.last_used_at);
-                let excess = group.len() - self.max_reusable_per_agent as usize;
-                for job in group.iter().take(excess) {
-                    remove.push(job.task_id.clone());
-                }
-            }
-            remove
-        };
-        for task_id in to_remove {
-            self.store.delete_job(task_id.clone()).await?;
-            self.jobs.write().unwrap().remove(&task_id);
-        }
-        Ok(())
-    }
-}
-
-fn state_label(state: JobState) -> &'static str {
-    match state {
-        JobState::Running => "running",
-        JobState::Completed => "completed",
-        JobState::Error => "error",
-        JobState::Cancelled => "cancelled",
-    }
-}
-
-fn truncate_summary(s: &str) -> String {
-    if s.len() <= SUMMARY_MAX {
-        return s.to_string();
-    }
-    let mut end = SUMMARY_MAX;
-    while !s.is_char_boundary(end) {
-        end -= 1;
-    }
-    format!("{}…", &s[..end])
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    async fn board(max_reusable: u32) -> (Store, JobBoard, SessionId) {
-        let store = Store::open_in_memory().unwrap();
-        let bus = EventBus::new();
-        let parent = SessionId::new();
-        let board = JobBoard::load(store.clone(), bus, &parent, max_reusable)
-            .await
-            .unwrap();
-        (store, board, parent)
-    }
-
-    fn spec(
-        task_id: &str,
-        parent: SessionId,
-        child: SessionId,
-        agent: &str,
-        objective: Option<&str>,
-    ) -> LaunchSpec {
-        LaunchSpec {
-            task_id: task_id.into(),
-            parent_session: parent,
-            child_session: child,
-            agent: agent.into(),
-            description: "d".into(),
-            objective: objective.map(Into::into),
-        }
-    }
-
-    #[tokio::test]
-    async fn alias_increments_per_agent() {
-        let (_store, board, parent) = board(2).await;
-        let a1 = board
-            .register_launch(
-                spec("t1", parent.clone(), SessionId::new(), "explorer", None),
-                1,
-            )
-            .await
-            .unwrap();
-        let a2 = board
-            .register_launch(
-                spec("t2", parent.clone(), SessionId::new(), "explorer", None),
-                2,
-            )
-            .await
-            .unwrap();
-        let f1 = board
-            .register_launch(
-                spec("t3", parent.clone(), SessionId::new(), "fixer", None),
-                3,
-            )
-            .await
-            .unwrap();
-        assert_eq!(a1, "exp-1");
-        assert_eq!(a2, "exp-2");
-        assert_eq!(f1, "fix-1");
-    }
-
-    #[tokio::test]
-    async fn finish_makes_job_reusable_and_resolvable_by_alias() {
-        let (_store, board, parent) = board(2).await;
-        let child = SessionId::new();
-        let alias = board
-            .register_launch(
-                spec(
-                    "t1",
-                    parent.clone(),
-                    child.clone(),
-                    "explorer",
-                    Some("map the auth flow"),
-                ),
-                1,
-            )
-            .await
-            .unwrap();
-        // Running jobs are not reusable.
-        assert!(board.resolve_reusable(&parent, &alias).is_none());
-        board
-            .finish("t1", JobState::Completed, Some("done".into()), 2)
-            .await
-            .unwrap();
-        let resolved = board.resolve_reusable(&parent, &alias).unwrap();
-        assert_eq!(resolved.child_session, child);
-        assert_eq!(resolved.result_summary.as_deref(), Some("done"));
-        // Also resolvable by task id.
-        assert!(board.resolve_reusable(&parent, "t1").is_some());
-    }
-
-    #[tokio::test]
-    async fn context_files_dedupe_and_respect_min_lines() {
-        let (_store, board, parent) = board(2).await;
-        board
-            .register_launch(spec("t1", parent, SessionId::new(), "explorer", None), 1)
-            .await
-            .unwrap();
-        // Below threshold — ignored.
-        board
-            .report_context_file("t1", "small.rs".into(), 3, 2)
-            .await
-            .unwrap();
-        board
-            .report_context_file("t1", "a.rs".into(), 20, 2)
-            .await
-            .unwrap();
-        // Same file again with a larger read keeps the max.
-        board
-            .report_context_file("t1", "a.rs".into(), 50, 3)
-            .await
-            .unwrap();
-        let job = board.snapshot().into_iter().next().unwrap();
-        assert_eq!(job.context_files.len(), 1);
-        assert_eq!(job.context_files[0].path, "a.rs");
-        assert_eq!(job.context_files[0].lines, 50);
-    }
-
-    #[tokio::test]
-    async fn trim_reusable_keeps_lru_within_limit() {
-        let (_store, board, parent) = board(2).await;
-        for (i, ts) in [(1, 10), (2, 20), (3, 30)] {
-            board
-                .register_launch(
-                    spec(
-                        &format!("t{i}"),
-                        parent.clone(),
-                        SessionId::new(),
-                        "explorer",
-                        None,
-                    ),
-                    ts,
-                )
-                .await
-                .unwrap();
-            board
-                .finish(&format!("t{i}"), JobState::Completed, None, ts)
-                .await
-                .unwrap();
-        }
-        // max_reusable = 2, so the oldest (t1, last_used 10) is dropped.
-        let ids: Vec<String> = board.snapshot().into_iter().map(|j| j.task_id).collect();
-        assert_eq!(ids.len(), 2);
-        assert!(!ids.contains(&"t1".to_string()));
-        assert!(ids.contains(&"t2".to_string()));
-        assert!(ids.contains(&"t3".to_string()));
-    }
-
-    #[tokio::test]
-    async fn reconcile_flips_terminal_jobs_and_moves_them_to_reusable_section() {
-        let (_store, board, parent) = board(2).await;
-        board
-            .register_launch(
-                spec("t1", parent, SessionId::new(), "explorer", Some("obj")),
-                1,
-            )
-            .await
-            .unwrap();
-        board
-            .finish("t1", JobState::Completed, Some("res".into()), 2)
-            .await
-            .unwrap();
-        // Before reconcile: appears under Active/Unreconciled.
-        let prompt = board.format_for_prompt().unwrap();
-        assert!(prompt.contains("Active / Unreconciled"));
-        board.reconcile_terminal(3).await.unwrap();
-        let prompt = board.format_for_prompt().unwrap();
-        assert!(prompt.contains("Reusable Sessions"));
-        assert!(prompt.contains("exp-1"));
-    }
-
-    #[tokio::test]
-    async fn board_reloads_persisted_jobs() {
-        let store = Store::open_in_memory().unwrap();
-        let bus = EventBus::new();
-        let parent = SessionId::new();
-        {
-            let board = JobBoard::load(store.clone(), bus.clone(), &parent, 2)
-                .await
-                .unwrap();
-            board
-                .register_launch(
-                    spec("t1", parent.clone(), SessionId::new(), "explorer", None),
-                    1,
-                )
-                .await
-                .unwrap();
-        }
-        // Fresh board over the same store sees the persisted job.
-        let board = JobBoard::load(store, bus, &parent, 2).await.unwrap();
-        assert!(!board.is_empty());
-        assert_eq!(board.snapshot().len(), 1);
-    }
-
-    #[tokio::test]
-    async fn empty_board_formats_to_none() {
-        let (_store, board, _parent) = board(2).await;
-        assert!(board.format_for_prompt().is_none());
-    }
-}

crates/harness-core/src/engine/loop.rs

@@ -20,39 +20,6 @@ pub struct RunConfig {
     pub temperature: Option<f32>,
     pub max_steps: u32,
     pub instructions: Vec<String>,
-    /// Pricing for `model`, from models.dev metadata. `None` leaves cost at 0.
-    pub cost: Option<crate::types::ModelCost>,
-    /// Whether to append the background job board to requests (primary/delegating agents).
-    pub inject_job_board: bool,
-    /// Optional user-provided reminder injected at the start of every turn (off by default).
-    pub reminder_turn_start: Option<String>,
-    /// Optional user-provided reminder injected on the turn after a file tool ran.
-    pub reminder_after_file_tool: Option<String>,
-}
-
-/// Adds a step's usage/cost onto the persisted session and republishes it. Cost accounting is
-/// best-effort: a store error here is logged, not surfaced as a run failure.
-async fn accumulate_session_usage(
-    ctx: &StepContext,
-    usage: &crate::types::TokenUsage,
-    cost: f64,
-    now: i64,
-) {
-    match ctx.store.session(ctx.session_id.clone()).await {
-        Ok(Some(mut session)) => {
-            session.usage.add(usage);
-            session.cost += cost;
-            session.updated_at = now;
-            if let Err(e) = ctx.store.upsert_session(session.clone()).await {
-                tracing::warn!(error = %e, "failed to persist session usage");
-                return;
-            }
-            ctx.bus
-                .publish(crate::event::AppEvent::SessionUpdated { session });
-        }
-        Ok(None) => {}
-        Err(e) => tracing::warn!(error = %e, "failed to load session for usage accounting"),
-    }
 }
 
 /// opencode's exit condition: keep stepping while the last assistant turn asked for more
@@ -166,8 +133,6 @@ pub async fn run_session(
 ) -> RunOutcome {
     let mut doomloop = DoomLoopGuard::new();
     let mut steps = 0u32;
-    // Whether the previous step ran a file tool, gating the `after_file_tool` reminder.
-    let mut prev_used_file_tool = false;
 
     loop {
         match should_continue(&ctx.store, &ctx.session_id).await {
@@ -206,37 +171,6 @@ pub async fn run_session(
             wire_messages.extend(convert_message(message, &parts));
         }
 
-        // Collect synthetic (non-persisted) blocks to append to the last user message this
-        // turn: the optional turn-start reminder, the job board, and — if the previous step
-        // ran a file tool — the optional after-file-tool reminder. docs/04-multiagent.md.
-        let mut synthetic: Vec<String> = Vec::new();
-        if let Some(reminder) = &run_config.reminder_turn_start {
-            synthetic.push(reminder.clone());
-        }
-        if run_config.inject_job_board {
-            if let Some(board) = &ctx.job_board {
-                if let Some(block) = board.format_for_prompt() {
-                    synthetic.push(block);
-                }
-            }
-        }
-        if prev_used_file_tool {
-            if let Some(reminder) = &run_config.reminder_after_file_tool {
-                synthetic.push(reminder.clone());
-            }
-        }
-        if !synthetic.is_empty() {
-            if let Some(last_user) = wire_messages
-                .iter_mut()
-                .rev()
-                .find(|m| m.role == WireRole::User)
-            {
-                for text in synthetic {
-                    last_user.content.push(WireContent::Text { text });
-                }
-            }
-        }
-
         let system_blocks = system::assemble(
             system::env_header(&ctx.cwd),
             &run_config.agent_prompt,
@@ -287,34 +221,17 @@ pub async fn run_session(
             &ctx,
             run_config.model.clone(),
             &run_config.agent_name,
-            run_config.cost,
             &mut doomloop,
         )
         .await;
 
         match step {
-            Ok(outcome) if outcome.aborted => {
-                accumulate_session_usage(&ctx, &outcome.usage, outcome.cost, now_fn()).await;
-                return RunOutcome::Aborted;
-            }
-            Ok(outcome) => {
-                accumulate_session_usage(&ctx, &outcome.usage, outcome.cost, now_fn()).await;
-                prev_used_file_tool = outcome.used_file_tool;
-                // A completed step means the orchestrator has now seen any terminal jobs
-                // that were on the board this turn; mark them reconciled.
-                if run_config.inject_job_board {
-                    if let Some(board) = &ctx.job_board {
-                        if let Err(e) = board.reconcile_terminal(now_fn()).await {
-                            tracing::warn!(error = %e, "failed to reconcile job board");
-                        }
-                    }
-                }
-                match outcome.result {
+            Ok(outcome) if outcome.aborted => return RunOutcome::Aborted,
+            Ok(outcome) => match outcome.result {
                 StepResult::Continue => continue,
                 StepResult::Stop => return RunOutcome::Stopped,
                 StepResult::Compact => return RunOutcome::Stopped, // stub until M6
-                }
-            }
+            },
             Err(step_err) if matches!(step_err.source, ProviderError::Cancelled) => {
                 return RunOutcome::Aborted;
             }
@@ -425,16 +342,11 @@ mod tests {
             permissions,
             static_rules: Vec::new(),
             extra_rules: Arc::new(std::sync::Mutex::new(Vec::new())),
-            parent_rules: Vec::new(),
             session_id,
             cwd: cwd.clone(),
             data_dir: cwd.join("tool-output"),
             cancel: CancellationToken::new(),
             now: 1,
-            spawner: None,
-            job_board: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 
@@ -510,31 +422,11 @@ mod tests {
             temperature: None,
             max_steps: 10,
             instructions: Vec::new(),
-            // $3/1M input, $15/1M output.
-            cost: Some(crate::types::ModelCost {
-                input: 3.0,
-                output: 15.0,
-                ..Default::default()
-            }),
-            inject_job_board: false,
-            reminder_turn_start: None,
-            reminder_after_file_tool: None,
         };
 
         let outcome = run_session(Arc::new(provider), ctx, &run_config, || 2).await;
         assert!(matches!(outcome, RunOutcome::Stopped));
 
-        // Both steps' usage and cost accumulate onto the session.
-        let session = store.session(session_id.clone()).await.unwrap().unwrap();
-        assert_eq!(session.usage.input, 30);
-        assert_eq!(session.usage.output, 13);
-        // (10*3 + 5*15)/1e6 + (20*3 + 8*15)/1e6 = 0.000105 + 0.00018
-        assert!(
-            (session.cost - 0.000_285).abs() < 1e-9,
-            "cost = {}",
-            session.cost
-        );
-
         let messages = store.messages(session_id.clone()).await.unwrap();
         assert_eq!(
             messages.len(),
@@ -625,10 +517,6 @@ mod tests {
             temperature: None,
             max_steps: 10,
             instructions: Vec::new(),
-            cost: None,
-            inject_job_board: false,
-            reminder_turn_start: None,
-            reminder_after_file_tool: None,
         };
 
         let outcome = run_session(Arc::new(provider), ctx, &run_config, || 2).await;
@@ -638,189 +526,4 @@ mod tests {
         let messages = store.messages(session_id).await.unwrap();
         assert_eq!(messages.len(), 1);
     }
-
-    /// Records the last request it was asked to stream so tests can assert on prompt content.
-    struct CapturingProvider {
-        last: StdMutex<Option<LlmRequest>>,
-    }
-
-    #[async_trait]
-    impl Provider for CapturingProvider {
-        fn id(&self) -> &str {
-            "mock"
-        }
-        async fn list_models(&self) -> Result<Vec<ModelInfo>, ProviderError> {
-            Ok(vec![])
-        }
-        async fn stream(
-            &self,
-            req: LlmRequest,
-            _cancel: CancellationToken,
-        ) -> Result<LlmEventStream, ProviderError> {
-            *self.last.lock().unwrap() = Some(req);
-            let events = vec![
-                Ok(LlmEvent::TextStart { id: "t".into() }),
-                Ok(LlmEvent::TextDelta {
-                    id: "t".into(),
-                    text: "ok".into(),
-                }),
-                Ok(LlmEvent::TextEnd { id: "t".into() }),
-                Ok(LlmEvent::Finish {
-                    reason: FinishReason::Stop,
-                    usage: usage(1, 1),
-                }),
-            ];
-            Ok(Box::pin(futures::stream::iter(events)))
-        }
-    }
-
-    #[tokio::test]
-    async fn job_board_is_injected_into_the_last_user_message() {
-        use crate::engine::jobs::{JobBoard, LaunchSpec};
-
-        let store = Store::open_in_memory().unwrap();
-        let bus = EventBus::new();
-        let model = ModelRef::new("mock", "mock-model");
-        let session = Session::new_root("orchestrator", model.clone(), 1);
-        let session_id = session.id.clone();
-        store.upsert_session(session).await.unwrap();
-
-        let user_message = Message::new_user(session_id.clone(), 1);
-        store.upsert_message(user_message.clone()).await.unwrap();
-        store
-            .upsert_part(Part {
-                id: crate::types::PartId::new(),
-                message_id: user_message.id.clone(),
-                session_id: session_id.clone(),
-                idx: 0,
-                body: PartBody::Text {
-                    text: "carry on".into(),
-                    synthetic: false,
-                },
-            })
-            .await
-            .unwrap();
-
-        // A board with one running job for this session.
-        let board = std::sync::Arc::new(
-            JobBoard::load(store.clone(), bus.clone(), &session_id, 2)
-                .await
-                .unwrap(),
-        );
-        board
-            .register_launch(
-                LaunchSpec {
-                    task_id: "t1".into(),
-                    parent_session: session_id.clone(),
-                    child_session: SessionId::new(),
-                    agent: "explorer".into(),
-                    description: "map auth".into(),
-                    objective: Some("map the auth flow".into()),
-                },
-                1,
-            )
-            .await
-            .unwrap();
-
-        let cwd = tempfile::tempdir().unwrap();
-        let mut ctx = make_ctx(store, bus, session_id, cwd.path().to_path_buf()).await;
-        ctx.job_board = Some(board);
-        let run_config = RunConfig {
-            agent_name: "orchestrator".into(),
-            agent_prompt: "You orchestrate.".into(),
-            model,
-            temperature: None,
-            max_steps: 1,
-            instructions: Vec::new(),
-            cost: None,
-            inject_job_board: true,
-            reminder_turn_start: None,
-            reminder_after_file_tool: None,
-        };
-
-        let provider = std::sync::Arc::new(CapturingProvider {
-            last: StdMutex::new(None),
-        });
-        let outcome = run_session(provider.clone(), ctx, &run_config, || 2).await;
-        assert!(matches!(outcome, RunOutcome::Stopped));
-
-        let req = provider.last.lock().unwrap().clone().expect("a request");
-        let last_user = req
-            .messages
-            .iter()
-            .rev()
-            .find(|m| m.role == WireRole::User)
-            .expect("a user message");
-        let text: String = last_user
-            .content
-            .iter()
-            .filter_map(|c| match c {
-                WireContent::Text { text } => Some(text.as_str()),
-                _ => None,
-            })
-            .collect::<Vec<_>>()
-            .join("\n");
-        assert!(text.contains("Background Job Board"), "got: {text}");
-        assert!(text.contains("exp-1"), "got: {text}");
-        assert!(text.contains("map the auth flow"), "got: {text}");
-    }
-
-    #[tokio::test]
-    async fn turn_start_reminder_is_injected_into_the_request() {
-        let store = Store::open_in_memory().unwrap();
-        let bus = EventBus::new();
-        let model = ModelRef::new("mock", "mock-model");
-        let session = Session::new_root("orchestrator", model.clone(), 1);
-        let session_id = session.id.clone();
-        store.upsert_session(session).await.unwrap();
-
-        let user_message = Message::new_user(session_id.clone(), 1);
-        store.upsert_message(user_message.clone()).await.unwrap();
-        store
-            .upsert_part(Part {
-                id: crate::types::PartId::new(),
-                message_id: user_message.id.clone(),
-                session_id: session_id.clone(),
-                idx: 0,
-                body: PartBody::Text {
-                    text: "do the thing".into(),
-                    synthetic: false,
-                },
-            })
-            .await
-            .unwrap();
-
-        let cwd = tempfile::tempdir().unwrap();
-        let ctx = make_ctx(store, bus, session_id, cwd.path().to_path_buf()).await;
-        let run_config = RunConfig {
-            agent_name: "orchestrator".into(),
-            agent_prompt: "You orchestrate.".into(),
-            model,
-            temperature: None,
-            max_steps: 1,
-            instructions: Vec::new(),
-            cost: None,
-            inject_job_board: false,
-            reminder_turn_start: Some("REMEMBER: stay on task.".into()),
-            reminder_after_file_tool: None,
-        };
-
-        let provider = std::sync::Arc::new(CapturingProvider {
-            last: StdMutex::new(None),
-        });
-        let outcome = run_session(provider.clone(), ctx, &run_config, || 2).await;
-        assert!(matches!(outcome, RunOutcome::Stopped));
-
-        let req = provider.last.lock().unwrap().clone().expect("a request");
-        let last_user = req
-            .messages
-            .iter()
-            .rev()
-            .find(|m| m.role == WireRole::User)
-            .expect("a user message");
-        let has_reminder = last_user.content.iter().any(
-            |c| matches!(c, WireContent::Text { text } if text.contains("REMEMBER: stay on task.")),
-        );
-        assert!(has_reminder, "turn-start reminder should be injected");
-    }
 }

crates/harness-core/src/engine/mod.rs

@@ -1,5 +1,4 @@
 pub mod doomloop;
-pub mod jobs;
 pub mod processor;
 pub mod retry;
 #[path = "loop.rs"]
@@ -7,6 +6,5 @@ pub mod session_loop;
 pub mod system;
 
 pub use doomloop::DoomLoopGuard;
-pub use jobs::{ContextFile, JobBoard, JobRecord, JobState};
 pub use processor::{process_step, StepContext, StepError, StepOutcome, StepResult};
 pub use session_loop::{run_session, RunConfig};

crates/harness-core/src/engine/processor.rs

@@ -10,14 +10,10 @@ use crate::event::{AppEvent, EventBus};
 use crate::llm::{FinishReason, LlmEvent, LlmEventStream, ProviderError};
 use crate::permission::{PermissionService, Ruleset};
 use crate::store::Store;
-use crate::tool::{
-    ContextReporter, MetadataSink, PermissionHandle, SubagentSpawner, Tool, ToolCtx, ToolError,
-    ToolRegistry,
-};
+use crate::tool::{MetadataSink, PermissionHandle, Tool, ToolCtx, ToolError, ToolRegistry};
 use crate::types::{Message, MessageId, Part, PartBody, PartId, SessionId, TokenUsage, ToolState};
 
 use super::doomloop::DoomLoopGuard;
-use super::jobs::JobBoard;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StepResult {
@@ -30,12 +26,7 @@ pub struct StepOutcome {
     pub result: StepResult,
     pub message_id: Option<MessageId>,
     pub usage: TokenUsage,
-    /// Dollar cost of this step's usage (0.0 when no pricing is available).
-    pub cost: f64,
     pub aborted: bool,
-    /// Whether a file-mutating tool (`edit`/`write`) ran this step — drives the optional
-    /// `after_file_tool` reminder injection on the next turn.
-    pub used_file_tool: bool,
 }
 
 pub struct StepError {
@@ -54,9 +45,6 @@ pub struct StepContext {
     pub permissions: Arc<PermissionService>,
     pub static_rules: Ruleset,
     pub extra_rules: Arc<Mutex<Ruleset>>,
-    /// Parent-effective ruleset for a subagent session; empty for a root session. Enables
-    /// permission intersection on this session's tool calls.
-    pub parent_rules: Ruleset,
     pub session_id: SessionId,
     pub cwd: PathBuf,
     /// Session's `tool-output` spill directory (see `tool::truncate`).
@@ -64,16 +52,6 @@ pub struct StepContext {
     pub cancel: CancellationToken,
     /// Wall-clock for `created_at` stamps — passed in so tests stay deterministic.
     pub now: i64,
-    /// Lets the `task` tool spawn subagents. `None` disables delegation (headless/tests).
-    pub spawner: Option<Arc<dyn SubagentSpawner>>,
-    /// This session's background job board (as a parent). Injected into requests when the
-    /// running agent can delegate; `None` disables the board.
-    pub job_board: Option<Arc<JobBoard>>,
-    /// Present in subagent sessions: reports read files to this session's job on the parent
-    /// board. `None` for root sessions (nothing to report to).
-    pub context_reporter: Option<Arc<dyn ContextReporter>>,
-    /// Language-server diagnostics source shared by the session's edit/write tool calls.
-    pub diagnostics: Option<Arc<dyn crate::lsp::DiagnosticsSource>>,
 }
 
 struct FlushTracker {
@@ -103,13 +81,9 @@ impl FlushTracker {
     }
 }
 
-/// Tool names that mutate files — after one runs, the optional `after_file_tool` reminder fires.
-const FILE_TOOLS: &[&str] = &["edit", "write"];
-
 struct Run<'a> {
     ctx: &'a StepContext,
     assistant: Option<Message>,
-    used_file_tool: bool,
     next_idx: u32,
     active_text: Option<PartId>,
     active_reasoning: Option<PartId>,
@@ -126,7 +100,6 @@ impl<'a> Run<'a> {
         Self {
             ctx,
             assistant: None,
-            used_file_tool: false,
             next_idx: 0,
             active_text: None,
             active_reasoning: None,
@@ -396,9 +369,6 @@ impl<'a> Run<'a> {
         input: serde_json::Value,
         doomloop: &mut DoomLoopGuard,
     ) -> Result<(), ProviderError> {
-        if FILE_TOOLS.contains(&name.as_str()) {
-            self.used_file_tool = true;
-        }
         let part_id = self.pending_tools.remove(&call_id).unwrap_or_default();
         let running = Part {
             id: part_id.clone(),
@@ -511,8 +481,7 @@ impl<'a> Run<'a> {
             self.ctx.static_rules.clone(),
             self.ctx.extra_rules.clone(),
             call_cancel.clone(),
-        )
-        .with_parent_rules(self.ctx.parent_rules.clone());
+        );
         let tool_ctx = ToolCtx {
             session_id: self.ctx.session_id.clone(),
             message_id: self.message_id(),
@@ -522,9 +491,6 @@ impl<'a> Run<'a> {
             cancel: call_cancel.clone(),
             ask,
             metadata: metadata_sink,
-            spawner: self.ctx.spawner.clone(),
-            context_reporter: self.ctx.context_reporter.clone(),
-            diagnostics: self.ctx.diagnostics.clone(),
         };
 
         let result = tokio::select! {
@@ -547,7 +513,6 @@ impl<'a> Run<'a> {
         &mut self,
         reason: FinishReason,
         usage: TokenUsage,
-        cost: f64,
     ) -> Result<StepResult, ProviderError> {
         let part = Part {
             id: PartId::new(),
@@ -556,7 +521,7 @@ impl<'a> Run<'a> {
             idx: self.next_idx,
             body: PartBody::StepFinish {
                 usage,
-                cost,
+                cost: 0.0,
                 reason: reason.clone(),
             },
         };
@@ -602,12 +567,10 @@ pub async fn process_step(
     ctx: &StepContext,
     model: crate::types::ModelRef,
     agent: &str,
-    cost: Option<crate::types::ModelCost>,
     doomloop: &mut DoomLoopGuard,
 ) -> Result<StepOutcome, StepError> {
     let mut run = Run::new(ctx);
     let mut usage = TokenUsage::default();
-    let mut step_cost = 0.0;
     let mut result = StepResult::Stop;
 
     loop {
@@ -619,9 +582,7 @@ pub async fn process_step(
                     result: StepResult::Stop,
                     message_id: run.assistant.as_ref().map(|m| m.id.clone()),
                     usage,
-                    cost: step_cost,
                     aborted: true,
-                    used_file_tool: run.used_file_tool,
                 });
             }
         };
@@ -669,8 +630,7 @@ pub async fn process_step(
                 usage: finish_usage,
             } => {
                 usage = finish_usage;
-                step_cost = cost.map(|c| c.cost_of(&finish_usage)).unwrap_or(0.0);
-                match run.on_finish(reason, finish_usage, step_cost).await {
+                match run.on_finish(reason, finish_usage).await {
                     Ok(r) => {
                         result = r;
                         Ok(())
@@ -692,8 +652,6 @@ pub async fn process_step(
         result,
         message_id: run.assistant.as_ref().map(|m| m.id.clone()),
         usage,
-        cost: step_cost,
         aborted: false,
-        used_file_tool: run.used_file_tool,
     })
 }

crates/harness-core/src/lib.rs

@@ -1,9 +1,7 @@
-pub mod agent;
 pub mod config;
 pub mod engine;
 pub mod event;
 pub mod llm;
-pub mod lsp;
 pub mod permission;
 pub mod store;
 pub mod tool;

crates/harness-core/src/lsp.rs

@@ -1,46 +0,0 @@
-//! Seam trait for language-server diagnostics, implemented by `harness-lsp` and consumed by
-//! the edit/write tools. Kept in core so `harness-tools` never links the LSP crate directly.
-//! See `docs/09-integrations.md`.
-
-use std::path::Path;
-use std::time::Duration;
-
-use async_trait::async_trait;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Severity {
-    Error,
-    Warning,
-    Info,
-    Hint,
-}
-
-/// One diagnostic reported by a language server. Line/character are 1-based for display.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Diagnostic {
-    pub line: u32,
-    pub character: u32,
-    pub severity: Severity,
-    pub message: String,
-    pub source: Option<String>,
-}
-
-impl Diagnostic {
-    /// `{file}: L{line}: {message}` — the one-line form appended to tool output.
-    pub fn display_line(&self, file: &str) -> String {
-        format!("{file}: L{}: {}", self.line, self.message)
-    }
-}
-
-/// A source of file diagnostics (an LSP pool). All methods are best-effort: failures are
-/// swallowed (logged) so a broken language server never fails a tool call.
-#[async_trait]
-pub trait DiagnosticsSource: Send + Sync {
-    /// Ensure a server for `path`'s language is running and told about the file's current
-    /// contents (spawn-if-needed + didOpen/didChange).
-    async fn touch(&self, path: &Path);
-
-    /// Diagnostics for `path`, waiting up to `wait` for the server to (re)publish after a
-    /// change. Returns whatever is known on timeout.
-    async fn diagnostics(&self, path: &Path, wait: Duration) -> Vec<Diagnostic>;
-}

crates/harness-core/src/permission/mod.rs

@@ -1,7 +1,7 @@
 pub mod rule;
 pub mod service;
 
-pub use rule::{evaluate, evaluate_intersected, Action, Rule, Ruleset};
+pub use rule::{evaluate, Action, Rule, Ruleset};
 pub use service::{
     spawn_auto_approve, AskDecision, AskError, AskInput, PermissionReply, PermissionService,
 };

crates/harness-core/src/permission/rule.rs

@@ -44,37 +44,6 @@ pub fn evaluate(stack: &[&Ruleset], permission: &str, pattern: &str) -> Action {
     result
 }
 
-impl Action {
-    /// How restrictive this verdict is: `Deny` > `Ask` > `Allow`. Used to intersect a
-    /// parent and child verdict when a subagent runs (docs/04-multiagent.md).
-    fn restrictiveness(self) -> u8 {
-        match self {
-            Action::Allow => 0,
-            Action::Ask => 1,
-            Action::Deny => 2,
-        }
-    }
-}
-
-/// Evaluate `permission`/`pattern` against a parent-effective stack and a child stack
-/// independently, returning the **more restrictive** of the two verdicts
-/// (`deny > ask > allow`). A subagent's tool call must satisfy both the rules it inherits
-/// from its spawning chain and its own agent ruleset.
-pub fn evaluate_intersected(
-    parent_stack: &[&Ruleset],
-    child_stack: &[&Ruleset],
-    permission: &str,
-    pattern: &str,
-) -> Action {
-    let parent = evaluate(parent_stack, permission, pattern);
-    let child = evaluate(child_stack, permission, pattern);
-    if child.restrictiveness() >= parent.restrictiveness() {
-        child
-    } else {
-        parent
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -143,49 +112,4 @@ mod tests {
     fn empty_stack_defaults_to_ask() {
         assert_eq!(evaluate(&[], "bash", "ls"), Action::Ask);
     }
-
-    #[test]
-    fn intersected_takes_the_more_restrictive_verdict() {
-        let parent_allow: Ruleset = vec![rule("edit", "*", Action::Allow)];
-        let child_deny: Ruleset = vec![rule("edit", "*", Action::Deny)];
-        // Child denies what the parent would allow → deny wins.
-        assert_eq!(
-            evaluate_intersected(&[&parent_allow], &[&child_deny], "edit", "main.rs"),
-            Action::Deny
-        );
-        // Symmetric: parent denies what the child would allow → deny still wins.
-        assert_eq!(
-            evaluate_intersected(&[&child_deny], &[&parent_allow], "edit", "main.rs"),
-            Action::Deny
-        );
-    }
-
-    #[test]
-    fn intersected_ask_beats_allow_but_loses_to_deny() {
-        let allow: Ruleset = vec![rule("bash", "*", Action::Allow)];
-        let ask: Ruleset = vec![rule("bash", "*", Action::Ask)];
-        let deny: Ruleset = vec![rule("bash", "*", Action::Deny)];
-        assert_eq!(
-            evaluate_intersected(&[&allow], &[&ask], "bash", "ls"),
-            Action::Ask
-        );
-        assert_eq!(
-            evaluate_intersected(&[&ask], &[&deny], "bash", "ls"),
-            Action::Deny
-        );
-    }
-
-    #[test]
-    fn intersected_allows_only_when_both_allow() {
-        let allow: Ruleset = vec![rule("read", "*", Action::Allow)];
-        assert_eq!(
-            evaluate_intersected(&[&allow], &[&allow], "read", "src/a.rs"),
-            Action::Allow
-        );
-        // Empty child stack defaults to Ask, which is more restrictive than parent Allow.
-        assert_eq!(
-            evaluate_intersected(&[&allow], &[], "read", "src/a.rs"),
-            Action::Ask
-        );
-    }
 }

crates/harness-core/src/permission/service.rs

@@ -8,7 +8,7 @@ use ulid::Ulid;
 use crate::event::{AppEvent, EventBus, PermissionRequest};
 use crate::types::SessionId;
 
-use super::rule::{evaluate, evaluate_intersected, Action, Rule, Ruleset};
+use super::rule::{evaluate, Action, Rule, Ruleset};
 
 pub struct AskInput {
     pub permission: String,
@@ -73,24 +73,6 @@ impl PermissionService {
         }
     }
 
-    /// Like [`ask`](Self::ask), but for a subagent: the verdict is the more restrictive of
-    /// the `parent_stack` (rules inherited from the spawning chain) and `child_stack` (the
-    /// subagent's own rules). Used so a child can never widen what its parent forbids.
-    pub async fn ask_intersected(
-        &self,
-        session_id: &SessionId,
-        parent_stack: &[&Ruleset],
-        child_stack: &[&Ruleset],
-        input: AskInput,
-        cancel: &CancellationToken,
-    ) -> Result<AskDecision, AskError> {
-        match evaluate_intersected(parent_stack, child_stack, &input.permission, &input.pattern) {
-            Action::Allow => Ok(AskDecision::Allowed),
-            Action::Deny => Err(AskError::Denied),
-            Action::Ask => self.ask_user(session_id, input, cancel).await,
-        }
-    }
-
     /// Bypasses ruleset evaluation entirely — used by the doom-loop guard, which must ask
     /// regardless of any `Allow` rule.
     pub async fn force_ask(

crates/harness-core/src/store/actor.rs

@@ -1,7 +1,6 @@
 use rusqlite::{params, Connection};
 use tokio::sync::oneshot;
 
-use crate::engine::jobs::JobRecord;
 use crate::types::{Message, MessageId, Part, Session, SessionId};
 
 use super::api::StoreError;
@@ -14,13 +13,9 @@ pub enum StoreCmd {
     UpsertSession(Session, Reply<()>),
     UpsertMessage(Message, Reply<()>),
     UpsertPart(Part, Reply<()>),
-    Session(SessionId, Reply<Option<Session>>),
     Sessions(Reply<Vec<Session>>),
     Messages(SessionId, Reply<Vec<Message>>),
     Parts(MessageId, Reply<Vec<Part>>),
-    UpsertJob(JobRecord, Reply<()>),
-    DeleteJob(String, Reply<()>),
-    JobsForParent(SessionId, Reply<Vec<JobRecord>>),
 }
 
 fn init_schema(conn: &Connection) -> rusqlite::Result<()> {
@@ -74,15 +69,6 @@ fn upsert_part(conn: &Connection, part: &Part) -> Result<(), StoreError> {
     Ok(())
 }
 
-fn get_session(conn: &Connection, id: &SessionId) -> Result<Option<Session>, StoreError> {
-    let mut stmt = conn.prepare("SELECT data FROM session WHERE id = ?1")?;
-    let mut rows = stmt.query_map(params![id.as_ref()], |row| row.get::<_, String>(0))?;
-    match rows.next() {
-        Some(data) => Ok(Some(serde_json::from_str(&data?)?)),
-        None => Ok(None),
-    }
-}
-
 fn list_sessions(conn: &Connection) -> Result<Vec<Session>, StoreError> {
     let mut stmt = conn.prepare("SELECT data FROM session ORDER BY id")?;
     let rows = stmt
@@ -113,34 +99,6 @@ fn list_parts(conn: &Connection, message_id: &MessageId) -> Result<Vec<Part>, St
         .collect()
 }
 
-fn upsert_job(conn: &Connection, job: &JobRecord) -> Result<(), StoreError> {
-    let data = serde_json::to_string(job)?;
-    conn.execute(
-        "INSERT INTO job (task_id, parent_session_id, data) VALUES (?1, ?2, ?3)
-         ON CONFLICT(task_id) DO UPDATE SET data = ?3",
-        params![job.task_id, job.parent_session.as_ref(), data],
-    )?;
-    Ok(())
-}
-
-fn delete_job(conn: &Connection, task_id: &str) -> Result<(), StoreError> {
-    conn.execute("DELETE FROM job WHERE task_id = ?1", params![task_id])?;
-    Ok(())
-}
-
-fn list_jobs_for_parent(
-    conn: &Connection,
-    parent: &SessionId,
-) -> Result<Vec<JobRecord>, StoreError> {
-    let mut stmt = conn.prepare("SELECT data FROM job WHERE parent_session_id = ?1")?;
-    let rows = stmt
-        .query_map(params![parent.as_ref()], |row| row.get::<_, String>(0))?
-        .collect::<Result<Vec<_>, _>>()?;
-    rows.iter()
-        .map(|data| serde_json::from_str(data).map_err(StoreError::from))
-        .collect()
-}
-
 /// Runs on a dedicated OS thread; the async facade in `api.rs` talks to it over `mpsc`.
 pub fn run(conn: Connection, mut rx: tokio::sync::mpsc::Receiver<StoreCmd>) {
     if let Err(e) = init_schema(&conn) {
@@ -158,9 +116,6 @@ pub fn run(conn: Connection, mut rx: tokio::sync::mpsc::Receiver<StoreCmd>) {
             StoreCmd::UpsertPart(part, reply) => {
                 let _ = reply.send(upsert_part(&conn, &part));
             }
-            StoreCmd::Session(id, reply) => {
-                let _ = reply.send(get_session(&conn, &id));
-            }
             StoreCmd::Sessions(reply) => {
                 let _ = reply.send(list_sessions(&conn));
             }
@@ -170,15 +125,6 @@ pub fn run(conn: Connection, mut rx: tokio::sync::mpsc::Receiver<StoreCmd>) {
             StoreCmd::Parts(message_id, reply) => {
                 let _ = reply.send(list_parts(&conn, &message_id));
             }
-            StoreCmd::UpsertJob(job, reply) => {
-                let _ = reply.send(upsert_job(&conn, &job));
-            }
-            StoreCmd::DeleteJob(task_id, reply) => {
-                let _ = reply.send(delete_job(&conn, &task_id));
-            }
-            StoreCmd::JobsForParent(parent, reply) => {
-                let _ = reply.send(list_jobs_for_parent(&conn, &parent));
-            }
         }
     }
 }

crates/harness-core/src/store/api.rs

@@ -3,7 +3,6 @@ use std::path::Path;
 use rusqlite::Connection;
 use tokio::sync::{mpsc, oneshot};
 
-use crate::engine::jobs::JobRecord;
 use crate::types::{Message, MessageId, Part, Session, SessionId};
 
 use super::actor::{self, StoreCmd};
@@ -78,11 +77,6 @@ impl Store {
         self.call(|reply| StoreCmd::UpsertPart(part, reply)).await
     }
 
-    pub async fn session(&self, session_id: SessionId) -> Result<Option<Session>, StoreError> {
-        self.call(|reply| StoreCmd::Session(session_id, reply))
-            .await
-    }
-
     pub async fn sessions(&self) -> Result<Vec<Session>, StoreError> {
         self.call(StoreCmd::Sessions).await
     }
@@ -95,19 +89,6 @@ impl Store {
     pub async fn parts(&self, message_id: MessageId) -> Result<Vec<Part>, StoreError> {
         self.call(|reply| StoreCmd::Parts(message_id, reply)).await
     }
-
-    pub async fn upsert_job(&self, job: JobRecord) -> Result<(), StoreError> {
-        self.call(|reply| StoreCmd::UpsertJob(job, reply)).await
-    }
-
-    pub async fn delete_job(&self, task_id: String) -> Result<(), StoreError> {
-        self.call(|reply| StoreCmd::DeleteJob(task_id, reply)).await
-    }
-
-    pub async fn jobs_for_parent(&self, parent: SessionId) -> Result<Vec<JobRecord>, StoreError> {
-        self.call(|reply| StoreCmd::JobsForParent(parent, reply))
-            .await
-    }
 }
 
 #[cfg(test)]

crates/harness-core/src/tool/mod.rs

@@ -10,58 +10,6 @@ use tokio_util::sync::CancellationToken;
 use crate::permission::{AskDecision, AskError, AskInput, PermissionService, Ruleset};
 use crate::types::{MessageId, SessionId};
 
-/// A request from the `task` tool to run a subagent. The spawner (owned by the composition
-/// root) resolves the agent, enforces the depth limit, applies permission intersection, and
-/// runs the child session foreground or background. See `docs/04-multiagent.md`.
-pub struct SpawnRequest {
-    pub parent_session_id: SessionId,
-    pub parent_message_id: MessageId,
-    pub agent: String,
-    pub description: String,
-    pub prompt: String,
-    /// Alias or task id of a completed job to reuse (continue its child session).
-    pub reuse_task_id: Option<String>,
-    pub background: bool,
-    /// The tool call's cancellation token — used for foreground child runs. Background runs
-    /// are childed from the parent session's run token by the spawner instead.
-    pub cancel: CancellationToken,
-}
-
-#[derive(Debug)]
-pub struct SpawnOutcome {
-    pub child_session_id: SessionId,
-    pub background: bool,
-    /// Board alias assigned to a background launch.
-    pub alias: Option<String>,
-    /// Final assistant text of a foreground run.
-    pub final_text: Option<String>,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum SpawnError {
-    #[error("unknown subagent {0:?}, or it is not usable as a subagent")]
-    InvalidAgent(String),
-    #[error("subagent depth limit reached — do this work yourself instead of delegating further")]
-    DepthExceeded,
-    #[error("cannot reuse {0:?}: no completed job with that alias for this session")]
-    ReuseNotFound(String),
-    #[error("{0}")]
-    Other(String),
-}
-
-#[async_trait]
-pub trait SubagentSpawner: Send + Sync {
-    async fn spawn(&self, req: SpawnRequest) -> Result<SpawnOutcome, SpawnError>;
-}
-
-/// Lets a child session report the files it read to its job board entry, so a completed
-/// specialist advertises what it already looked at (docs/04-multiagent.md). Present only in
-/// subagent sessions; the spawner wires it to the right board + job.
-#[async_trait]
-pub trait ContextReporter: Send + Sync {
-    async fn report_file(&self, path: String, lines: u32);
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum ToolError {
     #[error("permission denied")]
@@ -112,9 +60,6 @@ pub struct PermissionHandle {
     session_id: SessionId,
     static_rules: Ruleset,
     extra_rules: Arc<Mutex<Ruleset>>,
-    /// Parent-effective ruleset for a subagent session; empty for a root session. When
-    /// non-empty, verdicts are intersected so a child can only ever be *more* restricted.
-    parent_rules: Ruleset,
     cancel: CancellationToken,
 }
 
@@ -131,17 +76,10 @@ impl PermissionHandle {
             session_id,
             static_rules,
             extra_rules,
-            parent_rules: Vec::new(),
             cancel,
         }
     }
 
-    /// Sets the parent-effective ruleset so this handle intersects verdicts (subagent runs).
-    pub fn with_parent_rules(mut self, parent_rules: Ruleset) -> Self {
-        self.parent_rules = parent_rules;
-        self
-    }
-
     pub async fn ask(
         &self,
         permission: impl Into<String>,
@@ -150,29 +88,21 @@ impl PermissionHandle {
         metadata: serde_json::Value,
     ) -> Result<(), ToolError> {
         let extra_snapshot = self.extra_rules.lock().unwrap().clone();
-        let child_stack: [&Ruleset; 2] = [&self.static_rules, &extra_snapshot];
-        let input = AskInput {
+        let stack: [&Ruleset; 2] = [&self.static_rules, &extra_snapshot];
+        let decision = self
+            .service
+            .ask(
+                &self.session_id,
+                &stack,
+                AskInput {
                     permission: permission.into(),
                     pattern: pattern.into(),
                     always_pattern: always_pattern.into(),
                     metadata,
-        };
-        let decision = if self.parent_rules.is_empty() {
-            self.service
-                .ask(&self.session_id, &child_stack, input, &self.cancel)
-                .await?
-        } else {
-            let parent_stack: [&Ruleset; 1] = [&self.parent_rules];
-            self.service
-                .ask_intersected(
-                    &self.session_id,
-                    &parent_stack,
-                    &child_stack,
-                    input,
+                },
                 &self.cancel,
             )
-                .await?
-        };
+            .await?;
         if let AskDecision::AllowedAlways(rule) = decision {
             self.extra_rules.lock().unwrap().push(rule);
         }
@@ -190,14 +120,6 @@ pub struct ToolCtx {
     pub cancel: CancellationToken,
     pub ask: PermissionHandle,
     pub metadata: MetadataSink,
-    /// Present when the engine can spawn subagents (the `task` tool's capability). `None`
-    /// in headless/test contexts with no orchestration wired in.
-    pub spawner: Option<Arc<dyn SubagentSpawner>>,
-    /// Present in subagent sessions: lets the read tool report files to the job board.
-    pub context_reporter: Option<Arc<dyn ContextReporter>>,
-    /// Language-server diagnostics source (edit/write surface errors after a change). `None`
-    /// disables LSP integration.
-    pub diagnostics: Option<Arc<dyn crate::lsp::DiagnosticsSource>>,
 }
 
 #[derive(Debug)]

crates/harness-core/src/types/mod.rs

@@ -6,6 +6,6 @@ pub mod session;
 
 pub use ids::{MessageId, PartId, SessionId};
 pub use message::{Message, MessageError, Role};
-pub use model::{ModelCost, ModelInfo, ModelRef, TokenUsage};
+pub use model::{ModelInfo, ModelRef, TokenUsage};
 pub use part::{Part, PartBody, ToolState};
 pub use session::Session;

crates/harness-core/src/types/model.rs

@@ -34,71 +34,11 @@ impl TokenUsage {
     }
 }
 
-/// Per-model pricing in USD per **one million** tokens. Populated from models.dev metadata
-/// by `harness-providers`.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
-pub struct ModelCost {
-    pub input: f64,
-    pub output: f64,
-    pub cache_read: f64,
-    pub cache_write: f64,
-}
-
-impl ModelCost {
-    /// Dollar cost of a usage sample. Reasoning tokens are billed within `output` by the
-    /// providers we support (OpenAI reports them as a subset of `output_tokens`; Anthropic
-    /// counts thinking in output), so they are intentionally not charged separately here.
-    pub fn cost_of(&self, usage: &TokenUsage) -> f64 {
-        let per_million = |tokens: u64, rate: f64| (tokens as f64) * rate / 1_000_000.0;
-        per_million(usage.input, self.input)
-            + per_million(usage.output, self.output)
-            + per_million(usage.cache_read, self.cache_read)
-            + per_million(usage.cache_write, self.cache_write)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn cost_of_sums_components_per_million_excluding_reasoning() {
-        let cost = ModelCost {
-            input: 3.0,
-            output: 15.0,
-            cache_read: 0.30,
-            cache_write: 3.75,
-        };
-        let usage = TokenUsage {
-            input: 1_000_000,
-            output: 1_000_000,
-            reasoning: 500_000, // billed within output — must not add extra cost
-            cache_read: 1_000_000,
-            cache_write: 1_000_000,
-        };
-        // 3 + 15 + 0.30 + 3.75, with reasoning contributing nothing.
-        assert!((cost.cost_of(&usage) - 22.05).abs() < 1e-9);
-    }
-
-    #[test]
-    fn default_cost_is_zero() {
-        assert_eq!(ModelCost::default().cost_of(&TokenUsage::default()), 0.0);
-    }
-}
-
-/// Model metadata, keyed on `model`. Cost/limits are populated from models.dev by
-/// `harness-providers`; `reasoning`/`tool_call`/`attachment` are capability flags.
+// Full cost/context-limit metadata is populated by harness-providers (models.dev) in M1/M3;
+// this placeholder only carries what harness-core needs to key on.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ModelInfo {
     pub model: ModelRef,
     pub context_limit: u64,
     pub output_limit: u64,
-    #[serde(default)]
-    pub cost: ModelCost,
-    #[serde(default)]
-    pub reasoning: bool,
-    #[serde(default)]
-    pub tool_call: bool,
-    #[serde(default)]
-    pub attachment: bool,
 }

crates/harness-lsp/Cargo.toml

@@ -6,13 +6,6 @@ license.workspace = true
 
 [dependencies]
 harness-core = { workspace = true }
-tokio = { workspace = true }
-async-trait = { workspace = true }
-serde_json = { workspace = true }
-tracing = { workspace = true }
-
-[dev-dependencies]
-tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/harness-lsp/src/client.rs

@@ -1,325 +0,0 @@
-//! Minimal JSON-RPC client over an LSP server's child stdio: `Content-Length` framing, a
-//! request-id → oneshot map, and a diagnostics store keyed by document URI. Only the handful
-//! of methods the edit/write flow needs are implemented (docs/09-integrations.md).
-
-use std::collections::HashMap;
-use std::path::Path;
-use std::sync::atomic::{AtomicI64, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use harness_core::lsp::{Diagnostic, Severity};
-use serde_json::{json, Value};
-use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::process::{Child, Command};
-use tokio::sync::{oneshot, Notify};
-
-type Pending = Arc<Mutex<HashMap<i64, oneshot::Sender<Value>>>>;
-type DiagStore = Arc<Mutex<HashMap<String, Vec<Diagnostic>>>>;
-
-/// A running language server plus the state needed to talk to it.
-pub struct LspClient {
-    outgoing: tokio::sync::mpsc::UnboundedSender<String>,
-    next_id: AtomicI64,
-    pending: Pending,
-    diagnostics: DiagStore,
-    diag_notify: Arc<Notify>,
-    // Kept alive so the child is killed on drop (`kill_on_drop`).
-    _child: Child,
-}
-
-impl LspClient {
-    /// Spawns `command args`, performs the `initialize`/`initialized` handshake rooted at
-    /// `root`, and returns a ready client.
-    pub async fn spawn(command: &str, args: &[String], root: &Path) -> std::io::Result<Self> {
-        let mut child = Command::new(command)
-            .args(args)
-            .current_dir(root)
-            .stdin(std::process::Stdio::piped())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::null())
-            .kill_on_drop(true)
-            .spawn()?;
-
-        let stdin = child.stdin.take().expect("piped stdin");
-        let stdout = child.stdout.take().expect("piped stdout");
-
-        let (outgoing, mut out_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
-        let pending: Pending = Arc::default();
-        let diagnostics: DiagStore = Arc::default();
-        let diag_notify = Arc::new(Notify::new());
-
-        // Writer task: frame and forward outgoing payloads.
-        tokio::spawn(async move {
-            let mut stdin = stdin;
-            while let Some(payload) = out_rx.recv().await {
-                let frame = format!("Content-Length: {}\r\n\r\n{}", payload.len(), payload);
-                if stdin.write_all(frame.as_bytes()).await.is_err() {
-                    break;
-                }
-                let _ = stdin.flush().await;
-            }
-        });
-
-        // Reader task: parse frames, route responses, collect diagnostics, ack server requests.
-        {
-            let pending = pending.clone();
-            let diagnostics = diagnostics.clone();
-            let diag_notify = diag_notify.clone();
-            let outgoing_ack = outgoing.clone();
-            tokio::spawn(async move {
-                let mut reader = BufReader::new(stdout);
-                while let Some(msg) = read_message(&mut reader).await {
-                    dispatch(msg, &pending, &diagnostics, &diag_notify, &outgoing_ack);
-                }
-            });
-        }
-
-        let client = Self {
-            outgoing,
-            next_id: AtomicI64::new(1),
-            pending,
-            diagnostics,
-            diag_notify,
-            _child: child,
-        };
-
-        client.initialize(root).await?;
-        Ok(client)
-    }
-
-    async fn initialize(&self, root: &Path) -> std::io::Result<()> {
-        let root_uri = path_to_uri(root);
-        let params = json!({
-            "processId": std::process::id(),
-            "rootUri": root_uri,
-            "workspaceFolders": [{ "uri": root_uri, "name": "root" }],
-            "capabilities": {
-                "textDocument": {
-                    "publishDiagnostics": { "relatedInformation": false }
-                }
-            },
-            "clientInfo": { "name": "ai-harness" }
-        });
-        // A slow server (rust-analyzer indexing) can take a while to answer initialize.
-        let _ = self
-            .request("initialize", params, Duration::from_secs(30))
-            .await;
-        self.notify("initialized", json!({}));
-        Ok(())
-    }
-
-    fn send(&self, payload: Value) {
-        if let Ok(text) = serde_json::to_string(&payload) {
-            let _ = self.outgoing.send(text);
-        }
-    }
-
-    pub fn notify(&self, method: &str, params: Value) {
-        self.send(json!({ "jsonrpc": "2.0", "method": method, "params": params }));
-    }
-
-    async fn request(&self, method: &str, params: Value, timeout: Duration) -> Option<Value> {
-        let id = self.next_id.fetch_add(1, Ordering::Relaxed);
-        let (tx, rx) = oneshot::channel();
-        self.pending.lock().unwrap().insert(id, tx);
-        self.send(json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params }));
-        match tokio::time::timeout(timeout, rx).await {
-            Ok(Ok(value)) => Some(value),
-            _ => {
-                self.pending.lock().unwrap().remove(&id);
-                None
-            }
-        }
-    }
-
-    pub fn did_open(&self, path: &Path, language_id: &str, version: i32, text: &str) {
-        self.notify(
-            "textDocument/didOpen",
-            json!({
-                "textDocument": {
-                    "uri": path_to_uri(path),
-                    "languageId": language_id,
-                    "version": version,
-                    "text": text,
-                }
-            }),
-        );
-    }
-
-    pub fn did_change(&self, path: &Path, version: i32, text: &str) {
-        self.notify(
-            "textDocument/didChange",
-            json!({
-                "textDocument": { "uri": path_to_uri(path), "version": version },
-                "contentChanges": [{ "text": text }],
-            }),
-        );
-    }
-
-    /// Clears the stored diagnostics for `path` so the next `wait_diagnostics` observes a fresh
-    /// publish rather than a stale one.
-    pub fn clear(&self, path: &Path) {
-        self.diagnostics.lock().unwrap().remove(&path_to_uri(path));
-    }
-
-    /// Waits up to `wait` for the server to publish diagnostics for `path`, returning whatever
-    /// is stored on timeout (possibly empty).
-    pub async fn wait_diagnostics(&self, path: &Path, wait: Duration) -> Vec<Diagnostic> {
-        let uri = path_to_uri(path);
-        let deadline = tokio::time::Instant::now() + wait;
-        loop {
-            if let Some(diags) = self.diagnostics.lock().unwrap().get(&uri) {
-                return diags.clone();
-            }
-            let notified = self.diag_notify.notified();
-            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
-            if remaining.is_zero() {
-                break;
-            }
-            if tokio::time::timeout(remaining, notified).await.is_err() {
-                break;
-            }
-        }
-        self.diagnostics
-            .lock()
-            .unwrap()
-            .get(&uri)
-            .cloned()
-            .unwrap_or_default()
-    }
-}
-
-fn dispatch(
-    msg: Value,
-    pending: &Pending,
-    diagnostics: &DiagStore,
-    diag_notify: &Arc<Notify>,
-    outgoing: &tokio::sync::mpsc::UnboundedSender<String>,
-) {
-    let method = msg.get("method").and_then(|m| m.as_str());
-    let id = msg.get("id");
-
-    match (method, id) {
-        // Server → client request: ack with a null result so the server can proceed
-        // (e.g. client/registerCapability, window/workDoneProgress/create).
-        (Some(_), Some(id)) => {
-            let reply = json!({ "jsonrpc": "2.0", "id": id, "result": Value::Null });
-            if let Ok(text) = serde_json::to_string(&reply) {
-                let _ = outgoing.send(text);
-            }
-        }
-        // Notification from the server.
-        (Some("textDocument/publishDiagnostics"), None) => {
-            if let Some(params) = msg.get("params") {
-                if let Some((uri, diags)) = parse_diagnostics(params) {
-                    diagnostics.lock().unwrap().insert(uri, diags);
-                    diag_notify.notify_waiters();
-                }
-            }
-        }
-        (Some(_), None) => {}
-        // Response to one of our requests.
-        (None, Some(id)) => {
-            if let Some(id) = id.as_i64() {
-                if let Some(tx) = pending.lock().unwrap().remove(&id) {
-                    let result = msg.get("result").cloned().unwrap_or(Value::Null);
-                    let _ = tx.send(result);
-                }
-            }
-        }
-        (None, None) => {}
-    }
-}
-
-fn parse_diagnostics(params: &Value) -> Option<(String, Vec<Diagnostic>)> {
-    let uri = params.get("uri")?.as_str()?.to_string();
-    let items = params.get("diagnostics")?.as_array()?;
-    let diags = items
-        .iter()
-        .filter_map(|d| {
-            let start = d.get("range")?.get("start")?;
-            Some(Diagnostic {
-                line: start.get("line")?.as_u64().unwrap_or(0) as u32 + 1,
-                character: start.get("character")?.as_u64().unwrap_or(0) as u32 + 1,
-                severity: match d.get("severity").and_then(|s| s.as_u64()) {
-                    Some(1) => Severity::Error,
-                    Some(2) => Severity::Warning,
-                    Some(3) => Severity::Info,
-                    _ => Severity::Hint,
-                },
-                message: d.get("message")?.as_str().unwrap_or("").to_string(),
-                source: d
-                    .get("source")
-                    .and_then(|s| s.as_str())
-                    .map(|s| s.to_string()),
-            })
-        })
-        .collect();
-    Some((uri, diags))
-}
-
-/// Reads one `Content-Length`-framed JSON-RPC message, or `None` at EOF.
-async fn read_message<R: tokio::io::AsyncBufRead + Unpin>(reader: &mut R) -> Option<Value> {
-    use tokio::io::AsyncBufReadExt;
-    let mut content_length: Option<usize> = None;
-    loop {
-        let mut line = String::new();
-        let n = reader.read_line(&mut line).await.ok()?;
-        if n == 0 {
-            return None; // EOF
-        }
-        let trimmed = line.trim_end();
-        if trimmed.is_empty() {
-            break; // end of headers
-        }
-        if let Some(value) = trimmed.strip_prefix("Content-Length:") {
-            content_length = value.trim().parse().ok();
-        }
-    }
-    let len = content_length?;
-    let mut buf = vec![0u8; len];
-    reader.read_exact(&mut buf).await.ok()?;
-    serde_json::from_slice(&buf).ok()
-}
-
-/// `file://` URI for an absolute path (best-effort; assumes UTF-8, no percent-encoding needed
-/// for the local paths we handle).
-fn path_to_uri(path: &Path) -> String {
-    let s = path.to_string_lossy();
-    if s.starts_with('/') {
-        format!("file://{s}")
-    } else {
-        format!("file:///{s}")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_publish_diagnostics_into_one_based_positions() {
-        let params = json!({
-            "uri": "file:///tmp/a.rs",
-            "diagnostics": [{
-                "range": {"start": {"line": 4, "character": 8}, "end": {"line": 4, "character": 12}},
-                "severity": 1,
-                "message": "cannot find value `x`",
-                "source": "rustc"
-            }]
-        });
-        let (uri, diags) = parse_diagnostics(&params).unwrap();
-        assert_eq!(uri, "file:///tmp/a.rs");
-        assert_eq!(diags.len(), 1);
-        assert_eq!(diags[0].line, 5); // 0-based 4 → 1-based 5
-        assert_eq!(diags[0].character, 9);
-        assert_eq!(diags[0].severity, Severity::Error);
-        assert_eq!(diags[0].source.as_deref(), Some("rustc"));
-    }
-
-    #[test]
-    fn path_to_uri_prefixes_file_scheme() {
-        assert_eq!(path_to_uri(Path::new("/tmp/a.rs")), "file:///tmp/a.rs");
-    }
-}

crates/harness-lsp/src/lib.rs

@@ -1,238 +1 @@
-//! LSP diagnostics pool: maps a file extension to a language server, lazily spawns one server
-//! per language, and answers the core `DiagnosticsSource` seam. Built-in servers are only
-//! offered when their binary is on `PATH`; config can add or override them.
-//! See `docs/09-integrations.md`.
-
-mod client;
-
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use async_trait::async_trait;
-use harness_core::lsp::{Diagnostic, DiagnosticsSource};
-
-use client::LspClient;
-
-/// One language server: which binary to run and which extensions it handles.
-#[derive(Debug, Clone)]
-pub struct ServerConfig {
-    pub name: String,
-    pub command: String,
-    pub args: Vec<String>,
-    pub extensions: Vec<String>,
-}
-
-/// Built-in servers, tried only when their binary exists on `PATH`.
-fn builtin_servers() -> Vec<ServerConfig> {
-    vec![
-        ServerConfig {
-            name: "rust".into(),
-            command: "rust-analyzer".into(),
-            args: vec![],
-            extensions: vec!["rs".into()],
-        },
-        ServerConfig {
-            name: "typescript".into(),
-            command: "typescript-language-server".into(),
-            args: vec!["--stdio".into()],
-            extensions: vec!["ts".into(), "tsx".into(), "js".into(), "jsx".into()],
-        },
-        ServerConfig {
-            name: "go".into(),
-            command: "gopls".into(),
-            args: vec![],
-            extensions: vec!["go".into()],
-        },
-        ServerConfig {
-            name: "python".into(),
-            command: "pyright-langserver".into(),
-            args: vec!["--stdio".into()],
-            extensions: vec!["py".into()],
-        },
-    ]
-}
-
-/// LSP `languageId` for a file extension (falls back to the extension itself).
-fn language_id_for_ext(ext: &str) -> &str {
-    match ext {
-        "rs" => "rust",
-        "ts" => "typescript",
-        "tsx" => "typescriptreact",
-        "js" => "javascript",
-        "jsx" => "javascriptreact",
-        "go" => "go",
-        "py" => "python",
-        other => other,
-    }
-}
-
-/// Returns true if `command` is an absolute existing file or resolvable on `PATH`.
-fn binary_exists(command: &str) -> bool {
-    let p = Path::new(command);
-    if p.is_absolute() {
-        return p.is_file();
-    }
-    let Some(paths) = std::env::var_os("PATH") else {
-        return false;
-    };
-    std::env::split_paths(&paths).any(|dir| dir.join(command).is_file())
-}
-
-enum Slot {
-    Ready(Arc<LspClient>),
-    Failed,
-}
-
-pub struct LspPool {
-    root: PathBuf,
-    servers: Vec<ServerConfig>,
-    /// One slot per server name; absent until first spawn attempt.
-    clients: tokio::sync::Mutex<HashMap<String, Slot>>,
-    /// Open documents → last-sent version, so `didChange` bumps monotonically.
-    open: Mutex<HashMap<PathBuf, i32>>,
-}
-
-impl LspPool {
-    /// Builds a pool: available built-ins plus any `config` servers (which override built-ins
-    /// by name; an empty command disables a built-in).
-    pub fn new(root: PathBuf, config: Vec<ServerConfig>) -> Self {
-        let mut by_name: HashMap<String, ServerConfig> = HashMap::new();
-        for server in builtin_servers() {
-            if binary_exists(&server.command) {
-                by_name.insert(server.name.clone(), server);
-            }
-        }
-        for server in config {
-            if server.command.is_empty() {
-                by_name.remove(&server.name);
-            } else {
-                by_name.insert(server.name.clone(), server);
-            }
-        }
-        Self {
-            root,
-            servers: by_name.into_values().collect(),
-            clients: tokio::sync::Mutex::new(HashMap::new()),
-            open: Mutex::new(HashMap::new()),
-        }
-    }
-
-    fn server_for(&self, path: &Path) -> Option<&ServerConfig> {
-        let ext = path.extension().and_then(|e| e.to_str())?;
-        self.servers
-            .iter()
-            .find(|s| s.extensions.iter().any(|e| e == ext))
-    }
-
-    /// Gets or lazily spawns the client for `server`. Caches a failure so we don't respawn a
-    /// broken server on every edit.
-    async fn client_for(&self, server: &ServerConfig) -> Option<Arc<LspClient>> {
-        let mut clients = self.clients.lock().await;
-        match clients.get(&server.name) {
-            Some(Slot::Ready(c)) => return Some(c.clone()),
-            Some(Slot::Failed) => return None,
-            None => {}
-        }
-        match LspClient::spawn(&server.command, &server.args, &self.root).await {
-            Ok(client) => {
-                let client = Arc::new(client);
-                clients.insert(server.name.clone(), Slot::Ready(client.clone()));
-                Some(client)
-            }
-            Err(e) => {
-                tracing::warn!(server = %server.name, error = %e, "LSP server failed to start");
-                clients.insert(server.name.clone(), Slot::Failed);
-                None
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl DiagnosticsSource for LspPool {
-    async fn touch(&self, path: &Path) {
-        let Some(server) = self.server_for(path).cloned() else {
-            return;
-        };
-        let Ok(text) = tokio::fs::read_to_string(path).await else {
-            return;
-        };
-        let Some(client) = self.client_for(&server).await else {
-            return;
-        };
-        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or_default();
-        let language_id = language_id_for_ext(ext);
-
-        let existing_version = {
-            let mut open = self.open.lock().unwrap();
-            match open.get_mut(path) {
-                Some(version) => {
-                    *version += 1;
-                    Some(*version)
-                }
-                None => {
-                    open.insert(path.to_path_buf(), 1);
-                    None
-                }
-            }
-        };
-
-        // Fresh diagnostics only reflect the current contents — drop any stale set first.
-        client.clear(path);
-        match existing_version {
-            None => client.did_open(path, language_id, 1, &text),
-            Some(version) => client.did_change(path, version, &text),
-        }
-    }
-
-    async fn diagnostics(&self, path: &Path, wait: Duration) -> Vec<Diagnostic> {
-        let Some(server) = self.server_for(path).cloned() else {
-            return Vec::new();
-        };
-        let Some(client) = self.client_for(&server).await else {
-            return Vec::new();
-        };
-        client.wait_diagnostics(path, wait).await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn language_ids_map_common_extensions() {
-        assert_eq!(language_id_for_ext("rs"), "rust");
-        assert_eq!(language_id_for_ext("tsx"), "typescriptreact");
-        assert_eq!(language_id_for_ext("unknown"), "unknown");
-    }
-
-    #[test]
-    fn config_server_overrides_builtin_by_name() {
-        let pool = LspPool::new(
-            std::env::temp_dir(),
-            vec![ServerConfig {
-                name: "rust".into(),
-                command: "my-custom-ra".into(),
-                args: vec!["--flag".into()],
-                extensions: vec!["rs".into()],
-            }],
-        );
-        let server = pool.server_for(Path::new("/x/a.rs")).unwrap();
-        assert_eq!(server.command, "my-custom-ra");
-    }
-
-    #[test]
-    fn no_server_for_unknown_extension() {
-        let pool = LspPool::new(std::env::temp_dir(), vec![]);
-        assert!(pool.server_for(Path::new("/x/a.zzz")).is_none());
-    }
-
-    #[test]
-    fn binary_exists_finds_a_known_tool() {
-        assert!(binary_exists("sh"));
-        assert!(!binary_exists("definitely-not-a-real-binary-xyz"));
-    }
-}
+// LSP client pool + diagnostics service land here in M5.

crates/harness-lsp/tests/rust_analyzer.rs

@@ -1,34 +0,0 @@
-//! End-to-end LSP test against a real `rust-analyzer`. Ignored by default (requires the binary
-//! on PATH and is slow — RA indexes the project). Run with:
-//!   cargo test -p harness-lsp --test rust_analyzer -- --ignored --nocapture
-
-use std::time::Duration;
-
-use harness_core::lsp::{DiagnosticsSource, Severity};
-use harness_lsp::LspPool;
-
-#[tokio::test]
-#[ignore = "requires rust-analyzer on PATH; slow"]
-async fn rust_analyzer_reports_a_type_error() {
-    // Minimal cargo project with a deliberate type error.
-    let dir = tempfile::tempdir().unwrap();
-    std::fs::write(
-        dir.path().join("Cargo.toml"),
-        "[package]\nname = \"probe\"\nversion = \"0.1.0\"\nedition = \"2021\"\n",
-    )
-    .unwrap();
-    std::fs::create_dir_all(dir.path().join("src")).unwrap();
-    let main_rs = dir.path().join("src/main.rs");
-    std::fs::write(&main_rs, "fn main() {\n    let x: i32 = \"not an integer\";\n    let _ = x;\n}\n").unwrap();
-
-    let pool = LspPool::new(dir.path().to_path_buf(), vec![]);
-    pool.touch(&main_rs).await;
-    // Generous wait: rust-analyzer must index the workspace before it reports anything.
-    let diags = pool.diagnostics(&main_rs, Duration::from_secs(60)).await;
-
-    println!("diagnostics: {diags:#?}");
-    assert!(
-        diags.iter().any(|d| d.severity == Severity::Error),
-        "expected at least one error diagnostic, got: {diags:?}"
-    );
-}

crates/harness-providers/Cargo.toml

@@ -18,11 +18,9 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-dirs = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["test-util", "macros"] }
-tempfile = { workspace = true }
 
 [lints]
 workspace = true

crates/harness-providers/assets/models-snapshot.json

@@ -1,67 +0,0 @@
-{
-  "anthropic": {
-    "id": "anthropic",
-    "name": "Anthropic",
-    "models": {
-      "claude-sonnet-4-5": {
-        "id": "claude-sonnet-4-5",
-        "reasoning": true,
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 3, "output": 15, "cache_read": 0.3, "cache_write": 3.75 },
-        "limit": { "context": 200000, "output": 64000 }
-      },
-      "claude-opus-4-1": {
-        "id": "claude-opus-4-1",
-        "reasoning": true,
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 15, "output": 75, "cache_read": 1.5, "cache_write": 18.75 },
-        "limit": { "context": 200000, "output": 32000 }
-      },
-      "claude-haiku-4-5": {
-        "id": "claude-haiku-4-5",
-        "reasoning": true,
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 1, "output": 5, "cache_read": 0.1, "cache_write": 1.25 },
-        "limit": { "context": 200000, "output": 64000 }
-      }
-    }
-  },
-  "openai": {
-    "id": "openai",
-    "name": "OpenAI",
-    "models": {
-      "gpt-4o": {
-        "id": "gpt-4o",
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 2.5, "output": 10, "cache_read": 1.25 },
-        "limit": { "context": 128000, "output": 16384 }
-      },
-      "gpt-4o-mini": {
-        "id": "gpt-4o-mini",
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 0.15, "output": 0.6, "cache_read": 0.075 },
-        "limit": { "context": 128000, "output": 16384 }
-      },
-      "gpt-5": {
-        "id": "gpt-5",
-        "reasoning": true,
-        "tool_call": true,
-        "attachment": true,
-        "cost": { "input": 1.25, "output": 10, "cache_read": 0.125 },
-        "limit": { "context": 400000, "output": 128000 }
-      },
-      "o3": {
-        "id": "o3",
-        "reasoning": true,
-        "tool_call": true,
-        "cost": { "input": 2, "output": 8, "cache_read": 0.5 },
-        "limit": { "context": 200000, "output": 100000 }
-      }
-    }
-  }
-}

crates/harness-providers/src/auth.rs

@@ -1,228 +0,0 @@
-//! Credential storage for providers that authenticate outside the config file.
-//!
-//! A single JSON file (`~/.local/share/ai-harness/auth.json`, mode `0600`) keyed by provider
-//! id. OAuth providers (Copilot) store the token triple and refresh it in place; API-key
-//! providers store the bare key. Config-supplied keys take precedence over this file — this
-//! is only for interactively-obtained credentials.
-
-use std::collections::HashMap;
-use std::io;
-use std::path::{Path, PathBuf};
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum AuthRecord {
-    /// OAuth credentials. `expires` is a unix-ms timestamp; `0` means the token never expires
-    /// (opencode's direct-Bearer Copilot mode).
-    OAuth {
-        access: String,
-        refresh: String,
-        expires: i64,
-    },
-    Api {
-        key: String,
-    },
-}
-
-impl AuthRecord {
-    /// True when an OAuth token is at or past `expires` (with a safety skew), given `now_ms`.
-    /// API keys and never-expiring OAuth tokens (`expires == 0`) are never considered expired.
-    pub fn is_expired(&self, now_ms: i64, skew_ms: i64) -> bool {
-        match self {
-            AuthRecord::OAuth { expires, .. } if *expires > 0 => now_ms + skew_ms >= *expires,
-            _ => false,
-        }
-    }
-}
-
-/// Read/modify/write access to the auth file. Cheap to construct; every operation reloads so
-/// concurrent writers (a refresh in one provider, a login in another) don't clobber each other.
-#[derive(Debug, Clone)]
-pub struct AuthStorage {
-    path: PathBuf,
-}
-
-impl AuthStorage {
-    pub fn new(path: PathBuf) -> Self {
-        Self { path }
-    }
-
-    /// `~/.local/share/ai-harness/auth.json` (falling back to the temp dir if there is no
-    /// data directory).
-    pub fn default_path() -> PathBuf {
-        dirs::data_dir()
-            .unwrap_or_else(std::env::temp_dir)
-            .join("ai-harness")
-            .join("auth.json")
-    }
-
-    pub fn with_default_path() -> Self {
-        Self::new(Self::default_path())
-    }
-
-    /// Loads all records. A missing file yields an empty map; a corrupt file is an error.
-    pub fn load(&self) -> io::Result<HashMap<String, AuthRecord>> {
-        match std::fs::read(&self.path) {
-            Ok(bytes) => serde_json::from_slice(&bytes)
-                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)),
-            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(HashMap::new()),
-            Err(e) => Err(e),
-        }
-    }
-
-    pub fn get(&self, provider: &str) -> io::Result<Option<AuthRecord>> {
-        Ok(self.load()?.remove(provider))
-    }
-
-    pub fn set(&self, provider: &str, record: AuthRecord) -> io::Result<()> {
-        let mut records = self.load()?;
-        records.insert(provider.to_string(), record);
-        self.write(&records)
-    }
-
-    pub fn remove(&self, provider: &str) -> io::Result<()> {
-        let mut records = self.load()?;
-        if records.remove(provider).is_some() {
-            self.write(&records)?;
-        }
-        Ok(())
-    }
-
-    /// Serializes `records` and writes them with `0600` permissions via a temp-file rename so
-    /// a partial write can never leave a truncated auth file behind.
-    fn write(&self, records: &HashMap<String, AuthRecord>) -> io::Result<()> {
-        if let Some(parent) = self.path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        let json = serde_json::to_vec_pretty(records)
-            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-
-        let tmp = self.path.with_extension("json.tmp");
-        std::fs::write(&tmp, &json)?;
-        set_owner_only(&tmp)?;
-        std::fs::rename(&tmp, &self.path)?;
-        Ok(())
-    }
-}
-
-#[cfg(unix)]
-fn set_owner_only(path: &Path) -> io::Result<()> {
-    use std::os::unix::fs::PermissionsExt;
-    std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600))
-}
-
-#[cfg(not(unix))]
-fn set_owner_only(_path: &Path) -> io::Result<()> {
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn storage() -> (tempfile::TempDir, AuthStorage) {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("nested").join("auth.json");
-        (dir, AuthStorage::new(path))
-    }
-
-    #[test]
-    fn missing_file_loads_empty() {
-        let (_dir, store) = storage();
-        assert!(store.load().unwrap().is_empty());
-        assert_eq!(store.get("anthropic").unwrap(), None);
-    }
-
-    #[test]
-    fn set_get_roundtrip_and_overwrite() {
-        let (_dir, store) = storage();
-        store
-            .set("anthropic", AuthRecord::Api { key: "k1".into() })
-            .unwrap();
-        assert_eq!(
-            store.get("anthropic").unwrap(),
-            Some(AuthRecord::Api { key: "k1".into() })
-        );
-
-        store
-            .set("anthropic", AuthRecord::Api { key: "k2".into() })
-            .unwrap();
-        assert_eq!(
-            store.get("anthropic").unwrap(),
-            Some(AuthRecord::Api { key: "k2".into() })
-        );
-    }
-
-    #[test]
-    fn multiple_providers_coexist() {
-        let (_dir, store) = storage();
-        store
-            .set("openai", AuthRecord::Api { key: "sk".into() })
-            .unwrap();
-        store
-            .set(
-                "github-copilot",
-                AuthRecord::OAuth {
-                    access: "a".into(),
-                    refresh: "r".into(),
-                    expires: 0,
-                },
-            )
-            .unwrap();
-        let all = store.load().unwrap();
-        assert_eq!(all.len(), 2);
-        assert!(all.contains_key("openai"));
-        assert!(all.contains_key("github-copilot"));
-    }
-
-    #[test]
-    fn remove_deletes_only_named_provider() {
-        let (_dir, store) = storage();
-        store
-            .set("openai", AuthRecord::Api { key: "sk".into() })
-            .unwrap();
-        store
-            .set("anthropic", AuthRecord::Api { key: "an".into() })
-            .unwrap();
-        store.remove("openai").unwrap();
-        assert_eq!(store.get("openai").unwrap(), None);
-        assert!(store.get("anthropic").unwrap().is_some());
-        // Removing an absent provider is a no-op, not an error.
-        store.remove("openai").unwrap();
-    }
-
-    #[test]
-    fn oauth_expiry_respects_skew_and_never_expires() {
-        let never = AuthRecord::OAuth {
-            access: "a".into(),
-            refresh: "r".into(),
-            expires: 0,
-        };
-        assert!(!never.is_expired(i64::MAX, 0));
-
-        let expiring = AuthRecord::OAuth {
-            access: "a".into(),
-            refresh: "r".into(),
-            expires: 1_000,
-        };
-        assert!(!expiring.is_expired(800, 120));
-        assert!(expiring.is_expired(880, 120)); // within skew window
-        assert!(expiring.is_expired(1_000, 0));
-
-        assert!(!AuthRecord::Api { key: "k".into() }.is_expired(i64::MAX, 0));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn file_is_written_owner_only() {
-        use std::os::unix::fs::PermissionsExt;
-        let (_dir, store) = storage();
-        store
-            .set("openai", AuthRecord::Api { key: "sk".into() })
-            .unwrap();
-        let mode = std::fs::metadata(&store.path).unwrap().permissions().mode();
-        assert_eq!(mode & 0o777, 0o600);
-    }
-}

crates/harness-providers/src/codec/mod.rs

@@ -1,3 +1 @@
 pub mod anthropic;
-pub mod openai_chat;
-pub mod openai_responses;

crates/harness-providers/src/codec/openai_chat.rs

@@ -1,502 +0,0 @@
-//! Request builder + SSE decoder for OpenAI's `/chat/completions` streaming API.
-//!
-//! Also used as the fallback codec for OpenAI-compatible endpoints (including Copilot models
-//! whose `supported_endpoints` list `/chat/completions`).
-
-use std::collections::HashMap;
-
-use async_stream::try_stream;
-use eventsource_stream::Eventsource;
-use futures::Stream;
-use harness_core::llm::{
-    FinishReason, LlmEvent, LlmEventStream, LlmRequest, ProviderError, ReasoningEffort, Role,
-    WireContent,
-};
-use harness_core::types::TokenUsage;
-use serde_json::{json, Value};
-
-fn effort_str(effort: ReasoningEffort) -> &'static str {
-    match effort {
-        ReasoningEffort::Low => "low",
-        ReasoningEffort::Medium => "medium",
-        ReasoningEffort::High => "high",
-    }
-}
-
-fn role_str(role: Role) -> &'static str {
-    match role {
-        Role::System => "system",
-        Role::User => "user",
-        Role::Assistant => "assistant",
-        Role::Tool => "tool",
-    }
-}
-
-/// Flattens our grouped `WireMessage`s into the flat chat-completions message list. Tool
-/// results become their own `role: "tool"` messages (one per result), which is what the API
-/// expects regardless of how the engine grouped them.
-fn build_messages(system: &[String], messages: &[harness_core::llm::WireMessage]) -> Vec<Value> {
-    let mut out: Vec<Value> = Vec::new();
-
-    if !system.is_empty() {
-        out.push(json!({"role": "system", "content": system.join("\n\n")}));
-    }
-
-    for m in messages {
-        // Tool results are always emitted as standalone `tool` messages.
-        for c in &m.content {
-            if let WireContent::ToolResult {
-                call_id, output, ..
-            } = c
-            {
-                out.push(json!({
-                    "role": "tool",
-                    "tool_call_id": call_id,
-                    "content": output,
-                }));
-            }
-        }
-
-        let mut text = String::new();
-        let mut images: Vec<Value> = Vec::new();
-        let mut tool_calls: Vec<Value> = Vec::new();
-        for c in &m.content {
-            match c {
-                WireContent::Text { text: t } => {
-                    if !text.is_empty() {
-                        text.push('\n');
-                    }
-                    text.push_str(t);
-                }
-                WireContent::ToolCall {
-                    call_id,
-                    name,
-                    input,
-                } => tool_calls.push(json!({
-                    "id": call_id,
-                    "type": "function",
-                    "function": {"name": name, "arguments": input.to_string()},
-                })),
-                WireContent::Image { mime_type, data } => images.push(json!({
-                    "type": "image_url",
-                    "image_url": {"url": format!("data:{mime_type};base64,{data}")},
-                })),
-                WireContent::ToolResult { .. } => {} // handled above
-            }
-        }
-
-        // A message that carried nothing but tool results contributes no further entry.
-        if text.is_empty() && images.is_empty() && tool_calls.is_empty() {
-            continue;
-        }
-
-        let mut msg = json!({"role": role_str(m.role)});
-        if images.is_empty() {
-            msg["content"] = json!(text);
-        } else {
-            let mut parts = vec![json!({"type": "text", "text": text})];
-            parts.extend(images);
-            msg["content"] = json!(parts);
-        }
-        if !tool_calls.is_empty() {
-            msg["tool_calls"] = json!(tool_calls);
-        }
-        out.push(msg);
-    }
-
-    out
-}
-
-pub fn build_request(req: &LlmRequest) -> Value {
-    let mut body = json!({
-        "model": req.model,
-        "messages": build_messages(&req.system, &req.messages),
-        "stream": true,
-        "stream_options": {"include_usage": true},
-    });
-
-    if !req.tools.is_empty() {
-        body["tools"] = Value::Array(
-            req.tools
-                .iter()
-                .map(|t| {
-                    json!({
-                        "type": "function",
-                        "function": {
-                            "name": t.name,
-                            "description": t.description,
-                            "parameters": t.parameters,
-                        },
-                    })
-                })
-                .collect(),
-        );
-    }
-    if let Some(temp) = req.temperature {
-        body["temperature"] = json!(temp);
-    }
-    if let Some(max) = req.max_tokens {
-        body["max_completion_tokens"] = json!(max);
-    }
-    if let Some(effort) = req.reasoning.as_ref().and_then(|r| r.effort) {
-        body["reasoning_effort"] = json!(effort_str(effort));
-    }
-    body
-}
-
-fn map_finish_reason(reason: &str) -> FinishReason {
-    match reason {
-        "stop" => FinishReason::Stop,
-        "tool_calls" | "function_call" => FinishReason::ToolCalls,
-        "length" => FinishReason::Length,
-        "content_filter" => FinishReason::ContentFilter,
-        other => FinishReason::Unknown(other.to_string()),
-    }
-}
-
-#[derive(Default)]
-struct ToolAccum {
-    call_id: String,
-    name: String,
-    args: String,
-}
-
-/// Decodes a chat-completions SSE byte stream into normalized `LlmEvent`s. Tool-call deltas
-/// are accumulated by their `index` and flushed as `ToolCall`s once the stream ends.
-pub fn decode<S, E>(byte_stream: S) -> LlmEventStream
-where
-    S: Stream<Item = Result<bytes::Bytes, E>> + Send + 'static,
-    E: std::error::Error + Send + Sync + 'static,
-{
-    let events = byte_stream.eventsource();
-    Box::pin(try_stream! {
-        futures::pin_mut!(events);
-        let mut usage = TokenUsage::default();
-        let mut reason = FinishReason::Stop;
-        let mut text_open = false;
-        let mut reasoning_open = false;
-        let mut tools: HashMap<u64, ToolAccum> = HashMap::new();
-        let mut tool_order: Vec<u64> = Vec::new();
-
-        while let Some(item) = futures::StreamExt::next(&mut events).await {
-            let event = item.map_err(|e| ProviderError::Decode(e.to_string()))?;
-            let data = event.data.trim();
-            if data.is_empty() {
-                continue;
-            }
-            if data == "[DONE]" {
-                break;
-            }
-            let value: Value = serde_json::from_str(data)
-                .map_err(|e| ProviderError::Decode(format!("{e}: {data}")))?;
-
-            if let Some(u) = value.get("usage").filter(|u| u.is_object()) {
-                usage.input = u["prompt_tokens"].as_u64().unwrap_or(usage.input);
-                usage.output = u["completion_tokens"].as_u64().unwrap_or(usage.output);
-                usage.reasoning = u["completion_tokens_details"]["reasoning_tokens"]
-                    .as_u64()
-                    .unwrap_or(usage.reasoning);
-                usage.cache_read = u["prompt_tokens_details"]["cached_tokens"]
-                    .as_u64()
-                    .unwrap_or(usage.cache_read);
-            }
-
-            let choice = &value["choices"][0];
-            let delta = &choice["delta"];
-
-            if let Some(rc) = delta["reasoning_content"].as_str().filter(|s| !s.is_empty()) {
-                if !reasoning_open {
-                    reasoning_open = true;
-                    yield LlmEvent::ReasoningStart { id: "reasoning".into() };
-                }
-                yield LlmEvent::ReasoningDelta { id: "reasoning".into(), text: rc.to_string() };
-            }
-
-            if let Some(text) = delta["content"].as_str().filter(|s| !s.is_empty()) {
-                if reasoning_open {
-                    reasoning_open = false;
-                    yield LlmEvent::ReasoningEnd { id: "reasoning".into(), signature: None };
-                }
-                if !text_open {
-                    text_open = true;
-                    yield LlmEvent::TextStart { id: "0".into() };
-                }
-                yield LlmEvent::TextDelta { id: "0".into(), text: text.to_string() };
-            }
-
-            if let Some(calls) = delta["tool_calls"].as_array() {
-                for call in calls {
-                    let index = call["index"].as_u64().unwrap_or(0);
-                    let entry = tools.entry(index).or_insert_with(|| {
-                        tool_order.push(index);
-                        ToolAccum::default()
-                    });
-                    if let Some(id) = call["id"].as_str().filter(|s| !s.is_empty()) {
-                        entry.call_id = id.to_string();
-                    }
-                    if let Some(name) = call["function"]["name"].as_str().filter(|s| !s.is_empty()) {
-                        entry.name = name.to_string();
-                        yield LlmEvent::ToolInputStart {
-                            call_id: entry.call_id.clone(),
-                            name: entry.name.clone(),
-                        };
-                    }
-                    if let Some(args) = call["function"]["arguments"].as_str().filter(|s| !s.is_empty()) {
-                        entry.args.push_str(args);
-                        yield LlmEvent::ToolInputDelta {
-                            call_id: entry.call_id.clone(),
-                            json: args.to_string(),
-                        };
-                    }
-                }
-            }
-
-            if let Some(fr) = choice["finish_reason"].as_str() {
-                reason = map_finish_reason(fr);
-            }
-        }
-
-        if reasoning_open {
-            yield LlmEvent::ReasoningEnd { id: "reasoning".into(), signature: None };
-        }
-        if text_open {
-            yield LlmEvent::TextEnd { id: "0".into() };
-        }
-        for index in tool_order {
-            if let Some(entry) = tools.remove(&index) {
-                let input: Value = if entry.args.trim().is_empty() {
-                    json!({})
-                } else {
-                    serde_json::from_str(&entry.args).unwrap_or(Value::Null)
-                };
-                yield LlmEvent::ToolCall { call_id: entry.call_id, name: entry.name, input };
-            }
-        }
-        yield LlmEvent::Finish { reason, usage };
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures::StreamExt;
-    use harness_core::llm::{Initiator, ReasoningOpts, ToolSchema, WireMessage};
-
-    fn sse_stream(raw: &'static str) -> LlmEventStream {
-        let chunks: Vec<Result<bytes::Bytes, std::io::Error>> =
-            vec![Ok(bytes::Bytes::from_static(raw.as_bytes()))];
-        decode(futures::stream::iter(chunks))
-    }
-
-    fn req(model: &str) -> LlmRequest {
-        LlmRequest {
-            model: model.into(),
-            system: vec![],
-            messages: vec![],
-            tools: vec![],
-            temperature: None,
-            max_tokens: None,
-            reasoning: None,
-            initiator: Initiator::User,
-        }
-    }
-
-    #[tokio::test]
-    async fn decodes_text_only_response() {
-        let raw = concat!(
-            "data: {\"choices\":[{\"delta\":{\"content\":\"Hel\"},\"finish_reason\":null}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{\"content\":\"lo\"},\"finish_reason\":null}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n",
-            "data: {\"choices\":[],\"usage\":{\"prompt_tokens\":10,\"completion_tokens\":5}}\n\n",
-            "data: [DONE]\n\n",
-        );
-        let events: Vec<LlmEvent> = sse_stream(raw).map(|e| e.unwrap()).collect().await;
-        assert_eq!(
-            events,
-            vec![
-                LlmEvent::TextStart { id: "0".into() },
-                LlmEvent::TextDelta {
-                    id: "0".into(),
-                    text: "Hel".into()
-                },
-                LlmEvent::TextDelta {
-                    id: "0".into(),
-                    text: "lo".into()
-                },
-                LlmEvent::TextEnd { id: "0".into() },
-                LlmEvent::Finish {
-                    reason: FinishReason::Stop,
-                    usage: TokenUsage {
-                        input: 10,
-                        output: 5,
-                        ..Default::default()
-                    },
-                },
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn decodes_tool_call_accumulated_by_index() {
-        let raw = concat!(
-            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"read\",\"arguments\":\"\"}}]}}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\\\"file\\\"\"}}]}}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\":\\\"a.txt\\\"}\"}}]}}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"tool_calls\"}],\"usage\":{\"prompt_tokens\":1,\"completion_tokens\":8}}\n\n",
-            "data: [DONE]\n\n",
-        );
-        let events: Vec<LlmEvent> = sse_stream(raw).map(|e| e.unwrap()).collect().await;
-        assert_eq!(
-            events,
-            vec![
-                LlmEvent::ToolInputStart {
-                    call_id: "call_1".into(),
-                    name: "read".into()
-                },
-                LlmEvent::ToolInputDelta {
-                    call_id: "call_1".into(),
-                    json: "{\"file\"".into()
-                },
-                LlmEvent::ToolInputDelta {
-                    call_id: "call_1".into(),
-                    json: ":\"a.txt\"}".into()
-                },
-                LlmEvent::ToolCall {
-                    call_id: "call_1".into(),
-                    name: "read".into(),
-                    input: json!({"file": "a.txt"}),
-                },
-                LlmEvent::Finish {
-                    reason: FinishReason::ToolCalls,
-                    usage: TokenUsage {
-                        input: 1,
-                        output: 8,
-                        ..Default::default()
-                    },
-                },
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn decodes_reasoning_content_before_text() {
-        let raw = concat!(
-            "data: {\"choices\":[{\"delta\":{\"reasoning_content\":\"hmm\"}}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{\"content\":\"answer\"}}]}\n\n",
-            "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n",
-            "data: [DONE]\n\n",
-        );
-        let events: Vec<LlmEvent> = sse_stream(raw).map(|e| e.unwrap()).collect().await;
-        assert_eq!(
-            events,
-            vec![
-                LlmEvent::ReasoningStart {
-                    id: "reasoning".into()
-                },
-                LlmEvent::ReasoningDelta {
-                    id: "reasoning".into(),
-                    text: "hmm".into()
-                },
-                LlmEvent::ReasoningEnd {
-                    id: "reasoning".into(),
-                    signature: None
-                },
-                LlmEvent::TextStart { id: "0".into() },
-                LlmEvent::TextDelta {
-                    id: "0".into(),
-                    text: "answer".into()
-                },
-                LlmEvent::TextEnd { id: "0".into() },
-                LlmEvent::Finish {
-                    reason: FinishReason::Stop,
-                    usage: TokenUsage::default()
-                },
-            ]
-        );
-    }
-
-    #[test]
-    fn build_request_wraps_tools_in_function_envelope() {
-        let mut r = req("gpt-4o");
-        r.tools = vec![ToolSchema {
-            name: "read".into(),
-            description: "reads a file".into(),
-            parameters: json!({"type": "object"}),
-        }];
-        let body = build_request(&r);
-        assert_eq!(body["tools"][0]["type"], "function");
-        assert_eq!(body["tools"][0]["function"]["name"], "read");
-        assert_eq!(
-            body["tools"][0]["function"]["parameters"],
-            json!({"type": "object"})
-        );
-        assert_eq!(body["stream_options"]["include_usage"], true);
-    }
-
-    #[test]
-    fn build_request_prepends_system_message() {
-        let mut r = req("gpt-4o");
-        r.system = vec!["env".into(), "agent".into()];
-        r.messages = vec![WireMessage {
-            role: Role::User,
-            content: vec![WireContent::Text { text: "hi".into() }],
-        }];
-        let body = build_request(&r);
-        let msgs = body["messages"].as_array().unwrap();
-        assert_eq!(msgs[0]["role"], "system");
-        assert_eq!(msgs[0]["content"], "env\n\nagent");
-        assert_eq!(msgs[1]["role"], "user");
-        assert_eq!(msgs[1]["content"], "hi");
-    }
-
-    #[test]
-    fn build_request_expands_tool_results_to_tool_messages() {
-        let mut r = req("gpt-4o");
-        r.messages = vec![WireMessage {
-            role: Role::Tool,
-            content: vec![WireContent::ToolResult {
-                call_id: "call_1".into(),
-                output: "contents".into(),
-                is_error: false,
-            }],
-        }];
-        let body = build_request(&r);
-        let msgs = body["messages"].as_array().unwrap();
-        assert_eq!(msgs.len(), 1);
-        assert_eq!(msgs[0]["role"], "tool");
-        assert_eq!(msgs[0]["tool_call_id"], "call_1");
-        assert_eq!(msgs[0]["content"], "contents");
-    }
-
-    #[test]
-    fn build_request_emits_assistant_tool_calls() {
-        let mut r = req("gpt-4o");
-        r.messages = vec![WireMessage {
-            role: Role::Assistant,
-            content: vec![WireContent::ToolCall {
-                call_id: "call_1".into(),
-                name: "read".into(),
-                input: json!({"file": "a.txt"}),
-            }],
-        }];
-        let body = build_request(&r);
-        let msgs = body["messages"].as_array().unwrap();
-        assert_eq!(msgs[0]["tool_calls"][0]["id"], "call_1");
-        assert_eq!(msgs[0]["tool_calls"][0]["function"]["name"], "read");
-        assert_eq!(
-            msgs[0]["tool_calls"][0]["function"]["arguments"],
-            "{\"file\":\"a.txt\"}"
-        );
-    }
-
-    #[test]
-    fn build_request_sets_reasoning_effort() {
-        let mut r = req("o3");
-        r.reasoning = Some(ReasoningOpts {
-            effort: Some(ReasoningEffort::High),
-            budget_tokens: None,
-        });
-        let body = build_request(&r);
-        assert_eq!(body["reasoning_effort"], "high");
-    }
-}

crates/harness-providers/src/codec/openai_responses.rs

@@ -1,402 +0,0 @@
-//! Request builder + SSE decoder for OpenAI's `/responses` streaming API.
-//!
-//! The responses API is the preferred surface for `gpt-*` / `o-*` models: it carries
-//! reasoning items natively and reports reasoning-token usage separately.
-
-use std::collections::HashMap;
-
-use async_stream::try_stream;
-use eventsource_stream::Eventsource;
-use futures::Stream;
-use harness_core::llm::{
-    FinishReason, LlmEvent, LlmEventStream, LlmRequest, ProviderError, ReasoningEffort, Role,
-    WireContent,
-};
-use harness_core::types::TokenUsage;
-use serde_json::{json, Value};
-
-fn effort_str(effort: ReasoningEffort) -> &'static str {
-    match effort {
-        ReasoningEffort::Low => "low",
-        ReasoningEffort::Medium => "medium",
-        ReasoningEffort::High => "high",
-    }
-}
-
-/// Builds the `input` item list. Text/image content become `message` items; tool calls and
-/// their results become `function_call` / `function_call_output` items (the responses API
-/// keeps these as top-level items rather than nesting them inside messages).
-fn build_input(messages: &[harness_core::llm::WireMessage]) -> Vec<Value> {
-    let mut out: Vec<Value> = Vec::new();
-    for m in messages {
-        let (role, text_type) = match m.role {
-            Role::Assistant => ("assistant", "output_text"),
-            _ => ("user", "input_text"),
-        };
-        let mut content_parts: Vec<Value> = Vec::new();
-        for c in &m.content {
-            match c {
-                WireContent::Text { text } => {
-                    content_parts.push(json!({"type": text_type, "text": text}));
-                }
-                WireContent::Image { mime_type, data } => {
-                    content_parts.push(json!({
-                        "type": "input_image",
-                        "image_url": format!("data:{mime_type};base64,{data}"),
-                    }));
-                }
-                WireContent::ToolCall {
-                    call_id,
-                    name,
-                    input,
-                } => out.push(json!({
-                    "type": "function_call",
-                    "call_id": call_id,
-                    "name": name,
-                    "arguments": input.to_string(),
-                })),
-                WireContent::ToolResult {
-                    call_id, output, ..
-                } => out.push(json!({
-                    "type": "function_call_output",
-                    "call_id": call_id,
-                    "output": output,
-                })),
-            }
-        }
-        if !content_parts.is_empty() {
-            out.push(json!({"type": "message", "role": role, "content": content_parts}));
-        }
-    }
-    out
-}
-
-pub fn build_request(req: &LlmRequest) -> Value {
-    let mut body = json!({
-        "model": req.model,
-        "input": build_input(&req.messages),
-        "stream": true,
-        "store": false,
-    });
-
-    if !req.system.is_empty() {
-        body["instructions"] = json!(req.system.join("\n\n"));
-    }
-    if !req.tools.is_empty() {
-        body["tools"] = Value::Array(
-            req.tools
-                .iter()
-                .map(|t| {
-                    json!({
-                        "type": "function",
-                        "name": t.name,
-                        "description": t.description,
-                        "parameters": t.parameters,
-                    })
-                })
-                .collect(),
-        );
-    }
-    if let Some(temp) = req.temperature {
-        body["temperature"] = json!(temp);
-    }
-    if let Some(max) = req.max_tokens {
-        body["max_output_tokens"] = json!(max);
-    }
-    if let Some(effort) = req.reasoning.as_ref().and_then(|r| r.effort) {
-        body["reasoning"] = json!({"effort": effort_str(effort), "summary": "auto"});
-    }
-    body
-}
-
-fn map_status(status: Option<&str>, had_tool_call: bool) -> FinishReason {
-    match status {
-        Some("completed") if had_tool_call => FinishReason::ToolCalls,
-        Some("completed") => FinishReason::Stop,
-        Some("incomplete") => FinishReason::Length,
-        Some(other) => FinishReason::Unknown(other.to_string()),
-        None if had_tool_call => FinishReason::ToolCalls,
-        None => FinishReason::Stop,
-    }
-}
-
-/// Tracks which normalized stream an `item_id` belongs to so deltas route correctly.
-enum ItemKind {
-    Text,
-    Reasoning,
-    FunctionCall { call_id: String, name: String },
-}
-
-/// Decodes a `/responses` SSE byte stream into normalized `LlmEvent`s.
-pub fn decode<S, E>(byte_stream: S) -> LlmEventStream
-where
-    S: Stream<Item = Result<bytes::Bytes, E>> + Send + 'static,
-    E: std::error::Error + Send + Sync + 'static,
-{
-    let events = byte_stream.eventsource();
-    Box::pin(try_stream! {
-        futures::pin_mut!(events);
-        let mut items: HashMap<String, ItemKind> = HashMap::new();
-        let mut fn_args: HashMap<String, String> = HashMap::new();
-        let mut usage = TokenUsage::default();
-        let mut had_tool_call = false;
-
-        while let Some(item) = futures::StreamExt::next(&mut events).await {
-            let event = item.map_err(|e| ProviderError::Decode(e.to_string()))?;
-            if event.data.trim().is_empty() {
-                continue;
-            }
-            let value: Value = serde_json::from_str(&event.data)
-                .map_err(|e| ProviderError::Decode(format!("{e}: {}", event.data)))?;
-            let kind = value["type"].as_str().unwrap_or_default();
-
-            match kind {
-                "response.output_item.added" => {
-                    let item = &value["item"];
-                    let id = item["id"].as_str().unwrap_or_default().to_string();
-                    match item["type"].as_str().unwrap_or_default() {
-                        "message" => {
-                            items.insert(id.clone(), ItemKind::Text);
-                            yield LlmEvent::TextStart { id };
-                        }
-                        "reasoning" => {
-                            items.insert(id.clone(), ItemKind::Reasoning);
-                            yield LlmEvent::ReasoningStart { id };
-                        }
-                        "function_call" => {
-                            let call_id = item["call_id"].as_str().unwrap_or_default().to_string();
-                            let name = item["name"].as_str().unwrap_or_default().to_string();
-                            fn_args.insert(id.clone(), String::new());
-                            items.insert(id, ItemKind::FunctionCall { call_id: call_id.clone(), name: name.clone() });
-                            had_tool_call = true;
-                            yield LlmEvent::ToolInputStart { call_id, name };
-                        }
-                        _ => {}
-                    }
-                }
-                "response.output_text.delta" => {
-                    let id = value["item_id"].as_str().unwrap_or_default().to_string();
-                    let text = value["delta"].as_str().unwrap_or_default().to_string();
-                    yield LlmEvent::TextDelta { id, text };
-                }
-                "response.reasoning_summary_text.delta" => {
-                    let id = value["item_id"].as_str().unwrap_or_default().to_string();
-                    let text = value["delta"].as_str().unwrap_or_default().to_string();
-                    yield LlmEvent::ReasoningDelta { id, text };
-                }
-                "response.function_call_arguments.delta" => {
-                    let id = value["item_id"].as_str().unwrap_or_default().to_string();
-                    let delta = value["delta"].as_str().unwrap_or_default();
-                    if let (Some(buf), Some(ItemKind::FunctionCall { call_id, .. })) =
-                        (fn_args.get_mut(&id), items.get(&id))
-                    {
-                        buf.push_str(delta);
-                        yield LlmEvent::ToolInputDelta { call_id: call_id.clone(), json: delta.to_string() };
-                    }
-                }
-                "response.output_item.done" => {
-                    let id = value["item"]["id"].as_str().unwrap_or_default().to_string();
-                    match items.remove(&id) {
-                        Some(ItemKind::Text) => yield LlmEvent::TextEnd { id },
-                        Some(ItemKind::Reasoning) => yield LlmEvent::ReasoningEnd { id, signature: None },
-                        Some(ItemKind::FunctionCall { call_id, name }) => {
-                            let raw = fn_args.remove(&id).unwrap_or_default();
-                            let input: Value = if raw.trim().is_empty() {
-                                json!({})
-                            } else {
-                                serde_json::from_str(&raw).unwrap_or(Value::Null)
-                            };
-                            yield LlmEvent::ToolCall { call_id, name, input };
-                        }
-                        None => {}
-                    }
-                }
-                "response.completed" | "response.incomplete" => {
-                    let response = &value["response"];
-                    let u = &response["usage"];
-                    usage.input = u["input_tokens"].as_u64().unwrap_or(0);
-                    usage.output = u["output_tokens"].as_u64().unwrap_or(0);
-                    usage.reasoning = u["output_tokens_details"]["reasoning_tokens"].as_u64().unwrap_or(0);
-                    usage.cache_read = u["input_tokens_details"]["cached_tokens"].as_u64().unwrap_or(0);
-                    let status = response["status"].as_str();
-                    yield LlmEvent::Finish { reason: map_status(status, had_tool_call), usage };
-                }
-                "error" | "response.failed" => {
-                    let message = value["response"]["error"]["message"]
-                        .as_str()
-                        .or_else(|| value["message"].as_str())
-                        .unwrap_or("unknown error")
-                        .to_string();
-                    Err(ProviderError::Http { status: 0, body: message })?;
-                }
-                _ => {}
-            }
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures::StreamExt;
-    use harness_core::llm::{Initiator, ReasoningOpts, ToolSchema, WireMessage};
-
-    fn sse_stream(raw: &'static str) -> LlmEventStream {
-        let chunks: Vec<Result<bytes::Bytes, std::io::Error>> =
-            vec![Ok(bytes::Bytes::from_static(raw.as_bytes()))];
-        decode(futures::stream::iter(chunks))
-    }
-
-    fn req(model: &str) -> LlmRequest {
-        LlmRequest {
-            model: model.into(),
-            system: vec![],
-            messages: vec![],
-            tools: vec![],
-            temperature: None,
-            max_tokens: None,
-            reasoning: None,
-            initiator: Initiator::User,
-        }
-    }
-
-    #[tokio::test]
-    async fn decodes_text_response() {
-        let raw = concat!(
-            "data: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"msg_1\",\"type\":\"message\"}}\n\n",
-            "data: {\"type\":\"response.output_text.delta\",\"item_id\":\"msg_1\",\"delta\":\"Hello\"}\n\n",
-            "data: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"msg_1\"}}\n\n",
-            "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"usage\":{\"input_tokens\":10,\"output_tokens\":5}}}\n\n",
-        );
-        let events: Vec<LlmEvent> = sse_stream(raw).map(|e| e.unwrap()).collect().await;
-        assert_eq!(
-            events,
-            vec![
-                LlmEvent::TextStart { id: "msg_1".into() },
-                LlmEvent::TextDelta {
-                    id: "msg_1".into(),
-                    text: "Hello".into()
-                },
-                LlmEvent::TextEnd { id: "msg_1".into() },
-                LlmEvent::Finish {
-                    reason: FinishReason::Stop,
-                    usage: TokenUsage {
-                        input: 10,
-                        output: 5,
-                        ..Default::default()
-                    },
-                },
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn decodes_function_call_with_reasoning_tokens() {
-        let raw = concat!(
-            "data: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"fc_1\",\"type\":\"function_call\",\"call_id\":\"call_1\",\"name\":\"read\"}}\n\n",
-            "data: {\"type\":\"response.function_call_arguments.delta\",\"item_id\":\"fc_1\",\"delta\":\"{\\\"file\\\":\"}\n\n",
-            "data: {\"type\":\"response.function_call_arguments.delta\",\"item_id\":\"fc_1\",\"delta\":\"\\\"a.txt\\\"}\"}\n\n",
-            "data: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"fc_1\"}}\n\n",
-            "data: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\",\"usage\":{\"input_tokens\":3,\"output_tokens\":9,\"output_tokens_details\":{\"reasoning_tokens\":4}}}}\n\n",
-        );
-        let events: Vec<LlmEvent> = sse_stream(raw).map(|e| e.unwrap()).collect().await;
-        assert_eq!(
-            events,
-            vec![
-                LlmEvent::ToolInputStart {
-                    call_id: "call_1".into(),
-                    name: "read".into()
-                },
-                LlmEvent::ToolInputDelta {
-                    call_id: "call_1".into(),
-                    json: "{\"file\":".into()
-                },
-                LlmEvent::ToolInputDelta {
-                    call_id: "call_1".into(),
-                    json: "\"a.txt\"}".into()
-                },
-                LlmEvent::ToolCall {
-                    call_id: "call_1".into(),
-                    name: "read".into(),
-                    input: json!({"file": "a.txt"}),
-                },
-                LlmEvent::Finish {
-                    reason: FinishReason::ToolCalls,
-                    usage: TokenUsage {
-                        input: 3,
-                        output: 9,
-                        reasoning: 4,
-                        ..Default::default()
-                    },
-                },
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn failed_response_surfaces_as_err() {
-        let raw = "data: {\"type\":\"response.failed\",\"response\":{\"error\":{\"message\":\"boom\"}}}\n\n";
-        let events: Vec<Result<LlmEvent, ProviderError>> = sse_stream(raw).collect().await;
-        assert!(
-            matches!(events.last(), Some(Err(ProviderError::Http { body, .. })) if body == "boom")
-        );
-    }
-
-    #[test]
-    fn build_request_puts_system_in_instructions() {
-        let mut r = req("gpt-5");
-        r.system = vec!["env".into(), "agent".into()];
-        let body = build_request(&r);
-        assert_eq!(body["instructions"], "env\n\nagent");
-        assert!(body.get("messages").is_none());
-    }
-
-    #[test]
-    fn build_request_flattens_tool_calls_and_results_to_items() {
-        let mut r = req("gpt-5");
-        r.messages = vec![
-            WireMessage {
-                role: Role::Assistant,
-                content: vec![WireContent::ToolCall {
-                    call_id: "call_1".into(),
-                    name: "read".into(),
-                    input: json!({"file": "a.txt"}),
-                }],
-            },
-            WireMessage {
-                role: Role::Tool,
-                content: vec![WireContent::ToolResult {
-                    call_id: "call_1".into(),
-                    output: "contents".into(),
-                    is_error: false,
-                }],
-            },
-        ];
-        let body = build_request(&r);
-        let input = body["input"].as_array().unwrap();
-        assert_eq!(input[0]["type"], "function_call");
-        assert_eq!(input[0]["call_id"], "call_1");
-        assert_eq!(input[0]["arguments"], "{\"file\":\"a.txt\"}");
-        assert_eq!(input[1]["type"], "function_call_output");
-        assert_eq!(input[1]["output"], "contents");
-    }
-
-    #[test]
-    fn build_request_uses_flat_function_tool_shape_and_reasoning() {
-        let mut r = req("o3");
-        r.tools = vec![ToolSchema {
-            name: "read".into(),
-            description: "reads a file".into(),
-            parameters: json!({"type": "object"}),
-        }];
-        r.reasoning = Some(ReasoningOpts {
-            effort: Some(ReasoningEffort::Medium),
-            budget_tokens: None,
-        });
-        let body = build_request(&r);
-        assert_eq!(body["tools"][0]["type"], "function");
-        assert_eq!(body["tools"][0]["name"], "read");
-        assert_eq!(body["reasoning"]["effort"], "medium");
-        assert_eq!(body["reasoning"]["summary"], "auto");
-    }
-}

crates/harness-providers/src/copilot/device_flow.rs

@@ -1,209 +0,0 @@
-//! GitHub OAuth device flow (RFC 8628) for Copilot login.
-//!
-//! ai-harness must register its own GitHub OAuth app and supply its client id (we do not
-//! hardcode opencode's). The client id is passed in by the caller — see [`request_device_code`].
-
-use std::time::Duration;
-
-use serde::Deserialize;
-use serde_json::Value;
-
-const DEVICE_CODE_URL: &str = "https://github.com/login/device/code";
-const ACCESS_TOKEN_URL: &str = "https://github.com/login/oauth/access_token";
-const GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";
-/// Minimum scope needed to call the Copilot token-exchange endpoint.
-pub const SCOPE: &str = "read:user";
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct DeviceCode {
-    pub device_code: String,
-    pub user_code: String,
-    pub verification_uri: String,
-    /// Seconds between polls; GitHub requires honoring this and any `slow_down` bumps.
-    #[serde(default = "default_interval")]
-    pub interval: u64,
-    #[serde(default)]
-    pub expires_in: u64,
-}
-
-fn default_interval() -> u64 {
-    5
-}
-
-/// Result of one poll of the access-token endpoint.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PollOutcome {
-    /// The user hasn't authorized yet; keep polling at the current interval.
-    Pending,
-    /// GitHub asked us to slow down; add 5s to the interval (RFC 8628).
-    SlowDown,
-    /// Authorization complete.
-    Success { access_token: String },
-    /// Terminal failure (expired code, denied, unknown error) with a human-readable reason.
-    Failed(String),
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum DeviceFlowError {
-    #[error("network: {0}")]
-    Network(String),
-    #[error("unexpected response: {0}")]
-    Unexpected(String),
-}
-
-/// Pure mapping of an access-token poll response body to a [`PollOutcome`], so the state
-/// machine is testable without a live GitHub.
-pub fn parse_poll_response(body: &Value) -> PollOutcome {
-    if let Some(token) = body["access_token"].as_str() {
-        return PollOutcome::Success {
-            access_token: token.to_string(),
-        };
-    }
-    match body["error"].as_str() {
-        Some("authorization_pending") => PollOutcome::Pending,
-        Some("slow_down") => PollOutcome::SlowDown,
-        Some(other) => {
-            let desc = body["error_description"].as_str().unwrap_or(other);
-            PollOutcome::Failed(desc.to_string())
-        }
-        None => PollOutcome::Failed("no access_token and no error in response".to_string()),
-    }
-}
-
-/// Applies a `slow_down` to a poll interval per RFC 8628 (+5s).
-pub fn bump_interval(interval: u64) -> u64 {
-    interval + 5
-}
-
-/// Step 1: request a device + user code for `client_id`.
-pub async fn request_device_code(
-    client: &reqwest::Client,
-    client_id: &str,
-) -> Result<DeviceCode, DeviceFlowError> {
-    let resp = client
-        .post(DEVICE_CODE_URL)
-        .header("accept", "application/json")
-        .json(&serde_json::json!({"client_id": client_id, "scope": SCOPE}))
-        .send()
-        .await
-        .map_err(|e| DeviceFlowError::Network(e.to_string()))?;
-    let value: Value = resp
-        .json()
-        .await
-        .map_err(|e| DeviceFlowError::Network(e.to_string()))?;
-    serde_json::from_value(value.clone())
-        .map_err(|_| DeviceFlowError::Unexpected(value.to_string()))
-}
-
-/// Step 2 (single poll): exchange the device code for an access token, once.
-pub async fn poll_once(
-    client: &reqwest::Client,
-    client_id: &str,
-    device_code: &str,
-) -> Result<PollOutcome, DeviceFlowError> {
-    let resp = client
-        .post(ACCESS_TOKEN_URL)
-        .header("accept", "application/json")
-        .json(&serde_json::json!({
-            "client_id": client_id,
-            "device_code": device_code,
-            "grant_type": GRANT_TYPE,
-        }))
-        .send()
-        .await
-        .map_err(|e| DeviceFlowError::Network(e.to_string()))?;
-    let value: Value = resp
-        .json()
-        .await
-        .map_err(|e| DeviceFlowError::Network(e.to_string()))?;
-    Ok(parse_poll_response(&value))
-}
-
-/// Step 2 (full loop): polls until success or terminal failure, honoring `interval` and
-/// `slow_down`. `sleep` is injected so tests can drive it without real time.
-pub async fn poll_for_token<S, Fut>(
-    client: &reqwest::Client,
-    client_id: &str,
-    device: &DeviceCode,
-    sleep: S,
-) -> Result<String, DeviceFlowError>
-where
-    S: Fn(Duration) -> Fut,
-    Fut: std::future::Future<Output = ()>,
-{
-    let mut interval = device.interval;
-    loop {
-        sleep(Duration::from_secs(interval)).await;
-        match poll_once(client, client_id, &device.device_code).await? {
-            PollOutcome::Pending => {}
-            PollOutcome::SlowDown => interval = bump_interval(interval),
-            PollOutcome::Success { access_token } => return Ok(access_token),
-            PollOutcome::Failed(reason) => return Err(DeviceFlowError::Unexpected(reason)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn parses_success() {
-        let outcome =
-            parse_poll_response(&json!({"access_token": "gho_abc", "token_type": "bearer"}));
-        assert_eq!(
-            outcome,
-            PollOutcome::Success {
-                access_token: "gho_abc".into()
-            }
-        );
-    }
-
-    #[test]
-    fn parses_pending_and_slow_down() {
-        assert_eq!(
-            parse_poll_response(&json!({"error": "authorization_pending"})),
-            PollOutcome::Pending
-        );
-        assert_eq!(
-            parse_poll_response(&json!({"error": "slow_down", "interval": 10})),
-            PollOutcome::SlowDown
-        );
-    }
-
-    #[test]
-    fn parses_terminal_errors_with_description() {
-        match parse_poll_response(
-            &json!({"error": "expired_token", "error_description": "code expired"}),
-        ) {
-            PollOutcome::Failed(msg) => assert_eq!(msg, "code expired"),
-            other => panic!("expected Failed, got {other:?}"),
-        }
-        assert!(matches!(
-            parse_poll_response(&json!({"error": "access_denied"})),
-            PollOutcome::Failed(_)
-        ));
-        assert!(matches!(
-            parse_poll_response(&json!({})),
-            PollOutcome::Failed(_)
-        ));
-    }
-
-    #[test]
-    fn slow_down_adds_five_seconds() {
-        assert_eq!(bump_interval(5), 10);
-        assert_eq!(bump_interval(10), 15);
-    }
-
-    #[test]
-    fn device_code_defaults_interval() {
-        let dc: DeviceCode = serde_json::from_value(json!({
-            "device_code": "d",
-            "user_code": "WXYZ-1234",
-            "verification_uri": "https://github.com/login/device"
-        }))
-        .unwrap();
-        assert_eq!(dc.interval, 5);
-    }
-}

crates/harness-providers/src/copilot/mod.rs

@@ -1,10 +0,0 @@
-//! GitHub Copilot: OAuth device-flow login, token exchange, and a provider that multiplexes
-//! the chat/responses/anthropic codecs behind `api.githubcopilot.com`.
-
-pub mod device_flow;
-pub mod provider;
-pub mod token;
-
-pub use device_flow::{DeviceCode, PollOutcome};
-pub use provider::{CopilotCodec, CopilotModel, CopilotProvider};
-pub use token::{CopilotToken, TokenProvider};

crates/harness-providers/src/copilot/provider.rs

@@ -1,296 +0,0 @@
-//! Copilot provider: multiplexes all three wire codecs behind `api.githubcopilot.com`.
-//!
-//! Each model's `supported_endpoints` (from `GET /models`) decides which codec/endpoint to
-//! use. The token comes from [`super::token::TokenProvider`]. Network paths here are the
-//! flagged live-verification risk — the routing/header logic is unit-tested; end-to-end
-//! streaming must be checked against the live API.
-
-use std::collections::HashMap;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use async_trait::async_trait;
-use harness_core::llm::{
-    Initiator, LlmEventStream, LlmRequest, Provider, ProviderError, WireContent,
-};
-use harness_core::types::ModelInfo;
-use serde_json::Value;
-use tokio_util::sync::CancellationToken;
-
-use crate::codec::{anthropic, openai_chat, openai_responses};
-
-use super::token::TokenProvider;
-
-pub const DEFAULT_BASE_URL: &str = "https://api.githubcopilot.com";
-const API_VERSION: &str = "2026-06-01";
-const ANTHROPIC_BETA: &str = "interleaved-thinking-2025-05-14";
-const USER_AGENT: &str = concat!("ai-harness/", env!("CARGO_PKG_VERSION"));
-
-/// Which wire codec a Copilot model speaks.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CopilotCodec {
-    Chat,
-    Responses,
-    Anthropic,
-}
-
-impl CopilotCodec {
-    fn path(self) -> &'static str {
-        match self {
-            CopilotCodec::Chat => "/chat/completions",
-            CopilotCodec::Responses => "/responses",
-            CopilotCodec::Anthropic => "/v1/messages",
-        }
-    }
-
-    fn build_request(self, req: &LlmRequest) -> Value {
-        match self {
-            CopilotCodec::Chat => openai_chat::build_request(req),
-            CopilotCodec::Responses => openai_responses::build_request(req),
-            CopilotCodec::Anthropic => anthropic::build_request(req),
-        }
-    }
-
-    fn decode(
-        self,
-        stream: impl futures::Stream<Item = reqwest::Result<bytes::Bytes>> + Send + 'static,
-    ) -> LlmEventStream {
-        match self {
-            CopilotCodec::Chat => openai_chat::decode(stream),
-            CopilotCodec::Responses => openai_responses::decode(stream),
-            CopilotCodec::Anthropic => anthropic::decode(stream),
-        }
-    }
-}
-
-/// A single model as advertised by `GET /models`.
-#[derive(Debug, Clone)]
-pub struct CopilotModel {
-    pub id: String,
-    pub codec: CopilotCodec,
-    /// Only `model_picker_enabled` models are offered in the UI picker.
-    pub picker_enabled: bool,
-}
-
-/// Picks a codec from a model's `supported_endpoints`, preferring the responses API, then the
-/// Anthropic messages API, then chat completions.
-pub fn codec_for_endpoints(endpoints: &[String]) -> CopilotCodec {
-    let has = |needle: &str| endpoints.iter().any(|e| e.contains(needle));
-    if has("/responses") {
-        CopilotCodec::Responses
-    } else if has("/v1/messages") || has("/messages") {
-        CopilotCodec::Anthropic
-    } else {
-        CopilotCodec::Chat
-    }
-}
-
-/// Parses a Copilot `GET /models` response body.
-pub fn parse_models(body: &Value) -> Vec<CopilotModel> {
-    body["data"]
-        .as_array()
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|m| {
-                    let id = m["id"].as_str()?.to_string();
-                    let endpoints: Vec<String> = m["supported_endpoints"]
-                        .as_array()
-                        .map(|a| {
-                            a.iter()
-                                .filter_map(|e| e.as_str().map(String::from))
-                                .collect()
-                        })
-                        .unwrap_or_default();
-                    Some(CopilotModel {
-                        id,
-                        codec: codec_for_endpoints(&endpoints),
-                        picker_enabled: m["model_picker_enabled"].as_bool().unwrap_or(false),
-                    })
-                })
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
-fn has_images(req: &LlmRequest) -> bool {
-    req.messages
-        .iter()
-        .flat_map(|m| &m.content)
-        .any(|c| matches!(c, WireContent::Image { .. }))
-}
-
-fn initiator_header(initiator: Initiator) -> &'static str {
-    match initiator {
-        Initiator::User => "user",
-        Initiator::Agent => "agent",
-    }
-}
-
-pub struct CopilotProvider {
-    tokens: TokenProvider,
-    base_url: String,
-    client: reqwest::Client,
-    /// model id → codec, from `GET /models`. Unknown models default to chat completions.
-    codecs: HashMap<String, CopilotCodec>,
-}
-
-impl CopilotProvider {
-    pub fn new(oauth_token: impl Into<String>, models: Vec<CopilotModel>) -> Self {
-        Self::with_base_url(oauth_token, DEFAULT_BASE_URL, models)
-    }
-
-    pub fn with_base_url(
-        oauth_token: impl Into<String>,
-        base_url: impl Into<String>,
-        models: Vec<CopilotModel>,
-    ) -> Self {
-        let client = reqwest::Client::new();
-        let codecs = models.into_iter().map(|m| (m.id, m.codec)).collect();
-        Self {
-            tokens: TokenProvider::new(oauth_token, client.clone()),
-            base_url: base_url.into(),
-            client,
-            codecs,
-        }
-    }
-
-    fn codec_for(&self, model: &str) -> CopilotCodec {
-        self.codecs
-            .get(model)
-            .copied()
-            .unwrap_or(CopilotCodec::Chat)
-    }
-
-    fn classify_error(status: reqwest::StatusCode, body: String) -> ProviderError {
-        match status.as_u16() {
-            401 | 403 => ProviderError::Auth(body),
-            429 => ProviderError::RateLimited { retry_after: None },
-            s if (500..600).contains(&s) => ProviderError::Overloaded,
-            s => ProviderError::Http { status: s, body },
-        }
-    }
-}
-
-#[async_trait]
-impl Provider for CopilotProvider {
-    fn id(&self) -> &str {
-        "github-copilot"
-    }
-
-    async fn list_models(&self) -> Result<Vec<ModelInfo>, ProviderError> {
-        // Cost/limit metadata is layered on by models.dev; routing metadata lives in `codecs`.
-        Ok(Vec::new())
-    }
-
-    async fn stream(
-        &self,
-        req: LlmRequest,
-        cancel: CancellationToken,
-    ) -> Result<LlmEventStream, ProviderError> {
-        let codec = self.codec_for(&req.model);
-        let body = codec.build_request(&req);
-        let url = format!("{}{}", self.base_url, codec.path());
-
-        let now_secs = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs() as i64;
-        let token = self.tokens.token(now_secs).await;
-
-        let mut builder = self
-            .client
-            .post(&url)
-            .header("authorization", format!("Bearer {}", token.token))
-            .header("user-agent", USER_AGENT)
-            .header("x-github-api-version", API_VERSION)
-            .header("openai-intent", "conversation-edits")
-            .header("x-initiator", initiator_header(req.initiator));
-        if has_images(&req) {
-            builder = builder.header("copilot-vision-request", "true");
-        }
-        if codec == CopilotCodec::Anthropic {
-            builder = builder.header("anthropic-beta", ANTHROPIC_BETA);
-        }
-
-        let send = builder.json(&body).send();
-        let response = tokio::select! {
-            result = send => result.map_err(|e| ProviderError::Network(e.to_string()))?,
-            _ = cancel.cancelled() => return Err(ProviderError::Cancelled),
-        };
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let body = response.text().await.unwrap_or_default();
-            return Err(Self::classify_error(status, body));
-        }
-
-        Ok(codec.decode(response.bytes_stream()))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn codec_routing_prefers_responses_then_anthropic_then_chat() {
-        assert_eq!(
-            codec_for_endpoints(&["/chat/completions".into(), "/responses".into()]),
-            CopilotCodec::Responses
-        );
-        assert_eq!(
-            codec_for_endpoints(&["/v1/messages".into()]),
-            CopilotCodec::Anthropic
-        );
-        assert_eq!(
-            codec_for_endpoints(&["/chat/completions".into()]),
-            CopilotCodec::Chat
-        );
-        assert_eq!(codec_for_endpoints(&[]), CopilotCodec::Chat);
-    }
-
-    #[test]
-    fn parses_models_with_endpoints_and_picker_flag() {
-        let body = json!({
-            "data": [
-                {"id": "gpt-4o", "supported_endpoints": ["/chat/completions"], "model_picker_enabled": true},
-                {"id": "claude-sonnet-4-5", "supported_endpoints": ["/v1/messages"], "model_picker_enabled": true},
-                {"id": "o3", "supported_endpoints": ["/responses"], "model_picker_enabled": false},
-                {"id": "no-endpoints"}
-            ]
-        });
-        let models = parse_models(&body);
-        assert_eq!(models.len(), 4);
-        assert_eq!(models[0].codec, CopilotCodec::Chat);
-        assert!(models[0].picker_enabled);
-        assert_eq!(models[1].codec, CopilotCodec::Anthropic);
-        assert_eq!(models[2].codec, CopilotCodec::Responses);
-        assert!(!models[2].picker_enabled);
-        // Missing supported_endpoints → default chat, picker false.
-        assert_eq!(models[3].codec, CopilotCodec::Chat);
-        assert!(!models[3].picker_enabled);
-    }
-
-    #[test]
-    fn unknown_model_defaults_to_chat_codec() {
-        let provider = CopilotProvider::new("oauth", vec![]);
-        assert_eq!(provider.codec_for("whatever"), CopilotCodec::Chat);
-        assert_eq!(provider.id(), "github-copilot");
-    }
-
-    #[test]
-    fn known_model_uses_mapped_codec() {
-        let provider = CopilotProvider::new(
-            "oauth",
-            vec![CopilotModel {
-                id: "claude-sonnet-4-5".into(),
-                codec: CopilotCodec::Anthropic,
-                picker_enabled: true,
-            }],
-        );
-        assert_eq!(
-            provider.codec_for("claude-sonnet-4-5"),
-            CopilotCodec::Anthropic
-        );
-    }
-}

crates/harness-providers/src/copilot/token.rs

@@ -1,144 +0,0 @@
-//! Copilot API token strategy (flagged-risk area — verify against the live API).
-//!
-//! opencode sends the GitHub OAuth token directly as the Bearer (`expires: 0`). The classic
-//! Copilot API instead wants a short-lived token from `copilot_internal/v2/token`. We try the
-//! exchange first and cache it until shortly before expiry; if the endpoint rejects us, we fall
-//! back to the direct-Bearer behavior. Refresh is single-flight under a `tokio::Mutex`.
-
-use serde::Deserialize;
-use tokio::sync::Mutex;
-
-const EXCHANGE_URL: &str = "https://api.github.com/copilot_internal/v2/token";
-/// Refresh this many seconds before the reported expiry.
-const EXPIRY_SKEW_SECS: i64 = 120;
-const USER_AGENT: &str = concat!("ai-harness/", env!("CARGO_PKG_VERSION"));
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CopilotToken {
-    pub token: String,
-    /// Unix seconds; `0` means "never expires" (direct-Bearer fallback).
-    pub expires_at: i64,
-}
-
-impl CopilotToken {
-    /// True when the token should be refreshed at `now_secs` (never, for `expires_at == 0`).
-    pub fn needs_refresh(&self, now_secs: i64) -> bool {
-        self.expires_at != 0 && now_secs + EXPIRY_SKEW_SECS >= self.expires_at
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum TokenError {
-    #[error("network: {0}")]
-    Network(String),
-    /// The exchange endpoint is unavailable/unauthorized — the caller should fall back to the
-    /// direct-Bearer strategy.
-    #[error("exchange unsupported (status {0})")]
-    ExchangeUnsupported(u16),
-    #[error("unexpected response: {0}")]
-    Unexpected(String),
-}
-
-#[derive(Deserialize)]
-struct ExchangeResponse {
-    token: String,
-    #[serde(default)]
-    expires_at: i64,
-}
-
-/// Performs the token exchange once. `ExchangeUnsupported` signals the caller to fall back.
-pub async fn exchange(
-    client: &reqwest::Client,
-    oauth_token: &str,
-) -> Result<CopilotToken, TokenError> {
-    let resp = client
-        .get(EXCHANGE_URL)
-        .header("authorization", format!("token {oauth_token}"))
-        .header("accept", "application/json")
-        .header("user-agent", USER_AGENT)
-        .send()
-        .await
-        .map_err(|e| TokenError::Network(e.to_string()))?;
-
-    let status = resp.status();
-    if !status.is_success() {
-        // 401/403/404 → this deployment doesn't support the exchange; fall back to direct Bearer.
-        if matches!(status.as_u16(), 401 | 403 | 404) {
-            return Err(TokenError::ExchangeUnsupported(status.as_u16()));
-        }
-        return Err(TokenError::Network(format!("status {}", status.as_u16())));
-    }
-
-    let parsed: ExchangeResponse = resp
-        .json()
-        .await
-        .map_err(|e| TokenError::Unexpected(e.to_string()))?;
-    Ok(CopilotToken {
-        token: parsed.token,
-        expires_at: parsed.expires_at,
-    })
-}
-
-/// Caches the exchanged Copilot token and refreshes it single-flight. Falls back to using the
-/// OAuth token directly (never-expiring) when the exchange endpoint rejects the request.
-pub struct TokenProvider {
-    oauth_token: String,
-    client: reqwest::Client,
-    cached: Mutex<Option<CopilotToken>>,
-}
-
-impl TokenProvider {
-    pub fn new(oauth_token: impl Into<String>, client: reqwest::Client) -> Self {
-        Self {
-            oauth_token: oauth_token.into(),
-            client,
-            cached: Mutex::new(None),
-        }
-    }
-
-    /// Returns a usable Bearer token, refreshing/exchanging as needed. `now_secs` is injected
-    /// for testability.
-    pub async fn token(&self, now_secs: i64) -> CopilotToken {
-        let mut guard = self.cached.lock().await;
-        if let Some(tok) = guard.as_ref() {
-            if !tok.needs_refresh(now_secs) {
-                return tok.clone();
-            }
-        }
-        let fresh = match exchange(&self.client, &self.oauth_token).await {
-            Ok(tok) => tok,
-            Err(_) => CopilotToken {
-                // Direct-Bearer fallback: use the OAuth token itself, never expiring.
-                token: self.oauth_token.clone(),
-                expires_at: 0,
-            },
-        };
-        *guard = Some(fresh.clone());
-        fresh
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn never_expiring_token_does_not_refresh() {
-        let tok = CopilotToken {
-            token: "t".into(),
-            expires_at: 0,
-        };
-        assert!(!tok.needs_refresh(i64::MAX));
-    }
-
-    #[test]
-    fn refresh_triggers_within_skew_window() {
-        let tok = CopilotToken {
-            token: "t".into(),
-            expires_at: 1_000,
-        };
-        assert!(!tok.needs_refresh(800)); // 800 + 120 < 1000
-        assert!(tok.needs_refresh(881)); // 881 + 120 >= 1000
-        assert!(tok.needs_refresh(1_000));
-    }
-}

crates/harness-providers/src/lib.rs

@@ -1,14 +1,6 @@
 pub mod anthropic;
-pub mod auth;
 pub mod codec;
-pub mod copilot;
-pub mod modelsdev;
-pub mod openai;
 pub mod registry;
 
 pub use anthropic::AnthropicProvider;
-pub use auth::{AuthRecord, AuthStorage};
-pub use copilot::CopilotProvider;
-pub use modelsdev::ModelCatalog;
-pub use openai::OpenAiProvider;
 pub use registry::ProviderRegistry;

crates/harness-providers/src/modelsdev.rs

@@ -1,296 +0,0 @@
-//! models.dev metadata: per-model context/output limits, pricing, and capability flags.
-//!
-//! At runtime we prefer a cached copy of `https://models.dev/api.json` (refreshed every 24h);
-//! if the cache is missing/stale and the network is unavailable, we fall back to a baked
-//! snapshot so cost display and limits still work offline.
-
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::time::{Duration, SystemTime};
-
-use harness_core::types::{ModelCost, ModelInfo, ModelRef};
-use serde::Deserialize;
-
-const API_URL: &str = "https://models.dev/api.json";
-const CACHE_TTL: Duration = Duration::from_secs(24 * 60 * 60);
-/// Baked fallback, refreshed manually. Keeps cost/limits working with no cache and no network.
-const SNAPSHOT: &str = include_str!("../assets/models-snapshot.json");
-
-/// models.dev top-level shape: `{ provider_id: { models: { model_id: {...} } } }`. Unknown
-/// keys (provider metadata, per-model extras) are ignored.
-#[derive(Deserialize)]
-struct ApiProvider {
-    #[serde(default)]
-    models: HashMap<String, ApiModel>,
-}
-
-#[derive(Deserialize)]
-struct ApiModel {
-    #[serde(default)]
-    reasoning: bool,
-    #[serde(default)]
-    tool_call: bool,
-    #[serde(default)]
-    attachment: bool,
-    #[serde(default)]
-    cost: ApiCost,
-    #[serde(default)]
-    limit: ApiLimit,
-}
-
-#[derive(Deserialize, Default)]
-struct ApiCost {
-    #[serde(default)]
-    input: f64,
-    #[serde(default)]
-    output: f64,
-    #[serde(default)]
-    cache_read: f64,
-    #[serde(default)]
-    cache_write: f64,
-}
-
-#[derive(Deserialize, Default)]
-struct ApiLimit {
-    #[serde(default)]
-    context: u64,
-    #[serde(default)]
-    output: u64,
-}
-
-/// Parsed metadata keyed by `(provider_id, model_id)`.
-#[derive(Debug, Clone, Default)]
-pub struct ModelCatalog {
-    models: HashMap<(String, String), ModelInfo>,
-}
-
-impl ModelCatalog {
-    /// Parses a models.dev `api.json` document.
-    pub fn from_api_json(bytes: &[u8]) -> Result<Self, serde_json::Error> {
-        let raw: HashMap<String, ApiProvider> = serde_json::from_slice(bytes)?;
-        let mut models = HashMap::new();
-        for (provider_id, provider) in raw {
-            for (model_id, m) in provider.models {
-                let info = ModelInfo {
-                    model: ModelRef::new(provider_id.clone(), model_id.clone()),
-                    context_limit: m.limit.context,
-                    output_limit: m.limit.output,
-                    cost: ModelCost {
-                        input: m.cost.input,
-                        output: m.cost.output,
-                        cache_read: m.cost.cache_read,
-                        cache_write: m.cost.cache_write,
-                    },
-                    reasoning: m.reasoning,
-                    tool_call: m.tool_call,
-                    attachment: m.attachment,
-                };
-                models.insert((provider_id.clone(), model_id), info);
-            }
-        }
-        Ok(Self { models })
-    }
-
-    /// The baked fallback snapshot — always available, never fails.
-    pub fn baked() -> Self {
-        Self::from_api_json(SNAPSHOT.as_bytes()).expect("baked models snapshot must parse")
-    }
-
-    pub fn get(&self, provider: &str, model: &str) -> Option<&ModelInfo> {
-        self.models.get(&(provider.to_string(), model.to_string()))
-    }
-
-    /// Pricing for a model, or zero-cost if unknown.
-    pub fn cost(&self, provider: &str, model: &str) -> ModelCost {
-        self.get(provider, model)
-            .map(|m| m.cost)
-            .unwrap_or_default()
-    }
-
-    pub fn len(&self) -> usize {
-        self.models.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.models.is_empty()
-    }
-
-    /// Default cache location: `~/.cache/ai-harness/models.json`.
-    pub fn default_cache_path() -> PathBuf {
-        dirs::cache_dir()
-            .unwrap_or_else(std::env::temp_dir)
-            .join("ai-harness")
-            .join("models.json")
-    }
-
-    /// Loads from the cache if present and younger than [`CACHE_TTL`]; otherwise returns the
-    /// baked snapshot. Never touches the network — call [`ModelCatalog::refresh`] for that.
-    pub fn load_cached_or_baked(cache_path: &Path) -> Self {
-        if cache_fresh(cache_path, CACHE_TTL, SystemTime::now()) {
-            if let Ok(bytes) = std::fs::read(cache_path) {
-                if let Ok(catalog) = Self::from_api_json(&bytes) {
-                    if !catalog.is_empty() {
-                        return catalog;
-                    }
-                }
-            }
-        }
-        Self::baked()
-    }
-
-    /// Refreshes the default cache location with a fresh HTTP client. Convenience wrapper for
-    /// callers (the app) that don't want to depend on `reqwest` directly.
-    pub async fn refresh_default_cache() -> Result<Self, RefreshError> {
-        let client = reqwest::Client::new();
-        Self::refresh(&client, &Self::default_cache_path()).await
-    }
-
-    /// Fetches the latest metadata and writes it to `cache_path` (best-effort). Returns the
-    /// freshly-parsed catalog. Intended to run in the background so the *next* launch is current.
-    pub async fn refresh(
-        client: &reqwest::Client,
-        cache_path: &Path,
-    ) -> Result<Self, RefreshError> {
-        let bytes = client
-            .get(API_URL)
-            .send()
-            .await
-            .map_err(|e| RefreshError::Network(e.to_string()))?
-            .error_for_status()
-            .map_err(|e| RefreshError::Network(e.to_string()))?
-            .bytes()
-            .await
-            .map_err(|e| RefreshError::Network(e.to_string()))?;
-
-        let catalog =
-            Self::from_api_json(&bytes).map_err(|e| RefreshError::Parse(e.to_string()))?;
-
-        if let Some(parent) = cache_path.parent() {
-            let _ = std::fs::create_dir_all(parent);
-        }
-        if let Err(e) = std::fs::write(cache_path, &bytes) {
-            tracing::warn!(error = %e, "failed to cache models.dev metadata");
-        }
-        Ok(catalog)
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum RefreshError {
-    #[error("network: {0}")]
-    Network(String),
-    #[error("parse: {0}")]
-    Parse(String),
-}
-
-/// True when `path` exists and was modified within `ttl` of `now`.
-fn cache_fresh(path: &Path, ttl: Duration, now: SystemTime) -> bool {
-    let Ok(modified) = std::fs::metadata(path).and_then(|m| m.modified()) else {
-        return false;
-    };
-    match now.duration_since(modified) {
-        Ok(age) => age < ttl,
-        Err(_) => true, // modified in the future (clock skew) — treat as fresh
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const FIXTURE: &str = r#"{
-        "anthropic": {
-            "id": "anthropic",
-            "name": "Anthropic",
-            "models": {
-                "claude-sonnet-4-5": {
-                    "id": "claude-sonnet-4-5",
-                    "reasoning": true,
-                    "tool_call": true,
-                    "attachment": true,
-                    "cost": {"input": 3, "output": 15, "cache_read": 0.3, "cache_write": 3.75},
-                    "limit": {"context": 200000, "output": 64000}
-                }
-            }
-        },
-        "openai": {
-            "id": "openai",
-            "models": {
-                "gpt-4o": {
-                    "id": "gpt-4o",
-                    "tool_call": true,
-                    "cost": {"input": 2.5, "output": 10},
-                    "limit": {"context": 128000, "output": 16384}
-                }
-            }
-        }
-    }"#;
-
-    #[test]
-    fn parses_providers_and_models() {
-        let catalog = ModelCatalog::from_api_json(FIXTURE.as_bytes()).unwrap();
-        assert_eq!(catalog.len(), 2);
-
-        let sonnet = catalog.get("anthropic", "claude-sonnet-4-5").unwrap();
-        assert_eq!(sonnet.context_limit, 200_000);
-        assert_eq!(sonnet.output_limit, 64_000);
-        assert_eq!(sonnet.cost.input, 3.0);
-        assert_eq!(sonnet.cost.cache_write, 3.75);
-        assert!(sonnet.reasoning && sonnet.tool_call && sonnet.attachment);
-    }
-
-    #[test]
-    fn missing_cost_fields_default_to_zero() {
-        let catalog = ModelCatalog::from_api_json(FIXTURE.as_bytes()).unwrap();
-        let gpt = catalog.get("openai", "gpt-4o").unwrap();
-        assert_eq!(gpt.cost.cache_read, 0.0);
-        assert_eq!(gpt.cost.cache_write, 0.0);
-        assert!(!gpt.reasoning); // absent → false
-        assert!(gpt.tool_call);
-    }
-
-    #[test]
-    fn cost_helper_is_zero_for_unknown_model() {
-        let catalog = ModelCatalog::from_api_json(FIXTURE.as_bytes()).unwrap();
-        assert_eq!(catalog.cost("openai", "nonexistent"), ModelCost::default());
-        assert_eq!(catalog.cost("anthropic", "claude-sonnet-4-5").input, 3.0);
-    }
-
-    #[test]
-    fn baked_snapshot_parses_and_is_nonempty() {
-        let catalog = ModelCatalog::baked();
-        assert!(!catalog.is_empty());
-    }
-
-    #[test]
-    fn cache_freshness_respects_ttl() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("models.json");
-        assert!(!cache_fresh(&path, CACHE_TTL, SystemTime::now())); // missing
-
-        std::fs::write(&path, "{}").unwrap();
-        let now = SystemTime::now();
-        assert!(cache_fresh(&path, CACHE_TTL, now));
-        // A "now" far in the future makes the file look stale.
-        let future = now + Duration::from_secs(48 * 60 * 60);
-        assert!(!cache_fresh(&path, CACHE_TTL, future));
-    }
-
-    #[test]
-    fn load_cached_or_baked_falls_back_when_cache_absent() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("models.json");
-        let catalog = ModelCatalog::load_cached_or_baked(&path);
-        assert!(!catalog.is_empty()); // baked fallback
-    }
-
-    #[test]
-    fn load_cached_or_baked_reads_fresh_cache() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join("models.json");
-        std::fs::write(&path, FIXTURE).unwrap();
-        let catalog = ModelCatalog::load_cached_or_baked(&path);
-        assert_eq!(catalog.len(), 2);
-        assert!(catalog.get("anthropic", "claude-sonnet-4-5").is_some());
-    }
-}

crates/harness-providers/src/openai.rs

@@ -1,220 +0,0 @@
-use std::time::Duration;
-
-use async_trait::async_trait;
-use harness_core::llm::{LlmEventStream, LlmRequest, Provider, ProviderError};
-use harness_core::types::ModelInfo;
-use tokio_util::sync::CancellationToken;
-
-use crate::codec::{openai_chat, openai_responses};
-
-const DEFAULT_BASE_URL: &str = "https://api.openai.com/v1";
-/// OpenCode Zen's OpenAI-compatible gateway (chat-completions only).
-const OPENCODE_BASE_URL: &str = "https://opencode.ai/zen/v1";
-
-/// Which OpenAI wire format to speak for a given model.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ApiFlavor {
-    Responses,
-    Chat,
-}
-
-/// `gpt-*` and `o-*` models use the responses API; everything else (including
-/// OpenAI-compatible third-party endpoints) falls back to chat completions.
-fn flavor_for(model: &str) -> ApiFlavor {
-    let is_native = model.starts_with("gpt-")
-        || model.starts_with("o1")
-        || model.starts_with("o3")
-        || model.starts_with("o4")
-        || model == "o1"
-        || model == "o3";
-    if is_native {
-        ApiFlavor::Responses
-    } else {
-        ApiFlavor::Chat
-    }
-}
-
-pub struct OpenAiProvider {
-    id: String,
-    api_key: String,
-    base_url: String,
-    /// When set, always speak chat-completions regardless of model name — required for
-    /// OpenAI-compatible gateways (e.g. OpenCode Zen) that don't implement `/responses`.
-    chat_only: bool,
-    client: reqwest::Client,
-}
-
-impl OpenAiProvider {
-    pub fn new(api_key: impl Into<String>) -> Self {
-        Self {
-            id: "openai".to_string(),
-            api_key: api_key.into(),
-            base_url: DEFAULT_BASE_URL.to_string(),
-            chat_only: false,
-            client: reqwest::Client::new(),
-        }
-    }
-
-    pub fn with_base_url(api_key: impl Into<String>, base_url: impl Into<String>) -> Self {
-        Self {
-            id: "openai".to_string(),
-            api_key: api_key.into(),
-            base_url: base_url.into(),
-            chat_only: false,
-            client: reqwest::Client::new(),
-        }
-    }
-
-    /// An OpenCode Zen provider: id `opencode`, chat-completions only, defaulting to Zen's
-    /// gateway. Pass `base_url = None` to use the default endpoint.
-    pub fn opencode(api_key: impl Into<String>, base_url: Option<String>) -> Self {
-        Self {
-            id: "opencode".to_string(),
-            api_key: api_key.into(),
-            base_url: base_url.unwrap_or_else(|| OPENCODE_BASE_URL.to_string()),
-            chat_only: true,
-            client: reqwest::Client::new(),
-        }
-    }
-
-    /// The wire format for `model`, honoring `chat_only`.
-    fn flavor(&self, model: &str) -> ApiFlavor {
-        if self.chat_only {
-            ApiFlavor::Chat
-        } else {
-            flavor_for(model)
-        }
-    }
-
-    fn classify_error(
-        status: reqwest::StatusCode,
-        body: String,
-        retry_after: Option<Duration>,
-    ) -> ProviderError {
-        match status.as_u16() {
-            400 if body.contains("context_length_exceeded")
-                || body.contains("maximum context length") =>
-            {
-                ProviderError::ContextOverflow
-            }
-            401 | 403 => ProviderError::Auth(body),
-            429 => ProviderError::RateLimited { retry_after },
-            s if (500..600).contains(&s) => ProviderError::Overloaded,
-            s => ProviderError::Http { status: s, body },
-        }
-    }
-}
-
-#[async_trait]
-impl Provider for OpenAiProvider {
-    fn id(&self) -> &str {
-        &self.id
-    }
-
-    async fn list_models(&self) -> Result<Vec<ModelInfo>, ProviderError> {
-        // models.dev metadata is layered on top by the caller (see `modelsdev.rs`).
-        Ok(Vec::new())
-    }
-
-    async fn stream(
-        &self,
-        req: LlmRequest,
-        cancel: CancellationToken,
-    ) -> Result<LlmEventStream, ProviderError> {
-        let (path, body) = match self.flavor(&req.model) {
-            ApiFlavor::Responses => ("/responses", openai_responses::build_request(&req)),
-            ApiFlavor::Chat => ("/chat/completions", openai_chat::build_request(&req)),
-        };
-        let url = format!("{}{}", self.base_url, path);
-
-        let send = self
-            .client
-            .post(&url)
-            .header("authorization", format!("Bearer {}", self.api_key))
-            .json(&body)
-            .send();
-
-        let response = tokio::select! {
-            result = send => result.map_err(|e| ProviderError::Network(e.to_string()))?,
-            _ = cancel.cancelled() => return Err(ProviderError::Cancelled),
-        };
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let retry_after = response
-                .headers()
-                .get("retry-after")
-                .and_then(|v| v.to_str().ok())
-                .and_then(|s| s.parse::<u64>().ok())
-                .map(Duration::from_secs);
-            let body = response.text().await.unwrap_or_default();
-            return Err(Self::classify_error(status, body, retry_after));
-        }
-
-        Ok(match self.flavor(&req.model) {
-            ApiFlavor::Responses => openai_responses::decode(response.bytes_stream()),
-            ApiFlavor::Chat => openai_chat::decode(response.bytes_stream()),
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn routes_gpt_and_o_series_to_responses() {
-        assert_eq!(flavor_for("gpt-4o"), ApiFlavor::Responses);
-        assert_eq!(flavor_for("gpt-5"), ApiFlavor::Responses);
-        assert_eq!(flavor_for("o1"), ApiFlavor::Responses);
-        assert_eq!(flavor_for("o3-mini"), ApiFlavor::Responses);
-        assert_eq!(flavor_for("o4-mini"), ApiFlavor::Responses);
-    }
-
-    #[test]
-    fn routes_other_models_to_chat() {
-        assert_eq!(flavor_for("llama-3.1-70b"), ApiFlavor::Chat);
-        assert_eq!(flavor_for("deepseek-chat"), ApiFlavor::Chat);
-    }
-
-    #[test]
-    fn id_is_openai() {
-        assert_eq!(OpenAiProvider::new("k").id(), "openai");
-    }
-
-    #[test]
-    fn opencode_provider_is_chat_only_and_ids_as_opencode() {
-        let p = OpenAiProvider::opencode("k", None);
-        assert_eq!(p.id(), "opencode");
-        assert_eq!(p.base_url, OPENCODE_BASE_URL);
-        // Even a gpt-*/o* model must route to chat completions on a chat-only gateway.
-        assert_eq!(p.flavor("gpt-5.5"), ApiFlavor::Chat);
-        assert_eq!(p.flavor("claude-sonnet-5"), ApiFlavor::Chat);
-    }
-
-    #[test]
-    fn opencode_honors_custom_base_url() {
-        let p = OpenAiProvider::opencode("k", Some("https://example.test/v1".into()));
-        assert_eq!(p.base_url, "https://example.test/v1");
-    }
-
-    #[test]
-    fn classifies_context_overflow_from_400_body() {
-        assert!(matches!(
-            OpenAiProvider::classify_error(
-                reqwest::StatusCode::BAD_REQUEST,
-                "context_length_exceeded".into(),
-                None,
-            ),
-            ProviderError::ContextOverflow
-        ));
-        assert!(matches!(
-            OpenAiProvider::classify_error(
-                reqwest::StatusCode::BAD_REQUEST,
-                "some other error".into(),
-                None,
-            ),
-            ProviderError::Http { status: 400, .. }
-        ));
-    }
-}

crates/harness-tools/src/bash.rs

@@ -149,9 +149,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tools/src/diagnostics.rs

@@ -1,68 +0,0 @@
-//! Shared LSP-diagnostics reporting for the edit/write tools. After a file is written we ask
-//! the (optional) diagnostics source to re-analyze it and append any error-severity items to
-//! the tool output so the model sees mistakes it just introduced. Best-effort: no source, a
-//! slow server, or a timeout all just mean "no diagnostics" — never a tool failure.
-
-use std::path::Path;
-use std::time::Duration;
-
-use harness_core::lsp::Severity;
-use harness_core::tool::{ToolCtx, ToolOutput};
-
-/// docs/09-integrations.md: wait up to 1.5s for the server to (re)publish after the change.
-const DIAGNOSTICS_WAIT: Duration = Duration::from_millis(1500);
-
-/// Touches `path` in the language server and appends error-severity diagnostics to `output`
-/// (both as a human-readable block in the text and the full set in metadata under `diagnostics`).
-pub async fn append_diagnostics(ctx: &ToolCtx, path: &Path, display_name: &str, output: &mut ToolOutput) {
-    let Some(source) = &ctx.diagnostics else {
-        return;
-    };
-    source.touch(path).await;
-    let diagnostics = source.diagnostics(path, DIAGNOSTICS_WAIT).await;
-    if diagnostics.is_empty() {
-        return;
-    }
-
-    let errors: Vec<_> = diagnostics
-        .iter()
-        .filter(|d| d.severity == Severity::Error)
-        .collect();
-    if !errors.is_empty() {
-        output
-            .output
-            .push_str("\n\nLSP errors detected in this file, please fix:");
-        for diag in &errors {
-            output.output.push('\n');
-            output.output.push_str(&diag.display_line(display_name));
-        }
-    }
-
-    // Full set (all severities) into metadata for the TUI.
-    let items: Vec<serde_json::Value> = diagnostics
-        .iter()
-        .map(|d| {
-            serde_json::json!({
-                "line": d.line,
-                "character": d.character,
-                "severity": severity_str(d.severity),
-                "message": d.message,
-                "source": d.source,
-            })
-        })
-        .collect();
-    if let serde_json::Value::Object(map) = &mut output.metadata {
-        map.insert("diagnostics".into(), serde_json::Value::Array(items));
-    } else {
-        output.metadata = serde_json::json!({ "diagnostics": items });
-    }
-}
-
-fn severity_str(severity: Severity) -> &'static str {
-    match severity {
-        Severity::Error => "error",
-        Severity::Warning => "warning",
-        Severity::Info => "info",
-        Severity::Hint => "hint",
-    }
-}

crates/harness-tools/src/edit/mod.rs

@@ -196,9 +196,8 @@ impl Tool for EditTool {
             .map_err(|e| ToolError::Other(format!("{}: {e}", path.display())))?;
 
         let (added, removed) = diff_stats(&content_old, &content_new);
-        let mut output = ToolOutput::new(pattern.clone(), "Edit applied successfully.".to_string());
+        let mut output = ToolOutput::new(pattern, "Edit applied successfully.".to_string());
         output.metadata = serde_json::json!({"diff": diff, "added": added, "removed": removed});
-        crate::diagnostics::append_diagnostics(&ctx, &path, &pattern, &mut output).await;
         Ok(output)
     }
 }
@@ -233,9 +232,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tools/src/glob.rs

@@ -130,9 +130,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tools/src/grep.rs

@@ -159,9 +159,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tools/src/lib.rs

@@ -1,11 +1,9 @@
 mod bash;
-mod diagnostics;
 mod edit;
 mod glob;
 mod grep;
 mod paths;
 mod read;
-mod task;
 mod write;
 
 pub use bash::BashTool;
@@ -13,7 +11,6 @@ pub use edit::EditTool;
 pub use glob::GlobTool;
 pub use grep::GrepTool;
 pub use read::ReadTool;
-pub use task::TaskTool;
 pub use write::WriteTool;
 
 use std::sync::Arc;
@@ -29,10 +26,3 @@ pub fn register_builtins(registry: &mut ToolRegistry) {
     registry.register(Arc::new(GlobTool));
     registry.register(Arc::new(GrepTool));
 }
-
-/// Registers the multiagent `task` tool (M4). Kept separate from [`register_builtins`] so
-/// non-orchestrating contexts can omit delegation; the tool no-ops with an error if the
-/// session has no spawner wired in.
-pub fn register_task_tool(registry: &mut ToolRegistry) {
-    registry.register(Arc::new(TaskTool));
-}

crates/harness-tools/src/read.rs

@@ -102,13 +102,6 @@ impl Tool for ReadTool {
                 "(empty file or offset past end)".to_string(),
             ));
         }
-
-        // In a subagent session, advertise this read on the job board.
-        if let Some(reporter) = &ctx.context_reporter {
-            let reported = paths::relative_pattern(&ctx.cwd, &path);
-            reporter.report_file(reported, numbered.len() as u32).await;
-        }
-
         Ok(ToolOutput::new(
             params.file_path.clone(),
             numbered.join("\n"),
@@ -146,9 +139,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tools/src/task.rs

@@ -1,140 +0,0 @@
-//! The `task` tool: delegate work to a specialist subagent, foreground or background.
-//!
-//! This tool is deliberately thin — it validates input, gates on a `task/<agent>` permission,
-//! and hands off to the engine's `SubagentSpawner` (owned by the composition root), which
-//! resolves the agent, enforces the depth limit, applies permission intersection, and runs
-//! the child session. See `docs/04-multiagent.md`.
-
-use async_trait::async_trait;
-use serde::Deserialize;
-use serde_json::json;
-
-use harness_core::tool::{
-    invalid_input, SpawnError, SpawnRequest, Tool, ToolCtx, ToolError, ToolOutput,
-};
-
-#[derive(Debug, Deserialize)]
-struct TaskInput {
-    /// Short human-facing label for the subtask (shown on the job board).
-    description: String,
-    /// The full instruction handed to the subagent.
-    prompt: String,
-    /// Which specialist to run (must be a subagent-capable agent).
-    subagent_type: String,
-    /// Alias or task id of a completed job to continue instead of starting fresh.
-    #[serde(default)]
-    task_id: Option<String>,
-    /// Run in the background and return immediately (tracked on the job board).
-    #[serde(default)]
-    background: bool,
-}
-
-pub struct TaskTool;
-
-#[async_trait]
-impl Tool for TaskTool {
-    fn name(&self) -> &str {
-        "task"
-    }
-
-    fn description(&self) -> &str {
-        "Delegate a self-contained unit of work to a specialist subagent. Set `background: \
-         true` to launch it without blocking (track progress on the job board); reuse a \
-         completed subagent by passing its `task_id`/alias to continue the same session."
-    }
-
-    fn parameters(&self) -> serde_json::Value {
-        json!({
-            "type": "object",
-            "properties": {
-                "description": { "type": "string", "description": "Short label for the subtask." },
-                "prompt": { "type": "string", "description": "Full instruction for the subagent." },
-                "subagent_type": { "type": "string", "description": "Specialist to run." },
-                "task_id": { "type": "string", "description": "Alias/id of a completed job to reuse." },
-                "background": { "type": "boolean", "description": "Launch without blocking." }
-            },
-            "required": ["description", "prompt", "subagent_type"]
-        })
-    }
-
-    async fn execute(
-        &self,
-        input: serde_json::Value,
-        ctx: ToolCtx,
-    ) -> Result<ToolOutput, ToolError> {
-        let args: TaskInput = serde_json::from_value(input).map_err(|e| invalid_input(self, e))?;
-
-        let Some(spawner) = ctx.spawner.clone() else {
-            return Err(ToolError::Other(
-                "subagent delegation is not available in this session".into(),
-            ));
-        };
-
-        // Gate on task/<agent>. `Always` grants blanket delegation to this specialist.
-        ctx.ask
-            .ask(
-                "task",
-                &args.subagent_type,
-                &args.subagent_type,
-                json!({
-                    "agent": args.subagent_type,
-                    "description": args.description,
-                    "background": args.background,
-                }),
-            )
-            .await?;
-
-        let req = SpawnRequest {
-            parent_session_id: ctx.session_id.clone(),
-            parent_message_id: ctx.message_id.clone(),
-            agent: args.subagent_type.clone(),
-            description: args.description.clone(),
-            prompt: args.prompt,
-            reuse_task_id: args.task_id,
-            background: args.background,
-            cancel: ctx.cancel.clone(),
-        };
-
-        let outcome = spawner.spawn(req).await.map_err(map_spawn_error)?;
-
-        if outcome.background {
-            let alias = outcome.alias.unwrap_or_default();
-            Ok(ToolOutput {
-                title: format!("launched {} ({alias})", args.subagent_type),
-                output: format!(
-                    "Launched background task {alias} ({}). Check the job board; do not poll — \
-                     wait for completion.",
-                    outcome.child_session_id
-                ),
-                metadata: json!({
-                    "child_session": outcome.child_session_id,
-                    "agent": args.subagent_type,
-                    "alias": alias,
-                    "background": true,
-                }),
-            })
-        } else {
-            let text = outcome.final_text.unwrap_or_default();
-            Ok(ToolOutput {
-                title: format!("{} — {}", args.subagent_type, args.description),
-                output: text,
-                metadata: json!({
-                    "child_session": outcome.child_session_id,
-                    "agent": args.subagent_type,
-                    "background": false,
-                }),
-            })
-        }
-    }
-}
-
-fn map_spawn_error(err: SpawnError) -> ToolError {
-    match err {
-        // Depth/agent problems are the model's to fix — surface as tool errors it can read
-        // and act on, not hard failures.
-        SpawnError::DepthExceeded => ToolError::Other(err.to_string()),
-        SpawnError::InvalidAgent(_) => ToolError::Invalid(err.to_string()),
-        SpawnError::ReuseNotFound(_) => ToolError::Invalid(err.to_string()),
-        SpawnError::Other(msg) => ToolError::Other(msg),
-    }
-}

crates/harness-tools/src/write.rs

@@ -80,7 +80,6 @@ impl Tool for WriteTool {
             format!("wrote {} bytes", params.content.len()),
         );
         output.metadata = serde_json::json!({"diff": diff, "added": added, "removed": removed});
-        crate::diagnostics::append_diagnostics(&ctx, &path, &params.file_path, &mut output).await;
         Ok(output)
     }
 }
@@ -115,9 +114,6 @@ mod tests {
                 CancellationToken::new(),
             ),
             metadata,
-            spawner: None,
-            context_reporter: None,
-            diagnostics: None,
         }
     }
 

crates/harness-tui/src/input.rs

@@ -23,10 +23,6 @@ pub enum InputAction {
     SessionPickerUp,
     SessionPickerDown,
     SessionPickerSelect,
-    OpenJobs,
-    JobsUp,
-    JobsDown,
-    JobsDrillIn,
 }
 
 /// Translate a crossterm event into an action and/or mutate `state` directly.
@@ -53,21 +49,10 @@ fn handle_key(key: KeyEvent, state: &mut AppState) -> InputAction {
     match &state.modal {
         ModalState::Permission { .. } => handle_permission_key(key, state),
         ModalState::SessionPicker { .. } => handle_session_picker_key(key, state),
-        ModalState::JobsPane { .. } => handle_jobs_pane_key(key, state),
         ModalState::None => handle_normal_key(key, state),
     }
 }
 
-fn handle_jobs_pane_key(key: KeyEvent, _state: &mut AppState) -> InputAction {
-    match key.code {
-        KeyCode::Up => InputAction::JobsUp,
-        KeyCode::Down => InputAction::JobsDown,
-        KeyCode::Enter => InputAction::JobsDrillIn,
-        KeyCode::Esc => InputAction::CloseModal,
-        _ => InputAction::None,
-    }
-}
-
 fn handle_permission_key(key: KeyEvent, _state: &mut AppState) -> InputAction {
     match key.code {
         KeyCode::Char('y') | KeyCode::Char('Y') => {
@@ -134,7 +119,6 @@ fn handle_normal_key(key: KeyEvent, state: &mut AppState) -> InputAction {
             }
         }
         KeyCode::Char('s') if ctrl => InputAction::LoadSessions,
-        KeyCode::Char('j') if ctrl => InputAction::OpenJobs,
         KeyCode::Up => {
             let (row, _) = state.input.cursor();
             if row == 0 {
@@ -174,7 +158,6 @@ fn parse_slash_command(text: &str) -> Option<InputAction> {
         "/model" if !rest.is_empty() => Some(InputAction::SetModel(rest)),
         "/agent" if !rest.is_empty() => Some(InputAction::SetAgent(rest)),
         "/sessions" => Some(InputAction::LoadSessions),
-        "/jobs" => Some(InputAction::OpenJobs),
         "/quit" => Some(InputAction::Quit),
         _ => None,
     }
@@ -204,8 +187,6 @@ pub async fn apply_action(action: InputAction, state: &mut AppState, engine: &En
                 state.session_id = Some(id);
                 state.messages.clear();
                 state.scroll_offset = 0;
-                state.session_cost = 0.0;
-                state.session_tokens = 0;
                 state.dirty = true;
             }
             Err(e) => tracing::error!(error = %e, "failed to create session"),
@@ -252,45 +233,6 @@ pub async fn apply_action(action: InputAction, state: &mut AppState, engine: &En
                 }
             }
         }
-        InputAction::OpenJobs => {
-            if let Some(session_id) = state.session_id.clone() {
-                match engine.jobs(session_id).await {
-                    Ok(jobs) => {
-                        state.set_jobs(jobs);
-                        state.open_jobs_pane();
-                    }
-                    Err(e) => tracing::error!(error = %e, "failed to load jobs"),
-                }
-            }
-        }
-        InputAction::JobsUp => {
-            if let ModalState::JobsPane { selected } = &mut state.modal {
-                *selected = selected.saturating_sub(1);
-            }
-            state.dirty = true;
-        }
-        InputAction::JobsDown => {
-            let job_count = state.jobs.len();
-            if let ModalState::JobsPane { selected } = &mut state.modal {
-                if *selected + 1 < job_count {
-                    *selected += 1;
-                }
-            }
-            state.dirty = true;
-        }
-        InputAction::JobsDrillIn => {
-            if let Some(child) = state.selected_job_child() {
-                match engine.get_session(child).await {
-                    Ok(Some(session)) => {
-                        if let Err(e) = modal::select_session(state, engine, session).await {
-                            tracing::error!(error = %e, "failed to open subtask session");
-                        }
-                    }
-                    Ok(None) => tracing::warn!("subtask session no longer exists"),
-                    Err(e) => tracing::error!(error = %e, "failed to load subtask session"),
-                }
-            }
-        }
         InputAction::None => {}
     }
 }

crates/harness-tui/src/modal.rs

@@ -26,17 +26,13 @@ pub async fn select_session(
     session: Session,
 ) -> Result<(), harness_app::AppError> {
     let session_id = session.id.clone();
-    let messages = engine.session_messages(session_id.clone()).await?;
+    let messages = engine.session_messages(session_id).await?;
     let mut all_parts = Vec::new();
     for message in &messages {
         let parts = engine.message_parts(message.id.clone()).await?;
         all_parts.extend(parts);
     }
     state.set_session(session, messages, all_parts);
-    // Surface any subtasks this session spawned (drill-in and session-switch both land here).
-    if let Ok(jobs) = engine.jobs(session_id).await {
-        state.set_jobs(jobs);
-    }
     state.modal = ModalState::None;
     Ok(())
 }

crates/harness-tui/src/render.rs

@@ -33,9 +33,6 @@ pub fn render(frame: &mut Frame, state: &mut AppState) {
         ModalState::SessionPicker { sessions, selected } => {
             render_session_picker(frame, sessions, *selected, area);
         }
-        ModalState::JobsPane { selected } => {
-            render_jobs_pane(frame, &state.jobs, *selected, area);
-        }
         ModalState::None => {}
     }
 }
@@ -172,27 +169,13 @@ fn render_status(frame: &mut Frame, state: &AppState, area: Rect) {
     let hints = if state.ctrl_c_pressed {
         "Press Ctrl+C again to quit"
     } else {
-        "Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C: quit"
+        "Ctrl+S: sessions | Esc: abort | Ctrl+C: quit"
     };
-    let usage = format!(
-        "{} · ${:.4}",
-        format_tokens(state.session_tokens),
-        state.session_cost
-    );
-    let text = format!("{spinner}{status} · {usage} · {hints}");
+    let text = format!("{spinner}{status} · {hints}");
     let paragraph = Paragraph::new(text).style(Style::new().fg(Color::Gray));
     frame.render_widget(paragraph, area);
 }
 
-/// Compact token count: `1234` → `1.2k`, `2_000_000` → `2.0M`.
-fn format_tokens(n: u64) -> String {
-    match n {
-        0..=999 => format!("{n} tok"),
-        1_000..=999_999 => format!("{:.1}k tok", n as f64 / 1_000.0),
-        _ => format!("{:.1}M tok", n as f64 / 1_000_000.0),
-    }
-}
-
 fn render_permission_modal(
     frame: &mut Frame,
     request: &harness_core::event::PermissionRequest,
@@ -245,86 +228,6 @@ fn render_session_picker(
     frame.render_widget(paragraph, popup);
 }
 
-fn render_jobs_pane(
-    frame: &mut Frame,
-    jobs: &[harness_core::engine::JobRecord],
-    selected: usize,
-    area: Rect,
-) {
-    let popup = centered_rect(70, 70, area);
-    frame.render_widget(Clear, popup);
-
-    let mut text: Vec<Line<'static>> =
-        vec![Line::from("Background jobs").style(Style::new().add_modifier(Modifier::BOLD))];
-
-    if jobs.is_empty() {
-        text.push(Line::default());
-        text.push(Line::from("No subtasks spawned yet.").style(Style::new().fg(Color::DarkGray)));
-    } else {
-        for (i, job) in jobs.iter().enumerate() {
-            let marker = if i == selected { "> " } else { "  " };
-            let (icon, color) = job_state_style(job.state);
-            let header = format!(
-                "{marker}{icon} {} · {} · {}",
-                job.alias,
-                job.agent,
-                job_state_label(job.state),
-            );
-            let style = if i == selected {
-                Style::new().bg(Color::Blue).fg(Color::White)
-            } else {
-                Style::new().fg(color)
-            };
-            text.push(Line::from(Span::styled(header, style)));
-            if let Some(objective) = &job.objective {
-                text.push(
-                    Line::from(format!("    {objective}")).style(Style::new().fg(Color::Gray)),
-                );
-            }
-            if !job.context_files.is_empty() {
-                let files: Vec<&str> = job
-                    .context_files
-                    .iter()
-                    .take(8)
-                    .map(|f| f.path.as_str())
-                    .collect();
-                text.push(
-                    Line::from(format!("    read: {}", files.join(", ")))
-                        .style(Style::new().fg(Color::DarkGray)),
-                );
-            }
-        }
-        text.push(Line::default());
-        text.push(
-            Line::from("Enter: open subtask · Esc: close").style(Style::new().fg(Color::DarkGray)),
-        );
-    }
-
-    let block = Block::default().borders(Borders::ALL).title(" jobs ");
-    let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: false });
-    frame.render_widget(paragraph, popup);
-}
-
-fn job_state_label(state: harness_core::engine::JobState) -> &'static str {
-    use harness_core::engine::JobState;
-    match state {
-        JobState::Running => "running",
-        JobState::Completed => "completed",
-        JobState::Error => "error",
-        JobState::Cancelled => "cancelled",
-    }
-}
-
-fn job_state_style(state: harness_core::engine::JobState) -> (&'static str, Color) {
-    use harness_core::engine::JobState;
-    match state {
-        JobState::Running => ("⚙", Color::Yellow),
-        JobState::Completed => ("✓", Color::Green),
-        JobState::Error => ("✗", Color::Red),
-        JobState::Cancelled => ("∅", Color::DarkGray),
-    }
-}
-
 fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
     let popup_layout = Layout::default()
         .direction(Direction::Vertical)
@@ -570,59 +473,6 @@ mod tests {
         insta::assert_snapshot!(buffer_to_string(terminal.backend()));
     }
 
-    #[test]
-    fn snapshot_jobs_pane() {
-        use harness_core::engine::{ContextFile, JobRecord, JobState};
-
-        let backend = TestBackend::new(80, 24);
-        let mut terminal = Terminal::new(backend).unwrap();
-        let mut state = AppState::new(
-            "anthropic/claude-sonnet-4-5".to_string(),
-            "orchestrator".to_string(),
-        );
-        state.session_id = Some(SessionId("ses_test_001".to_string()));
-        state.jobs = vec![
-            JobRecord {
-                task_id: "t1".to_string(),
-                alias: "exp-1".to_string(),
-                parent_session: SessionId("ses_test_001".to_string()),
-                child_session: SessionId("ses_child_001".to_string()),
-                agent: "explorer".to_string(),
-                description: "map auth".to_string(),
-                objective: Some("map the auth flow".to_string()),
-                state: JobState::Completed,
-                reconciled: true,
-                result_summary: Some("done".to_string()),
-                context_files: vec![ContextFile {
-                    path: "src/auth.rs".to_string(),
-                    lines: 42,
-                }],
-                launched_at: 1,
-                updated_at: 2,
-                last_used_at: 2,
-            },
-            JobRecord {
-                task_id: "t2".to_string(),
-                alias: "fix-1".to_string(),
-                parent_session: SessionId("ses_test_001".to_string()),
-                child_session: SessionId("ses_child_002".to_string()),
-                agent: "fixer".to_string(),
-                description: "patch bug".to_string(),
-                objective: Some("fix the null deref".to_string()),
-                state: JobState::Running,
-                reconciled: false,
-                result_summary: None,
-                context_files: Vec::new(),
-                launched_at: 3,
-                updated_at: 3,
-                last_used_at: 3,
-            },
-        ];
-        state.modal = ModalState::JobsPane { selected: 1 };
-        terminal.draw(|frame| render(frame, &mut state)).unwrap();
-        insta::assert_snapshot!(buffer_to_string(terminal.backend()));
-    }
-
     #[test]
     fn render_empty_state_produces_frame() {
         let backend = TestBackend::new(80, 24);

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_empty_session.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 381
+assertion_line: 277
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_jobs_pane.snap

@@ -1,29 +0,0 @@
----
-source: crates/harness-tui/src/render.rs
-assertion_line: 621
-expression: buffer_to_string(terminal.backend())
----
-            new session · orchestrator · anthropic/claude-sonnet-4-5
-┌ chat ────────────────────────────────────────────────────────────────────────┐
-│                                                                              │
-│                                                                              │
-│           ┌ jobs ────────────────────────────────────────────────┐           │
-│           │Background jobs                                       │           │
-│           │  ✓ exp-1 · explorer · completed                      │           │
-│           │    map the auth flow                                 │           │
-│           │    read: src/auth.rs                                 │           │
-│           │> ⚙ fix-1 · fixer · running                           │           │
-│           │    fix the null deref                                │           │
-│           │                                                      │           │
-│           │Enter: open subtask · Esc: close                      │           │
-│           │                                                      │           │
-│           │                                                      │           │
-│           │                                                      │           │
-│           │                                                      │           │
-│           │                                                      │           │
-│           │                                                      │           │
-└───────────└──────────────────────────────────────────────────────┘───────────┘
-┌ input ───────────────────────────────────────────────────────────────────────┐
-│                                                                              │
-└──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_permission_modal.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 511
+assertion_line: 397
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_session_picker_modal.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 568
+assertion_line: 449
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_tool_card_completed.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 438
+assertion_line: 330
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_tool_card_error.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 488
+assertion_line: 376
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_tool_card_running.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 463
+assertion_line: 353
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/snapshots/harness__render__tests__snapshot_user_and_assistant_messages.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/harness-tui/src/render.rs
-assertion_line: 412
+assertion_line: 306
 expression: buffer_to_string(terminal.backend())
 ---
             new session · orchestrator · anthropic/claude-sonnet-4-5
@@ -26,4 +26,4 @@ expression: buffer_to_string(terminal.backend())
 ┌ input ───────────────────────────────────────────────────────────────────────┐
 │                                                                              │
 └──────────────────────────────────────────────────────────────────────────────┘
-idle · 0 tok · $0.0000 · Ctrl+S: sessions | Ctrl+J: jobs | Esc: abort | Ctrl+C:
+idle · Ctrl+S: sessions | Esc: abort | Ctrl+C: quit

crates/harness-tui/src/state.rs

@@ -1,5 +1,4 @@
 use harness_app::EngineHandle;
-use harness_core::engine::JobRecord;
 use harness_core::event::{AppEvent, PermissionRequest, RunOutcome};
 use harness_core::permission::PermissionReply;
 use harness_core::types::{Message, Part, PartBody, PartId, Role, Session, SessionId, ToolState};
@@ -87,10 +86,6 @@ pub enum ModalState {
         sessions: Vec<Session>,
         selected: usize,
     },
-    /// Background job board for the current session, with a cursor for drill-in.
-    JobsPane {
-        selected: usize,
-    },
 }
 
 /// All mutable UI state lives here.
@@ -110,13 +105,6 @@ pub struct AppState {
     pub ctrl_c_pressed: bool,
     /// Width the currently cached part lines were wrapped to; a change invalidates them.
     pub render_width: u16,
-    /// Accumulated session cost in USD, from `SessionCreated`/`SessionUpdated` events.
-    pub session_cost: f64,
-    /// Accumulated session tokens (input + output), for the status bar.
-    pub session_tokens: u64,
-    /// Background jobs spawned by the current session, newest activity last. Populated on
-    /// session load and kept live via `JobUpdated` events; surfaced in the jobs pane.
-    pub jobs: Vec<JobRecord>,
 }
 
 impl AppState {
@@ -137,9 +125,6 @@ impl AppState {
             dirty: true,
             ctrl_c_pressed: false,
             render_width: 0,
-            session_cost: 0.0,
-            session_tokens: 0,
-            jobs: Vec::new(),
         }
     }
 
@@ -162,11 +147,7 @@ impl AppState {
         self.session_title = session.title;
         self.agent = session.agent;
         self.model_ref = format!("{}/{}", session.model.provider_id, session.model.model_id);
-        self.session_cost = session.cost;
-        self.session_tokens = session.usage.input + session.usage.output;
         self.messages.clear();
-        // Jobs are reloaded for the newly-selected session by the caller.
-        self.jobs.clear();
 
         let mut messages = messages;
         messages.sort_by_key(|m| m.created_at);
@@ -190,8 +171,6 @@ impl AppState {
                     self.agent = session.agent;
                     self.model_ref =
                         format!("{}/{}", session.model.provider_id, session.model.model_id);
-                    self.session_cost = session.cost;
-                    self.session_tokens = session.usage.input + session.usage.output;
                     self.dirty = true;
                 }
             }
@@ -269,49 +248,13 @@ impl AppState {
                 }
                 self.dirty = true;
             }
-            AppEvent::JobUpdated { job } => {
-                if let Ok(record) = serde_json::from_value::<JobRecord>(job.0) {
-                    if self.session_id.as_ref() == Some(&record.parent_session) {
-                        self.upsert_job(record);
+            AppEvent::JobUpdated { .. }
+            | AppEvent::AuthPrompt { .. }
+            | AppEvent::ServerNotice { .. } => {
                 self.dirty = true;
             }
         }
     }
-            AppEvent::AuthPrompt { .. } | AppEvent::ServerNotice { .. } => {
-                self.dirty = true;
-            }
-        }
-    }
-
-    /// Replaces this session's job list (e.g. after loading a session).
-    pub fn set_jobs(&mut self, jobs: Vec<JobRecord>) {
-        self.jobs = jobs;
-        self.dirty = true;
-    }
-
-    /// Inserts or replaces a job by `task_id`, preserving list order for stable rendering.
-    fn upsert_job(&mut self, record: JobRecord) {
-        if let Some(existing) = self.jobs.iter_mut().find(|j| j.task_id == record.task_id) {
-            *existing = record;
-        } else {
-            self.jobs.push(record);
-        }
-    }
-
-    /// Opens the jobs pane (cursor at the top).
-    pub fn open_jobs_pane(&mut self) {
-        self.modal = ModalState::JobsPane { selected: 0 };
-        self.dirty = true;
-    }
-
-    /// Child session of the currently-selected job in the jobs pane, for drill-in.
-    pub fn selected_job_child(&self) -> Option<SessionId> {
-        if let ModalState::JobsPane { selected } = &self.modal {
-            self.jobs.get(*selected).map(|j| j.child_session.clone())
-        } else {
-            None
-        }
-    }
 
     pub fn scroll_up(&mut self, n: u16) {
         self.scroll_offset = self.scroll_offset.saturating_sub(n);