@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-core/src/task_state/api.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::task_ledger::{read_task_state_projection, validate_task_state_projection_is_current};
 
 use super::completion::{
     validate_admission, validate_commit_gate, validate_complete_task, validate_progress,
@@ -16,7 +17,7 @@ use super::shape::{
 };
 use super::task_diff_api::validate_harness_health_gate;
 use super::types::*;
-use super::util::read_json;
+
 pub fn validate_task_state(
     root: &Path,
     options: TaskStateOptions,
@@ -25,10 +26,11 @@ pub fn validate_task_state(
         errors: Vec::new(),
         notices: Vec::new(),
     };
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut report.errors)? else {
+    let Some(task_state) = read_task_state_projection(root)? else {
         return Ok(report);
     };
 
+    validate_task_state_projection_is_current(root, &mut report.errors)?;
     validate_task_state_shape(&task_state, &mut report.errors);
     let status = task_state
         .get("status")

package/crates/naome-core/src/task_state/completed_refresh.rs

@@ -1,16 +1,15 @@
 use std::path::Path;
 
-use serde_json::Value;
-
 use crate::models::NaomeError;
 
 use super::api::validate_task_state;
 use super::git_io::read_git_changed_paths;
 use super::repair::is_safe_harness_refresh_path;
 use super::types::{
-    CompletedTaskHarnessRefreshDiff, TaskStateMode, TaskStateOptions, CONTROL_STATE_PATH,
+    is_control_state_path, read_complete_active_task, CompletedTaskHarnessRefreshDiff,
+    TaskStateMode, TaskStateOptions,
 };
-use super::util::{matches_any_pattern, read_json, string_array};
+use super::util::{matches_any_pattern, string_array};
 pub(super) fn add_completed_task_diff_notice(
     root: &Path,
     notices: &mut Vec<String>,
@@ -27,17 +26,7 @@ pub(super) fn add_completed_task_diff_notice(
 pub fn completed_task_harness_refresh_diff(
     root: &Path,
 ) -> Result<Option<CompletedTaskHarnessRefreshDiff>, NaomeError> {
-    let mut read_errors = Vec::new();
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut read_errors)? else {
-        return Ok(None);
-    };
-    if !read_errors.is_empty() {
-        return Ok(None);
-    }
-    if task_state.get("status").and_then(Value::as_str) != Some("complete") {
-        return Ok(None);
-    }
-    let Some(active_task) = task_state.get("activeTask") else {
+    let Some((_, active_task)) = read_complete_active_task(root)? else {
         return Ok(None);
     };
 
@@ -47,7 +36,7 @@ pub fn completed_task_harness_refresh_diff(
     let mut other_paths = Vec::new();
 
     for path in read_git_changed_paths(root)? {
-        if path == CONTROL_STATE_PATH {
+        if is_control_state_path(&path) {
             continue;
         }
         if matches_any_pattern(&path, &allowed_paths) {

package/crates/naome-core/src/task_state/diff.rs

@@ -6,7 +6,7 @@ use serde_json::Value;
 use crate::models::NaomeError;
 
 use super::git_io::read_git_changed_entries;
-use super::types::{ChangedEntry, TaskDiff, CONTROL_STATE_PATH};
+use super::types::{is_control_state_path, ChangedEntry, TaskDiff};
 use super::util::{matches_any_pattern, normalize_path, string_array};
 pub(super) fn validate_changed_paths(
     active_task: &Value,
@@ -80,7 +80,7 @@ pub(super) fn task_diff_from_entries(active_task: &Value, entries: &[ChangedEntr
     let diff_paths: Vec<String> = entries
         .iter()
         .map(|entry| entry.path.clone())
-        .filter(|path| path != CONTROL_STATE_PATH)
+        .filter(|path| !is_control_state_path(path))
         .collect();
     let outside_paths = diff_paths
         .iter()

package/crates/naome-core/src/task_state/evidence.rs

@@ -7,7 +7,7 @@ use crate::models::NaomeError;
 
 use super::deleted_paths::read_historical_deleted_paths;
 use super::git_io::read_git_changed_entries;
-use super::types::{ALLOWED_EVIDENCE_STATUS, CONTROL_STATE_PATH};
+use super::types::{is_control_state_path, ALLOWED_EVIDENCE_STATUS, CONTROL_STATE_PATH};
 use super::util::{
     is_non_empty_string, matches_any_pattern, normalize_path, require_string, string_array,
 };
@@ -68,7 +68,12 @@ pub(super) fn validate_control_state_patterns(
     };
 
     for pattern in patterns {
-        if matches_any_pattern(CONTROL_STATE_PATH, std::slice::from_ref(&pattern)) {
+        if matches_any_pattern(CONTROL_STATE_PATH, std::slice::from_ref(&pattern))
+            || matches_any_pattern(
+                ".naome/tasks/example/task.json",
+                std::slice::from_ref(&pattern),
+            )
+        {
             errors.push(format!(
                 "{field_name} cannot include NAOME control state: {pattern}"
             ));
@@ -89,7 +94,7 @@ pub(super) fn validate_control_state_paths(
         let Some(path) = evidence_entry_path(entry) else {
             continue;
         };
-        if normalize_path(&path) == CONTROL_STATE_PATH {
+        if is_control_state_path(&normalize_path(&path)) {
             errors.push(format!(
                 "{field_name} cannot include NAOME control state: {path}"
             ));

package/crates/naome-core/src/task_state/mod.rs

@@ -30,7 +30,7 @@ mod util;
 
 pub use api::validate_task_state;
 pub use completed_refresh::completed_task_harness_refresh_diff;
-pub(crate) use proof_model::canonical_proof_check_ids;
+pub(crate) use proof_model::{canonical_proof_check_ids, canonical_proofs};
 pub use task_diff_api::{
     completed_task_commit_diff, completed_task_commit_paths, harness_refresh_diff,
     harness_refresh_with_unrelated_diff,

package/crates/naome-core/src/task_state/progress.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 
 use super::diff::validate_changed_paths;
 use super::git_io::read_git_changed_paths;
@@ -33,6 +34,7 @@ pub(super) fn validate_progress(
             if let Some(active_task) = task_state.get("activeTask") {
                 validate_changed_paths(active_task, root, errors)?;
             }
+            validate_repository_model_current(root, errors)?;
         }
         "needs_human_review" => {
             validate_human_review_state(task_state, root, errors)?;
@@ -60,6 +62,17 @@ pub(super) fn validate_progress(
     Ok(())
 }
 
+fn validate_repository_model_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let drift = repository_model_drift(root)?;
+    if drift.model_present && drift.stale {
+        errors.extend(drift.messages);
+    }
+    Ok(())
+}
+
 pub(super) fn checked_status<'a>(
     task_state: &'a Value,
     root: &Path,

package/crates/naome-core/src/task_state/proof_model.rs

@@ -8,13 +8,13 @@ use super::compact_proof::compact_proofs;
 use super::proof_sources::{check_id_from_proof, read_verification_defaults};
 
 #[derive(Debug, Clone)]
-pub(super) struct CanonicalProof {
-    pub(super) check_id: String,
-    pub(super) command: String,
-    pub(super) cwd: String,
-    pub(super) exit_code: i64,
-    pub(super) checked_at: String,
-    pub(super) evidence: Vec<Value>,
+pub(crate) struct CanonicalProof {
+    pub(crate) check_id: String,
+    pub(crate) command: String,
+    pub(crate) cwd: String,
+    pub(crate) exit_code: i64,
+    pub(crate) checked_at: String,
+    pub(crate) evidence: Vec<Value>,
 }
 
 #[derive(Debug, Clone)]
@@ -23,7 +23,7 @@ pub(super) struct VerificationDefaults {
     pub(super) cwd: String,
 }
 
-pub(super) fn canonical_proofs(
+pub(crate) fn canonical_proofs(
     active_task: &Value,
     root: &Path,
     errors: &mut Vec<String>,

package/crates/naome-core/src/task_state/repair.rs

@@ -6,7 +6,7 @@ use serde_json::Value;
 use crate::install_plan::MACHINE_OWNED_PATHS;
 use crate::models::NaomeError;
 
-use super::types::CONTROL_STATE_PATH;
+use super::types::is_control_state_path;
 use super::util::{
     is_non_empty_string, matches_any_pattern, normalize_path, read_json, string_array,
 };
@@ -69,7 +69,7 @@ pub(super) fn is_completed_task_diff(task_state: &Value, changed_paths: &[String
     let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
     let task_paths: Vec<&String> = changed_paths
         .iter()
-        .filter(|path| path.as_str() != CONTROL_STATE_PATH)
+        .filter(|path| !is_control_state_path(path))
         .collect();
     !task_paths.is_empty()
         && task_paths

package/crates/naome-core/src/task_state/task_diff_api.rs

@@ -16,10 +16,10 @@ use super::shape::{
     validate_pending_upgrade, validate_required_check_ids, validate_task_state_shape,
 };
 use super::types::{
-    CompletedTaskCommitDiff, HarnessRefreshDiff, HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
-    CONTROL_STATE_PATH,
+    is_control_state_path, read_complete_active_task, CompletedTaskCommitDiff, HarnessRefreshDiff,
+    HarnessRefreshWithUnrelatedDiff, TaskStateOptions,
 };
-use super::util::{matches_any_pattern, read_json, string_array};
+use super::util::{matches_any_pattern, string_array};
 
 pub fn completed_task_commit_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
     Ok(completed_task_commit_diff(root)?
@@ -30,16 +30,7 @@ pub fn completed_task_commit_paths(root: &Path) -> Result<Vec<String>, NaomeErro
 pub fn completed_task_commit_diff(
     root: &Path,
 ) -> Result<Option<CompletedTaskCommitDiff>, NaomeError> {
-    let mut read_errors = Vec::new();
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut read_errors)? else {
-        return Ok(None);
-    };
-    if !read_errors.is_empty()
-        || task_state.get("status").and_then(Value::as_str) != Some("complete")
-    {
-        return Ok(None);
-    }
-    let Some(active_task) = task_state.get("activeTask") else {
+    let Some((task_state, active_task)) = read_complete_active_task(root)? else {
         return Ok(None);
     };
 
@@ -47,7 +38,7 @@ pub fn completed_task_commit_diff(
     let mut task_entries = Vec::new();
     let mut unrelated_paths = Vec::new();
     for entry in read_git_changed_entries(root)? {
-        if entry.path == CONTROL_STATE_PATH || matches_any_pattern(&entry.path, &allowed_paths) {
+        if is_control_state_path(&entry.path) || matches_any_pattern(&entry.path, &allowed_paths) {
             task_entries.push(entry);
         } else {
             unrelated_paths.push(entry.path);
@@ -60,16 +51,16 @@ pub fn completed_task_commit_diff(
 
     let mut errors = Vec::new();
     validate_task_state_shape(&task_state, &mut errors);
-    validate_active_task(Some(active_task), &mut errors);
+    validate_active_task(Some(&active_task), &mut errors);
     validate_pending_upgrade(&task_state, root, &mut errors)?;
-    validate_active_task_references(Some(active_task), root, &mut errors, Some("complete"))?;
+    validate_active_task_references(Some(&active_task), root, &mut errors, Some("complete"))?;
     if !task_state.get("blocker").is_some_and(Value::is_null) {
         errors.push("complete task state must have blocker set to null.".to_string());
     }
     let check_ids = read_verification_check_ids(root, &mut errors)?;
-    validate_required_check_ids(active_task, &check_ids, &mut errors);
+    validate_required_check_ids(&active_task, &check_ids, &mut errors);
     validate_complete_task_against_entries(
-        active_task,
+        &active_task,
         root,
         &check_ids,
         &task_entries,

package/crates/naome-core/src/task_state/types.rs

@@ -1,6 +1,13 @@
+use std::path::Path;
+
+use serde_json::Value;
+
 use crate::harness_health::HarnessHealthOptions;
+use crate::models::NaomeError;
+use crate::task_ledger::read_task_state_projection;
 
 pub(super) const CONTROL_STATE_PATH: &str = ".naome/task-state.json";
+pub(super) const TASK_LEDGER_PATH_PREFIX: &str = ".naome/tasks/";
 pub(super) const ALLOWED_STATUS: &[&str] = &[
     "idle",
     "planning",
@@ -85,3 +92,20 @@ pub(super) struct TaskDiff {
     pub(super) diff_paths: Vec<String>,
     pub(super) outside_paths: Vec<String>,
 }
+
+pub(super) fn is_control_state_path(path: &str) -> bool {
+    path == CONTROL_STATE_PATH || path.starts_with(TASK_LEDGER_PATH_PREFIX)
+}
+
+pub(super) fn read_complete_active_task(root: &Path) -> Result<Option<(Value, Value)>, NaomeError> {
+    let Some(task_state) = read_task_state_projection(root)? else {
+        return Ok(None);
+    };
+    if task_state.get("status").and_then(Value::as_str) != Some("complete") {
+        return Ok(None);
+    }
+    let Some(active_task) = task_state.get("activeTask") else {
+        return Ok(None);
+    };
+    Ok(Some((task_state.clone(), active_task.clone())))
+}

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

@@ -46,7 +46,7 @@ pub fn seed_builtin_verification_checks(root: &Path) -> Result<bool, NaomeError>
         }
     }
 
-    let wired_change_types = wire_repository_quality_check(verification_object);
+    let wired_change_types = wire_repository_gate_checks(verification_object);
     let phases_added = ensure_default_phases(verification_object);
 
     if missing_checks.is_empty() && !wired_change_types && !phases_added {
@@ -126,7 +126,7 @@ fn default_phases() -> Vec<BuiltinPhase> {
         BuiltinPhase {
             id: "quality",
             order: 20,
-            check_ids: &["repository-quality-check"],
+            check_ids: &["repository-quality-check", "repository-semantic-check"],
         },
         BuiltinPhase {
             id: "diff-check",
@@ -136,7 +136,7 @@ fn default_phases() -> Vec<BuiltinPhase> {
     ]
 }
 
-fn wire_repository_quality_check(verification_object: &mut serde_json::Map<String, Value>) -> bool {
+fn wire_repository_gate_checks(verification_object: &mut serde_json::Map<String, Value>) -> bool {
     let Some(change_types) = verification_object
         .get_mut("changeTypes")
         .and_then(Value::as_array_mut)
@@ -155,33 +155,35 @@ fn wire_repository_quality_check(verification_object: &mut serde_json::Map<Strin
         {
             continue;
         }
-        let already_wired = ["requiredChecks", "recommendedChecks"].iter().any(|field| {
-            change_type_object
-                .get(*field)
-                .and_then(Value::as_array)
-                .is_some_and(|checks| {
-                    checks
-                        .iter()
-                        .any(|check| check.as_str() == Some("repository-quality-check"))
-                })
-        });
-        if already_wired {
-            continue;
-        }
         if !change_type_object
             .get("requiredChecks")
             .is_some_and(Value::is_array)
         {
             change_type_object.insert("requiredChecks".to_string(), Value::Array(Vec::new()));
         }
+        let missing_checks = ["repository-quality-check", "repository-semantic-check"]
+            .into_iter()
+            .filter(|check_id| {
+                !["requiredChecks", "recommendedChecks"].iter().any(|field| {
+                    change_type_object
+                        .get(*field)
+                        .and_then(Value::as_array)
+                        .is_some_and(|checks| {
+                            checks.iter().any(|check| check.as_str() == Some(*check_id))
+                        })
+                })
+            })
+            .collect::<Vec<_>>();
         let Some(required_checks) = change_type_object
             .get_mut("requiredChecks")
             .and_then(Value::as_array_mut)
         else {
             continue;
         };
-        required_checks.push(Value::String("repository-quality-check".to_string()));
-        changed = true;
+        for check_id in missing_checks {
+            required_checks.push(Value::String(check_id.to_string()));
+            changed = true;
+        }
     }
 
     changed
@@ -247,6 +249,15 @@ fn builtin_checks() -> Vec<BuiltinCheck> {
                 ".naome/repository-quality-baseline.json",
             ],
         },
+        BuiltinCheck {
+            id: "repository-semantic-check",
+            command: "node .naome/bin/naome.js semantic check --changed",
+            purpose: "Validate changed files against deterministic NAOME semantic cleanup rules.",
+            evidence: &[
+                ".naome/repository-quality.json",
+                ".naome/repository-quality-baseline.json",
+            ],
+        },
     ]
 }
 

package/crates/naome-core/src/workflow/agent/capability.rs

@@ -0,0 +1,194 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::repository_model::refresh_repository_model;
+use crate::workflow::agent_types::{
+    CapabilityGraph, CapabilityRoot, RepositoryCapability, VerificationEdge,
+};
+
+pub fn repository_capability_graph(root: &Path) -> Result<CapabilityGraph, NaomeError> {
+    let mut model = refresh_repository_model(root, false)?.model;
+    if model.languages.is_empty() && model.build_systems.is_empty() && model.adapters.is_empty() {
+        model = fallback_capability_model(root)?;
+    }
+    let mut capabilities = Vec::new();
+    capabilities.extend(
+        model
+            .languages
+            .into_iter()
+            .map(|signal| capability_from_signal("language", signal)),
+    );
+    capabilities.extend(
+        model
+            .build_systems
+            .into_iter()
+            .map(|signal| capability_from_signal("build", signal)),
+    );
+    capabilities.extend(
+        model
+            .adapters
+            .into_iter()
+            .map(|signal| capability_from_signal("adapter", signal)),
+    );
+    capabilities.sort_by(|left, right| left.id.cmp(&right.id));
+
+    let verification_edges = if model.verification_checks.is_empty() {
+        read_verification_edges(root)?
+    } else {
+        model
+            .verification_checks
+            .into_iter()
+            .map(|check| VerificationEdge {
+                check_id: check.id,
+                command: check.command,
+                evidence: check.evidence,
+            })
+            .collect()
+    };
+
+    Ok(CapabilityGraph {
+        schema: "naome.capability-graph.v1".to_string(),
+        capabilities,
+        roots: model
+            .roots
+            .into_iter()
+            .map(|root| CapabilityRoot {
+                role: root.role,
+                path: root.path,
+            })
+            .collect(),
+        verification_edges,
+    })
+}
+
+fn capability_from_signal(
+    kind: &str,
+    signal: crate::RepositoryWorldSignal,
+) -> RepositoryCapability {
+    RepositoryCapability {
+        id: format!("{kind}:{}", signal.value),
+        kind: kind.to_string(),
+        value: signal.value,
+        evidence: signal.evidence,
+    }
+}
+
+fn fallback_capability_model(root: &Path) -> Result<crate::RepositoryModel, NaomeError> {
+    let paths = fallback_paths(root)?;
+    let mut model = crate::RepositoryModel::default();
+    model.schema = "naome.repository-model.v2".to_string();
+    model.version = 2;
+    if paths
+        .iter()
+        .any(|path| path == "Cargo.toml" || path.ends_with(".rs"))
+    {
+        let evidence = first_evidence(&paths, &["Cargo.toml", ".rs"]);
+        model
+            .languages
+            .push(signal("language:rust", "rust", &evidence));
+        model
+            .build_systems
+            .push(signal("buildSystem:cargo", "cargo", &evidence));
+    }
+    Ok(model)
+}
+
+fn signal(id: &str, value: &str, evidence: &[String]) -> crate::RepositoryWorldSignal {
+    crate::RepositoryWorldSignal {
+        id: id.to_string(),
+        value: value.to_string(),
+        confidence: "detected".to_string(),
+        source: "fallback-scan".to_string(),
+        evidence: evidence.to_vec(),
+    }
+}
+
+fn read_verification_edges(root: &Path) -> Result<Vec<VerificationEdge>, NaomeError> {
+    let path = root.join(".naome/verification.json");
+    if !path.is_file() {
+        return Ok(Vec::new());
+    }
+    let verification: Value = serde_json::from_str(&fs::read_to_string(path)?)?;
+    Ok(verification
+        .get("checks")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|check| {
+            Some(VerificationEdge {
+                check_id: check.get("id")?.as_str()?.to_string(),
+                command: check.get("command")?.as_str()?.to_string(),
+                evidence: check
+                    .get("evidence")
+                    .and_then(Value::as_array)
+                    .into_iter()
+                    .flatten()
+                    .filter_map(Value::as_str)
+                    .map(ToString::to_string)
+                    .collect(),
+            })
+        })
+        .collect())
+}
+
+fn fallback_paths(root: &Path) -> Result<Vec<String>, NaomeError> {
+    let mut paths = Vec::new();
+    collect_fallback_paths(root, root, &mut paths)?;
+    paths.sort();
+    paths.dedup();
+    Ok(paths)
+}
+
+fn collect_fallback_paths(
+    root: &Path,
+    dir: &Path,
+    paths: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let relative = path
+            .strip_prefix(root)
+            .unwrap_or(&path)
+            .to_string_lossy()
+            .replace('\\', "/");
+        if is_fallback_ignored(&relative) {
+            continue;
+        }
+        if path.is_dir() {
+            collect_fallback_paths(root, &path, paths)?;
+        } else if path.is_file() {
+            paths.push(relative);
+        }
+    }
+    Ok(())
+}
+
+fn is_fallback_ignored(path: &str) -> bool {
+    path == ".git"
+        || path.starts_with(".git/")
+        || path.starts_with(".naome/archive/")
+        || path.starts_with(".naome/cache/")
+        || path == "node_modules"
+        || path.starts_with("node_modules/")
+        || path == "target"
+        || path.starts_with("target/")
+}
+
+fn first_evidence(paths: &[String], markers: &[&str]) -> Vec<String> {
+    let mut evidence = Vec::new();
+    for marker in markers {
+        if let Some(path) = paths
+            .iter()
+            .find(|path| path.as_str() == *marker || path.ends_with(marker))
+        {
+            evidence.push(path.clone());
+        }
+    }
+    evidence.sort();
+    evidence.dedup();
+    evidence
+}

package/crates/naome-core/src/workflow/agent/context_delta.rs

@@ -0,0 +1,42 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::support::{changed_paths, normalize_path, required_context};
+use crate::workflow::agent_types::ContextDeltaReport;
+
+pub fn context_delta_report(
+    root: &Path,
+    read_paths: &[String],
+) -> Result<ContextDeltaReport, NaomeError> {
+    let changed = changed_paths(root)?.into_iter().collect::<BTreeSet<_>>();
+    let required = required_context(root);
+    let read = read_paths
+        .iter()
+        .map(|path| normalize_path(path))
+        .collect::<BTreeSet<_>>();
+    let reusable_context = read
+        .iter()
+        .filter(|path| !changed.contains(*path) && root.join(path.as_str()).exists())
+        .cloned()
+        .collect();
+    let stale_context = read
+        .iter()
+        .filter(|path| changed.contains(*path))
+        .cloned()
+        .collect();
+    let unread_required_context = required
+        .iter()
+        .filter(|path| !read.contains(*path))
+        .cloned()
+        .collect();
+
+    Ok(ContextDeltaReport {
+        schema: "naome.context-delta.v1".to_string(),
+        reusable_context,
+        stale_context,
+        unread_required_context,
+        reason_codes: vec!["read-set-minimization".to_string()],
+    })
+}

package/crates/naome-core/src/workflow/agent/decision.rs

@@ -0,0 +1,32 @@
+use std::path::Path;
+
+use crate::decision::{evaluate_decision, EvaluationOptions};
+use crate::models::NaomeError;
+use crate::workflow::agent_types::DecisionGate;
+
+pub fn decision_gate(root: &Path) -> Result<DecisionGate, NaomeError> {
+    let decision = evaluate_decision(root, EvaluationOptions::offline())?;
+    let action = if decision.blocked {
+        if decision.state == "active_task_blocked" {
+            "ask_human"
+        } else {
+            "stop"
+        }
+    } else if decision.state == "ready_for_task" {
+        "create_task"
+    } else {
+        "continue"
+    };
+    let mut reason_codes = vec![decision.state.clone()];
+    if decision.state == "active_task_blocked" {
+        reason_codes.push("scope_review_required".to_string());
+    }
+
+    Ok(DecisionGate {
+        schema: "naome.decision-gate.v1".to_string(),
+        action: action.to_string(),
+        reason_codes,
+        human_options: decision.human_options,
+        next_action: decision.next_action,
+    })
+}