@lamentis/naome 1.2.0 → 1.2.1

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

@@ -0,0 +1,86 @@
+use serde_json::json;
+use std::fs;
+
+mod repo_support;
+
+use repo_support::{
+    assert_commit_paths, assert_isolated_worktree_ready, route_new_task, route_readme_task,
+    TestRepo,
+};
+
+#[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 = route_new_task(&repo, "Start a new task for README polish.", false);
+
+    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 = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    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 = route_readme_task(&repo, true);
+
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_completed_task_then_create_isolated_task_worktree"
+    );
+    assert!(route.mutation_performed);
+    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_isolated_worktree_ready(&route, &repo, "M USER.md");
+    assert_commit_paths(&repo, &["README.md"], &["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 = route_readme_task(&repo, true);
+
+    assert_eq!(route.policy_action, "create_isolated_task_worktree");
+    assert!(route.mutation_performed);
+    assert_isolated_worktree_ready(&route, &repo, "M USER.md");
+}

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

@@ -0,0 +1,141 @@
+use std::fs;
+
+use naome_core::{evaluate_route, explain_route, EvaluationOptions, RouteOptions};
+use serde_json::json;
+
+mod repo_support;
+
+use repo_support::TestRepo;
+
+#[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());
+}

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

@@ -0,0 +1,135 @@
+use std::fs;
+
+use naome_core::{evaluate_route, EvaluationOptions, RouteOptions};
+
+mod repo_support;
+
+use repo_support::{
+    assert_commit_paths, assert_isolated_worktree_ready, route_new_task, route_readme_task,
+    TestRepo,
+};
+
+#[test]
+fn execute_route_baselines_harness_refresh_before_dirty_repo_worktree() {
+    let repo = TestRepo::dirty_harness_refresh_repo("route-dirty-harness-refresh-worktree", true);
+
+    let route = route_readme_task(&repo, true);
+
+    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_isolated_worktree_ready(&route, &repo, "M USER.md");
+    assert_commit_paths(&repo, &["AGENTS.md", ".naome/manifest.json"], &["USER.md"]);
+}
+
+#[test]
+fn execute_route_baselines_pure_harness_refresh_before_new_task_without_worktree() {
+    let repo = TestRepo::completed_task_with_harness_refresh_only(
+        "route-pure-harness-refresh-no-worktree",
+    );
+
+    let route = route_readme_task(&repo, true);
+
+    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(), "");
+
+    assert_commit_paths(
+        &repo,
+        &["AGENTS.md", ".naome/manifest.json"],
+        &["README.md"],
+    );
+}
+
+#[test]
+fn execute_route_repair_request_baselines_harness_refresh_only() {
+    let repo = TestRepo::dirty_harness_refresh_repo("route-harness-refresh-repair-only", true);
+
+    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");
+
+    assert_commit_paths(&repo, &["AGENTS.md", ".naome/manifest.json"], &["USER.md"]);
+}
+
+#[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 = route_new_task(&repo, "Start a new task for README polish.", false);
+
+    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 = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    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\""));
+}

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

@@ -0,0 +1,198 @@
+use std::fs;
+
+use naome_core::{evaluate_route, EvaluationOptions, RouteOptions};
+use serde_json::json;
+
+mod repo_support;
+
+use repo_support::{assert_user_diff_committed, route_commit_request, TestRepo};
+
+#[test]
+fn execute_route_does_not_mutate_or_offer_clear_commit_for_dirty_unowned_diff() {
+    let repo = TestRepo::idle_readme("route-dirty-commit-request");
+    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::readme_quality_repo(
+        "route-user-diff-quality-pass",
+        Vec::new(),
+        vec!["diff-check"],
+    );
+    repo.write_file("README.md", "# Manual edit\n");
+
+    let route = route_commit_request(&repo);
+
+    assert_user_diff_committed(&route, &repo);
+
+    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_runs_repository_quality_check_without_shelling_to_repo_command() {
+    let repo = TestRepo::repository_quality_failure_repo("route-repository-quality-check");
+    repo.write_file(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n  five();\n}\n",
+    );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "src/large.js");
+    assert!(route.user_message.contains("repository-quality-check"));
+    assert!(route.user_message.contains("file-length"));
+}
+
+#[test]
+fn execute_route_commits_product_diff_with_declared_safe_quality_checks() {
+    let repo = TestRepo::product_quality_repo("route-product-diff-quality-pass");
+    repo.write_file(
+        "packages/naome/crates/naome-core/src/route.rs",
+        "pub fn changed() {}\n",
+    );
+
+    let route = route_commit_request(&repo);
+
+    assert_user_diff_committed(&route, &repo);
+
+    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_readme_rename_verification();
+    repo.commit_all("baseline");
+    repo.git(&["mv", "README.md", "INTRO.md"]);
+
+    let route = route_commit_request(&repo);
+
+    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::idle_readme("route-user-diff-no-quality-coverage");
+    repo.write_file("README.md", "# Manual edit\n");
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "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::readme_quality_repo(
+        "route-user-diff-mutating-check",
+        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.write_file("README.md", "# Manual edit\n");
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "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::readme_unsafe_diff_check_repo("route-user-diff-mutating-diff-check");
+    repo.write_file("README.md", "# Manual edit\n");
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "README.md");
+    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::readme_quality_repo(
+        "route-user-diff-quality-fail",
+        Vec::new(),
+        vec!["diff-check"],
+    );
+    repo.write_file("README.md", "# Manual edit  \n");
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = route_commit_request(&repo);
+
+    assert_quality_gate_blocked(&repo, &route, before_head, "README.md");
+    assert_eq!(route.human_options, vec!["review_unowned_diff"]);
+    assert!(route.user_message.contains("quality gate failed"));
+}
+
+fn assert_quality_gate_blocked(
+    repo: &TestRepo,
+    route: &naome_core::RouteDecision,
+    before_head: String,
+    changed_path: &str,
+) {
+    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(changed_path));
+}

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

@@ -0,0 +1,54 @@
+use serde_json::json;
+
+mod repo_support;
+
+use repo_support::{route_readme_task, try_route_readme_task, TestRepo};
+
+#[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");
+    repo.create_stale_task_worktrees(25);
+
+    let error = try_route_readme_task(&repo, true).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();
+    repo.create_stale_task_worktrees(25);
+
+    let error = try_route_readme_task(&repo, true).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 = route_readme_task(&repo, true);
+
+    let worktree = route.worktree.expect("route should create a worktree");
+    assert!(worktree.branch.contains(before_short));
+    assert!(worktree.path.contains(before_short));
+}