@lamentis/naome 1.1.2 → 1.2.1

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

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

@@ -0,0 +1,55 @@
+pub(crate) type Policy = (&'static str, bool, &'static str, &'static str);
+
+pub(crate) fn policy(
+    action: &'static str,
+    allowed: bool,
+    summary: &'static str,
+    next_action: &'static str,
+) -> Policy {
+    (action, allowed, summary, next_action)
+}
+
+pub(crate) fn harness_refresh_policy() -> Policy {
+    policy(
+        "auto_commit_harness_refresh_baseline",
+        true,
+        "The repository has only deterministic harness refresh changes.",
+        "Baseline the harness refresh before feature work.",
+    )
+}
+
+pub(crate) fn ambiguous_empty() -> Policy {
+    policy(
+        "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.",
+    )
+}
+
+pub(crate) fn ambiguous_conflict() -> Policy {
+    policy(
+        "block_ambiguous_intent",
+        false,
+        "The prompt contains conflicting workflow actions.",
+        "Ask which workflow action should run before mutating the repository.",
+    )
+}
+
+pub(crate) fn ambiguous_policy() -> Policy {
+    policy(
+        "block_ambiguous_intent",
+        false,
+        "The prompt does not clearly map to a safe NAOME task transition.",
+        "Ask for a narrower request or inspect status.",
+    )
+}
+
+pub(crate) fn unsafe_policy() -> Policy {
+    policy(
+        "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.",
+    )
+}

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

@@ -0,0 +1,40 @@
+use super::model::{PromptSegment, RiskContext, SegmentKind};
+use super::patterns::lexical_tokens;
+
+pub(crate) fn detect_risk(segments: &[PromptSegment]) -> RiskContext {
+    let mut codes = Vec::new();
+    for segment in segments
+        .iter()
+        .filter(|segment| segment.kind == SegmentKind::CommandLike)
+    {
+        let tokens = lexical_tokens(&segment.text);
+        if is_bypass_command(&tokens) {
+            codes.push("structured_risk:bypass_command".to_string());
+        }
+        if is_publish_command(&tokens) {
+            codes.push("structured_risk:publish_command".to_string());
+        }
+    }
+
+    codes.sort();
+    codes.dedup();
+    RiskContext {
+        has_risky_terms: !codes.is_empty(),
+        risk_codes: codes,
+    }
+}
+
+fn is_bypass_command(tokens: &[String]) -> bool {
+    tokens
+        .iter()
+        .any(|token| matches!(token.as_str(), "--no-verify" | "no-verify"))
+        || tokens
+            .windows(2)
+            .any(|window| window[0] == "git" && window[1] == "push")
+}
+
+fn is_publish_command(tokens: &[String]) -> bool {
+    tokens
+        .windows(2)
+        .any(|window| window[0] == "npm" && window[1] == "publish")
+}

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

@@ -0,0 +1,170 @@
+use super::model::{PromptSegment, SegmentKind};
+
+pub(crate) fn segment_prompt(prompt: &str) -> Vec<PromptSegment> {
+    let mut segments = Vec::new();
+    let mut rest = prompt;
+
+    loop {
+        let Some(start) = rest.find("```") else {
+            segment_plain_block(&mut segments, rest);
+            break;
+        };
+
+        segment_plain_block(&mut segments, &rest[..start]);
+        let after_open = &rest[start + 3..];
+        let Some(end) = after_open.find("```") else {
+            push_segment(&mut segments, SegmentKind::CodeFence, after_open);
+            break;
+        };
+
+        push_segment(
+            &mut segments,
+            SegmentKind::CodeFence,
+            code_fence_body(&after_open[..end]),
+        );
+        rest = &after_open[end + 3..];
+    }
+
+    segments
+}
+
+fn segment_plain_block(segments: &mut Vec<PromptSegment>, text: &str) {
+    for line in text.lines() {
+        let trimmed = line.trim();
+        if !trimmed.is_empty() {
+            segment_line(segments, line);
+        }
+    }
+}
+
+fn code_fence_body(text: &str) -> &str {
+    if let Some((language, body)) = text.split_once('\n') {
+        if language.trim().chars().all(|ch| ch.is_ascii_alphanumeric()) {
+            return body;
+        }
+    }
+    text
+}
+
+pub(crate) fn actionable_text(segments: &[PromptSegment]) -> String {
+    segments
+        .iter()
+        .filter(|segment| {
+            matches!(
+                segment.kind,
+                SegmentKind::Prose | SegmentKind::ListItem | SegmentKind::CommandLike
+            )
+        })
+        .map(|segment| segment.text.as_str())
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn segment_line(segments: &mut Vec<PromptSegment>, line: &str) {
+    let trimmed = line.trim();
+    if trimmed.is_empty() {
+        return;
+    }
+
+    let (kind, text) = if let Some(item) = list_item_text(trimmed) {
+        (SegmentKind::ListItem, item)
+    } else if is_command_like(trimmed) {
+        (SegmentKind::CommandLike, trimmed)
+    } else if is_path_like(trimmed) {
+        (SegmentKind::FilePath, trimmed)
+    } else {
+        (SegmentKind::Prose, trimmed)
+    };
+
+    segment_inline(segments, kind, text);
+}
+
+fn segment_inline(segments: &mut Vec<PromptSegment>, default_kind: SegmentKind, text: &str) {
+    let mut rest = text;
+    loop {
+        let Some(start) = rest.find('`') else {
+            segment_quotes(segments, default_kind, rest);
+            break;
+        };
+        segment_quotes(segments, default_kind, &rest[..start]);
+        let after_tick = &rest[start + 1..];
+        let Some(end) = after_tick.find('`') else {
+            segment_quotes(segments, default_kind, rest);
+            break;
+        };
+        push_segment(segments, SegmentKind::InlineCode, &after_tick[..end]);
+        rest = &after_tick[end + 1..];
+    }
+}
+
+fn segment_quotes(segments: &mut Vec<PromptSegment>, default_kind: SegmentKind, text: &str) {
+    let mut current = String::new();
+    let mut quoted = String::new();
+    let mut in_quote = false;
+    for ch in text.chars() {
+        if matches!(ch, '"' | '\'' | '“' | '”' | '‘' | '’') {
+            if in_quote {
+                push_segment(segments, SegmentKind::QuotedText, &quoted);
+                quoted.clear();
+            } else {
+                push_segment(segments, default_kind, &current);
+                current.clear();
+            }
+            in_quote = !in_quote;
+        } else if in_quote {
+            quoted.push(ch);
+        } else {
+            current.push(ch);
+        }
+    }
+
+    let kind = if in_quote {
+        default_kind
+    } else {
+        SegmentKind::QuotedText
+    };
+    push_segment(segments, kind, &quoted);
+    push_segment(segments, default_kind, &current);
+}
+
+fn push_segment(segments: &mut Vec<PromptSegment>, kind: SegmentKind, text: &str) {
+    let trimmed = text.trim();
+    if !trimmed.is_empty() {
+        segments.push(PromptSegment {
+            kind,
+            text: trimmed.to_string(),
+        });
+    }
+}
+
+fn list_item_text(trimmed: &str) -> Option<&str> {
+    if let Some(rest) = trimmed
+        .strip_prefix("- ")
+        .or_else(|| trimmed.strip_prefix("* "))
+    {
+        return Some(rest.trim());
+    }
+
+    let (number, rest) = trimmed.split_once(". ")?;
+    number
+        .chars()
+        .all(|ch| ch.is_ascii_digit())
+        .then_some(rest.trim())
+}
+
+fn is_command_like(trimmed: &str) -> bool {
+    let first = trimmed.split_whitespace().next().unwrap_or_default();
+    matches!(
+        first,
+        "git" | "npm" | "node" | "cargo" | "naome" | "rg" | "python" | "python3"
+    )
+}
+
+fn is_path_like(trimmed: &str) -> bool {
+    !trimmed.contains(' ')
+        && (trimmed.contains('/')
+            || trimmed.ends_with(".rs")
+            || trimmed.ends_with(".js")
+            || trimmed.ends_with(".json")
+            || trimmed.ends_with(".md"))
+}