@lamentis/naome 1.4.0 → 1.4.1

package/crates/naome-core/src/task_state/status/report_context.rs

@@ -0,0 +1,126 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::task_state::util::string_array;
+
+use super::git::git_status;
+use super::model::{
+    TaskGitStatus, TaskModeStatus, TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus,
+    TaskStatusFinding,
+};
+use super::proof::{
+    add_proof_findings, add_unknown_proof_findings, proof_status, recommended_commands,
+};
+use super::proof_read::{read_proofs, read_verification_checks};
+use super::report_support::{changed_entries, state_name, task_text};
+use super::scope::{add_scope_findings, scope_status};
+
+pub(super) struct TaskStatusContext {
+    pub(super) state: String,
+    pub(super) task_id: Option<String>,
+    pub(super) request: Option<String>,
+    pub(super) task_mode: TaskModeStatus,
+    pub(super) git: TaskGitStatus,
+    pub(super) scope: TaskScopeStatus,
+    pub(super) proof: TaskProofStatus,
+    pub(super) recommended_commands: Vec<TaskRecommendedCommand>,
+    pub(super) findings: Vec<TaskStatusFinding>,
+}
+
+impl TaskStatusContext {
+    pub(super) fn new(
+        root: &Path,
+        task_state: Option<&Value>,
+        mut findings: Vec<TaskStatusFinding>,
+    ) -> Result<Self, NaomeError> {
+        let active_task = task_state
+            .and_then(|state| state.get("activeTask"))
+            .filter(|task| task.is_object());
+        let state = state_name(task_state);
+        add_active_task_shape_finding(&state, task_state, active_task, &mut findings);
+        let task_id = task_text(active_task, "id");
+        let request = task_text(active_task, "request");
+        let task_mode = task_mode(active_task);
+        let admission_head = active_task
+            .and_then(|task| task.get("admission"))
+            .and_then(|admission| admission.get("gitHead"))
+            .and_then(Value::as_str)
+            .map(ToString::to_string);
+
+        let changed_entries = changed_entries(root, &mut findings);
+        let git = git_status(root, admission_head, &mut findings)?;
+        let scope = scope_status(active_task, &changed_entries);
+        add_scope_findings(&state, active_task, &scope, &mut findings);
+
+        let verification = read_verification_checks(root, &mut findings)?;
+        let proofs = active_task.map(read_proofs).unwrap_or_default();
+        add_unknown_proof_findings(&proofs, &verification, &mut findings);
+        let proof = proof_status(active_task, &proofs, &scope.in_scope_changed_paths);
+        add_proof_findings(
+            &proof,
+            &scope.in_scope_changed_paths,
+            &proofs,
+            &mut findings,
+        );
+        let recommended_commands =
+            recommended_commands(&proof, &verification, &scope.in_scope_changed_paths);
+
+        Ok(Self {
+            state,
+            task_id,
+            request,
+            task_mode,
+            git,
+            scope,
+            proof,
+            recommended_commands,
+            findings,
+        })
+    }
+}
+
+fn add_active_task_shape_finding(
+    state: &str,
+    task_state: Option<&Value>,
+    active_task: Option<&Value>,
+    findings: &mut Vec<TaskStatusFinding>,
+) {
+    if !matches!(
+        state,
+        "implementing" | "blocked" | "needs_human_review" | "revising"
+    ) {
+        return;
+    }
+    if task_state.is_some() && active_task.is_none() {
+        findings.push(super::model::finding(
+            "task.state.active_task_missing",
+            "error",
+            format!("Task state is {state} but activeTask is missing or not an object."),
+            Some(".naome/task-state.json".to_string()),
+            "Restore a valid activeTask object or reset the task state before continuing.",
+            "Do not complete or commit a task while activeTask is missing.",
+        ));
+    }
+}
+
+fn task_mode(active_task: Option<&Value>) -> TaskModeStatus {
+    let kind = task_text(active_task, "kind").unwrap_or_else(|| "standard".to_string());
+    let declared_review_fix = active_task
+        .and_then(|task| string_array(task.get("declaredChangeTypes")))
+        .unwrap_or_default()
+        .iter()
+        .any(|value| value == "review-fix");
+    let review_fix = kind == "review_fix" || declared_review_fix;
+    TaskModeStatus {
+        kind,
+        review_fix,
+        scope_policy: if review_fix {
+            "Review-fix tasks must stay inside explicit allowedPaths."
+        } else {
+            "Task changes must stay inside explicit allowedPaths."
+        }
+        .to_string(),
+    }
+}

package/crates/naome-core/src/task_state/status/report_support.rs

@@ -0,0 +1,117 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::task_ledger::read_task_state_projection;
+use crate::task_state::git_io::read_git_changed_entries;
+use crate::task_state::types::ChangedEntry;
+
+use super::model::{finding, TaskFeedback, TaskProofStatus, TaskStatusFinding, TASK_STATE_PATH};
+
+pub(super) fn read_task_state_for_status(
+    root: &Path,
+    findings: &mut Vec<TaskStatusFinding>,
+) -> Result<Option<Value>, NaomeError> {
+    let path = root.join(TASK_STATE_PATH);
+    if let Ok(content) = fs::read_to_string(&path) {
+        if has_conflict_markers(&content) {
+            findings.push(finding(
+                "task.state.conflict_markers",
+                "error",
+                ".naome/task-state.json contains unresolved conflict markers.",
+                Some(TASK_STATE_PATH.to_string()),
+                "Resolve the conflict markers and rerun naome task status.",
+                "Do not edit or commit task-state conflict markers.",
+            ));
+            return Ok(None);
+        }
+        if let Err(error) = serde_json::from_str::<Value>(&content) {
+            findings.push(finding(
+                "task.state.invalid_json",
+                "error",
+                format!(".naome/task-state.json is not valid JSON: {error}."),
+                Some(TASK_STATE_PATH.to_string()),
+                "Repair .naome/task-state.json to valid JSON or restore it from a clean task baseline.",
+                "Do not continue task work while task-state JSON is malformed.",
+            ));
+            return Ok(None);
+        }
+    }
+    read_task_state_projection(root)
+}
+
+pub(super) fn changed_entries(
+    root: &Path,
+    findings: &mut Vec<TaskStatusFinding>,
+) -> Vec<ChangedEntry> {
+    match read_git_changed_entries(root) {
+        Ok(entries) => entries,
+        Err(error) => {
+            findings.push(finding(
+                "task.git.status_unavailable",
+                "warning",
+                format!("Git changed-file status is unavailable: {error}"),
+                None,
+                "Run task status from a valid git work tree.",
+                "Do not infer task scope while git status is unavailable.",
+            ));
+            Vec::new()
+        }
+    }
+}
+
+pub(super) fn state_name(task_state: Option<&Value>) -> String {
+    task_state
+        .and_then(|state| state.get("status"))
+        .and_then(Value::as_str)
+        .unwrap_or("missing")
+        .to_string()
+}
+
+pub(super) fn task_text(active_task: Option<&Value>, key: &str) -> Option<String> {
+    active_task
+        .and_then(|task| task.get(key))
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+pub(super) fn task_feedback(findings: &[TaskStatusFinding]) -> Vec<TaskFeedback> {
+    findings
+        .iter()
+        .filter(|finding| finding.severity != "info")
+        .map(|finding| TaskFeedback {
+            problem: finding.message.clone(),
+            repair: finding.suggested_fix.clone(),
+            files: finding.path.iter().cloned().collect(),
+            must_not_do: vec![
+                "Do not commit out-of-scope changes.".to_string(),
+                "Do not bypass the NAOME commit gate.".to_string(),
+            ],
+        })
+        .collect()
+}
+
+pub(super) fn next_action(
+    state: &str,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+) -> String {
+    if let Some(finding) = findings.iter().find(|finding| finding.severity == "error") {
+        return finding.suggested_fix.clone();
+    }
+    if !proof.missing_checks.is_empty() || !proof.stale_checks.is_empty() {
+        return "Run missing or stale checks from naome task proof-plan before completion."
+            .to_string();
+    }
+    match state {
+        "idle" | "missing" => "Create a NAOME task before feature work.".to_string(),
+        "complete" => "Task is complete; baseline it before starting unrelated work.".to_string(),
+        _ => "Continue the active task and keep proof current.".to_string(),
+    }
+}
+
+fn has_conflict_markers(content: &str) -> bool {
+    content.contains("<<<<<<<") && content.contains("=======") && content.contains(">>>>>>>")
+}

package/crates/naome-core/src/task_state/status/scope.rs

@@ -0,0 +1,111 @@
+use serde_json::Value;
+
+use super::model::{finding, TaskScopeStatus, TaskStatusFinding, TASK_STATE_PATH};
+use crate::task_state::types::{is_control_state_path, ChangedEntry};
+use crate::task_state::util::{matches_any_pattern, string_array};
+
+pub(super) fn scope_status(
+    active_task: Option<&Value>,
+    changed_entries: &[ChangedEntry],
+) -> TaskScopeStatus {
+    let allowed_paths = active_task
+        .and_then(|task| string_array(task.get("allowedPaths")))
+        .unwrap_or_default();
+    let changed_paths = changed_entries
+        .iter()
+        .map(|entry| entry.path.clone())
+        .collect::<Vec<_>>();
+    let task_paths = changed_paths
+        .iter()
+        .filter(|path| !is_control_state_path(path))
+        .cloned()
+        .collect::<Vec<_>>();
+    let in_scope_changed_paths = task_paths
+        .iter()
+        .filter(|path| matches_any_pattern(path, &allowed_paths))
+        .cloned()
+        .collect::<Vec<_>>();
+    let out_of_scope_changed_paths = if active_task.is_some() {
+        task_paths
+            .iter()
+            .filter(|path| !matches_any_pattern(path, &allowed_paths))
+            .cloned()
+            .collect::<Vec<_>>()
+    } else {
+        Vec::new()
+    };
+
+    TaskScopeStatus {
+        allowed_paths,
+        changed_paths,
+        in_scope_changed_paths,
+        out_of_scope_changed_paths,
+    }
+}
+
+pub(super) fn add_scope_findings(
+    state: &str,
+    active_task: Option<&Value>,
+    scope: &TaskScopeStatus,
+    findings: &mut Vec<TaskStatusFinding>,
+) {
+    for path in &scope.out_of_scope_changed_paths {
+        findings.push(finding(
+            "task.scope.out_of_scope_change",
+            "error",
+            format!("Changed file is outside the active task scope: {path}."),
+            Some(path.clone()),
+            "Either add the file through an explicit task scope revision or remove the unrelated change.",
+            "Do not commit out-of-scope changes or bypass the NAOME commit gate.",
+        ));
+    }
+
+    if !scope.changed_paths.is_empty()
+        && scope
+            .changed_paths
+            .iter()
+            .all(|path| is_control_state_path(path))
+    {
+        findings.push(finding(
+            "task.scope.control_state_only_change",
+            "warning",
+            "Only NAOME control-state files are changed.",
+            Some(TASK_STATE_PATH.to_string()),
+            "Continue only if the task-state transition is intentional and supported by proof.",
+            "Do not use control-state-only edits to bypass normal task admission.",
+        ));
+    }
+
+    if active_task.is_none()
+        && scope
+            .changed_paths
+            .iter()
+            .any(|path| !is_control_state_path(path))
+    {
+        findings.push(finding(
+            "task.state.no_active_task_with_diff",
+            "error",
+            "Changed files exist but no active task is available.",
+            None,
+            "Create or recover the active task before continuing feature work.",
+            "Do not commit repository changes without an admitted NAOME task.",
+        ));
+    }
+
+    if state == "complete" && !scope.changed_paths.is_empty() {
+        for path in scope
+            .changed_paths
+            .iter()
+            .filter(|path| !is_control_state_path(path))
+        {
+            findings.push(finding(
+                "task.state.completed_task_has_diff",
+                "warning",
+                format!("Completed task has new unbaselined diff: {path}."),
+                Some(path.clone()),
+                "Baseline the completed task or create a new task for the new diff.",
+                "Do not mix new work into a completed task without an explicit baseline.",
+            ));
+        }
+    }
+}

package/crates/naome-core/src/task_state/status/transition.rs

@@ -0,0 +1,73 @@
+use super::control::agent_loop;
+use super::model::{finding, TaskProofStatus, TaskStatusFinding, TransitionReadinessReport};
+use super::report_context::TaskStatusContext;
+
+pub(super) fn transition_report(
+    context: TaskStatusContext,
+    target_state: &str,
+) -> TransitionReadinessReport {
+    let agent_loop = agent_loop(
+        &context.state,
+        &context.proof,
+        &context.findings,
+        &context.scope,
+    );
+    let blocking_findings = transition_blockers(&context.state, &context.findings, &context.proof);
+    let required_before_transition = blocking_findings
+        .iter()
+        .map(|finding| finding.suggested_fix.clone())
+        .collect::<Vec<_>>();
+    TransitionReadinessReport {
+        schema: "naome.task.transition-readiness.v1".to_string(),
+        target_state: target_state.to_string(),
+        allowed: blocking_findings.is_empty(),
+        blocking_findings,
+        required_before_transition,
+        agent_loop,
+    }
+}
+
+fn transition_blockers(
+    state: &str,
+    findings: &[TaskStatusFinding],
+    proof: &TaskProofStatus,
+) -> Vec<TaskStatusFinding> {
+    let mut blockers = findings
+        .iter()
+        .filter(|finding| {
+            finding.severity == "error" || finding.id == "task.state.completed_task_has_diff"
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+    if matches!(state, "idle" | "missing") {
+        blockers.push(finding(
+            "task.transition.no_active_task",
+            "error",
+            "No active task can transition to complete.",
+            None,
+            "Create or recover an active task before completing.",
+            "Do not complete an idle or missing task.",
+        ));
+    }
+    if matches!(state, "blocked" | "needs_human_review") {
+        blockers.push(finding(
+            "task.transition.blocked_state",
+            "error",
+            format!("Task state {state} cannot transition to complete."),
+            None,
+            "Resolve the blocker or required human review before completing the task.",
+            "Do not complete a blocked task state.",
+        ));
+    }
+    if !proof.stale_checks.is_empty() {
+        blockers.push(finding(
+            "task.transition.stale_proof",
+            "error",
+            "Task has stale proof.",
+            None,
+            "Rerun stale checks and record fresh proof.",
+            "Do not complete a task with stale proof.",
+        ));
+    }
+    blockers
+}

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

@@ -0,0 +1,23 @@
+mod agent_model;
+mod control;
+mod git;
+mod model;
+mod proof;
+mod proof_read;
+mod report;
+mod report_context;
+mod report_support;
+mod scope;
+mod transition;
+
+pub use agent_model::{
+    AgentLoop, NextActionV2, PolicyHints, ProofRecording, ProofRecordingAfterSuccess,
+    RecoveryGuidance, RepairPlanItem,
+};
+pub use control::task_status_exit_code;
+pub use model::{
+    TaskFeedback, TaskGitStatus, TaskModeStatus, TaskProofPlanReport, TaskProofStatus,
+    TaskRecommendedCommand, TaskScopeStatus, TaskStatusFinding, TaskStatusReportV1,
+    TransitionReadinessReport,
+};
+pub use report::{task_proof_plan, task_status_report, task_transition_readiness};

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

@@ -0,0 +1,103 @@
+use super::status::{TaskProofPlanReport, TaskProofStatus, TaskStatusFinding, TaskStatusReportV1};
+
+pub fn format_task_status(report: &TaskStatusReportV1) -> String {
+    let mut lines = vec![
+        format!("NAOME task status {}", report.state),
+        format!("agent loop: {}", report.agent_loop.state),
+        format!("next machine action: {}", report.next_action_v2.action_type),
+        format!("task: {}", report.task_id.as_deref().unwrap_or("<none>")),
+        format!("request: {}", report.request.as_deref().unwrap_or("<none>")),
+        format!(
+            "git head: {}",
+            report.git.head.as_deref().unwrap_or("<none>")
+        ),
+        format!(
+            "admission head: {}",
+            report.git.admission_head.as_deref().unwrap_or("<none>")
+        ),
+        format!(
+            "admission reachable: {}",
+            report.git.admission_head_reachable
+        ),
+        format!("changed files: {}", report.scope.changed_paths.len()),
+        format!(
+            "in scope: {}",
+            display_list(&report.scope.in_scope_changed_paths)
+        ),
+        format!(
+            "out of scope: {}",
+            display_list(&report.scope.out_of_scope_changed_paths)
+        ),
+    ];
+    append_proof_summary(&mut lines, &report.proof);
+    append_findings(&mut lines, &report.findings);
+    lines.push(format!("next action: {}", report.next_action));
+    lines.push(String::new());
+    lines.join("\n")
+}
+
+pub fn format_task_proof_plan(report: &TaskProofPlanReport) -> String {
+    let mut lines = vec![
+        format!(
+            "NAOME task proof plan {}",
+            report.task_id.as_deref().unwrap_or("<none>")
+        ),
+        format!("agent loop: {}", report.agent_loop.state),
+        format!("next machine action: {}", report.next_action_v2.action_type),
+    ];
+    append_proof_summary(&mut lines, &report.proof);
+    if !report.recommended_commands.is_empty() {
+        lines.push("recommended commands:".to_string());
+        for command in &report.recommended_commands {
+            lines.push(format!(
+                "- {}: {} (cwd {})",
+                command.check_id, command.command, command.cwd
+            ));
+        }
+    }
+    append_findings(&mut lines, &report.findings);
+    lines.push(format!("next action: {}", report.next_action));
+    lines.push(String::new());
+    lines.join("\n")
+}
+
+fn append_proof_summary(lines: &mut Vec<String>, proof: &TaskProofStatus) {
+    lines.push(format!(
+        "required checks: {}",
+        display_list(&proof.required_checks)
+    ));
+    lines.push(format!(
+        "passed checks: {}",
+        display_list(&proof.passed_checks)
+    ));
+    lines.push(format!(
+        "missing checks: {}",
+        display_list(&proof.missing_checks)
+    ));
+    lines.push(format!(
+        "stale checks: {}",
+        display_list(&proof.stale_checks)
+    ));
+}
+
+fn append_findings(lines: &mut Vec<String>, findings: &[TaskStatusFinding]) {
+    if findings.is_empty() {
+        return;
+    }
+    lines.push("findings:".to_string());
+    for finding in findings {
+        lines.push(format!(
+            "- {} {} {}",
+            finding.severity, finding.id, finding.message
+        ));
+        lines.push(format!("  fix: {}", finding.suggested_fix));
+    }
+}
+
+fn display_list(values: &[String]) -> String {
+    if values.is_empty() {
+        "<none>".to_string()
+    } else {
+        values.join(", ")
+    }
+}

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

@@ -1,3 +1,5 @@
+#![allow(dead_code, unused_imports)]
+
 mod states;
 
 use std::collections::HashMap;
@@ -12,7 +14,7 @@ use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
 pub use states::{
     active_task, complete_task_state, idle_task_state, ready_empty_verification_fixture,
-    successful_admission, successful_proof,
+    successful_admission, successful_proof, task_state_with_status,
 };
 
 static FIXTURE_COUNTER: AtomicU64 = AtomicU64::new(0);
@@ -88,6 +90,18 @@ impl TaskFixture {
         self.refresh_admission_head();
     }
 
+    pub fn set_admission_head(&self, head: &str) {
+        let path = self.root.join(".naome/task-state.json");
+        let mut task_state: Value =
+            serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+        task_state["activeTask"]["admission"]["gitHead"] = json!(head);
+        fs::write(
+            path,
+            format!("{}\n", serde_json::to_string_pretty(&task_state).unwrap()),
+        )
+        .unwrap();
+    }
+
     pub fn git<const N: usize>(&self, args: [&str; N]) -> String {
         let output = Command::new("git")
             .args(args)

package/crates/naome-core/tests/task_state_support/states.rs

@@ -12,6 +12,10 @@ pub fn complete_task_state(overrides: Value) -> Value {
     )
 }
 
+pub fn task_state_with_status(status: &str, active_task: Value) -> Value {
+    task_state_record(status, active_task, json!("2026-05-04T12:00:00.000Z"))
+}
+
 fn task_state_record(status: &str, active_task: Value, updated_at: Value) -> Value {
     let mut state: Value = serde_json::from_str(include_str!(
         "../../../../templates/naome-root/.naome/task-state.json"