@lamentis/naome 1.3.17 → 1.4.1

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

@@ -0,0 +1,150 @@
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+use crate::task_state::evidence::evidence_entry_path;
+use crate::task_state::util::normalize_path;
+
+use super::model::{finding, TaskStatusFinding};
+
+#[derive(Debug, Clone)]
+pub(super) struct ProofRecord {
+    pub(super) check_id: String,
+    pub(super) exit_code: i64,
+    pub(super) evidence_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct VerificationCheck {
+    pub(super) command: String,
+    pub(super) cwd: String,
+}
+
+pub(super) fn read_proofs(active_task: &Value) -> Vec<ProofRecord> {
+    let path_sets = proof_path_sets(active_task);
+    let mut proofs = Vec::new();
+    if let Some(legacy) = active_task.get("proofResults").and_then(Value::as_array) {
+        proofs.extend(legacy.iter().filter_map(read_legacy_proof));
+    }
+    if let Some(batches) = active_task.get("proofBatches").and_then(Value::as_array) {
+        for batch in batches {
+            let batch_evidence = batch_evidence(batch, &path_sets);
+            let Some(batch_proofs) = batch.get("proofs").and_then(Value::as_array) else {
+                continue;
+            };
+            for proof in batch_proofs {
+                let Some(check_id) = proof.get("checkId").and_then(Value::as_str) else {
+                    continue;
+                };
+                let Some(exit_code) = proof.get("exitCode").and_then(Value::as_i64) else {
+                    continue;
+                };
+                proofs.push(ProofRecord {
+                    check_id: check_id.to_string(),
+                    exit_code,
+                    evidence_paths: compact_evidence_paths(proof, &path_sets)
+                        .unwrap_or_else(|| batch_evidence.clone()),
+                });
+            }
+        }
+    }
+    proofs
+}
+
+pub(super) fn read_verification_checks(
+    root: &Path,
+    findings: &mut Vec<TaskStatusFinding>,
+) -> Result<BTreeMap<String, VerificationCheck>, NaomeError> {
+    let content = match fs::read_to_string(root.join(".naome/verification.json")) {
+        Ok(content) => content,
+        Err(_) => return Ok(BTreeMap::new()),
+    };
+    let verification: Value = match serde_json::from_str(&content) {
+        Ok(value) => value,
+        Err(error) => {
+            findings.push(finding(
+                "task.proof.verification_metadata_unreadable",
+                "warning",
+                format!(".naome/verification.json is not valid JSON: {error}."),
+                Some(".naome/verification.json".to_string()),
+                "Fix verification metadata so proof-plan can recommend commands.",
+                "Do not invent check commands when verification metadata is unreadable.",
+            ));
+            return Ok(BTreeMap::new());
+        }
+    };
+    Ok(verification
+        .get("checks")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|check| {
+            Some((
+                check.get("id")?.as_str()?.to_string(),
+                VerificationCheck {
+                    command: check.get("command")?.as_str()?.to_string(),
+                    cwd: check.get("cwd")?.as_str()?.to_string(),
+                },
+            ))
+        })
+        .collect())
+}
+
+fn batch_evidence(batch: &Value, path_sets: &BTreeMap<String, Vec<String>>) -> Vec<String> {
+    batch
+        .get("evidencePathSet")
+        .and_then(Value::as_str)
+        .and_then(|name| path_sets.get(name))
+        .cloned()
+        .unwrap_or_default()
+}
+
+fn compact_evidence_paths(
+    proof: &Value,
+    path_sets: &BTreeMap<String, Vec<String>>,
+) -> Option<Vec<String>> {
+    proof
+        .get("evidence")
+        .and_then(Value::as_array)
+        .map(|entries| evidence_paths(entries))
+        .or_else(|| {
+            proof
+                .get("evidencePathSet")
+                .and_then(Value::as_str)
+                .and_then(|name| path_sets.get(name))
+                .cloned()
+        })
+}
+
+fn read_legacy_proof(proof: &Value) -> Option<ProofRecord> {
+    Some(ProofRecord {
+        check_id: proof.get("checkId")?.as_str()?.to_string(),
+        exit_code: proof.get("exitCode")?.as_i64()?,
+        evidence_paths: proof
+            .get("evidence")
+            .and_then(Value::as_array)
+            .map(|entries| evidence_paths(entries))
+            .unwrap_or_default(),
+    })
+}
+
+fn proof_path_sets(active_task: &Value) -> BTreeMap<String, Vec<String>> {
+    active_task
+        .get("proofPathSets")
+        .and_then(Value::as_object)
+        .into_iter()
+        .flat_map(|sets| sets.iter())
+        .filter_map(|(name, value)| Some((name.clone(), evidence_paths(value.as_array()?))))
+        .collect()
+}
+
+fn evidence_paths(entries: &[Value]) -> Vec<String> {
+    entries
+        .iter()
+        .filter_map(evidence_entry_path)
+        .map(normalize_path)
+        .collect()
+}

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,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.",
+            ));
+        }
+    }
+}