@lamentis/naome 1.4.5 → 1.4.6

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

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

@@ -1,12 +1,30 @@
 mod repo_support;
+mod task_ledger_support;
 
 use naome_core::{
-    migrate_task_state_to_ledger, read_task_state_projection, render_task_state_from_ledger,
-    validate_task_state, TaskStateMode, TaskStateOptions,
+    completed_task_commit_paths, migrate_task_state_to_ledger, read_task_state_projection,
+    render_task_state_from_ledger, validate_task_state, TaskStateMode, TaskStateOptions,
 };
-use serde_json::{json, Map, Value};
+use serde_json::{json, Value};
 
-use repo_support::{diff_check, verification_value, TestRepo};
+use repo_support::TestRepo;
+use task_ledger_support::{
+    compact_complete_state, compact_task_spec_record, format_json, idle_state, object,
+    task_spec_record_with_id, LedgerHarness,
+};
+
+#[test]
+fn missing_task_state_projection_derives_idle_state() {
+    let repo = TestRepo::new("missing-projection");
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+
+    assert_eq!(state["schema"], "naome.task-state.v2");
+    assert_eq!(state["status"], "idle");
+    assert_eq!(state["activeTask"], Value::Null);
+    assert_eq!(state["blocker"], Value::Null);
+    assert_eq!(state["updatedAt"], "1970-01-01T00:00:00.000Z");
+}
 
 #[test]
 fn ledger_projection_renders_compatible_task_state_without_task_state_json() {
@@ -37,6 +55,76 @@ fn ledger_projection_renders_compatible_task_state_without_task_state_json() {
     assert!(report.errors.is_empty(), "{:?}", report.errors);
 }
 
+#[test]
+fn completed_task_commit_paths_exclude_local_task_state_projection() {
+    let repo = TestRepo::new("commit-with-local-projection");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(None);
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    render_task_state_from_ledger(repo.path(), true).unwrap();
+    repo.write_file("README.md", "# Changed\n");
+
+    let paths = completed_task_commit_paths(repo.path()).unwrap();
+
+    assert_eq!(paths, vec!["README.md"]);
+}
+
+#[test]
+fn completed_task_commit_paths_include_tracked_projection_untrack_deletion() {
+    let repo = TestRepo::new("commit-with-projection-deletion");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    repo.write_file("README.md", "# Changed\n");
+    repo.git(&["rm", "--cached", "-q", "--", ".naome/task-state.json"]);
+
+    let paths = completed_task_commit_paths(repo.path()).unwrap();
+
+    assert_eq!(paths, vec![".naome/task-state.json", "README.md"]);
+    assert!(repo.path().join(".naome/task-state.json").is_file());
+}
+
+#[test]
+fn local_runtime_ledgers_can_diverge_between_parallel_worktrees() {
+    let repo = TestRepo::new("parallel-ledger-main");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(None);
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let branch_root = repo.path().with_file_name(format!(
+        "{}-branch",
+        repo.path().file_name().unwrap().to_string_lossy()
+    ));
+    repo.git(&[
+        "worktree",
+        "add",
+        "-b",
+        "parallel-ledger-branch",
+        branch_root.to_str().unwrap(),
+        "HEAD",
+    ]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    write_branch_ledger(&branch_root, &head, "branch-task");
+
+    let main_state = read_task_state_projection(repo.path()).unwrap().unwrap();
+    let branch_state = read_task_state_projection(&branch_root).unwrap().unwrap();
+
+    assert_eq!(main_state["activeTask"]["id"], "readme-task");
+    assert_eq!(branch_state["activeTask"]["id"], "branch-task");
+    assert!(!repo.path().join(".naome/task-state.json").exists());
+    assert!(!branch_root.join(".naome/task-state.json").exists());
+}
+
 #[test]
 fn task_state_json_remains_backward_compatible_when_no_ledger_exists() {
     let repo = TestRepo::new("legacy");
@@ -47,6 +135,29 @@ fn task_state_json_remains_backward_compatible_when_no_ledger_exists() {
     assert_eq!(state["status"], "idle");
 }
 
+#[test]
+fn ignored_ledger_keeps_cli_written_projection_authoritative() {
+    let repo = TestRepo::new("ignored-ledger-with-cli-projection");
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n.naome/tasks/\n");
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    repo.write_naome_json("task-state.json", compact_complete_state(&head));
+    repo.write_file("README.md", "# Changed\n");
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+
+    assert_eq!(state["status"], "complete");
+    assert_eq!(
+        state["activeTask"]["proofBatches"][0]["proofs"][0]["checkId"],
+        "diff-check"
+    );
+}
+
 #[test]
 fn renderer_can_write_projection_for_external_tools() {
     let repo = TestRepo::new("write");
@@ -254,205 +365,32 @@ fn compact_completed_task_state_survives_incomplete_local_runtime_ledger() {
     assert!(report.errors.is_empty(), "{:?}", report.errors);
 }
 
-trait LedgerHarness {
-    fn write_base_harness(&self, task_state: Option<Value>);
-    fn write_complete_ledger(&self, admission_head: &str);
-}
-
-impl LedgerHarness for TestRepo {
-    fn write_base_harness(&self, task_state: Option<Value>) {
-        self.write_naome_json(
-            "init-state.json",
-            json!({ "initialized": true, "intakeStatus": "complete" }),
-        );
-        self.write_naome_json(
-            "upgrade-state.json",
-            json!({ "status": "complete", "pending": [] }),
-        );
-        self.write_naome_json(
-            "verification.json",
-            verification_value("ready", vec![diff_check(vec!["README.md"])], vec![]),
-        );
-        if let Some(state) = task_state {
-            self.write_naome_json("task-state.json", state);
-        }
-    }
-
-    fn write_complete_ledger(&self, admission_head: &str) {
-        self.write_file(
-            ".naome/tasks/active.json",
-            &format_json(object([
-                ("schema", json!("naome.task-ledger-active.v1")),
-                ("version", json!(1)),
-                ("primaryTaskId", json!("readme-task")),
-                (
-                    "worklanes",
-                    json!([{ "id": "default", "taskId": "readme-task", "status": "active" }]),
-                ),
-            ])),
-        );
-        self.write_file(
-            ".naome/tasks/readme-task/task.json",
-            &format_json(task_spec_record(admission_head)),
-        );
-        self.write_file(
-            ".naome/tasks/readme-task/events.jsonl",
-            concat!(
-                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"implementing\",\"recordedAt\":\"2026-05-08T00:00:01.000Z\"}\n",
-                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"complete\",\"recordedAt\":\"2026-05-08T00:00:02.000Z\"}\n"
+fn write_branch_ledger(root: &std::path::Path, admission_head: &str, task_id: &str) {
+    std::fs::create_dir_all(root.join(".naome/tasks").join(task_id)).unwrap();
+    std::fs::write(
+        root.join(".naome/tasks/active.json"),
+        format_json(object([
+            ("schema", json!("naome.task-ledger-active.v1")),
+            ("version", json!(1)),
+            ("primaryTaskId", json!(task_id)),
+            (
+                "worklanes",
+                json!([{ "id": "default", "taskId": task_id, "status": "active" }]),
             ),
-        );
-        self.write_file(
-            ".naome/tasks/readme-task/mutations.json",
-            &format_json(object([
-                ("schema", json!("naome.task-ledger-mutations.v1")),
-                ("version", json!(1)),
-                ("taskId", json!("readme-task")),
-                ("touchedPaths", json!(["README.md"])),
-                (
-                    "entries",
-                    json!([{ "path": "README.md", "class": "source change", "owner": "agent" }]),
-                ),
-            ])),
-        );
-        self.write_file(
-            ".naome/tasks/readme-task/proofs/diff-check.json",
-            &format_json(diff_proof_record()),
-        );
-    }
-}
-
-fn idle_state() -> Value {
-    object([
-        ("schema", json!("naome.task-state.v1")),
-        ("version", json!(1)),
-        ("status", json!("idle")),
-        ("activeTask", Value::Null),
-        ("blocker", Value::Null),
-        ("updatedAt", json!("2026-05-08T00:00:00.000Z")),
-    ])
-}
-
-fn compact_complete_state(admission_head: &str) -> Value {
-    object([
-        ("schema", json!("naome.task-state.v2")),
-        ("version", json!(2)),
-        ("status", json!("complete")),
-        ("activeTask", compact_active_task(admission_head)),
-        ("blocker", Value::Null),
-        ("updatedAt", json!("2026-05-08T00:00:04.000Z")),
-    ])
-}
-
-fn compact_active_task(admission_head: &str) -> Value {
-    object([
-        ("id", json!("readme-task")),
-        ("request", json!("Update README.")),
-        ("userPrompt", user_prompt()),
-        ("admission", admission_record(admission_head)),
-        ("allowedPaths", json!(["README.md"])),
-        ("declaredChangeTypes", json!(["product-docs"])),
-        ("requiredCheckIds", json!(["diff-check"])),
-        ("proofResults", json!([])),
-        ("proofPathSets", object([("changed", json!(["README.md"]))])),
-        ("proofBatches", json!([compact_proof_batch()])),
-        ("revisions", json!([])),
-        ("humanReview", human_review()),
-    ])
-}
-
-fn task_spec_record(admission_head: &str) -> Value {
-    task_spec_record_with_id(admission_head, "readme-task")
-}
-
-fn task_spec_record_with_id(admission_head: &str, task_id: &str) -> Value {
-    object([
-        ("schema", json!("naome.task-ledger-task.v1")),
-        ("version", json!(1)),
-        ("id", json!(task_id)),
-        ("request", json!("Update README.")),
-        ("userPrompt", user_prompt()),
-        ("admission", admission_record(admission_head)),
-        ("allowedPaths", json!(["README.md"])),
-        ("declaredChangeTypes", json!(["product-docs"])),
-        ("requiredCheckIds", json!(["diff-check"])),
-        ("humanReview", human_review()),
-    ])
-}
-
-fn compact_task_spec_record(admission_head: &str) -> Value {
-    let mut task = task_spec_record(admission_head);
-    let task_object = task.as_object_mut().unwrap();
-    task_object.insert(
-        "proofPathSets".to_string(),
-        object([("changed", json!(["README.md"]))]),
-    );
-    task_object.insert("proofBatches".to_string(), json!([compact_proof_batch()]));
-    task
-}
-
-fn diff_proof_record() -> Value {
-    object([
-        ("schema", json!("naome.task-ledger-proof.v1")),
-        ("version", json!(1)),
-        ("taskId", json!("readme-task")),
-        ("checkId", json!("diff-check")),
-        ("command", json!("git diff --check")),
-        ("cwd", json!(".")),
-        ("exitCode", json!(0)),
-        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
-        ("evidence", json!(["README.md"])),
-    ])
-}
-
-fn compact_proof_batch() -> Value {
-    object([
-        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
-        ("evidencePathSet", json!("changed")),
-        (
-            "proofs",
-            json!([{ "checkId": "diff-check", "exitCode": 0 }]),
-        ),
-    ])
-}
-
-fn admission_record(git_head: &str) -> Value {
-    object([
-        (
-            "command",
-            json!("node .naome/bin/check-task-state.js --admission"),
+        ])),
+    )
+    .unwrap();
+    std::fs::write(
+        root.join(".naome/tasks").join(task_id).join("task.json"),
+        format_json(task_spec_record_with_id(admission_head, task_id)),
+    )
+    .unwrap();
+    std::fs::write(
+        root.join(".naome/tasks").join(task_id).join("events.jsonl"),
+        concat!(
+            "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"implementing\",\"recordedAt\":\"2026-05-08T00:00:01.000Z\"}\n",
+            "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"complete\",\"recordedAt\":\"2026-05-08T00:00:02.000Z\"}\n"
         ),
-        ("cwd", json!(".")),
-        ("exitCode", json!(0)),
-        ("checkedAt", json!("2026-05-08T00:00:00.000Z")),
-        ("gitHead", json!(git_head)),
-        ("changedPaths", json!([])),
-    ])
-}
-
-fn user_prompt() -> Value {
-    object([
-        ("receivedAt", json!("2026-05-08T00:00:00.000Z")),
-        ("text", json!("Update README.")),
-    ])
-}
-
-fn human_review() -> Value {
-    object([
-        ("required", json!(false)),
-        ("approved", json!(false)),
-        ("reason", Value::Null),
-    ])
-}
-
-fn object<const N: usize>(entries: [(&str, Value); N]) -> Value {
-    let mut map = Map::new();
-    for (key, value) in entries {
-        map.insert(key.to_string(), value);
-    }
-    Value::Object(map)
-}
-
-fn format_json(value: Value) -> String {
-    format!("{}\n", serde_json::to_string_pretty(&value).unwrap())
+    )
+    .unwrap();
 }

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

@@ -0,0 +1,206 @@
+use serde_json::{json, Map, Value};
+
+use super::repo_support::{diff_check, verification_value, TestRepo};
+
+pub trait LedgerHarness {
+    fn write_base_harness(&self, task_state: Option<Value>);
+    fn write_complete_ledger(&self, admission_head: &str);
+}
+
+impl LedgerHarness for TestRepo {
+    fn write_base_harness(&self, task_state: Option<Value>) {
+        self.write_naome_json(
+            "init-state.json",
+            json!({ "initialized": true, "intakeStatus": "complete" }),
+        );
+        self.write_naome_json(
+            "upgrade-state.json",
+            json!({ "status": "complete", "pending": [] }),
+        );
+        self.write_naome_json(
+            "verification.json",
+            verification_value("ready", vec![diff_check(vec!["README.md"])], vec![]),
+        );
+        if let Some(state) = task_state {
+            self.write_naome_json("task-state.json", state);
+        }
+    }
+
+    fn write_complete_ledger(&self, admission_head: &str) {
+        self.write_file(
+            ".naome/tasks/active.json",
+            &format_json(object([
+                ("schema", json!("naome.task-ledger-active.v1")),
+                ("version", json!(1)),
+                ("primaryTaskId", json!("readme-task")),
+                (
+                    "worklanes",
+                    json!([{ "id": "default", "taskId": "readme-task", "status": "active" }]),
+                ),
+            ])),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/task.json",
+            &format_json(task_spec_record(admission_head)),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/events.jsonl",
+            concat!(
+                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"implementing\",\"recordedAt\":\"2026-05-08T00:00:01.000Z\"}\n",
+                "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"complete\",\"recordedAt\":\"2026-05-08T00:00:02.000Z\"}\n"
+            ),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/mutations.json",
+            &format_json(object([
+                ("schema", json!("naome.task-ledger-mutations.v1")),
+                ("version", json!(1)),
+                ("taskId", json!("readme-task")),
+                ("touchedPaths", json!(["README.md"])),
+                (
+                    "entries",
+                    json!([{ "path": "README.md", "class": "source change", "owner": "agent" }]),
+                ),
+            ])),
+        );
+        self.write_file(
+            ".naome/tasks/readme-task/proofs/diff-check.json",
+            &format_json(diff_proof_record()),
+        );
+    }
+}
+
+pub fn idle_state() -> Value {
+    object([
+        ("schema", json!("naome.task-state.v1")),
+        ("version", json!(1)),
+        ("status", json!("idle")),
+        ("activeTask", Value::Null),
+        ("blocker", Value::Null),
+        ("updatedAt", json!("2026-05-08T00:00:00.000Z")),
+    ])
+}
+
+pub fn compact_complete_state(admission_head: &str) -> Value {
+    object([
+        ("schema", json!("naome.task-state.v2")),
+        ("version", json!(2)),
+        ("status", json!("complete")),
+        ("activeTask", compact_active_task(admission_head)),
+        ("blocker", Value::Null),
+        ("updatedAt", json!("2026-05-08T00:00:04.000Z")),
+    ])
+}
+
+pub fn task_spec_record_with_id(admission_head: &str, task_id: &str) -> Value {
+    object([
+        ("schema", json!("naome.task-ledger-task.v1")),
+        ("version", json!(1)),
+        ("id", json!(task_id)),
+        ("request", json!("Update README.")),
+        ("userPrompt", user_prompt()),
+        ("admission", admission_record(admission_head)),
+        ("allowedPaths", json!(["README.md"])),
+        ("declaredChangeTypes", json!(["product-docs"])),
+        ("requiredCheckIds", json!(["diff-check"])),
+        ("humanReview", human_review()),
+    ])
+}
+
+pub fn compact_task_spec_record(admission_head: &str) -> Value {
+    let mut task = task_spec_record(admission_head);
+    let task_object = task.as_object_mut().unwrap();
+    task_object.insert(
+        "proofPathSets".to_string(),
+        object([("changed", json!(["README.md"]))]),
+    );
+    task_object.insert("proofBatches".to_string(), json!([compact_proof_batch()]));
+    task
+}
+
+pub fn object<const N: usize>(entries: [(&str, Value); N]) -> Value {
+    let mut map = Map::new();
+    for (key, value) in entries {
+        map.insert(key.to_string(), value);
+    }
+    Value::Object(map)
+}
+
+pub fn format_json(value: Value) -> String {
+    format!("{}\n", serde_json::to_string_pretty(&value).unwrap())
+}
+
+fn compact_active_task(admission_head: &str) -> Value {
+    object([
+        ("id", json!("readme-task")),
+        ("request", json!("Update README.")),
+        ("userPrompt", user_prompt()),
+        ("admission", admission_record(admission_head)),
+        ("allowedPaths", json!(["README.md"])),
+        ("declaredChangeTypes", json!(["product-docs"])),
+        ("requiredCheckIds", json!(["diff-check"])),
+        ("proofResults", json!([])),
+        ("proofPathSets", object([("changed", json!(["README.md"]))])),
+        ("proofBatches", json!([compact_proof_batch()])),
+        ("revisions", json!([])),
+        ("humanReview", human_review()),
+    ])
+}
+
+fn task_spec_record(admission_head: &str) -> Value {
+    task_spec_record_with_id(admission_head, "readme-task")
+}
+
+fn diff_proof_record() -> Value {
+    object([
+        ("schema", json!("naome.task-ledger-proof.v1")),
+        ("version", json!(1)),
+        ("taskId", json!("readme-task")),
+        ("checkId", json!("diff-check")),
+        ("command", json!("git diff --check")),
+        ("cwd", json!(".")),
+        ("exitCode", json!(0)),
+        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
+        ("evidence", json!(["README.md"])),
+    ])
+}
+
+fn compact_proof_batch() -> Value {
+    object([
+        ("checkedAt", json!("2026-05-08T00:00:03.000Z")),
+        ("evidencePathSet", json!("changed")),
+        (
+            "proofs",
+            json!([{ "checkId": "diff-check", "exitCode": 0 }]),
+        ),
+    ])
+}
+
+fn admission_record(git_head: &str) -> Value {
+    object([
+        (
+            "command",
+            json!("node .naome/bin/check-task-state.js --admission"),
+        ),
+        ("cwd", json!(".")),
+        ("exitCode", json!(0)),
+        ("checkedAt", json!("2026-05-08T00:00:00.000Z")),
+        ("gitHead", json!(git_head)),
+        ("changedPaths", json!([])),
+    ])
+}
+
+fn user_prompt() -> Value {
+    object([
+        ("receivedAt", json!("2026-05-08T00:00:00.000Z")),
+        ("text", json!("Update README.")),
+    ])
+}
+
+fn human_review() -> Value {
+    object([
+        ("required", json!(false)),
+        ("approved", json!(false)),
+        ("reason", Value::Null),
+    ])
+}

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

@@ -275,7 +275,44 @@ fn commit_gate_ignores_unstaged_user_edits_outside_completed_task_scope() {
     repo.init_git();
     repo.write("README.md", "# Task result\n");
     repo.write("USER.md", "user local edit\n");
-    repo.git(["add", "README.md", ".naome/task-state.json"]);
+    repo.git(["add", "README.md"]);
+
+    let report = commit_gate_report(&repo);
+
+    assert!(report.errors.is_empty(), "{:#?}", report.errors);
+}
+
+#[test]
+fn commit_gate_rejects_forced_local_task_state_projection_commit() {
+    let repo = TaskFixture::new(complete_task_state(json!({
+        "allowedPaths": ["README.md"],
+        "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+    })));
+    repo.write(".gitignore", ".naome/task-state.json\n");
+    repo.write("README.md", "# Baseline\n");
+    repo.init_git();
+    repo.write("README.md", "# Task result\n");
+    repo.git(["add", "README.md"]);
+    repo.git(["add", "-f", ".naome/task-state.json"]);
+
+    let report = commit_gate_report(&repo);
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("local-only runtime path"));
+    assert!(joined.contains(".naome/task-state.json"));
+}
+
+#[test]
+fn commit_gate_allows_local_task_state_projection_untrack_deletion() {
+    let repo = TaskFixture::new(complete_task_state(json!({
+        "allowedPaths": ["README.md"],
+        "proofResults": [successful_proof(json!({ "evidence": ["README.md"] }))]
+    })));
+    repo.write("README.md", "# Baseline\n");
+    repo.init_git();
+    repo.write("README.md", "# Task result\n");
+    repo.git(["add", "README.md"]);
+    repo.git(["rm", "--cached", "-q", "--", ".naome/task-state.json"]);
 
     let report = commit_gate_report(&repo);