@lamentis/naome 1.2.1 → 1.3.1

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

@@ -0,0 +1,328 @@
+mod repo_support;
+
+use naome_core::{
+    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 repo_support::{diff_check, verification_value, TestRepo};
+
+#[test]
+fn ledger_projection_renders_compatible_task_state_without_task_state_json() {
+    let repo = TestRepo::new("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);
+    repo.write_file("README.md", "# Changed\n");
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(state["schema"], "naome.task-state.v2");
+    assert_eq!(state["status"], "complete");
+    assert_eq!(state["activeTask"]["id"], "readme-task");
+    assert_eq!(
+        state["activeTask"]["proofResults"][0]["checkId"],
+        "diff-check"
+    );
+    assert_eq!(
+        state["activeTask"]["proofResults"][0]["evidence"][0],
+        "README.md"
+    );
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
+#[test]
+fn task_state_json_remains_backward_compatible_when_no_ledger_exists() {
+    let repo = TestRepo::new("legacy");
+    repo.write_base_harness(Some(idle_state()));
+
+    let state = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(state["schema"], "naome.task-state.v1");
+    assert_eq!(state["status"], "idle");
+}
+
+#[test]
+fn renderer_can_write_projection_for_external_tools() {
+    let repo = TestRepo::new("write");
+    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);
+
+    let rendered = render_task_state_from_ledger(repo.path(), true)
+        .unwrap()
+        .unwrap();
+    assert_eq!(rendered["status"], "complete");
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(projected["activeTask"]["id"], "readme-task");
+
+    let report = validate_task_state(
+        repo.path(),
+        TaskStateOptions {
+            mode: TaskStateMode::Progress,
+            ..TaskStateOptions::default()
+        },
+    )
+    .unwrap();
+    assert!(report
+        .errors
+        .iter()
+        .any(|error| error.contains("Task is complete")));
+}
+
+#[test]
+fn task_state_v2_can_migrate_to_ledger_without_losing_compact_proof_data() {
+    let repo = TestRepo::new("migrate-v2");
+    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_naome_json("task-state.json", compact_complete_state(&head));
+    repo.write_file("README.md", "# Changed\n");
+
+    let migrated = migrate_task_state_to_ledger(repo.path(), true)
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(migrated["source"], "task-state");
+    assert!(repo.path().join(".naome/tasks/active.json").is_file());
+    assert!(repo
+        .path()
+        .join(".naome/tasks/readme-task/proofs/diff-check.json")
+        .is_file());
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+    assert_eq!(projected["schema"], "naome.task-state.v2");
+    assert_eq!(projected["status"], "complete");
+    assert_eq!(
+        projected["activeTask"]["proofResults"][0]["checkId"],
+        "diff-check"
+    );
+    assert_eq!(
+        projected["activeTask"]["proofResults"][0]["evidence"],
+        json!(["README.md"])
+    );
+
+    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");
+    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_naome_json("task-state.json", idle_state());
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.iter().any(|error| {
+        error.contains(".naome/task-state.json is stale")
+            && error.contains("naome.js task render-state --write")
+    }));
+}
+
+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()),
+        );
+    }
+}
+
+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 {
+    object([
+        ("schema", json!("naome.task-ledger-task.v1")),
+        ("version", json!(1)),
+        ("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"])),
+        ("humanReview", human_review()),
+    ])
+}
+
+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),
+    ])
+}
+
+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())
+}

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

@@ -314,6 +314,20 @@ fn progress_rejects_in_flight_work_outside_scope() {
     assert!(joined.contains("src/session.js"));
 }
 
+#[test]
+fn progress_reports_stale_repository_model_for_scoped_stack_changes() {
+    let repo = TaskFixture::new(implementing_package_task());
+    repo.write(".naome/repository-model.json", "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n");
+    repo.init_git();
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+
+    let report = progress_report(&repo);
+    let joined = report.errors.join("\n");
+
+    assert!(joined.contains("repository model is stale"));
+    assert!(joined.contains("naome repo model --write"));
+}
+
 #[test]
 fn rejects_complete_task_when_evidence_omits_changed_allowed_path() {
     let repo = TaskFixture::new(complete_task_state(json!({
@@ -416,3 +430,17 @@ fn implementing_readme_task() -> serde_json::Value {
         "updatedAt": "2026-05-04T12:00:00.000Z"
     })
 }
+
+fn implementing_package_task() -> serde_json::Value {
+    json!({
+        "schema": "naome.task-state.v1",
+        "version": 1,
+        "status": "implementing",
+        "activeTask": active_task(json!({
+            "allowedPaths": ["Package.swift"],
+            "proofResults": []
+        })),
+        "blocker": null,
+        "updatedAt": "2026-05-04T12:00:00.000Z"
+    })
+}

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

@@ -1,49 +1,30 @@
 use naome_core::seed_builtin_verification_checks;
-use serde_json::json;
 
 mod repo_support;
 
-use repo_support::TestRepo;
+use repo_support::{change_type, quality_check, verification_value, TestRepo};
 
 #[test]
 fn seeds_builtin_checks_without_removing_repo_specific_checks() {
     let repo = TestRepo::new("verification-seed");
     repo.write_naome_json(
         "verification.json",
-        json!({
-            "schema": "naome.verification.v1",
-            "version": 1,
-            "status": "ready",
-            "lastUpdated": "2026-05-05",
-            "checks": [
-                {
-                    "id": "repo-docs",
-                    "command": "npm run docs:test",
-                    "cwd": ".",
-                    "purpose": "Validate repository documentation.",
-                    "cost": "fast",
-                    "source": "repository intake",
-                    "evidence": ["package.json"],
-                    "lastVerified": null
-                }
-            ],
-            "changeTypes": [
-                {
-                    "id": "repo-docs",
-                    "description": "Repository documentation changes.",
-                    "paths": ["docs/**"],
-                    "requiredChecks": ["repo-docs"],
-                    "recommendedChecks": [],
-                    "humanReview": false
-                }
-            ],
-            "releaseGates": [
-                {
-                    "checkId": "repo-docs",
-                    "requiredWhen": "Before merging repository documentation changes."
-                }
-            ]
-        }),
+        verification_value(
+            "ready",
+            vec![quality_check(
+                "repo-docs",
+                "npm run docs:test",
+                "Validate repository documentation.",
+                "fast",
+                vec!["package.json"],
+            )],
+            vec![change_type(
+                "repo-docs",
+                "Repository documentation changes.",
+                vec!["docs/**"],
+                vec!["repo-docs"],
+            )],
+        ),
     );
 
     let changed = seed_builtin_verification_checks(repo.path()).unwrap();
@@ -62,10 +43,22 @@ fn seeds_builtin_checks_without_removing_repo_specific_checks() {
         check_command(&verification, "naome-task-state"),
         Some("node .naome/bin/check-task-state.js")
     );
+    assert_eq!(
+        check_command(&verification, "repository-semantic-check"),
+        Some("node .naome/bin/naome.js semantic check --changed")
+    );
     assert_eq!(
         check_command(&verification, "repo-docs"),
         Some("npm run docs:test")
     );
+    let repo_docs_required = verification["changeTypes"][0]["requiredChecks"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .filter_map(serde_json::Value::as_str)
+        .collect::<Vec<_>>();
+    assert!(repo_docs_required.contains(&"repository-quality-check"));
+    assert!(repo_docs_required.contains(&"repository-semantic-check"));
 
     let changed_again = seed_builtin_verification_checks(repo.path()).unwrap();
     assert!(!changed_again);

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

@@ -0,0 +1,233 @@
+mod workflow_agent_support;
+
+use naome_core::{
+    agent_run_plan, context_delta_report, decision_gate, edit_session_watchdog,
+    proof_plan_for_task, repository_capability_graph, summarize_command_output, CommandCheckResult,
+};
+
+use workflow_agent_support::Repo;
+
+#[test]
+fn execution_plan_ledger_orders_read_edit_and_check_steps() {
+    let repo = Repo::new("execution-plan");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = agent_run_plan(repo.path()).unwrap();
+
+    assert_eq!(plan.schema, "naome.agent-run-plan.v1");
+    assert_eq!(plan.execution_plan.task_state, "implementing");
+    assert!(plan.execution_plan.steps.iter().any(|step| {
+        step.id == "read-required-context"
+            && step.reason_codes.contains(&"token-economy".to_string())
+    }));
+    assert!(plan.execution_plan.steps.iter().any(|step| {
+        step.id == "run-path-quality" && step.paths == vec!["src/lib.rs".to_string()]
+    }));
+    assert!(plan.execution_plan.steps.iter().all(|step| {
+        !step
+            .commands
+            .iter()
+            .any(|command| command.contains(".naome/task-state.json"))
+    }));
+    assert!(plan
+        .execution_plan
+        .steps
+        .iter()
+        .any(|step| step.id == "run-progress-gate"));
+}
+
+#[test]
+fn context_delta_marks_reusable_unread_and_stale_context() {
+    let repo = Repo::new("context-delta");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let delta = context_delta_report(
+        repo.path(),
+        &[
+            "docs/naome/testing.md".to_string(),
+            "src/lib.rs".to_string(),
+        ],
+    )
+    .unwrap();
+
+    assert_eq!(delta.schema, "naome.context-delta.v1");
+    assert!(delta
+        .reusable_context
+        .contains(&"docs/naome/testing.md".to_string()));
+    assert!(delta.stale_context.contains(&"src/lib.rs".to_string()));
+    assert!(delta
+        .unread_required_context
+        .contains(&".naome/task-state.json".to_string()));
+}
+
+#[test]
+fn proof_planner_recommends_minimal_missing_checks_in_phase_order() {
+    let repo = Repo::new("proof-plan");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["shape", "unit", "pack"]);
+    repo.write_phased_verification();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = proof_plan_for_task(
+        repo.path(),
+        &[CommandCheckResult {
+            check_id: "shape".to_string(),
+            exit_code: 0,
+        }],
+    )
+    .unwrap();
+
+    assert_eq!(plan.schema, "naome.proof-plan.v1");
+    assert_eq!(plan.recommended_check_ids, vec!["unit".to_string()]);
+    assert!(plan.withheld_check_ids.contains(&"pack".to_string()));
+    assert_eq!(plan.evidence_paths, vec!["src/lib.rs".to_string()]);
+}
+
+#[test]
+fn proof_planner_recommends_semantic_changed_gate_with_repository_quality() {
+    let repo = Repo::new("proof-plan-semantic");
+    repo.write_harness_state(
+        "implementing",
+        &["src/lib.rs"],
+        &[
+            "repository-quality-check",
+            "repository-semantic-check",
+            "package",
+        ],
+    );
+    repo.write_verification(&[
+        (
+            "repository-quality-check",
+            "node .naome/bin/naome.js quality check --changed",
+            "fast",
+        ),
+        (
+            "repository-semantic-check",
+            "node .naome/bin/naome.js semantic check --changed",
+            "fast",
+        ),
+        ("package", "npm run pack:dry-run", "slow"),
+    ]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let plan = proof_plan_for_task(repo.path(), &[]).unwrap();
+
+    assert_eq!(
+        plan.recommended_check_ids,
+        vec![
+            "repository-quality-check".to_string(),
+            "repository-semantic-check".to_string()
+        ]
+    );
+    assert!(plan.withheld_check_ids.contains(&"package".to_string()));
+}
+
+#[test]
+fn output_digest_keeps_relevant_lines_paths_and_artifacts() {
+    let output = [
+        "running 2 tests",
+        "error: failed at src/lib.rs:4",
+        "full log written to target/test-output/fail.log",
+        "noise line",
+    ]
+    .join("\n");
+
+    let digest = summarize_command_output("cargo test", ".", 101, &output, 3);
+
+    assert!(digest.truncated);
+    assert!(digest
+        .relevant_lines
+        .iter()
+        .any(|line| line.contains("error")));
+    assert!(digest.affected_paths.contains(&"src/lib.rs".to_string()));
+    assert!(digest
+        .artifacts
+        .contains(&"target/test-output/fail.log".to_string()));
+}
+
+#[test]
+fn capability_graph_maps_stack_roots_and_checks() {
+    let repo = Repo::new("capability-graph");
+    repo.write_harness_state("idle", &[], &[]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file(
+        "Cargo.toml",
+        "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+    );
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let graph = repository_capability_graph(repo.path()).unwrap();
+
+    assert_eq!(graph.schema, "naome.capability-graph.v1");
+    assert!(graph
+        .capabilities
+        .iter()
+        .any(|capability| capability.id == "language:rust"));
+    assert!(graph
+        .capabilities
+        .iter()
+        .any(|capability| capability.id == "build:cargo"));
+    assert!(graph
+        .verification_edges
+        .iter()
+        .any(|edge| edge.check_id == "unit"));
+}
+
+#[test]
+fn edit_watchdog_flags_scope_drift_and_recommends_early_gates() {
+    let repo = Repo::new("edit-watchdog");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+    repo.write_file("README.md", "# Demo\n");
+
+    let watchdog = edit_session_watchdog(
+        repo.path(),
+        &["src/lib.rs".to_string(), "README.md".to_string()],
+    )
+    .unwrap();
+
+    assert_eq!(watchdog.schema, "naome.edit-session-watchdog.v1");
+    assert!(watchdog
+        .next_commands
+        .contains(&"node .naome/bin/naome.js quality check --path src/lib.rs".to_string()));
+    assert!(watchdog.findings.iter().any(|finding| {
+        finding.check_id == "scope-drift" && finding.paths == vec!["README.md".to_string()]
+    }));
+}
+
+#[test]
+fn decision_gate_classifies_continue_vs_human_review() {
+    let repo = Repo::new("decision-gate");
+    repo.write_harness_state("implementing", &["src/lib.rs"], &["unit"]);
+    repo.write_verification(&[("unit", "cargo test", "fast")]);
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 41 }\n");
+    repo.init_git();
+    repo.write_file("src/lib.rs", "pub fn answer() -> i32 { 42 }\n");
+
+    let gate = decision_gate(repo.path()).unwrap();
+
+    assert_eq!(gate.schema, "naome.decision-gate.v1");
+    assert_eq!(gate.action, "continue");
+    assert!(gate
+        .reason_codes
+        .contains(&"active_task_in_progress".to_string()));
+
+    repo.write_file("README.md", "# Drift\n");
+    let drift_gate = decision_gate(repo.path()).unwrap();
+    assert_eq!(drift_gate.action, "ask_human");
+    assert!(drift_gate
+        .reason_codes
+        .contains(&"scope_review_required".to_string()));
+}