@lamentis/naome 1.1.1 → 1.2.0

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

@@ -1,6 +1,19 @@
-use std::path::Path;
+mod classifier;
+mod envelope;
+mod legacy;
+mod legacy_response;
+mod model;
+mod patterns;
+mod resolver;
+mod resolver_active;
+mod resolver_baseline;
+mod resolver_catalog;
+mod resolver_policy;
+mod resolver_shared;
+mod risk;
+mod segment;
 
-use serde::Serialize;
+use std::path::Path;
 
 use crate::decision::{evaluate_decision, EvaluationOptions};
 use crate::models::{Decision, NaomeError};
@@ -9,44 +22,9 @@ use crate::task_state::{
     validate_task_state, TaskStateMode, TaskStateOptions,
 };
 
-#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct IntentDecision {
-    pub schema: String,
-    pub repo_state: String,
-    pub blocked: bool,
-    pub prompt_intent: String,
-    pub certainty: String,
-    pub policy_action: String,
-    pub allowed: bool,
-    pub summary: String,
-    pub next_action: String,
-    pub user_message: String,
-    pub human_options: Vec<String>,
-    pub internal_notes: Vec<String>,
-    pub reason_codes: Vec<String>,
-    pub risk_codes: Vec<String>,
-    pub changed_paths: Vec<String>,
-    pub required_context: Vec<String>,
-    pub evidence: PromptEvidence,
-}
-
-#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct PromptEvidence {
-    pub references_current_task: bool,
-    pub requests_new_goal: bool,
-    pub requests_correction: bool,
-    pub requests_status: bool,
-    pub requests_review: bool,
-    pub requests_repair: bool,
-    pub requests_commit: bool,
-    pub requests_no_commit: bool,
-    pub requests_cancel: bool,
-    pub requests_completion: bool,
-    pub has_risky_terms: bool,
-    pub is_empty: bool,
-}
+use classifier::canonical_intent;
+pub use legacy::{format_intent, IntentDecision, PromptEvidence};
+use resolver::{resolve_intent, CompletedTaskReadiness, DirtyDiffReadiness};
 
 pub fn evaluate_intent(
     root: &Path,
@@ -54,861 +32,68 @@ pub fn evaluate_intent(
     options: EvaluationOptions,
 ) -> Result<IntentDecision, NaomeError> {
     let decision = evaluate_decision(root, options)?;
-    let completed_task_readiness = if decision.state == "completed_task_unbaselined" {
-        let report = validate_task_state(
-            root,
-            TaskStateOptions {
-                mode: TaskStateMode::State,
-                harness_health: None,
-            },
-        )?;
-        if report.errors.is_empty() {
-            CompletedTaskReadiness::Valid
-        } else if completed_task_harness_refresh_diff(root)?.is_some() {
-            CompletedTaskReadiness::ValidAfterHarnessRefresh
-        } else if completed_task_commit_diff(root)?
-            .is_some_and(|diff| !diff.unrelated_paths.is_empty())
-        {
-            CompletedTaskReadiness::ValidWithUnrelatedDirty
-        } else {
-            CompletedTaskReadiness::Invalid
-        }
-    } else {
-        CompletedTaskReadiness::Valid
-    };
-
-    let dirty_diff_readiness = if matches!(
-        decision.state.as_str(),
-        "dirty_unowned_diff"
-            | "task_admission_blocked"
-            | "harness_repair_unbaselined"
-            | "install_or_upgrade_unbaselined"
-    ) {
-        match harness_refresh_diff(root)? {
-            Some(diff) if diff.unrelated_paths.is_empty() => DirtyDiffReadiness::HarnessRefreshOnly,
-            Some(diff) if !diff.unrelated_paths.is_empty() => {
-                DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty
-            }
-            _ => DirtyDiffReadiness::Unclassified,
-        }
-    } else {
-        DirtyDiffReadiness::Unclassified
-    };
-
-    Ok(resolve_intent(
-        decision,
-        prompt,
+    let completed_task_readiness = completed_task_readiness(root, &decision)?;
+    let dirty_diff_readiness = dirty_diff_readiness(root, &decision)?;
+    let canonical = canonical_intent(prompt);
+    let resolved = resolve_intent(
+        &decision,
+        &canonical,
         completed_task_readiness,
         dirty_diff_readiness,
-    ))
-}
-
-pub fn format_intent(intent: &IntentDecision) -> String {
-    let mut lines = vec![
-        format!("NAOME intent: {}", intent.prompt_intent),
-        format!("Repo state: {}", intent.repo_state),
-        format!("Allowed: {}", intent.allowed),
-        format!("Policy action: {}", intent.policy_action),
-        format!("Summary: {}", intent.user_message),
-        format!("Next action: {}", intent.next_action),
-    ];
-
-    if !intent.human_options.is_empty() {
-        lines.push(format!(
-            "Human options: {}",
-            intent.human_options.join(", ")
-        ));
-    }
-
-    if !intent.reason_codes.is_empty() {
-        lines.push(format!("Reason codes: {}", intent.reason_codes.join(", ")));
-    }
-
-    if !intent.risk_codes.is_empty() {
-        lines.push(format!("Risk codes: {}", intent.risk_codes.join(", ")));
-    }
-
-    if !intent.changed_paths.is_empty() {
-        lines.push(format!(
-            "Changed paths: {}",
-            intent.changed_paths.join(", ")
-        ));
-    }
-
-    lines.push(String::new());
-    lines.join("\n")
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CompletedTaskReadiness {
-    Valid,
-    ValidAfterHarnessRefresh,
-    ValidWithUnrelatedDirty,
-    Invalid,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum DirtyDiffReadiness {
-    Unclassified,
-    HarnessRefreshOnly,
-    HarnessRefreshWithUnrelatedDirty,
+    );
+    Ok(legacy::legacy_decision(decision, canonical, resolved))
 }
 
-fn resolve_intent(
-    decision: Decision,
-    prompt: &str,
-    completed_task_readiness: CompletedTaskReadiness,
-    dirty_diff_readiness: DirtyDiffReadiness,
-) -> IntentDecision {
-    let evidence = PromptEvidence::from_prompt(prompt);
-    let prompt_intent = prompt_intent(&evidence);
-    let mut reason_codes = vec![format!("repo_state:{}", decision.state)];
-    let mut risk_codes = Vec::new();
-    if evidence.has_risky_terms {
-        risk_codes.push("prompt_contains_risky_terms".to_string());
-    }
-    if completed_task_readiness == CompletedTaskReadiness::Invalid {
-        risk_codes.push("completed_task_proof_invalid".to_string());
+fn completed_task_readiness(
+    root: &Path,
+    decision: &Decision,
+) -> Result<CompletedTaskReadiness, NaomeError> {
+    if decision.state != "completed_task_unbaselined" {
+        return Ok(CompletedTaskReadiness::Valid);
     }
 
-    let (policy_action, allowed, summary, next_action) = if evidence.is_empty {
-        (
-            "block_ambiguous_intent",
-            false,
-            "The prompt is empty, so NAOME cannot infer a safe task transition.",
-            "Ask for a concrete request before mutating the repository.",
-        )
-    } else if prompt_intent == "unsafe" {
-        reason_codes.push("winning_rule:unsafe_intent_precedence".to_string());
-        (
-            "block_unsafe_intent",
-            false,
-            "The prompt contains risky terms or asks to bypass guardrails.",
-            "Ask for a narrower request that does not expose secrets or bypass guardrails.",
-        )
-    } else if prompt_intent == "status_question" {
-        (
-            "answer_status_only",
-            true,
-            "The prompt asks for status or explanation, so no task mutation is needed.",
-            "Answer from the current NAOME status without editing files.",
-        )
-    } else {
-        match decision.state.as_str() {
-            "harness_unhealthy" => (
-                "repair_harness_only",
-                false,
-                "The harness is unhealthy, so normal task work is blocked.",
-                "Repair or review the harness before accepting feature work.",
-            ),
-            "first_run_required" => (
-                "run_first_run_protocol",
-                false,
-                "First-run intake must finish before feature work.",
-                "Run the NAOME first-run protocol.",
-            ),
-            "upgrade_required" => (
-                "run_upgrade_protocol",
-                false,
-                "A NAOME upgrade is pending before feature work.",
-                "Run the NAOME upgrade protocol.",
-            ),
-            "ready_for_task" => match prompt_intent.as_str() {
-                "new_task" => (
-                    "create_new_task",
-                    true,
-                    "The repository is clean and the prompt asks for a new goal.",
-                    "Create a NAOME task for the new request.",
-                ),
-                "commit_request" => (
-                    "block_ambiguous_intent",
-                    false,
-                    "The repository is already ready for work; there is no open task diff to baseline.",
-                    "Ask for the next concrete task or inspect status.",
-                ),
-                "review_request" => (
-                    "answer_status_only",
-                    true,
-                    "The prompt asks for review, but there is no open task diff.",
-                    "Answer from the current NAOME status without editing files.",
-                ),
-                "no_commit_request" => (
-                    "create_new_task_without_auto_baseline",
-                    true,
-                    "The repository is clean, so no commit is needed before the new task.",
-                    "Create a NAOME task for the new request.",
-                ),
-                "task_revision" => (
-                    "block_ambiguous_intent",
-                    false,
-                    "The prompt sounds like a correction, but there is no open task diff.",
-                    "Ask whether this is a new task or a status question.",
-                ),
-                _ => ambiguous_policy(),
-            },
-            "completed_task_unbaselined" => match prompt_intent.as_str() {
-                "no_commit_request" => (
-                    "block_auto_baseline_due_to_no_commit",
-                    false,
-                    "The prompt explicitly blocks committing, so NAOME will not auto-baseline the completed task.",
-                    "Review, revise, cancel, or manually resolve the completed task diff.",
-                ),
-                "review_request" => (
-                    "review_task_diff",
-                    false,
-                    "The prompt explicitly asks to review the completed task diff.",
-                    "Review the completed task diff before any baseline or new task.",
-                ),
-                "cancel_request" => (
-                    "cancel_task_changes",
-                    false,
-                    "The prompt explicitly asks to cancel the completed task changes.",
-                    "Cancel or review the completed task diff before any new task.",
-                ),
-                "commit_request" => (
-                    "commit_task_baseline",
-                    true,
-                    "The prompt asks to baseline the completed task diff.",
-                    "Run the NAOME commit baseline flow for the completed task.",
-                ),
-                "task_revision" => (
-                    "reopen_completed_task_revision",
-                    true,
-                    "The prompt refers to follow-up correction on the unbaselined completed task.",
-                    "Reopen the same task as a revision and mark proof stale before editing.",
-                ),
-                "new_task"
-                    if completed_task_readiness == CompletedTaskReadiness::Valid
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_completed_task_then_create_new_task",
-                        true,
-                        "The completed task is valid and the prompt asks for a distinct new goal.",
-                        "Baseline the completed task first, then create the next task.",
-                    )
-                },
-                "new_task"
-                    if completed_task_readiness == CompletedTaskReadiness::ValidAfterHarnessRefresh
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_harness_refresh_then_completed_task_then_create_new_task",
-                        true,
-                        "The completed task is valid after separating deterministic harness refresh changes.",
-                        "Baseline the harness refresh first, then baseline the completed task and create the next task.",
-                    )
-                },
-                "new_task"
-                    if completed_task_readiness == CompletedTaskReadiness::ValidWithUnrelatedDirty
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_completed_task_then_create_isolated_task_worktree",
-                        true,
-                        "The completed task is valid, and unrelated user edits are present.",
-                        "Baseline only the completed task paths, preserve unrelated user edits, and create an isolated worktree for the next task.",
-                    )
-                },
-                "new_task" => (
-                    "block_unsafe_intent",
-                    false,
-                    "The prompt asks for a new task, but the current completed task is not safe to auto-baseline.",
-                    "Review the completed diff and proof before starting new work.",
-                ),
-                _ => ambiguous_policy(),
-            },
-            "active_task_in_progress" => match prompt_intent.as_str() {
-                "review_request" => (
-                    "review_current_task_diff",
-                    false,
-                    "The prompt asks to review the active task diff.",
-                    "Review the active task before mutating it further.",
-                ),
-                "cancel_request" => (
-                    "cancel_current_task",
-                    false,
-                    "The prompt asks to cancel the active task.",
-                    "Cancel or review the active task before starting another.",
-                ),
-                "no_commit_request" => (
-                    "continue_current_task_without_commit",
-                    true,
-                    "A task is active and the prompt blocks committing.",
-                    "Continue the active task without baselining.",
-                ),
-                "task_revision" | "task_completion" => (
-                    "continue_current_task",
-                    true,
-                    "A task is active and the prompt appears to continue or finish it.",
-                    "Continue the current task and keep proof current.",
-                ),
-                "new_task" => (
-                    "block_ambiguous_intent",
-                    false,
-                    "A task is already active and the prompt appears to ask for a distinct new goal.",
-                    "Complete, revise, or cancel the active task before starting another.",
-                ),
-                _ => ambiguous_policy(),
-            },
-            "active_task_blocked" => (
-                "block_unowned_diff",
-                false,
-                "The active task is blocked by out-of-scope changes.",
-                "Resolve the scope blocker before interpreting new work.",
-            ),
-            "dirty_unowned_diff" | "task_admission_blocked" => match prompt_intent.as_str() {
-                "repair_request"
-                    if dirty_diff_readiness == DirtyDiffReadiness::HarnessRefreshOnly
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_harness_refresh_baseline",
-                        true,
-                        "The repository has only deterministic harness refresh changes.",
-                        "Baseline the harness refresh before feature work.",
-                    )
-                }
-                "repair_request"
-                    if dirty_diff_readiness
-                        == DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_harness_refresh_baseline",
-                        true,
-                        "The repository has deterministic harness refresh changes plus unrelated user edits.",
-                        "Baseline only the harness refresh and leave unrelated user edits untouched.",
-                    )
-                }
-                "new_task"
-                    if dirty_diff_readiness == DirtyDiffReadiness::HarnessRefreshOnly
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_harness_refresh_then_create_new_task",
-                        true,
-                        "The repository has only deterministic harness refresh changes.",
-                        "Baseline the harness refresh first, then create the next task in the same worktree.",
-                    )
-                }
-                "new_task"
-                    if dirty_diff_readiness
-                        == DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty
-                        && !evidence.has_risky_terms =>
-                {
-                    (
-                        "auto_commit_harness_refresh_then_create_isolated_task_worktree",
-                        true,
-                        "The repository has deterministic harness refresh changes plus unrelated user edits.",
-                        "Baseline only the harness refresh first, then create an isolated task worktree without touching user edits.",
-                    )
-                }
-                "new_task" if !evidence.has_risky_terms => (
-                    "create_isolated_task_worktree",
-                    true,
-                    "The repository has unrelated user changes, and the prompt asks for a new task.",
-                    "Create an isolated NAOME task worktree so the new task can proceed without touching those user changes.",
-                ),
-                "commit_request" if !evidence.has_risky_terms => (
-                    "commit_user_diff_with_quality_gate",
-                    true,
-                    "The prompt asks to commit unowned user changes.",
-                    "Run NAOME's user-diff quality gate, then commit only the current changed paths if every required check passes.",
-                ),
-                _ => (
-                    "block_unowned_diff",
-                    false,
-                    "The repository has unowned changes that must be resolved first.",
-                    "NAOME will not commit unowned changes. Review them, or route a new task so NAOME can isolate task work in a separate worktree.",
-                ),
-            },
-            "install_or_upgrade_unbaselined" | "harness_repair_unbaselined" => {
-                if prompt_intent == "no_commit_request" {
-                    (
-                        "block_auto_baseline_due_to_no_commit",
-                        false,
-                        "The prompt explicitly blocks committing, so NAOME will not auto-baseline setup or repair changes.",
-                        "Review, cancel, or manually resolve the setup diff before feature work.",
-                    )
-                } else if prompt_intent == "review_request" {
-                    (
-                        "review_diff_first",
-                        false,
-                        "The prompt explicitly asks to review setup, upgrade, or repair changes.",
-                        "Review the NAOME diff before any baseline or new task.",
-                    )
-                } else if prompt_intent == "cancel_request" {
-                    (
-                        "cancel_upgrade_baseline",
-                        false,
-                        "The prompt explicitly asks to cancel setup, upgrade, or repair changes.",
-                        "Cancel or review the NAOME diff before feature work.",
-                    )
-                } else if prompt_intent == "commit_request"
-                    && dirty_diff_readiness == DirtyDiffReadiness::HarnessRefreshOnly
-                {
-                    (
-                        "auto_commit_harness_refresh_baseline",
-                        true,
-                        "The prompt asks to baseline a deterministic harness refresh.",
-                        "Baseline only the harness refresh before feature work.",
-                    )
-                } else if prompt_intent == "commit_request" {
-                    (
-                        "commit_upgrade_baseline",
-                        true,
-                        "The prompt asks to baseline pending setup, upgrade, or repair changes.",
-                        "Run the appropriate NAOME baseline flow before feature work.",
-                    )
-                } else if prompt_intent == "repair_request"
-                    && dirty_diff_readiness == DirtyDiffReadiness::HarnessRefreshOnly
-                {
-                    (
-                        "auto_commit_harness_refresh_baseline",
-                        true,
-                        "The prompt asks to repair or baseline a deterministic harness refresh.",
-                        "Baseline only the harness refresh before feature work.",
-                    )
-                } else if prompt_intent == "repair_request" {
-                    (
-                        "commit_upgrade_baseline",
-                        true,
-                        "The prompt asks to repair or baseline pending setup, upgrade, or repair changes.",
-                        "Run the appropriate NAOME baseline flow before feature work.",
-                    )
-                } else if prompt_intent == "new_task"
-                    && dirty_diff_readiness == DirtyDiffReadiness::HarnessRefreshOnly
-                    && !evidence.has_risky_terms
-                {
-                    (
-                        "auto_commit_harness_refresh_then_create_new_task",
-                        true,
-                        "The prompt asks for a new goal and the only blocker is a deterministic harness refresh.",
-                        "Baseline the harness refresh automatically, rerun admission, then create the new task in the same worktree.",
-                    )
-                } else if prompt_intent == "new_task" && !evidence.has_risky_terms {
-                    (
-                        "auto_commit_upgrade_baseline_then_create_new_task",
-                        true,
-                        "The prompt asks for a new goal and the only blocker is a completed NAOME setup, upgrade, or repair diff.",
-                        "Baseline the NAOME diff automatically, rerun admission, then create the new task.",
-                    )
-                } else if prompt_intent == "new_task" {
-                    (
-                        "block_unsafe_intent",
-                        false,
-                        "The prompt asks for a new task, but risky terms make automatic baseline unsafe.",
-                        "Review the setup diff and prompt before starting feature work.",
-                    )
-                } else {
-                    (
-                        "block_unowned_diff",
-                        false,
-                        "Setup, upgrade, or repair changes must be resolved before task routing.",
-                        "Resolve the harness baseline decision before accepting feature work.",
-                    )
-                }
-            }
-            _ => (
-                "block_ambiguous_intent",
-                false,
-                "NAOME cannot safely map this prompt to a task transition for the current state.",
-                "Review the machine status and ask for a narrower request.",
-            ),
-        }
-    };
-
-    if evidence.references_current_task {
-        reason_codes.push("prompt_references_current_task".to_string());
-    }
-    if evidence.requests_new_goal {
-        reason_codes.push("prompt_requests_new_goal".to_string());
-    }
-    if evidence.requests_correction {
-        reason_codes.push("prompt_requests_correction".to_string());
-    }
-    if evidence.requests_commit {
-        reason_codes.push("prompt_requests_commit".to_string());
-    }
-    if evidence.requests_no_commit {
-        reason_codes.push("prompt_blocks_commit".to_string());
-    }
-    if evidence.requests_review {
-        reason_codes.push("prompt_requests_review".to_string());
-    }
-    if evidence.requests_repair {
-        reason_codes.push("prompt_requests_repair".to_string());
-    }
-    if evidence.requests_cancel {
-        reason_codes.push("prompt_requests_cancel".to_string());
+    let report = validate_task_state(
+        root,
+        TaskStateOptions {
+            mode: TaskStateMode::State,
+            harness_health: None,
+        },
+    )?;
+    if report.errors.is_empty() {
+        return Ok(CompletedTaskReadiness::Valid);
     }
 
-    let certainty = if !risk_codes.is_empty() && policy_action == "block_unsafe_intent" {
-        "unsafe"
-    } else if policy_action == "block_ambiguous_intent"
-        || policy_action == "block_auto_baseline_due_to_no_commit"
-    {
-        "ambiguous"
-    } else if evidence.requests_commit
-        || evidence.requests_status
-        || evidence.requests_review
-        || evidence.requests_repair
-        || evidence.requests_no_commit
-        || evidence.requests_cancel
-    {
-        "exact"
-    } else {
-        "likely"
-    };
-
-    let (user_message, human_options, mut internal_notes) =
-        response_policy(&decision, &prompt_intent, policy_action, summary);
-    internal_notes.extend(
-        reason_codes
-            .iter()
-            .filter(|code| code.starts_with("winning_rule:"))
-            .cloned(),
-    );
-
-    IntentDecision {
-        schema: "naome.intent.v1".to_string(),
-        repo_state: decision.state,
-        blocked: decision.blocked,
-        prompt_intent,
-        certainty: certainty.to_string(),
-        policy_action: policy_action.to_string(),
-        allowed,
-        summary: summary.to_string(),
-        next_action: next_action.to_string(),
-        user_message,
-        human_options,
-        internal_notes,
-        reason_codes,
-        risk_codes,
-        changed_paths: decision.changed_paths,
-        required_context: decision.required_context,
-        evidence,
+    if completed_task_harness_refresh_diff(root)?.is_some() {
+        return Ok(CompletedTaskReadiness::ValidAfterHarnessRefresh);
     }
-}
 
-impl PromptEvidence {
-    fn from_prompt(prompt: &str) -> Self {
-        let normalized = normalize_prompt(prompt);
-        let is_empty = normalized.trim().is_empty();
-        let references_current_task = contains_any(
-            &normalized,
-            &[
-                "current task",
-                "active task",
-                "same task",
-                "diesen task",
-                "diesem task",
-                "aktuellen task",
-                "gleichen task",
-                "vorherigen task",
-                "diese änderung",
-                "diesen diff",
-                "das noch",
-            ],
-        );
-        let uses_deprecated_clear_or_commit = normalized.contains("clear_or_commit_unowned_diff");
-        let requests_commit = !uses_deprecated_clear_or_commit
-            && contains_any(
-                &normalized,
-                &[
-                    "commit",
-                    "committe",
-                    "comitten",
-                    "committen",
-                    "baseline",
-                    "baselinen",
-                    "commit_task_baseline",
-                ],
-            );
-        let requests_no_commit = contains_any(
-            &normalized,
-            &[
-                "do not commit",
-                "don't commit",
-                "dont commit",
-                "without committing",
-                "no commit",
-                "nicht committen",
-                "nicht comitten",
-                "nicht baselinen",
-                "nicht commit",
-                "kein commit",
-            ],
-        );
-        let requests_review = contains_any(
-            &normalized,
-            &[
-                "review",
-                "review_task_diff",
-                "review_diff_first",
-                "show diff",
-                "zeige diff",
-                "zeig diff",
-                "prüfe",
-                "pruefe",
-                "prüfen",
-                "pruefen",
-                "anschauen",
-                "ansehen",
-            ],
-        );
-        let requests_repair = contains_any(
-            &normalized,
-            &[
-                "repair",
-                "repair all",
-                "repair_harness",
-                "repariere",
-                "reparieren",
-                "reparier",
-                "sync",
-            ],
-        );
-        let requests_cancel = contains_any(
-            &normalized,
-            &[
-                "cancel",
-                "abbrechen",
-                "verwerfen",
-                "zurücksetzen",
-                "cancel_task_changes",
-            ],
-        );
-        let requests_completion = contains_any(
-            &normalized,
-            &[
-                "complete",
-                "abschließen",
-                "abschliessen",
-                "fertigstellen",
-                "mark complete",
-                "als fertig",
-            ],
-        );
-        let requests_correction = references_current_task
-            || contains_any(
-                &normalized,
-                &[
-                    "auch noch",
-                    "kleinigkeit",
-                    "korrektur",
-                    "korrigiere",
-                    "korrigier",
-                    "nachbessern",
-                    "nachbesserung",
-                    "ändern",
-                    "aendern",
-                    "ändere",
-                    "fix das",
-                    "fixe das",
-                    "request_task_changes",
-                    "reopen",
-                    "erneut öffnen",
-                    "weiterführen",
-                    "weiter fuehren",
-                ],
-            );
-        let requests_new_goal = contains_any(
-            &normalized,
-            &[
-                "new task",
-                "neuer task",
-                "neuen task",
-                "neue aufgabe",
-                "nächster task",
-                "naechster task",
-                "implementiere",
-                "implementieren",
-                "baue",
-                "bauen",
-                "füge",
-                "fuege",
-                "erstelle",
-                "erstellen",
-                "mach bitte",
-                "add ",
-                "create ",
-            ],
-        );
-        let requests_status = contains_any(
-            &normalized,
-            &[
-                "status",
-                "stand",
-                "was ist",
-                "warum",
-                "wieso",
-                "wie können",
-                "wie koennen",
-                "wie sollten",
-                "erklär",
-                "erklaer",
-                "zeige",
-                "zeig",
-                "what do you say",
-            ],
-        ) && !requests_new_goal
-            && !requests_correction
-            && !requests_commit
-            && !requests_completion
-            && !requests_repair;
-        let has_risky_terms = contains_any(
-            &normalized,
-            &[
-                "secret",
-                "token",
-                "api key",
-                "private key",
-                "passwort",
-                "credential",
-                "npm publish",
-                "git push",
-                "force push",
-                "force-push",
-                "--no-verify",
-            ],
-        );
-
-        Self {
-            references_current_task,
-            requests_new_goal,
-            requests_correction,
-            requests_status,
-            requests_review,
-            requests_repair,
-            requests_commit,
-            requests_no_commit,
-            requests_cancel,
-            requests_completion,
-            has_risky_terms,
-            is_empty,
-        }
+    if completed_task_commit_diff(root)?.is_some_and(|diff| !diff.unrelated_paths.is_empty()) {
+        return Ok(CompletedTaskReadiness::ValidWithUnrelatedDirty);
     }
-}
 
-fn prompt_intent(evidence: &PromptEvidence) -> String {
-    let intent = if evidence.is_empty {
-        "ambiguous"
-    } else if evidence.has_risky_terms {
-        "unsafe"
-    } else if evidence.requests_status {
-        "status_question"
-    } else if evidence.requests_repair {
-        "repair_request"
-    } else if evidence.requests_cancel {
-        "cancel_request"
-    } else if evidence.requests_review {
-        "review_request"
-    } else if evidence.requests_no_commit {
-        "no_commit_request"
-    } else if evidence.requests_commit {
-        "commit_request"
-    } else if evidence.requests_new_goal
-        && !(evidence.references_current_task && evidence.requests_correction)
-    {
-        "new_task"
-    } else if evidence.requests_correction {
-        "task_revision"
-    } else if evidence.requests_completion {
-        "task_completion"
-    } else {
-        "ambiguous"
-    };
-
-    intent.to_string()
+    Ok(CompletedTaskReadiness::Invalid)
 }
 
-fn response_policy(
+fn dirty_diff_readiness(
+    root: &Path,
     decision: &Decision,
-    prompt_intent: &str,
-    policy_action: &str,
-    summary: &str,
-) -> (String, Vec<String>, Vec<String>) {
-    let mut internal_notes = vec![
-        format!("repo_state:{}", decision.state),
-        format!("prompt_intent:{prompt_intent}"),
-        format!("policy_action:{policy_action}"),
-    ];
-    if !decision.allowed_actions.is_empty() {
-        internal_notes.push(format!(
-            "internal_allowed_actions:{}",
-            decision.allowed_actions.join(",")
-        ));
+) -> Result<DirtyDiffReadiness, NaomeError> {
+    if !matches!(
+        decision.state.as_str(),
+        "dirty_unowned_diff"
+            | "task_admission_blocked"
+            | "harness_repair_unbaselined"
+            | "install_or_upgrade_unbaselined"
+    ) {
+        return Ok(DirtyDiffReadiness::Unclassified);
     }
 
-    let human_options = match policy_action {
-        "review_task_diff" => decision.allowed_actions.clone(),
-        "cancel_task_changes" => vec![
-            "review_task_diff".to_string(),
-            "cancel_task_changes".to_string(),
-        ],
-        "block_auto_baseline_due_to_no_commit" => decision
-            .allowed_actions
-            .iter()
-            .filter(|action| !action.starts_with("commit_"))
-            .cloned()
-            .collect(),
-        "block_unsafe_intent" => vec!["narrow_request".to_string(), "review_status".to_string()],
-        "block_ambiguous_intent" => decision.allowed_actions.clone(),
-        "block_unowned_diff" => decision
-            .allowed_actions
-            .iter()
-            .filter(|action| action.as_str() == "review_unowned_diff")
-            .cloned()
-            .collect(),
-        "repair_harness_only" => decision.allowed_actions.clone(),
-        "review_diff_first" | "cancel_upgrade_baseline" => decision.allowed_actions.clone(),
-        "review_current_task_diff" | "cancel_current_task" => decision.allowed_actions.clone(),
-        _ => Vec::new(),
-    };
-
-    let user_message = match policy_action {
-        "auto_commit_completed_task_then_create_new_task" => "The completed task is valid. NAOME can baseline it automatically before starting the next separate task.".to_string(),
-        "auto_commit_completed_task_then_create_isolated_task_worktree" => "The completed task is valid. NAOME can baseline only that task, preserve unrelated user edits, and create an isolated worktree for the next task.".to_string(),
-        "auto_commit_harness_refresh_then_create_new_task" => "NAOME can baseline deterministic harness refresh changes first, then create the next task in the same worktree.".to_string(),
-        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => "NAOME can baseline deterministic harness refresh changes first, then create an isolated task worktree and leave user edits untouched.".to_string(),
-        "auto_commit_harness_refresh_baseline" => "NAOME can baseline deterministic harness refresh changes and leave unrelated user edits untouched.".to_string(),
-        "create_isolated_task_worktree" => "NAOME can create an isolated task worktree and leave existing user edits untouched.".to_string(),
-        "commit_user_diff_with_quality_gate" => "NAOME can commit the current user-owned diff only after the configured quality gate passes. It will stage only the changed paths present before the gate runs.".to_string(),
-        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => "The completed task is valid after separating deterministic harness refresh changes. NAOME can baseline the refresh first, then baseline the task before starting the next separate task.".to_string(),
-        "auto_commit_upgrade_baseline_then_create_new_task" => "The setup or repair diff is ready. NAOME can baseline it automatically before starting the next task.".to_string(),
-        "create_new_task" | "create_new_task_without_auto_baseline" => "NAOME is ready to create the next task.".to_string(),
-        "answer_status_only" => summary.to_string(),
-        "block_auto_baseline_due_to_no_commit" => "I will not baseline or commit because the prompt explicitly blocks committing. Review, revise, cancel, or clear the current diff first.".to_string(),
-        "review_task_diff" | "review_diff_first" | "review_current_task_diff" => "The prompt asks for review, so NAOME will not mutate the repository automatically.".to_string(),
-        "cancel_task_changes" | "cancel_upgrade_baseline" | "cancel_current_task" => "The prompt asks to cancel changes, so NAOME will not start new work until that decision is handled.".to_string(),
-        "block_unsafe_intent" => "NAOME blocked this request because it contains unsafe or guardrail-bypass wording.".to_string(),
-        "block_unowned_diff" => "NAOME will not commit or clear unowned changes automatically. Review the existing diff, or ask for a separate new task so NAOME can use an isolated worktree and leave those edits untouched.".to_string(),
-        "repair_harness_only" => "NAOME harness health failed, so normal task work is blocked until repair or review.".to_string(),
-        _ => summary.to_string(),
+    let readiness = match harness_refresh_diff(root)? {
+        Some(diff) if diff.unrelated_paths.is_empty() => DirtyDiffReadiness::HarnessRefreshOnly,
+        Some(diff) if !diff.unrelated_paths.is_empty() => {
+            DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty
+        }
+        _ => DirtyDiffReadiness::Unclassified,
     };
-
-    (user_message, human_options, internal_notes)
-}
-
-fn ambiguous_policy() -> (&'static str, bool, &'static str, &'static str) {
-    (
-        "block_ambiguous_intent",
-        false,
-        "The prompt does not clearly map to a safe NAOME task transition.",
-        "Ask for a narrower request or inspect status.",
-    )
-}
-
-fn normalize_prompt(prompt: &str) -> String {
-    prompt
-        .to_lowercase()
-        .split_whitespace()
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
-fn contains_any(value: &str, needles: &[&str]) -> bool {
-    needles.iter().any(|needle| value.contains(needle))
+    Ok(readiness)
 }