@lamentis/naome 1.3.3 → 1.3.5

package/Cargo.lock

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

package/README.md

@@ -50,8 +50,6 @@ naome route --prompt-file /path/to/prompt.txt --execute --json
   perfect on day one.
 - Records verification proof before a task can be treated as complete.
 - Keeps sync fast by making baseline and deep quality scans explicit.
-- Can install optional Codex hooks for earlier agent feedback without making
-  hooks a human workflow requirement.
 
 ## Safety Model
 
@@ -99,8 +97,6 @@ After sync, NAOME writes the agent-facing workflow into `docs/naome/`:
 - `docs/naome/testing.md` maps change types to required checks.
 - `docs/naome/repository-quality.md` explains quality, structure, and cleanup
   policy.
-- `docs/naome/codex-hooks.md` explains the optional Codex hook acceleration
-  layer.
 
 Agents should follow the repository's NAOME docs instead of guessing workflow
 rules from generic project files.
@@ -116,7 +112,6 @@ The main local policy files are:
 - `.naome/repository-structure.json` for path role, module, and directory
   structure policy.
 - `.naome/task-state.json` for active task state and proof.
-- `.codex/hooks.json` only when optional Codex hooks were explicitly enabled.
 
 Product defaults stay generic. Repository-specific policy belongs in the local
 `.naome/` config files.

package/crates/naome-cli/Cargo.toml

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

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

@@ -69,6 +69,7 @@ const HELP: &str = r#"Usage:
   naome workflow phases [--json]
   naome workflow processes [--json]
   naome workflow mutations --path <path> [path...] [--json]
+  naome workflow information [--path <path>] [--json]
   naome check-harness-health [--root <path>] [--allow-missing-archive]
   naome check-task-state [--root <path>] [--admission|--progress|--commit-gate|--push-gate] [--allow-missing-archive]
   naome validate-verification [--root <path>]"#;

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

@@ -1,9 +1,10 @@
 use std::path::Path;
 
 use naome_core::{
-    agent_run_plan, classify_mutations, context_delta_report, decision_gate, doctor_report,
-    edit_session_watchdog, proof_plan_for_task, refresh_integrity, repository_capability_graph,
-    safe_rg_args, summarize_command_output, tracked_process_report, validate_search_command,
+    agent_run_plan, classify_information_path, classify_mutations, context_delta_report,
+    decision_gate, doctor_report, edit_session_watchdog, information_architecture_report,
+    proof_plan_for_task, refresh_integrity, repository_capability_graph, safe_rg_args,
+    summarize_command_output, tracked_process_report, validate_search_command,
     verification_phase_plan,
 };
 
@@ -32,7 +33,7 @@ pub fn run_workflow_command(
     args: &[String],
 ) -> Result<(), Box<dyn std::error::Error>> {
     let Some(subcommand) = args.get(1).map(String::as_str) else {
-        return Err("naome workflow requires agent-plan, context-delta, proof-plan, capabilities, edit-watchdog, decision-gate, digest, search-profile, check-search, phases, processes, or mutations.".into());
+        return Err("naome workflow requires agent-plan, context-delta, proof-plan, capabilities, edit-watchdog, decision-gate, digest, search-profile, check-search, phases, processes, mutations, or information.".into());
     };
     let json = args.iter().any(|arg| arg == "--json");
 
@@ -103,6 +104,7 @@ pub fn run_workflow_command(
             }
         }
         "mutations" => run_mutations(root, args, json)?,
+        "information" => run_information(args, json)?,
         _ => return Err(format!("unknown naome workflow command: {subcommand}").into()),
     }
     Ok(())
@@ -179,6 +181,30 @@ fn run_mutations(
     Ok(())
 }
 
+fn run_information(args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    if let Some(path) = option_value(args, "--path") {
+        let classification = classify_information_path(&path);
+        if json {
+            println!("{}", serde_json::to_string_pretty(&classification)?);
+        } else {
+            println!(
+                "{}: {} ({}, {})",
+                classification.path,
+                classification.class,
+                classification.commit_policy,
+                classification.restore_policy
+            );
+        }
+        return Ok(());
+    }
+
+    print_json_or_label(
+        serde_json::to_value(information_architecture_report())?,
+        json,
+        "NAOME information architecture ready.",
+    )
+}
+
 fn run_context_delta(
     root: &Path,
     args: &[String],

package/crates/naome-core/Cargo.toml

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

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

@@ -0,0 +1,179 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct InformationArchitectureReport {
+    pub schema: &'static str,
+    pub version: u8,
+    pub classes: Vec<InformationClass>,
+    pub rules: Vec<InformationPathRule>,
+}
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct InformationClass {
+    pub id: &'static str,
+    pub description: &'static str,
+    pub commit_policy: &'static str,
+    pub restore_policy: &'static str,
+}
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct InformationPathRule {
+    pub path_pattern: &'static str,
+    pub class: &'static str,
+    pub commit_policy: &'static str,
+    pub restore_policy: &'static str,
+}
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct InformationPathClassification {
+    pub path: String,
+    pub class: &'static str,
+    pub commit_policy: &'static str,
+    pub restore_policy: &'static str,
+}
+
+const CLASSES: &[(&str, &str, &str, &str)] = &[
+    (
+        "durable_project_state",
+        "Committed configuration, policy, and templates required to reconstruct the harness.",
+        "commit",
+        "restore_from_repository_or_package",
+    ),
+    (
+        "durable_task_ledger",
+        "Committed task intent, scope, and lifecycle records.",
+        "commit",
+        "restore_from_repository",
+    ),
+    (
+        "generated_projection",
+        "Compatibility views generated from durable state.",
+        "commit_when_required_by_compatibility",
+        "regenerate_from_durable_state",
+    ),
+    (
+        "local_runtime_state",
+        "Machine-local prompts, caches, temporary files, and runtime state.",
+        "never_commit",
+        "recreate_on_demand",
+    ),
+    (
+        "run_evidence",
+        "Verification outputs from a specific run.",
+        "prefer_compact_release_evidence",
+        "restore_from_ci_or_task_ledger_when_audited",
+    ),
+    (
+        "product_source",
+        "Repository source, package metadata, tests, scripts, and documentation.",
+        "commit_when_in_task_scope",
+        "restore_from_repository",
+    ),
+];
+struct RuleSeed {
+    path_pattern: &'static str,
+    class: &'static str,
+}
+
+const RULES: &[RuleSeed] = &[
+    RuleSeed { path_pattern: ".naome/tmp/**", class: "local_runtime_state" },
+    RuleSeed { path_pattern: ".naome/task-state.json", class: "generated_projection" },
+    RuleSeed { path_pattern: ".naome/tasks/active.json", class: "durable_task_ledger" },
+    RuleSeed { path_pattern: ".naome/tasks/*/task.json", class: "durable_task_ledger" },
+    RuleSeed { path_pattern: ".naome/tasks/*/events.jsonl", class: "durable_task_ledger" },
+    RuleSeed { path_pattern: ".naome/tasks/*/proofs/*.json", class: "run_evidence" },
+    RuleSeed { path_pattern: ".naome/manifest.json", class: "durable_project_state" },
+    RuleSeed { path_pattern: ".naome/verification.json", class: "durable_project_state" },
+    RuleSeed { path_pattern: ".naome/repository-quality*.json", class: "durable_project_state" },
+    RuleSeed { path_pattern: "docs/naome/**", class: "durable_project_state" },
+    RuleSeed { path_pattern: "packages/naome/templates/naome-root/**", class: "durable_project_state" },
+];
+pub fn information_architecture_report() -> InformationArchitectureReport {
+    InformationArchitectureReport {
+        schema: "naome.information-architecture.v1",
+        version: 1,
+        classes: CLASSES
+            .iter()
+            .map(|entry| class_from_tuple(*entry))
+            .collect(),
+        rules: RULES
+            .iter()
+            .map(|rule| rule_from_class(rule.path_pattern, rule.class))
+            .collect(),
+    }
+}
+
+pub fn classify_information_path(path: &str) -> InformationPathClassification {
+    let path = normalize_path(path);
+    let class_id = RULES
+        .iter()
+        .find(|rule| matches_information_rule(&path, rule.path_pattern))
+        .map(|rule| rule.class)
+        .unwrap_or("product_source");
+    let class = class_by_id(class_id);
+    InformationPathClassification {
+        path,
+        class: class.id,
+        commit_policy: class.commit_policy,
+        restore_policy: class.restore_policy,
+    }
+}
+
+fn rule_from_class(path_pattern: &'static str, class_id: &'static str) -> InformationPathRule {
+    let class = class_by_id(class_id);
+    InformationPathRule {
+        path_pattern,
+        class: class.id,
+        commit_policy: class.commit_policy,
+        restore_policy: class.restore_policy,
+    }
+}
+
+fn class_by_id(id: &str) -> InformationClass {
+    CLASSES
+        .iter()
+        .find(|(class_id, _, _, _)| *class_id == id)
+        .map(|entry| class_from_tuple(*entry))
+        .expect("information class rule must reference a known class")
+}
+
+fn class_from_tuple(
+    entry: (&'static str, &'static str, &'static str, &'static str),
+) -> InformationClass {
+    InformationClass {
+        id: entry.0,
+        description: entry.1,
+        commit_policy: entry.2,
+        restore_policy: entry.3,
+    }
+}
+
+fn normalize_path(path: &str) -> String {
+    path.replace('\\', "/")
+        .trim_start_matches("./")
+        .trim_end_matches('/')
+        .to_string()
+}
+
+fn matches_information_rule(path: &str, pattern: &str) -> bool {
+    if let Some(prefix) = pattern.strip_suffix("/**") {
+        return path == prefix || path.starts_with(&format!("{prefix}/"));
+    }
+    if let Some(prefix) = pattern
+        .strip_suffix("*.json")
+        .filter(|prefix| !prefix.contains('*'))
+    {
+        return path.starts_with(prefix) && path.ends_with(".json");
+    }
+
+    let path_parts: Vec<&str> = path.split('/').collect();
+    let pattern_parts: Vec<&str> = pattern.split('/').collect();
+    path_parts.len() == pattern_parts.len()
+        && path_parts
+            .iter()
+            .zip(pattern_parts.iter())
+            .all(|(path_part, pattern_part)| {
+                *pattern_part == "*"
+                    || *path_part == *pattern_part
+                    || pattern_part
+                        .strip_prefix('*')
+                        .is_some_and(|suffix| path_part.ends_with(suffix))
+            })
+}

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

@@ -60,16 +60,6 @@ pub const LOCAL_NATIVE_BINARY_PATHS: &[&str] = &[
     ".naome/task-journal.jsonl",
 ];
 
-pub const OPTIONAL_CODEX_HOOK_PATHS: &[&str] = &[
-    ".codex/config.toml",
-    ".codex/hooks.json",
-    ".naome/bin/codex-hook.js",
-    ".naome/bin/codex-hook-io.js",
-    ".naome/bin/codex-hook-policy.js",
-    ".naome/bin/codex-hook-runtime.js",
-    "docs/naome/codex-hooks.md",
-];
-
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct InstallPlan {
@@ -78,7 +68,6 @@ pub struct InstallPlan {
     pub machine_owned: Vec<&'static str>,
     pub project_owned: Vec<&'static str>,
     pub local_only_machine_owned: Vec<&'static str>,
-    pub optional_codex_hook_paths: Vec<&'static str>,
     pub gitignore_entries: Vec<&'static str>,
     pub git_exclude_entries: Vec<&'static str>,
     pub git_untrack_paths: Vec<&'static str>,
@@ -104,7 +93,6 @@ pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
         machine_owned: MACHINE_OWNED_PATHS.to_vec(),
         project_owned: PROJECT_OWNED_PATHS.to_vec(),
         local_only_machine_owned: LOCAL_ONLY_MACHINE_OWNED_PATHS.to_vec(),
-        optional_codex_hook_paths: OPTIONAL_CODEX_HOOK_PATHS.to_vec(),
         gitignore_entries,
         git_exclude_entries,
         git_untrack_paths,

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

@@ -2,6 +2,7 @@ mod context;
 mod decision;
 mod git;
 mod harness_health;
+mod information_architecture;
 mod install_plan;
 mod intent;
 mod journal;
@@ -23,6 +24,10 @@ pub use context::{
 };
 pub use decision::{evaluate_decision, format_decision, EvaluationOptions};
 pub use harness_health::{validate_harness_health, HarnessHealthOptions};
+pub use information_architecture::{
+    classify_information_path, information_architecture_report, InformationArchitectureReport,
+    InformationClass, InformationPathClassification, InformationPathRule,
+};
 pub use install_plan::{install_plan, InstallPlan};
 pub use install_plan::{MACHINE_OWNED_PATHS, PROJECT_OWNED_PATHS};
 pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence};

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

@@ -37,8 +37,25 @@ fn git_add_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
     if paths.is_empty() {
         return Ok(());
     }
+    let tracked_paths = git_ls_files(root, &[], paths)?;
+    if !tracked_paths.is_empty() {
+        let mut update_args = vec!["add", "-u", "--"];
+        update_args.extend(tracked_paths.iter().map(String::as_str));
+        ensure_git_success(
+            Command::new("git")
+                .args(update_args)
+                .current_dir(root)
+                .output()?,
+        )?;
+    }
+
+    let untracked_paths = git_ls_files(root, &["--others", "--exclude-standard"], paths)?;
+    if untracked_paths.is_empty() {
+        return Ok(());
+    }
+
     let mut args = vec!["add", "--"];
-    args.extend(paths.iter().map(String::as_str));
+    args.extend(untracked_paths.iter().map(String::as_str));
     let output = Command::new("git").args(args).current_dir(root).output()?;
     if output.status.success() {
         Ok(())
@@ -47,6 +64,31 @@ fn git_add_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
     }
 }
 
+fn git_ls_files(
+    root: &Path,
+    mode_args: &[&str],
+    paths: &[String],
+) -> Result<Vec<String>, NaomeError> {
+    let mut args = vec!["ls-files"];
+    args.extend(mode_args);
+    args.extend(["-z", "--"]);
+    args.extend(paths.iter().map(String::as_str));
+    let output = Command::new("git").args(args).current_dir(root).output()?;
+    if output.status.success() {
+        Ok(split_nul_paths(&output.stdout))
+    } else {
+        Err(NaomeError::new(command_output(&output)))
+    }
+}
+
+fn split_nul_paths(bytes: &[u8]) -> Vec<String> {
+    String::from_utf8_lossy(bytes)
+        .split('\0')
+        .filter(|path| !path.is_empty())
+        .map(ToString::to_string)
+        .collect()
+}
+
 pub(super) fn git_commit(root: &Path, message: &str) -> Result<(), NaomeError> {
     ensure_git_success(git_output(root, &["commit", "-m", message])?)
 }
@@ -64,9 +106,12 @@ pub(super) fn ensure_git_success(output: Output) -> Result<(), NaomeError> {
 }
 
 pub(super) fn command_output(output: &std::process::Output) -> String {
-    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-    if !stderr.is_empty() {
-        return stderr;
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    for message in [stderr.trim(), stdout.trim()] {
+        if !message.is_empty() {
+            return message.to_string();
+        }
     }
-    String::from_utf8_lossy(&output.stdout).trim().to_string()
+    format!("git exited with status {}", output.status)
 }

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

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use serde_json::{json, Value};
+use serde_json::{json, Map, Value};
 
 use crate::models::NaomeError;
 
@@ -28,28 +28,62 @@ pub(super) fn render_from_ledger(root: &Path) -> Result<Option<TaskLedgerProject
 }
 
 fn render_active_task(spec: Value, proof_results: Vec<Value>) -> Value {
-    json!({
-        "id": spec.get("id").cloned().unwrap_or(Value::Null),
-        "request": spec.get("request").cloned().unwrap_or(Value::Null),
-        "userPrompt": spec.get("userPrompt").cloned().unwrap_or(Value::Null),
-        "admission": spec.get("admission").cloned().unwrap_or(Value::Null),
-        "allowedPaths": spec.get("allowedPaths").cloned().unwrap_or_else(|| json!([])),
-        "declaredChangeTypes": spec
-            .get("declaredChangeTypes")
+    let mut active_task = Map::new();
+    active_task.insert(
+        "id".to_string(),
+        spec.get("id").cloned().unwrap_or(Value::Null),
+    );
+    active_task.insert(
+        "request".to_string(),
+        spec.get("request").cloned().unwrap_or(Value::Null),
+    );
+    active_task.insert(
+        "userPrompt".to_string(),
+        spec.get("userPrompt").cloned().unwrap_or(Value::Null),
+    );
+    active_task.insert(
+        "admission".to_string(),
+        spec.get("admission").cloned().unwrap_or(Value::Null),
+    );
+    active_task.insert(
+        "allowedPaths".to_string(),
+        spec.get("allowedPaths")
             .cloned()
             .unwrap_or_else(|| json!([])),
-        "requiredCheckIds": spec
-            .get("requiredCheckIds")
+    );
+    active_task.insert(
+        "declaredChangeTypes".to_string(),
+        spec.get("declaredChangeTypes")
             .cloned()
             .unwrap_or_else(|| json!([])),
-        "proofResults": proof_results,
-        "revisions": spec.get("revisions").cloned().unwrap_or_else(|| json!([])),
-        "humanReview": spec.get("humanReview").cloned().unwrap_or_else(|| {
+    );
+    active_task.insert(
+        "requiredCheckIds".to_string(),
+        spec.get("requiredCheckIds")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+    );
+    active_task.insert("proofResults".to_string(), Value::Array(proof_results));
+    if let Some(path_sets) = spec.get("proofPathSets") {
+        active_task.insert("proofPathSets".to_string(), path_sets.clone());
+    }
+    if let Some(batches) = spec.get("proofBatches") {
+        active_task.insert("proofBatches".to_string(), batches.clone());
+    }
+    active_task.insert(
+        "revisions".to_string(),
+        spec.get("revisions").cloned().unwrap_or_else(|| json!([])),
+    );
+    active_task.insert(
+        "humanReview".to_string(),
+        spec.get("humanReview").cloned().unwrap_or_else(|| {
             json!({
                 "required": false,
                 "approved": false,
                 "reason": null
             })
-        })
-    })
+        }),
+    );
+
+    Value::Object(active_task)
 }

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

@@ -0,0 +1,58 @@
+use naome_core::{classify_information_path, information_architecture_report};
+
+#[test]
+fn classifies_naome_information_by_restore_source() {
+    let durable = classify_information_path(".naome/verification.json");
+    assert_eq!(durable.class, "durable_project_state");
+    assert_eq!(durable.commit_policy, "commit");
+    assert_eq!(durable.restore_policy, "restore_from_repository_or_package");
+
+    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.restore_policy, "regenerate_from_durable_state");
+
+    let local = classify_information_path(".naome/tmp/route.prompt");
+    assert_eq!(local.class, "local_runtime_state");
+    assert_eq!(local.commit_policy, "never_commit");
+    assert_eq!(local.restore_policy, "recreate_on_demand");
+
+    let proof = classify_information_path(".naome/tasks/readme-task/proofs/diff-check.json");
+    assert_eq!(proof.class, "run_evidence");
+    assert_eq!(proof.commit_policy, "prefer_compact_release_evidence");
+    assert_eq!(
+        proof.restore_policy,
+        "restore_from_ci_or_task_ledger_when_audited"
+    );
+
+    let task = classify_information_path(".naome/tasks/readme-task/task.json");
+    assert_eq!(task.class, "durable_task_ledger");
+    assert_eq!(task.commit_policy, "commit");
+    assert_eq!(task.restore_policy, "restore_from_repository");
+}
+
+#[test]
+fn reports_information_architecture_contract_for_agents() {
+    let report = information_architecture_report();
+
+    assert_eq!(report.schema, "naome.information-architecture.v1");
+    assert!(report
+        .classes
+        .iter()
+        .any(|class| class.id == "durable_project_state"));
+    assert!(report
+        .classes
+        .iter()
+        .any(|class| class.id == "generated_projection"));
+    assert!(report
+        .classes
+        .iter()
+        .any(|class| class.id == "run_evidence"));
+    assert!(report
+        .rules
+        .iter()
+        .any(|rule| rule.path_pattern == ".naome/tasks/*/proofs/*.json"));
+}

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

@@ -19,17 +19,6 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert!(!plan
         .local_only_machine_owned
         .contains(&"docs/naome/architecture.md"));
-    assert!(plan
-        .optional_codex_hook_paths
-        .contains(&".codex/hooks.json"));
-    assert!(plan
-        .optional_codex_hook_paths
-        .contains(&".codex/config.toml"));
-    assert!(plan
-        .optional_codex_hook_paths
-        .contains(&".naome/bin/codex-hook.js"));
-    assert!(!plan.machine_owned.contains(&".naome/bin/codex-hook.js"));
-    assert!(!plan.project_owned.contains(&".codex/hooks.json"));
 }
 
 #[test]

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

@@ -119,6 +119,57 @@ fn task_state_v2_can_migrate_to_ledger_without_losing_compact_proof_data() {
     assert!(report.errors.is_empty(), "{:?}", report.errors);
 }
 
+#[test]
+fn ledger_projection_preserves_compact_proof_batches_from_task_spec() {
+    let repo = TestRepo::new("compact-ledger");
+    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_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" }]),
+            ),
+        ])),
+    );
+    repo.write_file(
+        ".naome/tasks/readme-task/task.json",
+        &format_json(compact_task_spec_record(&head)),
+    );
+    repo.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"
+        ),
+    );
+    repo.write_file("README.md", "# Changed\n");
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(projected["activeTask"]["proofResults"], json!([]));
+    assert_eq!(
+        projected["activeTask"]["proofPathSets"]["changed"],
+        json!(["README.md"])
+    );
+    assert_eq!(
+        projected["activeTask"]["proofBatches"][0]["proofs"][0]["checkId"],
+        "diff-check"
+    );
+
+    render_task_state_from_ledger(repo.path(), true).unwrap();
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
 #[test]
 fn task_state_validation_reports_stale_rendered_projection_when_ledger_exists() {
     let repo = TestRepo::new("stale-projection");
@@ -261,6 +312,17 @@ fn task_spec_record(admission_head: &str) -> Value {
     ])
 }
 
+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")),