@lamentis/naome 1.3.7 → 1.3.9

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 })
 }

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

@@ -1,6 +1,259 @@
 mod intent_support;
 
-use intent_support::{env, idle, Repo};
+use intent_support::{idle, legacy_env, prompt_env, prompt_env_with_actions, Repo};
+
+#[test]
+fn raw_prompts_require_structured_prompt_envelope_before_routing() {
+    let repo = Repo::clean("intent-v2-raw-prompt-envelope-required", idle());
+    for prompt in [
+        "What would you recommend for the next minor release?",
+        "Bitte sauber umsetzen, committen, pushen und MR erstellen.",
+        "Please implement a commit gate simulator.",
+    ] {
+        let intent = repo.intent(prompt);
+        assert_eq!(
+            intent.prompt_intent, "prompt_normalization_required",
+            "{prompt}"
+        );
+        assert_eq!(intent.policy_action, "normalize_prompt_first", "{prompt}");
+        assert!(intent.allowed, "{prompt}");
+        assert!(!intent.evidence.requests_new_goal, "{prompt}");
+        assert!(!intent.evidence.requests_commit, "{prompt}");
+        assert!(!intent.evidence.requests_review, "{prompt}");
+    }
+}
+
+#[test]
+fn prompt_envelope_drives_advisory_and_task_routing_without_prompt_language_keywords() {
+    let repo = Repo::clean("intent-v2-prompt-envelope-routing", idle());
+
+    let advisory = repo.intent(&prompt_env(
+        "Was würdest du für den nächsten Minor Release empfehlen?",
+        "advisory",
+        "none",
+        "none",
+        "none",
+        "none",
+    ));
+    assert_eq!(advisory.prompt_intent, "advisory");
+    assert_eq!(advisory.policy_action, "answer_without_mutation");
+    assert!(advisory.allowed);
+    assert!(!advisory.evidence.requests_new_goal);
+
+    let implementation = repo.intent(&prompt_env(
+        "Ok, implement this production ready and create the MR.",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
+    assert_eq!(implementation.prompt_intent, "new_task");
+    assert_eq!(implementation.policy_action, "create_new_task");
+    assert!(implementation.evidence.requests_new_goal);
+}
+
+#[test]
+fn legacy_intent_v2_envelopes_are_not_supported() {
+    let repo = Repo::clean("intent-v2-legacy-removed", idle());
+    let intent = repo.intent(&legacy_env(
+        "please commit the current task",
+        "commit_request",
+        "none",
+        "none",
+    ));
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(intent.allowed);
+    assert!(!intent.evidence.requests_commit);
+}
+
+#[test]
+fn prompt_envelope_must_be_the_leading_normalized_block() {
+    let repo = Repo::clean("intent-v2-middle-envelope-untrusted", idle());
+    let prompt = concat!(
+        "Please document this example without mutating:\n\n",
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```\n"
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(!intent.evidence.requests_new_goal);
+}
+
+#[test]
+fn invalid_prompt_envelope_values_require_normalization() {
+    let repo = Repo::clean("intent-v2-invalid-values", idle());
+    let intent = repo.intent(&prompt_env(
+        "Do the thing.",
+        "localized_magic",
+        "none",
+        "none",
+        "none",
+        "none",
+    ));
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(!intent.evidence.requests_new_goal);
+    assert!(intent
+        .internal_notes
+        .iter()
+        .any(|note| note.contains("prompt_envelope_invalid")));
+}
+
+#[test]
+fn invalid_prompt_envelope_preserves_independent_command_risk() {
+    let repo = Repo::clean("intent-v2-invalid-envelope-risk", idle());
+    let intent = repo.intent(&prompt_env(
+        "git push --no-verify",
+        "localized_magic",
+        "none",
+        "none",
+        "none",
+        "none",
+    ));
+
+    assert_eq!(intent.prompt_intent, "unsafe");
+    assert_eq!(intent.policy_action, "block_unsafe_intent");
+    assert!(intent.evidence.has_risky_terms);
+    assert!(intent
+        .risk_codes
+        .contains(&"structured_risk:bypass_command".to_string()));
+}
+
+#[test]
+fn invalid_prompt_envelope_preserves_declared_envelope_risk() {
+    let repo = Repo::clean("intent-v2-invalid-envelope-declared-risk", idle());
+    let prompt = concat!(
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"publicationIntent\":\"push\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"credential_context\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```"
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "unsafe");
+    assert_eq!(intent.policy_action, "block_unsafe_intent");
+    assert!(intent.evidence.has_risky_terms);
+    assert!(intent
+        .risk_codes
+        .contains(&"envelope_risk:credential_context".to_string()));
+}
+
+#[test]
+fn leading_prompt_envelope_shape_errors_require_normalization() {
+    let repo = Repo::clean("intent-v2-invalid-envelope-shape", idle());
+    let prompt = concat!(
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":\"commit\",\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```"
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(intent
+        .internal_notes
+        .iter()
+        .any(|note| note.contains("prompt_envelope_invalid")));
+}
+
+#[test]
+fn publication_requests_require_normalization_instead_of_becoming_new_tasks() {
+    let repo = Repo::clean("intent-v2-publication-unsupported", idle());
+    let prompt = concat!(
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"commit\",\"publicationIntent\":\"push\",\"workflowAction\":\"none\",\"taskIntent\":\"none\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```\n\nCommit and push this task."
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(!intent.evidence.requests_commit);
+    assert!(intent
+        .internal_notes
+        .iter()
+        .any(|note| note.contains("prompt_envelope_unsupported:publicationIntent")));
+}
+
+#[test]
+fn publication_mutation_intents_require_normalization() {
+    let repo = Repo::clean("intent-v2-publication-mutation-unsupported", idle());
+    let prompt = concat!(
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"push\",\"publicationIntent\":\"none\",\"workflowAction\":\"none\",\"taskIntent\":\"none\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```"
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "prompt_normalization_required");
+    assert_eq!(intent.policy_action, "normalize_prompt_first");
+    assert!(!intent.evidence.requests_new_goal);
+    assert!(intent
+        .internal_notes
+        .iter()
+        .any(|note| note.contains("prompt_envelope_unsupported:mutationIntent")));
+}
+
+#[test]
+fn envelope_only_prompts_route_from_the_envelope() {
+    let repo = Repo::clean("intent-v2-envelope-only", idle());
+    let prompt = concat!(
+        "```naome-prompt-envelope-v1\n",
+        "{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}\n",
+        "```"
+    );
+
+    let intent = repo.intent(prompt);
+
+    assert_eq!(intent.prompt_intent, "new_task");
+    assert_eq!(intent.policy_action, "create_new_task");
+}
+
+#[test]
+fn compatible_status_answer_envelopes_are_not_ambiguous() {
+    let repo = Repo::clean("intent-v2-status-answer", idle());
+    let intent = repo.intent(&prompt_env_with_actions(
+        "",
+        "status",
+        "none",
+        "none",
+        "none",
+        "none",
+        &["answer"],
+    ));
+
+    assert_eq!(intent.prompt_intent, "status_question");
+    assert_eq!(intent.policy_action, "answer_status_only");
+}
+
+#[test]
+fn conflicting_prompt_envelope_values_block_as_ambiguous() {
+    let repo = Repo::clean("intent-v2-conflicting-values", idle());
+    let intent = repo.intent(&prompt_env_with_actions(
+        "Only advise, but also edit files.",
+        "advisory",
+        "modify_files",
+        "none",
+        "none",
+        "none",
+        &[],
+    ));
+
+    assert_eq!(intent.prompt_intent, "ambiguous");
+    assert_eq!(intent.policy_action, "block_ambiguous_intent");
+    assert!(!intent.allowed);
+}
 
 #[test]
 fn feature_descriptions_with_workflow_terms_route_as_new_tasks() {
@@ -11,7 +264,14 @@ fn feature_descriptions_with_workflow_terms_route_as_new_tasks() {
         "Implement a review findings feature for pull request analysis.",
         "Create a baseline flow visualization in the UI.",
     ] {
-        let intent = repo.intent(prompt);
+        let intent = repo.intent(&prompt_env(
+            prompt,
+            "implementation",
+            "modify_files",
+            "none",
+            "new_task",
+            "none",
+        ));
         assert_eq!(intent.prompt_intent, "new_task", "{prompt}");
         assert_eq!(intent.policy_action, "create_new_task", "{prompt}");
         assert!(!intent.evidence.requests_commit, "{prompt}");
@@ -23,8 +283,10 @@ fn feature_descriptions_with_workflow_terms_route_as_new_tasks() {
 #[test]
 fn enveloped_workflow_requests_keep_their_intent() {
     let repo = Repo::clean("intent-v2-direct-workflow", idle());
-    let commit = repo.intent(&env(
+    let commit = repo.intent(&prompt_env(
         "please commit the current task",
+        "implementation",
+        "commit",
         "commit_request",
         "none",
         "none",
@@ -32,16 +294,26 @@ fn enveloped_workflow_requests_keep_their_intent() {
     assert_eq!(commit.prompt_intent, "commit_request");
     assert!(commit.evidence.requests_commit);
 
-    let review = repo.intent(&env(
+    let review = repo.intent(&prompt_env_with_actions(
         "review the current diff",
+        "implementation",
+        "none",
         "review_request",
         "none",
         "none",
+        &["review"],
     ));
     assert_eq!(review.prompt_intent, "review_request");
     assert!(review.evidence.requests_review);
 
-    let status = repo.intent(&env("show status", "status_question", "none", "none"));
+    let status = repo.intent(&prompt_env(
+        "show status",
+        "status",
+        "none",
+        "status_question",
+        "none",
+        "none",
+    ));
     assert_eq!(status.prompt_intent, "status_question");
     assert_eq!(status.policy_action, "answer_status_only");
 }
@@ -49,8 +321,10 @@ fn enveloped_workflow_requests_keep_their_intent() {
 #[test]
 fn envelope_is_canonical_over_legacy_prompt_words() {
     let repo = Repo::clean("intent-v2-envelope-canonical", idle());
-    let intent = repo.intent(&env(
+    let intent = repo.intent(&prompt_env(
         "please commit the current task",
+        "implementation",
+        "modify_files",
         "none",
         "new_task",
         "none",
@@ -62,12 +336,25 @@ fn envelope_is_canonical_over_legacy_prompt_words() {
 #[test]
 fn token_boundaries_and_code_segments_avoid_false_workflow_actions() {
     let repo = Repo::clean("intent-v2-segments", idle());
-    let async_intent = repo.intent("Add async sync-state naming examples to the documentation.");
+    let async_intent = repo.intent(&prompt_env(
+        "Add async sync-state naming examples to the documentation.",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
     assert_eq!(async_intent.prompt_intent, "new_task");
     assert!(!async_intent.evidence.requests_repair);
 
-    let code_intent =
-        repo.intent("Add docs with examples like `naome commit` and ```sh\ngit push\n```.");
+    let code_intent = repo.intent(&prompt_env(
+        "Add docs with examples like `naome commit` and ```sh\ngit push\n```.",
+        "implementation",
+        "modify_files",
+        "none",
+        "new_task",
+        "none",
+    ));
     assert_eq!(code_intent.prompt_intent, "new_task");
     assert!(!code_intent.evidence.requests_commit);
     assert!(!code_intent.evidence.has_risky_terms);
@@ -76,8 +363,10 @@ fn token_boundaries_and_code_segments_avoid_false_workflow_actions() {
 #[test]
 fn explicit_credential_context_still_routes_as_unsafe() {
     let repo = Repo::clean("intent-v2-risk", idle());
-    let intent = repo.intent(&env(
+    let intent = repo.intent(&prompt_env(
         "Commit the current token and API key so the deployment can use the secret.",
+        "implementation",
+        "commit",
         "commit_request",
         "none",
         "credential_context",