@lamentis/naome 1.1.2 → 1.2.1

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

@@ -0,0 +1,138 @@
+use serde::Serialize;
+
+use crate::models::Decision;
+
+use super::classifier::{has_candidate, winning_intent};
+use super::legacy_response::response_policy;
+use super::model::{CanonicalIntent, IntentKind};
+use super::resolver::ResolvedIntent;
+
+#[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,
+}
+
+pub(crate) fn legacy_decision(
+    decision: Decision,
+    canonical: CanonicalIntent,
+    resolved: ResolvedIntent,
+) -> IntentDecision {
+    let evidence = PromptEvidence::from_canonical(&canonical);
+    let (user_message, human_options, mut internal_notes) = response_policy(
+        &decision,
+        resolved.prompt_intent.as_str(),
+        &resolved.policy_action,
+        &resolved.summary,
+    );
+    for code in &resolved.reason_codes {
+        if !internal_notes.contains(code) {
+            internal_notes.push(code.clone());
+        }
+    }
+
+    IntentDecision {
+        schema: "naome.intent.v1".to_string(),
+        repo_state: decision.state,
+        blocked: decision.blocked,
+        prompt_intent: resolved.prompt_intent.as_str().to_string(),
+        certainty: resolved.certainty,
+        policy_action: resolved.policy_action,
+        allowed: resolved.allowed,
+        summary: resolved.summary,
+        next_action: resolved.next_action,
+        user_message,
+        human_options,
+        internal_notes,
+        reason_codes: resolved.reason_codes,
+        risk_codes: resolved.risk_codes,
+        changed_paths: decision.changed_paths,
+        required_context: decision.required_context,
+        evidence,
+    }
+}
+
+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")
+}
+
+impl PromptEvidence {
+    fn from_canonical(canonical: &CanonicalIntent) -> Self {
+        Self {
+            references_current_task: canonical.references_current_task,
+            requests_new_goal: has_candidate(canonical, IntentKind::NewTask),
+            requests_correction: has_candidate(canonical, IntentKind::TaskRevision),
+            requests_status: winning_intent(canonical) == IntentKind::StatusQuestion,
+            requests_review: has_candidate(canonical, IntentKind::ReviewRequest),
+            requests_repair: has_candidate(canonical, IntentKind::RepairRequest),
+            requests_commit: has_candidate(canonical, IntentKind::CommitRequest),
+            requests_no_commit: has_candidate(canonical, IntentKind::NoCommitRequest),
+            requests_cancel: has_candidate(canonical, IntentKind::CancelRequest),
+            requests_completion: has_candidate(canonical, IntentKind::TaskCompletion),
+            has_risky_terms: canonical.risk.has_risky_terms,
+            is_empty: canonical.is_empty,
+        }
+    }
+}

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

@@ -0,0 +1,76 @@
+use crate::models::Decision;
+
+pub(crate) fn response_policy(
+    decision: &Decision,
+    prompt_intent: &str,
+    policy_action: &str,
+    summary: &str,
+) -> (String, Vec<String>, Vec<String>) {
+    let internal_notes = response_notes(decision, prompt_intent, policy_action);
+    let human_options = response_human_options(decision, policy_action);
+    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.",
+        "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.",
+        "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.",
+        "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.",
+        "auto_commit_harness_refresh_baseline" => "NAOME can baseline deterministic harness refresh changes and leave unrelated user edits untouched.",
+        "create_isolated_task_worktree" => "NAOME can create an isolated task worktree and leave existing user edits untouched.",
+        "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.",
+        "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.",
+        "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.",
+        "create_new_task" | "create_new_task_without_auto_baseline" => "NAOME is ready to create the next task.",
+        "answer_status_only" => summary,
+        "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.",
+        "review_task_diff" | "review_diff_first" | "review_current_task_diff" => "The prompt asks for review, so NAOME will not mutate the repository automatically.",
+        "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.",
+        "block_unsafe_intent" => "NAOME blocked this request because it contains unsafe or guardrail-bypass wording.",
+        "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.",
+        "repair_harness_only" => "NAOME harness health failed, so normal task work is blocked until repair or review.",
+        _ => summary,
+    };
+
+    (user_message.to_string(), human_options, internal_notes)
+}
+
+fn response_notes(decision: &Decision, prompt_intent: &str, policy_action: &str) -> Vec<String> {
+    let mut notes = vec![
+        format!("repo_state:{}", decision.state),
+        format!("prompt_intent:{prompt_intent}"),
+        format!("policy_action:{policy_action}"),
+    ];
+    if !decision.allowed_actions.is_empty() {
+        notes.push(format!(
+            "internal_allowed_actions:{}",
+            decision.allowed_actions.join(",")
+        ));
+    }
+    notes
+}
+
+fn response_human_options(decision: &Decision, policy_action: &str) -> Vec<String> {
+    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(),
+    }
+}

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

@@ -0,0 +1,71 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum SegmentKind {
+    Prose,
+    InlineCode,
+    CodeFence,
+    QuotedText,
+    ListItem,
+    FilePath,
+    CommandLike,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct PromptSegment {
+    pub kind: SegmentKind,
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) enum IntentKind {
+    Ambiguous,
+    NewTask,
+    TaskRevision,
+    StatusQuestion,
+    ReviewRequest,
+    RepairRequest,
+    CommitRequest,
+    NoCommitRequest,
+    CancelRequest,
+    TaskCompletion,
+    Unsafe,
+}
+
+impl IntentKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Ambiguous => "ambiguous",
+            Self::NewTask => "new_task",
+            Self::TaskRevision => "task_revision",
+            Self::StatusQuestion => "status_question",
+            Self::ReviewRequest => "review_request",
+            Self::RepairRequest => "repair_request",
+            Self::CommitRequest => "commit_request",
+            Self::NoCommitRequest => "no_commit_request",
+            Self::CancelRequest => "cancel_request",
+            Self::TaskCompletion => "task_completion",
+            Self::Unsafe => "unsafe",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct IntentCandidate {
+    pub kind: IntentKind,
+    pub confidence: u8,
+    pub evidence: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RiskContext {
+    pub has_risky_terms: bool,
+    pub risk_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CanonicalIntent {
+    pub is_empty: bool,
+    pub references_current_task: bool,
+    pub candidates: Vec<IntentCandidate>,
+    pub risk: RiskContext,
+    pub has_workflow_conflict: bool,
+}

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,
+    }
+}