@lamentis/naome 1.2.0 → 1.2.1

package/crates/naome-core/src/route/context.rs

@@ -0,0 +1,180 @@
+use crate::intent::IntentDecision;
+use crate::models::Decision;
+
+pub(super) fn can_create_task(intent: &IntentDecision, decision: &Decision, execute: bool) -> bool {
+    let creation_intent = matches!(
+        intent.policy_action.as_str(),
+        "create_new_task"
+            | "create_new_task_without_auto_baseline"
+            | "auto_commit_completed_task_then_create_new_task"
+            | "auto_commit_completed_task_then_create_isolated_task_worktree"
+            | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+            | "auto_commit_upgrade_baseline_then_create_new_task"
+            | "create_isolated_task_worktree"
+    );
+    if !creation_intent || decision.state != "ready_for_task" || decision.blocked {
+        return false;
+    }
+
+    execute
+        || matches!(
+            intent.policy_action.as_str(),
+            "create_new_task" | "create_new_task_without_auto_baseline"
+        )
+}
+
+pub(super) fn winning_rule(intent: &IntentDecision) -> String {
+    match intent.policy_action.as_str() {
+        "block_unsafe_intent" => "unsafe_intent_precedence",
+        "block_auto_baseline_due_to_no_commit" => "no_commit_blocks_auto_baseline",
+        "continue_current_task_without_commit" => "no_commit_continues_active_task",
+        "review_task_diff" | "review_diff_first" | "review_current_task_diff" => {
+            "explicit_review_overrides_auto_baseline"
+        }
+        "cancel_task_changes" | "cancel_upgrade_baseline" | "cancel_current_task" => {
+            "explicit_cancel_overrides_auto_baseline"
+        }
+        "auto_commit_completed_task_then_create_new_task" => {
+            "completed_task_valid_new_task_auto_baseline"
+        }
+        "auto_commit_completed_task_then_create_isolated_task_worktree" => {
+            "completed_task_valid_with_unrelated_dirty_worktree"
+        }
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            "completed_task_harness_refresh_split_auto_baseline"
+        }
+        "auto_commit_harness_refresh_then_create_new_task" => {
+            "pure_harness_refresh_new_task_auto_baseline"
+        }
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => {
+            "dirty_repo_harness_refresh_worktree_isolation"
+        }
+        "auto_commit_harness_refresh_baseline" => "dirty_repo_harness_refresh_repair_baseline",
+        "auto_commit_upgrade_baseline_then_create_new_task" => "setup_diff_new_task_auto_baseline",
+        "reopen_completed_task_revision" | "continue_current_task" => {
+            "current_task_revision_continues_task"
+        }
+        "answer_status_only" => "status_request_read_only",
+        "create_new_task" | "create_new_task_without_auto_baseline" => "ready_repo_new_task",
+        "create_isolated_task_worktree" => "dirty_repo_new_task_worktree_isolation",
+        "commit_user_diff_with_quality_gate" => "explicit_user_diff_commit_quality_gate",
+        _ => "fallback_policy",
+    }
+    .to_string()
+}
+
+pub(super) fn discarded_actions(intent: &IntentDecision) -> Vec<String> {
+    let Some(actions_note) = intent
+        .internal_notes
+        .iter()
+        .find(|note| note.starts_with("internal_allowed_actions:"))
+    else {
+        return Vec::new();
+    };
+    let selected = selected_internal_action(&intent.policy_action);
+    actions_note
+        .trim_start_matches("internal_allowed_actions:")
+        .split(',')
+        .filter(|action| !action.is_empty() && Some(*action) != selected.as_deref())
+        .map(ToString::to_string)
+        .collect()
+}
+
+fn selected_internal_action(policy_action: &str) -> Option<String> {
+    match policy_action {
+        "auto_commit_completed_task_then_create_new_task"
+        | "auto_commit_completed_task_then_create_isolated_task_worktree"
+        | "commit_task_baseline" => Some("commit_task_baseline".to_string()),
+        "auto_commit_harness_refresh_then_create_new_task"
+        | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_baseline" => Some("commit_upgrade_baseline".to_string()),
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            Some("commit_task_baseline".to_string())
+        }
+        "auto_commit_upgrade_baseline_then_create_new_task" | "commit_upgrade_baseline" => {
+            Some("commit_upgrade_baseline".to_string())
+        }
+        other if other.starts_with("review_") || other.starts_with("cancel_") => {
+            Some(other.to_string())
+        }
+        _ => None,
+    }
+}
+
+pub(super) fn would_mutate(intent: &IntentDecision) -> bool {
+    matches!(
+        intent.policy_action.as_str(),
+        "auto_commit_completed_task_then_create_new_task"
+            | "auto_commit_completed_task_then_create_isolated_task_worktree"
+            | "auto_commit_upgrade_baseline_then_create_new_task"
+            | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_new_task"
+            | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+            | "auto_commit_harness_refresh_baseline"
+            | "create_isolated_task_worktree"
+            | "commit_task_baseline"
+            | "commit_upgrade_baseline"
+            | "commit_user_diff_with_quality_gate"
+    )
+}
+
+pub(super) fn required_context_for_route(
+    intent: &IntentDecision,
+    decision: &Decision,
+) -> Vec<String> {
+    let mut context = required_context_for_intent(intent);
+    if decision.state == "ready_for_task" {
+        push_unique(&mut context, "docs/naome/agent-workflow.md");
+        push_unique(&mut context, "docs/naome/testing.md");
+        push_unique(&mut context, ".naome/verification.json");
+    }
+    context
+}
+
+pub(super) fn required_context_for_intent(intent: &IntentDecision) -> Vec<String> {
+    let mut context = intent.required_context.clone();
+    match intent.policy_action.as_str() {
+        "create_new_task" | "create_new_task_without_auto_baseline" => {
+            push_unique(&mut context, "docs/naome/agent-workflow.md");
+            push_unique(&mut context, "docs/naome/testing.md");
+            push_unique(&mut context, ".naome/verification.json");
+            push_unique(&mut context, "docs/naome/architecture.md");
+        }
+        "create_isolated_task_worktree" => {
+            push_unique(&mut context, "docs/naome/agent-workflow.md");
+            push_unique(&mut context, "docs/naome/testing.md");
+            push_unique(&mut context, ".naome/verification.json");
+            push_unique(&mut context, "docs/naome/architecture.md");
+        }
+        "auto_commit_completed_task_then_create_new_task"
+        | "auto_commit_completed_task_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_then_create_new_task"
+        | "auto_commit_harness_refresh_then_create_isolated_task_worktree"
+        | "auto_commit_harness_refresh_baseline"
+        | "auto_commit_harness_refresh_then_completed_task_then_create_new_task"
+        | "reopen_completed_task_revision"
+        | "review_task_diff"
+        | "cancel_task_changes"
+        | "block_auto_baseline_due_to_no_commit" => {
+            push_unique(&mut context, "docs/naome/execution.md");
+            push_unique(&mut context, ".naome/task-state.json");
+        }
+        "answer_status_only" => {
+            push_unique(&mut context, "docs/naome/index.md");
+        }
+        "repair_harness_only" => {
+            push_unique(&mut context, ".naome/manifest.json");
+            push_unique(&mut context, "docs/naome/index.md");
+        }
+        _ => {}
+    }
+    context
+}
+
+fn push_unique(context: &mut Vec<String>, value: &str) {
+    if !context.iter().any(|entry| entry == value) {
+        context.push(value.to_string());
+    }
+}

package/crates/naome-core/src/route/execution.rs

@@ -0,0 +1,96 @@
+use std::path::{Path, PathBuf};
+
+use crate::intent::IntentDecision;
+use crate::journal::TaskJournalEntry;
+use crate::models::{Decision, NaomeError};
+
+use super::execution_baselines::{
+    baseline_completed_task, baseline_completed_task_then_worktree, baseline_harness_refresh,
+    baseline_harness_refresh_then_completed_task, baseline_harness_refresh_then_worktree,
+    baseline_pure_harness_refresh, baseline_setup, commit_upgrade_baseline,
+};
+use super::execution_tasks::{
+    commit_user_diff, create_task_worktree, journal_external_baseline_if_needed,
+};
+use super::RouteWorktree;
+
+pub(super) struct RouteExecution {
+    pub(super) mutation_performed: bool,
+    pub(super) executed_actions: Vec<String>,
+    pub(super) journal_entry: Option<TaskJournalEntry>,
+    pub(super) user_message: String,
+    pub(super) task_root: PathBuf,
+    pub(super) worktree: Option<RouteWorktree>,
+    pub(super) route_allowed: bool,
+    pub(super) human_options: Vec<String>,
+}
+
+impl RouteExecution {
+    pub(super) fn from_intent(root: &Path, intent: &IntentDecision) -> Self {
+        Self {
+            mutation_performed: false,
+            executed_actions: Vec::new(),
+            journal_entry: None,
+            user_message: intent.user_message.clone(),
+            task_root: root.to_path_buf(),
+            worktree: None,
+            route_allowed: intent.allowed,
+            human_options: intent.human_options.clone(),
+        }
+    }
+
+    pub(super) fn mark_action(&mut self, action: &str) {
+        self.mutation_performed = true;
+        self.executed_actions.push(action.to_string());
+    }
+}
+
+pub(super) fn execute_route_policy(
+    root: &Path,
+    prompt: &str,
+    initial_decision: &Decision,
+    intent: &IntentDecision,
+    repo_state_before: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    match intent.policy_action.as_str() {
+        "auto_commit_completed_task_then_create_new_task" => baseline_completed_task(
+            root,
+            "route_auto_baseline",
+            "NAOME baselined the completed task and is ready to create the next task.",
+            execution,
+        ),
+        "auto_commit_completed_task_then_create_isolated_task_worktree" => {
+            baseline_completed_task_then_worktree(root, prompt, execution)
+        }
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => {
+            baseline_harness_refresh_then_completed_task(root, execution)
+        }
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => {
+            baseline_harness_refresh_then_worktree(root, prompt, execution)
+        }
+        "auto_commit_harness_refresh_then_create_new_task" => {
+            baseline_pure_harness_refresh(root, execution)
+        }
+        "auto_commit_harness_refresh_baseline" => baseline_harness_refresh(root, execution),
+        "auto_commit_upgrade_baseline_then_create_new_task" => baseline_setup(root, execution),
+        "commit_task_baseline" => baseline_completed_task(
+            root,
+            "naome_commit_baseline",
+            "NAOME baselined the completed task and is ready for the next request.",
+            execution,
+        ),
+        "commit_upgrade_baseline" => commit_upgrade_baseline(root, execution),
+        "create_isolated_task_worktree" => create_task_worktree(root, prompt, execution),
+        "commit_user_diff_with_quality_gate" => commit_user_diff(root, execution),
+        "create_new_task" | "create_new_task_without_auto_baseline" => {
+            journal_external_baseline_if_needed(
+                root,
+                initial_decision,
+                repo_state_before,
+                execution,
+            )
+        }
+        _ => Ok(()),
+    }
+}

package/crates/naome-core/src/route/execution_baselines.rs

@@ -0,0 +1,146 @@
+use std::path::Path;
+
+use crate::models::NaomeError;
+use crate::task_state::{
+    completed_task_harness_refresh_diff, harness_refresh_diff, harness_refresh_with_unrelated_diff,
+};
+
+use super::execution::RouteExecution;
+use super::execution_support::{commit_completed_task, commit_harness_paths, set_created_worktree};
+use super::git_ops::{git_add_all, git_commit, git_head};
+use super::worktree::{
+    create_isolated_task_worktree_with_name_head, preflight_isolated_task_worktree,
+    task_worktree_name_head,
+};
+
+pub(super) fn baseline_completed_task(
+    root: &Path,
+    journal_action: &str,
+    message: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    commit_completed_task(root, git_head(root)?, journal_action, execution)?;
+    execution.user_message = message.to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_completed_task_then_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let name_head = task_worktree_name_head(root)?;
+    preflight_isolated_task_worktree(root, prompt, &name_head)?;
+    commit_completed_task(
+        root,
+        Some(name_head.clone()),
+        "route_auto_baseline",
+        execution,
+    )?;
+    let created = create_isolated_task_worktree_with_name_head(root, prompt, &name_head)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME baselined the completed task and created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn baseline_harness_refresh_then_completed_task(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(split) = completed_task_harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to split harness refresh paths from completed task diff.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    baseline_completed_task(
+        root,
+        "route_auto_baseline",
+        "NAOME baselined the harness refresh and completed task, then admitted the next task.",
+        execution,
+    )
+}
+
+pub(super) fn baseline_harness_refresh_then_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let name_head = task_worktree_name_head(root)?;
+    preflight_isolated_task_worktree(root, prompt, &name_head)?;
+    let Some(split) = harness_refresh_with_unrelated_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to split harness refresh paths from unrelated dirty paths.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    let created = create_isolated_task_worktree_with_name_head(root, prompt, &name_head)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME baselined the harness refresh and created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn baseline_pure_harness_refresh(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(diff) = harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to find deterministic harness refresh paths.",
+        ));
+    };
+    if !diff.unrelated_paths.is_empty() {
+        return Err(NaomeError::new(
+            "Harness refresh baseline expected no unrelated dirty paths.",
+        ));
+    }
+    commit_harness_paths(root, &diff.harness_paths, execution)?;
+    execution.user_message =
+        "NAOME baselined the harness refresh and is ready to create the next task in the same worktree."
+            .to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_harness_refresh(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let Some(split) = harness_refresh_diff(root)? else {
+        return Err(NaomeError::new(
+            "Unable to find deterministic harness refresh paths.",
+        ));
+    };
+    commit_harness_paths(root, &split.harness_paths, execution)?;
+    execution.user_message =
+        "NAOME baselined the deterministic harness refresh and left unrelated user edits untouched."
+            .to_string();
+    Ok(())
+}
+
+pub(super) fn baseline_setup(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    commit_upgrade_baseline(root, execution)?;
+    execution.user_message =
+        "NAOME baselined the setup changes and is ready to create the next task.".to_string();
+    Ok(())
+}
+
+pub(super) fn commit_upgrade_baseline(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_add_all(root)?;
+    git_commit(root, "chore(naome): baseline setup")?;
+    execution.mark_action("commit_upgrade_baseline");
+    Ok(())
+}

package/crates/naome-core/src/route/execution_support.rs

@@ -0,0 +1,57 @@
+use std::path::{Path, PathBuf};
+
+use crate::journal::append_task_journal;
+use crate::models::{Decision, NaomeError};
+
+use super::execution::RouteExecution;
+use super::git_ops::{git_add_completed_task_paths, git_commit, git_head, git_stage_only_paths};
+use super::RouteWorktree;
+
+pub(super) fn initial_decision_completed(decision: &Decision) -> bool {
+    decision
+        .task
+        .as_ref()
+        .map(|task| task.status.clone())
+        .as_deref()
+        .is_some_and(|status| status == "complete")
+}
+
+pub(super) fn commit_completed_task(
+    root: &Path,
+    before: Option<String>,
+    journal_action: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_add_completed_task_paths(root)?;
+    git_commit(root, "chore(naome): baseline completed task")?;
+    execution.journal_entry = append_task_journal(root, journal_action, before, git_head(root)?)?;
+    execution.mark_action("commit_task_baseline");
+    Ok(())
+}
+
+pub(super) fn commit_harness_paths(
+    root: &Path,
+    paths: &[String],
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    git_stage_only_paths(root, paths)?;
+    git_commit(root, "chore(naome): baseline harness refresh")?;
+    execution.mark_action("commit_harness_refresh_baseline");
+    Ok(())
+}
+
+pub(super) fn set_created_worktree(
+    root: &Path,
+    created: RouteWorktree,
+    prefix: &str,
+    execution: &mut RouteExecution,
+) {
+    execution.task_root = PathBuf::from(&created.path);
+    execution.mark_action("create_task_worktree");
+    execution.user_message = format!(
+        "{prefix} at {}. Continue the new task there; unrelated user edits remain untouched in the original worktree.",
+        created.path
+    );
+    debug_assert_eq!(created.source_root, root.to_string_lossy().to_string());
+    execution.worktree = Some(created);
+}

package/crates/naome-core/src/route/execution_tasks.rs

@@ -0,0 +1,71 @@
+use std::path::Path;
+
+use crate::git;
+use crate::journal::append_task_journal;
+use crate::models::{Decision, NaomeError};
+
+use super::execution::RouteExecution;
+use super::execution_support::{initial_decision_completed, set_created_worktree};
+use super::git_ops::{git_commit, git_head, git_stage_only_paths};
+use super::quality_gate::run_user_diff_quality_gate;
+use super::worktree::create_isolated_task_worktree;
+
+pub(super) fn create_task_worktree(
+    root: &Path,
+    prompt: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let created = create_isolated_task_worktree(root, prompt)?;
+    set_created_worktree(
+        root,
+        created,
+        "NAOME created an isolated task worktree",
+        execution,
+    );
+    Ok(())
+}
+
+pub(super) fn commit_user_diff(
+    root: &Path,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    let paths = git::changed_paths(root)?;
+    execution
+        .executed_actions
+        .push("run_user_diff_quality_gate".to_string());
+    match run_user_diff_quality_gate(root, &paths) {
+        Ok(check_ids) => {
+            git_stage_only_paths(root, &paths)?;
+            git_commit(root, "chore(user): baseline verified user changes")?;
+            execution.mark_action("commit_user_diff");
+            execution.user_message = format!(
+                "NAOME quality gates passed ({}) and committed only the current user-owned changed paths.",
+                check_ids.join(", ")
+            );
+        }
+        Err(error) => {
+            execution.route_allowed = false;
+            execution.human_options = vec!["review_unowned_diff".to_string()];
+            execution.user_message =
+                format!("NAOME user-diff quality gate failed, so no commit was created. {error}");
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn journal_external_baseline_if_needed(
+    root: &Path,
+    initial_decision: &Decision,
+    repo_state_before: &str,
+    execution: &mut RouteExecution,
+) -> Result<(), NaomeError> {
+    if repo_state_before != "ready_for_task" || !initial_decision_completed(initial_decision) {
+        return Ok(());
+    }
+    execution.journal_entry =
+        append_task_journal(root, "external_baseline", None, git_head(root)?)?;
+    if execution.journal_entry.is_some() {
+        execution.mark_action("journal_external_task_baseline");
+    }
+    Ok(())
+}

package/crates/naome-core/src/route/git_ops.rs

@@ -0,0 +1,72 @@
+use std::path::Path;
+use std::process::{Command, Output};
+
+use crate::models::NaomeError;
+use crate::task_state::completed_task_commit_paths;
+
+pub(super) fn git_head(root: &Path) -> Result<Option<String>, NaomeError> {
+    let output = git_output(root, &["rev-parse", "HEAD"])?;
+    if !output.status.success() {
+        return Ok(None);
+    }
+    Ok(Some(
+        String::from_utf8_lossy(&output.stdout).trim().to_string(),
+    ))
+}
+
+pub(super) fn git_add_all(root: &Path) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["add", "-A"])?)
+}
+
+pub(super) fn git_add_completed_task_paths(root: &Path) -> Result<(), NaomeError> {
+    let paths = completed_task_commit_paths(root)?;
+    if paths.is_empty() {
+        return Err(NaomeError::new(
+            "No task-owned paths are available to commit.",
+        ));
+    }
+    git_stage_only_paths(root, &paths)
+}
+
+pub(super) fn git_stage_only_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["reset", "-q", "--", "."])?)?;
+    git_add_paths(root, paths)
+}
+
+fn git_add_paths(root: &Path, paths: &[String]) -> Result<(), NaomeError> {
+    if paths.is_empty() {
+        return Ok(());
+    }
+    let mut args = vec!["add", "--"];
+    args.extend(paths.iter().map(String::as_str));
+    let output = Command::new("git").args(args).current_dir(root).output()?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(command_output(&output)))
+    }
+}
+
+pub(super) fn git_commit(root: &Path, message: &str) -> Result<(), NaomeError> {
+    ensure_git_success(git_output(root, &["commit", "-m", message])?)
+}
+
+pub(super) fn git_output(root: &Path, args: &[&str]) -> Result<Output, NaomeError> {
+    Ok(Command::new("git").args(args).current_dir(root).output()?)
+}
+
+pub(super) fn ensure_git_success(output: Output) -> Result<(), NaomeError> {
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(NaomeError::new(command_output(&output)))
+    }
+}
+
+pub(super) fn command_output(output: &std::process::Output) -> String {
+    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+    if !stderr.is_empty() {
+        return stderr;
+    }
+    String::from_utf8_lossy(&output.stdout).trim().to_string()
+}