@lamentis/naome 1.4.0 → 1.4.2

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

@@ -0,0 +1,148 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::agent_model::{AgentLoop, NextActionV2, RepairPlanItem};
+use super::control::{
+    agent_loop, next_action_v2, policy_hints, proof_recording, recovery_guidance, repair_plan,
+};
+use super::model::{
+    TaskProofPlanReport, TaskStatusReportV1, TransitionReadinessReport, PROOF_PLAN_SCHEMA,
+    STATUS_SCHEMA,
+};
+use super::report_context::TaskStatusContext;
+use super::report_support::{next_action, read_task_state_for_status, task_feedback};
+use super::transition::transition_report;
+
+pub fn task_status_report(root: &Path) -> Result<TaskStatusReportV1, NaomeError> {
+    let mut findings = Vec::new();
+    let task_state = read_task_state_for_status(root, &mut findings)?;
+    let context = TaskStatusContext::new(root, task_state.as_ref(), findings)?;
+    Ok(status_report(context))
+}
+
+pub fn task_proof_plan(root: &Path) -> Result<TaskProofPlanReport, NaomeError> {
+    let mut findings = Vec::new();
+    let task_state = read_task_state_for_status(root, &mut findings)?;
+    let context = TaskStatusContext::new(root, task_state.as_ref(), findings)?;
+    Ok(proof_plan_report(context))
+}
+
+pub fn task_transition_readiness(
+    root: &Path,
+    target_state: &str,
+) -> Result<TransitionReadinessReport, NaomeError> {
+    if target_state != "complete" {
+        return Err(NaomeError::new(format!(
+            "unsupported task transition target: {target_state}; v1.4.1 supports only complete"
+        )));
+    }
+    let mut findings = Vec::new();
+    let task_state = read_task_state_for_status(root, &mut findings)?;
+    let context = TaskStatusContext::new(root, task_state.as_ref(), findings)?;
+    Ok(transition_report(context, target_state))
+}
+
+fn status_report(context: TaskStatusContext) -> TaskStatusReportV1 {
+    let blocked = context
+        .findings
+        .iter()
+        .any(|finding| finding.severity == "error");
+    let next_action = next_action(&context.state, &context.proof, &context.findings);
+    let agent = agent_control(&context);
+    let policy_hints = policy_hints(&context.scope, &context.proof, &context.findings);
+    let recovery_guidance = recovery_guidance(&context.findings);
+    TaskStatusReportV1 {
+        schema: STATUS_SCHEMA.to_string(),
+        state: context.state,
+        task_id: context.task_id,
+        request: context.request,
+        task_mode: context.task_mode,
+        git: context.git,
+        scope: context.scope,
+        proof: context.proof,
+        blocked,
+        task_feedback: task_feedback(&context.findings),
+        findings: context.findings,
+        next_action,
+        next_action_v2: agent.next_action,
+        agent_loop: agent.loop_state,
+        repair_plan: agent.repair_plan,
+        policy_hints,
+        recovery_guidance,
+    }
+}
+
+fn proof_plan_report(context: TaskStatusContext) -> TaskProofPlanReport {
+    let next_action = proof_plan_next_action(&context);
+    let agent = agent_control(&context);
+    let proof_recording =
+        proof_recording(context.task_id.as_deref(), &context.scope, &context.proof);
+    let policy_hints = policy_hints(&context.scope, &context.proof, &context.findings);
+    let recovery_guidance = recovery_guidance(&context.findings);
+    let blocked = context
+        .findings
+        .iter()
+        .any(|finding| finding.id == "task.scope.out_of_scope_change");
+    TaskProofPlanReport {
+        schema: PROOF_PLAN_SCHEMA.to_string(),
+        state: context.state,
+        task_id: context.task_id,
+        task_mode: context.task_mode,
+        proof: context.proof,
+        recommended_commands: context.recommended_commands,
+        blocked,
+        task_feedback: task_feedback(&context.findings),
+        findings: context.findings,
+        next_action,
+        next_action_v2: agent.next_action,
+        agent_loop: agent.loop_state,
+        repair_plan: agent.repair_plan,
+        proof_recording,
+        policy_hints,
+        recovery_guidance,
+    }
+}
+
+struct AgentControl {
+    next_action: NextActionV2,
+    loop_state: AgentLoop,
+    repair_plan: Vec<RepairPlanItem>,
+}
+
+fn agent_control(context: &TaskStatusContext) -> AgentControl {
+    AgentControl {
+        next_action: next_action_v2(
+            &context.state,
+            &context.proof,
+            &context.findings,
+            &context.recommended_commands,
+            &context.scope,
+        ),
+        loop_state: agent_loop(
+            &context.state,
+            &context.proof,
+            &context.findings,
+            &context.scope,
+        ),
+        repair_plan: repair_plan(
+            &context.proof,
+            &context.findings,
+            &context.recommended_commands,
+            &context.scope,
+        ),
+    }
+}
+
+fn proof_plan_next_action(context: &TaskStatusContext) -> String {
+    if !context.proof.missing_checks.is_empty() || !context.proof.stale_checks.is_empty() {
+        if context.recommended_commands.is_empty() {
+            "Recover verification metadata or run the missing/stale checks manually, then record the proof in task-state.".to_string()
+        } else {
+            "Run the recommended missing or stale checks, then record the proof in task-state."
+                .to_string()
+        }
+    } else {
+        "Proof evidence is current for the active task.".to_string()
+    }
+}

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

@@ -0,0 +1,148 @@
+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>,
+    pub(super) human_review_pending: bool,
+    pub(super) blocker_present: bool,
+}
+
+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(root, 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,
+            human_review_pending: human_review_pending(active_task),
+            blocker_present: task_state
+                .and_then(|state| state.get("blocker"))
+                .is_some_and(|blocker| !blocker.is_null()),
+        })
+    }
+}
+
+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 human_review_pending(active_task: Option<&Value>) -> bool {
+    active_task
+        .and_then(|task| task.get("humanReview"))
+        .and_then(Value::as_object)
+        .is_some_and(|review| {
+            review
+                .get("required")
+                .and_then(Value::as_bool)
+                .unwrap_or(false)
+                && !review
+                    .get("approved")
+                    .and_then(Value::as_bool)
+                    .unwrap_or(false)
+        })
+}
+
+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,101 @@
+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,
+        context.human_review_pending,
+        context.blocker_present,
+    );
+    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,
+    human_review_pending: bool,
+    blocker_present: bool,
+) -> 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 human_review_pending {
+        blockers.push(finding(
+            "task.transition.human_review_required",
+            "error",
+            "Task requires human review approval before completion.",
+            Some(".naome/task-state.json".to_string()),
+            "Wait for explicit human review approval before completing the task.",
+            "Do not complete a task while humanReview.required is true and approved is false.",
+        ));
+    }
+    if blocker_present && !matches!(state, "blocked" | "needs_human_review") {
+        blockers.push(finding(
+            "task.transition.blocker_present",
+            "error",
+            "Task-state has a blocker object that must be resolved before completion.",
+            Some(".naome/task-state.json".to_string()),
+            "Resolve or clear the blocker through an existing safe task-state path before completing.",
+            "Do not complete a task while .naome/task-state.json blocker is still present.",
+        ));
+    }
+    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};