@lamentis/naome 1.1.2 → 1.2.1

package/crates/naome-core/src/route/builtin_checks.rs

@@ -0,0 +1,155 @@
+use std::path::Path;
+
+use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
+use crate::models::NaomeError;
+use crate::quality::{check_repository_quality, QualityMode};
+use crate::route::git_ops::{command_output, git_output};
+use crate::route::quality_gate::QualityCheck;
+use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
+use crate::verification_contract::validate_verification_contract;
+
+use super::builtin_context::{run_context_budget_check, template_root};
+use super::builtin_integrity::packaged_harness_integrity;
+use super::builtin_require::{require_builtin_quality_check, require_builtin_quality_check_any};
+
+pub(super) fn run_quality_check(
+    root: &Path,
+    check_id: &str,
+    check: &QualityCheck,
+) -> Result<(), NaomeError> {
+    match check_id {
+        "installer-tests" => require_builtin_quality_check(
+            check_id,
+            check,
+            "npm run test:naome-installer",
+        ),
+        "rust-build" => require_builtin_quality_check(check_id, check, "npm run build:rust"),
+        "decision-engine-tests" => {
+            require_builtin_quality_check(check_id, check, "npm run test:decision-engine")
+        }
+        "package-dry-run" => require_builtin_quality_check(check_id, check, "npm run pack:dry-run"),
+        "diff-check" => {
+            require_builtin_quality_check(check_id, check, "git diff --check")?;
+            let output = git_output(root, &["diff", "--check"])?;
+
+            if output.status.success() {
+                Ok(())
+            } else {
+                Err(NaomeError::new(command_output(&output)))
+            }
+        }
+        "naome-harness-health" => {
+            require_builtin_quality_check(
+                check_id,
+                check,
+                "node .naome/bin/check-harness-health.js",
+            )?;
+            run_harness_health_check(root)
+        }
+        "dogfood-health" => {
+            require_builtin_quality_check(check_id, check, "npm run dogfood:health")?;
+            run_harness_health_check(root)
+        }
+        "task-state-check" => {
+            require_builtin_quality_check(check_id, check, "npm run check:task-state")?;
+            run_template_task_state_check(root)
+        }
+        "verification-contract-check" => {
+            require_builtin_quality_check(
+                check_id,
+                check,
+                "npm run check:verification-contract",
+            )?;
+            run_template_verification_contract_check(root)
+        }
+        "context-budget-check" => {
+            require_builtin_quality_check(check_id, check, "npm run check:context-budget")?;
+            run_context_budget_check(root)
+        }
+        "repository-quality-check" => {
+            require_builtin_quality_check_any(
+                check_id,
+                check,
+                &[
+                    "naome quality check --changed",
+                    "node .naome/bin/naome.js quality check --changed",
+                    "npm run check:repository-quality",
+                ],
+            )?;
+            run_repository_quality_check(root)
+        }
+        _ => Err(NaomeError::new(format!(
+            "Quality check {check_id} is not a built-in safe check; NAOME will not execute repository-controlled verification commands."
+        ))),
+    }
+}
+
+fn run_repository_quality_check(root: &Path) -> Result<(), NaomeError> {
+    let report = check_repository_quality(root, QualityMode::Changed)?;
+    if report.ok {
+        return Ok(());
+    }
+
+    let details = report
+        .violations
+        .iter()
+        .take(20)
+        .map(|violation| {
+            let location = violation
+                .line
+                .map(|line| format!("{}:{line}", violation.path))
+                .unwrap_or_else(|| violation.path.clone());
+            format!("{location} {}: {}", violation.check_id, violation.message)
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    Err(NaomeError::new(format!(
+        "repository-quality-check failed with {} violation(s).\n{}",
+        report.violations.len(),
+        details
+    )))
+}
+
+fn run_harness_health_check(root: &Path) -> Result<(), NaomeError> {
+    let errors = validate_harness_health(
+        root,
+        HarnessHealthOptions {
+            expected_integrity: packaged_harness_integrity()?,
+            ..HarnessHealthOptions::default()
+        },
+    )?;
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(errors.join("\n")))
+    }
+}
+
+fn run_template_task_state_check(root: &Path) -> Result<(), NaomeError> {
+    let template_root = template_root(root);
+    let report = validate_task_state(
+        &template_root,
+        TaskStateOptions {
+            mode: TaskStateMode::State,
+            harness_health: Some(HarnessHealthOptions {
+                expected_integrity: packaged_harness_integrity()?,
+                allow_missing_archive: true,
+                ..HarnessHealthOptions::default()
+            }),
+        },
+    )?;
+    if report.errors.is_empty() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(report.errors.join("\n")))
+    }
+}
+
+fn run_template_verification_contract_check(root: &Path) -> Result<(), NaomeError> {
+    let errors = validate_verification_contract(&template_root(root))?;
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(errors.join("\n")))
+    }
+}

package/crates/naome-core/src/route/builtin_context.rs

@@ -0,0 +1,73 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use crate::models::NaomeError;
+
+pub(super) fn run_context_budget_check(root: &Path) -> Result<(), NaomeError> {
+    let template_root = template_root(root);
+    let mut context_files = vec![
+        template_root.join("AGENTS.md"),
+        template_root.join(".naomeignore"),
+    ];
+    context_files.extend(markdown_files(&template_root.join("docs").join("naome"))?);
+    context_files.sort();
+
+    let mut errors = Vec::new();
+    for path in context_files {
+        let content = fs::read_to_string(&path)?;
+        let line_count = count_lines(&content);
+        if line_count > 200 {
+            errors.push(format!(
+                "{}: {line_count} lines",
+                display_repo_path(root, &path)
+            ));
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(format!(
+            "NAOME context budget exceeded. Limit: 200 lines per file.\n{}",
+            errors.join("\n")
+        )))
+    }
+}
+
+pub(super) fn template_root(root: &Path) -> PathBuf {
+    root.join("packages")
+        .join("naome")
+        .join("templates")
+        .join("naome-root")
+}
+
+fn markdown_files(dir: &Path) -> Result<Vec<PathBuf>, NaomeError> {
+    let mut files = Vec::new();
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_dir() {
+            files.extend(markdown_files(&path)?);
+        } else if path.is_file() && path.extension().is_some_and(|extension| extension == "md") {
+            files.push(path);
+        }
+    }
+    Ok(files)
+}
+
+fn count_lines(content: &str) -> usize {
+    if content.is_empty() {
+        0
+    } else if content.ends_with('\n') {
+        content.split('\n').count() - 1
+    } else {
+        content.split('\n').count()
+    }
+}
+
+fn display_repo_path(root: &Path, path: &Path) -> String {
+    path.strip_prefix(root)
+        .unwrap_or(path)
+        .to_string_lossy()
+        .to_string()
+}

package/crates/naome-core/src/route/builtin_integrity.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+
+use crate::models::NaomeError;
+
+pub(super) fn packaged_harness_integrity() -> Result<HashMap<String, String>, NaomeError> {
+    const CHECKER: &str =
+        include_str!("../../../../templates/naome-root/.naome/bin/check-harness-health.js");
+    let start_marker = "const expectedMachineOwnedIntegrity = Object.freeze({";
+    let start = CHECKER
+        .find(start_marker)
+        .ok_or_else(|| NaomeError::new("Packaged harness integrity block is missing."))?;
+    let body_start = start + start_marker.len();
+    let end = CHECKER[body_start..]
+        .find("\n});")
+        .map(|offset| body_start + offset)
+        .ok_or_else(|| NaomeError::new("Packaged harness integrity block is incomplete."))?;
+
+    let mut integrity = HashMap::new();
+    for line in CHECKER[body_start..end].lines() {
+        let line = line.trim().trim_end_matches(',').trim();
+        if line.is_empty() {
+            continue;
+        }
+        let Some((path, hash)) = line.split_once(':') else {
+            return Err(NaomeError::new(format!(
+                "Packaged harness integrity entry is invalid: {line}"
+            )));
+        };
+        let path: String = serde_json::from_str(path.trim()).map_err(|error| {
+            NaomeError::new(format!(
+                "Packaged harness integrity path is invalid: {error}"
+            ))
+        })?;
+        let hash: String = serde_json::from_str(hash.trim()).map_err(|error| {
+            NaomeError::new(format!(
+                "Packaged harness integrity hash is invalid: {error}"
+            ))
+        })?;
+        integrity.insert(path, hash);
+    }
+
+    if integrity.is_empty() {
+        return Err(NaomeError::new(
+            "Packaged harness integrity block is empty.",
+        ));
+    }
+
+    Ok(integrity)
+}

package/crates/naome-core/src/route/builtin_require.rs

@@ -0,0 +1,40 @@
+use crate::models::NaomeError;
+
+use super::quality_gate::QualityCheck;
+
+pub(super) fn require_builtin_quality_check_any(
+    check_id: &str,
+    check: &QualityCheck,
+    expected_commands: &[&str],
+) -> Result<(), NaomeError> {
+    if check.cwd == "."
+        && expected_commands
+            .iter()
+            .any(|expected_command| check.command == *expected_command)
+    {
+        return Ok(());
+    }
+
+    Err(NaomeError::new(format!(
+        "Quality check {check_id} has an unsafe command or cwd; expected one of [{}] with cwd `.`.",
+        expected_commands
+            .iter()
+            .map(|command| format!("`{command}`"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )))
+}
+
+pub(super) fn require_builtin_quality_check(
+    check_id: &str,
+    check: &QualityCheck,
+    expected_command: &str,
+) -> Result<(), NaomeError> {
+    if check.cwd == "." && check.command == expected_command {
+        return Ok(());
+    }
+
+    Err(NaomeError::new(format!(
+        "Quality check {check_id} has an unsafe command or cwd; expected command `{expected_command}` with cwd `.`."
+    )))
+}

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

@@ -0,0 +1,180 @@
+use crate::intent::IntentDecision;
+use crate::models::Decision;
+
+pub(super) fn can_create_task(intent: &IntentDecision, decision: &Decision, execute: bool) -> bool {
+    let creation_intent = matches!(
+        intent.policy_action.as_str(),
+        "create_new_task"
+            | "create_new_task_without_auto_baseline"
+            | "auto_commit_completed_task_then_create_new_task"
+            | "auto_commit_completed_task_then_create_isolated_task_worktree"
+            | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+            | "auto_commit_upgrade_baseline_then_create_new_task"
+            | "create_isolated_task_worktree"
+    );
+    if !creation_intent || decision.state != "ready_for_task" || decision.blocked {
+        return false;
+    }
+
+    execute
+        || matches!(
+            intent.policy_action.as_str(),
+            "create_new_task" | "create_new_task_without_auto_baseline"
+        )
+}
+
+pub(super) fn winning_rule(intent: &IntentDecision) -> String {
+    match intent.policy_action.as_str() {
+        "block_unsafe_intent" => "unsafe_intent_precedence",
+        "block_auto_baseline_due_to_no_commit" => "no_commit_blocks_auto_baseline",
+        "continue_current_task_without_commit" => "no_commit_continues_active_task",
+        "review_task_diff" | "review_diff_first" | "review_current_task_diff" => {
+            "explicit_review_overrides_auto_baseline"
+        }
+        "cancel_task_changes" | "cancel_upgrade_baseline" | "cancel_current_task" => {
+            "explicit_cancel_overrides_auto_baseline"
+        }
+        "auto_commit_completed_task_then_create_new_task" => {
+            "completed_task_valid_new_task_auto_baseline"
+        }
+        "auto_commit_completed_task_then_create_isolated_task_worktree" => {
+            "completed_task_valid_with_unrelated_dirty_worktree"
+        }
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            "completed_task_harness_refresh_split_auto_baseline"
+        }
+        "auto_commit_harness_refresh_then_create_new_task" => {
+            "pure_harness_refresh_new_task_auto_baseline"
+        }
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => {
+            "dirty_repo_harness_refresh_worktree_isolation"
+        }
+        "auto_commit_harness_refresh_baseline" => "dirty_repo_harness_refresh_repair_baseline",
+        "auto_commit_upgrade_baseline_then_create_new_task" => "setup_diff_new_task_auto_baseline",
+        "reopen_completed_task_revision" | "continue_current_task" => {
+            "current_task_revision_continues_task"
+        }
+        "answer_status_only" => "status_request_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",
+        _ => "fallback_policy",
+    }
+    .to_string()
+}
+
+pub(super) fn discarded_actions(intent: &IntentDecision) -> Vec<String> {
+    let Some(actions_note) = intent
+        .internal_notes
+        .iter()
+        .find(|note| note.starts_with("internal_allowed_actions:"))
+    else {
+        return Vec::new();
+    };
+    let selected = selected_internal_action(&intent.policy_action);
+    actions_note
+        .trim_start_matches("internal_allowed_actions:")
+        .split(',')
+        .filter(|action| !action.is_empty() && Some(*action) != selected.as_deref())
+        .map(ToString::to_string)
+        .collect()
+}
+
+fn selected_internal_action(policy_action: &str) -> Option<String> {
+    match policy_action {
+        "auto_commit_completed_task_then_create_new_task"
+        | "auto_commit_completed_task_then_create_isolated_task_worktree"
+        | "commit_task_baseline" => Some("commit_task_baseline".to_string()),
+        "auto_commit_harness_refresh_then_create_new_task"
+        | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_baseline" => Some("commit_upgrade_baseline".to_string()),
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            Some("commit_task_baseline".to_string())
+        }
+        "auto_commit_upgrade_baseline_then_create_new_task" | "commit_upgrade_baseline" => {
+            Some("commit_upgrade_baseline".to_string())
+        }
+        other if other.starts_with("review_") || other.starts_with("cancel_") => {
+            Some(other.to_string())
+        }
+        _ => None,
+    }
+}
+
+pub(super) fn would_mutate(intent: &IntentDecision) -> bool {
+    matches!(
+        intent.policy_action.as_str(),
+        "auto_commit_completed_task_then_create_new_task"
+            | "auto_commit_completed_task_then_create_isolated_task_worktree"
+            | "auto_commit_upgrade_baseline_then_create_new_task"
+            | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+            | "auto_commit_harness_refresh_baseline"
+            | "create_isolated_task_worktree"
+            | "commit_task_baseline"
+            | "commit_upgrade_baseline"
+            | "commit_user_diff_with_quality_gate"
+    )
+}
+
+pub(super) fn required_context_for_route(
+    intent: &IntentDecision,
+    decision: &Decision,
+) -> Vec<String> {
+    let mut context = required_context_for_intent(intent);
+    if decision.state == "ready_for_task" {
+        push_unique(&mut context, "docs/naome/agent-workflow.md");
+        push_unique(&mut context, "docs/naome/testing.md");
+        push_unique(&mut context, ".naome/verification.json");
+    }
+    context
+}
+
+pub(super) fn required_context_for_intent(intent: &IntentDecision) -> Vec<String> {
+    let mut context = intent.required_context.clone();
+    match intent.policy_action.as_str() {
+        "create_new_task" | "create_new_task_without_auto_baseline" => {
+            push_unique(&mut context, "docs/naome/agent-workflow.md");
+            push_unique(&mut context, "docs/naome/testing.md");
+            push_unique(&mut context, ".naome/verification.json");
+            push_unique(&mut context, "docs/naome/architecture.md");
+        }
+        "create_isolated_task_worktree" => {
+            push_unique(&mut context, "docs/naome/agent-workflow.md");
+            push_unique(&mut context, "docs/naome/testing.md");
+            push_unique(&mut context, ".naome/verification.json");
+            push_unique(&mut context, "docs/naome/architecture.md");
+        }
+        "auto_commit_completed_task_then_create_new_task"
+        | "auto_commit_completed_task_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_then_create_new_task"
+        | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_baseline"
+        | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+        | "reopen_completed_task_revision"
+        | "review_task_diff"
+        | "cancel_task_changes"
+        | "block_auto_baseline_due_to_no_commit" => {
+            push_unique(&mut context, "docs/naome/execution.md");
+            push_unique(&mut context, ".naome/task-state.json");
+        }
+        "answer_status_only" => {
+            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");
+        }
+        _ => {}
+    }
+    context
+}
+
+fn push_unique(context: &mut Vec<String>, value: &str) {
+    if !context.iter().any(|entry| entry == value) {
+        context.push(value.to_string());
+    }
+}

package/crates/naome-core/src/route/execution.rs

@@ -0,0 +1,96 @@
+use std::path::{Path, PathBuf};
+
+use crate::intent::IntentDecision;
+use crate::journal::TaskJournalEntry;
+use crate::models::{Decision, NaomeError};
+
+use super::execution_baselines::{
+    baseline_completed_task, baseline_completed_task_then_worktree, baseline_harness_refresh,
+    baseline_harness_refresh_then_completed_task, baseline_harness_refresh_then_worktree,
+    baseline_pure_harness_refresh, baseline_setup, commit_upgrade_baseline,
+};
+use super::execution_tasks::{
+    commit_user_diff, create_task_worktree, journal_external_baseline_if_needed,
+};
+use super::RouteWorktree;
+
+pub(super) struct RouteExecution {
+    pub(super) mutation_performed: bool,
+    pub(super) executed_actions: Vec<String>,
+    pub(super) journal_entry: Option<TaskJournalEntry>,
+    pub(super) user_message: String,
+    pub(super) task_root: PathBuf,
+    pub(super) worktree: Option<RouteWorktree>,
+    pub(super) route_allowed: bool,
+    pub(super) human_options: Vec<String>,
+}
+
+impl RouteExecution {
+    pub(super) fn from_intent(root: &Path, intent: &IntentDecision) -> Self {
+        Self {
+            mutation_performed: false,
+            executed_actions: Vec::new(),
+            journal_entry: None,
+            user_message: intent.user_message.clone(),
+            task_root: root.to_path_buf(),
+            worktree: None,
+            route_allowed: intent.allowed,
+            human_options: intent.human_options.clone(),
+        }
+    }
+
+    pub(super) fn mark_action(&mut self, action: &str) {
+        self.mutation_performed = true;
+        self.executed_actions.push(action.to_string());
+    }
+}
+
+pub(super) fn execute_route_policy(
+    root: &Path,
+    prompt: &str,
+    initial_decision: &Decision,
+    intent: &IntentDecision,
+    repo_state_before: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    match intent.policy_action.as_str() {
+        "auto_commit_completed_task_then_create_new_task" => baseline_completed_task(
+            root,
+            "route_auto_baseline",
+            "NAOME baselined the completed task and is ready to create the next task.",
+            execution,
+        ),
+        "auto_commit_completed_task_then_create_isolated_task_worktree" => {
+            baseline_completed_task_then_worktree(root, prompt, execution)
+        }
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            baseline_harness_refresh_then_completed_task(root, execution)
+        }
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => {
+            baseline_harness_refresh_then_worktree(root, prompt, execution)
+        }
+        "auto_commit_harness_refresh_then_create_new_task" => {
+            baseline_pure_harness_refresh(root, execution)
+        }
+        "auto_commit_harness_refresh_baseline" => baseline_harness_refresh(root, execution),
+        "auto_commit_upgrade_baseline_then_create_new_task" => baseline_setup(root, execution),
+        "commit_task_baseline" => baseline_completed_task(
+            root,
+            "naome_commit_baseline",
+            "NAOME baselined the completed task and is ready for the next request.",
+            execution,
+        ),
+        "commit_upgrade_baseline" => commit_upgrade_baseline(root, execution),
+        "create_isolated_task_worktree" => create_task_worktree(root, prompt, execution),
+        "commit_user_diff_with_quality_gate" => commit_user_diff(root, execution),
+        "create_new_task" | "create_new_task_without_auto_baseline" => {
+            journal_external_baseline_if_needed(
+                root,
+                initial_decision,
+                repo_state_before,
+                execution,
+            )
+        }
+        _ => Ok(()),
+    }
+}