@lamentis/naome 1.4.5 → 1.4.6

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.4.5"
+version = "1.4.6"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.4.5"
+version = "1.4.6"
 dependencies = [
  "serde",
  "serde_json",

package/crates/naome-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-cli"
-version = "1.4.5"
+version = "1.4.6"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -197,6 +197,7 @@ fn find_harness_root(start: &Path) -> Option<PathBuf> {
         &[
             &[".naome", "task-state.json"],
             &[".naome", "tasks", "active.json"],
+            &[".naome", "manifest.json"],
         ],
     )
 }

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

@@ -1,12 +1,12 @@
 use std::fs;
 use std::path::Path;
 
+use naome_core::read_task_state_projection;
 use serde_json::{json, Value};
 
 pub(super) fn read_task_state(root: &Path) -> Result<Value, Box<dyn std::error::Error>> {
-    Ok(serde_json::from_str(&fs::read_to_string(
-        root.join(".naome/task-state.json"),
-    )?)?)
+    read_task_state_projection(root)?
+        .ok_or_else(|| "NAOME task-state projection is unavailable.".into())
 }
 
 pub(super) fn write_task_state(

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

@@ -0,0 +1,59 @@
+mod task_cli_support;
+
+use std::fs;
+
+use task_cli_support::{fixture_root, git, run_json, task_state, write_json};
+
+#[test]
+fn task_control_commands_work_without_task_state_projection_file() {
+    let root = fixture_root(task_state());
+    fs::remove_file(root.join(".naome/task-state.json")).unwrap();
+    write_json(
+        &root,
+        ".naome/manifest.json",
+        &serde_json::json!({
+            "schema": "naome.manifest.v1",
+            "name": "naome",
+            "harnessVersion": "1.4.6"
+        }),
+    );
+    git(&root, ["init"]);
+    git(&root, ["config", "user.email", "naome@example.com"]);
+    git(&root, ["config", "user.name", "NAOME Test"]);
+    git(
+        &root,
+        [
+            "add",
+            ".naomeignore",
+            ".naome/manifest.json",
+            ".naome/verification.json",
+            "README.md",
+        ],
+    );
+    git(&root, ["commit", "-m", "baseline"]);
+
+    let status = run_json(&root, ["task", "status", "--json"]);
+    assert_eq!(status["state"], "idle");
+    assert_eq!(status["taskId"], serde_json::Value::Null);
+    assert_eq!(status["proof"]["missingChecks"], serde_json::json!([]));
+
+    let proof_plan = run_json(&root, ["task", "proof-plan", "--json"]);
+    assert_eq!(proof_plan["state"], "idle");
+    assert_eq!(proof_plan["proof"]["requiredChecks"], serde_json::json!([]));
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+    assert_eq!(snapshot["task"]["state"], "idle");
+    assert_eq!(snapshot["nextAction"]["type"], "blocked");
+    assert_eq!(
+        snapshot["nextAction"]["primaryFindingId"],
+        "task.transition.no_active_task"
+    );
+
+    let commit_preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+    assert_eq!(commit_preflight["wouldPass"], false);
+    assert_eq!(commit_preflight["nextAction"]["type"], "blocked");
+    assert_eq!(
+        commit_preflight["nextAction"]["primaryFindingId"],
+        "task.transition.no_active_task"
+    );
+}

package/crates/naome-core/Cargo.toml

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

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

@@ -39,7 +39,7 @@ const CLASSES: &[(&str, &str, &str, &str)] = &[
     (
         "generated_projection",
         "Compatibility views generated from durable state.",
-        "commit_when_required_by_compatibility",
+        "never_commit",
         "regenerate_from_durable_state",
     ),
     (

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

@@ -21,7 +21,6 @@ pub const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naomeignore",
     ".naome/init-state.json",
     ".naome/manifest.json",
-    ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
     ".naome/repository-model.json",
@@ -43,6 +42,7 @@ pub const LOCAL_ONLY_MACHINE_OWNED_PATHS: &[&str] = &[
     ".naome/bin/naome.js",
     ".naome/bin/check-task-state.js",
     ".naome/bin/check-harness-health.js",
+    ".naome/task-state.json",
     ".naome/task-contract.schema.json",
     "docs/naome/index.md",
     "docs/naome/first-run.md",
@@ -76,7 +76,7 @@ pub struct InstallPlan {
 }
 
 pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
-    let gitignore_entries = vec![".naome/task-journal.jsonl"];
+    let gitignore_entries = vec![".naome/task-journal.jsonl", ".naome/tasks/"];
     let mut git_exclude_entries = vec![
         "# NAOME local machine-owned harness files.",
         ".naome/archive/",

package/crates/naome-core/src/route/execution_baselines.rs

@@ -56,7 +56,9 @@ pub(super) fn baseline_harness_refresh_then_completed_task(
             "Unable to split harness refresh paths from completed task diff.",
         ));
     };
-    commit_harness_paths(root, &split.harness_paths, execution)?;
+    let mut harness_paths = split.harness_paths;
+    harness_paths.extend(split.local_only_cleanup_paths);
+    commit_harness_paths(root, &harness_paths, execution)?;
     baseline_completed_task(
         root,
         "route_auto_baseline",

package/crates/naome-core/src/route/git_ops.rs

@@ -29,8 +29,10 @@ pub(super) fn git_add_completed_task_paths(root: &Path) -> Result<(), NaomeError
 }
 
 pub(super) fn git_stage_only_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    let cached_only_deletions = staged_deletions_with_local_files(root, paths)?;
     ensure_git_success(git_output(root, &["reset", "-q", "--", "."])?)?;
-    git_add_paths(root, paths)
+    git_add_paths(root, paths)?;
+    git_rm_cached_paths(root, &cached_only_deletions)
 }
 
 fn git_add_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
@@ -81,6 +83,51 @@ fn git_ls_files(
     }
 }
 
+fn staged_deletions_with_local_files(
+    root: &Path,
+    paths: &[String],
+) -> Result<Vec<String>, NaomeError> {
+    if paths.is_empty() {
+        return Ok(Vec::new());
+    }
+    let mut args = vec!["diff", "--name-status", "--cached", "-z", "--"];
+    args.extend(paths.iter().map(String::as_str));
+    let output = Command::new("git").args(args).current_dir(root).output()?;
+    if !output.status.success() {
+        return Err(NaomeError::new(command_output(&output)));
+    }
+
+    let mut deletions = Vec::new();
+    let tokens = split_nul_paths(&output.stdout);
+    let mut index = 0;
+    while index + 1 < tokens.len() {
+        let status = &tokens[index];
+        let path = tokens[index + 1].clone();
+        index += if status.starts_with('R') || status.starts_with('C') {
+            3
+        } else {
+            2
+        };
+        if status == "D" && root.join(&path).exists() && is_local_only_cleanup_path(&path) {
+            deletions.push(path);
+        }
+    }
+    Ok(deletions)
+}
+
+fn git_rm_cached_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    if paths.is_empty() {
+        return Ok(());
+    }
+    let mut args = vec!["rm", "--cached", "-q", "--ignore-unmatch", "--"];
+    args.extend(paths.iter().map(String::as_str));
+    ensure_git_success(Command::new("git").args(args).current_dir(root).output()?)
+}
+
+fn is_local_only_cleanup_path(path: &str) -> bool {
+    path == ".naome/task-state.json" || path.starts_with(".naome/tasks/")
+}
+
 fn split_nul_paths(bytes: &[u8]) -> Vec<String> {
     String::from_utf8_lossy(bytes)
         .split('\0')

package/crates/naome-core/src/route/worktree_files.rs

@@ -1,5 +1,6 @@
 use std::fs;
 use std::path::Path;
+use std::process::Command;
 
 use crate::install_plan::{LOCAL_NATIVE_BINARY_PATHS, LOCAL_ONLY_MACHINE_OWNED_PATHS};
 use crate::models::NaomeError;
@@ -13,7 +14,10 @@ pub(super) fn copy_local_harness_files(
     paths.extend_from_slice(LOCAL_NATIVE_BINARY_PATHS);
 
     for relative_path in paths {
-        if relative_path == ".naome/archive" || relative_path == ".naome/task-journal.jsonl" {
+        if relative_path == ".naome/archive"
+            || relative_path == ".naome/task-journal.jsonl"
+            || relative_path == ".naome/task-state.json"
+        {
             continue;
         }
 
@@ -27,6 +31,37 @@ pub(super) fn copy_local_harness_files(
         }
         fs::copy(&source, &destination)?;
     }
+    write_idle_projection_if_local_only(worktree_root)?;
 
     Ok(())
 }
+
+fn write_idle_projection_if_local_only(worktree_root: &Path) -> Result<(), NaomeError> {
+    let output = Command::new("git")
+        .args([
+            "ls-files",
+            "--error-unmatch",
+            "--",
+            ".naome/task-state.json",
+        ])
+        .current_dir(worktree_root)
+        .output()?;
+    if output.status.success() {
+        return Ok(());
+    }
+
+    fs::write(
+        worktree_root.join(".naome/task-state.json"),
+        concat!(
+            "{\n",
+            "  \"schema\": \"naome.task-state.v2\",\n",
+            "  \"version\": 2,\n",
+            "  \"status\": \"idle\",\n",
+            "  \"activeTask\": null,\n",
+            "  \"blocker\": null,\n",
+            "  \"updatedAt\": \"1970-01-01T00:00:00.000Z\"\n",
+            "}\n"
+        ),
+    )?;
+    Ok(())
+}

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");