@lamentis/naome 1.3.6 → 1.3.8

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

@@ -10,6 +10,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::paths;
 
 pub use model::{TaskLedgerProjection, TaskLedgerStatus};
 
@@ -21,10 +22,21 @@ pub fn migrate_task_state_to_ledger(
 }
 
 pub fn read_task_state_projection(root: &Path) -> Result<Option<Value>, NaomeError> {
-    if let Some(projection) = render::render_from_ledger(root)? {
+    let legacy = read::read_legacy_task_state(root)?;
+    if legacy.is_some() && local_runtime_ledger_is_ignored(root) {
+        return Ok(legacy);
+    }
+    let rendered = render::render_from_ledger(root)?;
+    if let (Some(projection), Some(legacy_state)) = (&rendered, &legacy) {
+        if legacy_completed_projection_covers_local_runtime_ledger(&projection.state, legacy_state)
+        {
+            return Ok(Some(legacy_state.clone()));
+        }
+    }
+    if let Some(projection) = rendered {
         return Ok(Some(projection.state));
     }
-    read::read_legacy_task_state(root)
+    Ok(legacy)
 }
 
 pub fn render_task_state_from_ledger(
@@ -46,3 +58,39 @@ pub(crate) fn validate_task_state_projection_is_current(
 ) -> Result<(), NaomeError> {
     write::validate_task_state_projection_is_current(root, errors)
 }
+
+pub(crate) fn legacy_completed_projection_covers_local_runtime_ledger(
+    rendered: &Value,
+    legacy: &Value,
+) -> bool {
+    if state_status(legacy) != Some("complete") || state_status(rendered) != Some("complete") {
+        return false;
+    }
+
+    let Some(legacy_task) = legacy.get("activeTask") else {
+        return false;
+    };
+    let Some(rendered_task) = rendered.get("activeTask") else {
+        return false;
+    };
+
+    has_compact_proof_evidence(legacy_task) && !has_compact_proof_evidence(rendered_task)
+}
+
+pub(crate) fn local_runtime_ledger_is_ignored(root: &Path) -> bool {
+    let ignored_patterns = paths::naomeignore_patterns(root);
+    paths::matches_any(".naome/tasks/active.json", &ignored_patterns)
+}
+
+fn state_status(state: &Value) -> Option<&str> {
+    state.get("status").and_then(Value::as_str)
+}
+
+fn has_compact_proof_evidence(active_task: &Value) -> bool {
+    ["proofResults", "proofBatches"].iter().any(|field| {
+        active_task
+            .get(*field)
+            .and_then(Value::as_array)
+            .is_some_and(|entries| !entries.is_empty())
+    })
+}

package/crates/naome-core/src/task_state/util.rs

@@ -43,18 +43,7 @@ pub(super) fn require_string_array(
     field_name: &str,
     errors: &mut Vec<String>,
 ) {
-    let Some(values) = value.and_then(Value::as_array) else {
-        errors.push(format!("{field_name} must be a non-empty string array."));
-        return;
-    };
-
-    if values.is_empty()
-        || values
-            .iter()
-            .any(|entry| !entry.as_str().is_some_and(is_non_empty_string))
-    {
-        errors.push(format!("{field_name} must be a non-empty string array."));
-    }
+    require_string_array_shape(value, field_name, errors, false);
 }
 
 pub(super) fn require_string_array_allow_empty(
@@ -62,16 +51,31 @@ pub(super) fn require_string_array_allow_empty(
     field_name: &str,
     errors: &mut Vec<String>,
 ) {
+    require_string_array_shape(value, field_name, errors, true);
+}
+
+fn require_string_array_shape(
+    value: Option<&Value>,
+    field_name: &str,
+    errors: &mut Vec<String>,
+    allow_empty: bool,
+) {
+    let label = if allow_empty {
+        "string array"
+    } else {
+        "non-empty string array"
+    };
     let Some(values) = value.and_then(Value::as_array) else {
-        errors.push(format!("{field_name} must be a string array."));
+        errors.push(format!("{field_name} must be a {label}."));
         return;
     };
 
-    if values
+    let invalid_empty = !allow_empty && values.is_empty();
+    let invalid_entry = values
         .iter()
-        .any(|entry| !entry.as_str().is_some_and(is_non_empty_string))
-    {
-        errors.push(format!("{field_name} must be a string array."));
+        .any(|entry| !entry.as_str().is_some_and(is_non_empty_string));
+    if invalid_empty || invalid_entry {
+        errors.push(format!("{field_name} must be a {label}."));
     }
 }
 

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/decision.rs

@@ -7,7 +7,7 @@ use serde_json::json;
 
 mod repo_support;
 
-use repo_support::TestRepo;
+use repo_support::{minimal_task_state, TestRepo};
 
 static ENV_LOCK: Mutex<()> = Mutex::new(());
 
@@ -193,13 +193,5 @@ fn online_checks_use_explicit_node_binary_from_environment() {
 }
 
 fn completed_without_proof_state() -> serde_json::Value {
-    json!({
-        "status": "complete",
-        "activeTask": {
-            "id": "readme-task",
-            "allowedPaths": ["README.md"],
-            "requiredCheckIds": ["diff-check"],
-            "proofResults": []
-        }
-    })
+    minimal_task_state("complete", "readme-task", "README.md", "diff-check")
 }

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

@@ -21,17 +21,14 @@ fn classifies_naome_information_by_restore_source() {
     assert_eq!(local.restore_policy, "recreate_on_demand");
 
     let proof = classify_information_path(".naome/tasks/readme-task/proofs/diff-check.json");
-    assert_eq!(proof.class, "run_evidence");
-    assert_eq!(proof.commit_policy, "prefer_compact_release_evidence");
-    assert_eq!(
-        proof.restore_policy,
-        "restore_from_ci_or_task_ledger_when_audited"
-    );
+    assert_eq!(proof.class, "local_runtime_state");
+    assert_eq!(proof.commit_policy, "never_commit");
+    assert_eq!(proof.restore_policy, "recreate_on_demand");
 
     let task = classify_information_path(".naome/tasks/readme-task/task.json");
-    assert_eq!(task.class, "durable_task_ledger");
-    assert_eq!(task.commit_policy, "commit");
-    assert_eq!(task.restore_policy, "restore_from_repository");
+    assert_eq!(task.class, "local_runtime_state");
+    assert_eq!(task.commit_policy, "never_commit");
+    assert_eq!(task.restore_policy, "recreate_on_demand");
 }
 
 #[test]
@@ -54,5 +51,5 @@ fn reports_information_architecture_contract_for_agents() {
     assert!(report
         .rules
         .iter()
-        .any(|rule| rule.path_pattern == ".naome/tasks/*/proofs/*.json"));
+        .any(|rule| rule.path_pattern == ".naome/tasks/**" && rule.class == "local_runtime_state"));
 }

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

@@ -30,6 +30,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .contains(&".naome/task-journal.jsonl"));
     assert!(plan.git_exclude_entries.contains(&".naome/archive/"));
     assert!(plan.git_exclude_entries.contains(&".naome/cache/"));
+    assert!(plan.git_exclude_entries.contains(&".naome/tasks/"));
     assert!(plan.git_exclude_entries.contains(&".naome/bin/naome-rust*"));
     assert!(plan
         .git_exclude_entries
@@ -39,6 +40,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .contains(&".naome/bin/check-harness-health.js"));
     assert!(plan.git_untrack_paths.contains(&".naome/archive"));
     assert!(plan.git_untrack_paths.contains(&".naome/cache"));
+    assert!(plan.git_untrack_paths.contains(&".naome/tasks"));
     assert!(plan.git_untrack_paths.contains(&".naome/bin/naome-rust"));
     assert!(plan
         .git_untrack_paths

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