@lamentis/naome 1.4.0 → 1.4.1

package/crates/naome-cli/tests/task_cli_agent_controls.rs

@@ -0,0 +1,217 @@
+use std::fs;
+use std::process::Command;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{fixture_root, init_git, task_state, write_fixture_file};
+
+#[test]
+fn status_json_exposes_policy_hints_and_recovery_guidance() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let status = run_json(&root, ["task", "status", "--json"]);
+
+    assert_eq!(status["policyHints"]["mayEdit"], json!(["README.md"]));
+    assert_eq!(status["taskMode"]["kind"], "standard");
+    assert_eq!(
+        status["policyHints"]["mustRunAfterEdit"],
+        json!(["diff-check"])
+    );
+    assert!(status["policyHints"]["forbiddenActions"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|item| item == "Do not bypass the NAOME commit gate."));
+    assert!(status["recoveryGuidance"].as_array().unwrap().is_empty());
+}
+
+#[test]
+fn repair_dry_run_previews_selected_safe_plan() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "src/lib.rs", "outside\n");
+    write_fixture_file(&root, "docs/outside.md", "outside\n");
+
+    let status = run_json(&root, ["task", "status", "--json"]);
+    let repair_ids = status["repairPlan"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter_map(|item| item["id"].as_str())
+        .collect::<Vec<_>>();
+    assert!(repair_ids.contains(&"remove_out_of_scope_change_src_lib_rs"));
+    assert!(repair_ids.contains(&"remove_out_of_scope_change_docs_outside_md"));
+
+    let preview = run_json(
+        &root,
+        [
+            "task",
+            "repair",
+            "--plan",
+            "remove_out_of_scope_change_src_lib_rs",
+            "--dry-run",
+            "--json",
+        ],
+    );
+
+    assert_eq!(preview["schema"], "naome.task.repair-preview.v1");
+    assert_eq!(preview["found"], true);
+    assert_eq!(preview["wouldExecute"], false);
+    assert_eq!(preview["plan"]["kind"], "git_revert_path");
+    assert_eq!(preview["plan"]["paths"], json!(["src/lib.rs"]));
+}
+
+#[test]
+fn record_proof_from_plan_writes_compact_batch() {
+    let root = fixture_root(task_cli_support::task_state_with_active_task(
+        task_cli_support::active_task(json!({
+            "proofPathSets": {
+                "current-task-diff": ["OLD.md"]
+            },
+            "proofBatches": [{
+                "id": "cli-task-proof",
+                "checkedAt": "2026-05-04T12:00:00.000Z",
+                "evidencePathSet": "current-task-diff",
+                "proofs": [{ "checkId": "diff-check", "exitCode": 0 }]
+            }]
+        })),
+    ));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let recorded = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+
+    assert_eq!(recorded["schema"], "naome.task.record-proof.v1");
+    assert_eq!(recorded["recorded"], true);
+    assert_eq!(recorded["checksRecorded"], json!(["diff-check"]));
+    assert_eq!(recorded["pathSetId"], "current-task-diff-2");
+    assert_eq!(recorded["proofBatchId"], "cli-task-proof-2");
+
+    let task_state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    assert_eq!(
+        task_state["activeTask"]["proofPathSets"]["current-task-diff"],
+        json!(["OLD.md"])
+    );
+    assert_eq!(
+        task_state["activeTask"]["proofPathSets"]["current-task-diff-2"],
+        json!(["README.md"])
+    );
+    assert_eq!(
+        task_state["activeTask"]["proofBatches"][1]["id"],
+        "cli-task-proof-2"
+    );
+    assert_eq!(
+        task_state["activeTask"]["proofBatches"][1]["proofs"][0]["checkId"],
+        "diff-check"
+    );
+}
+
+#[test]
+fn rerun_check_repair_preserves_configured_cwd() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    let mut verification: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/verification.json")).unwrap())
+            .unwrap();
+    verification["checks"][0]["cwd"] = json!("checks");
+    task_cli_support::write_json(&root, ".naome/verification.json", &verification);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let plan = run_json(&root, ["task", "proof-plan", "--json"]);
+    let rerun = plan["repairPlan"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|item| item["id"] == "rerun_diff-check")
+        .unwrap();
+
+    assert_eq!(rerun["cwd"], "checks");
+    assert_eq!(rerun["commands"], json!(["git diff --check"]));
+}
+
+#[test]
+fn agent_control_commands_emit_stable_json_contracts() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let scope = run_json(
+        &root,
+        [
+            "task",
+            "request-scope",
+            "--path",
+            "src/lib.rs",
+            "--reason",
+            "Need to update implementation.",
+            "--json",
+        ],
+    );
+    assert_eq!(scope["schema"], "naome.task.scope-request.v1");
+    assert_eq!(scope["wouldMutate"], false);
+    assert_eq!(scope["requestedPaths"], json!(["src/lib.rs"]));
+
+    let can_commit = run_json(&root, ["task", "can-commit", "--json"]);
+    assert_eq!(can_commit["schema"], "naome.task.commit-readiness.v1");
+    assert_eq!(can_commit["allowed"], false);
+    assert!(can_commit["requiredBeforeCommit"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|item| item.as_str().unwrap().contains("required check")));
+
+    let timeline = run_json(&root, ["task", "timeline", "--json"]);
+    assert_eq!(timeline["schema"], "naome.task.timeline.v1");
+    assert!(timeline["events"].as_array().unwrap().len() >= 2);
+
+    let snapshot = run_json(&root, ["task", "loop-snapshot", "--json"]);
+    assert_eq!(snapshot["schema"], "naome.task.loop-snapshot.v1");
+    assert_eq!(
+        snapshot["status"]["agentLoop"]["state"],
+        "blocked_by_missing_proof"
+    );
+}
+
+#[test]
+fn review_fix_mode_is_structured_not_inferred_from_prompt_text() {
+    let root = fixture_root(task_cli_support::task_state_with_active_task(
+        task_cli_support::active_task(json!({
+            "kind": "review_fix",
+            "declaredChangeTypes": ["review-fix"],
+            "proofResults": []
+        })),
+    ));
+    init_git(&root);
+
+    let status = run_json(&root, ["task", "status", "--json"]);
+
+    assert_eq!(status["taskMode"]["kind"], "review_fix");
+    assert_eq!(status["taskMode"]["reviewFix"], true);
+    assert!(status["taskMode"]["scopePolicy"]
+        .as_str()
+        .unwrap()
+        .contains("explicit allowedPaths"));
+}
+
+fn run_json<const N: usize>(root: &std::path::Path, args: [&str; N]) -> Value {
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    serde_json::from_slice(&output.stdout).unwrap()
+}

package/crates/naome-cli/tests/task_cli_control.rs

@@ -0,0 +1,126 @@
+use std::fs;
+use std::process::Command;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{
+    active_task, fixture_root, init_git, successful_proof, task_state, task_state_with_active_task,
+    write_fixture_file, write_json,
+};
+
+#[test]
+fn exit_code_reports_missing_stale_scope_git_and_conflict_states() {
+    assert_exit_code(
+        task_state(),
+        |root| write_fixture_file(root, "README.md", "changed\n"),
+        10,
+    );
+
+    assert_exit_code(
+        stale_task_state(),
+        |root| {
+            write_fixture_file(root, "README.md", "covered\n");
+            write_fixture_file(root, "docs/task.md", "stale\n");
+        },
+        11,
+    );
+
+    assert_exit_code(
+        task_state(),
+        |root| write_fixture_file(root, "src/lib.rs", "x\n"),
+        20,
+    );
+
+    assert_exit_code(
+        task_state(),
+        |root| {
+            set_admission_head(root, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+        },
+        30,
+    );
+
+    assert_exit_code(
+        task_state(),
+        |root| {
+            fs::write(
+                root.join(".naome/task-state.json"),
+                "<<<<<<< HEAD\n{}\n=======\n{}\n>>>>>>> branch\n",
+            )
+            .unwrap();
+        },
+        40,
+    );
+}
+
+#[test]
+fn can_transition_blocks_missing_proof_and_allows_fresh_proof() {
+    let blocked = run_transition(task_state(), |root| {
+        write_fixture_file(root, "README.md", "changed\n");
+    });
+    assert_eq!(blocked["schema"], "naome.task.transition-readiness.v1");
+    assert_eq!(blocked["allowed"], false);
+    assert!(blocked["blockingFindings"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|finding| { finding["id"] == "task.proof.missing_check" }));
+
+    let allowed = run_transition(fresh_task_state(), |root| {
+        write_fixture_file(root, "README.md", "changed\n");
+    });
+    assert_eq!(allowed["allowed"], true);
+    assert_eq!(allowed["agentLoop"]["state"], "ready_to_commit");
+}
+
+fn assert_exit_code(state: Value, mutate: impl FnOnce(&std::path::Path), expected: i32) {
+    let root = fixture_root(state);
+    init_git(&root);
+    mutate(&root);
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "status", "--json", "--exit-code"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert_eq!(output.status.code(), Some(expected));
+}
+
+fn run_transition(state: Value, mutate: impl FnOnce(&std::path::Path)) -> Value {
+    let root = fixture_root(state);
+    init_git(&root);
+    mutate(&root);
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "can-transition", "--to", "complete", "--json"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    serde_json::from_slice(&output.stdout).unwrap()
+}
+
+fn stale_task_state() -> Value {
+    task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["README.md", "docs/**"],
+        "proofPathSets": { "old": ["README.md"] },
+        "proofBatches": [{
+            "id": "old-proof",
+            "checkedAt": "2026-05-04T12:00:00.000Z",
+            "evidencePathSet": "old",
+            "proofs": [{ "checkId": "diff-check", "exitCode": 0 }]
+        }]
+    })))
+}
+
+fn fresh_task_state() -> Value {
+    task_state_with_active_task(active_task(json!({
+        "proofResults": [successful_proof(json!(["README.md"]))]
+    })))
+}
+
+fn set_admission_head(root: &std::path::Path, head: &str) {
+    let path = root.join(".naome/task-state.json");
+    let mut state: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+    state["activeTask"]["admission"]["gitHead"] = json!(head);
+    write_json(root, ".naome/task-state.json", &state);
+}

package/crates/naome-cli/tests/task_cli_support/mod.rs

@@ -0,0 +1,150 @@
+#![allow(dead_code)]
+
+use std::fs;
+use std::process::Command;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde_json::{json, Value};
+
+static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+pub fn task_state() -> Value {
+    task_state_with_active_task(active_task(json!({ "proofResults": [] })))
+}
+
+pub fn task_state_with_active_task(active_task: Value) -> Value {
+    let mut state: Value = serde_json::from_str(include_str!(
+        "../../../../templates/naome-root/.naome/task-state.json"
+    ))
+    .unwrap();
+    state["status"] = json!("implementing");
+    state["activeTask"] = active_task;
+    state["updatedAt"] = json!("2026-05-04T12:00:00.000Z");
+    state
+}
+
+pub fn active_task(overrides: Value) -> Value {
+    let mut task = json!({
+        "id": "cli-task",
+        "request": "Exercise task CLI.",
+        "userPrompt": {
+            "receivedAt": "2026-05-04T12:00:00.000Z",
+            "text": "Exercise task CLI."
+        },
+        "admission": {
+            "command": "node .naome/bin/check-task-state.js --admission",
+            "cwd": ".",
+            "exitCode": 0,
+            "checkedAt": "2026-05-04T12:00:00.000Z",
+            "gitHead": "pending-test-head",
+            "changedPaths": []
+        },
+        "allowedPaths": ["README.md"],
+        "declaredChangeTypes": ["docs"],
+        "requiredCheckIds": ["diff-check"],
+        "humanReview": {
+            "required": false,
+            "approved": false,
+            "reason": null
+        }
+    });
+    for (key, value) in overrides.as_object().unwrap() {
+        task.as_object_mut()
+            .unwrap()
+            .insert(key.clone(), value.clone());
+    }
+    task
+}
+
+pub fn successful_proof(evidence: Value) -> Value {
+    json!({
+        "checkId": "diff-check",
+        "command": "git diff --check",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-04T12:00:00.000Z",
+        "evidence": evidence
+    })
+}
+
+pub fn fixture_root(task_state: Value) -> std::path::PathBuf {
+    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-cli-fixture-{}-{nonce}-{counter}",
+        std::process::id()
+    ));
+    fs::create_dir_all(root.join(".naome")).unwrap();
+    fs::write(
+        root.join(".naomeignore"),
+        ".naome/archive/\n.naome/tasks/\n",
+    )
+    .unwrap();
+    write_json(&root, ".naome/task-state.json", &task_state);
+    write_json(&root, ".naome/verification.json", &verification());
+    write_fixture_file(&root, "README.md", "initial\n");
+    root
+}
+
+pub fn init_git(root: &std::path::Path) {
+    git(root, ["init"]);
+    git(root, ["config", "user.email", "naome@example.com"]);
+    git(root, ["config", "user.name", "NAOME Test"]);
+    git(root, ["add", "."]);
+    git(root, ["commit", "-m", "baseline"]);
+    let head = git(root, ["rev-parse", "HEAD"]).trim().to_string();
+    let path = root.join(".naome/task-state.json");
+    let mut state: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+    state["activeTask"]["admission"]["gitHead"] = json!(head);
+    write_json(root, ".naome/task-state.json", &state);
+}
+
+pub fn git<const N: usize>(root: &std::path::Path, args: [&str; N]) -> String {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    String::from_utf8_lossy(&output.stdout).to_string()
+}
+
+pub fn write_fixture_file(root: &std::path::Path, path: &str, content: &str) {
+    let target = root.join(path);
+    fs::create_dir_all(target.parent().unwrap()).unwrap();
+    fs::write(target, content).unwrap();
+}
+
+pub fn write_json(root: &std::path::Path, path: &str, value: &Value) {
+    write_fixture_file(
+        root,
+        path,
+        &format!("{}\n", serde_json::to_string_pretty(value).unwrap()),
+    );
+}
+
+fn verification() -> Value {
+    json!({
+        "schema": "naome.verification.v1",
+        "version": 1,
+        "status": "ready",
+        "checks": [{
+            "id": "diff-check",
+            "command": "git diff --check",
+            "cwd": ".",
+            "purpose": "Detect whitespace and patch formatting issues.",
+            "cost": "fast",
+            "source": "git",
+            "evidence": ["README.md"],
+            "lastVerified": null
+        }]
+    })
+}

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.4.0"
+version = "1.4.1"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-core/src/lib.rs

@@ -68,8 +68,13 @@ pub use task_ledger::{
     TaskLedgerProjection, TaskLedgerStatus,
 };
 pub use task_state::{
-    completed_task_commit_paths, validate_task_state, TaskStateMode, TaskStateOptions,
-    TaskStateReport,
+    completed_task_commit_paths, format_task_proof_plan, format_task_status, task_proof_plan,
+    task_status_exit_code, task_status_report, task_transition_readiness, validate_task_state,
+    AgentLoop, NextActionV2, PolicyHints, ProofRecording, ProofRecordingAfterSuccess,
+    RecoveryGuidance, RepairPlanItem, TaskFeedback, TaskGitStatus, TaskModeStatus,
+    TaskProofPlanReport, TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus, TaskStateMode,
+    TaskStateOptions, TaskStateReport, TaskStatusFinding, TaskStatusReportV1,
+    TransitionReadinessReport,
 };
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;

package/crates/naome-core/src/task_state/mod.rs

@@ -22,6 +22,8 @@ mod proof_types;
 mod push_gate;
 mod repair;
 mod shape;
+mod status;
+mod status_output;
 mod task_diff_api;
 mod task_records;
 mod task_references;
@@ -31,6 +33,14 @@ mod util;
 pub use api::validate_task_state;
 pub use completed_refresh::completed_task_harness_refresh_diff;
 pub(crate) use proof_model::{canonical_proof_check_ids, canonical_proofs};
+pub use status::{
+    task_proof_plan, task_status_exit_code, task_status_report, task_transition_readiness,
+    AgentLoop, NextActionV2, PolicyHints, ProofRecording, ProofRecordingAfterSuccess,
+    RecoveryGuidance, RepairPlanItem, TaskFeedback, TaskGitStatus, TaskModeStatus,
+    TaskProofPlanReport, TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus,
+    TaskStatusFinding, TaskStatusReportV1, TransitionReadinessReport,
+};
+pub use status_output::{format_task_proof_plan, format_task_status};
 pub use task_diff_api::{
     completed_task_commit_diff, completed_task_commit_paths, harness_refresh_diff,
     harness_refresh_with_unrelated_diff,

package/crates/naome-core/src/task_state/status/agent_model.rs

@@ -0,0 +1,76 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NextActionV2 {
+    #[serde(rename = "type")]
+    pub action_type: String,
+    pub reason: String,
+    pub check_ids: Vec<String>,
+    pub commands: Vec<String>,
+    pub paths: Vec<String>,
+    pub safe_to_execute: bool,
+    pub requires_user_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentLoop {
+    pub state: String,
+    pub can_continue_editing: bool,
+    pub can_run_checks: bool,
+    pub can_record_proof: bool,
+    pub can_commit: bool,
+    pub must_do_next: Vec<String>,
+    pub must_not_do: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RepairPlanItem {
+    pub id: String,
+    pub kind: String,
+    pub reason: String,
+    pub paths: Vec<String>,
+    pub check_ids: Vec<String>,
+    pub commands: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+    pub safe_to_execute: bool,
+    pub requires_user_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofRecording {
+    pub path_set_id: String,
+    pub paths: Vec<String>,
+    pub proof_batch_id: String,
+    pub checks_to_record: Vec<String>,
+    pub after_success: ProofRecordingAfterSuccess,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofRecordingAfterSuccess {
+    pub record_proof: bool,
+    pub instructions: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct PolicyHints {
+    pub may_edit: Vec<String>,
+    pub must_inspect_before_edit: Vec<String>,
+    pub must_run_after_edit: Vec<String>,
+    pub forbidden_actions: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecoveryGuidance {
+    pub id: String,
+    pub reason: String,
+    pub safe_next_action: String,
+    pub requires_user_approval: bool,
+}