@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-core/src/harness_health/integrity.rs

@@ -0,0 +1,96 @@
+use sha2::{Digest, Sha256};
+
+const HEALTH_CHECKER_RELATIVE_PATH: &str = ".naome/bin/check-harness-health.js";
+const TASK_STATE_CHECKER_RELATIVE_PATH: &str = ".naome/bin/check-task-state.js";
+
+pub(crate) const NAOME_COMMAND_RELATIVE_PATH: &str = ".naome/bin/naome.js";
+
+#[cfg(windows)]
+pub(crate) const NATIVE_BINARY_RELATIVE_PATH: &str = ".naome/bin/naome-rust.exe";
+#[cfg(not(windows))]
+pub(crate) const NATIVE_BINARY_RELATIVE_PATH: &str = ".naome/bin/naome-rust";
+
+pub(crate) fn machine_integrity_hash(relative_path: &str, content: &[u8]) -> String {
+    format!("sha256:{}", machine_sha256(relative_path, content))
+}
+
+pub(crate) fn sha256_bytes(content: &[u8]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(content);
+    format!("{:x}", hasher.finalize())
+}
+
+pub(crate) fn is_integrity_hash(value: &str) -> bool {
+    value.len() == "sha256:".len() + 64
+        && value.starts_with("sha256:")
+        && value["sha256:".len()..]
+            .chars()
+            .all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase())
+}
+
+pub(crate) fn native_integrity_from_naome_command(content: &str) -> Option<String> {
+    let prefix = "const expectedNativeBinaryIntegrity = \"";
+    let start = content.find(prefix)? + prefix.len();
+    let rest = &content[start..];
+    let end = rest.find("\";")?;
+    let value = &rest[..end];
+    is_integrity_hash(value).then(|| value.to_string())
+}
+
+fn machine_sha256(relative_path: &str, content: &[u8]) -> String {
+    let normalized = normalize_machine_owned_content(relative_path, content);
+    sha256_bytes(&normalized)
+}
+
+fn normalize_machine_owned_content(relative_path: &str, content: &[u8]) -> Vec<u8> {
+    if relative_path == HEALTH_CHECKER_RELATIVE_PATH
+        || relative_path == TASK_STATE_CHECKER_RELATIVE_PATH
+    {
+        return replace_expected_integrity_block(content);
+    }
+
+    if relative_path == NAOME_COMMAND_RELATIVE_PATH {
+        return replace_native_integrity_line(content);
+    }
+
+    content.to_vec()
+}
+
+fn replace_expected_integrity_block(content: &[u8]) -> Vec<u8> {
+    let text = String::from_utf8_lossy(content);
+    let start_marker = "const expectedMachineOwnedIntegrity = Object.freeze({\n";
+    let normalized =
+        "const expectedMachineOwnedIntegrity = Object.freeze({\n  __generated__: \"sha256:generated\"\n});\n";
+    let Some(start) = text.find(start_marker) else {
+        return content.to_vec();
+    };
+    let after_start = start + start_marker.len();
+    let Some(relative_end) = text[after_start..].find("\n});\n") else {
+        return content.to_vec();
+    };
+    let end = after_start + relative_end + "\n});\n".len();
+
+    let mut next = String::with_capacity(text.len());
+    next.push_str(&text[..start]);
+    next.push_str(normalized);
+    next.push_str(&text[end..]);
+    next.into_bytes()
+}
+
+fn replace_native_integrity_line(content: &[u8]) -> Vec<u8> {
+    let text = String::from_utf8_lossy(content);
+    let prefix = "const expectedNativeBinaryIntegrity = \"";
+    let Some(start) = text.find(prefix) else {
+        return content.to_vec();
+    };
+    let Some(relative_end) = text[start..].find(";\n") else {
+        return content.to_vec();
+    };
+    let end = start + relative_end + ";\n".len();
+
+    let mut next = String::with_capacity(text.len());
+    next.push_str(&text[..start]);
+    next.push_str("const expectedNativeBinaryIntegrity = \"sha256:generated\";\n");
+    next.push_str(&text[end..]);
+    next.into_bytes()
+}

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

@@ -1,49 +1,19 @@
+mod integrity;
+
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Component, Path};
 
 use serde_json::Value;
-use sha2::{Digest, Sha256};
 
+pub(crate) use self::integrity::machine_integrity_hash;
+use self::integrity::{
+    is_integrity_hash, native_integrity_from_naome_command, sha256_bytes,
+    NAOME_COMMAND_RELATIVE_PATH, NATIVE_BINARY_RELATIVE_PATH,
+};
+use crate::install_plan::{MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS};
 use crate::models::NaomeError;
 
-const HEALTH_CHECKER_RELATIVE_PATH: &str = ".naome/bin/check-harness-health.js";
-const TASK_STATE_CHECKER_RELATIVE_PATH: &str = ".naome/bin/check-task-state.js";
-const NAOME_COMMAND_RELATIVE_PATH: &str = ".naome/bin/naome.js";
-
-#[cfg(windows)]
-const NATIVE_BINARY_RELATIVE_PATH: &str = ".naome/bin/naome-rust.exe";
-#[cfg(not(windows))]
-const NATIVE_BINARY_RELATIVE_PATH: &str = ".naome/bin/naome-rust";
-
-const EXPECTED_MACHINE_OWNED_PATHS: &[&str] = &[
-    "AGENTS.md",
-    ".naome/package.json",
-    ".naome/bin/naome.js",
-    ".naome/bin/check-task-state.js",
-    ".naome/bin/check-harness-health.js",
-    ".naome/task-contract.schema.json",
-    "docs/naome/index.md",
-    "docs/naome/first-run.md",
-    "docs/naome/agent-workflow.md",
-    "docs/naome/execution.md",
-    "docs/naome/upgrade.md",
-];
-
-const EXPECTED_PROJECT_OWNED_PATHS: &[&str] = &[
-    ".naomeignore",
-    ".naome/init-state.json",
-    ".naome/manifest.json",
-    ".naome/task-state.json",
-    ".naome/upgrade-state.json",
-    ".naome/verification.json",
-    "docs/naome/architecture.md",
-    "docs/naome/decisions.md",
-    "docs/naome/repo-profile.md",
-    "docs/naome/security.md",
-    "docs/naome/testing.md",
-];
-
 #[derive(Debug, Clone, Default)]
 pub struct HarnessHealthOptions {
     pub expected_integrity: HashMap<String, String>,
@@ -57,11 +27,11 @@ pub fn validate_harness_health(
 ) -> Result<Vec<String>, NaomeError> {
     let mut errors = Vec::new();
 
-    for relative_path in EXPECTED_MACHINE_OWNED_PATHS {
+    for relative_path in MACHINE_OWNED_PATHS {
         validate_regular_file(root, relative_path, &mut errors)?;
     }
 
-    for relative_path in EXPECTED_PROJECT_OWNED_PATHS {
+    for relative_path in PROJECT_OWNED_PATHS {
         validate_regular_file(root, relative_path, &mut errors)?;
     }
 
@@ -130,13 +100,13 @@ fn validate_manifest_ownership(manifest: &Value, errors: &mut Vec<String>) {
 
     validate_contains_all(
         &machine_owned,
-        EXPECTED_MACHINE_OWNED_PATHS,
+        MACHINE_OWNED_PATHS,
         ".naome/manifest.json machineOwned",
         errors,
     );
     validate_contains_all(
         &project_owned,
-        EXPECTED_PROJECT_OWNED_PATHS,
+        PROJECT_OWNED_PATHS,
         ".naome/manifest.json projectOwned",
         errors,
     );
@@ -152,7 +122,7 @@ fn validate_manifest_integrity(
         return Ok(());
     };
 
-    for relative_path in EXPECTED_MACHINE_OWNED_PATHS {
+    for relative_path in MACHINE_OWNED_PATHS {
         let packaged_expected = options.expected_integrity.get(*relative_path);
         let manifest_expected = integrity.get(*relative_path).and_then(Value::as_str);
 
@@ -190,7 +160,7 @@ fn validate_manifest_integrity(
         }
 
         let content = fs::read(root.join(relative_path))?;
-        let actual = format!("sha256:{}", machine_sha256(relative_path, &content));
+        let actual = machine_integrity_hash(relative_path, &content);
         if actual != *packaged_expected {
             errors.push(format!(
                 "{relative_path} integrity mismatch. Expected {packaged_expected}, got {actual}."
@@ -475,85 +445,3 @@ fn is_version(value: &str) -> bool {
             .iter()
             .all(|part| !part.is_empty() && part.chars().all(|ch| ch.is_ascii_digit()))
 }
-
-fn is_integrity_hash(value: &str) -> bool {
-    value.len() == "sha256:".len() + 64
-        && value.starts_with("sha256:")
-        && value["sha256:".len()..]
-            .chars()
-            .all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase())
-}
-
-fn machine_sha256(relative_path: &str, content: &[u8]) -> String {
-    let normalized = normalize_machine_owned_content(relative_path, content);
-    sha256_bytes(&normalized)
-}
-
-fn sha256_bytes(content: &[u8]) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update(content);
-    format!("{:x}", hasher.finalize())
-}
-
-fn normalize_machine_owned_content(relative_path: &str, content: &[u8]) -> Vec<u8> {
-    if relative_path == HEALTH_CHECKER_RELATIVE_PATH
-        || relative_path == TASK_STATE_CHECKER_RELATIVE_PATH
-    {
-        return replace_expected_integrity_block(content);
-    }
-
-    if relative_path == NAOME_COMMAND_RELATIVE_PATH {
-        return replace_native_integrity_line(content);
-    }
-
-    content.to_vec()
-}
-
-fn replace_expected_integrity_block(content: &[u8]) -> Vec<u8> {
-    let text = String::from_utf8_lossy(content);
-    let start_marker = "const expectedMachineOwnedIntegrity = Object.freeze({\n";
-    let normalized =
-        "const expectedMachineOwnedIntegrity = Object.freeze({\n  __generated__: \"sha256:generated\"\n});\n";
-    let Some(start) = text.find(start_marker) else {
-        return content.to_vec();
-    };
-    let after_start = start + start_marker.len();
-    let Some(relative_end) = text[after_start..].find("\n});\n") else {
-        return content.to_vec();
-    };
-    let end = after_start + relative_end + "\n});\n".len();
-
-    let mut next = String::with_capacity(text.len());
-    next.push_str(&text[..start]);
-    next.push_str(normalized);
-    next.push_str(&text[end..]);
-    next.into_bytes()
-}
-
-fn replace_native_integrity_line(content: &[u8]) -> Vec<u8> {
-    let text = String::from_utf8_lossy(content);
-    let prefix = "const expectedNativeBinaryIntegrity = \"";
-    let Some(start) = text.find(prefix) else {
-        return content.to_vec();
-    };
-    let Some(relative_end) = text[start..].find(";\n") else {
-        return content.to_vec();
-    };
-    let end = start + relative_end + ";\n".len();
-    let replacement = "const expectedNativeBinaryIntegrity = \"sha256:generated\";\n";
-
-    let mut next = String::with_capacity(text.len());
-    next.push_str(&text[..start]);
-    next.push_str(replacement);
-    next.push_str(&text[end..]);
-    next.into_bytes()
-}
-
-fn native_integrity_from_naome_command(content: &str) -> Option<String> {
-    let prefix = "const expectedNativeBinaryIntegrity = \"";
-    let start = content.find(prefix)? + prefix.len();
-    let rest = &content[start..];
-    let end = rest.find("\";")?;
-    let value = &rest[..end];
-    is_integrity_hash(value).then(|| value.to_string())
-}

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

@@ -21,9 +21,14 @@ pub const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
+    ".naome/repository-quality.json",
+    ".naome/repository-structure.json",
+    ".naome/repository-quality-baseline.json",
     "docs/naome/architecture.md",
     "docs/naome/decisions.md",
     "docs/naome/repo-profile.md",
+    "docs/naome/repository-quality.md",
+    "docs/naome/repository-structure.md",
     "docs/naome/security.md",
     "docs/naome/testing.md",
 ];

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

@@ -0,0 +1,171 @@
+use std::collections::HashSet;
+
+use super::envelope::parse_routing_envelope;
+use super::model::{CanonicalIntent, IntentCandidate, IntentKind, PromptSegment, SegmentKind};
+use super::patterns;
+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 risk = detect_risk(&segments);
+
+    if let Some(envelope) = parse_routing_envelope(prompt) {
+        candidates.clear();
+        candidates.extend(envelope.candidates);
+        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();
+    }
+
+    candidates = dedupe_candidates(candidates);
+    let references_current_task = has_candidate_kind(&candidates, IntentKind::TaskRevision);
+    if risk.has_risky_terms {
+        candidates.push(IntentCandidate {
+            kind: IntentKind::Unsafe,
+            confidence: 100,
+            evidence: risk.risk_codes.join(","),
+        });
+    }
+
+    CanonicalIntent {
+        is_empty: actionable.trim().is_empty(),
+        references_current_task,
+        has_workflow_conflict: has_workflow_conflict(&candidates),
+        candidates,
+        risk,
+    }
+}
+
+pub(crate) fn winning_intent(canonical: &CanonicalIntent) -> IntentKind {
+    if canonical.is_empty || canonical.has_workflow_conflict {
+        return IntentKind::Ambiguous;
+    }
+    for kind in [
+        IntentKind::Unsafe,
+        IntentKind::StatusQuestion,
+        IntentKind::RepairRequest,
+        IntentKind::CancelRequest,
+        IntentKind::ReviewRequest,
+        IntentKind::NoCommitRequest,
+        IntentKind::CommitRequest,
+        IntentKind::NewTask,
+        IntentKind::TaskRevision,
+        IntentKind::TaskCompletion,
+    ] {
+        if has_candidate(canonical, kind) {
+            return kind;
+        }
+    }
+    IntentKind::Ambiguous
+}
+
+pub(crate) fn has_candidate(canonical: &CanonicalIntent, kind: IntentKind) -> bool {
+    canonical
+        .candidates
+        .iter()
+        .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 workflow = candidates
+        .iter()
+        .filter(|candidate| candidate.confidence >= DIRECT_WORKFLOW_CONFIDENCE)
+        .filter(|candidate| {
+            !matches!(
+                candidate.kind,
+                IntentKind::NewTask | IntentKind::TaskRevision | IntentKind::Unsafe
+            )
+        })
+        .map(|candidate| candidate.kind)
+        .collect::<HashSet<_>>();
+    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
+        .into_iter()
+        .filter(|candidate| seen.insert((candidate.kind, candidate.evidence.clone())))
+        .collect()
+}

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

@@ -0,0 +1,108 @@
+use serde::Deserialize;
+
+use super::model::{IntentCandidate, IntentKind, RiskContext};
+
+const ENVELOPE_FENCE: &str = "```naome-intent-v2";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RoutingEnvelope {
+    pub candidates: Vec<IntentCandidate>,
+    pub risk: RiskContext,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct EnvelopeInput {
+    schema: Option<String>,
+    workflow_action: Option<String>,
+    task_intent: Option<String>,
+    risk: Option<String>,
+    risk_codes: Option<Vec<String>>,
+}
+
+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 mut candidates = Vec::new();
+    if let Some(kind) = workflow_action(input.workflow_action.as_deref()) {
+        candidates.push(candidate(kind, "envelope.workflowAction"));
+    }
+    if let Some(kind) = task_intent(input.task_intent.as_deref()) {
+        candidates.push(candidate(kind, "envelope.taskIntent"));
+    }
+
+    let risk_codes = envelope_risk_codes(input.risk.as_deref(), input.risk_codes);
+    let risk = RiskContext {
+        has_risky_terms: !risk_codes.is_empty(),
+        risk_codes,
+    };
+
+    Some(RoutingEnvelope { candidates, risk })
+}
+
+fn envelope_json(prompt: &str) -> Option<&str> {
+    let start = prompt.find(ENVELOPE_FENCE)?;
+    let after_open = &prompt[start + ENVELOPE_FENCE.len()..];
+    let after_line = after_open
+        .strip_prefix('\n')
+        .or_else(|| after_open.strip_prefix("\r\n"))?;
+    let end = after_line.find("\n```")?;
+    Some(after_line[..end].trim())
+}
+
+fn workflow_action(value: Option<&str>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "commit_request" => Some(IntentKind::CommitRequest),
+        "review_request" => Some(IntentKind::ReviewRequest),
+        "repair_request" => Some(IntentKind::RepairRequest),
+        "cancel_request" => Some(IntentKind::CancelRequest),
+        "task_completion" => Some(IntentKind::TaskCompletion),
+        "status_question" => Some(IntentKind::StatusQuestion),
+        "no_commit_request" => Some(IntentKind::NoCommitRequest),
+        _ => None,
+    }
+}
+
+fn task_intent(value: Option<&str>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "new_task" => Some(IntentKind::NewTask),
+        "task_revision" => Some(IntentKind::TaskRevision),
+        _ => None,
+    }
+}
+
+fn envelope_risk_codes(risk: Option<&str>, risk_codes: Option<Vec<String>>) -> Vec<String> {
+    let mut codes = risk_codes.unwrap_or_default();
+    match normalized_value(risk).as_deref() {
+        Some("none") | Some("unknown") | None => {}
+        Some("unsafe") | Some("unsafe_context") => codes.push("envelope_risk:unsafe".to_string()),
+        Some("credential_context") => {
+            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}")),
+    }
+    codes.sort();
+    codes.dedup();
+    codes
+}
+
+fn normalized_value(value: Option<&str>) -> Option<String> {
+    value
+        .map(|value| value.trim().to_ascii_lowercase())
+        .filter(|value| !value.is_empty())
+}
+
+fn candidate(kind: IntentKind, evidence: &str) -> IntentCandidate {
+    IntentCandidate {
+        kind,
+        confidence: 100,
+        evidence: evidence.to_string(),
+    }
+}