@lamentis/naome 1.3.0 → 1.3.2

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

@@ -0,0 +1,328 @@
+mod repo_support;
+
+use naome_core::{
+    migrate_task_state_to_ledger, read_task_state_projection, render_task_state_from_ledger,
+    validate_task_state, TaskStateMode, TaskStateOptions,
+};
+use serde_json::{json, Map, Value};
+
+use repo_support::{diff_check, verification_value, TestRepo};
+
+#[test]
+fn ledger_projection_renders_compatible_task_state_without_task_state_json() {
+    let repo = TestRepo::new("projection");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(None);
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    repo.write_file("README.md", "# Changed\n");
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(state["schema"], "naome.task-state.v2");
+    assert_eq!(state["status"], "complete");
+    assert_eq!(state["activeTask"]["id"], "readme-task");
+    assert_eq!(
+        state["activeTask"]["proofResults"][0]["checkId"],
+        "diff-check"
+    );
+    assert_eq!(
+        state["activeTask"]["proofResults"][0]["evidence"][0],
+        "README.md"
+    );
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
+#[test]
+fn task_state_json_remains_backward_compatible_when_no_ledger_exists() {
+    let repo = TestRepo::new("legacy");
+    repo.write_base_harness(Some(idle_state()));
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(state["schema"], "naome.task-state.v1");
+    assert_eq!(state["status"], "idle");
+}
+
+#[test]
+fn renderer_can_write_projection_for_external_tools() {
+    let repo = TestRepo::new("write");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+
+    let rendered = render_task_state_from_ledger(repo.path(), true)
+        .unwrap()
+        .unwrap();
+    assert_eq!(rendered["status"], "complete");
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(projected["activeTask"]["id"], "readme-task");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Progress,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+    assert!(report
+        .errors
+        .iter()
+        .any(|error| error.contains("Task is complete")));
+}
+
+#[test]
+fn task_state_v2_can_migrate_to_ledger_without_losing_compact_proof_data() {
+    let repo = TestRepo::new("migrate-v2");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_naome_json("task-state.json", compact_complete_state(&head));
+    repo.write_file("README.md", "# Changed\n");
+
+    let migrated = migrate_task_state_to_ledger(repo.path(), true)
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(migrated["source"], "task-state");
+    assert!(repo.path().join(".naome/tasks/active.json").is_file());
+    assert!(repo
+        .path()
+        .join(".naome/tasks/readme-task/proofs/diff-check.json")
+        .is_file());
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(projected["schema"], "naome.task-state.v2");
+    assert_eq!(projected["status"], "complete");
+    assert_eq!(
+        projected["activeTask"]["proofResults"][0]["checkId"],
+        "diff-check"
+    );
+    assert_eq!(
+        projected["activeTask"]["proofResults"][0]["evidence"],
+        json!(["README.md"])
+    );
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
+#[test]
+fn task_state_validation_reports_stale_rendered_projection_when_ledger_exists() {
+    let repo = TestRepo::new("stale-projection");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    repo.write_naome_json("task-state.json", idle_state());
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.iter().any(|error| {
+        error.contains(".naome/task-state.json is stale")
+            && error.contains("naome.js task render-state --write")
+    }));
+}
+
+trait LedgerHarness {
+    fn write_base_harness(&self, task_state: Option<Value>);
+    fn write_complete_ledger(&self, admission_head: &str);
+}
+
+impl LedgerHarness for TestRepo {
+    fn write_base_harness(&self, task_state: Option<Value>) {
+        self.write_naome_json(
+            "init-state.json",
+            json!({ "initialized": true, "intakeStatus": "complete" }),
+        );
+        self.write_naome_json(
+            "upgrade-state.json",
+            json!({ "status": "complete", "pending": [] }),
+        );
+        self.write_naome_json(
+            "verification.json",
+            verification_value("ready", vec![diff_check(vec!["README.md"])], vec![]),
+        );
+        if let Some(state) = task_state {
+            self.write_naome_json("task-state.json", state);
+        }
+    }
+
+    fn write_complete_ledger(&self, admission_head: &str) {
+        self.write_file(
+            ".naome/tasks/active.json",
+            &format_json(object([
+                ("schema", json!("naome.task-ledger-active.v1")),
+                ("version", json!(1)),
+                ("primaryTaskId", json!("readme-task")),
+                (
+                    "worklanes",
+                    json!([{ "id": "default", "taskId": "readme-task", "status": "active" }]),
+                ),
+            ])),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/task.json",
+            &format_json(task_spec_record(admission_head)),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/events.jsonl",
+            concat!(
+                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"implementing\",\"recordedAt\":\"2026-05-08T00:00:01.000Z\"}\n",
+                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"complete\",\"recordedAt\":\"2026-05-08T00:00:02.000Z\"}\n"
+            ),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/mutations.json",
+            &format_json(object([
+                ("schema", json!("naome.task-ledger-mutations.v1")),
+                ("version", json!(1)),
+                ("taskId", json!("readme-task")),
+                ("touchedPaths", json!(["README.md"])),
+                (
+                    "entries",
+                    json!([{ "path": "README.md", "class": "source change", "owner": "agent" }]),
+                ),
+            ])),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/proofs/diff-check.json",
+            &format_json(diff_proof_record()),
+        );
+    }
+}
+
+fn idle_state() -> Value {
+    object([
+        ("schema", json!("naome.task-state.v1")),
+        ("version", json!(1)),
+        ("status", json!("idle")),
+        ("activeTask", Value::Null),
+        ("blocker", Value::Null),
+        ("updatedAt", json!("2026-05-08T00:00:00.000Z")),
+    ])
+}
+
+fn compact_complete_state(admission_head: &str) -> Value {
+    object([
+        ("schema", json!("naome.task-state.v2")),
+        ("version", json!(2)),
+        ("status", json!("complete")),
+        ("activeTask", compact_active_task(admission_head)),
+        ("blocker", Value::Null),
+        ("updatedAt", json!("2026-05-08T00:00:04.000Z")),
+    ])
+}
+
+fn compact_active_task(admission_head: &str) -> Value {
+    object([
+        ("id", json!("readme-task")),
+        ("request", json!("Update README.")),
+        ("userPrompt", user_prompt()),
+        ("admission", admission_record(admission_head)),
+        ("allowedPaths", json!(["README.md"])),
+        ("declaredChangeTypes", json!(["product-docs"])),
+        ("requiredCheckIds", json!(["diff-check"])),
+        ("proofResults", json!([])),
+        ("proofPathSets", object([("changed", json!(["README.md"]))])),
+        ("proofBatches", json!([compact_proof_batch()])),
+        ("revisions", json!([])),
+        ("humanReview", human_review()),
+    ])
+}
+
+fn task_spec_record(admission_head: &str) -> Value {
+    object([
+        ("schema", json!("naome.task-ledger-task.v1")),
+        ("version", json!(1)),
+        ("id", json!("readme-task")),
+        ("request", json!("Update README.")),
+        ("userPrompt", user_prompt()),
+        ("admission", admission_record(admission_head)),
+        ("allowedPaths", json!(["README.md"])),
+        ("declaredChangeTypes", json!(["product-docs"])),
+        ("requiredCheckIds", json!(["diff-check"])),
+        ("humanReview", human_review()),
+    ])
+}
+
+fn diff_proof_record() -> Value {
+    object([
+        ("schema", json!("naome.task-ledger-proof.v1")),
+        ("version", json!(1)),
+        ("taskId", json!("readme-task")),
+        ("checkId", json!("diff-check")),
+        ("command", json!("git diff --check")),
+        ("cwd", json!(".")),
+        ("exitCode", json!(0)),
+        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
+        ("evidence", json!(["README.md"])),
+    ])
+}
+
+fn compact_proof_batch() -> Value {
+    object([
+        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
+        ("evidencePathSet", json!("changed")),
+        (
+            "proofs",
+            json!([{ "checkId": "diff-check", "exitCode": 0 }]),
+        ),
+    ])
+}
+
+fn admission_record(git_head: &str) -> Value {
+    object([
+        (
+            "command",
+            json!("node .naome/bin/check-task-state.js --admission"),
+        ),
+        ("cwd", json!(".")),
+        ("exitCode", json!(0)),
+        ("checkedAt", json!("2026-05-08T00:00:00.000Z")),
+        ("gitHead", json!(git_head)),
+        ("changedPaths", json!([])),
+    ])
+}
+
+fn user_prompt() -> Value {
+    object([
+        ("receivedAt", json!("2026-05-08T00:00:00.000Z")),
+        ("text", json!("Update README.")),
+    ])
+}
+
+fn human_review() -> Value {
+    object([
+        ("required", json!(false)),
+        ("approved", json!(false)),
+        ("reason", Value::Null),
+    ])
+}
+
+fn object<const N: usize>(entries: [(&str, Value); N]) -> Value {
+    let mut map = Map::new();
+    for (key, value) in entries {
+        map.insert(key.to_string(), value);
+    }
+    Value::Object(map)
+}
+
+fn format_json(value: Value) -> String {
+    format!("{}\n", serde_json::to_string_pretty(&value).unwrap())
+}

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

@@ -8,8 +8,8 @@ use naome_core::{
 };
 use serde_json::json;
 use task_state_support::{
-    active_task, complete_task_state, idle_task_state, strict_health_options, successful_admission,
-    successful_proof, TaskFixture,
+    active_task, complete_task_state, idle_task_state, ready_empty_verification_fixture,
+    strict_health_options, successful_admission, successful_proof, TaskFixture,
 };
 
 #[test]
@@ -137,15 +137,7 @@ fn commit_gate_allows_install_baseline_with_gitignore_and_project_owned_paths()
     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": []
-        }),
+        ready_empty_verification_fixture(),
     );
 
     let report = commit_gate_report(&repo);
@@ -292,7 +284,7 @@ fn commit_gate_ignores_unstaged_user_edits_outside_completed_task_scope() {
 
 #[test]
 fn progress_accepts_implementing_task_with_scoped_diff_without_proof() {
-    let repo = TaskFixture::new(implementing_readme_task());
+    let repo = TaskFixture::new(implementing_readme_task_fixture());
     repo.init_git();
     repo.write("README.md", "# In progress\n");
 
@@ -303,7 +295,7 @@ fn progress_accepts_implementing_task_with_scoped_diff_without_proof() {
 
 #[test]
 fn progress_rejects_in_flight_work_outside_scope() {
-    let repo = TaskFixture::new(implementing_readme_task());
+    let repo = TaskFixture::new(implementing_readme_task_fixture());
     repo.init_git();
     repo.write("src/session.js", "export const session = null;\n");
 
@@ -314,6 +306,20 @@ fn progress_rejects_in_flight_work_outside_scope() {
     assert!(joined.contains("src/session.js"));
 }
 
+#[test]
+fn progress_reports_stale_repository_model_for_scoped_stack_changes() {
+    let repo = TaskFixture::new(implementing_package_task());
+    repo.write(".naome/repository-model.json", "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n");
+    repo.init_git();
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+
+    let report = progress_report(&repo);
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("repository model is stale"));
+    assert!(joined.contains("naome repo model --write"));
+}
+
 #[test]
 fn rejects_complete_task_when_evidence_omits_changed_allowed_path() {
     let repo = TaskFixture::new(complete_task_state(json!({
@@ -403,7 +409,7 @@ fn progress_report(repo: &TaskFixture) -> TaskStateReport {
     .unwrap()
 }
 
-fn implementing_readme_task() -> serde_json::Value {
+fn implementing_readme_task_fixture() -> serde_json::Value {
     json!({
         "schema": "naome.task-state.v1",
         "version": 1,
@@ -416,3 +422,17 @@ fn implementing_readme_task() -> serde_json::Value {
         "updatedAt": "2026-05-04T12:00:00.000Z"
     })
 }
+
+fn implementing_package_task() -> serde_json::Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "implementing",
+        "activeTask": active_task(json!({
+            "allowedPaths": ["Package.swift"],
+            "proofResults": []
+        })),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    })
+}

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

@@ -11,7 +11,8 @@ use naome_core::{HarnessHealthOptions, MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS}
 use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
 pub use states::{
-    active_task, complete_task_state, idle_task_state, successful_admission, successful_proof,
+    active_task, complete_task_state, idle_task_state, ready_empty_verification_fixture,
+    successful_admission, successful_proof,
 };
 
 static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);

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

@@ -1,24 +1,25 @@
 use serde_json::{json, Value};
 
 pub fn idle_task_state() -> Value {
-    json!({
-        "schema": "naome.task-state.v1",
-        "version": 1,
-        "status": "idle",
-        "activeTask": null,
-        "blocker": null,
-        "updatedAt": null
-    })
+    task_state_record("idle", Value::Null, Value::Null)
 }
 
 pub fn complete_task_state(overrides: Value) -> Value {
+    task_state_record(
+        "complete",
+        active_task(overrides),
+        json!("2026-05-04T12:00:00.000Z"),
+    )
+}
+
+fn task_state_record(status: &str, active_task: Value, updated_at: Value) -> Value {
     json!({
         "schema": "naome.task-state.v1",
         "version": 1,
-        "status": "complete",
-        "activeTask": active_task(overrides),
+        "status": status,
+        "activeTask": active_task,
         "blocker": null,
-        "updatedAt": "2026-05-04T12:00:00.000Z"
+        "updatedAt": updated_at
     })
 }
 
@@ -71,6 +72,22 @@ pub fn successful_proof(overrides: Value) -> Value {
     proof
 }
 
+pub fn ready_empty_verification_fixture() -> Value {
+    serde_json::from_str(
+        r#"{
+  "schema": "naome.verification.v1",
+  "version": 1,
+  "status": "ready",
+  "lastUpdated": "2026-05-05",
+  "checks": [],
+  "changeTypes": [],
+  "releaseGates": [],
+  "phases": []
+}"#,
+    )
+    .unwrap()
+}
+
 fn merge_object(target: &mut Value, overrides: Value) {
     let Some(target_object) = target.as_object_mut() else {
         return;

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

@@ -1,50 +1,13 @@
 use naome_core::seed_builtin_verification_checks;
-use serde_json::json;
 
 mod repo_support;
 
-use repo_support::TestRepo;
+use repo_support::{repo_docs_verification_fixture, TestRepo};
 
 #[test]
 fn seeds_builtin_checks_without_removing_repo_specific_checks() {
     let repo = TestRepo::new("verification-seed");
-    repo.write_naome_json(
-        "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "lastUpdated": "2026-05-05",
-            "checks": [
-                {
-                    "id": "repo-docs",
-                    "command": "npm run docs:test",
-                    "cwd": ".",
-                    "purpose": "Validate repository documentation.",
-                    "cost": "fast",
-                    "source": "repository intake",
-                    "evidence": ["package.json"],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "repo-docs",
-                    "description": "Repository documentation changes.",
-                    "paths": ["docs/**"],
-                    "requiredChecks": ["repo-docs"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-            "releaseGates": [
-                {
-                    "checkId": "repo-docs",
-                    "requiredWhen": "Before merging repository documentation changes."
-                }
-            ]
-        }),
-    );
+    repo.write_naome_json("verification.json", repo_docs_verification_fixture());
 
     let changed = seed_builtin_verification_checks(repo.path()).unwrap();
 
@@ -62,10 +25,22 @@ fn seeds_builtin_checks_without_removing_repo_specific_checks() {
         check_command(&verification, "naome-task-state"),
         Some("node .naome/bin/check-task-state.js")
     );
+    assert_eq!(
+        check_command(&verification, "repository-semantic-check"),
+        Some("node .naome/bin/naome.js semantic check --changed")
+    );
     assert_eq!(
         check_command(&verification, "repo-docs"),
         Some("npm run docs:test")
     );
+    let repo_docs_required = verification["changeTypes"][0]["requiredChecks"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter_map(serde_json::Value::as_str)
+        .collect::<Vec<_>>();
+    assert!(repo_docs_required.contains(&"repository-quality-check"));
+    assert!(repo_docs_required.contains(&"repository-semantic-check"));
 
     let changed_again = seed_builtin_verification_checks(repo.path()).unwrap();
     assert!(!changed_again);

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

@@ -3,7 +3,10 @@ use serde_json::json;
 
 mod repo_support;
 
-use repo_support::{change_type, diff_check, verification_value, TestRepo};
+use repo_support::{
+    change_type, check_missing_last_verified_fixture, diff_check,
+    placeholder_verification_contract_fixture, verification_value, TestRepo,
+};
 
 #[test]
 fn accepts_valid_contract_and_testing_map() {
@@ -39,35 +42,7 @@ fn rejects_missing_check_references_and_ready_placeholders() {
     repo.write_testing_markdown(default_testing_markdown());
     repo.write_naome_json(
         "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "lastUpdated": "2026-05-05",
-            "checks": [
-                {
-                    "id": "example-check",
-                    "command": "replace with real command",
-                    "cwd": ".",
-                    "purpose": "Replace with what this proves.",
-                    "cost": "fast",
-                    "source": "replace with evidence source",
-                    "evidence": [],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "docs",
-                    "description": "Documentation changes.",
-                    "paths": ["docs/**"],
-                    "requiredChecks": ["missing-check"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-            "releaseGates": []
-        }),
+        placeholder_verification_contract_fixture(),
     );
 
     let errors = validate_verification_contract(repo.path()).unwrap();
@@ -81,28 +56,7 @@ fn rejects_missing_check_references_and_ready_placeholders() {
 fn rejects_checks_without_explicit_last_verified_value() {
     let repo = TestRepo::new("verification-contract-last-verified");
     repo.write_testing_markdown(default_testing_markdown());
-    repo.write_naome_json(
-        "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "uninitialized",
-            "lastUpdated": null,
-            "checks": [
-                {
-                    "id": "diff-check",
-                    "command": "git diff --check",
-                    "cwd": ".",
-                    "purpose": "Reject whitespace errors.",
-                    "cost": "fast",
-                    "source": "git",
-                    "evidence": []
-                }
-            ],
-            "changeTypes": [],
-            "releaseGates": []
-        }),
-    );
+    repo.write_naome_json("verification.json", check_missing_last_verified_fixture());
 
     let errors = validate_verification_contract(repo.path()).unwrap();
     let joined = errors.join("\n");