@lamentis/naome 1.3.6 → 1.3.8

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

@@ -1,19 +1,25 @@
 use serde::Deserialize;
+use serde_json::Value;
 
 use super::model::{IntentCandidate, IntentKind, RiskContext};
 
-const ENVELOPE_FENCE: &str = "```naome-intent-v2";
+const PROMPT_ENVELOPE_FENCE: &str = "```naome-prompt-envelope-v1";
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct RoutingEnvelope {
     pub candidates: Vec<IntentCandidate>,
     pub risk: RiskContext,
+    pub validation_errors: Vec<String>,
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct EnvelopeInput {
     schema: Option<String>,
+    request_kind: Option<String>,
+    mutation_intent: Option<String>,
+    publication_intent: Option<String>,
+    requested_actions: Option<Vec<String>>,
     workflow_action: Option<String>,
     task_intent: Option<String>,
     risk: Option<String>,
@@ -21,32 +27,84 @@ struct EnvelopeInput {
 }
 
 pub(crate) fn parse_routing_envelope(prompt: &str) -> Option<RoutingEnvelope> {
-    let json = envelope_json(prompt)?;
-    let input = serde_json::from_str::<EnvelopeInput>(json).ok()?;
-    if !matches!(input.schema.as_deref(), Some("naome.intent.v2")) {
-        return None;
-    }
+    let json = prompt_envelope_json(prompt)?;
+    let raw = match serde_json::from_str::<Value>(json) {
+        Ok(raw) => raw,
+        Err(_) => {
+            return Some(invalid_envelope(
+                vec!["prompt_envelope_invalid:json".to_string()],
+                RiskContext {
+                    has_risky_terms: false,
+                    risk_codes: Vec::new(),
+                },
+            ));
+        }
+    };
+    let input = match serde_json::from_value::<EnvelopeInput>(raw.clone()) {
+        Ok(input) => input,
+        Err(_) => {
+            let mut validation_errors = vec!["prompt_envelope_invalid:shape".to_string()];
+            let risk_codes = envelope_risk_codes(
+                raw.get("risk").and_then(Value::as_str),
+                raw_string_array(&raw, "riskCodes"),
+                &mut validation_errors,
+            );
+            return Some(invalid_envelope(
+                validation_errors,
+                RiskContext {
+                    has_risky_terms: !risk_codes.is_empty(),
+                    risk_codes,
+                },
+            ));
+        }
+    };
 
     let mut candidates = Vec::new();
-    if let Some(kind) = workflow_action(input.workflow_action.as_deref()) {
+    let mut validation_errors = Vec::new();
+    if input.schema.as_deref() != Some("naome.prompt-envelope.v1") {
+        validation_errors.push("prompt_envelope_invalid:schema".to_string());
+    }
+    if let Some(kind) = request_kind(input.request_kind.as_deref(), &mut validation_errors) {
+        candidates.push(candidate(kind, "envelope.requestKind"));
+    }
+    if let Some(kind) = mutation_intent(input.mutation_intent.as_deref(), &mut validation_errors) {
+        candidates.push(candidate(kind, "envelope.mutationIntent"));
+    }
+    if let Some(kind) =
+        publication_intent(input.publication_intent.as_deref(), &mut validation_errors)
+    {
+        candidates.push(candidate(kind, "envelope.publicationIntent"));
+    }
+    for kind in requested_actions(input.requested_actions, &mut validation_errors) {
+        candidates.push(candidate(kind, "envelope.requestedActions"));
+    }
+    if let Some(kind) = workflow_action(input.workflow_action.as_deref(), &mut validation_errors) {
         candidates.push(candidate(kind, "envelope.workflowAction"));
     }
-    if let Some(kind) = task_intent(input.task_intent.as_deref()) {
+    if let Some(kind) = task_intent(input.task_intent.as_deref(), &mut validation_errors) {
         candidates.push(candidate(kind, "envelope.taskIntent"));
     }
 
-    let risk_codes = envelope_risk_codes(input.risk.as_deref(), input.risk_codes);
+    let risk_codes = envelope_risk_codes(
+        input.risk.as_deref(),
+        input.risk_codes,
+        &mut validation_errors,
+    );
     let risk = RiskContext {
         has_risky_terms: !risk_codes.is_empty(),
         risk_codes,
     };
 
-    Some(RoutingEnvelope { candidates, risk })
+    Some(RoutingEnvelope {
+        candidates,
+        risk,
+        validation_errors,
+    })
 }
 
-fn envelope_json(prompt: &str) -> Option<&str> {
-    let start = prompt.find(ENVELOPE_FENCE)?;
-    let after_open = &prompt[start + ENVELOPE_FENCE.len()..];
+pub(crate) fn prompt_envelope_json(prompt: &str) -> Option<&str> {
+    let fence = PROMPT_ENVELOPE_FENCE;
+    let after_open = prompt.strip_prefix(fence)?;
     let after_line = after_open
         .strip_prefix('\n')
         .or_else(|| after_open.strip_prefix("\r\n"))?;
@@ -54,7 +112,69 @@ fn envelope_json(prompt: &str) -> Option<&str> {
     Some(after_line[..end].trim())
 }
 
-fn workflow_action(value: Option<&str>) -> Option<IntentKind> {
+fn request_kind(value: Option<&str>, errors: &mut Vec<String>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "advisory" | "planning" | "planning_only" | "question" | "recommendation" => {
+            Some(IntentKind::Advisory)
+        }
+        "implementation" | "execution" | "task" | "feature" | "fix" => Some(IntentKind::NewTask),
+        "revision" | "correction" => Some(IntentKind::TaskRevision),
+        "status" => Some(IntentKind::StatusQuestion),
+        _ => invalid_value("requestKind", errors),
+    }
+}
+
+fn mutation_intent(value: Option<&str>, errors: &mut Vec<String>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "modify_files" | "edit_files" | "create_files" | "delete_files" => {
+            Some(IntentKind::NewTask)
+        }
+        "commit" | "baseline" => Some(IntentKind::CommitRequest),
+        "publish" | "push" | "merge_request" | "pull_request" => {
+            unsupported_value("mutationIntent", errors)
+        }
+        _ => invalid_value("mutationIntent", errors),
+    }
+}
+
+fn publication_intent(value: Option<&str>, errors: &mut Vec<String>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "commit" => Some(IntentKind::CommitRequest),
+        "push" | "merge_request" | "pull_request" | "mr" | "pr" => {
+            unsupported_value("publicationIntent", errors)
+        }
+        _ => invalid_value("publicationIntent", errors),
+    }
+}
+
+fn requested_actions(values: Option<Vec<String>>, errors: &mut Vec<String>) -> Vec<IntentKind> {
+    values
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|value| action_token(&value, errors))
+        .collect()
+}
+
+fn action_token(value: &str, errors: &mut Vec<String>) -> Option<IntentKind> {
+    match normalized_value(Some(value))?.as_str() {
+        "answer" | "advise" | "plan" | "recommend" => Some(IntentKind::Advisory),
+        "implement" | "edit" | "modify" | "create_task" => Some(IntentKind::NewTask),
+        "revise" | "correct" => Some(IntentKind::TaskRevision),
+        "status" => Some(IntentKind::StatusQuestion),
+        "review" => Some(IntentKind::ReviewRequest),
+        "repair" => Some(IntentKind::RepairRequest),
+        "commit" | "baseline" => Some(IntentKind::CommitRequest),
+        "no_commit" => Some(IntentKind::NoCommitRequest),
+        "cancel" => Some(IntentKind::CancelRequest),
+        "complete" => Some(IntentKind::TaskCompletion),
+        _ => invalid_value("requestedActions", errors),
+    }
+}
+
+fn workflow_action(value: Option<&str>, errors: &mut Vec<String>) -> Option<IntentKind> {
     match normalized_value(value)?.as_str() {
         "none" | "unknown" => None,
         "commit_request" => Some(IntentKind::CommitRequest),
@@ -64,20 +184,24 @@ fn workflow_action(value: Option<&str>) -> Option<IntentKind> {
         "task_completion" => Some(IntentKind::TaskCompletion),
         "status_question" => Some(IntentKind::StatusQuestion),
         "no_commit_request" => Some(IntentKind::NoCommitRequest),
-        _ => None,
+        _ => invalid_value("workflowAction", errors),
     }
 }
 
-fn task_intent(value: Option<&str>) -> Option<IntentKind> {
+fn task_intent(value: Option<&str>, errors: &mut Vec<String>) -> Option<IntentKind> {
     match normalized_value(value)?.as_str() {
         "none" | "unknown" => None,
         "new_task" => Some(IntentKind::NewTask),
         "task_revision" => Some(IntentKind::TaskRevision),
-        _ => None,
+        _ => invalid_value("taskIntent", errors),
     }
 }
 
-fn envelope_risk_codes(risk: Option<&str>, risk_codes: Option<Vec<String>>) -> Vec<String> {
+fn envelope_risk_codes(
+    risk: Option<&str>,
+    risk_codes: Option<Vec<String>>,
+    errors: &mut Vec<String>,
+) -> Vec<String> {
     let mut codes = risk_codes.unwrap_or_default();
     match normalized_value(risk).as_deref() {
         Some("none") | Some("unknown") | None => {}
@@ -86,19 +210,49 @@ fn envelope_risk_codes(risk: Option<&str>, risk_codes: Option<Vec<String>>) -> V
             codes.push("envelope_risk:credential_context".to_string());
         }
         Some("bypass_context") => codes.push("envelope_risk:bypass_context".to_string()),
-        Some(other) => codes.push(format!("envelope_risk:{other}")),
+        Some(_) => {
+            errors.push("prompt_envelope_invalid:risk".to_string());
+        }
     }
     codes.sort();
     codes.dedup();
     codes
 }
 
+fn invalid_value(field: &str, errors: &mut Vec<String>) -> Option<IntentKind> {
+    errors.push(format!("prompt_envelope_invalid:{field}"));
+    None
+}
+
+fn unsupported_value(field: &str, errors: &mut Vec<String>) -> Option<IntentKind> {
+    errors.push(format!("prompt_envelope_unsupported:{field}"));
+    None
+}
+
 fn normalized_value(value: Option<&str>) -> Option<String> {
     value
         .map(|value| value.trim().to_ascii_lowercase())
         .filter(|value| !value.is_empty())
 }
 
+fn raw_string_array(raw: &Value, field: &str) -> Option<Vec<String>> {
+    raw.get(field).and_then(Value::as_array).map(|values| {
+        values
+            .iter()
+            .filter_map(Value::as_str)
+            .map(ToString::to_string)
+            .collect()
+    })
+}
+
+fn invalid_envelope(validation_errors: Vec<String>, risk: RiskContext) -> RoutingEnvelope {
+    RoutingEnvelope {
+        candidates: Vec::new(),
+        risk,
+        validation_errors,
+    }
+}
+
 fn candidate(kind: IntentKind, evidence: &str) -> IntentCandidate {
     IntentCandidate {
         kind,

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

@@ -19,6 +19,8 @@ pub(crate) fn response_policy(
         "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.",
+        "normalize_prompt_first" => "NAOME needs a structured prompt envelope before it can route or mutate repository state.",
+        "answer_without_mutation" => "The prompt is advisory or planning-only, so NAOME will not mutate repository state.",
         "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.",

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

@@ -18,6 +18,8 @@ pub(crate) struct PromptSegment {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub(crate) enum IntentKind {
     Ambiguous,
+    PromptNormalizationRequired,
+    Advisory,
     NewTask,
     TaskRevision,
     StatusQuestion,
@@ -34,6 +36,8 @@ impl IntentKind {
     pub fn as_str(self) -> &'static str {
         match self {
             Self::Ambiguous => "ambiguous",
+            Self::PromptNormalizationRequired => "prompt_normalization_required",
+            Self::Advisory => "advisory",
             Self::NewTask => "new_task",
             Self::TaskRevision => "task_revision",
             Self::StatusQuestion => "status_question",
@@ -64,8 +68,10 @@ pub(crate) struct RiskContext {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct CanonicalIntent {
     pub is_empty: bool,
+    pub has_routing_envelope: bool,
     pub references_current_task: bool,
     pub candidates: Vec<IntentCandidate>,
     pub risk: RiskContext,
     pub has_workflow_conflict: bool,
+    pub validation_errors: Vec<String>,
 }

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

@@ -9,6 +9,7 @@ mod journal;
 mod models;
 mod paths;
 mod quality;
+mod repo_paths;
 mod repository_model;
 mod route;
 mod task_ledger;

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

@@ -1,9 +1,36 @@
+use std::fs;
+use std::path::Path;
+
+pub fn naomeignore_patterns(root: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(root.join(".naomeignore")) else {
+        return Vec::new();
+    };
+
+    let mut patterns = content
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
+        .map(normalize_ignore_pattern)
+        .collect::<Vec<_>>();
+    patterns.push(".naome/cache/**".to_string());
+    patterns
+}
+
 pub fn matches_any(path: &str, patterns: &[String]) -> bool {
     patterns
         .iter()
         .any(|pattern| matches_pattern(path, pattern))
 }
 
+fn normalize_ignore_pattern(pattern: &str) -> String {
+    let normalized = pattern.trim_start_matches("./").replace('\\', "/");
+    if normalized.ends_with('/') {
+        format!("{normalized}**")
+    } else {
+        normalized
+    }
+}
+
 fn matches_pattern(path: &str, pattern: &str) -> bool {
     let normalized_path = path.replace('\\', "/");
     let normalized_pattern = pattern.replace('\\', "/");

package/crates/naome-core/src/quality/scanner/repo_paths.rs

@@ -4,36 +4,10 @@ use std::path::Path;
 use std::process::Command;
 
 use crate::models::NaomeError;
+use crate::repo_paths::{collect_tracked_and_untracked_paths, RepoPathFallback};
 
 pub(crate) fn collect_repo_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
-    let output = Command::new("git")
-        .args([
-            "ls-files",
-            "-z",
-            "--cached",
-            "--others",
-            "--exclude-standard",
-        ])
-        .current_dir(root)
-        .output();
-    if let Ok(output) = output {
-        if output.status.success() {
-            let mut paths = output
-                .stdout
-                .split(|byte| *byte == 0)
-                .filter(|entry| !entry.is_empty())
-                .map(|entry| String::from_utf8_lossy(entry).replace('\\', "/"))
-                .collect::<Vec<_>>();
-            paths.sort();
-            paths.dedup();
-            return Ok(paths);
-        }
-    }
-
-    let mut paths = Vec::new();
-    collect_files_recursive(root, root, &mut paths)?;
-    paths.sort();
-    Ok(paths)
+    collect_tracked_and_untracked_paths(root, RepoPathFallback::Filesystem)
 }
 
 pub(super) fn added_lines_by_path(
@@ -103,25 +77,6 @@ pub(super) fn tracked_blob_hashes(root: &Path) -> Result<HashMap<String, String>
     Ok(hashes)
 }
 
-fn collect_files_recursive(
-    root: &Path,
-    dir: &Path,
-    paths: &mut Vec<String>,
-) -> Result<(), NaomeError> {
-    for entry in fs::read_dir(dir)? {
-        let entry = entry?;
-        let path = entry.path();
-        if path.is_dir() {
-            collect_files_recursive(root, &path, paths)?;
-        } else if path.is_file() {
-            if let Ok(relative) = path.strip_prefix(root) {
-                paths.push(relative.to_string_lossy().replace('\\', "/"));
-            }
-        }
-    }
-    Ok(())
-}
-
 fn untracked_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
     let output = Command::new("git")
         .args(["ls-files", "--others", "--exclude-standard", "-z"])

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

@@ -0,0 +1,76 @@
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum RepoPathFallback {
+    Empty,
+    Filesystem,
+}
+
+pub(crate) fn collect_tracked_and_untracked_paths(
+    root: &Path,
+    fallback: RepoPathFallback,
+) -> Result<Vec<String>, NaomeError> {
+    let output = Command::new("git")
+        .args([
+            "ls-files",
+            "-z",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+        ])
+        .current_dir(root)
+        .output();
+
+    if let Ok(output) = output {
+        if output.status.success() {
+            return Ok(sorted_unique_paths(
+                output
+                    .stdout
+                    .split(|byte| *byte == 0)
+                    .filter(|entry| !entry.is_empty())
+                    .map(|entry| String::from_utf8_lossy(entry).replace('\\', "/"))
+                    .collect(),
+            ));
+        }
+    }
+
+    match fallback {
+        RepoPathFallback::Empty => Ok(Vec::new()),
+        RepoPathFallback::Filesystem => collect_filesystem_paths(root),
+    }
+}
+
+fn collect_filesystem_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let mut paths = Vec::new();
+    collect_files_recursive(root, root, &mut paths)?;
+    Ok(sorted_unique_paths(paths))
+}
+
+fn collect_files_recursive(
+    root: &Path,
+    dir: &Path,
+    paths: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            collect_files_recursive(root, &path, paths)?;
+        } else if path.is_file() {
+            if let Ok(relative) = path.strip_prefix(root) {
+                paths.push(relative.to_string_lossy().replace('\\', "/"));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn sorted_unique_paths(mut paths: Vec<String>) -> Vec<String> {
+    paths.sort();
+    paths.dedup();
+    paths
+}

package/crates/naome-core/src/repository_model/path_scan.rs

@@ -1,32 +1,11 @@
 use std::collections::BTreeSet;
 use std::path::Path;
-use std::process::Command;
 
 use crate::models::NaomeError;
+use crate::repo_paths::{collect_tracked_and_untracked_paths, RepoPathFallback};
 
 pub(super) fn collect_repo_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
-    let output = Command::new("git")
-        .args([
-            "ls-files",
-            "-z",
-            "--cached",
-            "--others",
-            "--exclude-standard",
-        ])
-        .current_dir(root)
-        .output()?;
-    if !output.status.success() {
-        return Ok(Vec::new());
-    }
-    let mut paths = output
-        .stdout
-        .split(|byte| *byte == 0)
-        .filter(|entry| !entry.is_empty())
-        .map(|entry| String::from_utf8_lossy(entry).replace('\\', "/"))
-        .collect::<Vec<_>>();
-    paths.sort();
-    paths.dedup();
-    Ok(paths)
+    collect_tracked_and_untracked_paths(root, RepoPathFallback::Empty)
 }
 
 pub(super) fn evidence(paths: &[String], markers: &[&str]) -> Vec<String> {

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/src/task_ledger/write.rs

@@ -21,12 +21,18 @@ pub(super) fn validate_task_state_projection_is_current(
     if !read::active_path(root).is_file() {
         return Ok(());
     }
+    if super::local_runtime_ledger_is_ignored(root) {
+        return Ok(());
+    }
     let Some(legacy) = read::read_legacy_task_state(root)? else {
         return Ok(());
     };
     let Some(rendered) = render::render_from_ledger(root)? else {
         return Ok(());
     };
+    if super::legacy_completed_projection_covers_local_runtime_ledger(&rendered.state, &legacy) {
+        return Ok(());
+    }
     if legacy != rendered.state {
         errors.push(".naome/task-state.json is stale relative to .naome/tasks/. Run node .naome/bin/naome.js task render-state --write --json before completion or commit.".to_string());
     }