@lamentis/naome 1.0.2 → 1.1.1

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

@@ -0,0 +1,1159 @@
+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_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!(route.user_message.contains("trailing whitespace"));
+}
+
+#[test]
+fn execute_route_refuses_user_diff_commit_when_diff_check_adds_paths() {
+    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.git_status_short().contains("NEW.md"));
+    assert!(route
+        .user_message
+        .contains("Quality checks changed the diff path set"));
+}
+
+#[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_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 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_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 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"
+    })
+}