@lamentis/naome 1.1.1 → 1.2.0

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

@@ -0,0 +1,139 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::diff::task_diff_from_entries;
+pub(super) use super::evidence::{
+    evidence_entry_path, validate_control_state_paths, validate_control_state_patterns,
+    validate_evidence_array, validate_evidence_paths,
+};
+use super::git_io::read_git_changed_entries;
+use super::proof_entry::validate_proof_result;
+use super::proof_model::canonical_proofs;
+use super::types::ChangedEntry;
+use super::util::{is_iso_datetime, matches_any_pattern, normalize_path, string_array};
+pub(super) fn validate_proof_result_entries(
+    active_task: &Value,
+    check_ids: &HashSet<String>,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    if let Some(proofs) = active_task.get("proofResults").and_then(Value::as_array) {
+        for (index, proof) in proofs.iter().enumerate() {
+            validate_proof_result(proof, index, check_ids, root, errors, active_task)?;
+        }
+    }
+    for proof in canonical_proofs(active_task, root, errors)? {
+        if proof.command.trim().is_empty() {
+            errors.push(format!(
+                "activeTask proof command is empty: {}",
+                proof.check_id
+            ));
+        }
+        if proof.cwd.trim().is_empty() {
+            errors.push(format!("activeTask proof cwd is empty: {}", proof.check_id));
+        }
+        if !is_iso_datetime(&proof.checked_at) {
+            errors.push(format!(
+                "activeTask proof checkedAt must be an ISO timestamp: {}",
+                proof.check_id
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub(super) fn validate_proof_results(
+    active_task: &Value,
+    check_ids: &HashSet<String>,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let Some(required_check_ids) = active_task
+        .get("requiredCheckIds")
+        .and_then(Value::as_array)
+    else {
+        return Ok(());
+    };
+    let proofs = canonical_proofs(active_task, root, errors)?;
+
+    for check_id in required_check_ids {
+        let Some(check_id) = check_id.as_str().filter(|value| !value.trim().is_empty()) else {
+            continue;
+        };
+
+        match proofs.iter().find(|proof| proof.check_id == check_id) {
+            Some(proof) if proof.exit_code == 0 => {}
+            Some(_) => errors.push(format!(
+                "activeTask.proofResults failed proof result: {check_id}"
+            )),
+            None => errors.push(format!(
+                "activeTask.proofResults missing proof result: {check_id}"
+            )),
+        }
+    }
+
+    validate_proof_result_entries(active_task, check_ids, root, errors)
+}
+
+pub(super) fn validate_proof_evidence_covers_changed_paths(
+    active_task: Option<&Value>,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let Some(active_task) = active_task else {
+        return Ok(());
+    };
+    let mut proof_errors = Vec::new();
+    let proofs = canonical_proofs(active_task, root, &mut proof_errors)?;
+    if proofs.is_empty() {
+        return Ok(());
+    }
+
+    let entries = read_git_changed_entries(root)?;
+    validate_proof_evidence_covers_changed_entries(active_task, root, &entries, errors)
+}
+
+pub(super) fn validate_proof_evidence_covers_changed_entries(
+    active_task: &Value,
+    root: &Path,
+    entries: &[ChangedEntry],
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    let mut proof_errors = Vec::new();
+    let proofs = canonical_proofs(active_task, root, &mut proof_errors)?;
+    if proofs.is_empty() {
+        return Ok(());
+    }
+
+    let changed_paths = task_diff_from_entries(active_task, entries);
+    let evidence_paths: HashSet<String> = proofs
+        .iter()
+        .flat_map(|proof| proof.evidence.clone())
+        .filter_map(|entry| evidence_entry_path(&entry).map(normalize_path))
+        .collect();
+
+    let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
+    let changed_allowed_paths: Vec<String> = changed_paths
+        .diff_paths
+        .into_iter()
+        .filter(|path| matches_any_pattern(path, &allowed_paths))
+        .collect();
+    let missing_paths: Vec<String> = changed_allowed_paths
+        .into_iter()
+        .filter(|path| !evidence_paths.contains(path))
+        .collect();
+
+    if !missing_paths.is_empty() {
+        errors.push(format!(
+            "activeTask.proofResults evidence missing changed allowed paths: {}",
+            missing_paths.join(", ")
+        ));
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,66 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::proof::{
+    validate_control_state_paths, validate_evidence_array, validate_evidence_paths,
+};
+use super::util::{is_iso_datetime, require_string};
+
+pub(super) fn validate_proof_result(
+    proof: &Value,
+    index: usize,
+    check_ids: &HashSet<String>,
+    root: &Path,
+    errors: &mut Vec<String>,
+    active_task: &Value,
+) -> Result<(), NaomeError> {
+    let prefix = format!("activeTask.proofResults[{index}]");
+    let Some(object) = proof.as_object() else {
+        errors.push(format!("{prefix} must be an object."));
+        return Ok(());
+    };
+
+    require_string(object.get("checkId"), &format!("{prefix}.checkId"), errors);
+    require_string(object.get("command"), &format!("{prefix}.command"), errors);
+    require_string(object.get("cwd"), &format!("{prefix}.cwd"), errors);
+    validate_evidence_array(
+        object.get("evidence"),
+        &format!("{prefix}.evidence"),
+        errors,
+    );
+    validate_control_state_paths(
+        object.get("evidence"),
+        &format!("{prefix}.evidence"),
+        errors,
+    );
+
+    if object.get("exitCode").and_then(Value::as_i64).is_none() {
+        errors.push(format!("{prefix}.exitCode must be an integer."));
+    }
+
+    if !object
+        .get("checkedAt")
+        .and_then(Value::as_str)
+        .is_some_and(is_iso_datetime)
+    {
+        errors.push(format!("{prefix}.checkedAt must be an ISO timestamp."));
+    }
+
+    if let Some(check_id) = object.get("checkId").and_then(Value::as_str) {
+        if !check_id.trim().is_empty() && !check_ids.contains(check_id) {
+            errors.push(format!("{prefix}.checkId unknown check id: {check_id}"));
+        }
+    }
+
+    validate_evidence_paths(
+        object.get("evidence"),
+        &format!("{prefix}.evidence"),
+        root,
+        errors,
+        active_task,
+    )
+}

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

@@ -0,0 +1,70 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+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>,
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct VerificationDefaults {
+    pub(super) command: String,
+    pub(super) cwd: String,
+}
+
+pub(super) fn canonical_proofs(
+    active_task: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<Vec<CanonicalProof>, NaomeError> {
+    let defaults = read_verification_defaults(root, errors)?;
+    let mut proofs = legacy_proofs(active_task);
+    proofs.extend(compact_proofs(active_task, root, errors, &defaults)?);
+    Ok(proofs)
+}
+
+pub(crate) fn canonical_proof_check_ids(active_task: &Value) -> Vec<String> {
+    let mut check_ids = Vec::new();
+    if let Some(proofs) = active_task.get("proofResults").and_then(Value::as_array) {
+        check_ids.extend(proofs.iter().filter_map(check_id_from_proof));
+    }
+    if let Some(batches) = active_task.get("proofBatches").and_then(Value::as_array) {
+        for batch in batches {
+            if let Some(proofs) = batch.get("proofs").and_then(Value::as_array) {
+                check_ids.extend(proofs.iter().filter_map(check_id_from_proof));
+            }
+        }
+    }
+    check_ids
+}
+
+fn legacy_proofs(active_task: &Value) -> Vec<CanonicalProof> {
+    active_task
+        .get("proofResults")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|proof| {
+            let evidence = proof.get("evidence")?.as_array()?.clone();
+            Some(CanonicalProof {
+                check_id: proof.get("checkId")?.as_str()?.to_string(),
+                command: proof.get("command")?.as_str()?.to_string(),
+                cwd: proof.get("cwd")?.as_str()?.to_string(),
+                exit_code: proof.get("exitCode")?.as_i64()?,
+                checked_at: proof.get("checkedAt")?.as_str()?.to_string(),
+                evidence,
+            })
+        })
+        .collect()
+}

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

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::proof::{
+    validate_control_state_paths, validate_evidence_array, validate_evidence_paths,
+};
+use super::proof_model::VerificationDefaults;
+use super::util::read_json;
+
+pub(super) fn read_path_sets(
+    active_task: &Value,
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<HashMap<String, Vec<Value>>, NaomeError> {
+    let mut sets = HashMap::new();
+    let Some(path_sets) = active_task.get("proofPathSets") else {
+        return Ok(sets);
+    };
+    let Some(path_sets) = path_sets.as_object() else {
+        errors.push("activeTask.proofPathSets must be an object when present.".to_string());
+        return Ok(sets);
+    };
+    for (name, value) in path_sets {
+        let prefix = format!("activeTask.proofPathSets.{name}");
+        validate_evidence_array(Some(value), &prefix, errors);
+        validate_control_state_paths(Some(value), &prefix, errors);
+        validate_evidence_paths(Some(value), &prefix, root, errors, active_task)?;
+        if let Some(paths) = value.as_array() {
+            sets.insert(name.clone(), paths.clone());
+        }
+    }
+    Ok(sets)
+}
+
+pub(super) fn read_verification_defaults(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<HashMap<String, VerificationDefaults>, NaomeError> {
+    let Some(verification) = read_json(root, ".naome/verification.json", errors)? else {
+        return Ok(HashMap::new());
+    };
+    let mut defaults = HashMap::new();
+    for check in verification
+        .get("checks")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+    {
+        let (Some(id), Some(command), Some(cwd)) = (
+            check.get("id").and_then(Value::as_str),
+            check.get("command").and_then(Value::as_str),
+            check.get("cwd").and_then(Value::as_str),
+        ) else {
+            continue;
+        };
+        defaults.insert(
+            id.to_string(),
+            VerificationDefaults {
+                command: command.to_string(),
+                cwd: cwd.to_string(),
+            },
+        );
+    }
+    Ok(defaults)
+}
+
+pub(super) fn check_id_from_proof(proof: &Value) -> Option<String> {
+    proof
+        .get("checkId")
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}

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

@@ -0,0 +1,49 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::repair::{is_completed_task_diff, is_harness_repair_diff, is_naome_baseline_diff};
+use super::shape::validate_blocker;
+use super::types::BLOCKING_STATUS;
+pub(super) fn validate_push_gate(task_state: &Value, errors: &mut Vec<String>) {
+    let status = task_state
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("invalid");
+    if !BLOCKING_STATUS.contains(&status) {
+        return;
+    }
+
+    if status == "blocked" || status == "needs_human_review" {
+        validate_blocker(task_state.get("blocker"), errors);
+    }
+
+    errors.push(format!("NAOME push gate blocked because task state is {status}. Resolve the active task before pushing. Human options: continue_current_task, request_task_changes, mark_task_blocked, cancel_task_state."));
+}
+
+pub(super) fn format_dirty_diff_admission_blocker(
+    task_state: &Value,
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<String, NaomeError> {
+    let prefix = format!(
+        "Task admission requires a clean git diff. Changed paths: {}.",
+        changed_paths.join(", ")
+    );
+
+    if is_harness_repair_diff(root, changed_paths)? {
+        return Ok(format!("{prefix} These look like completed Harness Repair changes. Run NAOME intent for the next natural-language request before deciding whether to baseline, review, or cancel the repair diff."));
+    }
+
+    if is_completed_task_diff(task_state, changed_paths) {
+        return Ok(format!("{prefix} These look like completed task changes. Run NAOME intent for the next natural-language request; deterministic policy can baseline a valid completed task before creating the next task."));
+    }
+
+    if is_naome_baseline_diff(changed_paths) {
+        return Ok(format!("{prefix} These look like completed NAOME install or upgrade changes. Run NAOME intent for the next natural-language request; deterministic policy can baseline setup before creating the next task."));
+    }
+
+    Ok(format!("{prefix} Ask the user to choose exactly one: review_task_diff, request_task_changes, cancel_task_changes. Do not start new feature work or commit without explicit user selection."))
+}

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

@@ -0,0 +1,7 @@
+pub(super) use super::completed_refresh::add_completed_task_diff_notice;
+pub(super) use super::push_gate::{format_dirty_diff_admission_blocker, validate_push_gate};
+pub(super) use super::repair::{
+    is_deterministic_harness_refresh_diff, is_harness_repair_diff,
+    is_install_or_upgrade_baseline_diff, is_packaged_machine_owned_path, is_repair_archive_path,
+    is_safe_harness_refresh_path,
+};

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

@@ -0,0 +1,168 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::install_plan::MACHINE_OWNED_PATHS;
+use crate::models::NaomeError;
+
+use super::types::CONTROL_STATE_PATH;
+use super::util::{
+    is_non_empty_string, matches_any_pattern, normalize_path, read_json, string_array,
+};
+pub(super) fn is_harness_repair_diff(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<bool, NaomeError> {
+    let machine_owned_paths = read_machine_owned_paths(root)?;
+    if machine_owned_paths.is_empty() {
+        return Ok(false);
+    }
+
+    let has_repair_signal = changed_paths
+        .iter()
+        .any(|path| machine_owned_paths.contains(path) || is_repair_archive_path(path));
+    if !has_repair_signal {
+        return Ok(false);
+    }
+
+    Ok(changed_paths
+        .iter()
+        .all(|path| machine_owned_paths.contains(path) || is_repair_support_path(path)))
+}
+
+pub(super) fn is_repair_support_path(path: &str) -> bool {
+    path == ".naome/manifest.json"
+        || path == ".naome/upgrade-state.json"
+        || is_repair_archive_path(path)
+}
+
+pub(super) fn is_packaged_machine_owned_path(path: &str) -> bool {
+    MACHINE_OWNED_PATHS.iter().any(|owned| *owned == path)
+}
+
+pub(super) fn is_safe_harness_refresh_path(path: &str) -> bool {
+    is_packaged_machine_owned_path(path) || is_repair_support_path(path)
+}
+
+pub(super) fn is_deterministic_harness_refresh_diff(changed_paths: &[String]) -> bool {
+    !changed_paths.is_empty()
+        && changed_paths
+            .iter()
+            .any(|path| is_packaged_machine_owned_path(path) || is_repair_archive_path(path))
+        && changed_paths
+            .iter()
+            .all(|path| is_safe_harness_refresh_path(path))
+}
+
+pub(super) fn is_repair_archive_path(path: &str) -> bool {
+    path.starts_with(".naome/archive/repair-")
+}
+
+pub(super) fn is_completed_task_diff(task_state: &Value, changed_paths: &[String]) -> bool {
+    if task_state.get("status").and_then(Value::as_str) != Some("complete") {
+        return false;
+    }
+    let Some(active_task) = task_state.get("activeTask") else {
+        return false;
+    };
+    let allowed_paths = string_array(active_task.get("allowedPaths")).unwrap_or_default();
+    let task_paths: Vec<&String> = changed_paths
+        .iter()
+        .filter(|path| path.as_str() != CONTROL_STATE_PATH)
+        .collect();
+    !task_paths.is_empty()
+        && task_paths
+            .iter()
+            .all(|path| matches_any_pattern(path, &allowed_paths))
+}
+
+pub(super) fn is_naome_baseline_diff(changed_paths: &[String]) -> bool {
+    changed_paths.iter().all(|path| {
+        path == "AGENTS.md"
+            || path == ".gitignore"
+            || path == ".naomeignore"
+            || path.starts_with(".naome/")
+            || path.starts_with("docs/naome/")
+    })
+}
+
+pub(super) fn is_install_or_upgrade_baseline_diff(
+    root: &Path,
+    changed_paths: &[String],
+) -> Result<bool, NaomeError> {
+    if !is_naome_baseline_diff(changed_paths) {
+        return Ok(false);
+    }
+
+    let has_setup_signal = changed_paths.iter().any(|path| {
+        matches!(
+            path.as_str(),
+            "AGENTS.md"
+                | ".gitignore"
+                | ".naomeignore"
+                | ".naome/init-state.json"
+                | ".naome/manifest.json"
+                | ".naome/package.json"
+                | ".naome/task-contract.schema.json"
+                | ".naome/upgrade-state.json"
+        )
+    });
+    if !has_setup_signal {
+        return Ok(false);
+    }
+
+    if read_init_incomplete(root)? || read_upgrade_baseline_signal(root)? {
+        return Ok(true);
+    }
+
+    Ok(changed_paths.iter().any(|path| {
+        matches!(
+            path.as_str(),
+            ".naome/init-state.json" | ".naome/manifest.json" | ".naome/upgrade-state.json"
+        )
+    }))
+}
+
+pub(super) fn read_init_incomplete(root: &Path) -> Result<bool, NaomeError> {
+    let Some(init_state) = read_json(root, ".naome/init-state.json", &mut Vec::new())? else {
+        return Ok(false);
+    };
+
+    Ok(
+        init_state.get("initialized").and_then(Value::as_bool) != Some(true)
+            || init_state.get("intakeStatus").and_then(Value::as_str) != Some("complete"),
+    )
+}
+
+pub(super) fn read_upgrade_baseline_signal(root: &Path) -> Result<bool, NaomeError> {
+    let Some(upgrade_state) = read_json(root, ".naome/upgrade-state.json", &mut Vec::new())? else {
+        return Ok(false);
+    };
+
+    Ok(upgrade_state.get("fromVersion").is_some()
+        || upgrade_state
+            .get("pending")
+            .and_then(Value::as_array)
+            .is_some_and(|pending| !pending.is_empty())
+        || upgrade_state
+            .get("completed")
+            .and_then(Value::as_array)
+            .is_some_and(|completed| !completed.is_empty()))
+}
+
+pub(super) fn read_machine_owned_paths(root: &Path) -> Result<HashSet<String>, NaomeError> {
+    let Some(manifest) = read_json(root, ".naome/manifest.json", &mut Vec::new())? else {
+        return Ok(HashSet::new());
+    };
+
+    Ok(manifest
+        .get("machineOwned")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(Value::as_str)
+        .filter(|value| is_non_empty_string(value))
+        .map(normalize_path)
+        .collect())
+}

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

@@ -0,0 +1,117 @@
+use serde_json::Value;
+
+use super::proof::validate_control_state_patterns;
+pub(super) use super::task_records::{
+    format_blocker, validate_blocker, validate_human_review, validate_prompt_record,
+    validate_revisions,
+};
+pub(super) use super::task_references::{
+    read_verification_check_ids, validate_active_task_references, validate_pending_upgrade,
+    validate_required_check_ids,
+};
+use super::types::ALLOWED_STATUS;
+use super::util::{
+    is_id, is_iso_datetime, require_string, require_string_array, require_string_array_allow_empty,
+};
+pub(super) fn validate_task_state_shape(task_state: &Value, errors: &mut Vec<String>) {
+    let Some(object) = task_state.as_object() else {
+        errors.push(".naome/task-state.json must be a JSON object.".to_string());
+        return;
+    };
+
+    match (
+        object.get("schema").and_then(Value::as_str),
+        object.get("version").and_then(Value::as_i64),
+    ) {
+        (Some("naome.task-state.v1"), Some(1)) | (Some("naome.task-state.v2"), Some(2)) => {}
+        _ => errors.push(
+            ".naome/task-state.json schema/version must be naome.task-state.v1/1 or naome.task-state.v2/2."
+                .to_string(),
+        ),
+    }
+
+    let status = object.get("status").and_then(Value::as_str);
+    if !status.is_some_and(|value| ALLOWED_STATUS.contains(&value)) {
+        errors.push(format!(
+            ".naome/task-state.json status must be one of: {}.",
+            ALLOWED_STATUS.join(", ")
+        ));
+    }
+
+    if let Some(updated_at) = object.get("updatedAt") {
+        if !updated_at.is_null() && !updated_at.as_str().is_some_and(is_iso_datetime) {
+            errors.push(
+                ".naome/task-state.json updatedAt must be an ISO timestamp or null.".to_string(),
+            );
+        }
+    }
+}
+
+pub(super) fn validate_idle_state(task_state: &Value, errors: &mut Vec<String>) {
+    if !task_state.get("activeTask").is_some_and(Value::is_null) {
+        errors.push("idle task state must have activeTask set to null.".to_string());
+    }
+
+    if !task_state.get("blocker").is_some_and(Value::is_null) {
+        errors.push("idle task state must have blocker set to null.".to_string());
+    }
+}
+
+pub(super) fn validate_active_task(active_task: Option<&Value>, errors: &mut Vec<String>) {
+    let Some(active_task) = active_task.and_then(Value::as_object) else {
+        errors.push("activeTask must be an object for active task states.".to_string());
+        return;
+    };
+
+    if !active_task
+        .get("id")
+        .and_then(Value::as_str)
+        .is_some_and(is_id)
+    {
+        errors.push("activeTask.id must be kebab-case lowercase.".to_string());
+    }
+
+    require_string(active_task.get("request"), "activeTask.request", errors);
+    validate_prompt_record(
+        active_task.get("userPrompt"),
+        "activeTask.userPrompt",
+        errors,
+    );
+    require_string_array(
+        active_task.get("allowedPaths"),
+        "activeTask.allowedPaths",
+        errors,
+    );
+    require_string_array(
+        active_task.get("declaredChangeTypes"),
+        "activeTask.declaredChangeTypes",
+        errors,
+    );
+    require_string_array_allow_empty(
+        active_task.get("requiredCheckIds"),
+        "activeTask.requiredCheckIds",
+        errors,
+    );
+    validate_control_state_patterns(
+        active_task.get("allowedPaths"),
+        "activeTask.allowedPaths",
+        errors,
+    );
+
+    let proof_results = active_task.get("proofResults");
+    let proof_batches = active_task.get("proofBatches");
+    if proof_results.is_some_and(|value| !value.is_array()) {
+        errors.push("activeTask.proofResults must be an array when present.".to_string());
+    }
+    if proof_batches.is_some_and(|value| !value.is_array()) {
+        errors.push("activeTask.proofBatches must be an array when present.".to_string());
+    }
+    if proof_results.is_none() && proof_batches.is_none() {
+        errors.push(
+            "activeTask.proofResults or activeTask.proofBatches must be present.".to_string(),
+        );
+    }
+
+    validate_revisions(active_task.get("revisions"), errors);
+    validate_human_review(active_task.get("humanReview"), errors);
+}