@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-core/src/workflow/agent/execution.rs

@@ -0,0 +1,80 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::workflow::agent_types::{ExecutionPlanLedger, ExecutionPlanStep};
+
+use super::support::{read_task_state, required_context};
+
+pub fn execution_plan(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<ExecutionPlanLedger, NaomeError> {
+    let task_state = read_task_state(root)?;
+    let status = task_state
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("invalid")
+        .to_string();
+    let mut steps = vec![read_context_step(root)];
+
+    let task_paths = changed_paths
+        .iter()
+        .filter(|path| path.as_str() != ".naome/task-state.json")
+        .cloned()
+        .collect::<Vec<_>>();
+    if !task_paths.is_empty() {
+        steps.push(path_quality_step(&task_paths));
+    }
+    steps.push(task_state_step(&status));
+
+    Ok(ExecutionPlanLedger {
+        task_state: status,
+        changed_paths: changed_paths.to_vec(),
+        steps,
+    })
+}
+
+fn read_context_step(root: &Path) -> ExecutionPlanStep {
+    ExecutionPlanStep {
+        id: "read-required-context".to_string(),
+        phase: "shape".to_string(),
+        paths: required_context(root),
+        commands: Vec::new(),
+        reason_codes: vec!["token-economy".to_string()],
+    }
+}
+
+fn path_quality_step(changed_paths: &[String]) -> ExecutionPlanStep {
+    ExecutionPlanStep {
+        id: "run-path-quality".to_string(),
+        phase: "quality".to_string(),
+        paths: changed_paths.to_vec(),
+        commands: changed_paths
+            .iter()
+            .map(|path| format!("node .naome/bin/naome.js quality check --path {path}"))
+            .collect(),
+        reason_codes: vec!["early-touched-file-gate".to_string()],
+    }
+}
+
+fn task_state_step(status: &str) -> ExecutionPlanStep {
+    let implementing = status == "implementing";
+    ExecutionPlanStep {
+        id: if implementing {
+            "run-progress-gate"
+        } else {
+            "run-admission-or-status"
+        }
+        .to_string(),
+        phase: "shape".to_string(),
+        paths: vec![".naome/task-state.json".to_string()],
+        commands: vec![if implementing {
+            "node .naome/bin/check-task-state.js --progress".to_string()
+        } else {
+            "node .naome/bin/check-task-state.js --admission".to_string()
+        }],
+        reason_codes: vec!["scope-drift-prevention".to_string()],
+    }
+}

package/crates/naome-core/src/workflow/agent/proof.rs

@@ -0,0 +1,24 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::support::changed_paths;
+use crate::workflow::agent_types::ProofPlan;
+use crate::workflow::phases::{verification_phase_plan, CommandCheckResult};
+
+pub fn proof_plan_for_task(
+    root: &Path,
+    completed: &[CommandCheckResult],
+) -> Result<ProofPlan, NaomeError> {
+    let phase_plan = verification_phase_plan(root, completed)?;
+    Ok(ProofPlan {
+        schema: "naome.proof-plan.v1".to_string(),
+        recommended_check_ids: phase_plan.recommended_check_ids,
+        withheld_check_ids: phase_plan.withheld_check_ids,
+        evidence_paths: changed_paths(root)?
+            .into_iter()
+            .filter(|path| path != ".naome/task-state.json")
+            .collect(),
+        reason_codes: vec!["phase-ordered-minimal-proof".to_string()],
+    })
+}

package/crates/naome-core/src/workflow/agent/support.rs

@@ -0,0 +1,58 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::git;
+use crate::models::NaomeError;
+use crate::task_ledger::read_task_state_projection;
+
+pub(super) fn required_context(root: &Path) -> Vec<String> {
+    let mut paths = vec![
+        ".naome/task-state.json".to_string(),
+        ".naome/verification.json".to_string(),
+        "docs/naome/testing.md".to_string(),
+    ];
+    if root.join("docs/naome/context-economy.md").is_file() {
+        paths.push("docs/naome/context-economy.md".to_string());
+    }
+    paths
+}
+
+pub(super) fn read_task_state(root: &Path) -> Result<Value, NaomeError> {
+    Ok(read_task_state_projection(root)?.unwrap_or(Value::Null))
+}
+
+pub(super) fn active_allowed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let task_state = read_task_state(root)?;
+    Ok(task_state
+        .get("activeTask")
+        .and_then(|task| task.get("allowedPaths"))
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(Value::as_str)
+        .map(ToString::to_string)
+        .collect())
+}
+
+pub(super) fn changed_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    Ok(git::changed_paths(root)
+        .unwrap_or_default()
+        .into_iter()
+        .filter(|path| !path.trim().is_empty())
+        .collect())
+}
+
+pub(super) fn normalize_paths(paths: &[String]) -> Vec<String> {
+    paths
+        .iter()
+        .map(|path| normalize_path(path))
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect()
+}
+
+pub(super) fn normalize_path(path: &str) -> String {
+    path.trim_start_matches("./").replace('\\', "/")
+}

package/crates/naome-core/src/workflow/agent/watchdog.rs

@@ -0,0 +1,47 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+use crate::paths;
+use crate::workflow::agent_types::EditSessionWatchdog;
+use crate::workflow::types::WorkflowFinding;
+
+use super::support::{active_allowed_paths, normalize_paths};
+
+pub fn edit_session_watchdog(
+    root: &Path,
+    touched_paths: &[String],
+) -> Result<EditSessionWatchdog, NaomeError> {
+    let touched_paths = normalize_paths(touched_paths)
+        .into_iter()
+        .filter(|path| path != ".naome/task-state.json")
+        .collect::<Vec<_>>();
+    let allowed_paths = active_allowed_paths(root)?;
+    let out_of_scope = touched_paths
+        .iter()
+        .filter(|path| !allowed_paths.is_empty() && !paths::matches_any(path, &allowed_paths))
+        .cloned()
+        .collect::<Vec<_>>();
+    let mut next_commands = touched_paths
+        .iter()
+        .map(|path| format!("node .naome/bin/naome.js quality check --path {path}"))
+        .collect::<Vec<_>>();
+    next_commands.push("node .naome/bin/check-task-state.js --progress".to_string());
+
+    let findings = if out_of_scope.is_empty() {
+        Vec::new()
+    } else {
+        vec![WorkflowFinding::blocking(
+            "scope-drift",
+            "Touched paths are outside the active task scope.",
+            out_of_scope,
+            None,
+        )]
+    };
+
+    Ok(EditSessionWatchdog {
+        schema: "naome.edit-session-watchdog.v1".to_string(),
+        touched_paths,
+        next_commands,
+        findings,
+    })
+}

package/crates/naome-core/src/workflow/agent.rs

@@ -0,0 +1,34 @@
+mod capability;
+mod context_delta;
+mod decision;
+mod execution;
+mod proof;
+mod support;
+mod watchdog;
+
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::agent_types::AgentRunPlan;
+use super::phases::CommandCheckResult;
+
+pub use capability::repository_capability_graph;
+pub use context_delta::context_delta_report;
+pub use decision::decision_gate;
+pub use execution::execution_plan;
+pub use proof::proof_plan_for_task;
+pub use watchdog::edit_session_watchdog;
+
+pub fn agent_run_plan(root: &Path) -> Result<AgentRunPlan, NaomeError> {
+    let changed_paths = support::changed_paths(root)?;
+    Ok(AgentRunPlan {
+        schema: "naome.agent-run-plan.v1".to_string(),
+        execution_plan: execution_plan(root, &changed_paths)?,
+        context_delta: context_delta_report(root, &[])?,
+        proof_plan: proof_plan_for_task(root, &[] as &[CommandCheckResult])?,
+        capability_graph: repository_capability_graph(root)?,
+        edit_watchdog: edit_session_watchdog(root, &changed_paths)?,
+        decision_gate: decision_gate(root)?,
+    })
+}

package/crates/naome-core/src/workflow/agent_types.rs

@@ -0,0 +1,105 @@
+use serde::{Deserialize, Serialize};
+
+use super::types::WorkflowFinding;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentRunPlan {
+    pub schema: String,
+    pub execution_plan: ExecutionPlanLedger,
+    pub context_delta: ContextDeltaReport,
+    pub proof_plan: ProofPlan,
+    pub capability_graph: CapabilityGraph,
+    pub edit_watchdog: EditSessionWatchdog,
+    pub decision_gate: DecisionGate,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionPlanLedger {
+    pub task_state: String,
+    pub changed_paths: Vec<String>,
+    pub steps: Vec<ExecutionPlanStep>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionPlanStep {
+    pub id: String,
+    pub phase: String,
+    pub paths: Vec<String>,
+    pub commands: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextDeltaReport {
+    pub schema: String,
+    pub reusable_context: Vec<String>,
+    pub stale_context: Vec<String>,
+    pub unread_required_context: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofPlan {
+    pub schema: String,
+    pub recommended_check_ids: Vec<String>,
+    pub withheld_check_ids: Vec<String>,
+    pub evidence_paths: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CapabilityGraph {
+    pub schema: String,
+    pub capabilities: Vec<RepositoryCapability>,
+    pub roots: Vec<CapabilityRoot>,
+    pub verification_edges: Vec<VerificationEdge>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryCapability {
+    pub id: String,
+    pub kind: String,
+    pub value: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CapabilityRoot {
+    pub role: String,
+    pub path: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VerificationEdge {
+    pub check_id: String,
+    pub command: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditSessionWatchdog {
+    pub schema: String,
+    pub touched_paths: Vec<String>,
+    pub next_commands: Vec<String>,
+    pub findings: Vec<WorkflowFinding>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DecisionGate {
+    pub schema: String,
+    pub action: String,
+    pub reason_codes: Vec<String>,
+    pub human_options: Vec<String>,
+    pub next_action: String,
+}

package/crates/naome-core/src/workflow/doctor.rs

@@ -5,6 +5,7 @@ use serde::Serialize;
 
 use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
 use crate::verification_contract::validate_verification_contract;
 
@@ -18,6 +19,7 @@ pub struct DoctorReport {
     pub harness_health: DoctorSection,
     pub task_state: DoctorSection,
     pub verification: DoctorSection,
+    pub repository_model: RepositoryPolicySection,
     pub repository_quality: RepositoryPolicySection,
     pub repository_structure: RepositoryPolicySection,
     pub recommended_check_ids: Vec<String>,
@@ -38,6 +40,7 @@ pub struct RepositoryPolicySection {
     pub config_present: bool,
     pub baseline_present: bool,
     pub status: String,
+    pub messages: Vec<String>,
 }
 
 pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
@@ -59,6 +62,7 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
     let verification_errors = validate_verification_contract(root)?;
     let phase_plan = verification_phase_plan(root, &[])?;
 
+    let repository_model = repository_model_section(root)?;
     let repository_quality = policy_section(
         root,
         ".naome/repository-quality.json",
@@ -72,12 +76,14 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
     let ok = harness_health.status == "ok"
         && task_state.status == "ok"
         && verification.status == "ok"
+        && repository_model.status == "ok"
         && repository_quality.status == "ok"
         && repository_structure.status == "ok";
     let next_action = next_action(
         &harness_health,
         &task_state,
         &verification,
+        &repository_model,
         &repository_quality,
         &repository_structure,
     );
@@ -88,6 +94,7 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
         harness_health,
         task_state,
         verification,
+        repository_model,
         repository_quality,
         repository_structure,
         recommended_check_ids: phase_plan.recommended_check_ids,
@@ -117,13 +124,38 @@ fn policy_section(root: &Path, config_path: &str, baseline_path: &str) -> Reposi
             "missing"
         }
         .to_string(),
+        messages: Vec::new(),
     }
 }
 
+fn repository_model_section(root: &Path) -> Result<RepositoryPolicySection, NaomeError> {
+    let drift = repository_model_drift(root)?;
+    let config_present = drift.model_present;
+    let status = if !config_present {
+        "missing"
+    } else if drift.stale {
+        "stale"
+    } else {
+        "ok"
+    };
+    let messages = if !config_present {
+        vec!["NAOME repository model is missing; run naome repo model --write.".to_string()]
+    } else {
+        drift.messages
+    };
+    Ok(RepositoryPolicySection {
+        config_present,
+        baseline_present: true,
+        status: status.to_string(),
+        messages,
+    })
+}
+
 fn next_action(
     harness_health: &DoctorSection,
     task_state: &DoctorSection,
     verification: &DoctorSection,
+    repository_model: &RepositoryPolicySection,
     repository_quality: &RepositoryPolicySection,
     repository_structure: &RepositoryPolicySection,
 ) -> String {
@@ -136,6 +168,13 @@ fn next_action(
     if verification.status != "ok" {
         return "Fix .naome/verification.json before relying on gates.".to_string();
     }
+    if repository_model.status == "stale" {
+        return "Run naome repo model --write to refresh deterministic repository facts."
+            .to_string();
+    }
+    if repository_model.status != "ok" {
+        return "Run naome repo model --write to seed deterministic repository facts.".to_string();
+    }
     if repository_quality.status != "ok" || repository_structure.status != "ok" {
         return "Run naome quality init or naome sync to seed repository quality policy."
             .to_string();

package/crates/naome-core/src/workflow/mod.rs

@@ -1,3 +1,5 @@
+mod agent;
+mod agent_types;
 mod doctor;
 mod integrity;
 mod integrity_normalize;
@@ -10,6 +12,15 @@ mod policy;
 mod processes;
 mod types;
 
+pub use agent::{
+    agent_run_plan, context_delta_report, decision_gate, edit_session_watchdog,
+    proof_plan_for_task, repository_capability_graph,
+};
+pub use agent_types::{
+    AgentRunPlan, CapabilityGraph, CapabilityRoot, ContextDeltaReport, DecisionGate,
+    EditSessionWatchdog, ExecutionPlanLedger, ExecutionPlanStep, ProofPlan, RepositoryCapability,
+    VerificationEdge,
+};
 pub use doctor::{doctor_report, DoctorReport, DoctorSection, RepositoryPolicySection};
 pub use integrity::{refresh_integrity, IntegrityRefreshReport};
 pub use mutation::classify_mutations;

package/crates/naome-core/src/workflow/output.rs

@@ -71,6 +71,8 @@ fn is_relevant_line(line: &str) -> bool {
         "outside allowedpaths",
         "denied",
         "missing",
+        ".log",
+        "artifact",
     ]
     .iter()
     .any(|needle| lower.contains(needle))
@@ -86,8 +88,12 @@ fn collect_paths(lines: &[String]) -> Vec<String> {
                     '"' | '\'' | '`' | ':' | ',' | ';' | '(' | ')' | '[' | ']'
                 )
             });
-            if looks_like_path(cleaned) {
-                paths.insert(cleaned.replace('\\', "/"));
+            let path_token = cleaned
+                .split_once(':')
+                .map(|(path, _)| path)
+                .unwrap_or(cleaned);
+            if looks_like_path(path_token) {
+                paths.insert(path_token.replace('\\', "/"));
             }
         }
     }

package/crates/naome-core/src/workflow/phase_inference.rs

@@ -54,7 +54,7 @@ fn inferred_phase<'a>(check: &'a CheckDefinition, release_gate_ids: &HashSet<&st
     if id == "diff-check" || command.contains("diff --check") {
         return "diff-check";
     }
-    if id.contains("quality") {
+    if id.contains("quality") || id.contains("semantic") {
         return "quality";
     }
     if id.contains("health") || id.contains("task-state") || command.contains("check-task-state") {

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

@@ -0,0 +1,99 @@
+mod repo_support;
+
+use naome_core::{select_context_for_changed_paths, select_context_for_prompt};
+
+use repo_support::{verification_value, TestRepo};
+
+#[test]
+fn changed_context_selects_touched_files_and_compact_quality_capsule() {
+    let repo = context_repo("context-changed-quality");
+    repo.write_file("packages/tool/src/quality/scanner.rs", "pub fn scan() {}\n");
+    repo.write_file("docs/naome/testing.md", "# Testing\n");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "packages/tool/src/quality/scanner.rs",
+        "pub fn scan() {}\npub fn changed() {}\n",
+    );
+    repo.write_file("docs/naome/testing.md", "# Testing\n\nchanged\n");
+
+    let selection = select_context_for_changed_paths(repo.path()).unwrap();
+
+    assert_eq!(selection.schema, "naome.context-selection.v1");
+    assert_eq!(selection.mode, "changed");
+    assert_eq!(selection.capsule.id, "quality-work");
+    assert!(selection.required_context.iter().any(|item| {
+        item.path == "packages/tool/src/quality/scanner.rs" && item.reason == "changed_path"
+    }));
+    assert!(selection.commands.iter().any(|command| {
+        command == "node .naome/bin/naome.js quality check --path packages/tool/src/quality/scanner.rs"
+    }));
+    assert!(selection
+        .commands
+        .contains(&"node .naome/bin/naome.js quality check --changed".to_string()));
+    assert!(selection
+        .forbidden_context
+        .contains(&".naome/archive/**".to_string()));
+    assert!(selection.budget_ledger.selected_files < 6);
+    assert!(selection.budget_ledger.estimated_tokens > 0);
+}
+
+#[test]
+fn prompt_context_uses_file_mentions_without_broad_markdown_context() {
+    let repo = context_repo("context-prompt-paths");
+    repo.write_file("packages/app/src/lib.rs", "pub fn app() {}\n");
+    repo.write_file("docs/naome/repository-quality.md", "# Quality\n");
+    repo.commit_all("baseline");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "Please update packages/app/src/lib.rs and run a path-scoped quality check.",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(selection.capsule.id, "source-work");
+    assert_eq!(
+        selection.required_context[0].path,
+        "packages/app/src/lib.rs"
+    );
+    assert!(!selection
+        .required_context
+        .iter()
+        .any(|item| item.path == "docs/naome/repository-quality.md"));
+    assert!(selection
+        .optional_context
+        .iter()
+        .any(|item| item.path == "docs/naome/repository-quality.md"));
+}
+
+#[test]
+fn context_selection_reports_over_budget_when_many_paths_change() {
+    let repo = context_repo("context-budget");
+    for index in 0..20 {
+        repo.write_file(&format!("src/file_{index}.rs"), "pub fn before() {}\n");
+    }
+    repo.commit_all("baseline");
+    for index in 0..20 {
+        repo.write_file(&format!("src/file_{index}.rs"), "pub fn after() {}\n");
+    }
+
+    let selection = select_context_for_changed_paths(repo.path()).unwrap();
+
+    assert_eq!(selection.budget_ledger.selected_files, 12);
+    assert!(selection.budget_ledger.avoided_files >= 8);
+    assert!(selection
+        .budget_ledger
+        .reason_codes
+        .contains(&"context_file_budget_reached".to_string()));
+}
+
+fn context_repo(name: &str) -> TestRepo {
+    let repo = TestRepo::new(name);
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n.naome/cache/\n");
+    repo.write_naome_json(
+        "verification.json",
+        verification_value("ready", vec![], vec![]),
+    );
+    repo
+}