@lamentis/naome 1.2.1 → 1.3.1

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

@@ -6,7 +6,7 @@ use serde_json::Value;
 use crate::install_plan::MACHINE_OWNED_PATHS;
 use crate::models::NaomeError;
 
-use super::types::CONTROL_STATE_PATH;
+use super::types::is_control_state_path;
 use super::util::{
     is_non_empty_string, matches_any_pattern, normalize_path, read_json, string_array,
 };
@@ -69,7 +69,7 @@ pub(super) fn is_completed_task_diff(task_state: &Value, changed_paths: &[String
     let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
     let task_paths: Vec<&String> = changed_paths
         .iter()
-        .filter(|path| path.as_str() != CONTROL_STATE_PATH)
+        .filter(|path| !is_control_state_path(path))
         .collect();
     !task_paths.is_empty()
         && task_paths

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

@@ -16,10 +16,10 @@ use super::shape::{
     validate_pending_upgrade, validate_required_check_ids, validate_task_state_shape,
 };
 use super::types::{
-    CompletedTaskCommitDiff, HarnessRefreshDiff, HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
-    CONTROL_STATE_PATH,
+    is_control_state_path, read_complete_active_task, CompletedTaskCommitDiff, HarnessRefreshDiff,
+    HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
 };
-use super::util::{matches_any_pattern, read_json, string_array};
+use super::util::{matches_any_pattern, string_array};
 
 pub fn completed_task_commit_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
     Ok(completed_task_commit_diff(root)?
@@ -30,16 +30,7 @@ pub fn completed_task_commit_paths(root: &Path) -> Result<Vec<String>, NaomeErro
 pub fn completed_task_commit_diff(
     root: &Path,
 ) -> Result<Option<CompletedTaskCommitDiff>, NaomeError> {
-    let mut read_errors = Vec::new();
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut read_errors)? else {
-        return Ok(None);
-    };
-    if !read_errors.is_empty()
-        || task_state.get("status").and_then(Value::as_str) != Some("complete")
-    {
-        return Ok(None);
-    }
-    let Some(active_task) = task_state.get("activeTask") else {
+    let Some((task_state, active_task)) = read_complete_active_task(root)? else {
         return Ok(None);
     };
 
@@ -47,7 +38,7 @@ pub fn completed_task_commit_diff(
     let mut task_entries = Vec::new();
     let mut unrelated_paths = Vec::new();
     for entry in read_git_changed_entries(root)? {
-        if entry.path == CONTROL_STATE_PATH || matches_any_pattern(&entry.path, &allowed_paths) {
+        if is_control_state_path(&entry.path) || matches_any_pattern(&entry.path, &allowed_paths) {
             task_entries.push(entry);
         } else {
             unrelated_paths.push(entry.path);
@@ -60,16 +51,16 @@ pub fn completed_task_commit_diff(
 
     let mut errors = Vec::new();
     validate_task_state_shape(&task_state, &mut errors);
-    validate_active_task(Some(active_task), &mut errors);
+    validate_active_task(Some(&active_task), &mut errors);
     validate_pending_upgrade(&task_state, root, &mut errors)?;
-    validate_active_task_references(Some(active_task), root, &mut errors, Some("complete"))?;
+    validate_active_task_references(Some(&active_task), root, &mut errors, Some("complete"))?;
     if !task_state.get("blocker").is_some_and(Value::is_null) {
         errors.push("complete task state must have blocker set to null.".to_string());
     }
     let check_ids = read_verification_check_ids(root, &mut errors)?;
-    validate_required_check_ids(active_task, &check_ids, &mut errors);
+    validate_required_check_ids(&active_task, &check_ids, &mut errors);
     validate_complete_task_against_entries(
-        active_task,
+        &active_task,
         root,
         &check_ids,
         &task_entries,

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

@@ -1,6 +1,13 @@
+use std::path::Path;
+
+use serde_json::Value;
+
 use crate::harness_health::HarnessHealthOptions;
+use crate::models::NaomeError;
+use crate::task_ledger::read_task_state_projection;
 
 pub(super) const CONTROL_STATE_PATH: &str = ".naome/task-state.json";
+pub(super) const TASK_LEDGER_PATH_PREFIX: &str = ".naome/tasks/";
 pub(super) const ALLOWED_STATUS: &[&str] = &[
     "idle",
     "planning",
@@ -85,3 +92,20 @@ pub(super) struct TaskDiff {
     pub(super) diff_paths: Vec<String>,
     pub(super) outside_paths: Vec<String>,
 }
+
+pub(super) fn is_control_state_path(path: &str) -> bool {
+    path == CONTROL_STATE_PATH || path.starts_with(TASK_LEDGER_PATH_PREFIX)
+}
+
+pub(super) fn read_complete_active_task(root: &Path) -> Result<Option<(Value, Value)>, NaomeError> {
+    let Some(task_state) = read_task_state_projection(root)? else {
+        return Ok(None);
+    };
+    if task_state.get("status").and_then(Value::as_str) != Some("complete") {
+        return Ok(None);
+    }
+    let Some(active_task) = task_state.get("activeTask") else {
+        return Ok(None);
+    };
+    Ok(Some((task_state.clone(), active_task.clone())))
+}

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

@@ -46,7 +46,7 @@ pub fn seed_builtin_verification_checks(root: &Path) -> Result<bool, NaomeError>
         }
     }
 
-    let wired_change_types = wire_repository_quality_check(verification_object);
+    let wired_change_types = wire_repository_gate_checks(verification_object);
     let phases_added = ensure_default_phases(verification_object);
 
     if missing_checks.is_empty() && !wired_change_types && !phases_added {
@@ -126,7 +126,7 @@ fn default_phases() -> Vec<BuiltinPhase> {
         BuiltinPhase {
             id: "quality",
             order: 20,
-            check_ids: &["repository-quality-check"],
+            check_ids: &["repository-quality-check", "repository-semantic-check"],
         },
         BuiltinPhase {
             id: "diff-check",
@@ -136,7 +136,7 @@ fn default_phases() -> Vec<BuiltinPhase> {
     ]
 }
 
-fn wire_repository_quality_check(verification_object: &mut serde_json::Map<String, Value>) -> bool {
+fn wire_repository_gate_checks(verification_object: &mut serde_json::Map<String, Value>) -> bool {
     let Some(change_types) = verification_object
         .get_mut("changeTypes")
         .and_then(Value::as_array_mut)
@@ -155,33 +155,35 @@ fn wire_repository_quality_check(verification_object: &mut serde_json::Map<Strin
         {
             continue;
         }
-        let already_wired = ["requiredChecks", "recommendedChecks"].iter().any(|field| {
-            change_type_object
-                .get(*field)
-                .and_then(Value::as_array)
-                .is_some_and(|checks| {
-                    checks
-                        .iter()
-                        .any(|check| check.as_str() == Some("repository-quality-check"))
-                })
-        });
-        if already_wired {
-            continue;
-        }
         if !change_type_object
             .get("requiredChecks")
             .is_some_and(Value::is_array)
         {
             change_type_object.insert("requiredChecks".to_string(), Value::Array(Vec::new()));
         }
+        let missing_checks = ["repository-quality-check", "repository-semantic-check"]
+            .into_iter()
+            .filter(|check_id| {
+                !["requiredChecks", "recommendedChecks"].iter().any(|field| {
+                    change_type_object
+                        .get(*field)
+                        .and_then(Value::as_array)
+                        .is_some_and(|checks| {
+                            checks.iter().any(|check| check.as_str() == Some(*check_id))
+                        })
+                })
+            })
+            .collect::<Vec<_>>();
         let Some(required_checks) = change_type_object
             .get_mut("requiredChecks")
             .and_then(Value::as_array_mut)
         else {
             continue;
         };
-        required_checks.push(Value::String("repository-quality-check".to_string()));
-        changed = true;
+        for check_id in missing_checks {
+            required_checks.push(Value::String(check_id.to_string()));
+            changed = true;
+        }
     }
 
     changed
@@ -247,6 +249,15 @@ fn builtin_checks() -> Vec<BuiltinCheck> {
                 ".naome/repository-quality-baseline.json",
             ],
         },
+        BuiltinCheck {
+            id: "repository-semantic-check",
+            command: "node .naome/bin/naome.js semantic check --changed",
+            purpose: "Validate changed files against deterministic NAOME semantic cleanup rules.",
+            evidence: &[
+                ".naome/repository-quality.json",
+                ".naome/repository-quality-baseline.json",
+            ],
+        },
     ]
 }
 

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

@@ -0,0 +1,194 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::repository_model::refresh_repository_model;
+use crate::workflow::agent_types::{
+    CapabilityGraph, CapabilityRoot, RepositoryCapability, VerificationEdge,
+};
+
+pub fn repository_capability_graph(root: &Path) -> Result<CapabilityGraph, NaomeError> {
+    let mut model = refresh_repository_model(root, false)?.model;
+    if model.languages.is_empty() && model.build_systems.is_empty() && model.adapters.is_empty() {
+        model = fallback_capability_model(root)?;
+    }
+    let mut capabilities = Vec::new();
+    capabilities.extend(
+        model
+            .languages
+            .into_iter()
+            .map(|signal| capability_from_signal("language", signal)),
+    );
+    capabilities.extend(
+        model
+            .build_systems
+            .into_iter()
+            .map(|signal| capability_from_signal("build", signal)),
+    );
+    capabilities.extend(
+        model
+            .adapters
+            .into_iter()
+            .map(|signal| capability_from_signal("adapter", signal)),
+    );
+    capabilities.sort_by(|left, right| left.id.cmp(&right.id));
+
+    let verification_edges = if model.verification_checks.is_empty() {
+        read_verification_edges(root)?
+    } else {
+        model
+            .verification_checks
+            .into_iter()
+            .map(|check| VerificationEdge {
+                check_id: check.id,
+                command: check.command,
+                evidence: check.evidence,
+            })
+            .collect()
+    };
+
+    Ok(CapabilityGraph {
+        schema: "naome.capability-graph.v1".to_string(),
+        capabilities,
+        roots: model
+            .roots
+            .into_iter()
+            .map(|root| CapabilityRoot {
+                role: root.role,
+                path: root.path,
+            })
+            .collect(),
+        verification_edges,
+    })
+}
+
+fn capability_from_signal(
+    kind: &str,
+    signal: crate::RepositoryWorldSignal,
+) -> RepositoryCapability {
+    RepositoryCapability {
+        id: format!("{kind}:{}", signal.value),
+        kind: kind.to_string(),
+        value: signal.value,
+        evidence: signal.evidence,
+    }
+}
+
+fn fallback_capability_model(root: &Path) -> Result<crate::RepositoryModel, NaomeError> {
+    let paths = fallback_paths(root)?;
+    let mut model = crate::RepositoryModel::default();
+    model.schema = "naome.repository-model.v2".to_string();
+    model.version = 2;
+    if paths
+        .iter()
+        .any(|path| path == "Cargo.toml" || path.ends_with(".rs"))
+    {
+        let evidence = first_evidence(&paths, &["Cargo.toml", ".rs"]);
+        model
+            .languages
+            .push(signal("language:rust", "rust", &evidence));
+        model
+            .build_systems
+            .push(signal("buildSystem:cargo", "cargo", &evidence));
+    }
+    Ok(model)
+}
+
+fn signal(id: &str, value: &str, evidence: &[String]) -> crate::RepositoryWorldSignal {
+    crate::RepositoryWorldSignal {
+        id: id.to_string(),
+        value: value.to_string(),
+        confidence: "detected".to_string(),
+        source: "fallback-scan".to_string(),
+        evidence: evidence.to_vec(),
+    }
+}
+
+fn read_verification_edges(root: &Path) -> Result<Vec<VerificationEdge>, NaomeError> {
+    let path = root.join(".naome/verification.json");
+    if !path.is_file() {
+        return Ok(Vec::new());
+    }
+    let verification: Value = serde_json::from_str(&fs::read_to_string(path)?)?;
+    Ok(verification
+        .get("checks")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|check| {
+            Some(VerificationEdge {
+                check_id: check.get("id")?.as_str()?.to_string(),
+                command: check.get("command")?.as_str()?.to_string(),
+                evidence: check
+                    .get("evidence")
+                    .and_then(Value::as_array)
+                    .into_iter()
+                    .flatten()
+                    .filter_map(Value::as_str)
+                    .map(ToString::to_string)
+                    .collect(),
+            })
+        })
+        .collect())
+}
+
+fn fallback_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let mut paths = Vec::new();
+    collect_fallback_paths(root, root, &mut paths)?;
+    paths.sort();
+    paths.dedup();
+    Ok(paths)
+}
+
+fn collect_fallback_paths(
+    root: &Path,
+    dir: &Path,
+    paths: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let relative = path
+            .strip_prefix(root)
+            .unwrap_or(&path)
+            .to_string_lossy()
+            .replace('\\', "/");
+        if is_fallback_ignored(&relative) {
+            continue;
+        }
+        if path.is_dir() {
+            collect_fallback_paths(root, &path, paths)?;
+        } else if path.is_file() {
+            paths.push(relative);
+        }
+    }
+    Ok(())
+}
+
+fn is_fallback_ignored(path: &str) -> bool {
+    path == ".git"
+        || path.starts_with(".git/")
+        || path.starts_with(".naome/archive/")
+        || path.starts_with(".naome/cache/")
+        || path == "node_modules"
+        || path.starts_with("node_modules/")
+        || path == "target"
+        || path.starts_with("target/")
+}
+
+fn first_evidence(paths: &[String], markers: &[&str]) -> Vec<String> {
+    let mut evidence = Vec::new();
+    for marker in markers {
+        if let Some(path) = paths
+            .iter()
+            .find(|path| path.as_str() == *marker || path.ends_with(marker))
+        {
+            evidence.push(path.clone());
+        }
+    }
+    evidence.sort();
+    evidence.dedup();
+    evidence
+}

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

@@ -0,0 +1,42 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::support::{changed_paths, normalize_path, required_context};
+use crate::workflow::agent_types::ContextDeltaReport;
+
+pub fn context_delta_report(
+    root: &Path,
+    read_paths: &[String],
+) -> Result<ContextDeltaReport, NaomeError> {
+    let changed = changed_paths(root)?.into_iter().collect::<BTreeSet<_>>();
+    let required = required_context(root);
+    let read = read_paths
+        .iter()
+        .map(|path| normalize_path(path))
+        .collect::<BTreeSet<_>>();
+    let reusable_context = read
+        .iter()
+        .filter(|path| !changed.contains(*path) && root.join(path.as_str()).exists())
+        .cloned()
+        .collect();
+    let stale_context = read
+        .iter()
+        .filter(|path| changed.contains(*path))
+        .cloned()
+        .collect();
+    let unread_required_context = required
+        .iter()
+        .filter(|path| !read.contains(*path))
+        .cloned()
+        .collect();
+
+    Ok(ContextDeltaReport {
+        schema: "naome.context-delta.v1".to_string(),
+        reusable_context,
+        stale_context,
+        unread_required_context,
+        reason_codes: vec!["read-set-minimization".to_string()],
+    })
+}

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

@@ -0,0 +1,32 @@
+use std::path::Path;
+
+use crate::decision::{evaluate_decision, EvaluationOptions};
+use crate::models::NaomeError;
+use crate::workflow::agent_types::DecisionGate;
+
+pub fn decision_gate(root: &Path) -> Result<DecisionGate, NaomeError> {
+    let decision = evaluate_decision(root, EvaluationOptions::offline())?;
+    let action = if decision.blocked {
+        if decision.state == "active_task_blocked" {
+            "ask_human"
+        } else {
+            "stop"
+        }
+    } else if decision.state == "ready_for_task" {
+        "create_task"
+    } else {
+        "continue"
+    };
+    let mut reason_codes = vec![decision.state.clone()];
+    if decision.state == "active_task_blocked" {
+        reason_codes.push("scope_review_required".to_string());
+    }
+
+    Ok(DecisionGate {
+        schema: "naome.decision-gate.v1".to_string(),
+        action: action.to_string(),
+        reason_codes,
+        human_options: decision.human_options,
+        next_action: decision.next_action,
+    })
+}

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