@lamentis/naome 1.2.1 → 1.3.1

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

@@ -0,0 +1,183 @@
+use std::fs;
+use std::path::Path;
+
+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;
+
+use super::phases::verification_phase_plan;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DoctorReport {
+    pub schema: String,
+    pub ok: bool,
+    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>,
+    pub withheld_check_ids: Vec<String>,
+    pub next_action: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DoctorSection {
+    pub status: String,
+    pub messages: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+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> {
+    let harness_errors = validate_harness_health(
+        root,
+        HarnessHealthOptions {
+            allow_missing_integrity: true,
+            allow_missing_archive: true,
+            ..HarnessHealthOptions::default()
+        },
+    )?;
+    let task_report = validate_task_state(
+        root,
+        TaskStateOptions {
+            mode: TaskStateMode::State,
+            harness_health: None,
+        },
+    )?;
+    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",
+        ".naome/repository-quality-baseline.json",
+    );
+    let repository_structure = policy_section(root, ".naome/repository-structure.json", "");
+
+    let harness_health = section(harness_errors);
+    let task_state = section(task_report.errors);
+    let verification = section(verification_errors);
+    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,
+    );
+
+    Ok(DoctorReport {
+        schema: "naome.doctor.v1".to_string(),
+        ok,
+        harness_health,
+        task_state,
+        verification,
+        repository_model,
+        repository_quality,
+        repository_structure,
+        recommended_check_ids: phase_plan.recommended_check_ids,
+        withheld_check_ids: phase_plan.withheld_check_ids,
+        next_action,
+    })
+}
+
+fn section(messages: Vec<String>) -> DoctorSection {
+    DoctorSection {
+        status: if messages.is_empty() { "ok" } else { "blocked" }.to_string(),
+        messages,
+    }
+}
+
+fn policy_section(root: &Path, config_path: &str, baseline_path: &str) -> RepositoryPolicySection {
+    let config_present =
+        fs::metadata(root.join(config_path)).is_ok_and(|metadata| metadata.is_file());
+    let baseline_present = baseline_path.is_empty()
+        || fs::metadata(root.join(baseline_path)).is_ok_and(|metadata| metadata.is_file());
+    RepositoryPolicySection {
+        config_present,
+        baseline_present,
+        status: if config_present && baseline_present {
+            "ok"
+        } else {
+            "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 {
+    if task_state.status != "ok" {
+        return "Finish or resolve the active task before starting new work.".to_string();
+    }
+    if harness_health.status != "ok" {
+        return "Repair the NAOME harness before feature work.".to_string();
+    }
+    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();
+    }
+    "NAOME is ready for task work; follow the recommended verification phase order.".to_string()
+}

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

@@ -1,3 +1,6 @@
+mod agent;
+mod agent_types;
+mod doctor;
 mod integrity;
 mod integrity_normalize;
 mod integrity_support;
@@ -9,6 +12,16 @@ 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;
 pub use output::{summarize_command_output, CommandOutputSummary};

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

@@ -34,13 +34,12 @@ fn mutation_class(path: &str) -> &'static str {
     {
         return "local-only repair";
     }
-    if path.starts_with("packages/naome/templates/") || path.starts_with(".naome/bin/") {
+    if path.starts_with(".naome/bin/") {
         return "harness template";
     }
     if path.ends_with(".tgz")
         || path.starts_with("dist/")
         || path.contains("/dist/")
-        || path.starts_with("packages/naome/native/")
         || path.starts_with("native/")
     {
         return "release artifact";

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

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

@@ -18,7 +18,9 @@ const MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/index.md",
     "docs/naome/first-run.md",
     "docs/naome/agent-workflow.md",
+    "docs/naome/context-economy.md",
     "docs/naome/execution.md",
+    "docs/naome/task-ledger.md",
     "docs/naome/upgrade.md",
 ];
 
@@ -29,12 +31,14 @@ const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
+    ".naome/repository-model.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-model.md",
     "docs/naome/repository-quality.md",
     "docs/naome/repository-structure.md",
     "docs/naome/security.md",

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

@@ -8,6 +8,7 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert_eq!(plan.harness_version, "1.0.0");
     assert!(plan.machine_owned.contains(&"docs/naome/execution.md"));
     assert!(plan.project_owned.contains(&"docs/naome/architecture.md"));
+    assert!(!plan.project_owned.contains(&".naome/tasks/**"));
     assert!(plan
         .local_only_machine_owned
         .contains(&".naome/bin/check-task-state.js"));
@@ -18,6 +19,17 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert!(!plan
         .local_only_machine_owned
         .contains(&"docs/naome/architecture.md"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".codex/hooks.json"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".codex/config.toml"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".naome/bin/codex-hook.js"));
+    assert!(!plan.machine_owned.contains(&".naome/bin/codex-hook.js"));
+    assert!(!plan.project_owned.contains(&".codex/hooks.json"));
 }
 
 #[test]
@@ -28,6 +40,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .gitignore_entries
         .contains(&".naome/task-journal.jsonl"));
     assert!(plan.git_exclude_entries.contains(&".naome/archive/"));
+    assert!(plan.git_exclude_entries.contains(&".naome/cache/"));
     assert!(plan.git_exclude_entries.contains(&".naome/bin/naome-rust*"));
     assert!(plan
         .git_exclude_entries
@@ -36,6 +49,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
         .git_exclude_entries
         .contains(&".naome/bin/check-harness-health.js"));
     assert!(plan.git_untrack_paths.contains(&".naome/archive"));
+    assert!(plan.git_untrack_paths.contains(&".naome/cache"));
     assert!(plan.git_untrack_paths.contains(&".naome/bin/naome-rust"));
     assert!(plan
         .git_untrack_paths