@lamentis/naome 1.0.2 → 1.1.1

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

@@ -0,0 +1,826 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{evaluate_intent, EvaluationOptions};
+use serde_json::json;
+
+#[test]
+fn clean_repo_with_new_goal_creates_task() {
+    let repo = TestRepo::new("intent-clean-new-task");
+    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 intent = evaluate_intent(
+        repo.path(),
+        "Bitte implementiere eine neue kleine Funktion.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "ready_for_task");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(intent.policy_action, "create_new_task");
+    assert!(intent.allowed);
+}
+
+#[test]
+fn completed_setup_diff_and_new_goal_auto_baselines_before_new_task() {
+    let repo = TestRepo::new("intent-setup-new-task");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_naome_json(
+        "manifest.json",
+        json!({
+            "machineOwned": ["AGENTS.md"],
+            "projectOwned": [
+                ".naome/init-state.json",
+                ".naome/task-state.json",
+                ".naome/upgrade-state.json",
+                ".naome/verification.json",
+                "docs/naome/**"
+            ],
+            "integrity": {}
+        }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_naome_json(
+        "init-state.json",
+        json!({
+            "initialized": true,
+            "intakeStatus": "complete",
+            "initializedBy": "codex"
+        }),
+    );
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Please add a README summary as a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "install_or_upgrade_unbaselined");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(
+        intent.policy_action,
+        "auto_commit_upgrade_baseline_then_create_new_task"
+    );
+    assert!(intent.allowed);
+}
+
+#[test]
+fn active_task_with_distinct_new_goal_blocks_instead_of_continuing() {
+    let repo = TestRepo::new("intent-active-new-task");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_naome_state(active_task_state("implementing"));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Jetzt implementiere bitte noch ein neues Release-System.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "active_task_in_progress");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(intent.policy_action, "block_ambiguous_intent");
+    assert!(!intent.allowed);
+}
+
+#[test]
+fn active_task_with_correction_continues_current_task() {
+    let repo = TestRepo::new("intent-active-correction");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_naome_state(active_task_state("implementing"));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Mach bitte diese Kleinigkeit im aktuellen Task auch noch.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "active_task_in_progress");
+    assert_eq!(intent.prompt_intent, "task_revision");
+    assert_eq!(intent.policy_action, "continue_current_task");
+    assert!(intent.allowed);
+}
+
+#[test]
+fn completed_valid_task_and_new_goal_can_auto_baseline_then_create() {
+    let repo = TestRepo::new("intent-complete-new-task");
+    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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Danach implementiere bitte einen neuen Task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "completed_task_unbaselined");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(
+        intent.policy_action,
+        "auto_commit_completed_task_then_create_new_task"
+    );
+    assert!(intent.allowed);
+}
+
+#[test]
+fn completed_valid_task_with_unrelated_user_edit_creates_isolated_worktree() {
+    let repo = TestRepo::new("intent-complete-new-task-with-user-edit");
+    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, true));
+    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");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Add another line to README as a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "completed_task_unbaselined");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(
+        intent.policy_action,
+        "auto_commit_completed_task_then_create_isolated_task_worktree"
+    );
+    assert!(intent.allowed);
+    assert!(intent.human_options.is_empty());
+    assert!(intent.user_message.contains("isolated worktree"));
+}
+
+#[test]
+fn dirty_repo_with_harness_refresh_and_user_edit_baselines_refresh_before_worktree() {
+    let repo = TestRepo::new("intent-dirty-harness-refresh-with-user-edit");
+    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": "standard",
+            "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 intent = evaluate_intent(
+        repo.path(),
+        "Add another line to README as a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "dirty_unowned_diff");
+    assert_eq!(
+        intent.policy_action,
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+    );
+    assert!(intent.allowed);
+    assert!(intent.human_options.is_empty());
+}
+
+#[test]
+fn completed_task_state_with_only_harness_refresh_baselines_before_new_task() {
+    let repo = TestRepo::new("intent-complete-pure-harness-refresh");
+    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, true));
+    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 intent = evaluate_intent(
+        repo.path(),
+        "Add another line to README as a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "harness_repair_unbaselined");
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(
+        intent.policy_action,
+        "auto_commit_harness_refresh_then_create_new_task"
+    );
+    assert!(intent.allowed);
+    assert!(intent.human_options.is_empty());
+    assert!(!intent.user_message.contains("isolated worktree"));
+}
+
+#[test]
+fn completed_task_state_with_manifest_only_diff_is_not_harness_refresh() {
+    let repo = TestRepo::new("intent-complete-manifest-only-diff");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\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": "standard",
+            "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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_naome_json(
+        "manifest.json",
+        json!({
+            "name": "naome",
+            "harnessVersion": "9.9.9",
+            "profile": "standard",
+            "machineOwned": ["AGENTS.md"],
+            "projectOwned": [".naome/manifest.json", ".naome/task-state.json"],
+            "integrity": {}
+        }),
+    );
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Add another line to README as a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "dirty_unowned_diff");
+    assert_eq!(intent.policy_action, "create_isolated_task_worktree");
+}
+
+#[test]
+fn dirty_repo_repair_request_baselines_only_harness_refresh() {
+    let repo = TestRepo::new("intent-dirty-harness-refresh-repair-request");
+    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": "standard",
+            "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 intent = evaluate_intent(
+        repo.path(),
+        "please repair all",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "dirty_unowned_diff");
+    assert_eq!(intent.prompt_intent, "repair_request");
+    assert_eq!(intent.policy_action, "auto_commit_harness_refresh_baseline");
+    assert!(intent.allowed);
+    assert!(intent.human_options.is_empty());
+}
+
+#[test]
+fn dirty_unowned_commit_request_does_not_offer_clear_or_commit_fallback() {
+    let repo = TestRepo::new("intent-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 intent =
+        evaluate_intent(repo.path(), "okay commit it", EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(intent.repo_state, "dirty_unowned_diff");
+    assert_eq!(intent.prompt_intent, "commit_request");
+    assert_eq!(intent.policy_action, "commit_user_diff_with_quality_gate");
+    assert!(intent.allowed);
+    assert!(!intent
+        .human_options
+        .contains(&"clear_or_commit_unowned_diff".to_string()));
+    assert!(intent.user_message.contains("quality gate"));
+}
+
+#[test]
+fn unsafe_terms_win_over_commit_and_new_task_requests() {
+    let repo = TestRepo::new("intent-unsafe-priority");
+    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 intent = evaluate_intent(
+        repo.path(),
+        "Create a new task, commit it, then push with --no-verify and include this API key.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "unsafe");
+    assert_eq!(intent.policy_action, "block_unsafe_intent");
+    assert!(!intent.allowed);
+    assert!(!intent.human_options.is_empty());
+    assert!(intent
+        .internal_notes
+        .contains(&"winning_rule:unsafe_intent_precedence".to_string()));
+}
+
+#[test]
+fn do_not_commit_blocks_completed_task_auto_baseline() {
+    let repo = TestRepo::new("intent-no-commit-priority");
+    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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Do not commit. Please start a new task after this.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "no_commit_request");
+    assert_eq!(intent.policy_action, "block_auto_baseline_due_to_no_commit");
+    assert!(!intent.allowed);
+    assert!(intent
+        .human_options
+        .contains(&"review_task_diff".to_string()));
+}
+
+#[test]
+fn explicit_review_request_overrides_auto_baseline() {
+    let repo = TestRepo::new("intent-review-priority");
+    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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Review the current task diff, then also create a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "review_request");
+    assert_eq!(intent.policy_action, "review_task_diff");
+    assert!(!intent.allowed);
+    assert!(intent
+        .human_options
+        .contains(&"commit_task_baseline".to_string()));
+}
+
+#[test]
+fn explicit_cancel_request_overrides_auto_baseline() {
+    let repo = TestRepo::new("intent-cancel-priority");
+    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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Cancel the current task changes, but also start a new task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "cancel_request");
+    assert_eq!(intent.policy_action, "cancel_task_changes");
+    assert!(!intent.allowed);
+    assert!(intent
+        .human_options
+        .contains(&"review_task_diff".to_string()));
+}
+
+#[test]
+fn explicit_new_task_wins_over_vague_continuation_wording() {
+    let repo = TestRepo::new("intent-new-over-vague-continuation");
+    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 intent = evaluate_intent(
+        repo.path(),
+        "Als neuer Task: mach bitte auch noch eine kurze README Ergänzung.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(intent.policy_action, "create_new_task");
+    assert!(intent.allowed);
+}
+
+#[test]
+fn status_requests_do_not_offer_mutating_human_options() {
+    let repo = TestRepo::new("intent-status-readonly");
+    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 intent = evaluate_intent(
+        repo.path(),
+        "What is the current NAOME status and why?",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "status_question");
+    assert_eq!(intent.policy_action, "answer_status_only");
+    assert!(intent.allowed);
+    assert!(intent.human_options.is_empty());
+    assert!(!intent.user_message.contains("commit_task_baseline"));
+}
+
+#[test]
+fn completed_invalid_task_and_new_goal_blocks_auto_baseline() {
+    let repo = TestRepo::new("intent-invalid-complete-new-task");
+    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, false));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Danach implementiere bitte einen neuen Task.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.repo_state, "completed_task_unbaselined");
+    assert_eq!(intent.policy_action, "block_unsafe_intent");
+    assert!(!intent.allowed);
+    assert!(intent
+        .risk_codes
+        .contains(&"completed_task_proof_invalid".to_string()));
+}
+
+#[test]
+fn completed_task_correction_reopens_same_task_revision() {
+    let repo = TestRepo::new("intent-complete-correction");
+    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, true));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "task state"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let intent = evaluate_intent(
+        repo.path(),
+        "Bitte im gleichen Task noch eine Kleinigkeit korrigieren.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "task_revision");
+    assert_eq!(intent.policy_action, "reopen_completed_task_revision");
+    assert!(intent.allowed);
+}
+
+#[test]
+fn risky_prompt_without_clear_task_transition_blocks_unsafe() {
+    let repo = TestRepo::new("intent-risky-unclear");
+    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 intent = evaluate_intent(
+        repo.path(),
+        "Hier ist ein API key und bitte --no-verify.",
+        EvaluationOptions::offline(),
+    )
+    .unwrap();
+
+    assert_eq!(intent.prompt_intent, "unsafe");
+    assert_eq!(intent.policy_action, "block_unsafe_intent");
+    assert!(!intent.allowed);
+}
+
+fn active_task_state(status: &str) -> serde_json::Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": status,
+        "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": "",
+                "changedPaths": []
+            },
+            "allowedPaths": ["README.md"],
+            "declaredChangeTypes": ["product-docs"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": [],
+            "revisions": [],
+            "humanReview": {
+                "required": false,
+                "approved": false,
+                "reason": null
+            }
+        },
+        "blocker": null,
+        "updatedAt": "2026-05-06T00:00:00.000Z"
+    })
+}
+
+fn completed_task_state(admission_head: &str, include_proof: bool) -> serde_json::Value {
+    let proof_results = if include_proof {
+        json!([
+            {
+                "checkId": "diff-check",
+                "command": "git diff --check",
+                "cwd": ".",
+                "exitCode": 0,
+                "checkedAt": "2026-05-06T00:00:00.000Z",
+                "evidence": ["README.md"]
+            }
+        ])
+    } else {
+        json!([])
+    };
+
+    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": proof_results,
+            "revisions": [],
+            "humanReview": {
+                "required": false,
+                "approved": false,
+                "reason": null
+            }
+        },
+        "blocker": null,
+        "updatedAt": "2026-05-06T00:00:00.000Z"
+    })
+}
+
+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-intent-{name}-{nonce}"));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        Self { root }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    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 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_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 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()
+    }
+}