@lamentis/naome 1.4.2 → 1.4.3

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

@@ -1,14 +1,21 @@
 use std::path::Path;
 
+mod agent_snapshot;
 mod can_edit;
 mod check_run;
+mod commit_preflight;
 mod common;
+mod compact_proof;
 mod complete;
 mod loop_control;
+mod path_policy;
+mod planner;
+mod preflight;
 mod readiness;
 mod record;
 mod repair;
 mod scope_request;
+mod scope_suggestions;
 mod timeline;
 
 use naome_core::{
@@ -23,13 +30,18 @@ pub fn run_task_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std:
         Some("migrate-ledger") => migrate_ledger(root, args),
         Some("status") => task_status(root, args),
         Some("proof-plan") => proof_plan(root, args),
+        Some("agent-snapshot") => agent_snapshot::agent_snapshot(root, args),
+        Some("preflight") => preflight::preflight(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("compact-proof") => compact_proof::compact_proof(root, args),
         Some("complete") => complete::complete_task(root, args),
         Some("loop") => loop_control::task_loop(root, args),
+        Some("commit-preflight") => commit_preflight::commit_preflight(root, args),
+        Some("scope-suggestions") => scope_suggestions::scope_suggestions(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),

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

@@ -0,0 +1,290 @@
+use std::fs;
+use std::process::Command;
+
+use serde_json::{json, Value};
+
+mod task_cli_support;
+
+use task_cli_support::{
+    active_task, fixture_root, git, init_git, run_json, task_state, task_state_with_active_task,
+    write_fixture_file, write_json,
+};
+
+#[test]
+fn agent_snapshot_reports_missing_proof_and_safe_commands() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["schema"], "naome.task.agent-snapshot.v1");
+    assert_eq!(snapshot["proof"]["missingChecks"], json!(["diff-check"]));
+    assert_eq!(snapshot["nextAction"]["type"], "run_checks");
+    assert_eq!(snapshot["checks"]["safeToRun"][0]["checkId"], "diff-check");
+}
+
+#[test]
+fn preflight_reports_path_policy_and_check_plan() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["scripts/*.js"],
+        "proofResults": []
+    }))));
+    fs::write(
+        root.join(".naomeignore"),
+        ".naome/archive/\n.naome/tasks/\ndist/\n",
+    )
+    .unwrap();
+    init_git(&root);
+
+    let allowed = run_json(
+        &root,
+        ["task", "preflight", "--path", "scripts/check.js", "--json"],
+    );
+    assert_eq!(allowed["paths"][0]["editable"], true);
+    assert_eq!(allowed["paths"][0]["risk"], "medium");
+
+    let ignored = run_json(
+        &root,
+        ["task", "preflight", "--path", "dist/bundle.js", "--json"],
+    );
+    assert_eq!(ignored["paths"][0]["editable"], false);
+    assert_eq!(ignored["findings"][0]["id"], "task.preflight.ignored_path");
+
+    let traversal = run_json(
+        &root,
+        ["task", "preflight", "--path", "..\\outside.js", "--json"],
+    );
+    assert_eq!(traversal["paths"][0]["editable"], false);
+    assert_eq!(traversal["findings"][0]["id"], "task.preflight.unsafe_path");
+
+    let control = run_json(
+        &root,
+        ["task", "preflight", "--path", ".naomeignore", "--json"],
+    );
+    assert_eq!(control["paths"][0]["editable"], false);
+    assert_eq!(control["findings"][0]["id"], "task.preflight.control_path");
+}
+
+#[test]
+fn preflight_blocks_when_no_target_paths_are_selected() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+
+    let preflight = run_json(&root, ["task", "preflight", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.preflight.v1");
+    assert_eq!(
+        preflight["findings"][0]["id"],
+        "task.preflight.missing_target_paths"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["safeToExecute"], false);
+}
+
+#[test]
+fn preflight_from_changed_allows_clean_changed_set() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    git(&root, ["add", ".naome/task-state.json"]);
+    git(&root, ["commit", "-m", "record admission head"]);
+
+    let preflight = run_json(&root, ["task", "preflight", "--from-changed", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.preflight.v1");
+    assert!(preflight["findings"].as_array().unwrap().is_empty());
+    assert_eq!(preflight["paths"], json!([]));
+    assert_eq!(preflight["nextAction"]["type"], "edit");
+}
+
+#[test]
+fn commit_preflight_blocks_missing_proof() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+
+    assert_eq!(preflight["schema"], "naome.task.commit-preflight.v1");
+    assert_eq!(preflight["wouldPass"], false);
+    assert_eq!(
+        preflight["blockingFindings"][0]["id"],
+        "task.proof.missing_check"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "rerun_checks");
+    assert_eq!(preflight["nextAction"]["checkIds"], json!(["diff-check"]));
+}
+
+#[test]
+fn agent_snapshot_prefers_commit_ready_over_more_editing() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        [
+            "task",
+            "run-check",
+            "--check",
+            "diff-check",
+            "--record-proof",
+            "--json",
+        ],
+    );
+    assert_eq!(checked["recordedProof"], true);
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["commit"]["canCommit"], true);
+    assert_eq!(snapshot["nextAction"]["type"], "commit_ready");
+    assert_eq!(snapshot["nextAction"]["safeToExecute"], false);
+}
+
+#[test]
+fn commit_preflight_surfaces_transition_blocker_action_and_exit_code() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": [],
+        "humanReview": {
+            "required": true,
+            "approved": false,
+            "reason": "Release owner approval required."
+        },
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+
+    assert_eq!(preflight["wouldPass"], false);
+    assert_eq!(
+        preflight["blockingFindings"][0]["id"],
+        "task.transition.human_review_required"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["safeToExecute"], false);
+
+    let output = Command::new(env!("CARGO_BIN_EXE_naome"))
+        .args(["task", "commit-preflight", "--json", "--exit-code"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(1));
+}
+
+#[test]
+fn compact_proof_dry_run_and_write_remove_verbose_fields() {
+    let root = fixture_root(task_state());
+    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"]["proofPathSets"] = json!({ "current": ["README.md"] });
+    state["activeTask"]["proofBatches"] = json!([{
+        "id": "batch",
+        "checkedAt": "2026-05-14T00:00:00.000Z",
+        "evidencePathSet": "current",
+        "proofs": [{
+            "checkId": "diff-check",
+            "command": "git diff --check",
+            "cwd": ".",
+            "exitCode": 0,
+            "evidenceFingerprint": "fnv64:test",
+            "stdoutSummary": "large",
+            "stderrSummary": "large",
+            "durationMs": 42
+        }]
+    }]);
+    write_json(&root, ".naome/task-state.json", &state);
+
+    let dry = run_json(&root, ["task", "compact-proof", "--dry-run", "--json"]);
+    assert_eq!(dry["dryRun"], true);
+    assert_eq!(dry["removedVerboseFields"], 3);
+    let unchanged = fs::read_to_string(&path).unwrap();
+    assert!(unchanged.contains("stdoutSummary"));
+
+    let compacted = run_json(&root, ["task", "compact-proof", "--json"]);
+    assert_eq!(compacted["compacted"], true);
+    let changed = fs::read_to_string(&path).unwrap();
+    assert!(!changed.contains("stdoutSummary"));
+    assert!(changed.contains("evidenceFingerprint"));
+}
+
+#[test]
+fn record_proof_rejects_task_and_path_mismatched_receipts() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["README.md", "docs/**"],
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let checked = run_json(
+        &root,
+        ["task", "run-check", "--check", "diff-check", "--json"],
+    );
+    assert_eq!(checked["exitCode"], 0);
+
+    let mut state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    state["activeTask"]["id"] = json!("different-task");
+    write_json(&root, ".naome/task-state.json", &state);
+    let task_mismatch = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+    assert_eq!(
+        task_mismatch["findings"][0]["id"],
+        "task.proof.receipt_task_mismatch"
+    );
+
+    state["activeTask"]["id"] = json!("cli-task");
+    write_json(&root, ".naome/task-state.json", &state);
+    write_fixture_file(&root, "docs/new.md", "new\n");
+    let path_mismatch = run_json(
+        &root,
+        ["task", "record-proof", "--from-proof-plan", "--json"],
+    );
+    assert_eq!(
+        path_mismatch["findings"][0]["id"],
+        "task.proof.receipt_path_mismatch"
+    );
+}
+
+#[test]
+fn scope_suggestions_reports_test_support_helpers() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["scripts/**"],
+        "proofResults": []
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "scripts/new-flow.test.js", "test('x', () => {});\n");
+
+    let suggestions = run_json(
+        &root,
+        ["task", "scope-suggestions", "--from-changed", "--json"],
+    );
+
+    assert_eq!(suggestions["schema"], "naome.task.scope-suggestions.v1");
+    assert!(suggestions["suggestions"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|suggestion| suggestion["path"] == "scripts/naome-installer-support.js"));
+}
+
+#[test]
+fn commit_preflight_exit_code_reports_blocker() {
+    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", "commit-preflight", "--json", "--exit-code"])
+        .current_dir(root)
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(10));
+}

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

@@ -96,7 +96,7 @@ fn record_proof_rejects_receipts_from_older_same_path_content() {
     assert_eq!(recorded["recorded"], false);
     assert_eq!(
         recorded["findings"][0]["id"],
-        "task.proof.no_recent_success"
+        "task.proof.stale_receipt_content"
     );
 }
 

package/crates/naome-core/Cargo.toml

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

package/package.json

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