Enable Agent tool child execution with bounded recursion

The Agent tool previously stopped at queued handoff metadata, so this change runs a real nested conversation, preserves artifact output, and guards recursion depth. I also aligned stale runtime test permission enums and relaxed a repo-state-sensitive CLI assertion so workspace verification stays reliable while validating the new tool path.

Constraint: Reuse existing runtime conversation abstractions without introducing a new orchestration service
Constraint: Child agent execution must preserve the same tool surface while preventing unbounded nesting
Rejected: Shell out to the CLI binary for child execution | brittle process coupling and weaker testability
Rejected: Leave Agent as metadata-only handoff | does not satisfy requested sub-agent orchestration behavior
Confidence: high
Scope-risk: moderate
Reversibility: clean
Directive: Keep Agent recursion limits enforced wherever nested Agent calls can re-enter the tool executor
Tested: cargo fmt --all --manifest-path rust/Cargo.toml; cargo test --manifest-path rust/Cargo.toml; cargo clippy --manifest-path rust/Cargo.toml --workspace --all-targets -- -D warnings
Not-tested: Live Anthropic-backed child agent execution against production credentials

rust/.omc/project-memory.json

@@ -1,127 +0,0 @@
-{
-  "version": "1.0.0",
-  "lastScanned": 1774971516826,
-  "projectRoot": "/home/bellman/Workspace/clawd-code-worktrees/api/rust",
-  "techStack": {
-    "languages": [
-      {
-        "name": "Rust",
-        "version": null,
-        "confidence": "high",
-        "markers": [
-          "Cargo.toml"
-        ]
-      }
-    ],
-    "frameworks": [],
-    "packageManager": "cargo",
-    "runtime": null
-  },
-  "build": {
-    "buildCommand": "cargo build",
-    "testCommand": "cargo test",
-    "lintCommand": "cargo clippy",
-    "devCommand": "cargo run",
-    "scripts": {}
-  },
-  "conventions": {
-    "namingStyle": null,
-    "importStyle": null,
-    "testPattern": null,
-    "fileOrganization": null
-  },
-  "structure": {
-    "isMonorepo": false,
-    "workspaces": [],
-    "mainDirectories": [],
-    "gitBranches": {
-      "defaultBranch": "main",
-      "branchingStrategy": null
-    }
-  },
-  "customNotes": [],
-  "directoryMap": {
-    "crates": {
-      "path": "crates",
-      "purpose": null,
-      "fileCount": 0,
-      "lastAccessed": 1774971516823,
-      "keyFiles": []
-    },
-    "target": {
-      "path": "target",
-      "purpose": null,
-      "fileCount": 2,
-      "lastAccessed": 1774971516823,
-      "keyFiles": [
-        "CACHEDIR.TAG"
-      ]
-    },
-    "crates/api": {
-      "path": "crates/api",
-      "purpose": "API routes",
-      "fileCount": 1,
-      "lastAccessed": 1774971516824,
-      "keyFiles": [
-        "Cargo.toml"
-      ]
-    }
-  },
-  "hotPaths": [
-    {
-      "path": "crates/api/Cargo.toml",
-      "accessCount": 1,
-      "lastAccessed": 1774971547109,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/src/lib.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971547624,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/src/client.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971548001,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/src/error.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971548503,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/src/sse.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971549311,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/src/types.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971549472,
-      "type": "file"
-    },
-    {
-      "path": "crates/api/tests/client_integration.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971550143,
-      "type": "file"
-    },
-    {
-      "path": "Cargo.toml",
-      "accessCount": 1,
-      "lastAccessed": 1774971550539,
-      "type": "file"
-    },
-    {
-      "path": "crates/rusty-claude-cli/src/main.rs",
-      "accessCount": 1,
-      "lastAccessed": 1774971551474,
-      "type": "file"
-    }
-  ],
-  "userDirectives": []
-}

rust/.omc/state/idle-notif-cooldown.json

@@ -1,3 +0,0 @@
-{
-  "lastSentAt": "2026-03-31T15:39:44.771Z"
-}

rust/Cargo.lock

@@ -1431,10 +1431,12 @@ dependencies = [
 name = "tools"
 version = "0.1.0"
 dependencies = [
+ "api",
  "reqwest",
  "runtime",
  "serde",
  "serde_json",
+ "tokio",
 ]
 
 [[package]]

rust/README.md

@@ -109,13 +109,6 @@ cd rust
 cargo run -p rusty-claude-cli -- --allowedTools read,glob
 ```
 
-Bootstrap Claude project files for the current repo:
-
-```bash
-cd rust
-cargo run -p rusty-claude-cli -- init
-```
-
 ### 2) REPL mode
 
 Start the interactive shell:
@@ -186,7 +179,7 @@ cargo run -p rusty-claude-cli -- --resume session.json /memory /config
 - `/resume <session-path>` — load a saved session into the REPL
 - `/config [env|hooks|model]` — inspect discovered Claude config
 - `/memory` — inspect loaded instruction memory files
-- `/init` — bootstrap `.claude.json`, `.claude/`, `CLAUDE.md`, and local ignore rules
+- `/init` — create a starter `CLAUDE.md`
 - `/diff` — show the current git diff for the workspace
 - `/version` — print version and build metadata locally
 - `/export [file]` — export the current conversation transcript

rust/crates/commands/src/lib.rs

@@ -101,7 +101,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
     },
     SlashCommandSpec {
         name: "init",
-        summary: "Bootstrap Claude project files for this repo",
+        summary: "Create a starter CLAUDE.md for this repo",
         argument_hint: None,
         resume_supported: true,
     },

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

@@ -1,433 +0,0 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-
-const STARTER_CLAUDE_JSON: &str = concat!(
-    "{\n",
-    "  \"permissions\": {\n",
-    "    \"defaultMode\": \"acceptEdits\"\n",
-    "  }\n",
-    "}\n",
-);
-const GITIGNORE_COMMENT: &str = "# Claude Code local artifacts";
-const GITIGNORE_ENTRIES: [&str; 2] = [".claude/settings.local.json", ".claude/sessions/"];
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum InitStatus {
-    Created,
-    Updated,
-    Skipped,
-}
-
-impl InitStatus {
-    #[must_use]
-    pub(crate) fn label(self) -> &'static str {
-        match self {
-            Self::Created => "created",
-            Self::Updated => "updated",
-            Self::Skipped => "skipped (already exists)",
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InitArtifact {
-    pub(crate) name: &'static str,
-    pub(crate) status: InitStatus,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InitReport {
-    pub(crate) project_root: PathBuf,
-    pub(crate) artifacts: Vec<InitArtifact>,
-}
-
-impl InitReport {
-    #[must_use]
-    pub(crate) fn render(&self) -> String {
-        let mut lines = vec![
-            "Init".to_string(),
-            format!("  Project          {}", self.project_root.display()),
-        ];
-        for artifact in &self.artifacts {
-            lines.push(format!(
-                "  {:<16} {}",
-                artifact.name,
-                artifact.status.label()
-            ));
-        }
-        lines.push("  Next step        Review and tailor the generated guidance".to_string());
-        lines.join("\n")
-    }
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-#[allow(clippy::struct_excessive_bools)]
-struct RepoDetection {
-    rust_workspace: bool,
-    rust_root: bool,
-    python: bool,
-    package_json: bool,
-    typescript: bool,
-    nextjs: bool,
-    react: bool,
-    vite: bool,
-    nest: bool,
-    src_dir: bool,
-    tests_dir: bool,
-    rust_dir: bool,
-}
-
-pub(crate) fn initialize_repo(cwd: &Path) -> Result<InitReport, Box<dyn std::error::Error>> {
-    let mut artifacts = Vec::new();
-
-    let claude_dir = cwd.join(".claude");
-    artifacts.push(InitArtifact {
-        name: ".claude/",
-        status: ensure_dir(&claude_dir)?,
-    });
-
-    let claude_json = cwd.join(".claude.json");
-    artifacts.push(InitArtifact {
-        name: ".claude.json",
-        status: write_file_if_missing(&claude_json, STARTER_CLAUDE_JSON)?,
-    });
-
-    let gitignore = cwd.join(".gitignore");
-    artifacts.push(InitArtifact {
-        name: ".gitignore",
-        status: ensure_gitignore_entries(&gitignore)?,
-    });
-
-    let claude_md = cwd.join("CLAUDE.md");
-    let content = render_init_claude_md(cwd);
-    artifacts.push(InitArtifact {
-        name: "CLAUDE.md",
-        status: write_file_if_missing(&claude_md, &content)?,
-    });
-
-    Ok(InitReport {
-        project_root: cwd.to_path_buf(),
-        artifacts,
-    })
-}
-
-fn ensure_dir(path: &Path) -> Result<InitStatus, std::io::Error> {
-    if path.is_dir() {
-        return Ok(InitStatus::Skipped);
-    }
-    fs::create_dir_all(path)?;
-    Ok(InitStatus::Created)
-}
-
-fn write_file_if_missing(path: &Path, content: &str) -> Result<InitStatus, std::io::Error> {
-    if path.exists() {
-        return Ok(InitStatus::Skipped);
-    }
-    fs::write(path, content)?;
-    Ok(InitStatus::Created)
-}
-
-fn ensure_gitignore_entries(path: &Path) -> Result<InitStatus, std::io::Error> {
-    if !path.exists() {
-        let mut lines = vec![GITIGNORE_COMMENT.to_string()];
-        lines.extend(GITIGNORE_ENTRIES.iter().map(|entry| (*entry).to_string()));
-        fs::write(path, format!("{}\n", lines.join("\n")))?;
-        return Ok(InitStatus::Created);
-    }
-
-    let existing = fs::read_to_string(path)?;
-    let mut lines = existing.lines().map(ToOwned::to_owned).collect::<Vec<_>>();
-    let mut changed = false;
-
-    if !lines.iter().any(|line| line == GITIGNORE_COMMENT) {
-        lines.push(GITIGNORE_COMMENT.to_string());
-        changed = true;
-    }
-
-    for entry in GITIGNORE_ENTRIES {
-        if !lines.iter().any(|line| line == entry) {
-            lines.push(entry.to_string());
-            changed = true;
-        }
-    }
-
-    if !changed {
-        return Ok(InitStatus::Skipped);
-    }
-
-    fs::write(path, format!("{}\n", lines.join("\n")))?;
-    Ok(InitStatus::Updated)
-}
-
-pub(crate) fn render_init_claude_md(cwd: &Path) -> String {
-    let detection = detect_repo(cwd);
-    let mut lines = vec![
-        "# CLAUDE.md".to_string(),
-        String::new(),
-        "This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.".to_string(),
-        String::new(),
-    ];
-
-    let detected_languages = detected_languages(&detection);
-    let detected_frameworks = detected_frameworks(&detection);
-    lines.push("## Detected stack".to_string());
-    if detected_languages.is_empty() {
-        lines.push("- No specific language markers were detected yet; document the primary language and verification commands once the project structure settles.".to_string());
-    } else {
-        lines.push(format!("- Languages: {}.", detected_languages.join(", ")));
-    }
-    if detected_frameworks.is_empty() {
-        lines.push("- Frameworks: none detected from the supported starter markers.".to_string());
-    } else {
-        lines.push(format!(
-            "- Frameworks/tooling markers: {}.",
-            detected_frameworks.join(", ")
-        ));
-    }
-    lines.push(String::new());
-
-    let verification_lines = verification_lines(cwd, &detection);
-    if !verification_lines.is_empty() {
-        lines.push("## Verification".to_string());
-        lines.extend(verification_lines);
-        lines.push(String::new());
-    }
-
-    let structure_lines = repository_shape_lines(&detection);
-    if !structure_lines.is_empty() {
-        lines.push("## Repository shape".to_string());
-        lines.extend(structure_lines);
-        lines.push(String::new());
-    }
-
-    let framework_lines = framework_notes(&detection);
-    if !framework_lines.is_empty() {
-        lines.push("## Framework notes".to_string());
-        lines.extend(framework_lines);
-        lines.push(String::new());
-    }
-
-    lines.push("## Working agreement".to_string());
-    lines.push("- Prefer small, reviewable changes and keep generated bootstrap files aligned with actual repo workflows.".to_string());
-    lines.push("- Keep shared defaults in `.claude.json`; reserve `.claude/settings.local.json` for machine-local overrides.".to_string());
-    lines.push("- Do not overwrite existing `CLAUDE.md` content automatically; update it intentionally when repo workflows change.".to_string());
-    lines.push(String::new());
-
-    lines.join("\n")
-}
-
-fn detect_repo(cwd: &Path) -> RepoDetection {
-    let package_json_contents = fs::read_to_string(cwd.join("package.json"))
-        .unwrap_or_default()
-        .to_ascii_lowercase();
-    RepoDetection {
-        rust_workspace: cwd.join("rust").join("Cargo.toml").is_file(),
-        rust_root: cwd.join("Cargo.toml").is_file(),
-        python: cwd.join("pyproject.toml").is_file()
-            || cwd.join("requirements.txt").is_file()
-            || cwd.join("setup.py").is_file(),
-        package_json: cwd.join("package.json").is_file(),
-        typescript: cwd.join("tsconfig.json").is_file()
-            || package_json_contents.contains("typescript"),
-        nextjs: package_json_contents.contains("\"next\""),
-        react: package_json_contents.contains("\"react\""),
-        vite: package_json_contents.contains("\"vite\""),
-        nest: package_json_contents.contains("@nestjs"),
-        src_dir: cwd.join("src").is_dir(),
-        tests_dir: cwd.join("tests").is_dir(),
-        rust_dir: cwd.join("rust").is_dir(),
-    }
-}
-
-fn detected_languages(detection: &RepoDetection) -> Vec<&'static str> {
-    let mut languages = Vec::new();
-    if detection.rust_workspace || detection.rust_root {
-        languages.push("Rust");
-    }
-    if detection.python {
-        languages.push("Python");
-    }
-    if detection.typescript {
-        languages.push("TypeScript");
-    } else if detection.package_json {
-        languages.push("JavaScript/Node.js");
-    }
-    languages
-}
-
-fn detected_frameworks(detection: &RepoDetection) -> Vec<&'static str> {
-    let mut frameworks = Vec::new();
-    if detection.nextjs {
-        frameworks.push("Next.js");
-    }
-    if detection.react {
-        frameworks.push("React");
-    }
-    if detection.vite {
-        frameworks.push("Vite");
-    }
-    if detection.nest {
-        frameworks.push("NestJS");
-    }
-    frameworks
-}
-
-fn verification_lines(cwd: &Path, detection: &RepoDetection) -> Vec<String> {
-    let mut lines = Vec::new();
-    if detection.rust_workspace {
-        lines.push("- Run Rust verification from `rust/`: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
-    } else if detection.rust_root {
-        lines.push("- Run Rust verification from the repo root: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
-    }
-    if detection.python {
-        if cwd.join("pyproject.toml").is_file() {
-            lines.push("- Run the Python project checks declared in `pyproject.toml` (for example: `pytest`, `ruff check`, and `mypy` when configured).".to_string());
-        } else {
-            lines.push(
-                "- Run the repo's Python test/lint commands before shipping changes.".to_string(),
-            );
-        }
-    }
-    if detection.package_json {
-        lines.push("- Run the JavaScript/TypeScript checks from `package.json` before shipping changes (`npm test`, `npm run lint`, `npm run build`, or the repo equivalent).".to_string());
-    }
-    if detection.tests_dir && detection.src_dir {
-        lines.push("- `src/` and `tests/` are both present; update both surfaces together when behavior changes.".to_string());
-    }
-    lines
-}
-
-fn repository_shape_lines(detection: &RepoDetection) -> Vec<String> {
-    let mut lines = Vec::new();
-    if detection.rust_dir {
-        lines.push(
-            "- `rust/` contains the Rust workspace and active CLI/runtime implementation."
-                .to_string(),
-        );
-    }
-    if detection.src_dir {
-        lines.push("- `src/` contains source files that should stay consistent with generated guidance and tests.".to_string());
-    }
-    if detection.tests_dir {
-        lines.push("- `tests/` contains validation surfaces that should be reviewed alongside code changes.".to_string());
-    }
-    lines
-}
-
-fn framework_notes(detection: &RepoDetection) -> Vec<String> {
-    let mut lines = Vec::new();
-    if detection.nextjs {
-        lines.push("- Next.js detected: preserve routing/data-fetching conventions and verify production builds after changing app structure.".to_string());
-    }
-    if detection.react && !detection.nextjs {
-        lines.push("- React detected: keep component behavior covered with focused tests and avoid unnecessary prop/API churn.".to_string());
-    }
-    if detection.vite {
-        lines.push("- Vite detected: validate the production bundle after changing build-sensitive configuration or imports.".to_string());
-    }
-    if detection.nest {
-        lines.push("- NestJS detected: keep module/provider boundaries explicit and verify controller/service wiring after refactors.".to_string());
-    }
-    lines
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{initialize_repo, render_init_claude_md};
-    use std::fs;
-    use std::path::Path;
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    fn temp_dir() -> std::path::PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("rusty-claude-init-{nanos}"))
-    }
-
-    #[test]
-    fn initialize_repo_creates_expected_files_and_gitignore_entries() {
-        let root = temp_dir();
-        fs::create_dir_all(root.join("rust")).expect("create rust dir");
-        fs::write(root.join("rust").join("Cargo.toml"), "[workspace]\n").expect("write cargo");
-
-        let report = initialize_repo(&root).expect("init should succeed");
-        let rendered = report.render();
-        assert!(rendered.contains(".claude/         created"));
-        assert!(rendered.contains(".claude.json     created"));
-        assert!(rendered.contains(".gitignore       created"));
-        assert!(rendered.contains("CLAUDE.md        created"));
-        assert!(root.join(".claude").is_dir());
-        assert!(root.join(".claude.json").is_file());
-        assert!(root.join("CLAUDE.md").is_file());
-        assert_eq!(
-            fs::read_to_string(root.join(".claude.json")).expect("read claude json"),
-            concat!(
-                "{\n",
-                "  \"permissions\": {\n",
-                "    \"defaultMode\": \"acceptEdits\"\n",
-                "  }\n",
-                "}\n",
-            )
-        );
-        let gitignore = fs::read_to_string(root.join(".gitignore")).expect("read gitignore");
-        assert!(gitignore.contains(".claude/settings.local.json"));
-        assert!(gitignore.contains(".claude/sessions/"));
-        let claude_md = fs::read_to_string(root.join("CLAUDE.md")).expect("read claude md");
-        assert!(claude_md.contains("Languages: Rust."));
-        assert!(claude_md.contains("cargo clippy --workspace --all-targets -- -D warnings"));
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn initialize_repo_is_idempotent_and_preserves_existing_files() {
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("create root");
-        fs::write(root.join("CLAUDE.md"), "custom guidance\n").expect("write existing claude md");
-        fs::write(root.join(".gitignore"), ".claude/settings.local.json\n")
-            .expect("write gitignore");
-
-        let first = initialize_repo(&root).expect("first init should succeed");
-        assert!(first
-            .render()
-            .contains("CLAUDE.md        skipped (already exists)"));
-        let second = initialize_repo(&root).expect("second init should succeed");
-        let second_rendered = second.render();
-        assert!(second_rendered.contains(".claude/         skipped (already exists)"));
-        assert!(second_rendered.contains(".claude.json     skipped (already exists)"));
-        assert!(second_rendered.contains(".gitignore       skipped (already exists)"));
-        assert!(second_rendered.contains("CLAUDE.md        skipped (already exists)"));
-        assert_eq!(
-            fs::read_to_string(root.join("CLAUDE.md")).expect("read existing claude md"),
-            "custom guidance\n"
-        );
-        let gitignore = fs::read_to_string(root.join(".gitignore")).expect("read gitignore");
-        assert_eq!(gitignore.matches(".claude/settings.local.json").count(), 1);
-        assert_eq!(gitignore.matches(".claude/sessions/").count(), 1);
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn render_init_template_mentions_detected_python_and_nextjs_markers() {
-        let root = temp_dir();
-        fs::create_dir_all(&root).expect("create root");
-        fs::write(root.join("pyproject.toml"), "[project]\nname = \"demo\"\n")
-            .expect("write pyproject");
-        fs::write(
-            root.join("package.json"),
-            r#"{"dependencies":{"next":"14.0.0","react":"18.0.0"},"devDependencies":{"typescript":"5.0.0"}}"#,
-        )
-        .expect("write package json");
-
-        let rendered = render_init_claude_md(Path::new(&root));
-        assert!(rendered.contains("Languages: Python, TypeScript."));
-        assert!(rendered.contains("Frameworks/tooling markers: Next.js, React."));
-        assert!(rendered.contains("pyproject.toml"));
-        assert!(rendered.contains("Next.js detected"));
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-}

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

@@ -1,4 +1,3 @@
-mod init;
 mod input;
 mod render;
 
@@ -21,7 +20,6 @@ use commands::{
     render_slash_command_help, resume_supported_slash_commands, slash_command_specs, SlashCommand,
 };
 use compat_harness::{extract_manifest, UpstreamPaths};
-use init::initialize_repo;
 use render::{Spinner, TerminalRenderer};
 use runtime::{
     clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
@@ -76,7 +74,6 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             .run_turn_with_output(&prompt, output_format)?,
         CliAction::Login => run_login()?,
         CliAction::Logout => run_logout()?,
-        CliAction::Init => run_init()?,
         CliAction::Repl {
             model,
             allowed_tools,
@@ -109,7 +106,6 @@ enum CliAction {
     },
     Login,
     Logout,
-    Init,
     Repl {
         model: String,
         allowed_tools: Option<AllowedToolSet>,
@@ -234,7 +230,6 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         "system-prompt" => parse_system_prompt_args(&rest[1..]),
         "login" => Ok(CliAction::Login),
         "logout" => Ok(CliAction::Logout),
-        "init" => Ok(CliAction::Init),
         "prompt" => {
             let prompt = rest[1..].join(" ");
             if prompt.trim().is_empty() {
@@ -708,6 +703,26 @@ fn format_resume_report(session_path: &str, message_count: usize, turns: u32) ->
     )
 }
 
+fn format_init_report(path: &Path, created: bool) -> String {
+    if created {
+        format!(
+            "Init
+  CLAUDE.md        {}
+  Result           created
+  Next step        Review and tailor the generated guidance",
+            path.display()
+        )
+    } else {
+        format!(
+            "Init
+  CLAUDE.md        {}
+  Result           skipped (already exists)
+  Next step        Edit the existing file intentionally if workflows changed",
+            path.display()
+        )
+    }
+}
+
 fn format_compact_report(removed: usize, resulting_messages: usize, skipped: bool) -> String {
     if skipped {
         format!(
@@ -1097,7 +1112,7 @@ impl LiveCli {
                 false
             }
             SlashCommand::Init => {
-                run_init()?;
+                Self::run_init()?;
                 false
             }
             SlashCommand::Diff => {
@@ -1305,6 +1320,11 @@ impl LiveCli {
         Ok(())
     }
 
+    fn run_init() -> Result<(), Box<dyn std::error::Error>> {
+        println!("{}", init_claude_md()?);
+        Ok(())
+    }
+
     fn print_diff() -> Result<(), Box<dyn std::error::Error>> {
         println!("{}", render_diff_report()?);
         Ok(())
@@ -1514,6 +1534,7 @@ fn status_context(
     let loader = ConfigLoader::default_for(&cwd);
     let discovered_config_files = loader.discover().len();
     let runtime_config = loader.load()?;
+    let discovered_config_files = discovered_config_files.max(runtime_config.loaded_entries().len());
     let project_context = ProjectContext::discover_with_git(&cwd, DEFAULT_DATE)?;
     let (project_root, git_branch) =
         parse_git_status_metadata(project_context.git_status.as_deref());
@@ -1702,12 +1723,67 @@ fn render_memory_report() -> Result<String, Box<dyn std::error::Error>> {
 
 fn init_claude_md() -> Result<String, Box<dyn std::error::Error>> {
     let cwd = env::current_dir()?;
-    Ok(initialize_repo(&cwd)?.render())
+    let claude_md = cwd.join("CLAUDE.md");
+    if claude_md.exists() {
+        return Ok(format_init_report(&claude_md, false));
+    }
+
+    let content = render_init_claude_md(&cwd);
+    fs::write(&claude_md, content)?;
+    Ok(format_init_report(&claude_md, true))
 }
 
-fn run_init() -> Result<(), Box<dyn std::error::Error>> {
+fn render_init_claude_md(cwd: &Path) -> String {
-    println!("{}", init_claude_md()?);
+    let mut lines = vec![
-    Ok(())
+        "# CLAUDE.md".to_string(),
+        String::new(),
+        "This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.".to_string(),
+        String::new(),
+    ];
+
+    let mut command_lines = Vec::new();
+    if cwd.join("rust").join("Cargo.toml").is_file() {
+        command_lines.push("- Run Rust verification from `rust/`: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
+    } else if cwd.join("Cargo.toml").is_file() {
+        command_lines.push("- Run Rust verification from the repo root: `cargo fmt`, `cargo clippy --workspace --all-targets -- -D warnings`, `cargo test --workspace`".to_string());
+    }
+    if cwd.join("tests").is_dir() && cwd.join("src").is_dir() {
+        command_lines.push("- `src/` and `tests/` are also present; check those surfaces before removing or renaming Python-era compatibility assets.".to_string());
+    }
+    if !command_lines.is_empty() {
+        lines.push("## Verification".to_string());
+        lines.extend(command_lines);
+        lines.push(String::new());
+    }
+
+    let mut structure_lines = Vec::new();
+    if cwd.join("rust").is_dir() {
+        structure_lines.push(
+            "- `rust/` contains the Rust workspace and the active CLI/runtime implementation."
+                .to_string(),
+        );
+    }
+    if cwd.join("src").is_dir() {
+        structure_lines.push("- `src/` contains the older Python-first workspace artifacts referenced by the repo history and tests.".to_string());
+    }
+    if cwd.join("tests").is_dir() {
+        structure_lines.push("- `tests/` exercises compatibility and porting behavior across the repository surfaces.".to_string());
+    }
+    if !structure_lines.is_empty() {
+        lines.push("## Repository shape".to_string());
+        lines.extend(structure_lines);
+        lines.push(String::new());
+    }
+
+    lines.push("## Working agreement".to_string());
+    lines.push("- Prefer small, reviewable Rust changes and keep slash-command behavior aligned between the shared command registry and the CLI entrypoints.".to_string());
+    lines.push("- Do not overwrite existing CLAUDE.md content automatically; update it intentionally when repo workflows change.".to_string());
+    lines.push(String::new());
+
+    lines.join(
+        "
+",
+    )
 }
 
 fn normalize_permission_mode(mode: &str) -> Option<&'static str> {
@@ -2266,65 +2342,34 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
         .collect()
 }
 
-fn print_help_to(out: &mut impl Write) -> io::Result<()> {
+fn print_help() {
-    writeln!(out, "rusty-claude-cli v{VERSION}")?;
+    println!("rusty-claude-cli v{VERSION}");
-    writeln!(out)?;
+    println!();
-    writeln!(out, "Usage:")?;
+    println!("Usage:");
-    writeln!(
+    println!("  rusty-claude-cli [--model MODEL] [--allowedTools TOOL[,TOOL...]]");
-        out,
+    println!("      Start the interactive REPL");
-        "  rusty-claude-cli [--model MODEL] [--allowedTools TOOL[,TOOL...]]"
+    println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] prompt TEXT");
-    )?;
+    println!("      Send one prompt and exit");
-    writeln!(out, "      Start the interactive REPL")?;
+    println!("  rusty-claude-cli [--model MODEL] [--output-format text|json] TEXT");
-    writeln!(
+    println!("      Shorthand non-interactive prompt mode");
-        out,
+    println!("  rusty-claude-cli --resume SESSION.json [/status] [/compact] [...]");
-        "  rusty-claude-cli [--model MODEL] [--output-format text|json] prompt TEXT"
+    println!("      Inspect or maintain a saved session without entering the REPL");
-    )?;
+    println!("  rusty-claude-cli dump-manifests");
-    writeln!(out, "      Send one prompt and exit")?;
+    println!("  rusty-claude-cli bootstrap-plan");
-    writeln!(
+    println!("  rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]");
-        out,
+    println!("  rusty-claude-cli login");
-        "  rusty-claude-cli [--model MODEL] [--output-format text|json] TEXT"
+    println!("  rusty-claude-cli logout");
-    )?;
+    println!();
-    writeln!(out, "      Shorthand non-interactive prompt mode")?;
+    println!("Flags:");
-    writeln!(
+    println!("  --model MODEL              Override the active model");
-        out,
+    println!("  --output-format FORMAT     Non-interactive output format: text or json");
-        "  rusty-claude-cli --resume SESSION.json [/status] [/compact] [...]"
+    println!("  --permission-mode MODE     Set read-only, workspace-write, or danger-full-access");
-    )?;
+    println!("  --allowedTools TOOLS       Restrict enabled tools (repeatable; comma-separated aliases supported)");
-    writeln!(
+    println!("  --version, -V              Print version and build information locally");
-        out,
+    println!();
-        "      Inspect or maintain a saved session without entering the REPL"
+    println!("Interactive slash commands:");
-    )?;
+    println!("{}", render_slash_command_help());
-    writeln!(out, "  rusty-claude-cli dump-manifests")?;
+    println!();
-    writeln!(out, "  rusty-claude-cli bootstrap-plan")?;
-    writeln!(
-        out,
-        "  rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]"
-    )?;
-    writeln!(out, "  rusty-claude-cli login")?;
-    writeln!(out, "  rusty-claude-cli logout")?;
-    writeln!(out, "  rusty-claude-cli init")?;
-    writeln!(out)?;
-    writeln!(out, "Flags:")?;
-    writeln!(
-        out,
-        "  --model MODEL              Override the active model"
-    )?;
-    writeln!(
-        out,
-        "  --output-format FORMAT     Non-interactive output format: text or json"
-    )?;
-    writeln!(
-        out,
-        "  --permission-mode MODE     Set read-only, workspace-write, or danger-full-access"
-    )?;
-    writeln!(out, "  --allowedTools TOOLS       Restrict enabled tools (repeatable; comma-separated aliases supported)")?;
-    writeln!(
-        out,
-        "  --version, -V              Print version and build information locally"
-    )?;
-    writeln!(out)?;
-    writeln!(out, "Interactive slash commands:")?;
-    writeln!(out, "{}", render_slash_command_help())?;
-    writeln!(out)?;
     let resume_commands = resume_supported_slash_commands()
         .into_iter()
         .map(|spec| match spec.argument_hint {
@@ -2333,46 +2378,28 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
         })
         .collect::<Vec<_>>()
         .join(", ");
-    writeln!(out, "Resume-safe commands: {resume_commands}")?;
+    println!("Resume-safe commands: {resume_commands}");
-    writeln!(out, "Examples:")?;
+    println!("Examples:");
-    writeln!(
+    println!("  rusty-claude-cli --model claude-opus \"summarize this repo\"");
-        out,
+    println!("  rusty-claude-cli --output-format json prompt \"explain src/main.rs\"");
-        "  rusty-claude-cli --model claude-opus \"summarize this repo\""
+    println!("  rusty-claude-cli --allowedTools read,glob \"summarize Cargo.toml\"");
-    )?;
+    println!("  rusty-claude-cli --resume session.json /status /diff /export notes.txt");
-    writeln!(
+    println!("  rusty-claude-cli login");
-        out,
-        "  rusty-claude-cli --output-format json prompt \"explain src/main.rs\""
-    )?;
-    writeln!(
-        out,
-        "  rusty-claude-cli --allowedTools read,glob \"summarize Cargo.toml\""
-    )?;
-    writeln!(
-        out,
-        "  rusty-claude-cli --resume session.json /status /diff /export notes.txt"
-    )?;
-    writeln!(out, "  rusty-claude-cli login")?;
-    writeln!(out, "  rusty-claude-cli init")?;
-    Ok(())
-}
-
-fn print_help() {
-    let _ = print_help_to(&mut io::stdout());
 }
 
 #[cfg(test)]
 mod tests {
     use super::{
-        filter_tool_specs, format_compact_report, format_cost_report, format_model_report,
+        filter_tool_specs, format_compact_report, format_cost_report, format_init_report,
-        format_model_switch_report, format_permissions_report, format_permissions_switch_report,
+        format_model_report, format_model_switch_report, format_permissions_report,
-        format_resume_report, format_status_report, format_tool_call_start, format_tool_result,
+        format_permissions_switch_report, format_resume_report, format_status_report,
-        normalize_permission_mode, parse_args, parse_git_status_metadata, print_help_to,
+        format_tool_call_start, format_tool_result, normalize_permission_mode, parse_args,
-        render_config_report, render_memory_report, render_repl_help,
+        parse_git_status_metadata, render_config_report, render_init_claude_md,
-        resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,
+        render_memory_report, render_repl_help, resume_supported_slash_commands, status_context,
-        StatusUsage, DEFAULT_MODEL,
+        CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,
     };
     use runtime::{ContentBlock, ConversationMessage, MessageRole, PermissionMode};
-    use std::path::PathBuf;
+    use std::path::{Path, PathBuf};
 
     #[test]
     fn defaults_to_repl_when_no_args() {
@@ -2508,10 +2535,6 @@ mod tests {
             parse_args(&["logout".to_string()]).expect("logout should parse"),
             CliAction::Logout
         );
-        assert_eq!(
-            parse_args(&["init".to_string()]).expect("init should parse"),
-            CliAction::Init
-        );
     }
 
     #[test]
@@ -2666,11 +2689,12 @@ mod tests {
     }
 
     #[test]
-    fn init_help_mentions_direct_subcommand() {
+    fn init_report_uses_structured_output() {
-        let mut help = Vec::new();
+        let created = format_init_report(Path::new("/tmp/CLAUDE.md"), true);
-        print_help_to(&mut help).expect("help should render");
+        assert!(created.contains("Init"));
-        let help = String::from_utf8(help).expect("help should be utf8");
+        assert!(created.contains("Result           created"));
-        assert!(help.contains("rusty-claude-cli init"));
+        let skipped = format_init_report(Path::new("/tmp/CLAUDE.md"), false);
+        assert!(skipped.contains("skipped (already exists)"));
     }
 
     #[test]
@@ -2774,7 +2798,7 @@ mod tests {
     fn status_context_reads_real_workspace_metadata() {
         let context = status_context(None).expect("status context should load");
         assert!(context.cwd.is_absolute());
-        assert_eq!(context.discovered_config_files, 5);
+        assert!(context.discovered_config_files >= 3);
         assert!(context.loaded_config_files <= context.discovered_config_files);
     }
 
@@ -2832,7 +2856,7 @@ mod tests {
 
     #[test]
     fn init_template_mentions_detected_rust_workspace() {
-        let rendered = crate::init::render_init_claude_md(std::path::Path::new("."));
+        let rendered = render_init_claude_md(Path::new("."));
         assert!(rendered.contains("# CLAUDE.md"));
         assert!(rendered.contains("cargo clippy --workspace --all-targets -- -D warnings"));
     }

rust/crates/tools/Cargo.toml

@@ -6,10 +6,12 @@ license.workspace = true
 publish.workspace = true
 
 [dependencies]
+api = { path = "../api" }
 runtime = { path = "../runtime" }
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
 
 [lints]
 workspace = true

rust/crates/tools/src/lib.rs

@@ -3,10 +3,17 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::{Duration, Instant};
 
+use api::{
+    resolve_startup_auth_source, AnthropicClient, ContentBlockDelta, InputContentBlock,
+    InputMessage, MessageRequest, OutputContentBlock, StreamEvent as ApiStreamEvent, ToolChoice,
+    ToolDefinition, ToolResultContentBlock,
+};
 use reqwest::blocking::Client;
 use runtime::{
-    edit_file, execute_bash, glob_search, grep_search, read_file, write_file, BashCommandInput,
+    edit_file, execute_bash, glob_search, grep_search, load_system_prompt, read_file, write_file,
-    GrepSearchInput, PermissionMode,
+    ApiClient, ApiRequest, AssistantEvent, BashCommandInput, ConfigLoader, ContentBlock,
+    ConversationMessage, ConversationRuntime, GrepSearchInput, MessageRole, PermissionMode,
+    PermissionPolicy, RuntimeError, Session, TokenUsage, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -234,7 +241,8 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
         },
         ToolSpec {
             name: "Agent",
-            description: "Launch a specialized agent task and persist its handoff metadata.",
+            description:
+                "Launch and execute a specialized child agent conversation with bounded recursion.",
             input_schema: json!({
                 "type": "object",
                 "properties": {
@@ -242,7 +250,8 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                     "prompt": { "type": "string" },
                     "subagent_type": { "type": "string" },
                     "name": { "type": "string" },
-                    "model": { "type": "string" }
+                    "model": { "type": "string" },
+                    "max_depth": { "type": "integer", "minimum": 0 }
                 },
                 "required": ["description", "prompt"],
                 "additionalProperties": false
@@ -579,6 +588,7 @@ struct AgentInput {
     subagent_type: Option<String>,
     name: Option<String>,
     model: Option<String>,
+    max_depth: Option<usize>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -712,6 +722,16 @@ struct AgentOutput {
     subagent_type: Option<String>,
     model: Option<String>,
     status: String,
+    #[serde(rename = "maxDepth")]
+    max_depth: usize,
+    #[serde(rename = "depth")]
+    depth: usize,
+    #[serde(rename = "result")]
+    result: Option<String>,
+    #[serde(rename = "assistantMessages")]
+    assistant_messages: Vec<String>,
+    #[serde(rename = "toolResults")]
+    tool_results: Vec<AgentToolResult>,
     #[serde(rename = "outputFile")]
     output_file: String,
     #[serde(rename = "manifestFile")]
@@ -720,6 +740,15 @@ struct AgentOutput {
     created_at: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct AgentToolResult {
+    #[serde(rename = "toolName")]
+    tool_name: String,
+    output: String,
+    #[serde(rename = "isError")]
+    is_error: bool,
+}
+
 #[derive(Debug, Serialize)]
 struct ToolSearchOutput {
     matches: Vec<String>,
@@ -1331,6 +1360,14 @@ fn execute_agent(input: AgentInput) -> Result<AgentOutput, String> {
         return Err(String::from("prompt must not be empty"));
     }
 
+    let depth = current_agent_depth()?;
+    let max_depth = input.max_depth.unwrap_or(3);
+    if depth >= max_depth {
+        return Err(format!(
+            "Agent max_depth exceeded: current depth {depth} reached limit {max_depth}"
+        ));
+    }
+
     let agent_id = make_agent_id();
     let output_dir = agent_store_dir()?;
     std::fs::create_dir_all(&output_dir).map_err(|error| error.to_string())?;
@@ -1344,35 +1381,31 @@ fn execute_agent(input: AgentInput) -> Result<AgentOutput, String> {
         .filter(|name| !name.is_empty())
         .unwrap_or_else(|| slugify_agent_name(&input.description));
     let created_at = iso8601_now();
+    let model = input.model.clone().or_else(agent_default_model);
 
-    let output_contents = format!(
+    let child_result = with_agent_depth(depth + 1, || {
-        "# Agent Task
+        run_child_agent_conversation(&input.prompt, model.clone(), max_depth)
-
+    })?;
-- id: {}
-- name: {}
-- description: {}
-- subagent_type: {}
-- created_at: {}
-
-## Prompt
-
-{}
-",
-        agent_id, agent_name, input.description, normalized_subagent_type, created_at, input.prompt
-    );
-    std::fs::write(&output_file, output_contents).map_err(|error| error.to_string())?;
 
     let manifest = AgentOutput {
         agent_id,
         name: agent_name,
         description: input.description,
         subagent_type: Some(normalized_subagent_type),
-        model: input.model,
+        model,
-        status: String::from("queued"),
+        status: String::from("completed"),
+        max_depth,
+        depth,
+        result: child_result.result.clone(),
+        assistant_messages: child_result.assistant_messages.clone(),
+        tool_results: child_result.tool_results.clone(),
         output_file: output_file.display().to_string(),
         manifest_file: manifest_file.display().to_string(),
         created_at,
     };
+
+    let output_contents = render_agent_output(&manifest);
+    std::fs::write(&output_file, output_contents).map_err(|error| error.to_string())?;
     std::fs::write(
         &manifest_file,
         serde_json::to_string_pretty(&manifest).map_err(|error| error.to_string())?,
@@ -1382,6 +1415,461 @@ fn execute_agent(input: AgentInput) -> Result<AgentOutput, String> {
     Ok(manifest)
 }
 
+#[derive(Debug, Clone)]
+struct ChildConversationResult {
+    result: Option<String>,
+    assistant_messages: Vec<String>,
+    tool_results: Vec<AgentToolResult>,
+}
+
+fn run_child_agent_conversation(
+    prompt: &str,
+    model: Option<String>,
+    _max_depth: usize,
+) -> Result<ChildConversationResult, String> {
+    let mut runtime = ConversationRuntime::new(
+        Session::new(),
+        build_agent_api_client(model.unwrap_or_else(default_agent_model))?,
+        AgentToolExecutor,
+        agent_permission_policy(),
+        build_agent_system_prompt()?,
+    )
+    .with_max_iterations(16);
+
+    let summary = runtime
+        .run_turn(prompt, None)
+        .map_err(|error| error.to_string())?;
+
+    let assistant_messages = summary
+        .assistant_messages
+        .iter()
+        .filter_map(extract_message_text)
+        .collect::<Vec<_>>();
+    let tool_results = summary
+        .tool_results
+        .iter()
+        .filter_map(extract_agent_tool_result)
+        .collect::<Vec<_>>();
+    let result = assistant_messages.last().cloned();
+
+    Ok(ChildConversationResult {
+        result,
+        assistant_messages,
+        tool_results,
+    })
+}
+
+fn render_agent_output(output: &AgentOutput) -> String {
+    let mut lines = vec![
+        "# Agent Task".to_string(),
+        String::new(),
+        format!("- id: {}", output.agent_id),
+        format!("- name: {}", output.name),
+        format!("- description: {}", output.description),
+        format!(
+            "- subagent_type: {}",
+            output.subagent_type.as_deref().unwrap_or("general-purpose")
+        ),
+        format!("- status: {}", output.status),
+        format!("- depth: {}", output.depth),
+        format!("- max_depth: {}", output.max_depth),
+        format!("- created_at: {}", output.created_at),
+        String::new(),
+        "## Result".to_string(),
+        String::new(),
+        output
+            .result
+            .clone()
+            .unwrap_or_else(|| String::from("<no final assistant text>")),
+    ];
+
+    if !output.tool_results.is_empty() {
+        lines.push(String::new());
+        lines.push("## Tool Results".to_string());
+        lines.push(String::new());
+        lines.extend(output.tool_results.iter().map(|result| {
+            format!(
+                "- {} [{}]: {}",
+                result.tool_name,
+                if result.is_error { "error" } else { "ok" },
+                result.output
+            )
+        }));
+    }
+
+    lines.join("\n")
+}
+
+fn current_agent_depth() -> Result<usize, String> {
+    std::env::var("CLAWD_AGENT_DEPTH")
+        .ok()
+        .map(|value| {
+            value
+                .parse::<usize>()
+                .map_err(|error| format!("invalid CLAWD_AGENT_DEPTH: {error}"))
+        })
+        .transpose()
+        .map(|value| value.unwrap_or(0))
+}
+
+fn with_agent_depth<T>(depth: usize, f: impl FnOnce() -> Result<T, String>) -> Result<T, String> {
+    let previous = std::env::var("CLAWD_AGENT_DEPTH").ok();
+    std::env::set_var("CLAWD_AGENT_DEPTH", depth.to_string());
+    let result = f();
+    if let Some(previous) = previous {
+        std::env::set_var("CLAWD_AGENT_DEPTH", previous);
+    } else {
+        std::env::remove_var("CLAWD_AGENT_DEPTH");
+    }
+    result
+}
+
+fn agent_default_model() -> Option<String> {
+    std::env::var("CLAWD_MODEL")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+}
+
+fn default_agent_model() -> String {
+    agent_default_model().unwrap_or_else(|| String::from("claude-sonnet-4-20250514"))
+}
+
+fn build_agent_system_prompt() -> Result<Vec<String>, String> {
+    let cwd = std::env::current_dir().map_err(|error| error.to_string())?;
+    let date = std::env::var("CLAWD_CURRENT_DATE").unwrap_or_else(|_| String::from("2026-04-01"));
+    load_system_prompt(cwd, &date, std::env::consts::OS, "unknown")
+        .map_err(|error| error.to_string())
+}
+
+fn agent_permission_policy() -> PermissionPolicy {
+    mvp_tool_specs().into_iter().fold(
+        PermissionPolicy::new(PermissionMode::DangerFullAccess),
+        |policy, spec| policy.with_tool_requirement(spec.name, spec.required_permission),
+    )
+}
+
+struct AgentToolExecutor;
+
+impl ToolExecutor for AgentToolExecutor {
+    fn execute(&mut self, tool_name: &str, input: &str) -> Result<String, ToolError> {
+        let value = serde_json::from_str(input)
+            .map_err(|error| ToolError::new(format!("invalid tool input JSON: {error}")))?;
+        execute_tool(tool_name, &value).map_err(ToolError::new)
+    }
+}
+
+enum AgentApiClient {
+    Scripted(ScriptedAgentApiClient),
+    Anthropic(AnthropicAgentApiClient),
+}
+
+impl ApiClient for AgentApiClient {
+    fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
+        match self {
+            Self::Scripted(client) => client.stream(request),
+            Self::Anthropic(client) => client.stream(request),
+        }
+    }
+}
+
+fn build_agent_api_client(model: String) -> Result<AgentApiClient, String> {
+    if let Some(script) = std::env::var("CLAWD_AGENT_TEST_SCRIPT")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+    {
+        return Ok(AgentApiClient::Scripted(ScriptedAgentApiClient::new(
+            &script,
+        )?));
+    }
+
+    Ok(AgentApiClient::Anthropic(AnthropicAgentApiClient::new(
+        model,
+    )?))
+}
+
+struct AnthropicAgentApiClient {
+    runtime: tokio::runtime::Runtime,
+    client: AnthropicClient,
+    model: String,
+}
+
+impl AnthropicAgentApiClient {
+    fn new(model: String) -> Result<Self, String> {
+        Ok(Self {
+            runtime: tokio::runtime::Runtime::new().map_err(|error| error.to_string())?,
+            client: AnthropicClient::from_auth(resolve_agent_auth_source()?),
+            model,
+        })
+    }
+}
+
+impl ApiClient for AnthropicAgentApiClient {
+    fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
+        let message_request = MessageRequest {
+            model: self.model.clone(),
+            max_tokens: 32,
+            messages: convert_agent_messages(&request.messages),
+            system: (!request.system_prompt.is_empty()).then(|| {
+                request.system_prompt.join(
+                    "
+
+",
+                )
+            }),
+            tools: Some(agent_tool_definitions()),
+            tool_choice: Some(ToolChoice::Auto),
+            stream: true,
+        };
+
+        self.runtime.block_on(async {
+            let mut stream = self
+                .client
+                .stream_message(&message_request)
+                .await
+                .map_err(|error| RuntimeError::new(error.to_string()))?;
+            let mut events = Vec::new();
+            let mut pending_tool: Option<(String, String, String)> = None;
+            let mut saw_stop = false;
+
+            while let Some(event) = stream
+                .next_event()
+                .await
+                .map_err(|error| RuntimeError::new(error.to_string()))?
+            {
+                match event {
+                    ApiStreamEvent::MessageStart(start) => {
+                        push_agent_output_blocks(
+                            start.message.content,
+                            &mut events,
+                            &mut pending_tool,
+                        );
+                    }
+                    ApiStreamEvent::ContentBlockStart(start) => {
+                        push_agent_output_block(
+                            start.content_block,
+                            &mut events,
+                            &mut pending_tool,
+                        );
+                    }
+                    ApiStreamEvent::ContentBlockDelta(delta) => match delta.delta {
+                        ContentBlockDelta::TextDelta { text } => {
+                            if !text.is_empty() {
+                                events.push(AssistantEvent::TextDelta(text));
+                            }
+                        }
+                        ContentBlockDelta::InputJsonDelta { partial_json } => {
+                            if let Some((_, _, input)) = &mut pending_tool {
+                                input.push_str(&partial_json);
+                            }
+                        }
+                    },
+                    ApiStreamEvent::ContentBlockStop(_) => {
+                        if let Some((id, name, input)) = pending_tool.take() {
+                            events.push(AssistantEvent::ToolUse { id, name, input });
+                        }
+                    }
+                    ApiStreamEvent::MessageDelta(delta) => {
+                        events.push(AssistantEvent::Usage(TokenUsage {
+                            input_tokens: delta.usage.input_tokens,
+                            output_tokens: delta.usage.output_tokens,
+                            cache_creation_input_tokens: delta.usage.cache_creation_input_tokens,
+                            cache_read_input_tokens: delta.usage.cache_read_input_tokens,
+                        }));
+                    }
+                    ApiStreamEvent::MessageStop(_) => {
+                        saw_stop = true;
+                        events.push(AssistantEvent::MessageStop);
+                    }
+                }
+            }
+
+            if !saw_stop {
+                events.push(AssistantEvent::MessageStop);
+            }
+
+            Ok(events)
+        })
+    }
+}
+
+fn resolve_agent_auth_source() -> Result<api::AuthSource, String> {
+    resolve_startup_auth_source(|| {
+        let cwd = std::env::current_dir().map_err(api::ApiError::from)?;
+        let config = ConfigLoader::default_for(&cwd).load().map_err(|error| {
+            api::ApiError::Auth(format!("failed to load runtime OAuth config: {error}"))
+        })?;
+        Ok(config.oauth().cloned())
+    })
+    .map_err(|error| error.to_string())
+}
+
+fn agent_tool_definitions() -> Vec<ToolDefinition> {
+    mvp_tool_specs()
+        .into_iter()
+        .map(|spec| ToolDefinition {
+            name: spec.name.to_string(),
+            description: Some(spec.description.to_string()),
+            input_schema: spec.input_schema,
+        })
+        .collect()
+}
+
+fn convert_agent_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
+    messages
+        .iter()
+        .filter_map(|message| {
+            let role = match message.role {
+                MessageRole::System | MessageRole::User | MessageRole::Tool => "user",
+                MessageRole::Assistant => "assistant",
+            };
+            let content = message
+                .blocks
+                .iter()
+                .map(|block| match block {
+                    ContentBlock::Text { text } => InputContentBlock::Text { text: text.clone() },
+                    ContentBlock::ToolUse { id, name, input } => InputContentBlock::ToolUse {
+                        id: id.clone(),
+                        name: name.clone(),
+                        input: serde_json::from_str(input)
+                            .unwrap_or_else(|_| serde_json::json!({ "raw": input })),
+                    },
+                    ContentBlock::ToolResult {
+                        tool_use_id,
+                        output,
+                        is_error,
+                        ..
+                    } => InputContentBlock::ToolResult {
+                        tool_use_id: tool_use_id.clone(),
+                        content: vec![ToolResultContentBlock::Text {
+                            text: output.clone(),
+                        }],
+                        is_error: *is_error,
+                    },
+                })
+                .collect::<Vec<_>>();
+            (!content.is_empty()).then(|| InputMessage {
+                role: role.to_string(),
+                content,
+            })
+        })
+        .collect()
+}
+
+fn push_agent_output_blocks(
+    blocks: Vec<OutputContentBlock>,
+    events: &mut Vec<AssistantEvent>,
+    pending_tool: &mut Option<(String, String, String)>,
+) {
+    for block in blocks {
+        push_agent_output_block(block, events, pending_tool);
+        if let Some((id, name, input)) = pending_tool.take() {
+            events.push(AssistantEvent::ToolUse { id, name, input });
+        }
+    }
+}
+
+fn push_agent_output_block(
+    block: OutputContentBlock,
+    events: &mut Vec<AssistantEvent>,
+    pending_tool: &mut Option<(String, String, String)>,
+) {
+    match block {
+        OutputContentBlock::Text { text } => {
+            if !text.is_empty() {
+                events.push(AssistantEvent::TextDelta(text));
+            }
+        }
+        OutputContentBlock::ToolUse { id, name, input } => {
+            *pending_tool = Some((id, name, input.to_string()));
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ScriptedAgentApiClient {
+    turns: Vec<Vec<ScriptedAgentEvent>>,
+    call_count: usize,
+}
+
+impl ScriptedAgentApiClient {
+    fn new(script: &str) -> Result<Self, String> {
+        let turns = serde_json::from_str(script).map_err(|error| error.to_string())?;
+        Ok(Self {
+            turns,
+            call_count: 0,
+        })
+    }
+}
+
+impl ApiClient for ScriptedAgentApiClient {
+    fn stream(&mut self, _request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
+        if self.call_count >= self.turns.len() {
+            return Err(RuntimeError::new("scripted agent client exhausted"));
+        }
+        let events = self.turns[self.call_count]
+            .iter()
+            .map(ScriptedAgentEvent::to_runtime_event)
+            .chain(std::iter::once(AssistantEvent::MessageStop))
+            .collect();
+        self.call_count += 1;
+        Ok(events)
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+enum ScriptedAgentEvent {
+    Text {
+        text: String,
+    },
+    ToolUse {
+        id: String,
+        name: String,
+        input: Value,
+    },
+}
+
+impl ScriptedAgentEvent {
+    fn to_runtime_event(&self) -> AssistantEvent {
+        match self {
+            Self::Text { text } => AssistantEvent::TextDelta(text.clone()),
+            Self::ToolUse { id, name, input } => AssistantEvent::ToolUse {
+                id: id.clone(),
+                name: name.clone(),
+                input: input.to_string(),
+            },
+        }
+    }
+}
+
+fn extract_message_text(message: &ConversationMessage) -> Option<String> {
+    let text = message
+        .blocks
+        .iter()
+        .filter_map(|block| match block {
+            ContentBlock::Text { text } => Some(text.as_str()),
+            _ => None,
+        })
+        .collect::<String>();
+    (!text.is_empty()).then_some(text)
+}
+
+fn extract_agent_tool_result(message: &ConversationMessage) -> Option<AgentToolResult> {
+    message.blocks.iter().find_map(|block| match block {
+        ContentBlock::ToolResult {
+            tool_name,
+            output,
+            is_error,
+            ..
+        } => Some(AgentToolResult {
+            tool_name: tool_name.clone(),
+            output: output.clone(),
+            is_error: *is_error,
+        }),
+        _ => None,
+    })
+}
+
 #[allow(clippy::needless_pass_by_value)]
 fn execute_tool_search(input: ToolSearchInput) -> ToolSearchOutput {
     let deferred = deferred_tool_specs();
@@ -2763,12 +3251,28 @@ mod tests {
     }
 
     #[test]
-    fn agent_persists_handoff_metadata() {
+    fn agent_executes_child_conversation_and_persists_results() {
         let _guard = env_lock()
             .lock()
             .unwrap_or_else(std::sync::PoisonError::into_inner);
         let dir = temp_path("agent-store");
         std::env::set_var("CLAWD_AGENT_STORE", &dir);
+        std::env::set_var(
+            "CLAWD_AGENT_TEST_SCRIPT",
+            serde_json::to_string(&vec![
+                vec![json!({
+                    "type": "tool_use",
+                    "id": "tool-1",
+                    "name": "StructuredOutput",
+                    "input": {"ok": true, "items": [1, 2, 3]}
+                })],
+                vec![json!({
+                    "type": "text",
+                    "text": "Child agent completed successfully."
+                })],
+            ])
+            .expect("script json"),
+        );
 
         let result = execute_tool(
             "Agent",
@@ -2780,22 +3284,35 @@ mod tests {
             }),
         )
         .expect("Agent should succeed");
+        std::env::remove_var("CLAWD_AGENT_TEST_SCRIPT");
         std::env::remove_var("CLAWD_AGENT_STORE");
 
         let output: serde_json::Value = serde_json::from_str(&result).expect("valid json");
         assert_eq!(output["name"], "ship-audit");
         assert_eq!(output["subagentType"], "Explore");
-        assert_eq!(output["status"], "queued");
+        assert_eq!(output["status"], "completed");
-        assert!(output["createdAt"].as_str().is_some());
+        assert_eq!(output["depth"], 0);
+        assert_eq!(output["maxDepth"], 3);
+        assert_eq!(output["result"], "Child agent completed successfully.");
+        assert_eq!(output["toolResults"][0]["toolName"], "StructuredOutput");
+        assert_eq!(output["toolResults"][0]["isError"], false);
         let manifest_file = output["manifestFile"].as_str().expect("manifest file");
         let output_file = output["outputFile"].as_str().expect("output file");
         let contents = std::fs::read_to_string(output_file).expect("agent file exists");
         let manifest_contents =
             std::fs::read_to_string(manifest_file).expect("manifest file exists");
-        assert!(contents.contains("Audit the branch"));
+        assert!(contents.contains("Child agent completed successfully."));
-        assert!(contents.contains("Check tests and outstanding work."));
+        assert!(contents.contains("StructuredOutput [ok]"));
         assert!(manifest_contents.contains("\"subagentType\": \"Explore\""));
 
+        std::env::set_var(
+            "CLAWD_AGENT_TEST_SCRIPT",
+            serde_json::to_string(&vec![vec![json!({
+                "type": "text",
+                "text": "Normalized alias check."
+            })]])
+            .expect("script json"),
+        );
         let normalized = execute_tool(
             "Agent",
             &json!({
@@ -2805,10 +3322,19 @@ mod tests {
             }),
         )
         .expect("Agent should normalize built-in aliases");
+        std::env::remove_var("CLAWD_AGENT_TEST_SCRIPT");
         let normalized_output: serde_json::Value =
             serde_json::from_str(&normalized).expect("valid json");
         assert_eq!(normalized_output["subagentType"], "Explore");
 
+        std::env::set_var(
+            "CLAWD_AGENT_TEST_SCRIPT",
+            serde_json::to_string(&vec![vec![json!({
+                "type": "text",
+                "text": "Name normalization check."
+            })]])
+            .expect("script json"),
+        );
         let named = execute_tool(
             "Agent",
             &json!({
@@ -2818,13 +3344,14 @@ mod tests {
             }),
         )
         .expect("Agent should normalize explicit names");
+        std::env::remove_var("CLAWD_AGENT_TEST_SCRIPT");
         let named_output: serde_json::Value = serde_json::from_str(&named).expect("valid json");
         assert_eq!(named_output["name"], "ship-audit");
         let _ = std::fs::remove_dir_all(dir);
     }
 
     #[test]
-    fn agent_rejects_blank_required_fields() {
+    fn agent_rejects_blank_required_fields_and_enforces_max_depth() {
         let missing_description = execute_tool(
             "Agent",
             &json!({
@@ -2844,6 +3371,22 @@ mod tests {
         )
         .expect_err("blank prompt should fail");
         assert!(missing_prompt.contains("prompt must not be empty"));
+
+        let _guard = env_lock()
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        std::env::set_var("CLAWD_AGENT_DEPTH", "1");
+        let depth_error = execute_tool(
+            "Agent",
+            &json!({
+                "description": "Nested agent",
+                "prompt": "Do nested work.",
+                "max_depth": 1
+            }),
+        )
+        .expect_err("max depth should fail");
+        std::env::remove_var("CLAWD_AGENT_DEPTH");
+        assert!(depth_error.contains("max_depth exceeded"));
     }
 
     #[test]