@lamentis/naome 1.4.2 → 1.4.4

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

@@ -0,0 +1,109 @@
+use std::path::Path;
+use std::process::Command;
+
+use serde_json::json;
+
+use super::common::{agent_session, print_json_with_session};
+use super::path_policy::is_ignored;
+use super::planner;
+
+pub(super) fn scope_suggestions(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let session = agent_session(args)?;
+    if !args.iter().any(|arg| arg == "--from-changed") {
+        return Err("naome task scope-suggestions requires --from-changed".into());
+    }
+    let mut suggestions = rename_suggestions(root)
+        .into_iter()
+        .chain(loader_suggestions(root))
+        .filter(|suggestion| {
+            !suggestion
+                .get("path")
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|path| is_ignored(root, path))
+        })
+        .collect::<Vec<_>>();
+    suggestions.sort_by(|left, right| {
+        left.get("path")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or("")
+            .cmp(
+                right
+                    .get("path")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or(""),
+            )
+    });
+    print_json_with_session(
+        json!({
+            "schema": "naome.task.scope-suggestions.v1",
+            "suggestions": suggestions,
+            "agentInstruction": "Suggestions are read-only hints; task scope mutation still requires explicit approval."
+        }),
+        session.as_deref(),
+    )
+}
+
+fn rename_suggestions(root: &Path) -> Vec<serde_json::Value> {
+    let Ok(output) = Command::new("git")
+        .args(["status", "--porcelain=v1", "-z"])
+        .current_dir(root)
+        .output()
+    else {
+        return Vec::new();
+    };
+    if !output.status.success() {
+        return Vec::new();
+    }
+    let mut suggestions = Vec::new();
+    let entries = output.stdout.split(|byte| *byte == 0).collect::<Vec<_>>();
+    let mut index = 0;
+    while index < entries.len() {
+        let entry = entries[index];
+        index += 1;
+        if entry.len() < 4 {
+            continue;
+        }
+        let status = String::from_utf8_lossy(&entry[..2]);
+        if status.contains('R') && index < entries.len() {
+            let old = String::from_utf8_lossy(entries[index]).replace('\\', "/");
+            index += 1;
+            let new = String::from_utf8_lossy(&entry[3..]).replace('\\', "/");
+            for path in [old, new] {
+                suggestions.push(json!({
+                    "path": path,
+                    "reason": "paired path for renamed file",
+                    "confidence": 0.95,
+                    "requiresUserApproval": true
+                }));
+            }
+        }
+    }
+    suggestions
+}
+
+fn loader_suggestions(root: &Path) -> Vec<serde_json::Value> {
+    planner::changed_paths(root)
+        .into_iter()
+        .filter(|path| path.ends_with(".test.js") || path.ends_with("_test.rs"))
+        .filter_map(|path| {
+            let loader = if path.starts_with("scripts/") {
+                Some("scripts/naome-installer-support.js".to_string())
+            } else if path.contains("/tests/") {
+                path.split("/tests/")
+                    .next()
+                    .map(|prefix| format!("{prefix}/tests/support/mod.rs"))
+            } else {
+                None
+            }?;
+            Some(json!({
+                "path": loader,
+                "reason": "fixture support helper for changed test",
+                "confidence": 0.7,
+                "requiresUserApproval": true
+            }))
+        })
+        .collect()
+}

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,332 @@
+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, write_verification_checks,
+};
+
+#[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 agent_snapshot_merges_duplicate_check_reasons_from_proof_and_impact_plans() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["src/lib.rs"],
+        "requiredCheckIds": ["repository-quality-check"],
+        "proofResults": []
+    }))));
+    write_verification_checks(
+        &root,
+        json!([{
+            "id": "repository-quality-check",
+            "command": "node .naome/bin/naome.js quality check --changed",
+            "cwd": ".",
+            "purpose": "Validate changed-file quality.",
+            "cost": "fast",
+            "source": "NAOME",
+            "evidence": [".naome/repository-quality.json"],
+            "lastVerified": null
+        }]),
+    );
+    init_git(&root);
+    write_fixture_file(&root, "src/lib.rs", "pub fn changed() {}\n");
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+    let commands = snapshot["checks"]["recommended"].as_array().unwrap();
+    let quality_commands = commands
+        .iter()
+        .filter(|command| command["checkId"] == "repository-quality-check")
+        .collect::<Vec<_>>();
+
+    assert_eq!(quality_commands.len(), 1);
+    assert_eq!(
+        quality_commands[0]["reason"],
+        "changed_source,missing-proof"
+    );
+    assert_eq!(
+        quality_commands[0]["selectionReason"],
+        "changed_source,missing-proof"
+    );
+    assert_eq!(quality_commands[0]["impactedPaths"], json!(["src/lib.rs"]));
+}
+
+#[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.4"
 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.4",
   "description": "Native-first CLI for the NAOME agent harness.",
   "license": "Apache-2.0",
   "type": "module",