@lamentis/naome 1.1.2 → 1.2.1

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

@@ -1,826 +1,131 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::time::{SystemTime, UNIX_EPOCH};
+mod intent_support;
 
-use naome_core::{evaluate_intent, EvaluationOptions};
-use serde_json::json;
+use naome_core::IntentDecision;
 
-#[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);
-}
+use intent_support::{completed_state, env, idle, Repo};
 
 #[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": {}
-        }),
+fn repo_state_and_envelope_resolve_task_policy() {
+    let clean = Repo::clean("clean", idle());
+    assert_intent(
+        &clean.intent("Please implement a small new feature."),
+        "ready_for_task",
+        "new_task",
+        "create_new_task",
+        true,
     );
-    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"
+    let mut active_state = completed_state("HEAD", true);
+    active_state["status"] = serde_json::json!("implementing");
+    let active = Repo::clean("active", active_state);
+    let revision = active.intent(&env("follow up", "none", "task_revision", "none"));
+    assert_intent(
+        &revision,
+        "active_task_in_progress",
+        "task_revision",
+        "continue_current_task",
+        true,
     );
-    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"
+    let distinct = active.intent(&env("separate work", "none", "new_task", "none"));
+    assert_intent(
+        &distinct,
+        "active_task_in_progress",
+        "new_task",
+        "block_ambiguous_intent",
+        false,
     );
-    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": {}
-        }),
+    let completed = Repo::completed("completed", true);
+    let next = completed.intent("After that, please implement a new task.");
+    assert_intent(
+        &next,
+        "completed_task_unbaselined",
+        "new_task",
+        "auto_commit_completed_task_then_create_new_task",
+        true,
     );
-    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"
+        completed
+            .intent(&env("review", "review_request", "new_task", "none"))
+            .policy_action,
+        "review_task_diff"
     );
-    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": {}
-        }),
+    assert_eq!(
+        completed
+            .intent(&env("cancel", "cancel_request", "new_task", "none"))
+            .policy_action,
+        "cancel_task_changes"
     );
-    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": {}
-        }),
+    assert_eq!(
+        completed
+            .intent(&env("no commit", "no_commit_request", "new_task", "none"))
+            .policy_action,
+        "block_auto_baseline_due_to_no_commit"
     );
-
-    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"
+        completed
+            .intent(&env("revise", "none", "task_revision", "none"))
+            .policy_action,
+        "reopen_completed_task_revision"
     );
-    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": {}
-        }),
+fn workflow_and_risk_intents_are_structured_not_language_keywords() {
+    let status =
+        Repo::clean("status", idle()).intent(&env("anything", "status_question", "none", "none"));
+    assert_intent(
+        &status,
+        "ready_for_task",
+        "status_question",
+        "answer_status_only",
+        true,
     );
 
-    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": {}
-        }),
+    let dirty = Repo::clean("dirty", idle());
+    dirty.write("README.md", "# Manual edit\n");
+    let commit = dirty.intent(&env("okay commit it", "commit_request", "none", "none"));
+    assert_intent(
+        &commit,
+        "dirty_unowned_diff",
+        "commit_request",
+        "commit_user_diff_with_quality_gate",
+        true,
     );
-    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();
+    let deprecated = dirty.intent("clear_or_commit_unowned_diff");
+    assert_intent(
+        &deprecated,
+        "dirty_unowned_diff",
+        "ambiguous",
+        "block_unowned_diff",
+        false,
+    );
 
-    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"));
+    let risky = Repo::clean("risky", idle()).intent(&env(
+        "include this API key",
+        "commit_request",
+        "new_task",
+        "credential_context",
+    ));
+    assert_eq!(risky.prompt_intent, "unsafe");
+    assert_eq!(risky.policy_action, "block_unsafe_intent");
+    assert!(!risky.allowed);
 }
 
 #[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");
+fn invalid_completed_task_proof_blocks_new_task_baseline() {
+    let repo = Repo::completed("invalid", false);
+    let intent = repo.intent("After that, please implement a new task.");
     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()
-    }
+fn assert_intent(intent: &IntentDecision, state: &str, prompt: &str, policy: &str, allowed: bool) {
+    assert_eq!(intent.repo_state, state);
+    assert_eq!(intent.prompt_intent, prompt);
+    assert_eq!(intent.policy_action, policy);
+    assert_eq!(intent.allowed, allowed);
 }