@lamentis/naome 1.0.0

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

@@ -0,0 +1,588 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use naome_core::{validate_task_state, HarnessHealthOptions, TaskStateMode, TaskStateOptions};
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+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",
+];
+
+#[test]
+fn accepts_idle_task_state_template() {
+    let repo = TaskFixture::new(idle_task_state());
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+}
+
+#[test]
+fn admission_blocks_dirty_idle_worktree() {
+    let repo = TaskFixture::new(idle_task_state());
+    repo.init_git();
+    repo.write("README.md", "# Dirty baseline\n");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Admission,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("Task admission requires a clean git diff"));
+    assert!(joined.contains("README.md"));
+    assert!(joined.contains("review_task_diff"));
+}
+
+#[test]
+fn admission_blocks_clean_repo_when_harness_is_unhealthy() {
+    let repo = TaskFixture::new(idle_task_state());
+    let integrity = repo.install_healthy_harness();
+    repo.init_git();
+    repo.write("docs/naome/execution.md", "# Tampered\n");
+    repo.git(["add", "docs/naome/execution.md"]);
+    repo.git(["commit", "-m", "tamper harness"]);
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Admission,
+            harness_health: Some(strict_health_options(integrity)),
+        },
+    )
+    .unwrap();
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("Harness health failed"));
+    assert!(joined.contains("docs/naome/execution.md"));
+    assert!(joined.contains("repair_harness"));
+    assert!(joined.contains("review_harness_health"));
+}
+
+#[test]
+fn accepts_complete_task_with_scoped_diff_and_notice() {
+    let repo = TaskFixture::new(complete_task_state(json!({
+        "allowedPaths": ["README.md"],
+        "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+    })));
+    repo.init_git();
+    repo.write("README.md", "# Test\n");
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+    assert!(report
+        .notices
+        .join("\n")
+        .contains("Next task admission is blocked"));
+}
+
+#[test]
+fn commit_gate_blocks_normal_task_commit_when_harness_is_unhealthy() {
+    let repo = TaskFixture::new(complete_task_state(json!({
+        "allowedPaths": ["README.md"],
+        "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+    })));
+    let integrity = repo.install_healthy_harness();
+    repo.init_git();
+    repo.write("docs/naome/execution.md", "# Tampered\n");
+    repo.git(["add", "docs/naome/execution.md"]);
+    repo.git(["commit", "-m", "tamper harness"]);
+    repo.write("README.md", "# Task result\n");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::CommitGate,
+            harness_health: Some(strict_health_options(integrity)),
+        },
+    )
+    .unwrap();
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("Harness health failed"));
+    assert!(joined.contains("docs/naome/execution.md"));
+    assert!(joined.contains("repair_harness"));
+}
+
+#[test]
+fn commit_gate_allows_install_baseline_with_gitignore_and_project_owned_paths() {
+    let repo = TaskFixture::new(idle_task_state());
+    repo.write_json(
+        ".naome/init-state.json",
+        json!({
+            "initialized": false,
+            "intakeStatus": "not_started",
+            "initializedAt": null,
+            "initializedBy": null,
+            "blockedReason": null,
+            "requiredDocs": []
+        }),
+    );
+    repo.init_git();
+    repo.write(
+        ".gitignore",
+        "# NAOME local machine-owned harness files.\n.naome/archive/\n",
+    );
+    repo.write("AGENTS.md", "# Agent Instructions\n");
+    repo.write("docs/naome/architecture.md", "# Architecture\n");
+    repo.write("docs/naome/testing.md", "# Testing\n");
+    repo.write_json(
+        ".naome/verification.json",
+        json!({
+            "schema": "naome.verification.v1",
+            "version": 1,
+            "status": "ready",
+            "lastUpdated": "2026-05-05",
+            "checks": [],
+            "changeTypes": [],
+            "releaseGates": []
+        }),
+    );
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::CommitGate,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+}
+
+#[test]
+fn progress_accepts_implementing_task_with_scoped_diff_without_proof() {
+    let repo = TaskFixture::new(json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "implementing",
+        "activeTask": active_task(json!({
+            "allowedPaths": ["README.md"],
+            "proofResults": []
+        })),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    }));
+    repo.init_git();
+    repo.write("README.md", "# In progress\n");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Progress,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+}
+
+#[test]
+fn progress_rejects_in_flight_work_outside_scope() {
+    let repo = TaskFixture::new(json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "implementing",
+        "activeTask": active_task(json!({
+            "allowedPaths": ["README.md"],
+            "proofResults": []
+        })),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    }));
+    repo.init_git();
+    repo.write("src/session.js", "export const session = null;\n");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Progress,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("Changed files outside allowedPaths"));
+    assert!(joined.contains("src/session.js"));
+}
+
+#[test]
+fn rejects_complete_task_when_evidence_omits_changed_allowed_path() {
+    let repo = TaskFixture::new(complete_task_state(json!({
+        "allowedPaths": ["packages/next/README.md"],
+        "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+    })));
+    repo.write("README.md", "# Root README\n");
+    repo.write("packages/next/README.md", "# Package README\n");
+    repo.init_git();
+    repo.write("packages/next/README.md", "# Package README\n\nSmoke.\n");
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("evidence missing changed allowed paths"));
+    assert!(joined.contains("packages/next/README.md"));
+}
+
+#[test]
+fn accepts_committed_deleted_file_evidence_after_task_baseline_is_clean() {
+    let repo = TaskFixture::new(idle_task_state());
+    repo.write(
+        "docs/naome/deleted-file-evidence.tmp",
+        "temporary fixture\n",
+    );
+    repo.init_git();
+    let admission_head = repo.git(["rev-parse", "HEAD"]).trim().to_string();
+    fs::remove_file(repo.path().join("docs/naome/deleted-file-evidence.tmp")).unwrap();
+    repo.write_json(
+        ".naome/task-state.json",
+        complete_task_state(json!({
+            "admission": successful_admission(json!({ "gitHead": admission_head })),
+            "allowedPaths": ["docs/naome/deleted-file-evidence.tmp"],
+            "proofResults": [
+                successful_proof(json!({
+                    "evidence": [
+                        {
+                            "path": "docs/naome/deleted-file-evidence.tmp",
+                            "status": "deleted"
+                        }
+                    ]
+                }))
+            ]
+        })),
+    );
+    repo.git(["add", "-A"]);
+    repo.git(["commit", "-m", "baseline deleted evidence"]);
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+}
+
+struct TaskFixture {
+    root: PathBuf,
+}
+
+impl TaskFixture {
+    fn new(task_state: Value) -> 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-task-state-rust-{}-{nonce}-{counter}",
+            std::process::id()
+        ));
+        fs::create_dir_all(root.join(".naome")).unwrap();
+        write_json(&root, ".naome/task-state.json", task_state);
+        write_json(
+            &root,
+            ".naome/init-state.json",
+            json!({
+                "initialized": true,
+                "intakeStatus": "complete",
+                "initializedAt": "2026-05-04T12:00:00.000Z",
+                "initializedBy": "naome-test",
+                "blockedReason": null,
+                "requiredDocs": []
+            }),
+        );
+        write_json(
+            &root,
+            ".naome/upgrade-state.json",
+            json!({
+                "status": "complete",
+                "fromVersion": null,
+                "toVersion": "0.6.1",
+                "pending": [],
+                "completed": []
+            }),
+        );
+        write_json(
+            &root,
+            ".naome/verification.json",
+            json!({
+                "schema": "naome.verification.v1",
+                "version": 1,
+                "status": "ready",
+                "lastUpdated": "2026-05-04",
+                "checks": [
+                    {
+                        "id": "diff-check",
+                        "command": "git diff --check",
+                        "cwd": ".",
+                        "purpose": "Detect whitespace and patch formatting issues.",
+                        "cost": "fast",
+                        "source": "git",
+                        "evidence": ["README.md"],
+                        "lastVerified": "2026-05-04"
+                    }
+                ],
+                "changeTypes": [],
+                "releaseGates": []
+            }),
+        );
+        Self { root }
+    }
+
+    fn path(&self) -> &Path {
+        &self.root
+    }
+
+    fn write(&self, relative_path: &str, content: &str) {
+        let path = self.root.join(relative_path);
+        fs::create_dir_all(path.parent().unwrap()).unwrap();
+        fs::write(path, content).unwrap();
+    }
+
+    fn write_json(&self, relative_path: &str, value: Value) {
+        write_json(&self.root, relative_path, value);
+    }
+
+    fn install_healthy_harness(&self) -> HashMap<String, String> {
+        let mut integrity = HashMap::new();
+
+        for relative_path in MACHINE_OWNED_PATHS {
+            let content = machine_content(relative_path);
+            self.write(relative_path, &content);
+            integrity.insert(
+                (*relative_path).to_string(),
+                format!("sha256:{}", sha256(&content)),
+            );
+        }
+
+        for relative_path in PROJECT_OWNED_PATHS {
+            let path = self.root.join(relative_path);
+            if *relative_path == ".naome/manifest.json" || path.exists() {
+                continue;
+            }
+            let content = if *relative_path == ".naomeignore" {
+                ".naome/archive/\n".to_string()
+            } else {
+                format!("# {relative_path}\n")
+            };
+            self.write(relative_path, &content);
+        }
+
+        fs::create_dir_all(self.root.join(".naome/archive")).unwrap();
+        self.write_json(
+            ".naome/manifest.json",
+            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
+            }),
+        );
+
+        integrity
+    }
+
+    fn init_git(&self) {
+        self.git(["init"]);
+        self.git(["config", "user.email", "naome@example.com"]);
+        self.git(["config", "user.name", "NAOME Test"]);
+        self.git(["add", "."]);
+        self.git(["commit", "-m", "baseline"]);
+        self.refresh_admission_head();
+    }
+
+    fn refresh_admission_head(&self) {
+        let path = self.root.join(".naome/task-state.json");
+        let mut task_state: Value =
+            serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+        let Some(active_task) = task_state.get_mut("activeTask") else {
+            return;
+        };
+        let Some(admission) = active_task.get_mut("admission") else {
+            return;
+        };
+
+        admission["gitHead"] = Value::String(self.git(["rev-parse", "HEAD"]).trim().to_string());
+        fs::write(
+            path,
+            format!("{}\n", serde_json::to_string_pretty(&task_state).unwrap()),
+        )
+        .unwrap();
+    }
+
+    fn git<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(),
+            "{}\n{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+        String::from_utf8_lossy(&output.stdout).to_string()
+    }
+}
+
+fn strict_health_options(expected_integrity: HashMap<String, String>) -> HarnessHealthOptions {
+    HarnessHealthOptions {
+        expected_integrity,
+        allow_missing_integrity: false,
+        allow_missing_archive: false,
+    }
+}
+
+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 sha256(content: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(content.as_bytes());
+    format!("{:x}", hasher.finalize())
+}
+
+fn write_json(root: &Path, relative_path: &str, value: Value) {
+    let path = root.join(relative_path);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(
+        path,
+        format!("{}\n", serde_json::to_string_pretty(&value).unwrap()),
+    )
+    .unwrap();
+}
+
+fn idle_task_state() -> Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "idle",
+        "activeTask": null,
+        "blocker": null,
+        "updatedAt": null
+    })
+}
+
+fn complete_task_state(overrides: Value) -> Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "complete",
+        "activeTask": active_task(overrides),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    })
+}
+
+fn active_task(overrides: Value) -> Value {
+    let mut task = json!({
+        "id": "readme-test",
+        "request": "Update the README.",
+        "userPrompt": {
+            "receivedAt": "2026-05-04T12:00:00.000Z",
+            "text": "Update the README."
+        },
+        "admission": successful_admission(json!({})),
+        "allowedPaths": ["README.md"],
+        "declaredChangeTypes": ["docs"],
+        "requiredCheckIds": ["diff-check"],
+        "proofResults": [],
+        "humanReview": {
+            "required": false,
+            "approved": false,
+            "reason": null
+        }
+    });
+    merge_object(&mut task, overrides);
+    task
+}
+
+fn successful_admission(overrides: Value) -> Value {
+    let mut admission = json!({
+        "command": "node .naome/bin/check-task-state.js --admission",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-04T12:00:00.000Z",
+        "gitHead": "pending-test-head",
+        "changedPaths": []
+    });
+    merge_object(&mut admission, overrides);
+    admission
+}
+
+fn successful_proof(overrides: Value) -> Value {
+    let mut proof = json!({
+        "checkId": "diff-check",
+        "command": "git diff --check",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-04T12:00:00.000Z",
+        "evidence": ["README.md"]
+    });
+    merge_object(&mut proof, overrides);
+    proof
+}
+
+fn merge_object(target: &mut Value, overrides: Value) {
+    let Some(target_object) = target.as_object_mut() else {
+        return;
+    };
+    let Some(overrides_object) = overrides.as_object() else {
+        return;
+    };
+
+    for (key, value) in overrides_object {
+        target_object.insert(key.clone(), value.clone());
+    }
+}