@lamentis/naome 1.3.6 → 1.3.8

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.3.6"
+version = "1.3.8"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.3.6"
+version = "1.3.8"
 dependencies = [
  "serde",
  "serde_json",

package/README.md

@@ -41,6 +41,11 @@ For agent-driven work, route the user's request through the harness:
 naome route --prompt-file /path/to/prompt.txt --execute --json
 ```
 
+Prompt files should start with a fenced `naome-prompt-envelope-v1` JSON
+envelope that normalizes the raw user text into canonical routing fields. A raw
+natural-language prompt routes to a non-mutating normalization decision instead
+of becoming a task by keyword inference.
+
 ## Why NAOME?
 
 - Keeps agents inside explicit task scope.
@@ -84,8 +89,9 @@ naome commit -m "type(scope): summary"
 
 `naome sync` installs or repairs the local harness files. It does not run a
 hidden full-repository quality scan. It also migrates any active legacy
-task-state into the task ledger automatically. If quality policy is newly
-seeded, run `naome quality init --baseline` deliberately; use `--deep` or
+task-state into the local task ledger automatically and untracks local
+`.naome/tasks/` runtime folders from Git. If quality policy is newly seeded,
+run `naome quality init --baseline` deliberately; use `--deep` or
 `--deep-baseline` only when you want expensive repository-wide checks.
 
 ## Repository Docs
@@ -111,7 +117,7 @@ The main local policy files are:
   quality policy.
 - `.naome/repository-structure.json` for path role, module, and directory
   structure policy.
-- `.naome/task-state.json` for active task state and proof.
+- `.naome/task-state.json` for the compact committed active task projection.
 
 Product defaults stay generic. Repository-specific policy belongs in the local
 `.naome/` config files.

package/crates/naome-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-cli"
-version = "1.3.6"
+version = "1.3.8"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.3.6"
+version = "1.3.8"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -1,5 +1,8 @@
-use std::path::Path;
+use std::path::{Component, Path};
 
+use serde::Deserialize;
+
+use crate::intent::prompt_envelope_json;
 use crate::{git, models::NaomeError};
 
 use super::helpers::{capsule_for_paths, context_item, is_source_path, normalize_paths};
@@ -7,6 +10,13 @@ use super::types::{ContextBudgetLedger, ContextItem, ContextSelection};
 
 const MAX_CONTEXT_FILES: usize = 12;
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PromptEnvelopeContext {
+    schema: Option<String>,
+    referenced_paths: Option<Vec<String>>,
+}
+
 pub fn select_context_for_changed_paths(root: &Path) -> Result<ContextSelection, NaomeError> {
     let paths = git::changed_paths(root)?;
     Ok(selection_for_paths(root, "changed", paths))
@@ -19,7 +29,9 @@ pub fn select_context_for_prompt(
     Ok(selection_for_paths(
         root,
         "prompt",
-        mentioned_paths(prompt.as_ref()),
+        envelope_referenced_paths(prompt.as_ref())
+            .filter(|paths| !paths.is_empty())
+            .unwrap_or_else(|| mentioned_paths(root, prompt.as_ref())),
     ))
 }
 
@@ -119,7 +131,7 @@ fn forbidden_context() -> Vec<String> {
     .collect()
 }
 
-fn mentioned_paths(prompt: &str) -> Vec<String> {
+fn mentioned_paths(root: &Path, prompt: &str) -> Vec<String> {
     prompt
         .split_whitespace()
         .map(|token| {
@@ -127,8 +139,50 @@ fn mentioned_paths(prompt: &str) -> Vec<String> {
                 matches!(ch, '"' | '\'' | '`' | ',' | ';' | ':' | ')' | '(')
             })
         })
-        .filter(|token| token.contains('/') || is_source_path(token) || token.ends_with(".md"))
         .filter(|token| !token.starts_with('-') && !token.starts_with("http"))
         .map(|token| token.trim_start_matches("./").replace('\\', "/"))
+        .filter(|path| path_looks_contextual(path))
+        .filter(|path| path_exists_or_has_repo_parent(root, path))
         .collect()
 }
+
+fn envelope_referenced_paths(prompt: &str) -> Option<Vec<String>> {
+    let input =
+        serde_json::from_str::<PromptEnvelopeContext>(prompt_envelope_json(prompt)?).ok()?;
+    if input.schema.as_deref() != Some("naome.prompt-envelope.v1") {
+        return None;
+    }
+    Some(
+        input
+            .referenced_paths
+            .unwrap_or_default()
+            .into_iter()
+            .map(|path| path.trim_start_matches("./").replace('\\', "/"))
+            .filter(|path| is_repo_relative_path(path))
+            .filter(|path| path_looks_contextual(path))
+            .collect(),
+    )
+}
+
+fn is_repo_relative_path(path: &str) -> bool {
+    let candidate = Path::new(path);
+    !path.contains(':')
+        && !candidate.is_absolute()
+        && !candidate
+            .components()
+            .any(|component| matches!(component, Component::ParentDir))
+}
+
+fn path_looks_contextual(path: &str) -> bool {
+    path.contains('/') || is_source_path(path) || path.ends_with(".md")
+}
+
+fn path_exists_or_has_repo_parent(root: &Path, path: &str) -> bool {
+    let candidate = root.join(path);
+    if candidate.exists() {
+        return true;
+    }
+    candidate
+        .parent()
+        .is_some_and(|parent| parent != root && parent.exists())
+}

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

@@ -1,4 +1,3 @@
-use std::fs;
 use std::path::Path;
 use std::process::Command;
 
@@ -6,7 +5,7 @@ use crate::models::NaomeError;
 use crate::paths;
 
 pub fn changed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
-    let ignored_patterns = read_naomeignore_patterns(root);
+    let ignored_patterns = paths::naomeignore_patterns(root);
     let output = Command::new("git")
         .args(["status", "--porcelain=v1", "-z", "-uall"])
         .current_dir(root)
@@ -57,27 +56,3 @@ pub fn changed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
     paths.dedup();
     Ok(paths)
 }
-
-fn read_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
-}
-
-fn normalize_ignore_pattern(pattern: &str) -> String {
-    let normalized = pattern.trim_start_matches("./").replace('\\', "/");
-    if normalized.ends_with('/') {
-        format!("{normalized}**")
-    } else {
-        normalized
-    }
-}

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

@@ -36,12 +36,6 @@ const CLASSES: &[(&str, &str, &str, &str)] = &[
         "commit",
         "restore_from_repository_or_package",
     ),
-    (
-        "durable_task_ledger",
-        "Committed task intent, scope, and lifecycle records.",
-        "commit",
-        "restore_from_repository",
-    ),
     (
         "generated_projection",
         "Compatibility views generated from durable state.",
@@ -67,23 +61,18 @@ const CLASSES: &[(&str, &str, &str, &str)] = &[
         "restore_from_repository",
     ),
 ];
-struct RuleSeed {
-    path_pattern: &'static str,
-    class: &'static str,
-}
-
-const RULES: &[RuleSeed] = &[
-    RuleSeed { path_pattern: ".naome/tmp/**", class: "local_runtime_state" },
-    RuleSeed { path_pattern: ".naome/task-state.json", class: "generated_projection" },
-    RuleSeed { path_pattern: ".naome/tasks/active.json", class: "durable_task_ledger" },
-    RuleSeed { path_pattern: ".naome/tasks/*/task.json", class: "durable_task_ledger" },
-    RuleSeed { path_pattern: ".naome/tasks/*/events.jsonl", class: "durable_task_ledger" },
-    RuleSeed { path_pattern: ".naome/tasks/*/proofs/*.json", class: "run_evidence" },
-    RuleSeed { path_pattern: ".naome/manifest.json", class: "durable_project_state" },
-    RuleSeed { path_pattern: ".naome/verification.json", class: "durable_project_state" },
-    RuleSeed { path_pattern: ".naome/repository-quality*.json", class: "durable_project_state" },
-    RuleSeed { path_pattern: "docs/naome/**", class: "durable_project_state" },
-    RuleSeed { path_pattern: "packages/naome/templates/naome-root/**", class: "durable_project_state" },
+const RULES: &[(&str, &str)] = &[
+    (".naome/tmp/**", "local_runtime_state"),
+    (".naome/task-state.json", "generated_projection"),
+    (".naome/tasks/**", "local_runtime_state"),
+    (".naome/manifest.json", "durable_project_state"),
+    (".naome/verification.json", "durable_project_state"),
+    (".naome/repository-quality*.json", "durable_project_state"),
+    ("docs/naome/**", "durable_project_state"),
+    (
+        "packages/naome/templates/naome-root/**",
+        "durable_project_state",
+    ),
 ];
 pub fn information_architecture_report() -> InformationArchitectureReport {
     InformationArchitectureReport {
@@ -95,7 +84,7 @@ pub fn information_architecture_report() -> InformationArchitectureReport {
             .collect(),
         rules: RULES
             .iter()
-            .map(|rule| rule_from_class(rule.path_pattern, rule.class))
+            .map(|(path_pattern, class)| rule_from_class(path_pattern, class))
             .collect(),
     }
 }
@@ -104,8 +93,8 @@ pub fn classify_information_path(path: &str) -> InformationPathClassification {
     let path = normalize_path(path);
     let class_id = RULES
         .iter()
-        .find(|rule| matches_information_rule(&path, rule.path_pattern))
-        .map(|rule| rule.class)
+        .find(|(pattern, _)| matches_information_rule(&path, pattern))
+        .map(|(_, class)| *class)
         .unwrap_or("product_source");
     let class = class_by_id(class_id);
     InformationPathClassification {

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

@@ -81,11 +81,13 @@ pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
         ".naome/bin/naome-rust*",
         ".naome/cache/",
         ".naome/task-journal.jsonl",
+        ".naome/tasks/",
     ];
     git_exclude_entries.extend_from_slice(LOCAL_ONLY_MACHINE_OWNED_PATHS);
 
     let mut git_untrack_paths = LOCAL_ONLY_MACHINE_OWNED_PATHS.to_vec();
     git_untrack_paths.extend_from_slice(LOCAL_NATIVE_BINARY_PATHS);
+    git_untrack_paths.push(".naome/tasks");
 
     InstallPlan {
         schema: "naome.install-plan.v1",

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

@@ -1,29 +1,42 @@
 use std::collections::HashSet;
 
 use super::envelope::parse_routing_envelope;
-use super::model::{CanonicalIntent, IntentCandidate, IntentKind, PromptSegment, SegmentKind};
-use super::patterns;
+use super::model::{CanonicalIntent, IntentCandidate, IntentKind};
 use super::risk::detect_risk;
 use super::segment::{actionable_text, segment_prompt};
 
-const DIRECT_WORKFLOW_CONFIDENCE: u8 = 90;
-const NEW_TASK_CONFIDENCE: u8 = 80;
-const REVISION_CONFIDENCE: u8 = 78;
-const GENERIC_WORK_CONFIDENCE: u8 = 50;
-
 pub(crate) fn canonical_intent(prompt: &str) -> CanonicalIntent {
     let segments = segment_prompt(prompt);
     let actionable = actionable_text(&segments);
-    let mut candidates = classify_candidates(&segments);
+    let mut has_routing_envelope = false;
+    let mut validation_errors = Vec::new();
+    let mut candidates = Vec::new();
     let mut risk = detect_risk(&segments);
 
     if let Some(envelope) = parse_routing_envelope(prompt) {
+        has_routing_envelope = true;
         candidates.clear();
-        candidates.extend(envelope.candidates);
+        validation_errors = envelope.validation_errors;
         risk.risk_codes.extend(envelope.risk.risk_codes);
         risk.risk_codes.sort();
         risk.risk_codes.dedup();
         risk.has_risky_terms = !risk.risk_codes.is_empty();
+        if validation_errors.is_empty() {
+            candidates.extend(envelope.candidates);
+        } else {
+            candidates.push(IntentCandidate {
+                kind: IntentKind::PromptNormalizationRequired,
+                confidence: 100,
+                evidence: "invalid_prompt_envelope".to_string(),
+            });
+        }
+    } else if !actionable.trim().is_empty() {
+        candidates.clear();
+        candidates.push(IntentCandidate {
+            kind: IntentKind::PromptNormalizationRequired,
+            confidence: 100,
+            evidence: "missing_prompt_envelope".to_string(),
+        });
     }
 
     candidates = dedupe_candidates(candidates);
@@ -37,11 +50,13 @@ pub(crate) fn canonical_intent(prompt: &str) -> CanonicalIntent {
     }
 
     CanonicalIntent {
-        is_empty: actionable.trim().is_empty(),
+        is_empty: actionable.trim().is_empty() && !has_routing_envelope,
+        has_routing_envelope,
         references_current_task,
         has_workflow_conflict: has_workflow_conflict(&candidates),
         candidates,
         risk,
+        validation_errors,
     }
 }
 
@@ -51,14 +66,16 @@ pub(crate) fn winning_intent(canonical: &CanonicalIntent) -> IntentKind {
     }
     for kind in [
         IntentKind::Unsafe,
+        IntentKind::PromptNormalizationRequired,
         IntentKind::StatusQuestion,
+        IntentKind::Advisory,
         IntentKind::RepairRequest,
         IntentKind::CancelRequest,
         IntentKind::ReviewRequest,
         IntentKind::NoCommitRequest,
         IntentKind::CommitRequest,
-        IntentKind::NewTask,
         IntentKind::TaskRevision,
+        IntentKind::NewTask,
         IntentKind::TaskCompletion,
     ] {
         if has_candidate(canonical, kind) {
@@ -75,67 +92,44 @@ pub(crate) fn has_candidate(canonical: &CanonicalIntent, kind: IntentKind) -> bo
         .any(|candidate| candidate.kind == kind)
 }
 
-fn classify_candidates(segments: &[PromptSegment]) -> Vec<IntentCandidate> {
-    let mut candidates = Vec::new();
-    for segment in action_segments(segments) {
-        classify_direct_workflow(&mut candidates, segment);
-        classify_task_work(&mut candidates, &segment.text);
-    }
-
-    if candidates.is_empty() {
-        let actionable = actionable_text(segments);
-        if patterns::is_generic_work_request(&actionable) {
-            push(
-                &mut candidates,
-                IntentKind::NewTask,
-                GENERIC_WORK_CONFIDENCE,
-                "generic_work_request",
-            );
-        }
-    }
-
-    dedupe_candidates(candidates)
-}
-
-fn classify_direct_workflow(candidates: &mut Vec<IntentCandidate>, segment: &PromptSegment) {
-    let intents = if segment.kind == SegmentKind::CommandLike {
-        patterns::command_workflow_intents(&segment.text)
-    } else {
-        patterns::structured_workflow_intents(&segment.text)
-    };
-    for intent in intents {
-        push(
-            candidates,
-            intent,
-            DIRECT_WORKFLOW_CONFIDENCE,
-            &patterns::normalized(&segment.text),
-        );
-    }
-}
-
-fn classify_task_work(candidates: &mut Vec<IntentCandidate>, text: &str) {
-    if let Some(intent) = patterns::explicit_task_intent(text) {
-        let confidence = if intent == IntentKind::NewTask {
-            NEW_TASK_CONFIDENCE
-        } else {
-            REVISION_CONFIDENCE
-        };
-        push(candidates, intent, confidence, &patterns::normalized(text));
-    }
-}
-
 fn has_candidate_kind(candidates: &[IntentCandidate], kind: IntentKind) -> bool {
     candidates.iter().any(|candidate| candidate.kind == kind)
 }
 
 fn has_workflow_conflict(candidates: &[IntentCandidate]) -> bool {
+    let kinds = candidates
+        .iter()
+        .map(|candidate| candidate.kind)
+        .collect::<HashSet<_>>();
+    let mutating_kinds = [
+        IntentKind::NewTask,
+        IntentKind::TaskRevision,
+        IntentKind::CommitRequest,
+        IntentKind::RepairRequest,
+        IntentKind::ReviewRequest,
+        IntentKind::CancelRequest,
+        IntentKind::TaskCompletion,
+    ];
+    if (kinds.contains(&IntentKind::Advisory) || kinds.contains(&IntentKind::StatusQuestion))
+        && mutating_kinds.iter().any(|kind| kinds.contains(kind))
+    {
+        return true;
+    }
+    if kinds.contains(&IntentKind::CommitRequest) && kinds.contains(&IntentKind::NoCommitRequest) {
+        return true;
+    }
+
     let workflow = candidates
         .iter()
-        .filter(|candidate| candidate.confidence >= DIRECT_WORKFLOW_CONFIDENCE)
+        .filter(|candidate| candidate.confidence >= 90)
         .filter(|candidate| {
             !matches!(
                 candidate.kind,
-                IntentKind::NewTask | IntentKind::TaskRevision | IntentKind::Unsafe
+                IntentKind::NewTask
+                    | IntentKind::TaskRevision
+                    | IntentKind::Unsafe
+                    | IntentKind::Advisory
+                    | IntentKind::StatusQuestion
             )
         })
         .map(|candidate| candidate.kind)
@@ -143,25 +137,6 @@ fn has_workflow_conflict(candidates: &[IntentCandidate]) -> bool {
     workflow.len() > 1
 }
 
-fn action_segments(segments: &[PromptSegment]) -> impl Iterator<Item = &PromptSegment> {
-    segments.iter().filter(|segment| {
-        matches!(
-            segment.kind,
-            super::model::SegmentKind::Prose
-                | super::model::SegmentKind::ListItem
-                | super::model::SegmentKind::CommandLike
-        )
-    })
-}
-
-fn push(candidates: &mut Vec<IntentCandidate>, kind: IntentKind, confidence: u8, text: &str) {
-    candidates.push(IntentCandidate {
-        kind,
-        confidence,
-        evidence: text.to_string(),
-    });
-}
-
 fn dedupe_candidates(candidates: Vec<IntentCandidate>) -> Vec<IntentCandidate> {
     let mut seen = HashSet::new();
     candidates