@lamentis/naome 1.1.1 → 1.2.0

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

@@ -203,6 +203,138 @@ fn execute_route_commits_user_diff_after_quality_gate_passes() {
     assert!(route.user_message.contains("quality gates passed"));
 }
 
+#[test]
+fn execute_route_runs_repository_quality_check_without_shelling_to_repo_command() {
+    let repo = TestRepo::new("route-repository-quality-check");
+    repo.init_git();
+    repo.write_file(
+        ".naome/repository-quality.json",
+        r#"{
+  "schema": "naome.repository-quality.v1",
+  "version": 1,
+  "status": "ready",
+  "limits": {
+    "maxFileLines": 5,
+    "maxNewFileLines": 5,
+    "maxDiffAddedLines": 200,
+    "maxFunctionLines": 40,
+    "maxTopLevelSymbols": 30,
+    "duplicateBlockLines": 4,
+    "nearDuplicateSimilarity": 0.9
+  },
+  "disabledChecks": [],
+  "ignoredPaths": [],
+  "generatedPaths": []
+}
+"#,
+    );
+    repo.write_file(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n}\n",
+    );
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_naome_json(
+        "verification.json",
+        json!({
+            "schema": "naome.verification.v1",
+            "version": 1,
+            "status": "ready",
+            "checks": [
+                {
+                    "id": "repository-quality-check",
+                    "command": "naome quality check --changed",
+                    "cwd": ".",
+                    "purpose": "Validate changed files against repository quality rules.",
+                    "cost": "fast",
+                    "source": "NAOME built-in",
+                    "evidence": ["src/**"],
+                    "lastVerified": null
+                }
+            ],
+            "changeTypes": [
+                {
+                    "id": "source",
+                    "description": "Source changes.",
+                    "paths": ["src/**"],
+                    "requiredChecks": ["repository-quality-check"],
+                    "recommendedChecks": [],
+                    "humanReview": false
+                }
+            ],
+            "releaseGates": []
+        }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file(
+        "src/large.js",
+        "export function legacy() {\n  one();\n  two();\n  three();\n  four();\n  five();\n}\n",
+    );
+    let before_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+
+    let route = evaluate_route(
+        repo.path(),
+        "commit my changes",
+        RouteOptions {
+            execute: true,
+            evaluation: EvaluationOptions::offline(),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
+    assert!(!route.allowed);
+    assert!(!route.mutation_performed);
+    assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
+    assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
+    assert!(route.user_message.contains("repository-quality-check"));
+    assert!(route.user_message.contains("file-length"));
+}
+
+#[test]
+fn execute_route_commits_product_diff_with_declared_safe_quality_checks() {
+    let repo = TestRepo::new("route-product-diff-quality-pass");
+    repo.init_git();
+    repo.write_file(
+        "packages/naome/crates/naome-core/src/route.rs",
+        "pub fn baseline() {}\n",
+    );
+    repo.write_base_naome_state(json!({ "status": "idle", "activeTask": null }));
+    repo.write_product_quality_verification();
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file(
+        "packages/naome/crates/naome-core/src/route.rs",
+        "pub fn changed() {}\n",
+    );
+
+    let route = evaluate_route(
+        repo.path(),
+        "commit my changes",
+        RouteOptions {
+            execute: true,
+            evaluation: EvaluationOptions::offline(),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(route.policy_action, "commit_user_diff_with_quality_gate");
+    assert!(route.allowed);
+    assert!(route.mutation_performed);
+    assert_eq!(
+        route.executed_actions,
+        vec![
+            "run_user_diff_quality_gate".to_string(),
+            "commit_user_diff".to_string()
+        ]
+    );
+    assert_eq!(repo.git_status_short(), "");
+
+    let committed_paths = repo.git_stdout(&["show", "--name-only", "--format=", "HEAD"]);
+    assert!(committed_paths.contains("packages/naome/crates/naome-core/src/route.rs"));
+    assert!(route.user_message.contains("quality gates passed"));
+}
+
 #[test]
 fn execute_route_preserves_staged_rename_when_committing_user_diff() {
     let repo = TestRepo::new("route-user-diff-staged-rename");
@@ -334,11 +466,17 @@ fn execute_route_refuses_user_diff_commit_when_check_mutates_after_diff_check()
     assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
     assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
     assert!(repo.git_status_short().contains("README.md"));
-    assert!(route.user_message.contains("trailing whitespace"));
+    assert_eq!(
+        fs::read_to_string(repo.path().join("README.md")).unwrap(),
+        "# Manual edit\n"
+    );
+    assert!(route
+        .user_message
+        .contains("will not execute repository-controlled verification commands"));
 }
 
 #[test]
-fn execute_route_refuses_user_diff_commit_when_diff_check_adds_paths() {
+fn execute_route_refuses_user_diff_commit_when_diff_check_command_is_unsafe() {
     let repo = TestRepo::new("route-user-diff-mutating-diff-check");
     repo.init_git();
     repo.write_file("README.md", "# Baseline\n");
@@ -394,10 +532,10 @@ fn execute_route_refuses_user_diff_commit_when_diff_check_adds_paths() {
     assert!(!route.mutation_performed);
     assert_eq!(route.executed_actions, vec!["run_user_diff_quality_gate"]);
     assert_eq!(repo.git_stdout(&["rev-parse", "HEAD"]), before_head);
-    assert!(repo.git_status_short().contains("NEW.md"));
+    assert!(!repo.path().join("NEW.md").exists());
     assert!(route
         .user_message
-        .contains("Quality checks changed the diff path set"));
+        .contains("Quality check diff-check has an unsafe command or cwd"));
 }
 
 #[test]
@@ -1050,6 +1188,85 @@ impl TestRepo {
         );
     }
 
+    fn write_product_quality_verification(&self) {
+        self.write_naome_json(
+            "verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "checks": [
+                    {
+                        "id": "installer-tests",
+                        "command": "npm run test:naome-installer",
+                        "cwd": ".",
+                        "purpose": "Validate installer behavior.",
+                        "cost": "medium",
+                        "source": "test",
+                        "evidence": ["scripts/naome-installer.test.js"],
+                        "lastVerified": null
+                    },
+                    {
+                        "id": "rust-build",
+                        "command": "npm run build:rust",
+                        "cwd": ".",
+                        "purpose": "Build native CLI.",
+                        "cost": "medium",
+                        "source": "test",
+                        "evidence": ["packages/naome/Cargo.toml"],
+                        "lastVerified": null
+                    },
+                    {
+                        "id": "decision-engine-tests",
+                        "command": "npm run test:decision-engine",
+                        "cwd": ".",
+                        "purpose": "Validate route decisions.",
+                        "cost": "fast",
+                        "source": "test",
+                        "evidence": ["packages/naome/crates/naome-core/tests/route.rs"],
+                        "lastVerified": null
+                    },
+                    {
+                        "id": "package-dry-run",
+                        "command": "npm run pack:dry-run",
+                        "cwd": ".",
+                        "purpose": "Validate package metadata.",
+                        "cost": "medium",
+                        "source": "test",
+                        "evidence": ["packages/naome/package.json"],
+                        "lastVerified": null
+                    },
+                    {
+                        "id": "diff-check",
+                        "command": "git diff --check",
+                        "cwd": ".",
+                        "purpose": "Reject whitespace errors.",
+                        "cost": "fast",
+                        "source": "test",
+                        "evidence": ["packages/naome/crates/naome-core/src/route.rs"],
+                        "lastVerified": null
+                    }
+                ],
+                "changeTypes": [
+                    {
+                        "id": "product-installer-or-template",
+                        "description": "NAOME product changes.",
+                        "paths": ["packages/naome/**", "scripts/**"],
+                        "requiredChecks": [
+                            "installer-tests",
+                            "rust-build",
+                            "decision-engine-tests",
+                            "package-dry-run"
+                        ],
+                        "recommendedChecks": [],
+                        "humanReview": false
+                    }
+                ],
+                "releaseGates": []
+            }),
+        );
+    }
+
     fn write_naome_json(&self, file_name: &str, value: serde_json::Value) {
         let path = self.root.join(".naome").join(file_name);
         fs::write(

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

@@ -32,9 +32,12 @@ const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
+    ".naome/repository-quality.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/security.md",
     "docs/naome/testing.md",
 ];

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

@@ -0,0 +1,110 @@
+mod task_state_compact_support;
+
+use naome_core::{evaluate_route, EvaluationOptions, RouteOptions, TaskStateMode};
+use serde_json::{json, Value};
+use task_state_compact_support::{
+    compact_state, large_compact_state, large_expanded_state, legacy_state, MiniRepo,
+};
+
+#[test]
+fn legacy_v1_proof_results_remain_valid() {
+    let repo = MiniRepo::new();
+    let head = repo.seed();
+    repo.change_readme();
+    repo.write_task_state(legacy_state(&head));
+
+    let report = repo.validate(TaskStateMode::State);
+
+    assert_eq!(report.errors, Vec::<String>::new());
+}
+
+#[test]
+fn compact_path_sets_and_batches_cover_completion_commit_and_route() {
+    let repo = MiniRepo::new();
+    let head = repo.seed();
+    repo.change_readme();
+    repo.write_task_state(compact_state(&head));
+
+    let completion = repo.validate(TaskStateMode::State);
+    assert_eq!(completion.errors, Vec::<String>::new());
+
+    let route = evaluate_route(
+        repo.path(),
+        "new task",
+        RouteOptions {
+            execute: false,
+            evaluation: EvaluationOptions::offline(),
+        },
+    )
+    .unwrap();
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_completed_task_then_create_new_task"
+    );
+
+    repo.git(["add", "README.md", ".naome/task-state.json"]);
+    let commit_gate = repo.validate(TaskStateMode::CommitGate);
+    assert_eq!(commit_gate.errors, Vec::<String>::new());
+}
+
+#[test]
+fn compact_missing_required_proof_is_reported() {
+    let repo = MiniRepo::new();
+    let head = repo.seed();
+    repo.change_readme();
+    let mut state = compact_state(&head);
+    state["activeTask"]["proofBatches"][0]["proofs"] = json!([
+        {
+            "checkId": "alpha",
+            "exitCode": 0
+        }
+    ]);
+    repo.write_task_state(state);
+
+    let report = repo.validate(TaskStateMode::State);
+
+    assert!(
+        report
+            .errors
+            .iter()
+            .any(|error| error.contains("missing proof result: beta")),
+        "{:?}",
+        report.errors
+    );
+}
+
+#[test]
+fn compact_missing_evidence_is_reported() {
+    let repo = MiniRepo::new();
+    let head = repo.seed();
+    repo.change_readme();
+    let mut state = compact_state(&head);
+    state["activeTask"]["proofBatches"][0]["evidencePathSet"] = Value::Null;
+    state["activeTask"]["proofBatches"][0]["proofs"][0]["evidencePathSet"] = Value::Null;
+    repo.write_task_state(state);
+
+    let report = repo.validate(TaskStateMode::State);
+
+    assert!(
+        report
+            .errors
+            .iter()
+            .any(|error| error.contains("evidence must be an evidence array or path-set reference")),
+        "{:?}",
+        report.errors
+    );
+}
+
+#[test]
+fn compact_writer_payload_is_smaller_than_expanded_equivalent() {
+    let compact = large_compact_state("abcdef");
+    let expanded = large_expanded_state("abcdef");
+
+    let compact_len = serde_json::to_string(&compact).unwrap().len();
+    let expanded_len = serde_json::to_string(&expanded).unwrap().len();
+
+    assert!(
+        compact_len * 100 / expanded_len < 75,
+        "compact={compact_len} expanded={expanded_len}"
+    );
+}

package/crates/naome-core/tests/task_state_compact_support/mod.rs

@@ -0,0 +1,5 @@
+pub mod repo;
+pub mod states;
+
+pub use repo::MiniRepo;
+pub use states::{compact_state, large_compact_state, large_expanded_state, legacy_state};

package/crates/naome-core/tests/task_state_compact_support/repo.rs

@@ -0,0 +1,130 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{validate_task_state, TaskStateMode, TaskStateOptions};
+use serde_json::{json, Value};
+
+static REPO_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+pub struct MiniRepo {
+    root: PathBuf,
+}
+
+impl MiniRepo {
+    pub fn new() -> Self {
+        let stamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = REPO_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let root = std::env::temp_dir().join(format!("naome-compact-proof-{stamp}-{counter}"));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        let repo = Self { root };
+        repo.git(["init"]);
+        repo.git(["config", "user.email", "compact@example.test"]);
+        repo.git(["config", "user.name", "Compact Proof"]);
+        repo
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.root
+    }
+
+    pub fn seed(&self) -> String {
+        fs::write(self.root.join(".naomeignore"), "").unwrap();
+        fs::write(self.root.join("README.md"), "before\n").unwrap();
+        fs::write(
+            self.root.join(".naome/init-state.json"),
+            json_text(json!({
+                "schema": "naome.init-state.v1",
+                "version": 1,
+                "initialized": true,
+                "intakeStatus": "complete"
+            })),
+        )
+        .unwrap();
+        fs::write(
+            self.root.join(".naome/upgrade-state.json"),
+            json_text(json!({
+                "schema": "naome.upgrade-state.v1",
+                "version": 1,
+                "status": "complete",
+                "fromVersion": "1.1.2",
+                "toVersion": "1.2.0",
+                "pending": [],
+                "completed": []
+            })),
+        )
+        .unwrap();
+        fs::write(
+            self.root.join(".naome/verification.json"),
+            json_text(verification_contract()),
+        )
+        .unwrap();
+        self.git(["add", "."]);
+        self.git(["commit", "-m", "seed"]);
+        self.git_stdout(["rev-parse", "HEAD"])
+    }
+
+    pub fn change_readme(&self) {
+        fs::write(self.root.join("README.md"), "after\n").unwrap();
+    }
+
+    pub fn write_task_state(&self, state: Value) {
+        fs::write(self.root.join(".naome/task-state.json"), json_text(state)).unwrap();
+    }
+
+    pub fn validate(&self, mode: TaskStateMode) -> naome_core::TaskStateReport {
+        validate_task_state(
+            &self.root,
+            TaskStateOptions {
+                mode,
+                harness_health: None,
+            },
+        )
+        .unwrap()
+    }
+
+    pub fn git<const N: usize>(&self, args: [&str; N]) {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "{}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    fn git_stdout<const N: usize>(&self, args: [&str; N]) -> String {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(output.status.success());
+        String::from_utf8_lossy(&output.stdout).trim().to_string()
+    }
+}
+
+fn verification_contract() -> Value {
+    json!({
+        "schema": "naome.verification.v1",
+        "version": 1,
+        "status": "ready",
+        "checks": [
+            { "id": "alpha", "command": "npm run alpha", "cwd": ".", "evidence": ["README.md"] },
+            { "id": "beta", "command": "npm run beta", "cwd": ".", "evidence": ["README.md"] }
+        ],
+        "changeTypes": []
+    })
+}
+
+fn json_text(value: Value) -> String {
+    format!("{}\n", serde_json::to_string_pretty(&value).unwrap())
+}

package/crates/naome-core/tests/task_state_compact_support/states.rs

@@ -0,0 +1,151 @@
+use serde_json::{json, Value};
+
+const T0: &str = "2026-05-07T00:00:00.000Z";
+
+pub fn compact_state(admission_head: &str) -> Value {
+    base_state(
+        admission_head,
+        json!({
+            "proofPathSets": {
+                "changed-readme": ["README.md"]
+            },
+            "proofBatches": [
+                {
+                    "checkedAt": T0,
+                    "evidencePathSet": "changed-readme",
+                    "proofs": [
+                        {
+                            "checkId": "alpha",
+                            "exitCode": 0
+                        },
+                        {
+                            "checkId": "beta",
+                            "command": "npm run beta -- --changed README.md",
+                            "cwd": "tools",
+                            "exitCode": 0
+                        }
+                    ]
+                }
+            ]
+        }),
+    )
+}
+
+pub fn legacy_state(admission_head: &str) -> Value {
+    let mut state = base_state(
+        admission_head,
+        json!({
+            "proofResults": [
+                proof("alpha", "npm run alpha", "."),
+                proof("beta", "npm run beta", ".")
+            ]
+        }),
+    );
+    state["schema"] = json!("naome.task-state.v1");
+    state["version"] = json!(1);
+    state
+}
+
+pub fn large_compact_state(admission_head: &str) -> Value {
+    let evidence: Vec<Value> = (0..12)
+        .map(|index| json!(format!("src/module_{index}.rs")))
+        .collect();
+    let proofs: Vec<Value> = (0..8)
+        .map(|index| {
+            json!({
+                "checkId": format!("check-{index}"),
+                "exitCode": 0
+            })
+        })
+        .collect();
+    base_state(
+        admission_head,
+        json!({
+            "proofPathSets": {
+                "large-change": evidence
+            },
+            "proofBatches": [
+                {
+                    "checkedAt": T0,
+                    "command": "cargo test",
+                    "cwd": ".",
+                    "evidencePathSet": "large-change",
+                    "proofs": proofs
+                }
+            ]
+        }),
+    )
+}
+
+pub fn large_expanded_state(admission_head: &str) -> Value {
+    let evidence: Vec<Value> = (0..12)
+        .map(|index| json!(format!("src/module_{index}.rs")))
+        .collect();
+    let proofs: Vec<Value> = (0..8)
+        .map(|index| {
+            json!({
+                "checkId": format!("check-{index}"),
+                "command": "cargo test",
+                "cwd": ".",
+                "exitCode": 0,
+                "checkedAt": T0,
+                "evidence": evidence
+            })
+        })
+        .collect();
+    base_state(
+        admission_head,
+        json!({
+            "proofResults": proofs
+        }),
+    )
+}
+
+fn base_state(admission_head: &str, proof_payload: Value) -> Value {
+    let mut task = json!({
+        "id": "compact-proof",
+        "request": "Update README.",
+        "userPrompt": {
+            "receivedAt": T0,
+            "text": "Update README."
+        },
+        "admission": {
+            "command": "node .naome/bin/check-task-state.js --admission",
+            "cwd": ".",
+            "exitCode": 0,
+            "checkedAt": T0,
+            "gitHead": admission_head,
+            "changedPaths": []
+        },
+        "allowedPaths": ["README.md"],
+        "declaredChangeTypes": ["docs"],
+        "requiredCheckIds": ["alpha", "beta"],
+        "humanReview": {
+            "required": false,
+            "approved": false,
+            "reason": null
+        }
+    });
+    task.as_object_mut()
+        .unwrap()
+        .extend(proof_payload.as_object().unwrap().clone());
+    json!({
+        "schema": "naome.task-state.v2",
+        "version": 2,
+        "status": "complete",
+        "activeTask": task,
+        "blocker": null,
+        "updatedAt": T0
+    })
+}
+
+fn proof(check_id: &str, command: &str, cwd: &str) -> Value {
+    json!({
+        "checkId": check_id,
+        "command": command,
+        "cwd": cwd,
+        "exitCode": 0,
+        "checkedAt": T0,
+        "evidence": ["README.md"]
+    })
+}