@lamentis/naome 1.4.4 → 1.4.6

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

@@ -7,7 +7,7 @@ mod write;
 
 use std::path::Path;
 
-use serde_json::Value;
+use serde_json::{json, Value};
 
 use crate::models::NaomeError;
 use crate::paths;
@@ -36,7 +36,7 @@ pub fn read_task_state_projection(root: &Path) -> Result<Option<Value>, NaomeErr
     if let Some(projection) = rendered {
         return Ok(Some(projection.state));
     }
-    Ok(legacy)
+    Ok(legacy.or_else(|| Some(idle_projection())))
 }
 
 pub fn render_task_state_from_ledger(
@@ -94,3 +94,14 @@ fn has_compact_proof_evidence(active_task: &Value) -> bool {
             .is_some_and(|entries| !entries.is_empty())
     })
 }
+
+fn idle_projection() -> Value {
+    json!({
+        "schema": "naome.task-state.v2",
+        "version": 2,
+        "status": "idle",
+        "activeTask": null,
+        "blocker": null,
+        "updatedAt": "1970-01-01T00:00:00.000Z"
+    })
+}

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

@@ -31,6 +31,10 @@ pub(super) fn validate_commit_gate(
     if changed_paths.is_empty() {
         return Ok(());
     }
+    validate_no_forced_local_runtime_commits(&staged_entries, errors);
+    if !errors.is_empty() {
+        return Ok(());
+    }
 
     let status = task_state
         .get("status")
@@ -93,6 +97,31 @@ pub(super) fn validate_commit_gate(
     Ok(())
 }
 
+fn validate_no_forced_local_runtime_commits(
+    staged_entries: &[ChangedEntry],
+    errors: &mut Vec<String>,
+) {
+    for entry in staged_entries {
+        if is_allowed_local_runtime_cleanup(entry) {
+            continue;
+        }
+        if is_local_only_runtime_path(&entry.path) {
+            errors.push(format!(
+                "NAOME commit gate blocked local-only runtime path: {}. Keep it local-only; only staged rm --cached cleanup deletions are allowed.",
+                entry.path
+            ));
+        }
+    }
+}
+
+fn is_allowed_local_runtime_cleanup(entry: &ChangedEntry) -> bool {
+    entry.status == "deleted" && is_local_only_runtime_path(&entry.path)
+}
+
+fn is_local_only_runtime_path(path: &str) -> bool {
+    path == ".naome/task-state.json" || path.starts_with(".naome/tasks/")
+}
+
 pub(super) fn validate_completed_task_for_harness_refresh(
     task_state: &Value,
     root: &Path,

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

@@ -3,8 +3,9 @@ use std::path::Path;
 use crate::models::NaomeError;
 
 use super::api::validate_task_state;
-use super::git_io::read_git_changed_paths;
+use super::git_io::read_git_changed_entries;
 use super::repair::is_safe_harness_refresh_path;
+use super::task_diff_api::is_local_only_untrack_cleanup;
 use super::types::{
     is_control_state_path, read_complete_active_task, CompletedTaskHarnessRefreshDiff,
     TaskStateMode, TaskStateOptions,
@@ -19,10 +20,16 @@ pub fn completed_task_harness_refresh_diff(
 
     let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
     let mut harness_paths = Vec::new();
+    let mut local_only_cleanup_paths = Vec::new();
     let mut task_paths = Vec::new();
     let mut other_paths = Vec::new();
 
-    for path in read_git_changed_paths(root)? {
+    for entry in read_git_changed_entries(root)? {
+        if is_local_only_untrack_cleanup(&entry) {
+            local_only_cleanup_paths.push(entry.path);
+            continue;
+        }
+        let path = entry.path;
         if is_control_state_path(&path) {
             continue;
         }
@@ -57,6 +64,7 @@ pub fn completed_task_harness_refresh_diff(
     {
         Ok(Some(CompletedTaskHarnessRefreshDiff {
             harness_paths,
+            local_only_cleanup_paths,
             task_paths,
         }))
     } else {

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

@@ -16,8 +16,8 @@ use super::shape::{
     validate_pending_upgrade, validate_required_check_ids, validate_task_state_shape,
 };
 use super::types::{
-    is_control_state_path, read_complete_active_task, CompletedTaskCommitDiff, HarnessRefreshDiff,
-    HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
+    is_control_state_path, is_local_runtime_path, read_complete_active_task, ChangedEntry,
+    CompletedTaskCommitDiff, HarnessRefreshDiff, HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
 };
 use super::util::{matches_any_pattern, string_array};
 
@@ -36,9 +36,17 @@ pub fn completed_task_commit_diff(
 
     let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
     let mut task_entries = Vec::new();
+    let mut local_only_cleanup_paths = Vec::new();
     let mut unrelated_paths = Vec::new();
     for entry in read_git_changed_entries(root)? {
-        if is_control_state_path(&entry.path) || matches_any_pattern(&entry.path, &allowed_paths) {
+        if is_local_only_untrack_cleanup(&entry) {
+            local_only_cleanup_paths.push(entry.path);
+            continue;
+        }
+        if is_control_state_path(&entry.path) || is_local_runtime_path(&entry.path) {
+            continue;
+        }
+        if matches_any_pattern(&entry.path, &allowed_paths) {
             task_entries.push(entry);
         } else {
             unrelated_paths.push(entry.path);
@@ -73,6 +81,7 @@ pub fn completed_task_commit_diff(
     let mut task_paths: Vec<String> = task_entries
         .into_iter()
         .map(|entry| entry.path)
+        .chain(local_only_cleanup_paths)
         .collect::<HashSet<_>>()
         .into_iter()
         .collect();
@@ -85,6 +94,11 @@ pub fn completed_task_commit_diff(
     }))
 }
 
+pub(super) fn is_local_only_untrack_cleanup(entry: &ChangedEntry) -> bool {
+    (entry.path == ".naome/task-state.json" || entry.path.starts_with(".naome/tasks/"))
+        && entry.status == "deleted"
+}
+
 pub fn harness_refresh_diff(root: &Path) -> Result<Option<HarnessRefreshDiff>, NaomeError> {
     let changed_paths = read_git_changed_paths(root)?;
     let has_repair_signal = changed_paths

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

@@ -67,6 +67,7 @@ pub(super) struct ChangedEntry {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CompletedTaskHarnessRefreshDiff {
     pub harness_paths: Vec<String>,
+    pub local_only_cleanup_paths: Vec<String>,
     pub task_paths: Vec<String>,
 }
 

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

@@ -9,10 +9,7 @@ fn classifies_naome_information_by_restore_source() {
 
     let projection = classify_information_path(".naome/task-state.json");
     assert_eq!(projection.class, "generated_projection");
-    assert_eq!(
-        projection.commit_policy,
-        "commit_when_required_by_compatibility"
-    );
+    assert_eq!(projection.commit_policy, "never_commit");
     assert_eq!(projection.restore_policy, "regenerate_from_durable_state");
 
     let local = classify_information_path(".naome/tmp/route.prompt");

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

@@ -9,6 +9,10 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert!(plan.machine_owned.contains(&"docs/naome/execution.md"));
     assert!(plan.project_owned.contains(&"docs/naome/architecture.md"));
     assert!(!plan.project_owned.contains(&".naome/tasks/**"));
+    assert!(!plan.project_owned.contains(&".naome/task-state.json"));
+    assert!(plan
+        .local_only_machine_owned
+        .contains(&".naome/task-state.json"));
     assert!(plan
         .local_only_machine_owned
         .contains(&".naome/bin/check-task-state.js"));
@@ -28,6 +32,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
     assert!(plan
         .gitignore_entries
         .contains(&".naome/task-journal.jsonl"));
+    assert!(plan.gitignore_entries.contains(&".naome/tasks/"));
     assert!(plan.git_exclude_entries.contains(&".naome/archive/"));
     assert!(plan.git_exclude_entries.contains(&".naome/cache/"));
     assert!(plan.git_exclude_entries.contains(&".naome/tasks/"));
@@ -35,6 +40,7 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
     assert!(plan
         .git_exclude_entries
         .contains(&".naome/task-journal.jsonl"));
+    assert!(plan.git_exclude_entries.contains(&".naome/task-state.json"));
     assert!(plan
         .git_exclude_entries
         .contains(&".naome/bin/check-harness-health.js"));
@@ -45,5 +51,6 @@ fn install_plan_includes_git_exclude_and_untrack_policy() {
     assert!(plan
         .git_untrack_paths
         .contains(&".naome/task-journal.jsonl"));
+    assert!(plan.git_untrack_paths.contains(&".naome/task-state.json"));
     assert!(plan.git_untrack_paths.contains(&"docs/naome/first-run.md"));
 }

package/crates/naome-core/tests/repo_support/mod.rs

@@ -14,8 +14,9 @@ pub use routes::{
     try_route_readme_task,
 };
 pub use verification_values::{
-    change_type, check_missing_last_verified_fixture, diff_check, minimal_task_state,
-    placeholder_verification_contract_fixture, quality_check, repo_docs_verification_fixture,
-    repository_quality_config_source, repository_quality_config_value, repository_semantic_check,
+    change_type, check_missing_last_verified_fixture, completed_task_state, diff_check,
+    minimal_task_state, placeholder_verification_contract_fixture, quality_check,
+    repo_docs_verification_fixture, repository_quality_config_source,
+    repository_quality_config_value, repository_semantic_check,
     semantic_repository_quality_fixture_source, verification_value,
 };

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

@@ -78,6 +78,110 @@ fn execute_route_auto_baselines_then_admits_next_task_and_writes_local_journal()
     assert!(journal.contains("\"outcome\":\"route_auto_baseline\""));
 }
 
+#[test]
+fn execute_route_preserves_cached_projection_untrack_cleanup() {
+    let repo = TestRepo::completed_task_with_diff("route-projection-untrack-cleanup");
+    let git_dir = repo.git_stdout(&["rev-parse", "--git-dir"]);
+    std::fs::write(
+        repo.path().join(git_dir).join("info").join("exclude"),
+        ".naome/task-state.json\n",
+    )
+    .unwrap();
+    repo.git(&["rm", "--cached", "-q", "--", ".naome/task-state.json"]);
+
+    let route = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_completed_task_then_create_new_task"
+    );
+    assert!(route.mutation_performed);
+    assert!(repo.git_status_short().is_empty());
+    let committed_paths = repo.git_stdout(&["show", "--name-status", "--format=", "HEAD"]);
+    assert!(committed_paths.contains("M\tREADME.md"));
+    assert!(committed_paths.contains("D\t.naome/task-state.json"));
+}
+
+#[test]
+fn execute_route_preserves_cached_ledger_untrack_cleanup() {
+    let repo = TestRepo::completed_task_with_diff("route-ledger-untrack-cleanup");
+    let git_dir = repo.git_stdout(&["rev-parse", "--git-dir"]);
+    std::fs::write(
+        repo.path().join(git_dir).join("info").join("exclude"),
+        ".naome/tasks/\n",
+    )
+    .unwrap();
+    repo.write_file(".naome/tasks/active.json", "{}\n");
+    repo.git(&["add", "-f", ".naome/tasks/active.json"]);
+    repo.git(&["commit", "-m", "track ledger runtime"]);
+    let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_base_naome_state(repo_support::completed_task_state(&admission_head));
+    repo.git(&["add", ".naome/task-state.json"]);
+    repo.git(&["commit", "-m", "refresh task state"]);
+    repo.git(&["rm", "--cached", "-q", "--", ".naome/tasks/active.json"]);
+
+    let route = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_completed_task_then_create_new_task"
+    );
+    assert!(route.mutation_performed);
+    assert!(repo.git_status_short().is_empty());
+    let committed_paths = repo.git_stdout(&["show", "--name-status", "--format=", "HEAD"]);
+    assert!(committed_paths.contains("M\tREADME.md"));
+    assert!(committed_paths.contains("D\t.naome/tasks/active.json"));
+}
+
+#[test]
+fn execute_route_preserves_projection_cleanup_in_harness_split_baseline() {
+    let repo = TestRepo::completed_task_with_harness_refresh_diff(
+        "route-harness-split-projection-cleanup",
+    );
+    let git_dir = repo.git_stdout(&["rev-parse", "--git-dir"]);
+    std::fs::write(
+        repo.path().join(git_dir).join("info").join("exclude"),
+        ".naome/task-state.json\n",
+    )
+    .unwrap();
+    repo.git(&["rm", "--cached", "-q", "--", ".naome/task-state.json"]);
+
+    let route = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+    );
+    assert_eq!(
+        route.executed_actions,
+        vec![
+            "commit_harness_refresh_baseline".to_string(),
+            "commit_task_baseline".to_string(),
+        ]
+    );
+    assert!(repo.git_status_short().is_empty());
+    let harness_commit_paths = repo.git_stdout(&["show", "--name-status", "--format=", "HEAD^"]);
+    assert!(harness_commit_paths.contains("D\t.naome/task-state.json"));
+}
+
+#[test]
+fn execute_route_does_not_preserve_cached_product_file_deletion_cleanup() {
+    let repo = TestRepo::completed_task_with_diff("route-product-untrack-ignored");
+    repo.git(&["rm", "--cached", "-q", "--", "README.md"]);
+
+    let route = route_new_task(&repo, "Start a new task for README polish.", true);
+
+    assert_eq!(
+        route.policy_action,
+        "auto_commit_completed_task_then_create_new_task"
+    );
+    assert!(route.mutation_performed);
+    assert!(repo.git_status_short().is_empty());
+    let committed_paths = repo.git_stdout(&["show", "--name-status", "--format=", "HEAD"]);
+    assert!(committed_paths.contains("M\tREADME.md"));
+    assert!(!committed_paths.contains("D\tREADME.md"));
+}
+
 #[test]
 fn execute_route_baselines_completed_task_and_creates_worktree_for_unrelated_user_edit() {
     let repo = TestRepo::completed_task_with_unrelated_user_edit("route-preserve-user-edit");

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

@@ -1,8 +1,13 @@
 use serde_json::json;
+use std::fs;
 
 mod repo_support;
 
-use repo_support::{route_readme_task, try_route_readme_task, TestRepo};
+use naome_core::read_task_state_projection;
+use repo_support::{
+    completed_task_state, diff_check, route_readme_task, try_route_readme_task, verification_value,
+    TestRepo,
+};
 
 #[test]
 fn execute_route_refuses_to_create_more_than_max_isolated_worktrees() {
@@ -52,3 +57,44 @@ fn execute_route_uses_preflighted_worktree_name_after_completed_task_baseline()
     assert!(worktree.branch.contains(before_short));
     assert!(worktree.path.contains(before_short));
 }
+
+#[test]
+fn execute_route_resets_local_task_state_projection_in_isolated_worktree() {
+    let repo = TestRepo::new("route-worktree-no-stale-projection");
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n.naome/tasks/\n");
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_file("USER.md", "user baseline\n");
+    repo.write_naome_json(
+        "init-state.json",
+        json!({ "initialized": true, "intakeStatus": "complete" }),
+    );
+    repo.write_naome_json("upgrade-state.json", json!({ "status": "complete" }));
+    repo.write_naome_json(
+        "verification.json",
+        verification_value("ready", vec![diff_check(vec!["README.md"])], vec![]),
+    );
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let git_dir = repo.git_stdout(&["rev-parse", "--git-dir"]);
+    std::fs::write(
+        repo.path().join(git_dir).join("info").join("exclude"),
+        ".naome/task-state.json\n",
+    )
+    .unwrap();
+    let admission_head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_naome_json("task-state.json", completed_task_state(&admission_head));
+    repo.write_file("README.md", "# Changed\n");
+    repo.write_file("USER.md", "user local edit\n");
+
+    let route = route_readme_task(&repo, true);
+    let task_root = route.task_root.as_str();
+
+    assert_ne!(task_root, repo.path().to_string_lossy().as_ref());
+    assert!(fs::exists(std::path::Path::new(task_root).join(".naome/task-state.json")).unwrap());
+    let projection = read_task_state_projection(std::path::Path::new(task_root))
+        .unwrap()
+        .unwrap();
+    assert_eq!(projection["status"], "idle");
+    assert_eq!(projection["activeTask"], serde_json::Value::Null);
+}