@lamentis/naome 1.4.0 → 1.4.1

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: true,
+            requires_user_approval: false,
+        })
+        .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;

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

@@ -0,0 +1,133 @@
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::NaomeError;
+
+use super::model::{finding, TaskGitStatus, TaskStatusFinding};
+use crate::task_state::git_io::{command_output, git_commit_exists, read_git_head};
+
+pub(super) fn git_status(
+    root: &Path,
+    admission_head: Option<String>,
+    findings: &mut Vec<TaskStatusFinding>,
+) -> Result<TaskGitStatus, NaomeError> {
+    let head = read_git_head(root)?;
+    let mut admission_head_reachable = false;
+    if let Some(admission_head) = admission_head.as_deref() {
+        if !git_commit_exists(root, admission_head)? {
+            findings.push(finding(
+                "task.git.admission_head_missing",
+                "error",
+                format!("Admission git head does not exist: {admission_head}."),
+                None,
+                "Recover the task-state from a reachable baseline or restart the task after sync.",
+                "Do not continue normal task work until the admission head is reachable.",
+            ));
+        } else if !is_ancestor(root, admission_head, "HEAD")? {
+            findings.push(finding(
+                "task.git.admission_head_not_reachable",
+                "error",
+                "Admission git head is not an ancestor of the current HEAD.",
+                None,
+                "Rebase or recreate the task-state against the current branch before continuing.",
+                "Do not commit task work against a branch that lost its admission baseline.",
+            ));
+        } else {
+            admission_head_reachable = true;
+        }
+    }
+
+    let (upstream, ahead, behind) = branch_divergence(root)?;
+    if upstream.is_some() && ahead > 0 && behind > 0 {
+        findings.push(finding(
+            "task.git.branch_diverged",
+            "warning",
+            format!("Current branch diverged from upstream ({ahead} ahead, {behind} behind)."),
+            None,
+            "Pull with rebase or coordinate the branch before recording final task proof.",
+            "Do not ignore branch divergence when interpreting task proof.",
+        ));
+    }
+
+    let operation_in_progress = operation_in_progress(root)?;
+    if let Some(operation) = &operation_in_progress {
+        findings.push(finding(
+            "task.git.operation_in_progress",
+            "error",
+            format!("Git operation in progress: {operation}."),
+            None,
+            "Finish or abort the git operation, then rerun naome task status.",
+            "Do not commit or mutate task-state while a git operation is unresolved.",
+        ));
+    }
+
+    Ok(TaskGitStatus {
+        head,
+        admission_head,
+        admission_head_reachable,
+        upstream,
+        ahead,
+        behind,
+        operation_in_progress,
+    })
+}
+
+fn is_ancestor(root: &Path, ancestor: &str, descendant: &str) -> Result<bool, NaomeError> {
+    Ok(Command::new("git")
+        .args(["merge-base", "--is-ancestor", ancestor, descendant])
+        .current_dir(root)
+        .status()?
+        .success())
+}
+
+fn branch_divergence(root: &Path) -> Result<(Option<String>, usize, usize), NaomeError> {
+    let upstream = Command::new("git")
+        .args(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])
+        .current_dir(root)
+        .output()?;
+    if !upstream.status.success() {
+        return Ok((None, 0, 0));
+    }
+    let upstream_name = command_output(&upstream);
+    let counts = Command::new("git")
+        .args(["rev-list", "--left-right", "--count", "HEAD...@{u}"])
+        .current_dir(root)
+        .output()?;
+    if !counts.status.success() {
+        return Ok((Some(upstream_name), 0, 0));
+    }
+    let text = String::from_utf8_lossy(&counts.stdout);
+    let mut parts = text.split_whitespace();
+    let ahead = parts
+        .next()
+        .and_then(|value| value.parse::<usize>().ok())
+        .unwrap_or(0);
+    let behind = parts
+        .next()
+        .and_then(|value| value.parse::<usize>().ok())
+        .unwrap_or(0);
+    Ok((Some(upstream_name), ahead, behind))
+}
+
+fn operation_in_progress(root: &Path) -> Result<Option<String>, NaomeError> {
+    for (name, marker) in [
+        ("merge", "MERGE_HEAD"),
+        ("cherry-pick", "CHERRY_PICK_HEAD"),
+        ("revert", "REVERT_HEAD"),
+        ("rebase", "rebase-merge"),
+        ("rebase", "rebase-apply"),
+    ] {
+        let output = Command::new("git")
+            .args(["rev-parse", "--git-path", marker])
+            .current_dir(root)
+            .output()?;
+        if !output.status.success() {
+            continue;
+        }
+        let path = root.join(String::from_utf8_lossy(&output.stdout).trim());
+        if path.exists() {
+            return Ok(Some(name.to_string()));
+        }
+    }
+    Ok(None)
+}