@lamentis/naome 1.1.2 → 1.2.0

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

@@ -0,0 +1,170 @@
+use super::model::IntentKind;
+
+pub(crate) fn normalized(text: &str) -> String {
+    text.to_lowercase()
+        .chars()
+        .map(|ch| if ch.is_alphanumeric() { ch } else { ' ' })
+        .collect::<String>()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+pub(crate) fn lexical_tokens(text: &str) -> Vec<String> {
+    text.split_whitespace()
+        .map(|token| {
+            token
+                .trim_matches(|ch: char| !ch.is_alphanumeric() && ch != '_' && ch != '-')
+                .to_lowercase()
+        })
+        .filter(|token| !token.is_empty())
+        .collect()
+}
+
+pub(crate) fn structured_workflow_intents(text: &str) -> Vec<IntentKind> {
+    let tokens = lexical_tokens(text);
+    let mut intents = Vec::new();
+
+    if let Some(intent) = structured_action(&tokens) {
+        intents.push(intent);
+    }
+    if let Some(intent) = legacy_v1_short_action_request(&tokens) {
+        intents.push(intent);
+    }
+    if legacy_v1_no_commit(&tokens) {
+        intents.push(IntentKind::NoCommitRequest);
+    }
+    if has_structured_token(&tokens, &["no_commit", "without_commit"]) {
+        intents.push(IntentKind::NoCommitRequest);
+    }
+
+    intents.sort_by_key(|kind| kind.as_str());
+    intents.dedup();
+    intents
+}
+
+pub(crate) fn command_workflow_intents(text: &str) -> Vec<IntentKind> {
+    let tokens = lexical_tokens(text);
+    let mut intents = Vec::new();
+    if let Some(intent) = cli_action(&tokens) {
+        intents.push(intent);
+    }
+    intents
+}
+
+pub(crate) fn explicit_task_intent(text: &str) -> Option<IntentKind> {
+    let tokens = lexical_tokens(text);
+    if has_structured_token(&tokens, &["task_revision", "current_task", "active_task"]) {
+        return Some(IntentKind::TaskRevision);
+    }
+    if has_structured_token(&tokens, &["new_task", "create_new_task", "separate_task"]) {
+        return Some(IntentKind::NewTask);
+    }
+    None
+}
+
+pub(crate) fn is_generic_work_request(text: &str) -> bool {
+    !lexical_tokens(text).is_empty()
+}
+
+fn structured_action(tokens: &[String]) -> Option<IntentKind> {
+    policy_action(tokens)
+}
+
+fn policy_action(tokens: &[String]) -> Option<IntentKind> {
+    for token in tokens {
+        let intent = match token.as_str() {
+            "commit_task_baseline" | "commit_user_diff" | "commit_upgrade_baseline" => {
+                IntentKind::CommitRequest
+            }
+            "review_task_diff" | "review_current_task_diff" | "review_unowned_diff" => {
+                IntentKind::ReviewRequest
+            }
+            "repair_harness" | "repair_harness_only" => IntentKind::RepairRequest,
+            "cancel_task_changes" | "cancel_current_task" => IntentKind::CancelRequest,
+            "continue_current_task" | "task_complete" | "complete_task" => {
+                IntentKind::TaskCompletion
+            }
+            "answer_status_only" => IntentKind::StatusQuestion,
+            "clear_or_commit_unowned_diff" => IntentKind::Ambiguous,
+            _ => continue,
+        };
+        return Some(intent);
+    }
+    None
+}
+
+fn cli_action(tokens: &[String]) -> Option<IntentKind> {
+    match (
+        tokens.first().map(String::as_str),
+        tokens.get(1).map(String::as_str),
+    ) {
+        (Some("naome"), Some("commit")) => Some(IntentKind::CommitRequest),
+        (Some("naome"), Some("status")) => Some(IntentKind::StatusQuestion),
+        (Some("naome"), Some("sync" | "update" | "install")) => Some(IntentKind::RepairRequest),
+        (Some("git"), Some("commit")) => Some(IntentKind::CommitRequest),
+        _ => None,
+    }
+}
+
+// Kept only so pre-v2 route callers keep their existing conservative behavior.
+// A naome-intent-v2 envelope clears these candidates before policy resolution.
+fn legacy_v1_short_action_request(tokens: &[String]) -> Option<IntentKind> {
+    let action_index = tokens
+        .iter()
+        .position(|token| legacy_v1_action_intent(token).is_some())?;
+    if action_index > 1 || tokens.len() > 6 {
+        return None;
+    }
+
+    let intent = legacy_v1_action_intent(&tokens[action_index])?;
+    if intent == IntentKind::StatusQuestion || tokens.len() <= 3 {
+        return Some(intent);
+    }
+    if tokens.len() <= 2 || legacy_v1_has_action_scope(tokens) {
+        return Some(intent);
+    }
+    None
+}
+
+fn legacy_v1_no_commit(tokens: &[String]) -> bool {
+    tokens
+        .windows(3)
+        .any(|window| window[0] == "do" && window[1] == "not" && window[2] == "commit")
+        || tokens
+            .windows(2)
+            .any(|window| matches!(window[0].as_str(), "no" | "without") && window[1] == "commit")
+}
+
+fn legacy_v1_action_intent(token: &str) -> Option<IntentKind> {
+    match token {
+        "commit" | "baseline" => Some(IntentKind::CommitRequest),
+        "review" => Some(IntentKind::ReviewRequest),
+        "repair" | "sync" => Some(IntentKind::RepairRequest),
+        "cancel" => Some(IntentKind::CancelRequest),
+        "complete" | "completion" => Some(IntentKind::TaskCompletion),
+        "status" => Some(IntentKind::StatusQuestion),
+        _ => None,
+    }
+}
+
+fn legacy_v1_has_action_scope(tokens: &[String]) -> bool {
+    has_structured_token(
+        tokens,
+        &[
+            "task",
+            "diff",
+            "harness",
+            "baseline",
+            "state",
+            "current_task",
+            "active_task",
+        ],
+    )
+}
+
+fn has_structured_token(tokens: &[String], accepted: &[&str]) -> bool {
+    tokens
+        .iter()
+        .any(|token| accepted.iter().any(|accepted| token == accepted))
+}

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

@@ -0,0 +1,162 @@
+use crate::models::Decision;
+
+use super::classifier::winning_intent;
+use super::model::{CanonicalIntent, IntentKind};
+use super::resolver_policy::state_policy;
+use super::resolver_shared::{ambiguous_conflict, ambiguous_empty, unsafe_policy, Policy};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CompletedTaskReadiness {
+    Valid,
+    ValidAfterHarnessRefresh,
+    ValidWithUnrelatedDirty,
+    Invalid,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum DirtyDiffReadiness {
+    Unclassified,
+    HarnessRefreshOnly,
+    HarnessRefreshWithUnrelatedDirty,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ResolvedIntent {
+    pub prompt_intent: IntentKind,
+    pub certainty: String,
+    pub policy_action: String,
+    pub allowed: bool,
+    pub summary: String,
+    pub next_action: String,
+    pub reason_codes: Vec<String>,
+    pub risk_codes: Vec<String>,
+}
+
+pub(crate) fn resolve_intent(
+    decision: &Decision,
+    canonical: &CanonicalIntent,
+    completed_task_readiness: CompletedTaskReadiness,
+    dirty_diff_readiness: DirtyDiffReadiness,
+) -> ResolvedIntent {
+    let prompt_intent = winning_intent(canonical);
+    let mut reason_codes = reason_codes(decision, canonical, prompt_intent);
+    let mut risk_codes = canonical.risk.risk_codes.clone();
+    if canonical.risk.has_risky_terms
+        && !risk_codes
+            .iter()
+            .any(|code| code == "prompt_contains_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());
+    }
+
+    let policy = resolve_policy(
+        decision,
+        canonical,
+        prompt_intent,
+        completed_task_readiness,
+        dirty_diff_readiness,
+        &mut reason_codes,
+    );
+
+    ResolvedIntent {
+        prompt_intent,
+        certainty: certainty(prompt_intent, &policy.0, &risk_codes),
+        policy_action: policy.0.to_string(),
+        allowed: policy.1,
+        summary: policy.2.to_string(),
+        next_action: policy.3.to_string(),
+        reason_codes,
+        risk_codes,
+    }
+}
+
+fn resolve_policy(
+    decision: &Decision,
+    canonical: &CanonicalIntent,
+    prompt_intent: IntentKind,
+    completed_task_readiness: CompletedTaskReadiness,
+    dirty_diff_readiness: DirtyDiffReadiness,
+    reason_codes: &mut Vec<String>,
+) -> Policy {
+    if canonical.is_empty {
+        ambiguous_empty()
+    } else if canonical.has_workflow_conflict {
+        reason_codes.push("winning_rule:workflow_intent_conflict".to_string());
+        ambiguous_conflict()
+    } else if prompt_intent == IntentKind::Unsafe {
+        reason_codes.push("winning_rule:unsafe_intent_precedence".to_string());
+        unsafe_policy()
+    } else if prompt_intent == IntentKind::StatusQuestion {
+        (
+            "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 {
+        state_policy(
+            decision,
+            prompt_intent,
+            completed_task_readiness,
+            dirty_diff_readiness,
+            canonical.risk.has_risky_terms,
+        )
+    }
+}
+
+fn reason_codes(
+    decision: &Decision,
+    canonical: &CanonicalIntent,
+    prompt_intent: IntentKind,
+) -> Vec<String> {
+    let mut codes = vec![format!("repo_state:{}", decision.state)];
+    if canonical.references_current_task {
+        codes.push("prompt_references_current_task".to_string());
+    }
+    for (kind, code) in [
+        (IntentKind::NewTask, "prompt_requests_new_goal"),
+        (IntentKind::TaskRevision, "prompt_requests_correction"),
+        (IntentKind::CommitRequest, "prompt_requests_commit"),
+        (IntentKind::NoCommitRequest, "prompt_blocks_commit"),
+        (IntentKind::ReviewRequest, "prompt_requests_review"),
+        (IntentKind::RepairRequest, "prompt_requests_repair"),
+        (IntentKind::CancelRequest, "prompt_requests_cancel"),
+    ] {
+        if prompt_intent == kind
+            || canonical
+                .candidates
+                .iter()
+                .any(|candidate| candidate.kind == kind)
+        {
+            codes.push(code.to_string());
+        }
+    }
+    codes
+}
+
+fn certainty(intent: IntentKind, policy_action: &str, risk_codes: &[String]) -> String {
+    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"
+        || intent == IntentKind::Ambiguous
+    {
+        "ambiguous"
+    } else if matches!(
+        intent,
+        IntentKind::CommitRequest
+            | IntentKind::StatusQuestion
+            | IntentKind::ReviewRequest
+            | IntentKind::RepairRequest
+            | IntentKind::NoCommitRequest
+            | IntentKind::CancelRequest
+    ) {
+        "exact"
+    } else {
+        "likely"
+    }
+    .to_string()
+}

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

@@ -0,0 +1,17 @@
+use super::model::IntentKind;
+use super::resolver_catalog::{
+    POLICY_ACTIVE_CANCEL, POLICY_ACTIVE_CONTINUE, POLICY_ACTIVE_NEW_BLOCK, POLICY_ACTIVE_NO_COMMIT,
+    POLICY_ACTIVE_REVIEW,
+};
+use super::resolver_shared::{ambiguous_policy, Policy};
+
+pub(crate) fn active_policy(intent: IntentKind) -> Policy {
+    match intent {
+        IntentKind::ReviewRequest => POLICY_ACTIVE_REVIEW,
+        IntentKind::CancelRequest => POLICY_ACTIVE_CANCEL,
+        IntentKind::NoCommitRequest => POLICY_ACTIVE_NO_COMMIT,
+        IntentKind::TaskRevision | IntentKind::TaskCompletion => POLICY_ACTIVE_CONTINUE,
+        IntentKind::NewTask => POLICY_ACTIVE_NEW_BLOCK,
+        _ => ambiguous_policy(),
+    }
+}

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

@@ -0,0 +1,55 @@
+use super::model::IntentKind;
+use super::resolver::DirtyDiffReadiness;
+use super::resolver_catalog::{
+    POLICY_BASELINE_BLOCK, POLICY_BASELINE_CANCEL, POLICY_BASELINE_COMMIT_UPGRADE,
+    POLICY_BASELINE_NEW_REFRESH, POLICY_BASELINE_NEW_UPGRADE, POLICY_BASELINE_NO_COMMIT,
+    POLICY_BASELINE_REVIEW, POLICY_DIRTY_BLOCK, POLICY_DIRTY_COMMIT_USER,
+    POLICY_DIRTY_NEW_ISOLATED, POLICY_DIRTY_NEW_REFRESH, POLICY_DIRTY_NEW_WORKTREE,
+};
+use super::resolver_shared::{harness_refresh_policy, unsafe_policy, Policy};
+
+pub(crate) fn dirty_policy(intent: IntentKind, dirty: DirtyDiffReadiness, risky: bool) -> Policy {
+    match (intent, dirty, risky) {
+        (IntentKind::RepairRequest, DirtyDiffReadiness::HarnessRefreshOnly, false) => {
+            harness_refresh_policy()
+        }
+        (
+            IntentKind::RepairRequest,
+            DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty,
+            false,
+        ) => harness_refresh_policy(),
+        (IntentKind::NewTask, DirtyDiffReadiness::HarnessRefreshOnly, false) => {
+            POLICY_DIRTY_NEW_REFRESH
+        }
+        (IntentKind::NewTask, DirtyDiffReadiness::HarnessRefreshWithUnrelatedDirty, false) => {
+            POLICY_DIRTY_NEW_ISOLATED
+        }
+        (IntentKind::NewTask, _, false) => POLICY_DIRTY_NEW_WORKTREE,
+        (IntentKind::CommitRequest, _, false) => POLICY_DIRTY_COMMIT_USER,
+        _ => POLICY_DIRTY_BLOCK,
+    }
+}
+
+pub(crate) fn baseline_policy(
+    intent: IntentKind,
+    dirty: DirtyDiffReadiness,
+    risky: bool,
+) -> Policy {
+    match intent {
+        IntentKind::NoCommitRequest => POLICY_BASELINE_NO_COMMIT,
+        IntentKind::ReviewRequest => POLICY_BASELINE_REVIEW,
+        IntentKind::CancelRequest => POLICY_BASELINE_CANCEL,
+        IntentKind::CommitRequest | IntentKind::RepairRequest
+            if dirty == DirtyDiffReadiness::HarnessRefreshOnly =>
+        {
+            harness_refresh_policy()
+        }
+        IntentKind::CommitRequest | IntentKind::RepairRequest => POLICY_BASELINE_COMMIT_UPGRADE,
+        IntentKind::NewTask if dirty == DirtyDiffReadiness::HarnessRefreshOnly && !risky => {
+            POLICY_BASELINE_NEW_REFRESH
+        }
+        IntentKind::NewTask if !risky => POLICY_BASELINE_NEW_UPGRADE,
+        IntentKind::NewTask => unsafe_policy(),
+        _ => POLICY_BASELINE_BLOCK,
+    }
+}

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

@@ -0,0 +1,167 @@
+use super::resolver_shared::Policy;
+
+pub(crate) const POLICY_ACTIVE_BLOCKED: Policy = (
+    "block_unowned_diff",
+    false,
+    "The active task is blocked by out-of-scope changes.",
+    "Resolve the scope blocker before interpreting new work.",
+);
+pub(crate) const POLICY_ACTIVE_CANCEL: Policy = (
+    "cancel_current_task",
+    false,
+    "The prompt asks to cancel the active task.",
+    "Cancel or review the active task before starting another.",
+);
+pub(crate) const POLICY_ACTIVE_CONTINUE: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_ACTIVE_NEW_BLOCK: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_ACTIVE_NO_COMMIT: Policy = (
+    "continue_current_task_without_commit",
+    true,
+    "A task is active and the prompt blocks committing.",
+    "Continue the active task without baselining.",
+);
+pub(crate) const POLICY_ACTIVE_REVIEW: Policy = (
+    "review_current_task_diff",
+    false,
+    "The prompt asks to review the active task diff.",
+    "Review the active task before mutating it further.",
+);
+pub(crate) const POLICY_BASELINE_BLOCK: Policy = (
+    "block_unowned_diff",
+    false,
+    "Setup, upgrade, or repair changes must be resolved before task routing.",
+    "Resolve the harness baseline decision before accepting feature work.",
+);
+pub(crate) const POLICY_BASELINE_CANCEL: Policy = (
+    "cancel_upgrade_baseline",
+    false,
+    "The prompt explicitly asks to cancel setup, upgrade, or repair changes.",
+    "Cancel or review the NAOME diff before feature work.",
+);
+pub(crate) const POLICY_BASELINE_COMMIT_UPGRADE: Policy = (
+    "commit_upgrade_baseline",
+    true,
+    "The prompt asks to baseline pending setup, upgrade, or repair changes.",
+    "Run the appropriate NAOME baseline flow before feature work.",
+);
+pub(crate) const POLICY_BASELINE_NEW_REFRESH: Policy = ("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.");
+pub(crate) const POLICY_BASELINE_NEW_UPGRADE: Policy = ("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.");
+pub(crate) const POLICY_BASELINE_NO_COMMIT: Policy = ("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.");
+pub(crate) const POLICY_BASELINE_REVIEW: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_CANCEL: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_COMMIT: Policy = (
+    "commit_task_baseline",
+    true,
+    "The prompt asks to baseline the completed task diff.",
+    "Run the NAOME commit baseline flow for the completed task.",
+);
+pub(crate) const POLICY_COMPLETED_NEW_INVALID: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_NEW_ISOLATED: Policy = ("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.");
+pub(crate) const POLICY_COMPLETED_NEW_REFRESH: Policy = ("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.");
+pub(crate) const POLICY_COMPLETED_NEW_VALID: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_NO_COMMIT: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_REVIEW: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_COMPLETED_REVISION: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_DIRTY_BLOCK: Policy = ("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.");
+pub(crate) const POLICY_DIRTY_COMMIT_USER: Policy = ("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.");
+pub(crate) const POLICY_DIRTY_NEW_ISOLATED: Policy = ("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.");
+pub(crate) const POLICY_DIRTY_NEW_REFRESH: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_DIRTY_NEW_WORKTREE: Policy = ("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.");
+pub(crate) const POLICY_FIRST_RUN: Policy = (
+    "run_first_run_protocol",
+    false,
+    "First-run intake must finish before feature work.",
+    "Run the NAOME first-run protocol.",
+);
+pub(crate) const POLICY_HARNESS_UNHEALTHY: Policy = (
+    "repair_harness_only",
+    false,
+    "The harness is unhealthy, so normal task work is blocked.",
+    "Repair or review the harness before accepting feature work.",
+);
+pub(crate) const POLICY_READY_COMMIT_BLOCK: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_READY_NEW: Policy = (
+    "create_new_task",
+    true,
+    "The repository is clean and the prompt asks for a new goal.",
+    "Create a NAOME task for the new request.",
+);
+pub(crate) const POLICY_READY_NO_COMMIT: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_READY_REVIEW_STATUS: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_READY_REVISION_BLOCK: Policy = (
+    "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.",
+);
+pub(crate) const POLICY_UPGRADE: Policy = (
+    "run_upgrade_protocol",
+    false,
+    "A NAOME upgrade is pending before feature work.",
+    "Run the NAOME upgrade protocol.",
+);

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

@@ -0,0 +1,72 @@
+use crate::models::Decision;
+
+use super::model::IntentKind;
+use super::resolver::{CompletedTaskReadiness, DirtyDiffReadiness};
+use super::resolver_active::active_policy;
+use super::resolver_baseline::{baseline_policy, dirty_policy};
+use super::resolver_catalog::{
+    POLICY_ACTIVE_BLOCKED, POLICY_COMPLETED_CANCEL, POLICY_COMPLETED_COMMIT,
+    POLICY_COMPLETED_NEW_INVALID, POLICY_COMPLETED_NEW_ISOLATED, POLICY_COMPLETED_NEW_REFRESH,
+    POLICY_COMPLETED_NEW_VALID, POLICY_COMPLETED_NO_COMMIT, POLICY_COMPLETED_REVIEW,
+    POLICY_COMPLETED_REVISION, POLICY_FIRST_RUN, POLICY_HARNESS_UNHEALTHY,
+    POLICY_READY_COMMIT_BLOCK, POLICY_READY_NEW, POLICY_READY_NO_COMMIT,
+    POLICY_READY_REVIEW_STATUS, POLICY_READY_REVISION_BLOCK, POLICY_UPGRADE,
+};
+use super::resolver_shared::{ambiguous_policy, Policy};
+
+pub(crate) fn state_policy(
+    decision: &Decision,
+    prompt_intent: IntentKind,
+    completed: CompletedTaskReadiness,
+    dirty: DirtyDiffReadiness,
+    risky: bool,
+) -> Policy {
+    match decision.state.as_str() {
+        "harness_unhealthy" => POLICY_HARNESS_UNHEALTHY,
+        "first_run_required" => POLICY_FIRST_RUN,
+        "upgrade_required" => POLICY_UPGRADE,
+        "ready_for_task" => ready_policy(prompt_intent),
+        "completed_task_unbaselined" => completed_policy(prompt_intent, completed, risky),
+        "active_task_in_progress" => active_policy(prompt_intent),
+        "active_task_blocked" => POLICY_ACTIVE_BLOCKED,
+        "dirty_unowned_diff" | "task_admission_blocked" => {
+            dirty_policy(prompt_intent, dirty, risky)
+        }
+        "install_or_upgrade_unbaselined" | "harness_repair_unbaselined" => {
+            baseline_policy(prompt_intent, dirty, risky)
+        }
+        _ => ambiguous_policy(),
+    }
+}
+
+fn ready_policy(intent: IntentKind) -> Policy {
+    match intent {
+        IntentKind::NewTask => POLICY_READY_NEW,
+        IntentKind::CommitRequest => POLICY_READY_COMMIT_BLOCK,
+        IntentKind::ReviewRequest => POLICY_READY_REVIEW_STATUS,
+        IntentKind::NoCommitRequest => POLICY_READY_NO_COMMIT,
+        IntentKind::TaskRevision => POLICY_READY_REVISION_BLOCK,
+        _ => ambiguous_policy(),
+    }
+}
+
+fn completed_policy(intent: IntentKind, completed: CompletedTaskReadiness, risky: bool) -> Policy {
+    match intent {
+        IntentKind::NoCommitRequest => POLICY_COMPLETED_NO_COMMIT,
+        IntentKind::ReviewRequest => POLICY_COMPLETED_REVIEW,
+        IntentKind::CancelRequest => POLICY_COMPLETED_CANCEL,
+        IntentKind::CommitRequest => POLICY_COMPLETED_COMMIT,
+        IntentKind::TaskRevision => POLICY_COMPLETED_REVISION,
+        IntentKind::NewTask => completed_new_task_policy(completed, risky),
+        _ => ambiguous_policy(),
+    }
+}
+
+fn completed_new_task_policy(completed: CompletedTaskReadiness, risky: bool) -> Policy {
+    match (completed, risky) {
+        (CompletedTaskReadiness::Valid, false) => POLICY_COMPLETED_NEW_VALID,
+        (CompletedTaskReadiness::ValidAfterHarnessRefresh, false) => POLICY_COMPLETED_NEW_REFRESH,
+        (CompletedTaskReadiness::ValidWithUnrelatedDirty, false) => POLICY_COMPLETED_NEW_ISOLATED,
+        _ => POLICY_COMPLETED_NEW_INVALID,
+    }
+}