@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-core/tests/route.rs

@@ -1,1476 +1 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use naome_core::{evaluate_route, explain_route, EvaluationOptions, RouteOptions};
-use serde_json::{json, Value};
-
-#[test]
-fn dry_route_reports_auto_baseline_without_mutating() {
-    let repo = TestRepo::completed_task_with_diff("route-dry-auto");
-    let before = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "Start a new task for README polish.",
-        RouteOptions {
-            execute: false,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_completed_task_then_create_new_task"
-    );
-    assert!(!route.mutation_performed);
-    assert!(!route.can_create_task);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before);
-    assert!(!route.user_message.contains("commit_task_baseline"));
-    assert!(route.human_options.is_empty());
-}
-
-#[test]
-fn execute_route_auto_baselines_then_admits_next_task_and_writes_local_journal() {
-    let repo = TestRepo::completed_task_with_diff("route-execute-auto");
-
-    let route = evaluate_route(
-        repo.path(),
-        "Start a new task for README polish.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_completed_task_then_create_new_task"
-    );
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert!(route
-        .executed_actions
-        .contains(&"commit_task_baseline".to_string()));
-    assert!(repo.git_status_short().is_empty());
-
-    let journal = fs::read_to_string(repo.path().join(".naome/task-journal.jsonl")).unwrap();
-    assert!(journal.contains("\"taskId\":\"readme-task\""));
-    assert!(journal.contains("\"outcome\":\"route_auto_baseline\""));
-}
-
-#[test]
-fn execute_route_baselines_completed_task_and_creates_worktree_for_unrelated_user_edit() {
-    let repo = TestRepo::completed_task_with_unrelated_user_edit("route-preserve-user-edit");
-
-    let route = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_completed_task_then_create_isolated_task_worktree"
-    );
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert!(route.user_message.contains("isolated task worktree"));
-    assert!(route.human_options.is_empty());
-    assert_ne!(route.task_root, repo.path().to_string_lossy());
-    assert!(route.worktree.is_some());
-    assert_eq!(repo.git_status_short(), "M USER.md");
-    assert_eq!(
-        TestRepo::git_status_short_at(Path::new(&route.task_root)),
-        ""
-    );
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("README.md"));
-    assert!(!committed_paths.contains("USER.md"));
-}
-
-#[test]
-fn execute_route_creates_worktree_for_dirty_repo_new_task() {
-    let repo = TestRepo::new("route-dirty-worktree");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_file("USER.md", "user baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("USER.md", "user local edit\n");
-
-    let route = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "create_isolated_task_worktree");
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert!(route.worktree.is_some());
-    assert_eq!(repo.git_status_short(), "M USER.md");
-    assert_eq!(
-        TestRepo::git_status_short_at(Path::new(&route.task_root)),
-        ""
-    );
-}
-
-#[test]
-fn execute_route_does_not_mutate_or_offer_clear_commit_for_dirty_unowned_diff() {
-    let repo = TestRepo::new("route-dirty-commit-request");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-    let before_status = repo.git_status_short();
-
-    let route = evaluate_route(
-        repo.path(),
-        "clear_or_commit_unowned_diff",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "block_unowned_diff");
-    assert!(!route.mutation_performed);
-    assert!(!route.can_create_task);
-    assert_eq!(route.executed_actions, Vec::<String>::new());
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert_eq!(repo.git_status_short(), before_status);
-    assert!(!route
-        .human_options
-        .contains(&"clear_or_commit_unowned_diff".to_string()));
-}
-
-#[test]
-fn execute_route_commits_user_diff_after_quality_gate_passes() {
-    let repo = TestRepo::new("route-user-diff-quality-pass");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_readme_quality_verification(Vec::new(), vec!["diff-check"]);
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit\n");
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(route.allowed);
-    assert!(route.mutation_performed);
-    assert_eq!(
-        route.executed_actions,
-        vec![
-            "run_user_diff_quality_gate".to_string(),
-            "commit_user_diff".to_string()
-        ]
-    );
-    assert_eq!(repo.git_status_short(), "");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("README.md"));
-    assert!(route.user_message.contains("quality gates passed"));
-}
-
-#[test]
-fn execute_route_commits_product_diff_with_declared_safe_quality_checks() {
-    let repo = TestRepo::new("route-product-diff-quality-pass");
-    repo.init_git();
-    repo.write_file(
-        "packages/naome/crates/naome-core/src/route.rs",
-        "pub fn baseline() {}\n",
-    );
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_product_quality_verification();
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file(
-        "packages/naome/crates/naome-core/src/route.rs",
-        "pub fn changed() {}\n",
-    );
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(route.allowed);
-    assert!(route.mutation_performed);
-    assert_eq!(
-        route.executed_actions,
-        vec![
-            "run_user_diff_quality_gate".to_string(),
-            "commit_user_diff".to_string()
-        ]
-    );
-    assert_eq!(repo.git_status_short(), "");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("packages/naome/crates/naome-core/src/route.rs"));
-    assert!(route.user_message.contains("quality gates passed"));
-}
-
-#[test]
-fn execute_route_preserves_staged_rename_when_committing_user_diff() {
-    let repo = TestRepo::new("route-user-diff-staged-rename");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_naome_json(
-        "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "checks": [
-                {
-                    "id": "diff-check",
-                    "command": "git diff --check",
-                    "cwd": ".",
-                    "purpose": "Reject whitespace errors.",
-                    "cost": "fast",
-                    "source": "test",
-                    "evidence": ["README.md", "INTRO.md"],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "docs",
-                    "description": "Repository docs.",
-                    "paths": ["README.md", "INTRO.md"],
-                    "requiredChecks": ["diff-check"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-            "releaseGates": []
-        }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.git(&["mv", "README.md", "INTRO.md"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(route.allowed);
-    assert!(route.mutation_performed);
-    assert_eq!(repo.git_status_short(), "");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-status", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("README.md"));
-    assert!(committed_paths.contains("INTRO.md"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_without_quality_coverage() {
-    let repo = TestRepo::new("route-user-diff-no-quality-coverage");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("README.md"));
-    assert!(route.user_message.contains("No quality coverage"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_when_check_mutates_after_diff_check() {
-    let repo = TestRepo::new("route-user-diff-mutating-check");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_readme_quality_verification(
-        vec![json!({
-            "id": "mutate-readme-after-check",
-            "command": "node -e \"require('fs').writeFileSync('README.md', '# Mutated  \\\\n')\"",
-            "cwd": ".",
-            "purpose": "Simulate a mutating check that dirties checked content.",
-            "cost": "fast",
-            "source": "test",
-            "evidence": ["README.md"],
-            "lastVerified": null
-        })],
-        vec!["mutate-readme-after-check"],
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("README.md"));
-    assert_eq!(
-        fs::read_to_string(repo.path().join("README.md")).unwrap(),
-        "# Manual edit\n"
-    );
-    assert!(route
-        .user_message
-        .contains("will not execute repository-controlled verification commands"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_when_diff_check_command_is_unsafe() {
-    let repo = TestRepo::new("route-user-diff-mutating-diff-check");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_naome_json(
-        "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "checks": [
-                {
-                    "id": "diff-check",
-                    "command": "node -e \"const fs = require('fs'); const marker = '.git/naome-diff-check-marker'; if (fs.existsSync(marker)) { fs.writeFileSync('NEW.md', '# unexpected\\\\n'); } else { fs.writeFileSync(marker, 'x'); }\"",
-                    "cwd": ".",
-                    "purpose": "Simulate a mutating diff check.",
-                    "cost": "fast",
-                    "source": "test",
-                    "evidence": ["README.md"],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "readme",
-                    "description": "README changes.",
-                    "paths": ["README.md"],
-                    "requiredChecks": ["diff-check"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-            "releaseGates": []
-        }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(!repo.path().join("NEW.md").exists());
-    assert!(route
-        .user_message
-        .contains("Quality check diff-check has an unsafe command or cwd"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_when_quality_gate_fails() {
-    let repo = TestRepo::new("route-user-diff-quality-fail");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_readme_quality_verification(Vec::new(), vec!["diff-check"]);
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Manual edit  \n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("README.md"));
-    assert_eq!(route.human_options, vec!["review_unowned_diff"]);
-    assert!(route.user_message.contains("quality gate failed"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_when_dogfood_health_finds_integrity_mismatch() {
-    let repo = TestRepo::from_template("route-user-diff-dogfood-health-integrity");
-    repo.init_git();
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_dogfood_readme_quality_verification();
-    repo.write_file(
-        ".naome/bin/check-task-state.js",
-        "#!/usr/bin/env node\nconsole.log('already tampered');\n",
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Local edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("README.md"));
-    assert!(route.user_message.contains("quality gate failed"));
-    assert!(route.user_message.contains("integrity mismatch"));
-}
-
-#[test]
-fn execute_route_refuses_user_diff_commit_when_task_state_check_finds_template_integrity_mismatch()
-{
-    let repo = TestRepo::new("route-user-diff-task-state-integrity");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_task_state_readme_quality_verification();
-    repo.copy_packaged_template_to_route_template_root();
-    repo.write_file(
-        "packages/naome/templates/naome-root/.naome/bin/check-task-state.js",
-        "#!/usr/bin/env node\nconsole.log('already tampered');\n",
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("README.md", "# Local edit\n");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit my changes",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
-    assert!(!route.allowed);
-    assert!(!route.mutation_performed);
-    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("README.md"));
-    assert!(route.user_message.contains("quality gate failed"));
-    assert!(route.user_message.contains("integrity mismatch"));
-}
-
-#[test]
-fn execute_route_baselines_harness_refresh_before_dirty_repo_worktree() {
-    let repo = TestRepo::new("route-dirty-harness-refresh-worktree");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_file("USER.md", "user baseline\n");
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nOld harness.\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "old",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "standard",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-    repo.write_file("USER.md", "user local edit\n");
-
-    let route = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_harness_refresh_then_create_isolated_task_worktree"
-    );
-    assert_eq!(
-        route.executed_actions,
-        vec![
-            "commit_harness_refresh_baseline".to_string(),
-            "create_task_worktree".to_string()
-        ]
-    );
-    assert!(route.can_create_task);
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert!(route.worktree.is_some());
-    assert_eq!(repo.git_status_short(), "M USER.md");
-    assert_eq!(
-        TestRepo::git_status_short_at(Path::new(&route.task_root)),
-        ""
-    );
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("AGENTS.md"));
-    assert!(committed_paths.contains(".naome/manifest.json"));
-    assert!(!committed_paths.contains("USER.md"));
-}
-
-#[test]
-fn execute_route_baselines_pure_harness_refresh_before_new_task_without_worktree() {
-    let repo = TestRepo::new("route-pure-harness-refresh-no-worktree");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nOld harness.\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "old",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-    repo.write_base_naome_state(completed_task_state(&admission_head));
-    repo.git(&["add", ".naome/task-state.json"]);
-    repo.git(&["commit", "-m", "task state"]);
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "standard",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-
-    let route = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_harness_refresh_then_create_new_task"
-    );
-    assert_eq!(
-        route.executed_actions,
-        vec!["commit_harness_refresh_baseline".to_string()]
-    );
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert!(route.worktree.is_none());
-    assert_eq!(route.task_root, repo.path().to_string_lossy());
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert_eq!(repo.git_status_short(), "");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("AGENTS.md"));
-    assert!(committed_paths.contains(".naome/manifest.json"));
-    assert!(!committed_paths.contains("README.md"));
-}
-
-#[test]
-fn execute_route_repair_request_baselines_harness_refresh_only() {
-    let repo = TestRepo::new("route-harness-refresh-repair-only");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_file("USER.md", "user baseline\n");
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nOld harness.\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "old",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-    repo.write_naome_json(
-        "manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "standard",
-            "machineOwned": ["AGENTS.md"],
-            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-            "integrity": {}
-        }),
-    );
-    repo.write_file("USER.md", "user local edit\n");
-
-    let route = evaluate_route(
-        repo.path(),
-        "please repair all",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "auto_commit_harness_refresh_baseline");
-    assert!(route.mutation_performed);
-    assert_eq!(
-        route.executed_actions,
-        vec!["commit_harness_refresh_baseline".to_string()]
-    );
-    assert_eq!(repo.git_status_short(), "M USER.md");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("AGENTS.md"));
-    assert!(committed_paths.contains(".naome/manifest.json"));
-    assert!(!committed_paths.contains("USER.md"));
-}
-
-#[test]
-fn execute_route_refuses_to_create_more_than_max_isolated_worktrees() {
-    let repo = TestRepo::new("route-worktree-limit");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_file("USER.md", "user baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-    repo.write_file("USER.md", "user local edit\n");
-    let common_dir = repo.git_stdout(&["rev-parse", "--git-common-dir"]);
-    let worktree_root = repo.path().join(common_dir).join("naome").join("worktrees");
-    fs::create_dir_all(&worktree_root).unwrap();
-    for index in 0..25 {
-        fs::create_dir_all(worktree_root.join(format!("stale-{index}"))).unwrap();
-    }
-
-    let error = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap_err();
-
-    assert!(error
-        .to_string()
-        .contains("Too many NAOME task worktrees are present"));
-}
-
-#[test]
-fn execute_route_preflights_worktree_before_completed_task_baseline() {
-    let repo =
-        TestRepo::completed_task_with_unrelated_user_edit("route-completed-worktree-preflight");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-    let before_status = repo.git_status_short();
-    let common_dir = repo.git_stdout(&["rev-parse", "--git-common-dir"]);
-    let worktree_root = repo.path().join(common_dir).join("naome").join("worktrees");
-    fs::create_dir_all(&worktree_root).unwrap();
-    for index in 0..25 {
-        fs::create_dir_all(worktree_root.join(format!("stale-{index}"))).unwrap();
-    }
-
-    let error = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap_err();
-
-    assert!(error
-        .to_string()
-        .contains("Too many NAOME task worktrees are present"));
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert_eq!(repo.git_status_short(), before_status);
-}
-
-#[test]
-fn execute_route_uses_preflighted_worktree_name_after_completed_task_baseline() {
-    let repo = TestRepo::completed_task_with_unrelated_user_edit("route-worktree-name-preflight");
-    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-    let before_short = &before_head[..12];
-
-    let route = evaluate_route(
-        repo.path(),
-        "Add another line to README as a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    let worktree = route.worktree.expect("route should create a worktree");
-    assert!(worktree.branch.contains(before_short));
-    assert!(worktree.path.contains(before_short));
-}
-
-#[test]
-fn dry_route_plans_harness_refresh_split_before_completed_task_baseline() {
-    let repo = TestRepo::completed_task_with_harness_refresh_diff("route-dry-harness-refresh");
-    let before = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "Start a new task for README polish.",
-        RouteOptions {
-            execute: false,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
-    );
-    assert!(!route.mutation_performed);
-    assert!(!route.can_create_task);
-    assert!(route.human_options.is_empty());
-    assert!(route.intent.risk_codes.is_empty());
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before);
-}
-
-#[test]
-fn execute_route_splits_harness_refresh_then_completed_task_baseline() {
-    let repo = TestRepo::completed_task_with_harness_refresh_diff("route-execute-harness-refresh");
-
-    let route = evaluate_route(
-        repo.path(),
-        "Start a new task for README polish.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(
-        route.policy_action,
-        "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
-    );
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert_eq!(
-        route.executed_actions,
-        vec![
-            "commit_harness_refresh_baseline".to_string(),
-            "commit_task_baseline".to_string()
-        ]
-    );
-    assert_eq!(route.next_decision.state, "ready_for_task");
-    assert!(repo.git_status_short().is_empty());
-
-    let log = repo.git_stdout(&["log", "--format=%s", "-2"]);
-    assert!(log.contains("chore(naome): baseline completed task"));
-    assert!(log.contains("chore(naome): baseline harness refresh"));
-
-    let journal = fs::read_to_string(repo.path().join(".naome/task-journal.jsonl")).unwrap();
-    assert!(journal.contains("\"taskId\":\"readme-task\""));
-    assert!(journal.contains("\"outcome\":\"route_auto_baseline\""));
-}
-
-#[test]
-fn execute_route_does_not_mutate_when_prompt_blocks_commit() {
-    let repo = TestRepo::completed_task_with_diff("route-no-commit");
-    let before = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "Do not commit. Start a new task after this.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "block_auto_baseline_due_to_no_commit");
-    assert!(!route.mutation_performed);
-    assert!(!route.can_create_task);
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before);
-    assert!(repo.git_status_short().contains("README.md"));
-}
-
-#[test]
-fn explicit_route_commit_baseline_leaves_unrelated_user_edit_unstaged() {
-    let repo = TestRepo::completed_task_with_diff("route-commit-task-scope");
-    repo.write_file("USER.md", "user baseline\n");
-    repo.git(&["add", "USER.md"]);
-    repo.git(&["commit", "-m", "user baseline"]);
-    repo.write_file("README.md", "# Changed\n");
-    repo.write_file("USER.md", "user local edit\n");
-    repo.git(&["add", "USER.md"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "commit_task_baseline",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.policy_action, "commit_task_baseline");
-    assert!(route.mutation_performed);
-    assert_eq!(repo.git_status_short(), "M USER.md");
-
-    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
-    assert!(committed_paths.contains("README.md"));
-    assert!(!committed_paths.contains("USER.md"));
-}
-
-#[test]
-fn execute_route_journals_external_commit_after_completed_task() {
-    let repo = TestRepo::completed_task_with_diff("route-external-commit");
-    repo.git(&["add", "-A"]);
-    repo.git(&["commit", "-m", "manual baseline"]);
-    assert!(repo.git_status_short().is_empty());
-
-    let route = evaluate_route(
-        repo.path(),
-        "Create a new task for README polish.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::offline(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.repo_state_before, "ready_for_task");
-    assert!(route.mutation_performed);
-    assert!(route.can_create_task);
-    assert!(route
-        .executed_actions
-        .contains(&"journal_external_task_baseline".to_string()));
-
-    let journal = fs::read_to_string(repo.path().join(".naome/task-journal.jsonl")).unwrap();
-    assert!(journal.contains("\"outcome\":\"external_baseline\""));
-    assert!(journal.contains("\"taskId\":\"readme-task\""));
-}
-
-#[test]
-fn explain_reports_winning_rule_and_mutation_plan_without_executing() {
-    let repo = TestRepo::completed_task_with_diff("route-explain");
-    let before = repo.git_stdout(&["rev-parse", "HEAD"]);
-
-    let explain = explain_route(
-        repo.path(),
-        "Start a new task for README polish.",
-        EvaluationOptions::offline(),
-    )
-    .unwrap();
-
-    assert_eq!(
-        explain.winning_rule,
-        "completed_task_valid_new_task_auto_baseline"
-    );
-    assert!(explain.would_mutate);
-    assert!(explain
-        .discarded_candidate_actions
-        .contains(&"review_task_diff".to_string()));
-    assert!(explain
-        .required_context
-        .contains(&"docs/naome/execution.md".to_string()));
-    assert!(!explain.user_message.contains("commit_task_baseline"));
-    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before);
-}
-
-#[test]
-fn unhealthy_harness_route_blocks_normal_work() {
-    let repo = TestRepo::new("route-unhealthy");
-    repo.init_git();
-    repo.write_file("README.md", "# Baseline\n");
-    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-    repo.write_file(".naome/bin/check-harness-health.js", "process.exit(1);\n");
-    repo.git(&["add", "."]);
-    repo.git(&["commit", "-m", "baseline"]);
-
-    let route = evaluate_route(
-        repo.path(),
-        "Create a new task.",
-        RouteOptions {
-            execute: true,
-            evaluation: EvaluationOptions::online(),
-        },
-    )
-    .unwrap();
-
-    assert_eq!(route.repo_state_before, "harness_unhealthy");
-    assert!(!route.mutation_performed);
-    assert!(!route.can_create_task);
-    assert!(!route.human_options.is_empty());
-}
-
-struct TestRepo {
-    root: PathBuf,
-}
-
-impl TestRepo {
-    fn new(name: &str) -> Self {
-        let nonce = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let root = std::env::temp_dir().join(format!("naome-route-{name}-{nonce}"));
-        fs::create_dir_all(root.join(".naome")).unwrap();
-        Self { root }
-    }
-
-    fn from_template(name: &str) -> Self {
-        let repo = Self::new(name);
-        let template_root = packaged_template_root();
-        copy_dir(&template_root, repo.path());
-        fs::create_dir_all(repo.path().join(".naome/archive")).unwrap();
-        repo
-    }
-
-    fn copy_packaged_template_to_route_template_root(&self) {
-        copy_dir(&packaged_template_root(), &self.route_template_root());
-        fs::create_dir_all(self.route_template_root().join(".naome/archive")).unwrap();
-    }
-
-    fn route_template_root(&self) -> PathBuf {
-        self.root
-            .join("packages")
-            .join("naome")
-            .join("templates")
-            .join("naome-root")
-    }
-
-    fn completed_task_with_diff(name: &str) -> Self {
-        let repo = Self::new(name);
-        repo.init_git();
-        repo.write_file("README.md", "# Baseline\n");
-        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-        repo.git(&["add", "."]);
-        repo.git(&["commit", "-m", "baseline"]);
-        let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-        repo.write_base_naome_state(completed_task_state(&admission_head));
-        repo.git(&["add", ".naome/task-state.json"]);
-        repo.git(&["commit", "-m", "task state"]);
-        repo.write_file("README.md", "# Changed\n");
-        repo
-    }
-
-    fn completed_task_with_unrelated_user_edit(name: &str) -> Self {
-        let repo = Self::new(name);
-        repo.init_git();
-        repo.write_file("README.md", "# Baseline\n");
-        repo.write_file("USER.md", "user baseline\n");
-        repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
-        repo.git(&["add", "."]);
-        repo.git(&["commit", "-m", "baseline"]);
-        let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
-        repo.write_base_naome_state(completed_task_state(&admission_head));
-        repo.git(&["add", ".naome/task-state.json"]);
-        repo.git(&["commit", "-m", "task state"]);
-        repo.write_file("README.md", "# Changed\n");
-        repo.write_file("USER.md", "user local edit\n");
-        repo
-    }
-
-    fn completed_task_with_harness_refresh_diff(name: &str) -> Self {
-        let repo = Self::completed_task_with_diff(name);
-        repo.write_file("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-        repo.write_file(
-            ".naome/manifest.json",
-            r#"{
-  "name": "naome",
-  "harnessVersion": "1.1.0",
-  "profile": "standard",
-  "machineOwned": ["AGENTS.md"],
-  "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
-  "integrity": {}
-}
-"#,
-        );
-        repo
-    }
-
-    fn path(&self) -> &Path {
-        &self.root
-    }
-
-    fn write_base_naome_state(&self, task_state: serde_json::Value) {
-        self.write_naome_json(
-            "init-state.json",
-            json!({ "initialized": true, "intakeStatus": "complete" }),
-        );
-        self.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
-        self.write_naome_json(
-            "verification.json",
-            json!({
-                "schema": "naome.verification.v1",
-                "version": 1,
-                "status": "ready",
-                "checks": [
-                    {
-                        "id": "diff-check",
-                        "command": "git diff --check",
-                        "cwd": ".",
-                        "purpose": "Reject whitespace errors.",
-                        "cost": "fast",
-                        "source": "test",
-                        "evidence": ["README.md"],
-                        "lastVerified": null
-                    }
-                ],
-                "changeTypes": [],
-                "releaseGates": []
-            }),
-        );
-        self.write_naome_json("task-state.json", task_state);
-    }
-
-    fn write_readme_quality_verification(
-        &self,
-        extra_checks: Vec<Value>,
-        required_checks: Vec<&str>,
-    ) {
-        let mut checks = vec![json!({
-            "id": "diff-check",
-            "command": "git diff --check",
-            "cwd": ".",
-            "purpose": "Reject whitespace errors.",
-            "cost": "fast",
-            "source": "test",
-            "evidence": ["README.md"],
-            "lastVerified": null
-        })];
-        checks.extend(extra_checks);
-
-        self.write_naome_json(
-            "verification.json",
-            json!({
-                "schema": "naome.verification.v1",
-                "version": 1,
-                "status": "ready",
-                "checks": checks,
-                "changeTypes": [
-                    {
-                        "id": "readme",
-                        "description": "README changes.",
-                        "paths": ["README.md"],
-                        "requiredChecks": required_checks,
-                        "recommendedChecks": [],
-                        "humanReview": false
-                    }
-                ],
-                "releaseGates": []
-            }),
-        );
-    }
-
-    fn write_product_quality_verification(&self) {
-        self.write_naome_json(
-            "verification.json",
-            json!({
-                "schema": "naome.verification.v1",
-                "version": 1,
-                "status": "ready",
-                "checks": [
-                    {
-                        "id": "installer-tests",
-                        "command": "npm run test:naome-installer",
-                        "cwd": ".",
-                        "purpose": "Validate installer behavior.",
-                        "cost": "medium",
-                        "source": "test",
-                        "evidence": ["scripts/naome-installer.test.js"],
-                        "lastVerified": null
-                    },
-                    {
-                        "id": "rust-build",
-                        "command": "npm run build:rust",
-                        "cwd": ".",
-                        "purpose": "Build native CLI.",
-                        "cost": "medium",
-                        "source": "test",
-                        "evidence": ["packages/naome/Cargo.toml"],
-                        "lastVerified": null
-                    },
-                    {
-                        "id": "decision-engine-tests",
-                        "command": "npm run test:decision-engine",
-                        "cwd": ".",
-                        "purpose": "Validate route decisions.",
-                        "cost": "fast",
-                        "source": "test",
-                        "evidence": ["packages/naome/crates/naome-core/tests/route.rs"],
-                        "lastVerified": null
-                    },
-                    {
-                        "id": "package-dry-run",
-                        "command": "npm run pack:dry-run",
-                        "cwd": ".",
-                        "purpose": "Validate package metadata.",
-                        "cost": "medium",
-                        "source": "test",
-                        "evidence": ["packages/naome/package.json"],
-                        "lastVerified": null
-                    },
-                    {
-                        "id": "diff-check",
-                        "command": "git diff --check",
-                        "cwd": ".",
-                        "purpose": "Reject whitespace errors.",
-                        "cost": "fast",
-                        "source": "test",
-                        "evidence": ["packages/naome/crates/naome-core/src/route.rs"],
-                        "lastVerified": null
-                    }
-                ],
-                "changeTypes": [
-                    {
-                        "id": "product-installer-or-template",
-                        "description": "NAOME product changes.",
-                        "paths": ["packages/naome/**", "scripts/**"],
-                        "requiredChecks": [
-                            "installer-tests",
-                            "rust-build",
-                            "decision-engine-tests",
-                            "package-dry-run"
-                        ],
-                        "recommendedChecks": [],
-                        "humanReview": false
-                    }
-                ],
-                "releaseGates": []
-            }),
-        );
-    }
-
-    fn write_dogfood_readme_quality_verification(&self) {
-        self.write_naome_json(
-            "verification.json",
-            json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "checks": [
-                {
-                    "id": "dogfood-health",
-                    "command": "npm run dogfood:health",
-                    "cwd": ".",
-                    "purpose": "Validate installed harness integrity.",
-                    "cost": "fast",
-                    "source": "test",
-                    "evidence": [".naome/bin/check-task-state.js"],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "installed-self-hosted-harness",
-                    "description": "Installed harness files.",
-                    "paths": ["README.md"],
-                    "requiredChecks": ["dogfood-health"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-                "releaseGates": []
-            }),
-        );
-    }
-
-    fn write_task_state_readme_quality_verification(&self) {
-        self.write_naome_json(
-            "verification.json",
-            json!({
-                "schema": "naome.verification.v1",
-                "version": 1,
-                "status": "ready",
-                "checks": [
-                    {
-                        "id": "task-state-check",
-                        "command": "npm run check:task-state",
-                        "cwd": ".",
-                        "purpose": "Validate template task-state and harness integrity.",
-                        "cost": "fast",
-                        "source": "test",
-                        "evidence": ["packages/naome/templates/naome-root/.naome/bin/check-task-state.js"],
-                        "lastVerified": null
-                    }
-                ],
-                "changeTypes": [
-                    {
-                        "id": "installed-self-hosted-harness",
-                        "description": "Installed harness files.",
-                        "paths": ["README.md"],
-                        "requiredChecks": ["task-state-check"],
-                        "recommendedChecks": [],
-                        "humanReview": false
-                    }
-                ],
-                "releaseGates": []
-            }),
-        );
-    }
-
-    fn write_naome_json(&self, file_name: &str, value: serde_json::Value) {
-        let path = self.root.join(".naome").join(file_name);
-        fs::write(
-            path,
-            format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
-        )
-        .unwrap();
-    }
-
-    fn write_file(&self, relative_path: &str, content: &str) {
-        let path = self.root.join(relative_path);
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent).unwrap();
-        }
-        fs::write(path, content).unwrap();
-    }
-
-    fn init_git(&self) {
-        self.git(&["init"]);
-        self.git(&["config", "user.email", "naome@example.com"]);
-        self.git(&["config", "user.name", "NAOME Test"]);
-    }
-
-    fn git(&self, args: &[&str]) {
-        let output = Command::new("git")
-            .args(args)
-            .current_dir(&self.root)
-            .output()
-            .unwrap();
-        assert!(
-            output.status.success(),
-            "git {:?} failed\nstdout:\n{}\nstderr:\n{}",
-            args,
-            String::from_utf8_lossy(&output.stdout),
-            String::from_utf8_lossy(&output.stderr)
-        );
-    }
-
-    fn git_stdout(&self, args: &[&str]) -> String {
-        let output = Command::new("git")
-            .args(args)
-            .current_dir(&self.root)
-            .output()
-            .unwrap();
-        assert!(output.status.success());
-        String::from_utf8_lossy(&output.stdout).trim().to_string()
-    }
-
-    fn git_status_short(&self) -> String {
-        self.git_stdout(&["status", "--short"])
-    }
-
-    fn git_status_short_at(root: &Path) -> String {
-        let output = Command::new("git")
-            .args(["status", "--short"])
-            .current_dir(root)
-            .output()
-            .unwrap();
-        assert!(output.status.success());
-        String::from_utf8_lossy(&output.stdout).trim().to_string()
-    }
-}
-
-fn packaged_template_root() -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("..")
-        .join("..")
-        .join("templates")
-        .join("naome-root")
-}
-
-fn copy_dir(from: &Path, to: &Path) {
-    fs::create_dir_all(to).unwrap();
-    for entry in fs::read_dir(from).unwrap() {
-        let entry = entry.unwrap();
-        let from_path = entry.path();
-        let to_path = to.join(entry.file_name());
-        let file_type = entry.file_type().unwrap();
-        if file_type.is_dir() {
-            copy_dir(&from_path, &to_path);
-        } else if file_type.is_file() {
-            if let Some(parent) = to_path.parent() {
-                fs::create_dir_all(parent).unwrap();
-            }
-            fs::copy(&from_path, &to_path).unwrap();
-        }
-    }
-}
-
-fn completed_task_state(admission_head: &str) -> serde_json::Value {
-    json!({
-        "schema": "naome.task-state.v1",
-        "version": 1,
-        "status": "complete",
-        "activeTask": {
-            "id": "readme-task",
-            "request": "Change README.",
-            "userPrompt": {
-                "receivedAt": "2026-05-06T00:00:00.000Z",
-                "text": "Change README."
-            },
-            "admission": {
-                "command": "node .naome/bin/check-task-state.js --admission",
-                "cwd": ".",
-                "exitCode": 0,
-                "checkedAt": "2026-05-06T00:00:00.000Z",
-                "gitHead": admission_head,
-                "changedPaths": []
-            },
-            "allowedPaths": ["README.md"],
-            "declaredChangeTypes": ["product-docs"],
-            "requiredCheckIds": ["diff-check"],
-            "proofResults": [
-                {
-                    "checkId": "diff-check",
-                    "command": "git diff --check",
-                    "cwd": ".",
-                    "exitCode": 0,
-                    "checkedAt": "2026-05-06T00:00:00.000Z",
-                    "evidence": ["README.md"]
-                }
-            ],
-            "revisions": [],
-            "humanReview": {
-                "required": false,
-                "approved": false,
-                "reason": null
-            }
-        },
-        "blocker": null,
-        "updatedAt": "2026-05-06T00:00:00.000Z"
-    })
-}
+// Route integration tests are split by scenario in route_*.rs.