@lamentis/naome 1.4.0 → 1.4.2

package/crates/naome-cli/src/task_commands/repair.rs

@@ -0,0 +1,77 @@
+use std::path::Path;
+
+use naome_core::task_status_report;
+use serde_json::json;
+
+use super::common::{agent_session, print_json_with_session, value_after};
+
+pub(super) fn repair_preview(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let session = agent_session(args)?;
+    let dry_run = args.iter().any(|arg| arg == "--dry-run");
+    let execute_safe = args.iter().any(|arg| arg == "--execute-safe");
+    if dry_run && execute_safe {
+        return Err("naome task repair accepts only one of --dry-run or --execute-safe".into());
+    }
+    if !dry_run && !execute_safe {
+        return Err("naome task repair requires --dry-run or --execute-safe".into());
+    }
+    let plan_id = value_after(args, "--plan").ok_or("naome task repair requires --plan <id>")?;
+    let status = task_status_report(root)?;
+    let plan = status
+        .repair_plan
+        .iter()
+        .find(|item| item.id == plan_id)
+        .cloned();
+    let mut steps = Vec::new();
+    let mut executed = false;
+    let mut requires_user_approval = false;
+    if execute_safe {
+        if let Some(plan) = &plan {
+            if !can_execute_safe(plan) {
+                requires_user_approval = true;
+            } else {
+                match plan.kind.as_str() {
+                    "rerun_check" if plan.check_ids.len() == 1 => {
+                        steps.push(super::check_run::run_check_by_id(
+                            root,
+                            &plan.check_ids[0],
+                            false,
+                            session.as_deref(),
+                        )?);
+                        executed = true;
+                    }
+                    "record_proof" => {
+                        steps.push(super::record::record_proof_value(root, session.as_deref())?);
+                        executed = true;
+                    }
+                    _ => {
+                        requires_user_approval = true;
+                    }
+                }
+            }
+        }
+    }
+    print_json_with_session(
+        json!({
+            "schema": if dry_run { "naome.task.repair-preview.v1" } else { "naome.task.repair-execute.v1" },
+            "planId": plan_id,
+            "found": plan.is_some(),
+            "wouldExecute": dry_run && plan.as_ref().is_some_and(can_execute_safe),
+            "executed": executed,
+            "requiresUserApproval": requires_user_approval || plan.as_ref().is_some_and(|item| item.requires_user_approval),
+            "plan": plan,
+            "steps": steps,
+            "agentInstruction": if executed { "Executed only NAOME safe check/proof repair steps." } else { "Review this output; unsafe repair plans require human approval." }
+        }),
+        session.as_deref(),
+    )
+}
+
+fn can_execute_safe(item: &naome_core::RepairPlanItem) -> bool {
+    item.safe_to_execute
+        && !item.requires_user_approval
+        && matches!(item.kind.as_str(), "rerun_check" | "record_proof")
+}

package/crates/naome-cli/src/task_commands/scope_request.rs

@@ -0,0 +1,24 @@
+use std::path::Path;
+
+use serde_json::json;
+
+use super::common::{print_json, repeated_values, value_after};
+
+pub(super) fn request_scope(
+    _root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let requested_paths = repeated_values(args, "--path");
+    if requested_paths.is_empty() {
+        return Err("naome task request-scope requires at least one --path".into());
+    }
+    let reason = value_after(args, "--reason").unwrap_or("No reason provided.");
+    print_json(json!({
+        "schema": "naome.task.scope-request.v1",
+        "wouldMutate": false,
+        "requestedPaths": requested_paths,
+        "reason": reason,
+        "suggestedFix": "Ask for an explicit task-scope revision before editing these paths.",
+        "agentInstruction": "Do not edit requested paths until a human or deterministic task revision admits them."
+    }))
+}

package/crates/naome-cli/src/task_commands/timeline.rs

@@ -0,0 +1,71 @@
+use std::path::Path;
+
+use naome_core::task_status_report;
+use serde_json::{json, Value};
+
+use super::common::{print_json, read_task_state};
+
+pub(super) fn timeline(root: &Path, _args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let status = task_status_report(root)?;
+    let state = read_task_state(root)?;
+    let active = state.get("activeTask").unwrap_or(&Value::Null);
+    let mut events = admission_events(active);
+    events.extend(proof_events(active));
+    events.push(json!({ "type": "current_diff", "paths": status.scope.changed_paths }));
+    print_json(json!({
+        "schema": "naome.task.timeline.v1",
+        "state": status.state,
+        "taskId": status.task_id,
+        "events": events
+    }))
+}
+
+pub(super) fn loop_snapshot(
+    root: &Path,
+    _args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let status = task_status_report(root)?;
+    print_json(json!({
+        "schema": "naome.task.loop-snapshot.v1",
+        "taskId": status.task_id,
+        "state": status.state,
+        "status": {
+            "agentLoop": status.agent_loop,
+            "nextActionV2": status.next_action_v2,
+            "findings": status.findings,
+            "repairPlan": status.repair_plan,
+            "policyHints": status.policy_hints,
+            "recoveryGuidance": status.recovery_guidance
+        },
+        "proof": status.proof
+    }))
+}
+
+fn admission_events(active: &Value) -> Vec<Value> {
+    active
+        .get("admission")
+        .map(|admission| {
+            vec![json!({
+                "type": "admission",
+                "gitHead": admission.get("gitHead").cloned().unwrap_or(Value::Null),
+                "checkedAt": admission.get("checkedAt").cloned().unwrap_or(Value::Null)
+            })]
+        })
+        .unwrap_or_default()
+}
+
+fn proof_events(active: &Value) -> Vec<Value> {
+    active
+        .get("proofBatches")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .map(|batch| {
+            json!({
+                "type": "proof_batch",
+                "id": batch.get("id").cloned().unwrap_or(Value::Null),
+                "checkedAt": batch.get("checkedAt").cloned().unwrap_or(Value::Null)
+            })
+        })
+        .collect()
+}

package/crates/naome-cli/src/task_commands.rs

@@ -1,15 +1,94 @@
 use std::path::Path;
 
-use naome_core::{migrate_task_state_to_ledger, render_task_state_from_ledger};
+mod can_edit;
+mod check_run;
+mod common;
+mod complete;
+mod loop_control;
+mod readiness;
+mod record;
+mod repair;
+mod scope_request;
+mod timeline;
+
+use naome_core::{
+    format_task_proof_plan, format_task_status, migrate_task_state_to_ledger,
+    render_task_state_from_ledger, task_proof_plan, task_status_exit_code, task_status_report,
+    task_transition_readiness,
+};
 
 pub fn run_task_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     match args.get(1).map(String::as_str) {
         Some("render-state") => render_state(root, args),
         Some("migrate-ledger") => migrate_ledger(root, args),
+        Some("status") => task_status(root, args),
+        Some("proof-plan") => proof_plan(root, args),
+        Some("can-edit") => can_edit::can_edit(root, args),
+        Some("run-check") => check_run::run_check_command(root, args),
+        Some("can-transition") => can_transition(root, args),
+        Some("repair") => repair::repair_preview(root, args),
+        Some("record-proof") => record::record_proof(root, args),
+        Some("complete") => complete::complete_task(root, args),
+        Some("loop") => loop_control::task_loop(root, args),
+        Some("request-scope") => scope_request::request_scope(root, args),
+        Some("can-commit") => readiness::can_commit(root, args),
+        Some("timeline") => timeline::timeline(root, args),
+        Some("loop-snapshot") => timeline::loop_snapshot(root, args),
         _ => Err("unknown task command".into()),
     }
 }
 
+fn task_status(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let session = common::agent_session(args)?;
+    let report = task_status_report(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        common::print_json_with_session(serde_json::to_value(&report)?, session.as_deref())?;
+    } else {
+        print!("{}", format_task_status(&report));
+    }
+    exit_if_requested(args, task_status_exit_code(&report.findings, &report.proof));
+    Ok(())
+}
+
+fn proof_plan(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let session = common::agent_session(args)?;
+    let report = task_proof_plan(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        common::print_json_with_session(serde_json::to_value(&report)?, session.as_deref())?;
+    } else {
+        print!("{}", format_task_proof_plan(&report));
+    }
+    exit_if_requested(args, task_status_exit_code(&report.findings, &report.proof));
+    Ok(())
+}
+
+fn can_transition(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let session = common::agent_session(args)?;
+    let Some(target) = args
+        .windows(2)
+        .find(|window| window[0] == "--to")
+        .map(|window| window[1].as_str())
+    else {
+        return Err("naome task can-transition requires --to complete".into());
+    };
+    let report = task_transition_readiness(root, target)?;
+    if args.iter().any(|arg| arg == "--json") {
+        common::print_json_with_session(serde_json::to_value(&report)?, session.as_deref())?;
+    } else {
+        println!(
+            "NAOME task transition {target}: {}",
+            if report.allowed { "allowed" } else { "blocked" }
+        );
+    }
+    Ok(())
+}
+
+fn exit_if_requested(args: &[String], code: i32) {
+    if args.iter().any(|arg| arg == "--exit-code") {
+        std::process::exit(code);
+    }
+}
+
 fn render_state(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     let write = args.iter().any(|arg| arg == "--write");
     let json = args.iter().any(|arg| arg == "--json");

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

@@ -0,0 +1,58 @@
+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 task_status_json_reports_scope_and_next_action() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "status", "--json"])
+        .current_dir(&root)
+        .output()
+        .unwrap();
+
+    assert_success(&output);
+    let payload: Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(payload["schema"], "naome.task.status.v1");
+    assert_eq!(
+        payload["scope"]["inScopeChangedPaths"],
+        json!(["README.md"])
+    );
+    assert_eq!(payload["nextActionV2"]["type"], "rerun_checks");
+    assert_eq!(payload["agentLoop"]["state"], "blocked_by_missing_proof");
+}
+
+#[test]
+fn task_proof_plan_human_output_lists_recommended_commands() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "proof-plan"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+
+    assert_success(&output);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("agent loop: blocked_by_missing_proof"));
+    assert!(stdout.contains("recommended commands:"));
+    assert!(stdout.contains("diff-check: git diff --check"));
+}
+
+fn assert_success(output: &std::process::Output) {
+    assert!(
+        output.status.success(),
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

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

@@ -0,0 +1,210 @@
+use std::fs;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{fixture_root, init_git, run_json, 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 check = run_json(
+        &root,
+        ["task", "run-check", "--check", "diff-check", "--json"],
+    );
+    assert_eq!(check["schema"], "naome.task.run-check.v1");
+    assert_eq!(check["executed"], true);
+    assert_eq!(check["recordedProof"], false);
+
+    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"));
+}

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