@lamentis/naome 1.4.0 → 1.4.1

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

@@ -0,0 +1,301 @@
+#![allow(dead_code, unused_imports)]
+
+use std::fs;
+
+use naome_core::{
+    task_proof_plan, task_status_exit_code, task_status_report, task_transition_readiness,
+};
+use serde_json::{json, Value};
+
+mod task_state_support;
+
+use task_state_support::{
+    active_task, complete_task_state, idle_task_state, successful_proof, task_state_with_status,
+    TaskFixture,
+};
+
+#[test]
+fn clean_idle_status_is_actionable_and_stable_json() {
+    let repo = TaskFixture::new(idle_task_state());
+    repo.init_git();
+
+    let status = task_status_report(repo.path()).unwrap();
+    let value = serde_json::to_value(&status).unwrap();
+
+    assert_eq!(value["schema"], "naome.task.status.v1");
+    assert_eq!(value["state"], "idle");
+    assert_eq!(value["blocked"], false);
+    assert_eq!(value["scope"]["changedPaths"], json!([]));
+    assert!(value["nextAction"]
+        .as_str()
+        .is_some_and(|action| action.contains("Create a NAOME task")));
+    assert_eq!(value["nextActionV2"]["type"], "create_task");
+    assert_eq!(value["agentLoop"]["state"], "ready_for_new_task");
+}
+
+#[test]
+fn implementing_status_splits_in_scope_and_out_of_scope_changes() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["README.md"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": []
+        })),
+    ));
+    repo.init_git();
+    repo.write("README.md", "changed\n");
+    repo.write("src/lib.rs", "pub fn outside() {}\n");
+
+    let status = task_status_report(repo.path()).unwrap();
+
+    assert_eq!(status.scope.in_scope_changed_paths, vec!["README.md"]);
+    assert_eq!(status.scope.out_of_scope_changed_paths, vec!["src/lib.rs"]);
+    assert!(status.findings.iter().any(|finding| {
+        finding.id == "task.scope.out_of_scope_change"
+            && finding.path.as_deref() == Some("src/lib.rs")
+            && finding.agent_instruction.contains("Do not commit")
+    }));
+    assert_eq!(status.next_action_v2.action_type, "repair_scope");
+    assert_eq!(status.agent_loop.state, "blocked_by_scope_drift");
+    assert!(status
+        .repair_plan
+        .iter()
+        .any(|item| item.id == "remove_out_of_scope_change_src_lib_rs"
+            && item.paths == vec!["src/lib.rs"]));
+    assert!(status.blocked);
+}
+
+#[test]
+fn completed_task_with_new_diff_reports_unbaselined_diff() {
+    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", "new diff after completion\n");
+
+    let status = task_status_report(repo.path()).unwrap();
+
+    assert!(status.findings.iter().any(|finding| {
+        finding.id == "task.state.completed_task_has_diff"
+            && finding.path.as_deref() == Some("README.md")
+    }));
+    let transition = task_transition_readiness(repo.path(), "complete").unwrap();
+    assert!(!transition.allowed);
+    assert!(transition
+        .blocking_findings
+        .iter()
+        .any(|finding| finding.id == "task.state.completed_task_has_diff"));
+}
+
+#[test]
+fn proof_plan_reports_missing_and_stale_required_checks() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["README.md", "docs/**"],
+            "requiredCheckIds": ["diff-check"],
+            "proofPathSets": {
+                "old": ["README.md"]
+            },
+            "proofBatches": [{
+                "id": "old-proof",
+                "checkedAt": "2026-05-04T12:00:00.000Z",
+                "evidencePathSet": "old",
+                "proofs": [{ "checkId": "diff-check", "exitCode": 0 }]
+            }]
+        })),
+    ));
+    repo.init_git();
+    repo.write("README.md", "covered\n");
+    repo.write("docs/task.md", "not covered\n");
+
+    let plan = task_proof_plan(repo.path()).unwrap();
+
+    assert_eq!(plan.proof.missing_checks, Vec::<String>::new());
+    assert_eq!(plan.proof.stale_checks, vec!["diff-check"]);
+    assert_eq!(plan.next_action_v2.action_type, "rerun_checks");
+    assert_eq!(plan.agent_loop.state, "blocked_by_stale_proof");
+    assert_eq!(
+        plan.proof_recording.paths,
+        vec!["README.md", "docs/task.md"]
+    );
+    assert_eq!(plan.proof_recording.checks_to_record, vec!["diff-check"]);
+    assert!(plan
+        .repair_plan
+        .iter()
+        .any(|item| item.kind == "rerun_check" && item.check_ids == vec!["diff-check"]));
+    assert!(plan.recommended_commands.iter().any(|command| {
+        command.check_id == "diff-check" && command.command == "git diff --check"
+    }));
+    assert!(plan.task_feedback.iter().any(|feedback| {
+        feedback.problem.contains("Proof evidence") && feedback.files == vec!["docs/task.md"]
+    }));
+}
+
+#[test]
+fn proof_plan_next_action_reports_missing_proof_without_command_metadata() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["README.md"],
+            "requiredCheckIds": ["unknown-check"],
+            "proofResults": []
+        })),
+    ));
+    repo.write_json(
+        ".naome/verification.json",
+        json!({
+            "schema": "naome.verification.v1",
+            "version": 1,
+            "status": "ready",
+            "checks": []
+        }),
+    );
+    repo.init_git();
+    repo.write("README.md", "changed\n");
+
+    let plan = task_proof_plan(repo.path()).unwrap();
+
+    assert!(plan.recommended_commands.is_empty());
+    assert_eq!(plan.proof.missing_checks, vec!["unknown-check"]);
+    assert!(plan.next_action.contains("Recover verification metadata"));
+}
+
+#[test]
+fn transition_readiness_blocks_missing_proof_and_allows_fresh_proof() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["README.md"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": []
+        })),
+    ));
+    repo.init_git();
+    repo.write("README.md", "changed\n");
+
+    let blocked = task_transition_readiness(repo.path(), "complete").unwrap();
+    assert!(!blocked.allowed);
+    assert!(blocked
+        .blocking_findings
+        .iter()
+        .any(|finding| finding.id == "task.proof.missing_check"));
+
+    let mut state: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/task-state.json")).unwrap(),
+    )
+    .unwrap();
+    state["activeTask"]["proofResults"] =
+        json!([successful_proof(json!({ "evidence": ["README.md"] }))]);
+    fs::write(
+        repo.path().join(".naome/task-state.json"),
+        format!("{}\n", serde_json::to_string_pretty(&state).unwrap()),
+    )
+    .unwrap();
+
+    let allowed = task_transition_readiness(repo.path(), "complete").unwrap();
+    assert!(allowed.allowed);
+    assert_eq!(allowed.agent_loop.state, "ready_to_commit");
+}
+
+#[test]
+fn legacy_proof_results_remain_readable_when_fresh() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["README.md"],
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+        })),
+    ));
+    repo.init_git();
+    repo.write("README.md", "covered\n");
+
+    let plan = task_proof_plan(repo.path()).unwrap();
+
+    assert_eq!(plan.proof.passed_checks, vec!["diff-check"]);
+    assert!(plan.proof.missing_checks.is_empty());
+    assert!(plan.proof.stale_checks.is_empty());
+}
+
+#[test]
+fn task_status_reports_no_active_task_and_control_state_only_changes() {
+    let repo = TaskFixture::new(task_state_with_status("idle", Value::Null));
+    repo.init_git();
+    repo.write("README.md", "unowned\n");
+
+    let status = task_status_report(repo.path()).unwrap();
+    assert!(status
+        .findings
+        .iter()
+        .all(|finding| finding.id != "task.scope.out_of_scope_change"));
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.state.no_active_task_with_diff"));
+    assert_eq!(status.next_action_v2.action_type, "create_task");
+    assert_eq!(task_status_exit_code(&status.findings, &status.proof), 50);
+
+    fs::remove_file(repo.path().join("README.md")).unwrap();
+    repo.write(".naome/task-state.json", "{\n  \"status\": \"idle\"\n}\n");
+    let status = task_status_report(repo.path()).unwrap();
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.scope.control_state_only_change"));
+}
+
+#[test]
+fn malformed_task_state_reports_deterministic_status_finding() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({})),
+    ));
+    repo.init_git();
+    repo.write(".naome/task-state.json", "{ invalid json\n");
+
+    let status = task_status_report(repo.path()).unwrap();
+
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.state.invalid_json"));
+    assert_eq!(task_status_exit_code(&status.findings, &status.proof), 40);
+}
+
+#[test]
+fn active_state_without_active_task_is_corrupt_and_cannot_complete() {
+    let repo = TaskFixture::new(task_state_with_status("implementing", Value::Null));
+    repo.init_git();
+
+    let status = task_status_report(repo.path()).unwrap();
+    let transition = task_transition_readiness(repo.path(), "complete").unwrap();
+
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.state.active_task_missing"));
+    assert!(!transition.allowed);
+}
+
+#[test]
+fn blocked_task_states_cannot_transition_to_complete() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "blocked",
+        active_task(json!({
+            "requiredCheckIds": ["diff-check"],
+            "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+        })),
+    ));
+    repo.init_git();
+
+    let transition = task_transition_readiness(repo.path(), "complete").unwrap();
+
+    assert!(!transition.allowed);
+    assert!(transition
+        .blocking_findings
+        .iter()
+        .any(|finding| finding.id == "task.transition.blocked_state"));
+}

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

@@ -0,0 +1,141 @@
+#![allow(dead_code, unused_imports)]
+
+use std::fs;
+
+use naome_core::{task_status_exit_code, task_status_report};
+use serde_json::json;
+
+mod task_state_support;
+
+use task_state_support::{active_task, task_state_with_status, TaskFixture};
+
+#[test]
+fn task_status_reports_git_recovery_findings() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["**"],
+            "requiredCheckIds": [],
+            "proofResults": []
+        })),
+    ));
+    repo.init_git();
+    repo.set_admission_head("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+
+    let status = task_status_report(repo.path()).unwrap();
+
+    assert_eq!(status.git.admission_head_reachable, false);
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.git.admission_head_missing"));
+}
+
+#[test]
+fn task_status_reports_unreachable_existing_admission_head() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({})),
+    ));
+    repo.init_git();
+    let admission_head = repo.git(["rev-parse", "HEAD"]).trim().to_string();
+    repo.git(["checkout", "--orphan", "other"]);
+    repo.write("OTHER.md", "other\n");
+    repo.git(["add", "."]);
+    repo.git(["commit", "-m", "other"]);
+    repo.set_admission_head(&admission_head);
+
+    let status = task_status_report(repo.path()).unwrap();
+
+    assert!(status.findings.iter().any(|finding| {
+        finding.id == "task.git.admission_head_not_reachable"
+            && finding.suggested_fix.contains("Rebase")
+    }));
+}
+
+#[test]
+fn task_status_reports_operation_in_progress_and_conflict_markers() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({})),
+    ));
+    repo.init_git();
+    let merge_head = repo.git(["rev-parse", "--git-path", "MERGE_HEAD"]);
+    fs::write(repo.path().join(merge_head.trim()), "deadbeef\n").unwrap();
+
+    let status = task_status_report(repo.path()).unwrap();
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.git.operation_in_progress"));
+
+    fs::write(
+        repo.path().join(".naome/task-state.json"),
+        "<<<<<<< HEAD\n{}\n=======\n{}\n>>>>>>> branch\n",
+    )
+    .unwrap();
+    let status = task_status_report(repo.path()).unwrap();
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.state.conflict_markers"));
+}
+
+#[test]
+fn task_status_reports_branch_divergence_when_upstream_split() {
+    let repo = TaskFixture::new(task_state_with_status(
+        "implementing",
+        active_task(json!({
+            "allowedPaths": ["**"],
+            "requiredCheckIds": [],
+            "proofResults": []
+        })),
+    ));
+    repo.init_git();
+    let remote = repo.path().join("remote.git");
+    let branch = repo.git(["rev-parse", "--abbrev-ref", "HEAD"]);
+    let branch = branch.trim();
+    repo.git(["init", "--bare", remote.to_str().unwrap()]);
+    repo.git(["remote", "add", "origin", remote.to_str().unwrap()]);
+    repo.git(["push", "-u", "origin", branch]);
+
+    repo.write("LOCAL.md", "local\n");
+    repo.git(["add", "."]);
+    repo.git(["commit", "-m", "local"]);
+
+    let clone = std::env::temp_dir().join(format!(
+        "naome-task-status-remote-work-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&clone);
+    repo.git(["clone", remote.to_str().unwrap(), clone.to_str().unwrap()]);
+    git_in(&clone, ["config", "user.email", "naome@example.com"]);
+    git_in(&clone, ["config", "user.name", "NAOME Test"]);
+    fs::write(clone.join("REMOTE.md"), "remote\n").unwrap();
+    git_in(&clone, ["add", "."]);
+    git_in(&clone, ["commit", "-m", "remote"]);
+    git_in(&clone, ["push"]);
+    repo.git(["fetch", "origin"]);
+
+    let status = task_status_report(repo.path()).unwrap();
+    assert_eq!(status.git.ahead, 1);
+    assert_eq!(status.git.behind, 1);
+    assert!(status
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.git.branch_diverged"));
+    assert_eq!(task_status_exit_code(&status.findings, &status.proof), 0);
+}
+
+fn git_in<const N: usize>(root: &std::path::Path, args: [&str; N]) {
+    let output = std::process::Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamentis/naome",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Native-first CLI for the NAOME agent harness.",
   "license": "Apache-2.0",
   "type": "module",