@lamentis/naome 1.0.0

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

@@ -0,0 +1,297 @@
+use std::fs;
+use std::sync::Mutex;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{evaluate_decision, EvaluationOptions};
+use serde_json::json;
+
+static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+#[test]
+fn first_run_state_returns_protocol_action() {
+    let repo = TestRepo::new("first-run");
+    repo.write_naome_json("init-state.json", json!({ "initialized": false }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({ "status": "idle", "activeTask": null }),
+    );
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(decision.state, "first_run_required");
+    assert_eq!(decision.allowed_actions, vec!["run_first_run_protocol"]);
+    assert_eq!(
+        decision.next_action,
+        "Run the NAOME first-run protocol before feature work."
+    );
+}
+
+#[test]
+fn completed_task_diff_returns_baseline_choices() {
+    let repo = TestRepo::new("completed-task");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({
+            "status": "complete",
+            "activeTask": {
+                "id": "readme-task",
+                "allowedPaths": ["README.md"],
+                "requiredCheckIds": ["diff-check"],
+                "proofResults": []
+            }
+        }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file("README.md", "# Changed\n");
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(decision.state, "completed_task_unbaselined");
+    assert!(decision
+        .allowed_actions
+        .contains(&"commit_task_baseline".to_string()));
+    assert!(decision
+        .allowed_actions
+        .contains(&"request_task_changes".to_string()));
+    assert_eq!(decision.changed_paths, vec!["README.md"]);
+}
+
+#[test]
+fn idle_unowned_diff_blocks_new_feature_work() {
+    let repo = TestRepo::new("unowned-diff");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({ "status": "idle", "activeTask": null }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file("README.md", "# Manual change\n");
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(decision.state, "dirty_unowned_diff");
+    assert_eq!(
+        decision.allowed_actions,
+        vec!["review_unowned_diff", "clear_or_commit_unowned_diff"]
+    );
+    assert_eq!(decision.changed_paths, vec!["README.md"]);
+}
+
+#[test]
+fn changed_paths_handle_worktree_renames_without_corrupting_old_path_tokens() {
+    let repo = TestRepo::new("worktree-rename");
+    repo.init_git();
+    repo.write_file("packages/old/file.txt", "baseline\n");
+    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({ "status": "idle", "activeTask": null }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+
+    fs::create_dir_all(repo.path().join("packages/new")).unwrap();
+    fs::rename(
+        repo.path().join("packages/old/file.txt"),
+        repo.path().join("packages/new/file.txt"),
+    )
+    .unwrap();
+    repo.git(&["add", "-N", "packages/new/file.txt"]);
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert!(decision
+        .changed_paths
+        .contains(&"packages/new/file.txt".to_string()));
+    assert!(!decision
+        .changed_paths
+        .iter()
+        .any(|path| path == "ckages/old/file.txt" || path == "kages/old/file.txt"));
+}
+
+#[test]
+fn active_task_allows_control_state_and_untracked_files_inside_scope() {
+    let repo = TestRepo::new("active-scope");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({
+            "status": "implementing",
+            "activeTask": {
+                "id": "rust-task",
+                "allowedPaths": ["packages/naome/crates/naome-core/src/lib.rs"],
+                "requiredCheckIds": ["decision-engine-tests"],
+                "proofResults": []
+            }
+        }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file(
+        "packages/naome/crates/naome-core/src/lib.rs",
+        "pub fn marker() {}\n",
+    );
+    repo.write_naome_json(
+        "task-state.json",
+        json!({
+            "status": "implementing",
+            "activeTask": {
+                "id": "rust-task",
+                "allowedPaths": ["packages/naome/crates/naome-core/src/lib.rs"],
+                "requiredCheckIds": ["decision-engine-tests"],
+                "proofResults": []
+            }
+        }),
+    );
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(decision.state, "active_task_in_progress");
+    assert!(!decision.blocked);
+    assert_eq!(
+        decision.changed_paths,
+        vec!["packages/naome/crates/naome-core/src/lib.rs".to_string()]
+    );
+}
+
+#[test]
+fn changed_paths_exclude_naomeignore_matches() {
+    let repo = TestRepo::new("ignored-archive");
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n");
+    repo.write_naome_json("init-state.json", json!({ "initialized": false }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({ "status": "idle", "activeTask": null }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    repo.write_file(
+        ".naome/archive/AGENTS.pre-naome.md",
+        "# Archived instructions\n",
+    );
+
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::offline()).unwrap();
+
+    assert_eq!(decision.state, "first_run_required");
+    assert!(decision.changed_paths.is_empty());
+}
+
+#[cfg(unix)]
+#[test]
+fn online_checks_use_explicit_node_binary_from_environment() {
+    let _guard = ENV_LOCK.lock().unwrap();
+    let repo = TestRepo::new("explicit-node-bin");
+    repo.init_git();
+    repo.write_naome_json("init-state.json", json!({ "initialized": true }));
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "task-state.json",
+        json!({ "status": "idle", "activeTask": null }),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let fake_node = std::env::temp_dir().join(format!(
+        "naome-fake-node-{}-{}",
+        std::process::id(),
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    fs::write(&fake_node, "#!/bin/sh\nexit 0\n").unwrap();
+    let mut permissions = fs::metadata(&fake_node).unwrap().permissions();
+    use std::os::unix::fs::PermissionsExt;
+    permissions.set_mode(0o755);
+    fs::set_permissions(&fake_node, permissions).unwrap();
+
+    let previous = std::env::var_os("NAOME_NODE_BIN");
+    std::env::set_var("NAOME_NODE_BIN", &fake_node);
+    let decision = evaluate_decision(repo.path(), EvaluationOptions::online()).unwrap();
+    if let Some(value) = previous {
+        std::env::set_var("NAOME_NODE_BIN", value);
+    } else {
+        std::env::remove_var("NAOME_NODE_BIN");
+    }
+
+    assert_eq!(decision.state, "ready_for_task");
+    assert_eq!(
+        decision.harness_health.unwrap().command,
+        format!("{} .naome/bin/check-harness-health.js", fake_node.display())
+    );
+}
+
+struct TestRepo {
+    root: PathBuf,
+}
+
+impl TestRepo {
+    fn new(name: &str) -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let root = std::env::temp_dir().join(format!("naome-core-{name}-{nonce}"));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        Self { root }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    fn write_file(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        fs::write(path, content).unwrap();
+    }
+
+    fn write_naome_json(&self, file_name: &str, value: serde_json::Value) {
+        let path = self.root.join(".naome").join(file_name);
+        fs::write(
+            path,
+            format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
+        )
+        .unwrap();
+    }
+
+    fn init_git(&self) {
+        self.git(&["init"]);
+        self.git(&["config", "user.email", "naome@example.com"]);
+        self.git(&["config", "user.name", "NAOME Test"]);
+    }
+
+    fn git(&self, args: &[&str]) {
+        let output = Command::new("git")
+            .args(args)
+            .current_dir(&self.root)
+            .output()
+            .unwrap();
+        assert!(
+            output.status.success(),
+            "git {:?} failed\nstdout:\n{}\nstderr:\n{}",
+            args,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+}

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

@@ -0,0 +1,232 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{validate_harness_health, HarnessHealthOptions};
+use serde_json::json;
+use sha2::{Digest, Sha256};
+
+const MACHINE_OWNED_PATHS: &[&str] = &[
+    "AGENTS.md",
+    ".naome/package.json",
+    ".naome/bin/naome.js",
+    ".naome/bin/check-task-state.js",
+    ".naome/bin/check-harness-health.js",
+    ".naome/task-contract.schema.json",
+    "docs/naome/index.md",
+    "docs/naome/first-run.md",
+    "docs/naome/agent-workflow.md",
+    "docs/naome/execution.md",
+    "docs/naome/upgrade.md",
+];
+
+const PROJECT_OWNED_PATHS: &[&str] = &[
+    ".naomeignore",
+    ".naome/init-state.json",
+    ".naome/manifest.json",
+    ".naome/task-state.json",
+    ".naome/upgrade-state.json",
+    ".naome/verification.json",
+    "docs/naome/architecture.md",
+    "docs/naome/decisions.md",
+    "docs/naome/repo-profile.md",
+    "docs/naome/security.md",
+    "docs/naome/testing.md",
+];
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[test]
+fn accepts_healthy_harness_root() {
+    let repo = HarnessFixture::new();
+
+    let errors = validate_harness_health(repo.path(), options(repo.integrity.clone())).unwrap();
+
+    assert!(errors.is_empty(), "{errors:#?}");
+}
+
+#[test]
+fn accepts_missing_archive_directory_when_ignore_boundary_exists() {
+    let repo = HarnessFixture::new();
+    fs::remove_dir_all(repo.path().join(".naome/archive")).unwrap();
+
+    let errors = validate_harness_health(repo.path(), options(repo.integrity.clone())).unwrap();
+
+    assert!(errors.is_empty(), "{errors:#?}");
+}
+
+#[test]
+fn rejects_drifted_machine_owned_files() {
+    let repo = HarnessFixture::new();
+    repo.write("docs/naome/execution.md", "# Tampered\n");
+
+    let errors = validate_harness_health(repo.path(), options(repo.integrity.clone())).unwrap();
+    let joined = errors.join("\n");
+
+    assert!(joined.contains("integrity mismatch"));
+    assert!(joined.contains("docs/naome/execution.md"));
+}
+
+#[test]
+fn rejects_missing_archive_ignore_boundary() {
+    let repo = HarnessFixture::new();
+    repo.write(".naomeignore", "node_modules/\n");
+
+    let errors = validate_harness_health(repo.path(), options(repo.integrity.clone())).unwrap();
+    let joined = errors.join("\n");
+
+    assert!(joined.contains(".naomeignore must include .naome/archive/."));
+}
+
+#[cfg(unix)]
+#[test]
+fn rejects_symlinked_machine_owned_paths() {
+    let repo = HarnessFixture::new();
+    repo.write("external-execution.md", "# External\n");
+    fs::remove_file(repo.path().join("docs/naome/execution.md")).unwrap();
+    std::os::unix::fs::symlink(
+        repo.path().join("external-execution.md"),
+        repo.path().join("docs/naome/execution.md"),
+    )
+    .unwrap();
+
+    let errors = validate_harness_health(repo.path(), options(repo.integrity.clone())).unwrap();
+    let joined = errors.join("\n");
+
+    assert!(joined.contains("must not contain symlinks"));
+    assert!(joined.contains("docs/naome/execution.md"));
+}
+
+fn options(expected_integrity: HashMap<String, String>) -> HarnessHealthOptions {
+    HarnessHealthOptions {
+        expected_integrity,
+        allow_missing_integrity: false,
+        allow_missing_archive: false,
+    }
+}
+
+struct HarnessFixture {
+    root: PathBuf,
+    integrity: HashMap<String, String>,
+}
+
+impl HarnessFixture {
+    fn new() -> Self {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let counter = FIXTURE_COUNTER.fetch_add(1, Ordering::Relaxed);
+        let root = std::env::temp_dir().join(format!(
+            "naome-harness-health-{}-{nonce}-{counter}",
+            std::process::id()
+        ));
+        let mut integrity = HashMap::new();
+
+        for relative_path in MACHINE_OWNED_PATHS {
+            let content = machine_content(relative_path);
+            write_file(&root, relative_path, &content);
+            integrity.insert(
+                (*relative_path).to_string(),
+                format!("sha256:{}", sha256(&content)),
+            );
+        }
+
+        for relative_path in PROJECT_OWNED_PATHS {
+            let content = if *relative_path == ".naomeignore" {
+                ".naome/archive/\n".to_string()
+            } else {
+                format!("# {relative_path}\n")
+            };
+            write_file(&root, relative_path, &content);
+        }
+
+        fs::create_dir_all(root.join(".naome/archive")).unwrap();
+        write_file(
+            &root,
+            ".naome/manifest.json",
+            &format!(
+                "{}\n",
+                serde_json::to_string_pretty(&json!({
+                    "name": "naome",
+                    "harnessVersion": "0.6.1",
+                    "profile": "standard",
+                    "installedAt": "2026-05-05T00:00:00.000Z",
+                    "machineOwned": MACHINE_OWNED_PATHS,
+                    "projectOwned": PROJECT_OWNED_PATHS,
+                    "integrity": integrity
+                }))
+                .unwrap()
+            ),
+        );
+        write_file(
+            &root,
+            ".naome/task-state.json",
+            &format!(
+                "{}\n",
+                serde_json::to_string_pretty(&json!({
+                    "schema": "naome.task-state.v1",
+                    "version": 1,
+                    "status": "idle",
+                    "activeTask": null,
+                    "blocker": null,
+                    "updatedAt": null
+                }))
+                .unwrap()
+            ),
+        );
+        write_file(
+            &root,
+            ".naome/upgrade-state.json",
+            &format!(
+                "{}\n",
+                serde_json::to_string_pretty(&json!({
+                    "status": "complete",
+                    "fromVersion": null,
+                    "toVersion": "0.6.1",
+                    "pending": [],
+                    "completed": []
+                }))
+                .unwrap()
+            ),
+        );
+
+        Self { root, integrity }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    fn write(&self, relative_path: &str, content: &str) {
+        write_file(&self.root, relative_path, content);
+    }
+}
+
+fn machine_content(relative_path: &str) -> String {
+    match relative_path {
+        "AGENTS.md" => [
+            "# Agent Instructions",
+            "Run node .naome/bin/check-harness-health.js before feature work.",
+            "Run node .naome/bin/check-task-state.js --admission before task work.",
+            "",
+        ]
+        .join("\n"),
+        ".naome/package.json" => format!("{}\n", json!({ "type": "commonjs" })),
+        _ => format!("# {relative_path}\n"),
+    }
+}
+
+fn write_file(root: &Path, relative_path: &str, content: &str) {
+    let path = root.join(relative_path);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, content).unwrap();
+}
+
+fn sha256(content: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(content.as_bytes());
+    format!("{:x}", hasher.finalize())
+}

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

@@ -0,0 +1,35 @@
+use naome_core::install_plan;
+
+#[test]
+fn install_plan_marks_machine_docs_and_bins_local_only() {
+    let plan = install_plan("1.0.0");
+
+    assert_eq!(plan.schema, "naome.install-plan.v1");
+    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
+        .local_only_machine_owned
+        .contains(&".naome/bin/check-task-state.js"));
+    assert!(plan
+        .local_only_machine_owned
+        .contains(&"docs/naome/execution.md"));
+    assert!(!plan.local_only_machine_owned.contains(&"AGENTS.md"));
+    assert!(!plan
+        .local_only_machine_owned
+        .contains(&"docs/naome/architecture.md"));
+}
+
+#[test]
+fn install_plan_includes_gitignore_and_untrack_policy() {
+    let plan = install_plan("1.0.0");
+
+    assert!(plan.gitignore_entries.contains(&".naome/archive/"));
+    assert!(plan.gitignore_entries.contains(&".naome/bin/naome-rust*"));
+    assert!(plan
+        .gitignore_entries
+        .contains(&".naome/bin/check-harness-health.js"));
+    assert!(plan.git_untrack_paths.contains(&".naome/archive"));
+    assert!(plan.git_untrack_paths.contains(&".naome/bin/naome-rust"));
+    assert!(plan.git_untrack_paths.contains(&"docs/naome/first-run.md"));
+}