@lamentis/naome 1.1.2 → 1.2.1

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

@@ -1,43 +1,16 @@
-use std::collections::HashMap;
+mod task_state_support;
+
 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",
-];
+
+use naome_core::{
+    validate_task_state, TaskStateMode, TaskStateOptions, TaskStateReport, MACHINE_OWNED_PATHS,
+    PROJECT_OWNED_PATHS,
+};
+use serde_json::json;
+use task_state_support::{
+    active_task, complete_task_state, idle_task_state, strict_health_options, successful_admission,
+    successful_proof, TaskFixture,
+};
 
 #[test]
 fn accepts_idle_task_state_template() {
@@ -175,14 +148,7 @@ fn commit_gate_allows_install_baseline_with_gitignore_and_project_owned_paths()
         }),
     );
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(report.errors.is_empty(), "{:#?}", report.errors);
 }
@@ -197,27 +163,10 @@ fn commit_gate_allows_staged_harness_refresh_split_from_completed_task() {
     repo.init_git();
     repo.write("README.md", "# Task result\n");
     repo.write("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-    repo.write_json(
-        ".naome/manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.0",
-            "profile": "standard",
-            "machineOwned": MACHINE_OWNED_PATHS,
-            "projectOwned": PROJECT_OWNED_PATHS,
-            "integrity": {}
-        }),
-    );
+    write_harness_manifest(&repo, "1.1.0");
     repo.git(["add", "AGENTS.md", ".naome/manifest.json"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(report.errors.is_empty(), "{:#?}", report.errors);
 }
@@ -232,27 +181,10 @@ fn commit_gate_allows_staged_harness_refresh_after_completed_task_is_baselined()
     repo.write("README.md", "# Completed task result\n");
     repo.init_git();
     repo.write("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
-    repo.write_json(
-        ".naome/manifest.json",
-        json!({
-            "name": "naome",
-            "harnessVersion": "1.1.1",
-            "profile": "standard",
-            "machineOwned": MACHINE_OWNED_PATHS,
-            "projectOwned": PROJECT_OWNED_PATHS,
-            "integrity": {}
-        }),
-    );
+    write_harness_manifest(&repo, "1.1.1");
     repo.git(["add", "AGENTS.md", ".naome/manifest.json"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(report.errors.is_empty(), "{:#?}", report.errors);
 }
@@ -269,14 +201,7 @@ fn commit_gate_rejects_harness_refresh_when_completed_task_proof_is_missing() {
     repo.write("AGENTS.md", "# Agent Instructions\n\nUpdated by sync.\n");
     repo.git(["add", "AGENTS.md"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(
         report
@@ -310,14 +235,7 @@ fn commit_gate_rejects_harness_refresh_with_pending_upgrade_state() {
     );
     repo.git(["add", "AGENTS.md", ".naome/upgrade-state.json"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(
         report
@@ -350,14 +268,7 @@ fn commit_gate_rejects_support_only_harness_refresh_after_completed_task_is_base
     );
     repo.git(["add", ".naome/upgrade-state.json"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     assert!(!report.errors.is_empty(), "{:#?}", report.errors);
 }
@@ -374,70 +285,29 @@ fn commit_gate_ignores_unstaged_user_edits_outside_completed_task_scope() {
     repo.write("USER.md", "user local edit\n");
     repo.git(["add", "README.md", ".naome/task-state.json"]);
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::CommitGate,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = commit_gate_report(&repo);
 
     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"
-    }));
+    let repo = TaskFixture::new(implementing_readme_task());
     repo.init_git();
     repo.write("README.md", "# In progress\n");
 
-    let report = validate_task_state(
-        repo.path(),
-        TaskStateOptions {
-            mode: TaskStateMode::Progress,
-            ..TaskStateOptions::default()
-        },
-    )
-    .unwrap();
+    let report = progress_report(&repo);
 
     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"
-    }));
+    let repo = TaskFixture::new(implementing_readme_task());
     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 report = progress_report(&repo);
     let joined = report.errors.join("\n");
 
     assert!(joined.contains("Changed files outside allowedPaths"));
@@ -497,291 +367,52 @@ fn accepts_committed_deleted_file_evidence_after_task_baseline_is_clean() {
     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_harness_manifest(repo: &TaskFixture, harness_version: &str) {
+    repo.write_json(
+        ".naome/manifest.json",
+        json!({
+            "name": "naome",
+            "harnessVersion": harness_version,
+            "profile": "standard",
+            "machineOwned": MACHINE_OWNED_PATHS,
+            "projectOwned": PROJECT_OWNED_PATHS,
+            "integrity": {}
+        }),
+    );
 }
 
-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()),
+fn commit_gate_report(repo: &TaskFixture) -> TaskStateReport {
+    validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::CommitGate,
+            ..TaskStateOptions::default()
+        },
     )
-    .unwrap();
+    .unwrap()
 }
 
-fn idle_task_state() -> Value {
-    json!({
-        "schema": "naome.task-state.v1",
-        "version": 1,
-        "status": "idle",
-        "activeTask": null,
-        "blocker": null,
-        "updatedAt": null
-    })
+fn progress_report(repo: &TaskFixture) -> TaskStateReport {
+    validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Progress,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap()
 }
 
-fn complete_task_state(overrides: Value) -> Value {
+fn implementing_readme_task() -> serde_json::Value {
     json!({
         "schema": "naome.task-state.v1",
         "version": 1,
-        "status": "complete",
-        "activeTask": active_task(overrides),
+        "status": "implementing",
+        "activeTask": active_task(json!({
+            "allowedPaths": ["README.md"],
+            "proofResults": []
+        })),
         "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());
-    }
-}

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