@lamentis/naome 1.4.0 → 1.4.2

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.4.0"
+version = "1.4.2"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -68,8 +68,13 @@ pub use task_ledger::{
     TaskLedgerProjection, TaskLedgerStatus,
 };
 pub use task_state::{
-    completed_task_commit_paths, validate_task_state, TaskStateMode, TaskStateOptions,
-    TaskStateReport,
+    completed_task_commit_paths, format_task_proof_plan, format_task_status,
+    task_evidence_fingerprint, task_proof_plan, task_status_exit_code, task_status_report,
+    task_transition_readiness, validate_task_state, AgentLoop, NextActionV2, PolicyHints,
+    ProofRecording, ProofRecordingAfterSuccess, RecoveryGuidance, RepairPlanItem, TaskFeedback,
+    TaskGitStatus, TaskModeStatus, TaskProofPlanReport, TaskProofStatus, TaskRecommendedCommand,
+    TaskScopeStatus, TaskStateMode, TaskStateOptions, TaskStateReport, TaskStatusFinding,
+    TaskStatusReportV1, TransitionReadinessReport,
 };
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;

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

@@ -0,0 +1,47 @@
+use std::fs;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+pub fn task_evidence_fingerprint(root: &Path, paths: &[String]) -> Result<String, NaomeError> {
+    let mut paths = paths.to_vec();
+    paths.sort();
+    let mut hash = Fnv64::new();
+    for path in paths {
+        hash.update(path.as_bytes());
+        hash.update(b"\0");
+        match fs::read(root.join(&path)) {
+            Ok(content) => {
+                hash.update(b"file:");
+                hash.update(content.len().to_string().as_bytes());
+                hash.update(b":");
+                hash.update(&content);
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+                hash.update(b"missing");
+            }
+            Err(error) => return Err(NaomeError::from(error)),
+        }
+        hash.update(b"\0");
+    }
+    Ok(format!("fnv64:{:016x}", hash.finish()))
+}
+
+struct Fnv64(u64);
+
+impl Fnv64 {
+    fn new() -> Self {
+        Self(0xcbf29ce484222325)
+    }
+
+    fn update(&mut self, bytes: &[u8]) {
+        for byte in bytes {
+            self.0 ^= u64::from(*byte);
+            self.0 = self.0.wrapping_mul(0x100000001b3);
+        }
+    }
+
+    fn finish(self) -> u64 {
+        self.0
+    }
+}

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

@@ -8,6 +8,7 @@ mod completion;
 mod deleted_paths;
 mod diff;
 mod evidence;
+mod evidence_fingerprint;
 mod git_io;
 mod git_parse;
 mod git_refs;
@@ -22,6 +23,8 @@ mod proof_types;
 mod push_gate;
 mod repair;
 mod shape;
+mod status;
+mod status_output;
 mod task_diff_api;
 mod task_records;
 mod task_references;
@@ -30,7 +33,16 @@ mod util;
 
 pub use api::validate_task_state;
 pub use completed_refresh::completed_task_harness_refresh_diff;
+pub use evidence_fingerprint::task_evidence_fingerprint;
 pub(crate) use proof_model::{canonical_proof_check_ids, canonical_proofs};
+pub use status::{
+    task_proof_plan, task_status_exit_code, task_status_report, task_transition_readiness,
+    AgentLoop, NextActionV2, PolicyHints, ProofRecording, ProofRecordingAfterSuccess,
+    RecoveryGuidance, RepairPlanItem, TaskFeedback, TaskGitStatus, TaskModeStatus,
+    TaskProofPlanReport, TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus,
+    TaskStatusFinding, TaskStatusReportV1, TransitionReadinessReport,
+};
+pub use status_output::{format_task_proof_plan, format_task_status};
 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/status/agent_model.rs

@@ -0,0 +1,76 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NextActionV2 {
+    #[serde(rename = "type")]
+    pub action_type: String,
+    pub reason: String,
+    pub check_ids: Vec<String>,
+    pub commands: Vec<String>,
+    pub paths: Vec<String>,
+    pub safe_to_execute: bool,
+    pub requires_user_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentLoop {
+    pub state: String,
+    pub can_continue_editing: bool,
+    pub can_run_checks: bool,
+    pub can_record_proof: bool,
+    pub can_commit: bool,
+    pub must_do_next: Vec<String>,
+    pub must_not_do: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RepairPlanItem {
+    pub id: String,
+    pub kind: String,
+    pub reason: String,
+    pub paths: Vec<String>,
+    pub check_ids: Vec<String>,
+    pub commands: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+    pub safe_to_execute: bool,
+    pub requires_user_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofRecording {
+    pub path_set_id: String,
+    pub paths: Vec<String>,
+    pub proof_batch_id: String,
+    pub checks_to_record: Vec<String>,
+    pub after_success: ProofRecordingAfterSuccess,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofRecordingAfterSuccess {
+    pub record_proof: bool,
+    pub instructions: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct PolicyHints {
+    pub may_edit: Vec<String>,
+    pub must_inspect_before_edit: Vec<String>,
+    pub must_run_after_edit: Vec<String>,
+    pub forbidden_actions: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecoveryGuidance {
+    pub id: String,
+    pub reason: String,
+    pub safe_next_action: String,
+    pub requires_user_approval: bool,
+}

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

@@ -0,0 +1,87 @@
+use super::super::agent_model::NextActionV2;
+use super::super::model::{
+    TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus, TaskStatusFinding,
+};
+use super::shared::{action_check_ids, has_finding, has_git_recovery};
+
+pub(in crate::task_state::status) fn next_action_v2(
+    state: &str,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+    commands: &[TaskRecommendedCommand],
+    scope: &TaskScopeStatus,
+) -> NextActionV2 {
+    let (action_type, reason, paths, safe) = prioritized_action(state, proof, findings, scope);
+    NextActionV2 {
+        action_type: action_type.to_string(),
+        reason,
+        check_ids: action_check_ids(proof),
+        commands: commands
+            .iter()
+            .map(|command| command.command.clone())
+            .collect(),
+        paths,
+        safe_to_execute: safe,
+        requires_user_approval: !safe,
+    }
+}
+
+fn prioritized_action(
+    state: &str,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+    scope: &TaskScopeStatus,
+) -> (&'static str, String, Vec<String>, bool) {
+    if has_finding(findings, "task.state.conflict_markers") {
+        return (
+            "blocked",
+            "Task-state conflict markers must be resolved.".to_string(),
+            vec![],
+            false,
+        );
+    }
+    if has_git_recovery(findings) {
+        return (
+            "recover_git_state",
+            "Git recovery is required before task work can continue.".to_string(),
+            vec![],
+            false,
+        );
+    }
+    if has_finding(findings, "task.scope.out_of_scope_change") {
+        return (
+            "repair_scope",
+            "Out-of-scope changes must be removed or admitted.".to_string(),
+            scope.out_of_scope_changed_paths.clone(),
+            true,
+        );
+    }
+    if !proof.missing_checks.is_empty() || !proof.stale_checks.is_empty() {
+        return (
+            "rerun_checks",
+            "Required proof is missing or stale.".to_string(),
+            scope.in_scope_changed_paths.clone(),
+            true,
+        );
+    }
+    match state {
+        "idle" | "missing" => (
+            "create_task",
+            "No active task is in progress.".to_string(),
+            vec![],
+            true,
+        ),
+        "complete" => (
+            "none",
+            "Task is complete and proof is current.".to_string(),
+            vec![],
+            true,
+        ),
+        _ => (
+            "continue_editing",
+            "Active task is healthy.".to_string(),
+            scope.in_scope_changed_paths.clone(),
+            true,
+        ),
+    }
+}

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

@@ -0,0 +1,32 @@
+use super::super::model::{TaskProofStatus, TaskStatusFinding};
+use super::shared::has_finding;
+
+pub fn task_status_exit_code(findings: &[TaskStatusFinding], proof: &TaskProofStatus) -> i32 {
+    if has_finding(findings, "task.state.conflict_markers")
+        || has_finding(findings, "task.state.invalid_json")
+        || has_finding(findings, "task.state.active_task_missing")
+    {
+        40
+    } else if findings.iter().any(|finding| {
+        matches!(
+            finding.id.as_str(),
+            "task.git.operation_in_progress"
+                | "task.git.admission_head_missing"
+                | "task.git.admission_head_not_reachable"
+        )
+    }) {
+        30
+    } else if has_finding(findings, "task.scope.out_of_scope_change") {
+        20
+    } else if has_finding(findings, "task.state.no_active_task_with_diff") {
+        50
+    } else if has_finding(findings, "task.state.completed_task_has_diff") {
+        60
+    } else if !proof.missing_checks.is_empty() {
+        10
+    } else if !proof.stale_checks.is_empty() {
+        11
+    } else {
+        0
+    }
+}

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

@@ -0,0 +1,70 @@
+use super::super::agent_model::AgentLoop;
+use super::super::model::{TaskProofStatus, TaskScopeStatus, TaskStatusFinding};
+use super::shared::{action_check_ids, has_finding, has_git_recovery};
+
+pub(in crate::task_state::status) fn agent_loop(
+    state: &str,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+    scope: &TaskScopeStatus,
+) -> AgentLoop {
+    let loop_state = agent_loop_state(state, proof, findings, scope);
+    AgentLoop {
+        can_continue_editing: matches!(loop_state.as_str(), "healthy" | "ready_to_commit"),
+        can_run_checks: !matches!(
+            loop_state.as_str(),
+            "blocked_by_scope_drift" | "blocked_by_git_state" | "blocked_by_task_state"
+        ),
+        can_record_proof: matches!(
+            loop_state.as_str(),
+            "blocked_by_missing_proof" | "blocked_by_stale_proof" | "ready_to_commit"
+        ),
+        can_commit: loop_state == "ready_to_commit",
+        must_do_next: must_do_next(&loop_state, proof),
+        must_not_do: must_not_do(&loop_state),
+        state: loop_state,
+    }
+}
+
+fn agent_loop_state(
+    state: &str,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+    scope: &TaskScopeStatus,
+) -> String {
+    if has_finding(findings, "task.state.conflict_markers") {
+        "blocked_by_task_state"
+    } else if has_git_recovery(findings) {
+        "blocked_by_git_state"
+    } else if has_finding(findings, "task.scope.out_of_scope_change") {
+        "blocked_by_scope_drift"
+    } else if has_finding(findings, "task.state.no_active_task_with_diff") {
+        "blocked_by_task_state"
+    } else if !proof.missing_checks.is_empty() {
+        "blocked_by_missing_proof"
+    } else if !proof.stale_checks.is_empty() {
+        "blocked_by_stale_proof"
+    } else if matches!(state, "idle" | "missing") {
+        "ready_for_new_task"
+    } else if state == "complete" || !scope.in_scope_changed_paths.is_empty() {
+        "ready_to_commit"
+    } else {
+        "healthy"
+    }
+    .to_string()
+}
+
+fn must_do_next(state: &str, proof: &TaskProofStatus) -> Vec<String> {
+    match state {
+        "blocked_by_missing_proof" | "blocked_by_stale_proof" => action_check_ids(proof),
+        value => vec![value.to_string()],
+    }
+}
+
+fn must_not_do(state: &str) -> Vec<String> {
+    let mut items = vec!["Do not bypass the NAOME commit gate.".to_string()];
+    if state != "ready_to_commit" {
+        items.push("Do not commit until task can-transition allows completion.".to_string());
+    }
+    items
+}

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

@@ -0,0 +1,31 @@
+use super::super::agent_model::PolicyHints;
+use super::super::model::{TaskProofStatus, TaskScopeStatus, TaskStatusFinding};
+use super::shared::action_check_ids;
+
+pub(in crate::task_state::status) fn policy_hints(
+    scope: &TaskScopeStatus,
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+) -> PolicyHints {
+    let may_edit = if scope.in_scope_changed_paths.is_empty() {
+        scope.allowed_paths.clone()
+    } else {
+        scope.in_scope_changed_paths.clone()
+    };
+    let mut forbidden_actions = vec![
+        "Do not bypass the NAOME commit gate.".to_string(),
+        "Do not commit before can-transition or can-commit allows it.".to_string(),
+    ];
+    if findings
+        .iter()
+        .any(|finding| finding.id == "task.scope.out_of_scope_change")
+    {
+        forbidden_actions.push("Do not keep out-of-scope changes in the task diff.".to_string());
+    }
+    PolicyHints {
+        may_edit,
+        must_inspect_before_edit: scope.out_of_scope_changed_paths.clone(),
+        must_run_after_edit: action_check_ids(proof),
+        forbidden_actions,
+    }
+}

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

@@ -0,0 +1,25 @@
+use super::super::agent_model::{ProofRecording, ProofRecordingAfterSuccess};
+use super::super::model::{TaskProofStatus, TaskScopeStatus};
+use super::shared::action_check_ids;
+
+pub(in crate::task_state::status) fn proof_recording(
+    task_id: Option<&str>,
+    scope: &TaskScopeStatus,
+    proof: &TaskProofStatus,
+) -> ProofRecording {
+    let checks_to_record = action_check_ids(proof);
+    let proof_batch_id = format!(
+        "{}-proof",
+        task_id.unwrap_or("current-task").replace('_', "-")
+    );
+    ProofRecording {
+        path_set_id: "current-task-diff".to_string(),
+        paths: scope.in_scope_changed_paths.clone(),
+        proof_batch_id,
+        checks_to_record: checks_to_record.clone(),
+        after_success: ProofRecordingAfterSuccess {
+            record_proof: !checks_to_record.is_empty(),
+            instructions: "After each command exits 0, record one proof batch using pathSetId current-task-diff and the listed in-scope paths.".to_string(),
+        },
+    }
+}

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

@@ -0,0 +1,19 @@
+use super::super::agent_model::RecoveryGuidance;
+use super::super::model::TaskStatusFinding;
+
+pub(in crate::task_state::status) fn recovery_guidance(
+    findings: &[TaskStatusFinding],
+) -> Vec<RecoveryGuidance> {
+    findings
+        .iter()
+        .filter(|finding| {
+            finding.id.starts_with("task.git.") || finding.id == "task.state.conflict_markers"
+        })
+        .map(|finding| RecoveryGuidance {
+            id: finding.id.clone(),
+            reason: finding.message.clone(),
+            safe_next_action: finding.suggested_fix.clone(),
+            requires_user_approval: true,
+        })
+        .collect()
+}

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

@@ -0,0 +1,125 @@
+use super::super::agent_model::RepairPlanItem;
+use super::super::model::{
+    TaskProofStatus, TaskRecommendedCommand, TaskScopeStatus, TaskStatusFinding,
+};
+use super::shared::action_check_ids;
+
+pub(in crate::task_state::status) fn repair_plan(
+    proof: &TaskProofStatus,
+    findings: &[TaskStatusFinding],
+    commands: &[TaskRecommendedCommand],
+    scope: &TaskScopeStatus,
+) -> Vec<RepairPlanItem> {
+    let mut items = Vec::new();
+    items.extend(scope_repairs(findings));
+    items.extend(git_repairs(findings));
+    items.extend(check_repairs(commands));
+    if !proof.missing_checks.is_empty() || !proof.stale_checks.is_empty() {
+        items.push(RepairPlanItem {
+            id: "record_current_task_proof".to_string(),
+            kind: "record_proof".to_string(),
+            reason: "Record successful missing or stale checks against the current task diff."
+                .to_string(),
+            paths: scope.in_scope_changed_paths.clone(),
+            check_ids: action_check_ids(proof),
+            commands: Vec::new(),
+            cwd: None,
+            safe_to_execute: true,
+            requires_user_approval: false,
+        });
+    }
+    items
+}
+
+fn check_repairs(commands: &[TaskRecommendedCommand]) -> Vec<RepairPlanItem> {
+    commands
+        .iter()
+        .map(|command| RepairPlanItem {
+            id: format!("rerun_{}", command.check_id),
+            kind: "rerun_check".to_string(),
+            reason: command.reason.clone(),
+            paths: Vec::new(),
+            check_ids: vec![command.check_id.clone()],
+            commands: vec![command.command.clone()],
+            cwd: Some(command.cwd.clone()),
+            safe_to_execute: command.safe_to_execute,
+            requires_user_approval: !command.safe_to_execute,
+        })
+        .collect()
+}
+
+fn scope_repairs(findings: &[TaskStatusFinding]) -> Vec<RepairPlanItem> {
+    findings
+        .iter()
+        .filter(|finding| finding.id == "task.scope.out_of_scope_change")
+        .filter_map(|finding| {
+            let path = finding.path.clone()?;
+            Some(RepairPlanItem {
+                id: format!("remove_out_of_scope_change_{}", repair_path_slug(&path)),
+                kind: "git_revert_path".to_string(),
+                reason: finding.message.clone(),
+                paths: vec![path],
+                check_ids: Vec::new(),
+                commands: Vec::new(),
+                cwd: None,
+                safe_to_execute: true,
+                requires_user_approval: false,
+            })
+        })
+        .collect()
+}
+
+fn git_repairs(findings: &[TaskStatusFinding]) -> Vec<RepairPlanItem> {
+    findings
+        .iter()
+        .filter(|finding| {
+            matches!(
+                finding.id.as_str(),
+                "task.git.operation_in_progress"
+                    | "task.git.admission_head_missing"
+                    | "task.git.admission_head_not_reachable"
+            )
+        })
+        .map(|finding| RepairPlanItem {
+            id: if finding.id == "task.git.operation_in_progress" {
+                "finish_git_operation"
+            } else {
+                "restart_task"
+            }
+            .to_string(),
+            kind: if finding.id == "task.git.operation_in_progress" {
+                "finish_git_operation"
+            } else {
+                "restart_task"
+            }
+            .to_string(),
+            reason: finding.message.clone(),
+            paths: Vec::new(),
+            check_ids: Vec::new(),
+            commands: Vec::new(),
+            cwd: None,
+            safe_to_execute: false,
+            requires_user_approval: true,
+        })
+        .collect()
+}
+
+fn repair_path_slug(path: &str) -> String {
+    let slug = path
+        .chars()
+        .map(|character| {
+            if character.is_ascii_alphanumeric() {
+                character.to_ascii_lowercase()
+            } else {
+                '_'
+            }
+        })
+        .collect::<String>()
+        .trim_matches('_')
+        .to_string();
+    if slug.is_empty() {
+        "path".to_string()
+    } else {
+        slug
+    }
+}

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

@@ -0,0 +1,25 @@
+use super::super::model::{TaskProofStatus, TaskStatusFinding};
+
+pub(super) fn action_check_ids(proof: &TaskProofStatus) -> Vec<String> {
+    proof
+        .missing_checks
+        .iter()
+        .chain(proof.stale_checks.iter())
+        .cloned()
+        .collect()
+}
+
+pub(super) fn has_finding(findings: &[TaskStatusFinding], id: &str) -> bool {
+    findings.iter().any(|finding| finding.id == id)
+}
+
+pub(super) fn has_git_recovery(findings: &[TaskStatusFinding]) -> bool {
+    findings.iter().any(|finding| {
+        matches!(
+            finding.id.as_str(),
+            "task.git.operation_in_progress"
+                | "task.git.admission_head_missing"
+                | "task.git.admission_head_not_reachable"
+        )
+    })
+}

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

@@ -0,0 +1,16 @@
+mod action;
+mod exit_code;
+mod loop_state;
+mod policy;
+mod proof_recording;
+mod recovery;
+mod repair;
+mod shared;
+
+pub(in crate::task_state::status) use action::next_action_v2;
+pub use exit_code::task_status_exit_code;
+pub(in crate::task_state::status) use loop_state::agent_loop;
+pub(in crate::task_state::status) use policy::policy_hints;
+pub(in crate::task_state::status) use proof_recording::proof_recording;
+pub(in crate::task_state::status) use recovery::recovery_guidance;
+pub(in crate::task_state::status) use repair::repair_plan;