@lamentis/naome 1.3.7 → 1.3.8

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

@@ -89,6 +89,20 @@ fn resolve_policy(
     } else if prompt_intent == IntentKind::Unsafe {
         reason_codes.push("winning_rule:unsafe_intent_precedence".to_string());
         unsafe_policy()
+    } else if prompt_intent == IntentKind::PromptNormalizationRequired {
+        (
+            "normalize_prompt_first",
+            true,
+            "NAOME needs a structured prompt envelope before routing or mutating repository state.",
+            "Normalize the user prompt into the deterministic NAOME prompt envelope, then rerun routing.",
+        )
+    } else if prompt_intent == IntentKind::Advisory {
+        (
+            "answer_without_mutation",
+            true,
+            "The prompt envelope classifies this as advisory or planning-only work.",
+            "Answer without creating a task, journaling, editing files, committing, pushing, or creating a merge request.",
+        )
     } else if prompt_intent == IntentKind::StatusQuestion {
         (
             "answer_status_only",
@@ -113,11 +127,20 @@ fn reason_codes(
     prompt_intent: IntentKind,
 ) -> Vec<String> {
     let mut codes = vec![format!("repo_state:{}", decision.state)];
+    if canonical.has_routing_envelope {
+        codes.push("prompt_has_routing_envelope".to_string());
+    }
+    codes.extend(canonical.validation_errors.iter().cloned());
     if canonical.references_current_task {
         codes.push("prompt_references_current_task".to_string());
     }
     for (kind, code) in [
         (IntentKind::NewTask, "prompt_requests_new_goal"),
+        (
+            IntentKind::PromptNormalizationRequired,
+            "prompt_requires_normalization_envelope",
+        ),
+        (IntentKind::Advisory, "prompt_requests_advisory_answer"),
         (IntentKind::TaskRevision, "prompt_requests_correction"),
         (IntentKind::CommitRequest, "prompt_requests_commit"),
         (IntentKind::NoCommitRequest, "prompt_blocks_commit"),
@@ -153,6 +176,8 @@ fn certainty(intent: IntentKind, policy_action: &str, risk_codes: &[String]) ->
             | IntentKind::RepairRequest
             | IntentKind::NoCommitRequest
             | IntentKind::CancelRequest
+            | IntentKind::PromptNormalizationRequired
+            | IntentKind::Advisory
     ) {
         "exact"
     } else {

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

@@ -1,5 +1,4 @@
 use super::model::{PromptSegment, RiskContext, SegmentKind};
-use super::patterns::lexical_tokens;
 
 pub(crate) fn detect_risk(segments: &[PromptSegment]) -> RiskContext {
     let mut codes = Vec::new();
@@ -38,3 +37,14 @@ fn is_publish_command(tokens: &[String]) -> bool {
         .windows(2)
         .any(|window| window[0] == "npm" && window[1] == "publish")
 }
+
+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()
+}

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

@@ -3,7 +3,6 @@ mod envelope;
 mod legacy;
 mod legacy_response;
 mod model;
-mod patterns;
 mod resolver;
 mod resolver_active;
 mod resolver_baseline;
@@ -23,6 +22,7 @@ use crate::task_state::{
 };
 
 use classifier::canonical_intent;
+pub(crate) use envelope::prompt_envelope_json;
 pub use legacy::{format_intent, IntentDecision, PromptEvidence};
 use resolver::{resolve_intent, CompletedTaskReadiness, DirtyDiffReadiness};
 

package/crates/naome-core/src/route/context.rs

@@ -57,6 +57,8 @@ pub(super) fn winning_rule(intent: &IntentDecision) -> String {
             "current_task_revision_continues_task"
         }
         "answer_status_only" => "status_request_read_only",
+        "normalize_prompt_first" => "prompt_envelope_required_before_routing",
+        "answer_without_mutation" => "advisory_prompt_read_only",
         "create_new_task" | "create_new_task_without_auto_baseline" => "ready_repo_new_task",
         "create_isolated_task_worktree" => "dirty_repo_new_task_worktree_isolation",
         "commit_user_diff_with_quality_gate" => "explicit_user_diff_commit_quality_gate",
@@ -164,6 +166,12 @@ pub(super) fn required_context_for_intent(intent: &IntentDecision) -> Vec<String
         "answer_status_only" => {
             push_unique(&mut context, "docs/naome/index.md");
         }
+        "normalize_prompt_first" => {
+            push_unique(&mut context, "docs/naome/agent-workflow.md");
+        }
+        "answer_without_mutation" => {
+            push_unique(&mut context, "docs/naome/index.md");
+        }
         "repair_harness_only" => {
             push_unique(&mut context, ".naome/manifest.json");
             push_unique(&mut context, "docs/naome/index.md");

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

@@ -66,6 +66,91 @@ fn prompt_context_uses_file_mentions_without_broad_markdown_context() {
         .any(|item| item.path == "docs/naome/repository-quality.md"));
 }
 
+#[test]
+fn prompt_context_ignores_nonexistent_concept_tokens_that_look_path_like() {
+    let repo = context_repo("context-prompt-concept-terms");
+    repo.write_file("docs/naome/repository-quality.md", "# Quality\n");
+    repo.commit_all("baseline");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "Advisory/planning-only prompts and German/English examples must not become paths.",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(
+        selection.required_context[0].path,
+        ".naome/verification.json"
+    );
+    assert!(!selection
+        .required_context
+        .iter()
+        .any(|item| item.path == "Advisory/planning-only" || item.path == "German/English"));
+}
+
+#[test]
+fn prompt_context_prefers_envelope_referenced_paths_over_raw_prompt_tokens() {
+    let repo = context_repo("context-prompt-envelope-paths");
+    repo.write_file("packages/app/src/lib.rs", "pub fn app() {}\n");
+    repo.write_file("packages/app/src/other.rs", "pub fn other() {}\n");
+    repo.commit_all("baseline");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "```naome-prompt-envelope-v1\n{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[\"packages/app/src/lib.rs\"],\"constraints\":[],\"uncertainties\":[]}\n```\n\nPlease mention packages/app/src/other.rs in prose but use the envelope path.",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(
+        selection.required_context[0].path,
+        "packages/app/src/lib.rs"
+    );
+    assert!(!selection
+        .required_context
+        .iter()
+        .any(|item| item.path == "packages/app/src/other.rs"));
+}
+
+#[test]
+fn prompt_context_keeps_envelope_paths_for_nested_creation_targets() {
+    let repo = app_context_repo("context-prompt-envelope-new-paths");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "```naome-prompt-envelope-v1\n{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"create_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[\"packages/app/src/new/mod.rs\"],\"constraints\":[],\"uncertainties\":[]}\n```\n\nCreate the new module.",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(
+        selection.required_context[0].path,
+        "packages/app/src/new/mod.rs"
+    );
+}
+
+#[test]
+fn prompt_context_rejects_envelope_paths_outside_repository() {
+    let repo = app_context_repo("context-prompt-envelope-safe-paths");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "```naome-prompt-envelope-v1\n{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[\"../notes.md\",\"/tmp/file.rs\",\"packages/app/src/lib.rs\"],\"constraints\":[],\"uncertainties\":[]}\n```",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(
+        selection.required_context[0].path,
+        "packages/app/src/lib.rs"
+    );
+    assert!(!selection
+        .required_context
+        .iter()
+        .any(|item| item.path == "../notes.md" || item.path == "/tmp/file.rs"));
+}
+
 #[test]
 fn context_selection_reports_over_budget_when_many_paths_change() {
     let repo = context_repo("context-budget");
@@ -97,3 +182,10 @@ fn context_repo(name: &str) -> TestRepo {
     );
     repo
 }
+
+fn app_context_repo(name: &str) -> TestRepo {
+    let repo = context_repo(name);
+    repo.write_file("packages/app/src/lib.rs", "pub fn app() {}\n");
+    repo.commit_all("baseline");
+    repo
+}

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

@@ -2,13 +2,20 @@ mod intent_support;
 
 use naome_core::IntentDecision;
 
-use intent_support::{completed_state, env, idle, Repo};
+use intent_support::{completed_state, idle, prompt_env, prompt_env_with_actions, Repo};
 
 #[test]
 fn repo_state_and_envelope_resolve_task_policy() {
     let clean = Repo::clean("clean", idle());
     assert_intent(
-        &clean.intent("Please implement a small new feature."),
+        &clean.intent(&prompt_env(
+            "Please implement a small new feature.",
+            "implementation",
+            "modify_files",
+            "none",
+            "new_task",
+            "none",
+        )),
         "ready_for_task",
         "new_task",
         "create_new_task",
@@ -18,7 +25,14 @@ fn repo_state_and_envelope_resolve_task_policy() {
     let mut active_state = completed_state("HEAD", true);
     active_state["status"] = serde_json::json!("implementing");
     let active = Repo::clean("active", active_state);
-    let revision = active.intent(&env("follow up", "none", "task_revision", "none"));
+    let revision = active.intent(&prompt_env(
+        "follow up",
+        "revision",
+        "modify_files",
+        "none",
+        "task_revision",
+        "none",
+    ));
     assert_intent(
         &revision,
         "active_task_in_progress",
@@ -26,7 +40,14 @@ fn repo_state_and_envelope_resolve_task_policy() {
         "continue_current_task",
         true,
     );
-    let distinct = active.intent(&env("separate work", "none", "new_task", "none"));
+    let distinct = active.intent(&prompt_env(
+        "separate work",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
     assert_intent(
         &distinct,
         "active_task_in_progress",
@@ -36,7 +57,14 @@ fn repo_state_and_envelope_resolve_task_policy() {
     );
 
     let completed = Repo::completed("completed", true);
-    let next = completed.intent("After that, please implement a new task.");
+    let next = completed.intent(&prompt_env(
+        "After that, please implement a new task.",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
     assert_intent(
         &next,
         "completed_task_unbaselined",
@@ -46,25 +74,55 @@ fn repo_state_and_envelope_resolve_task_policy() {
     );
     assert_eq!(
         completed
-            .intent(&env("review", "review_request", "new_task", "none"))
+            .intent(&prompt_env_with_actions(
+                "review",
+                "implementation",
+                "none",
+                "review_request",
+                "none",
+                "none",
+                &["review"],
+            ))
             .policy_action,
         "review_task_diff"
     );
     assert_eq!(
         completed
-            .intent(&env("cancel", "cancel_request", "new_task", "none"))
+            .intent(&prompt_env_with_actions(
+                "cancel",
+                "implementation",
+                "none",
+                "cancel_request",
+                "none",
+                "none",
+                &["cancel"],
+            ))
             .policy_action,
         "cancel_task_changes"
     );
     assert_eq!(
         completed
-            .intent(&env("no commit", "no_commit_request", "new_task", "none"))
+            .intent(&prompt_env(
+                "no commit",
+                "implementation",
+                "none",
+                "no_commit_request",
+                "new_task",
+                "none",
+            ))
             .policy_action,
         "block_auto_baseline_due_to_no_commit"
     );
     assert_eq!(
         completed
-            .intent(&env("revise", "none", "task_revision", "none"))
+            .intent(&prompt_env(
+                "revise",
+                "revision",
+                "modify_files",
+                "none",
+                "task_revision",
+                "none",
+            ))
             .policy_action,
         "reopen_completed_task_revision"
     );
@@ -72,8 +130,14 @@ fn repo_state_and_envelope_resolve_task_policy() {
 
 #[test]
 fn workflow_and_risk_intents_are_structured_not_language_keywords() {
-    let status =
-        Repo::clean("status", idle()).intent(&env("anything", "status_question", "none", "none"));
+    let status = Repo::clean("status", idle()).intent(&prompt_env(
+        "anything",
+        "status",
+        "none",
+        "status_question",
+        "none",
+        "none",
+    ));
     assert_intent(
         &status,
         "ready_for_task",
@@ -84,7 +148,14 @@ fn workflow_and_risk_intents_are_structured_not_language_keywords() {
 
     let dirty = Repo::clean("dirty", idle());
     dirty.write("README.md", "# Manual edit\n");
-    let commit = dirty.intent(&env("okay commit it", "commit_request", "none", "none"));
+    let commit = dirty.intent(&prompt_env(
+        "okay commit it",
+        "implementation",
+        "commit",
+        "commit_request",
+        "none",
+        "none",
+    ));
     assert_intent(
         &commit,
         "dirty_unowned_diff",
@@ -97,15 +168,17 @@ fn workflow_and_risk_intents_are_structured_not_language_keywords() {
     assert_intent(
         &deprecated,
         "dirty_unowned_diff",
-        "ambiguous",
-        "block_unowned_diff",
-        false,
+        "prompt_normalization_required",
+        "normalize_prompt_first",
+        true,
     );
 
-    let risky = Repo::clean("risky", idle()).intent(&env(
+    let risky = Repo::clean("risky", idle()).intent(&prompt_env(
         "include this API key",
+        "implementation",
+        "commit",
         "commit_request",
-        "new_task",
+        "none",
         "credential_context",
     ));
     assert_eq!(risky.prompt_intent, "unsafe");
@@ -116,7 +189,14 @@ fn workflow_and_risk_intents_are_structured_not_language_keywords() {
 #[test]
 fn invalid_completed_task_proof_blocks_new_task_baseline() {
     let repo = Repo::completed("invalid", false);
-    let intent = repo.intent("After that, please implement a new task.");
+    let intent = repo.intent(&prompt_env(
+        "After that, please implement a new task.",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
     assert_eq!(intent.policy_action, "block_unsafe_intent");
     assert!(intent
         .risk_codes

package/crates/naome-core/tests/intent_support/mod.rs

@@ -11,12 +11,50 @@ use serde_json::{json, Value};
 
 static REPO_COUNTER: AtomicU64 = AtomicU64::new(0);
 
-pub fn env(prompt: &str, workflow: &str, task: &str, risk: &str) -> String {
+pub fn legacy_env(prompt: &str, workflow: &str, task: &str, risk: &str) -> String {
     format!(
         "```naome-intent-v2\n{{\"schema\":\"naome.intent.v2\",\"workflowAction\":\"{workflow}\",\"taskIntent\":\"{task}\",\"risk\":\"{risk}\"}}\n```\n\n{prompt}"
     )
 }
 
+pub fn prompt_env(
+    prompt: &str,
+    request_kind: &str,
+    mutation_intent: &str,
+    workflow: &str,
+    task: &str,
+    risk: &str,
+) -> String {
+    prompt_env_with_actions(
+        prompt,
+        request_kind,
+        mutation_intent,
+        workflow,
+        task,
+        risk,
+        &[],
+    )
+}
+
+pub fn prompt_env_with_actions(
+    prompt: &str,
+    request_kind: &str,
+    mutation_intent: &str,
+    workflow: &str,
+    task: &str,
+    risk: &str,
+    actions: &[&str],
+) -> String {
+    let requested_actions = actions
+        .iter()
+        .map(|action| format!("\"{action}\""))
+        .collect::<Vec<_>>()
+        .join(",");
+    format!(
+        "```naome-prompt-envelope-v1\n{{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"{request_kind}\",\"mutationIntent\":\"{mutation_intent}\",\"workflowAction\":\"{workflow}\",\"taskIntent\":\"{task}\",\"risk\":\"{risk}\",\"requestedActions\":[{requested_actions}],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}}\n```\n\n{prompt}"
+    )
+}
+
 pub fn idle() -> Value {
     json!({ "status": "idle", "activeTask": null })
 }