@lamentis/naome 1.4.4 → 1.4.6

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

@@ -0,0 +1,101 @@
+use std::collections::BTreeSet;
+
+use naome_core::{TaskProofStatus, TaskStatusReportV1};
+use serde_json::{json, Value};
+
+pub(super) fn action(
+    action_type: &str,
+    action_id: &str,
+    reason_codes: &[impl AsRef<str>],
+    commands: &[Value],
+    paths: Vec<String>,
+    check_ids: &[String],
+    safe_to_execute: bool,
+    requires_user_approval: bool,
+    primary_finding_id: Option<&str>,
+) -> Value {
+    json!({
+        "type": action_type,
+        "actionId": action_id,
+        "reasonCodes": reason_codes.iter().map(|code| code.as_ref()).collect::<Vec<_>>(),
+        "primaryFindingId": primary_finding_id,
+        "commands": commands,
+        "paths": paths,
+        "checkIds": check_ids,
+        "safeToExecute": safe_to_execute,
+        "requiresUserApproval": requires_user_approval
+    })
+}
+
+pub(super) fn primary_finding_id(status: &TaskStatusReportV1, prefix: &str) -> Option<String> {
+    status
+        .findings
+        .iter()
+        .find(|finding| finding.id.starts_with(prefix))
+        .map(|finding| finding.id.clone())
+}
+
+pub(super) fn reason_codes(commands: &[Value], proof: &TaskProofStatus) -> Vec<String> {
+    let mut codes = BTreeSet::new();
+    for command in commands {
+        collect_csv(command.get("reason"), &mut codes);
+        collect_csv(command.get("selectionReason"), &mut codes);
+    }
+    if !proof.missing_checks.is_empty() {
+        codes.insert("missing-proof".to_string());
+    }
+    if !proof.stale_checks.is_empty() {
+        codes.insert("stale-proof".to_string());
+    }
+    codes.into_iter().collect()
+}
+
+pub(super) fn impacted_paths(commands: &[Value], fallback: &[String]) -> Vec<String> {
+    let mut paths = BTreeSet::new();
+    for command in commands {
+        collect_string_array(command.get("impactedPaths"), &mut paths);
+    }
+    if paths.is_empty() {
+        paths.extend(fallback.iter().cloned());
+    }
+    paths.into_iter().collect()
+}
+
+pub(super) fn check_ids(commands: &[Value], proof: &TaskProofStatus) -> Vec<String> {
+    let mut ids = BTreeSet::new();
+    ids.extend(commands.iter().filter_map(check_id));
+    if ids.is_empty() {
+        ids.extend(proof.missing_checks.iter().cloned());
+        ids.extend(proof.stale_checks.iter().cloned());
+    }
+    ids.into_iter().collect()
+}
+
+fn check_id(command: &Value) -> Option<String> {
+    command
+        .get("checkId")
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+pub(super) fn collect_csv(value: Option<&Value>, values: &mut BTreeSet<String>) {
+    if let Some(raw) = value.and_then(Value::as_str) {
+        values.extend(
+            raw.split(',')
+                .map(str::trim)
+                .filter(|part| !part.is_empty())
+                .map(ToString::to_string),
+        );
+    }
+}
+
+pub(super) fn collect_string_array(value: Option<&Value>, values: &mut BTreeSet<String>) {
+    values.extend(
+        value
+            .and_then(Value::as_array)
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_str)
+            .map(ToString::to_string),
+    );
+}

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

@@ -16,6 +16,8 @@ mod record;
 mod repair;
 mod scope_request;
 mod scope_suggestions;
+mod single_pass_action;
+mod single_pass_action_fields;
 mod timeline;
 
 use naome_core::{

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

@@ -21,6 +21,18 @@ fn agent_snapshot_reports_missing_proof_and_safe_commands() {
     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["nextAction"]["actionId"],
+        "proof.run_required_checks"
+    );
+    assert_eq!(
+        snapshot["nextAction"]["reasonCodes"],
+        json!(["changed_docs", "missing-proof"])
+    );
+    assert_eq!(
+        snapshot["nextAction"]["commands"][0]["command"],
+        "git diff --check"
+    );
     assert_eq!(snapshot["checks"]["safeToRun"][0]["checkId"], "diff-check");
 }
 
@@ -85,6 +97,12 @@ fn preflight_reports_path_policy_and_check_plan() {
     );
     assert_eq!(allowed["paths"][0]["editable"], true);
     assert_eq!(allowed["paths"][0]["risk"], "medium");
+    assert_eq!(allowed["nextAction"]["actionId"], "preflight.edit_allowed");
+    assert_eq!(allowed["nextAction"]["paths"], json!(["scripts/check.js"]));
+    assert_eq!(
+        allowed["nextAction"]["reasonCodes"],
+        json!(["preflight-clean"])
+    );
 
     let ignored = run_json(
         &root,
@@ -92,6 +110,12 @@ fn preflight_reports_path_policy_and_check_plan() {
     );
     assert_eq!(ignored["paths"][0]["editable"], false);
     assert_eq!(ignored["findings"][0]["id"], "task.preflight.ignored_path");
+    assert_eq!(ignored["nextAction"]["actionId"], "preflight.blocked");
+    assert_eq!(ignored["nextAction"]["paths"], json!(["dist/bundle.js"]));
+    assert_eq!(
+        ignored["nextAction"]["reasonCodes"],
+        json!(["preflight-blocked"])
+    );
 
     let traversal = run_json(
         &root,
@@ -121,6 +145,7 @@ fn preflight_blocks_when_no_target_paths_are_selected() {
         "task.preflight.missing_target_paths"
     );
     assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["actionId"], "preflight.blocked");
     assert_eq!(preflight["nextAction"]["safeToExecute"], false);
 }
 
@@ -153,7 +178,11 @@ fn commit_preflight_blocks_missing_proof() {
         preflight["blockingFindings"][0]["id"],
         "task.proof.missing_check"
     );
-    assert_eq!(preflight["nextAction"]["type"], "rerun_checks");
+    assert_eq!(preflight["nextAction"]["type"], "run_checks");
+    assert_eq!(
+        preflight["nextAction"]["actionId"],
+        "proof.run_required_checks"
+    );
     assert_eq!(preflight["nextAction"]["checkIds"], json!(["diff-check"]));
 }
 
@@ -180,9 +209,120 @@ fn agent_snapshot_prefers_commit_ready_over_more_editing() {
 
     assert_eq!(snapshot["commit"]["canCommit"], true);
     assert_eq!(snapshot["nextAction"]["type"], "commit_ready");
+    assert_eq!(snapshot["nextAction"]["actionId"], "commit.ready");
+    assert_eq!(
+        snapshot["nextAction"]["reasonCodes"],
+        json!(["commit-ready"])
+    );
     assert_eq!(snapshot["nextAction"]["safeToExecute"], false);
 }
 
+#[test]
+fn agent_snapshot_reports_stale_proof_as_concrete_check_action() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["README.md", "docs/**"],
+        "requiredCheckIds": ["diff-check"],
+        "proofPathSets": {
+            "old": ["README.md"]
+        },
+        "proofBatches": [{
+            "id": "old-proof",
+            "checkedAt": "2026-05-04T12:00:00.000Z",
+            "evidencePathSet": "old",
+            "proofs": [{ "checkId": "diff-check", "exitCode": 0 }]
+        }]
+    }))));
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "covered\n");
+    write_fixture_file(&root, "docs/new.md", "not-covered\n");
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["nextAction"]["type"], "run_checks");
+    assert_eq!(
+        snapshot["nextAction"]["actionId"],
+        "proof.run_required_checks"
+    );
+    assert_eq!(
+        snapshot["nextAction"]["reasonCodes"],
+        json!(["changed_docs", "stale-proof"])
+    );
+    assert_eq!(snapshot["nextAction"]["checkIds"], json!(["diff-check"]));
+    assert_eq!(
+        snapshot["nextAction"]["paths"],
+        json!(["README.md", "docs/new.md"])
+    );
+}
+
+#[test]
+fn agent_snapshot_blocks_scope_drift_before_edit_or_commit_paths() {
+    let root = fixture_root(task_state());
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+    write_fixture_file(&root, "src/outside.rs", "pub fn outside() {}\n");
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["nextAction"]["type"], "repair_scope");
+    assert_eq!(snapshot["nextAction"]["actionId"], "scope.repair_drift");
+    assert_eq!(
+        snapshot["nextAction"]["reasonCodes"],
+        json!(["scope-drift"])
+    );
+    assert_eq!(snapshot["nextAction"]["paths"], json!(["src/outside.rs"]));
+    assert_eq!(snapshot["nextAction"]["safeToExecute"], false);
+    assert_eq!(snapshot["nextAction"]["requiresUserApproval"], true);
+}
+
+#[test]
+fn task_loop_execute_safe_records_proof_compacts_and_returns_commit_ready() {
+    let root = fixture_root(task_state());
+    let mut state: Value =
+        serde_json::from_str(&fs::read_to_string(root.join(".naome/task-state.json")).unwrap())
+            .unwrap();
+    state["activeTask"]["proofResults"] = json!([{
+        "checkId": "old-check",
+        "command": "old",
+        "cwd": ".",
+        "exitCode": 0,
+        "checkedAt": "2026-05-14T00:00:00.000Z",
+        "evidence": ["README.md"],
+        "stdoutSummary": "verbose",
+        "stderrSummary": "verbose",
+        "durationMs": 99
+    }]);
+    write_json(&root, ".naome/task-state.json", &state);
+    init_git(&root);
+    write_fixture_file(&root, "README.md", "changed\n");
+
+    let looped = run_json(&root, ["task", "loop", "--execute-safe", "--json"]);
+
+    assert_eq!(looped["schema"], "naome.task.loop.v1");
+    assert_eq!(looped["nextAction"]["type"], "commit_ready");
+    assert_eq!(looped["nextAction"]["actionId"], "commit.ready");
+    assert_eq!(looped["nextAction"]["reasonCodes"], json!(["commit-ready"]));
+    assert!(looped["executedSteps"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|step| {
+            step["schema"] == "naome.task.run-check.v1"
+                && step["checkId"] == "diff-check"
+                && step["recordedProof"] == true
+        }));
+    assert!(looped["executedSteps"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|step| {
+            step["schema"] == "naome.task.compact-proof.v1" && step["compacted"] == true
+        }));
+
+    let changed = fs::read_to_string(root.join(".naome/task-state.json")).unwrap();
+    assert!(!changed.contains("stdoutSummary"));
+    assert!(changed.contains("evidenceFingerprint"));
+}
+
 #[test]
 fn commit_preflight_surfaces_transition_blocker_action_and_exit_code() {
     let root = fixture_root(task_state_with_active_task(active_task(json!({
@@ -204,7 +344,12 @@ fn commit_preflight_surfaces_transition_blocker_action_and_exit_code() {
         preflight["blockingFindings"][0]["id"],
         "task.transition.human_review_required"
     );
-    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["type"], "human_review");
+    assert_eq!(preflight["nextAction"]["actionId"], "human_review.required");
+    assert_eq!(
+        preflight["nextAction"]["reasonCodes"],
+        json!(["human-review-required"])
+    );
     assert_eq!(preflight["nextAction"]["safeToExecute"], false);
 
     let output = Command::new(env!("CARGO_BIN_EXE_naome"))

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-cli/tests/task_cli_review_fixes.rs

@@ -0,0 +1,107 @@
+use serde_json::json;
+
+mod task_cli_support;
+
+use task_cli_support::{
+    active_task, fixture_root, init_git, run_json, task_state, task_state_with_active_task,
+    write_fixture_file, write_verification_checks,
+};
+
+#[test]
+fn agent_snapshot_records_existing_receipts_before_rerunning_checks() {
+    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", "--json"],
+    );
+    assert_eq!(checked["exitCode"], 0);
+    assert_eq!(checked["recordedProof"], false);
+
+    let snapshot = run_json(&root, ["task", "agent-snapshot", "--json"]);
+
+    assert_eq!(snapshot["nextAction"]["type"], "record_proof");
+    assert_eq!(
+        snapshot["nextAction"]["actionId"],
+        "proof.record_from_receipts"
+    );
+    assert_eq!(snapshot["nextAction"]["checkIds"], json!(["diff-check"]));
+    assert_eq!(snapshot["nextAction"]["safeToExecute"], true);
+}
+
+#[test]
+fn commit_preflight_surfaces_generic_transition_blocker_action() {
+    let mut state = task_state_with_active_task(active_task(json!({
+        "requiredCheckIds": [],
+        "proofResults": []
+    })));
+    state["status"] = json!("blocked");
+    let root = fixture_root(state);
+    init_git(&root);
+
+    let preflight = run_json(&root, ["task", "commit-preflight", "--json"]);
+
+    assert_eq!(preflight["wouldPass"], false);
+    assert_eq!(
+        preflight["blockingFindings"][0]["id"],
+        "task.transition.blocked_state"
+    );
+    assert_eq!(preflight["nextAction"]["type"], "blocked");
+    assert_eq!(preflight["nextAction"]["actionId"], "transition.blocked");
+    assert_eq!(
+        preflight["nextAction"]["reasonCodes"],
+        json!(["transition-blocked"])
+    );
+    assert_eq!(
+        preflight["nextAction"]["primaryFindingId"],
+        "task.transition.blocked_state"
+    );
+}
+
+#[test]
+fn task_loop_execute_safe_runs_merged_safe_impact_plan() {
+    let root = fixture_root(task_state_with_active_task(active_task(json!({
+        "allowedPaths": ["src/lib.rs"],
+        "requiredCheckIds": ["diff-check"],
+        "proofResults": []
+    }))));
+    write_verification_checks(
+        &root,
+        json!([
+            {
+                "id": "diff-check",
+                "command": "git diff --check",
+                "cwd": ".",
+                "purpose": "Detect whitespace and patch formatting issues.",
+                "cost": "fast",
+                "source": "git",
+                "evidence": ["src/lib.rs"],
+                "lastVerified": null
+            },
+            {
+                "id": "repository-quality-check",
+                "command": "git diff --check",
+                "cwd": ".",
+                "purpose": "Exercise an additional safe impact-planned check.",
+                "cost": "fast",
+                "source": "git",
+                "evidence": ["src/lib.rs"],
+                "lastVerified": null
+            }
+        ]),
+    );
+    init_git(&root);
+    write_fixture_file(&root, "src/lib.rs", "pub fn changed() {}\n");
+
+    let looped = run_json(&root, ["task", "loop", "--execute-safe", "--json"]);
+    let executed = looped["executedSteps"].as_array().unwrap();
+
+    assert!(executed
+        .iter()
+        .any(|step| step["checkId"] == "diff-check" && step["executed"] == true));
+    assert!(executed
+        .iter()
+        .any(|step| { step["checkId"] == "repository-quality-check" && step["executed"] == true }));
+}

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.4.4"
+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(())
+}