@lamentis/naome 1.2.1 → 1.3.1

package/crates/naome-core/src/task_ledger/import.rs

@@ -0,0 +1,142 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+use super::read::{active_path, task_dir};
+use super::write::json_text;
+
+pub(super) fn migrate_task_state_to_ledger(
+    root: &Path,
+    write_ledger: bool,
+) -> Result<Option<Value>, NaomeError> {
+    if active_path(root).is_file() {
+        return Ok(Some(json!({
+            "schema": "naome.task-ledger-migration.v1",
+            "source": "ledger",
+            "updated": false,
+            "reason": "ledger already exists"
+        })));
+    }
+
+    let Some(task_state) = super::read::read_legacy_task_state(root)? else {
+        return Ok(None);
+    };
+    let Some(active_task) = task_state
+        .get("activeTask")
+        .filter(|value| !value.is_null())
+    else {
+        return Ok(None);
+    };
+    let Some(task_id) = active_task.get("id").and_then(Value::as_str) else {
+        return Err(NaomeError::new(
+            "Cannot migrate task-state to ledger: activeTask.id is missing.",
+        ));
+    };
+
+    let task_dir = task_dir(root, task_id);
+    let proof_dir = task_dir.join("proofs");
+    let proofs = super::proof_record::expanded_proofs(active_task, root)?;
+    let status = task_state
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("implementing");
+    let updated_at = task_state
+        .get("updatedAt")
+        .and_then(Value::as_str)
+        .unwrap_or("1970-01-01T00:00:00.000Z");
+
+    let active = json!({
+        "schema": "naome.task-ledger-active.v1",
+        "version": 1,
+        "primaryTaskId": task_id,
+        "worklanes": [
+            { "id": "default", "taskId": task_id, "status": "active" }
+        ]
+    });
+    let spec = task_spec(active_task);
+    let events = task_events(status, updated_at, task_state.get("blocker"));
+
+    if write_ledger {
+        fs::create_dir_all(&proof_dir)?;
+        fs::write(active_path(root), json_text(&active)?)?;
+        fs::write(task_dir.join("task.json"), json_text(&spec)?)?;
+        fs::write(task_dir.join("events.jsonl"), events)?;
+        for proof in &proofs {
+            let file_name = super::proof_record::proof_file_name(
+                proof
+                    .get("checkId")
+                    .and_then(Value::as_str)
+                    .unwrap_or("proof"),
+            );
+            fs::write(proof_dir.join(file_name), json_text(proof)?)?;
+        }
+        if let Some(projection) = super::render::render_from_ledger(root)? {
+            super::write::write_task_state_projection(root, &projection.state)?;
+        }
+    }
+
+    Ok(Some(json!({
+        "schema": "naome.task-ledger-migration.v1",
+        "source": "task-state",
+        "updated": write_ledger,
+        "taskId": task_id,
+        "proofCount": proofs.len()
+    })))
+}
+
+fn task_spec(active_task: &Value) -> Value {
+    json!({
+        "schema": "naome.task-ledger-task.v1",
+        "version": 1,
+        "id": active_task.get("id").cloned().unwrap_or(Value::Null),
+        "request": active_task.get("request").cloned().unwrap_or(Value::Null),
+        "userPrompt": active_task.get("userPrompt").cloned().unwrap_or(Value::Null),
+        "admission": active_task.get("admission").cloned().unwrap_or(Value::Null),
+        "allowedPaths": active_task.get("allowedPaths").cloned().unwrap_or_else(|| json!([])),
+        "declaredChangeTypes": active_task
+            .get("declaredChangeTypes")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "requiredCheckIds": active_task
+            .get("requiredCheckIds")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "revisions": active_task.get("revisions").cloned().unwrap_or_else(|| json!([])),
+        "humanReview": active_task.get("humanReview").cloned().unwrap_or_else(|| {
+            json!({
+                "required": false,
+                "approved": false,
+                "reason": null
+            })
+        })
+    })
+}
+
+fn task_events(status: &str, updated_at: &str, blocker: Option<&Value>) -> String {
+    let mut events = Vec::new();
+    events.push(json!({
+        "schema": "naome.task-ledger-event.v1",
+        "type": "status",
+        "status": status,
+        "recordedAt": updated_at
+    }));
+    if let Some(blocker) = blocker.filter(|value| !value.is_null()) {
+        events.push(json!({
+            "schema": "naome.task-ledger-event.v1",
+            "type": "blocker",
+            "blocker": blocker,
+            "recordedAt": updated_at
+        }));
+    }
+
+    let mut text = events
+        .into_iter()
+        .map(|event| serde_json::to_string(&event).unwrap_or_else(|_| "{}".to_string()))
+        .collect::<Vec<_>>()
+        .join("\n");
+    text.push('\n');
+    text
+}

package/crates/naome-core/src/task_ledger/model.rs

@@ -0,0 +1,13 @@
+use serde_json::Value;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TaskLedgerProjection {
+    pub state: Value,
+    pub status: TaskLedgerStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TaskLedgerStatus {
+    Active,
+    LegacyFallback,
+}

package/crates/naome-core/src/task_ledger/proof_record.rs

@@ -0,0 +1,52 @@
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+use crate::task_state::canonical_proofs;
+
+pub(super) fn expanded_proofs(active_task: &Value, root: &Path) -> Result<Vec<Value>, NaomeError> {
+    let mut errors = Vec::new();
+    let proofs = canonical_proofs(active_task, root, &mut errors)?;
+    if !errors.is_empty() {
+        return Err(NaomeError::new(format!(
+            "Cannot migrate invalid task proof into ledger: {}",
+            errors.join("; ")
+        )));
+    }
+
+    Ok(proofs
+        .into_iter()
+        .map(|proof| {
+            json!({
+                "schema": "naome.task-ledger-proof.v1",
+                "version": 1,
+                "taskId": active_task.get("id").cloned().unwrap_or(Value::Null),
+                "checkId": proof.check_id,
+                "command": proof.command,
+                "cwd": proof.cwd,
+                "exitCode": proof.exit_code,
+                "checkedAt": proof.checked_at,
+                "evidence": proof.evidence
+            })
+        })
+        .collect())
+}
+
+pub(super) fn proof_file_name(check_id: &str) -> String {
+    let mut name = check_id
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.') {
+                ch
+            } else {
+                '_'
+            }
+        })
+        .collect::<String>();
+    if name.is_empty() {
+        name = "proof".to_string();
+    }
+    name.push_str(".json");
+    name
+}

package/crates/naome-core/src/task_ledger/read.rs

@@ -0,0 +1,118 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+pub(super) fn read_legacy_task_state(root: &Path) -> Result<Option<Value>, NaomeError> {
+    let path = root.join(".naome/task-state.json");
+    if !path.is_file() {
+        return Ok(None);
+    }
+    let content = fs::read_to_string(path)?;
+    Ok(Some(serde_json::from_str(&content)?))
+}
+
+pub(super) fn read_active_task_id(root: &Path) -> Result<Option<String>, NaomeError> {
+    let path = active_path(root);
+    if !path.is_file() {
+        return Ok(None);
+    }
+    let active = read_json(&path)?;
+    Ok(active
+        .get("primaryTaskId")
+        .and_then(Value::as_str)
+        .map(ToString::to_string))
+}
+
+pub(super) fn read_task_spec(root: &Path, task_id: &str) -> Result<Value, NaomeError> {
+    read_json(&task_dir(root, task_id).join("task.json"))
+}
+
+pub(super) fn read_status(
+    root: &Path,
+    task_id: &str,
+) -> Result<(String, Option<Value>, String), NaomeError> {
+    let events_path = task_dir(root, task_id).join("events.jsonl");
+    let mut status = "implementing".to_string();
+    let mut blocker = None;
+    let mut updated_at = None;
+
+    if events_path.is_file() {
+        for line in fs::read_to_string(events_path)?.lines() {
+            if line.trim().is_empty() {
+                continue;
+            }
+            let event: Value = serde_json::from_str(line)?;
+            if let Some(recorded_at) = event.get("recordedAt").and_then(Value::as_str) {
+                updated_at = Some(recorded_at.to_string());
+            }
+            match event.get("type").and_then(Value::as_str) {
+                Some("status") => {
+                    if let Some(next_status) = event.get("status").and_then(Value::as_str) {
+                        status = next_status.to_string();
+                    }
+                }
+                Some("blocker") => blocker = event.get("blocker").cloned(),
+                _ => {}
+            }
+        }
+    }
+
+    Ok((
+        status,
+        blocker,
+        updated_at.unwrap_or_else(|| "1970-01-01T00:00:00.000Z".to_string()),
+    ))
+}
+
+pub(super) fn read_proofs(root: &Path, task_id: &str) -> Result<Vec<Value>, NaomeError> {
+    let proofs_dir = task_dir(root, task_id).join("proofs");
+    if !proofs_dir.is_dir() {
+        return Ok(Vec::new());
+    }
+
+    let mut entries: Vec<PathBuf> = fs::read_dir(proofs_dir)?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("json"))
+        .collect();
+    entries.sort();
+
+    let mut proofs = Vec::new();
+    for path in entries {
+        let proof = read_json(&path)?;
+        proofs.push(json!({
+            "checkId": proof.get("checkId").cloned().unwrap_or(Value::Null),
+            "command": proof.get("command").cloned().unwrap_or(Value::Null),
+            "cwd": proof.get("cwd").cloned().unwrap_or(Value::Null),
+            "exitCode": proof.get("exitCode").cloned().unwrap_or(Value::Null),
+            "checkedAt": proof.get("checkedAt").cloned().unwrap_or(Value::Null),
+            "evidence": proof.get("evidence").cloned().unwrap_or_else(|| json!([])),
+            "outputSummary": proof.get("outputSummary").cloned().unwrap_or(Value::Null)
+        }));
+    }
+    Ok(proofs
+        .into_iter()
+        .map(|mut proof| {
+            if proof.get("outputSummary").is_some_and(Value::is_null) {
+                proof.as_object_mut().unwrap().remove("outputSummary");
+            }
+            proof
+        })
+        .collect())
+}
+
+fn read_json(path: &Path) -> Result<Value, NaomeError> {
+    let content = fs::read_to_string(path)?;
+    Ok(serde_json::from_str(&content)?)
+}
+
+pub(super) fn active_path(root: &Path) -> PathBuf {
+    root.join(".naome/tasks/active.json")
+}
+
+pub(super) fn task_dir(root: &Path, task_id: &str) -> PathBuf {
+    root.join(".naome/tasks").join(task_id)
+}

package/crates/naome-core/src/task_ledger/render.rs

@@ -0,0 +1,55 @@
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+use super::model::{TaskLedgerProjection, TaskLedgerStatus};
+use super::read::{read_active_task_id, read_proofs, read_status, read_task_spec};
+
+pub(super) fn render_from_ledger(root: &Path) -> Result<Option<TaskLedgerProjection>, NaomeError> {
+    let Some(task_id) = read_active_task_id(root)? else {
+        return Ok(None);
+    };
+    let spec = read_task_spec(root, &task_id)?;
+    let (status, blocker, updated_at) = read_status(root, &task_id)?;
+    let active_task = render_active_task(spec, read_proofs(root, &task_id)?);
+    Ok(Some(TaskLedgerProjection {
+        state: json!({
+            "schema": "naome.task-state.v2",
+            "version": 2,
+            "status": status,
+            "activeTask": active_task,
+            "blocker": blocker,
+            "updatedAt": updated_at
+        }),
+        status: TaskLedgerStatus::Active,
+    }))
+}
+
+fn render_active_task(spec: Value, proof_results: Vec<Value>) -> Value {
+    json!({
+        "id": spec.get("id").cloned().unwrap_or(Value::Null),
+        "request": spec.get("request").cloned().unwrap_or(Value::Null),
+        "userPrompt": spec.get("userPrompt").cloned().unwrap_or(Value::Null),
+        "admission": spec.get("admission").cloned().unwrap_or(Value::Null),
+        "allowedPaths": spec.get("allowedPaths").cloned().unwrap_or_else(|| json!([])),
+        "declaredChangeTypes": spec
+            .get("declaredChangeTypes")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "requiredCheckIds": spec
+            .get("requiredCheckIds")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "proofResults": proof_results,
+        "revisions": spec.get("revisions").cloned().unwrap_or_else(|| json!([])),
+        "humanReview": spec.get("humanReview").cloned().unwrap_or_else(|| {
+            json!({
+                "required": false,
+                "approved": false,
+                "reason": null
+            })
+        })
+    })
+}

package/crates/naome-core/src/task_ledger/write.rs

@@ -0,0 +1,38 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::read;
+use super::render;
+
+pub(super) fn write_task_state_projection(root: &Path, state: &Value) -> Result<(), NaomeError> {
+    let path = root.join(".naome/task-state.json");
+    fs::write(path, json_text(state)?)?;
+    Ok(())
+}
+
+pub(super) fn validate_task_state_projection_is_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    if !read::active_path(root).is_file() {
+        return Ok(());
+    }
+    let Some(legacy) = read::read_legacy_task_state(root)? else {
+        return Ok(());
+    };
+    let Some(rendered) = render::render_from_ledger(root)? else {
+        return Ok(());
+    };
+    if legacy != rendered.state {
+        errors.push(".naome/task-state.json is stale relative to .naome/tasks/. Run node .naome/bin/naome.js task render-state --write --json before completion or commit.".to_string());
+    }
+    Ok(())
+}
+
+pub(super) fn json_text(value: &Value) -> Result<String, NaomeError> {
+    Ok(format!("{}\n", serde_json::to_string_pretty(value)?))
+}

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

@@ -0,0 +1,48 @@
+mod import;
+mod model;
+mod proof_record;
+mod read;
+mod render;
+mod write;
+
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub use model::{TaskLedgerProjection, TaskLedgerStatus};
+
+pub fn migrate_task_state_to_ledger(
+    root: &Path,
+    write_ledger: bool,
+) -> Result<Option<Value>, NaomeError> {
+    import::migrate_task_state_to_ledger(root, write_ledger)
+}
+
+pub fn read_task_state_projection(root: &Path) -> Result<Option<Value>, NaomeError> {
+    if let Some(projection) = render::render_from_ledger(root)? {
+        return Ok(Some(projection.state));
+    }
+    read::read_legacy_task_state(root)
+}
+
+pub fn render_task_state_from_ledger(
+    root: &Path,
+    write_projection: bool,
+) -> Result<Option<Value>, NaomeError> {
+    let Some(projection) = render::render_from_ledger(root)? else {
+        return Ok(None);
+    };
+    if write_projection {
+        write::write_task_state_projection(root, &projection.state)?;
+    }
+    Ok(Some(projection.state))
+}
+
+pub(crate) fn validate_task_state_projection_is_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    write::validate_task_state_projection_is_current(root, errors)
+}

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

@@ -3,6 +3,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::task_ledger::{read_task_state_projection, validate_task_state_projection_is_current};
 
 use super::completion::{
     validate_admission, validate_commit_gate, validate_complete_task, validate_progress,
@@ -16,7 +17,7 @@ use super::shape::{
 };
 use super::task_diff_api::validate_harness_health_gate;
 use super::types::*;
-use super::util::read_json;
+
 pub fn validate_task_state(
     root: &Path,
     options: TaskStateOptions,
@@ -25,10 +26,11 @@ pub fn validate_task_state(
         errors: Vec::new(),
         notices: Vec::new(),
     };
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut report.errors)? else {
+    let Some(task_state) = read_task_state_projection(root)? else {
         return Ok(report);
     };
 
+    validate_task_state_projection_is_current(root, &mut report.errors)?;
     validate_task_state_shape(&task_state, &mut report.errors);
     let status = task_state
         .get("status")

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

@@ -1,16 +1,15 @@
 use std::path::Path;
 
-use serde_json::Value;
-
 use crate::models::NaomeError;
 
 use super::api::validate_task_state;
 use super::git_io::read_git_changed_paths;
 use super::repair::is_safe_harness_refresh_path;
 use super::types::{
-    CompletedTaskHarnessRefreshDiff, TaskStateMode, TaskStateOptions, CONTROL_STATE_PATH,
+    is_control_state_path, read_complete_active_task, CompletedTaskHarnessRefreshDiff,
+    TaskStateMode, TaskStateOptions,
 };
-use super::util::{matches_any_pattern, read_json, string_array};
+use super::util::{matches_any_pattern, string_array};
 pub(super) fn add_completed_task_diff_notice(
     root: &Path,
     notices: &mut Vec<String>,
@@ -27,17 +26,7 @@ pub(super) fn add_completed_task_diff_notice(
 pub fn completed_task_harness_refresh_diff(
     root: &Path,
 ) -> Result<Option<CompletedTaskHarnessRefreshDiff>, NaomeError> {
-    let mut read_errors = Vec::new();
-    let Some(task_state) = read_json(root, ".naome/task-state.json", &mut read_errors)? else {
-        return Ok(None);
-    };
-    if !read_errors.is_empty() {
-        return Ok(None);
-    }
-    if task_state.get("status").and_then(Value::as_str) != Some("complete") {
-        return Ok(None);
-    }
-    let Some(active_task) = task_state.get("activeTask") else {
+    let Some((_, active_task)) = read_complete_active_task(root)? else {
         return Ok(None);
     };
 
@@ -47,7 +36,7 @@ pub fn completed_task_harness_refresh_diff(
     let mut other_paths = Vec::new();
 
     for path in read_git_changed_paths(root)? {
-        if path == CONTROL_STATE_PATH {
+        if is_control_state_path(&path) {
             continue;
         }
         if matches_any_pattern(&path, &allowed_paths) {

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

@@ -6,7 +6,7 @@ use serde_json::Value;
 use crate::models::NaomeError;
 
 use super::git_io::read_git_changed_entries;
-use super::types::{ChangedEntry, TaskDiff, CONTROL_STATE_PATH};
+use super::types::{is_control_state_path, ChangedEntry, TaskDiff};
 use super::util::{matches_any_pattern, normalize_path, string_array};
 pub(super) fn validate_changed_paths(
     active_task: &Value,
@@ -80,7 +80,7 @@ pub(super) fn task_diff_from_entries(active_task: &Value, entries: &[ChangedEntr
     let diff_paths: Vec<String> = entries
         .iter()
         .map(|entry| entry.path.clone())
-        .filter(|path| path != CONTROL_STATE_PATH)
+        .filter(|path| !is_control_state_path(path))
         .collect();
     let outside_paths = diff_paths
         .iter()

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

@@ -7,7 +7,7 @@ use crate::models::NaomeError;
 
 use super::deleted_paths::read_historical_deleted_paths;
 use super::git_io::read_git_changed_entries;
-use super::types::{ALLOWED_EVIDENCE_STATUS, CONTROL_STATE_PATH};
+use super::types::{is_control_state_path, ALLOWED_EVIDENCE_STATUS, CONTROL_STATE_PATH};
 use super::util::{
     is_non_empty_string, matches_any_pattern, normalize_path, require_string, string_array,
 };
@@ -68,7 +68,12 @@ pub(super) fn validate_control_state_patterns(
     };
 
     for pattern in patterns {
-        if matches_any_pattern(CONTROL_STATE_PATH, std::slice::from_ref(&pattern)) {
+        if matches_any_pattern(CONTROL_STATE_PATH, std::slice::from_ref(&pattern))
+            || matches_any_pattern(
+                ".naome/tasks/example/task.json",
+                std::slice::from_ref(&pattern),
+            )
+        {
             errors.push(format!(
                 "{field_name} cannot include NAOME control state: {pattern}"
             ));
@@ -89,7 +94,7 @@ pub(super) fn validate_control_state_paths(
         let Some(path) = evidence_entry_path(entry) else {
             continue;
         };
-        if normalize_path(&path) == CONTROL_STATE_PATH {
+        if is_control_state_path(&normalize_path(&path)) {
             errors.push(format!(
                 "{field_name} cannot include NAOME control state: {path}"
             ));

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

@@ -30,7 +30,7 @@ mod util;
 
 pub use api::validate_task_state;
 pub use completed_refresh::completed_task_harness_refresh_diff;
-pub(crate) use proof_model::canonical_proof_check_ids;
+pub(crate) use proof_model::{canonical_proof_check_ids, canonical_proofs};
 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/progress.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 
 use super::diff::validate_changed_paths;
 use super::git_io::read_git_changed_paths;
@@ -33,6 +34,7 @@ pub(super) fn validate_progress(
             if let Some(active_task) = task_state.get("activeTask") {
                 validate_changed_paths(active_task, root, errors)?;
             }
+            validate_repository_model_current(root, errors)?;
         }
         "needs_human_review" => {
             validate_human_review_state(task_state, root, errors)?;
@@ -60,6 +62,17 @@ pub(super) fn validate_progress(
     Ok(())
 }
 
+fn validate_repository_model_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let drift = repository_model_drift(root)?;
+    if drift.model_present && drift.stale {
+        errors.extend(drift.messages);
+    }
+    Ok(())
+}
+
 pub(super) fn checked_status<'a>(
     task_state: &'a Value,
     root: &Path,

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

@@ -8,13 +8,13 @@ use super::compact_proof::compact_proofs;
 use super::proof_sources::{check_id_from_proof, read_verification_defaults};
 
 #[derive(Debug, Clone)]
-pub(super) struct CanonicalProof {
-    pub(super) check_id: String,
-    pub(super) command: String,
-    pub(super) cwd: String,
-    pub(super) exit_code: i64,
-    pub(super) checked_at: String,
-    pub(super) evidence: Vec<Value>,
+pub(crate) struct CanonicalProof {
+    pub(crate) check_id: String,
+    pub(crate) command: String,
+    pub(crate) cwd: String,
+    pub(crate) exit_code: i64,
+    pub(crate) checked_at: String,
+    pub(crate) evidence: Vec<Value>,
 }
 
 #[derive(Debug, Clone)]
@@ -23,7 +23,7 @@ pub(super) struct VerificationDefaults {
     pub(super) cwd: String,
 }
 
-pub(super) fn canonical_proofs(
+pub(crate) fn canonical_proofs(
     active_task: &Value,
     root: &Path,
     errors: &mut Vec<String>,