@lamentis/naome 1.4.0 → 1.4.1

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

@@ -0,0 +1,150 @@
+use serde::{Deserialize, Serialize};
+
+use super::agent_model::{
+    AgentLoop, NextActionV2, PolicyHints, ProofRecording, RecoveryGuidance, RepairPlanItem,
+};
+
+pub(super) const STATUS_SCHEMA: &str = "naome.task.status.v1";
+pub(super) const PROOF_PLAN_SCHEMA: &str = "naome.task.proof-plan.v1";
+pub(super) const TASK_STATE_PATH: &str = ".naome/task-state.json";
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskStatusReportV1 {
+    pub schema: String,
+    pub state: String,
+    pub task_id: Option<String>,
+    pub request: Option<String>,
+    pub task_mode: TaskModeStatus,
+    pub git: TaskGitStatus,
+    pub scope: TaskScopeStatus,
+    pub proof: TaskProofStatus,
+    pub blocked: bool,
+    pub findings: Vec<TaskStatusFinding>,
+    pub next_action: String,
+    pub next_action_v2: NextActionV2,
+    pub agent_loop: AgentLoop,
+    pub repair_plan: Vec<RepairPlanItem>,
+    pub policy_hints: PolicyHints,
+    pub recovery_guidance: Vec<RecoveryGuidance>,
+    pub task_feedback: Vec<TaskFeedback>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskProofPlanReport {
+    pub schema: String,
+    pub state: String,
+    pub task_id: Option<String>,
+    pub task_mode: TaskModeStatus,
+    pub proof: TaskProofStatus,
+    pub recommended_commands: Vec<TaskRecommendedCommand>,
+    pub blocked: bool,
+    pub findings: Vec<TaskStatusFinding>,
+    pub next_action: String,
+    pub next_action_v2: NextActionV2,
+    pub agent_loop: AgentLoop,
+    pub repair_plan: Vec<RepairPlanItem>,
+    pub proof_recording: ProofRecording,
+    pub policy_hints: PolicyHints,
+    pub recovery_guidance: Vec<RecoveryGuidance>,
+    pub task_feedback: Vec<TaskFeedback>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TransitionReadinessReport {
+    pub schema: String,
+    pub target_state: String,
+    pub allowed: bool,
+    pub blocking_findings: Vec<TaskStatusFinding>,
+    pub required_before_transition: Vec<String>,
+    pub agent_loop: AgentLoop,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskGitStatus {
+    pub head: Option<String>,
+    pub admission_head: Option<String>,
+    pub admission_head_reachable: bool,
+    pub upstream: Option<String>,
+    pub ahead: usize,
+    pub behind: usize,
+    pub operation_in_progress: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskModeStatus {
+    pub kind: String,
+    pub review_fix: bool,
+    pub scope_policy: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskScopeStatus {
+    pub allowed_paths: Vec<String>,
+    pub changed_paths: Vec<String>,
+    pub in_scope_changed_paths: Vec<String>,
+    pub out_of_scope_changed_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskProofStatus {
+    pub required_checks: Vec<String>,
+    pub passed_checks: Vec<String>,
+    pub missing_checks: Vec<String>,
+    pub stale_checks: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskStatusFinding {
+    pub id: String,
+    pub severity: String,
+    pub message: String,
+    pub path: Option<String>,
+    pub suggested_fix: String,
+    pub agent_instruction: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskFeedback {
+    pub problem: String,
+    pub repair: String,
+    pub files: Vec<String>,
+    pub must_not_do: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskRecommendedCommand {
+    pub check_id: String,
+    pub command: String,
+    pub cwd: String,
+    pub reason: String,
+    pub selection_reason: String,
+    pub impacted_paths: Vec<String>,
+}
+
+pub(super) fn finding(
+    id: &str,
+    severity: &str,
+    message: impl Into<String>,
+    path: Option<String>,
+    suggested_fix: &str,
+    agent_instruction: &str,
+) -> TaskStatusFinding {
+    TaskStatusFinding {
+        id: id.to_string(),
+        severity: severity.to_string(),
+        message: message.into(),
+        path,
+        suggested_fix: suggested_fix.to_string(),
+        agent_instruction: agent_instruction.to_string(),
+    }
+}

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

@@ -0,0 +1,167 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde_json::Value;
+
+use crate::task_state::util::string_array;
+
+use super::model::{finding, TaskProofStatus, TaskRecommendedCommand, TaskStatusFinding};
+use super::proof_read::{ProofRecord, VerificationCheck};
+
+pub(super) fn proof_status(
+    active_task: Option<&Value>,
+    proofs: &[ProofRecord],
+    current_task_paths: &[String],
+) -> TaskProofStatus {
+    let required_checks = active_task
+        .and_then(|task| string_array(task.get("requiredCheckIds")))
+        .unwrap_or_default();
+    let mut passed_checks = Vec::new();
+    let mut missing_checks = Vec::new();
+    let mut stale_checks = Vec::new();
+
+    for check_id in &required_checks {
+        let successful = proofs
+            .iter()
+            .filter(|proof| proof.check_id == *check_id && proof.exit_code == 0)
+            .collect::<Vec<_>>();
+        if successful.is_empty() {
+            missing_checks.push(check_id.clone());
+        } else if successful
+            .iter()
+            .any(|proof| evidence_covers(&proof.evidence_paths, current_task_paths))
+        {
+            passed_checks.push(check_id.clone());
+        } else {
+            stale_checks.push(check_id.clone());
+        }
+    }
+
+    TaskProofStatus {
+        required_checks,
+        passed_checks,
+        missing_checks,
+        stale_checks,
+    }
+}
+
+pub(super) fn add_proof_findings(
+    proof: &TaskProofStatus,
+    current_task_paths: &[String],
+    proofs: &[ProofRecord],
+    findings: &mut Vec<TaskStatusFinding>,
+) {
+    for check_id in &proof.missing_checks {
+        findings.push(finding(
+            "task.proof.missing_check",
+            "error",
+            format!("Required check has no passing proof: {check_id}."),
+            None,
+            "Run the required check and record passing proof before completing the task.",
+            "Do not mark a task complete while required checks are missing.",
+        ));
+    }
+
+    for check_id in &proof.stale_checks {
+        let files = stale_files_for_check(check_id, current_task_paths, proofs);
+        if files.is_empty() {
+            findings.push(finding(
+                "task.scope.missing_evidence",
+                "warning",
+                format!("Proof evidence is stale for required check: {check_id}."),
+                None,
+                "Rerun the check and record evidence for the current task-owned diff.",
+                "Do not reuse stale proof for new changed files.",
+            ));
+        }
+        for file in files {
+            findings.push(finding(
+                "task.scope.missing_evidence",
+                "warning",
+                format!("Proof evidence for {check_id} does not cover changed file: {file}."),
+                Some(file),
+                "Rerun the check and record evidence for the current task-owned diff.",
+                "Do not reuse stale proof for new changed files.",
+            ));
+        }
+    }
+}
+
+pub(super) fn add_unknown_proof_findings(
+    proofs: &[ProofRecord],
+    verification: &BTreeMap<String, VerificationCheck>,
+    findings: &mut Vec<TaskStatusFinding>,
+) {
+    let mut seen = BTreeSet::new();
+    for proof in proofs {
+        if verification.contains_key(&proof.check_id) || !seen.insert(proof.check_id.clone()) {
+            continue;
+        }
+        findings.push(finding(
+            "task.proof.unknown_check_metadata",
+            "info",
+            format!(
+                "Proof references a check not present in .naome/verification.json: {}.",
+                proof.check_id
+            ),
+            None,
+            "Keep the proof readable; add verification metadata if agents should recommend it.",
+            "Treat unknown check metadata as advisory, not as proof failure by itself.",
+        ));
+    }
+}
+
+pub(super) fn recommended_commands(
+    proof: &TaskProofStatus,
+    verification: &BTreeMap<String, VerificationCheck>,
+    current_task_paths: &[String],
+) -> Vec<TaskRecommendedCommand> {
+    let check_ids = proof
+        .missing_checks
+        .iter()
+        .chain(proof.stale_checks.iter())
+        .cloned()
+        .collect::<BTreeSet<_>>();
+    check_ids
+        .iter()
+        .filter_map(|check_id| {
+            let check = verification.get(check_id)?;
+            Some(TaskRecommendedCommand {
+                check_id: check_id.clone(),
+                command: check.command.clone(),
+                cwd: check.cwd.clone(),
+                reason: if proof.stale_checks.contains(check_id) {
+                    "stale-proof".to_string()
+                } else {
+                    "missing-proof".to_string()
+                },
+                selection_reason: "Required by active task proof state.".to_string(),
+                impacted_paths: current_task_paths.to_vec(),
+            })
+        })
+        .collect()
+}
+
+fn evidence_covers(evidence_paths: &[String], current_paths: &[String]) -> bool {
+    current_paths
+        .iter()
+        .all(|path| evidence_paths.iter().any(|evidence| evidence == path))
+}
+
+fn stale_files_for_check(
+    check_id: &str,
+    current_task_paths: &[String],
+    proofs: &[ProofRecord],
+) -> Vec<String> {
+    let mut covered = BTreeSet::new();
+    for proof in proofs
+        .iter()
+        .filter(|proof| proof.check_id == check_id && proof.exit_code == 0)
+    {
+        covered.extend(proof.evidence_paths.iter().cloned());
+    }
+    current_task_paths
+        .iter()
+        .filter(|path| !covered.contains(*path))
+        .cloned()
+        .collect()
+}

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()
+    }
+}