@lamentis/naome 1.0.2 → 1.1.0

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

@@ -0,0 +1,169 @@
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::Path;
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::Serialize;
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+const JOURNAL_PATH: &str = ".naome/task-journal.jsonl";
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskJournalEntry {
+    pub schema: String,
+    pub recorded_at: String,
+    pub task_id: Option<String>,
+    pub request: Option<String>,
+    pub user_prompt: Option<String>,
+    pub revision_count: usize,
+    pub proof_summary: Vec<String>,
+    pub outcome: String,
+    pub commit_before: Option<String>,
+    pub commit_after: Option<String>,
+    pub head: Option<String>,
+}
+
+pub fn append_task_journal(
+    root: &Path,
+    outcome: &str,
+    commit_before: Option<String>,
+    commit_after: Option<String>,
+) -> Result<Option<TaskJournalEntry>, NaomeError> {
+    ensure_journal_is_local_only(root)?;
+    let task_state = read_json(root, ".naome/task-state.json")?;
+    let Some(active_task) = task_state
+        .get("activeTask")
+        .filter(|value| !value.is_null())
+    else {
+        return Ok(None);
+    };
+
+    let entry = TaskJournalEntry {
+        schema: "naome.task-journal-entry.v1".to_string(),
+        recorded_at: timestamp_now(),
+        task_id: string_at(active_task, "id"),
+        request: string_at(active_task, "request"),
+        user_prompt: active_task
+            .get("userPrompt")
+            .and_then(|prompt| prompt.get("text"))
+            .and_then(Value::as_str)
+            .map(ToString::to_string),
+        revision_count: active_task
+            .get("revisions")
+            .and_then(Value::as_array)
+            .map_or(0, Vec::len),
+        proof_summary: proof_summary(active_task),
+        outcome: outcome.to_string(),
+        commit_before,
+        commit_after: commit_after.clone(),
+        head: git_head(root).ok().flatten(),
+    };
+
+    if journal_contains(root, &entry)? {
+        return Ok(Some(entry));
+    }
+
+    fs::create_dir_all(root.join(".naome"))?;
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(root.join(JOURNAL_PATH))?;
+    writeln!(file, "{}", serde_json::to_string(&entry)?)?;
+    Ok(Some(entry))
+}
+
+fn ensure_journal_is_local_only(root: &Path) -> Result<(), NaomeError> {
+    let git_info = root.join(".git").join("info");
+    if !git_info.is_dir() {
+        return Ok(());
+    }
+
+    let exclude_path = git_info.join("exclude");
+    let existing = fs::read_to_string(&exclude_path).unwrap_or_default();
+    if existing
+        .lines()
+        .map(str::trim)
+        .any(|line| line == JOURNAL_PATH)
+    {
+        return Ok(());
+    }
+
+    let mut next = existing;
+    if !next.is_empty() && !next.ends_with('\n') {
+        next.push('\n');
+    }
+    next.push_str("# NAOME local task journal.\n");
+    next.push_str(JOURNAL_PATH);
+    next.push('\n');
+    fs::write(exclude_path, next)?;
+    Ok(())
+}
+
+fn journal_contains(root: &Path, entry: &TaskJournalEntry) -> Result<bool, NaomeError> {
+    let path = root.join(JOURNAL_PATH);
+    if !path.is_file() {
+        return Ok(false);
+    }
+
+    let content = fs::read_to_string(path)?;
+    Ok(content.lines().any(|line| {
+        let Ok(value) = serde_json::from_str::<Value>(line) else {
+            return false;
+        };
+        value.get("taskId").and_then(Value::as_str) == entry.task_id.as_deref()
+            && value.get("outcome").and_then(Value::as_str) == Some(entry.outcome.as_str())
+            && value.get("commitAfter").and_then(Value::as_str) == entry.commit_after.as_deref()
+    }))
+}
+
+fn proof_summary(active_task: &Value) -> Vec<String> {
+    active_task
+        .get("proofResults")
+        .and_then(Value::as_array)
+        .map(|proofs| {
+            proofs
+                .iter()
+                .filter_map(|proof| proof.get("checkId").and_then(Value::as_str))
+                .map(ToString::to_string)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn read_json(root: &Path, relative_path: &str) -> Result<Value, NaomeError> {
+    Ok(serde_json::from_str(&fs::read_to_string(
+        root.join(relative_path),
+    )?)?)
+}
+
+fn string_at(value: &Value, key: &str) -> Option<String> {
+    value
+        .get(key)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+fn git_head(root: &Path) -> Result<Option<String>, NaomeError> {
+    let output = Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .current_dir(root)
+        .output()?;
+    if !output.status.success() {
+        return Ok(None);
+    }
+    Ok(Some(
+        String::from_utf8_lossy(&output.stdout).trim().to_string(),
+    ))
+}
+
+fn timestamp_now() -> String {
+    let seconds = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0);
+    format!("unix:{seconds}")
+}

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

@@ -2,8 +2,11 @@ mod decision;
 mod git;
 mod harness_health;
 mod install_plan;
+mod intent;
+mod journal;
 mod models;
 mod paths;
+mod route;
 mod task_state;
 mod verification;
 mod verification_contract;
@@ -11,7 +14,13 @@ mod verification_contract;
 pub use decision::{evaluate_decision, format_decision, EvaluationOptions};
 pub use harness_health::{validate_harness_health, HarnessHealthOptions};
 pub use install_plan::{install_plan, InstallPlan};
+pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence};
+pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
-pub use task_state::{validate_task_state, TaskStateMode, TaskStateOptions, TaskStateReport};
+pub use route::{evaluate_route, explain_route, ExplainDecision, RouteDecision, RouteOptions};
+pub use task_state::{
+    completed_task_commit_paths, validate_task_state, TaskStateMode, TaskStateOptions,
+    TaskStateReport,
+};
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;

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

@@ -12,6 +12,9 @@ pub struct Decision {
     pub summary: String,
     pub allowed_actions: Vec<String>,
     pub next_action: String,
+    pub user_message: String,
+    pub human_options: Vec<String>,
+    pub internal_notes: Vec<String>,
     pub changed_paths: Vec<String>,
     pub required_context: Vec<String>,
     pub task: Option<TaskDecision>,
@@ -27,16 +30,23 @@ impl Decision {
         allowed_actions: Vec<&str>,
         next_action: &str,
     ) -> Self {
+        let allowed_actions: Vec<String> = allowed_actions
+            .into_iter()
+            .map(ToString::to_string)
+            .collect();
+        let (user_message, human_options, internal_notes) =
+            response_policy(state, blocked, summary, next_action, &allowed_actions);
+
         Self {
             schema: "naome.decision.v1".to_string(),
             state: state.to_string(),
             blocked,
             summary: summary.to_string(),
-            allowed_actions: allowed_actions
-                .into_iter()
-                .map(ToString::to_string)
-                .collect(),
+            allowed_actions,
             next_action: next_action.to_string(),
+            user_message,
+            human_options,
+            internal_notes,
             changed_paths: Vec::new(),
             required_context: Vec::new(),
             task: None,
@@ -46,6 +56,55 @@ impl Decision {
     }
 }
 
+fn response_policy(
+    state: &str,
+    blocked: bool,
+    summary: &str,
+    next_action: &str,
+    allowed_actions: &[String],
+) -> (String, Vec<String>, Vec<String>) {
+    let mut internal_notes = vec![format!("internal_state:{state}")];
+    if !allowed_actions.is_empty() {
+        internal_notes.push(format!(
+            "internal_allowed_actions:{}",
+            allowed_actions.join(",")
+        ));
+    }
+
+    let human_options = if blocked && human_decision_required(state) {
+        allowed_actions.to_vec()
+    } else {
+        Vec::new()
+    };
+
+    let user_message = match state {
+        "completed_task_unbaselined" => "The completed task is verified and waiting for the next request. If the next request is a separate task, NAOME can baseline this task automatically first.".to_string(),
+        "install_or_upgrade_unbaselined" | "harness_repair_unbaselined" => {
+            "NAOME setup or repair changes are ready to be routed. A separate new task can trigger an automatic baseline when policy allows.".to_string()
+        }
+        "ready_for_task" => "NAOME is ready for the next task.".to_string(),
+        "harness_unhealthy" => "NAOME harness health failed, so normal task work is blocked until the harness is repaired or reviewed.".to_string(),
+        _ => {
+            if blocked {
+                format!("{summary} {next_action}")
+            } else {
+                summary.to_string()
+            }
+        }
+    };
+
+    (user_message, human_options, internal_notes)
+}
+
+fn human_decision_required(state: &str) -> bool {
+    !matches!(
+        state,
+        "completed_task_unbaselined"
+            | "install_or_upgrade_unbaselined"
+            | "harness_repair_unbaselined"
+    )
+}
+
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct TaskDecision {