@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-cli/src/repository_model_commands.rs

@@ -0,0 +1,84 @@
+use std::path::Path;
+
+use naome_core::{explain_repository_model_path, refresh_repository_model, RepositoryModelRefresh};
+
+use crate::cli_args::option_value;
+
+pub fn run_repo_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome repo requires model, check, or explain.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "model" => run_model(root, args, json)?,
+        "check" => run_check(root, json)?,
+        "explain" => run_explain(root, args, json)?,
+        _ => return Err(format!("unknown naome repo command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+fn run_model(root: &Path, args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let report = refresh_repository_model(root, args.iter().any(|arg| arg == "--write"))?;
+    print_refresh_report(&report, json)
+}
+
+fn run_check(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let report = refresh_repository_model(root, false)?;
+    print_refresh_report(&report, json)
+}
+
+fn print_refresh_report(
+    report: &RepositoryModelRefresh,
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if !report.updated_paths.is_empty() {
+        println!(
+            "NAOME repository model updated: {}.",
+            report.updated_paths.join(", ")
+        );
+    } else if report.ok {
+        println!("NAOME repository model is current.");
+    } else {
+        println!("NAOME repository model is stale.");
+        println!("Run naome repo model --write to refresh deterministic repository facts.");
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_explain(root: &Path, args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(path) = option_value(args, "--path") else {
+        return Err("naome repo explain requires --path <path>.".into());
+    };
+    let explanation = explain_repository_model_path(root, path)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&explanation)?);
+    } else {
+        println!(
+            "{} role={} language={} module={} entity={}",
+            explanation.path,
+            explanation.role.as_deref().unwrap_or("unknown"),
+            explanation.language.as_deref().unwrap_or("unknown"),
+            explanation.module.as_deref().unwrap_or("unknown"),
+            explanation.entity.as_deref().unwrap_or("unknown")
+        );
+        if !explanation.facts.is_empty() {
+            println!(
+                "Facts: {}",
+                explanation
+                    .facts
+                    .iter()
+                    .map(|fact| fact.id.as_str())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            );
+        }
+    }
+    Ok(())
+}

package/crates/naome-cli/src/task_commands.rs

@@ -0,0 +1,62 @@
+use std::path::Path;
+
+use naome_core::{migrate_task_state_to_ledger, render_task_state_from_ledger};
+
+pub fn run_task_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    match args.get(1).map(String::as_str) {
+        Some("render-state") => render_state(root, args),
+        Some("migrate-ledger") => migrate_ledger(root, args),
+        _ => Err("unknown task command".into()),
+    }
+}
+
+fn render_state(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let write = args.iter().any(|arg| arg == "--write");
+    let json = args.iter().any(|arg| arg == "--json");
+    let rendered = render_task_state_from_ledger(root, write)?;
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.task-render-state.v1",
+                "updated": write && rendered.is_some(),
+                "source": if rendered.is_some() { "ledger" } else { "task-state" },
+                "taskState": rendered
+            }))?
+        );
+    } else if rendered.is_some() {
+        println!("NAOME task-state projection rendered from task ledger.");
+    } else {
+        println!(
+            "NAOME task ledger not found; existing task-state compatibility mode remains active."
+        );
+    }
+
+    Ok(())
+}
+
+fn migrate_ledger(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let write = args.iter().any(|arg| arg == "--write");
+    let json = args.iter().any(|arg| arg == "--json");
+    let migrated = migrate_task_state_to_ledger(root, write)?;
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.task-migrate-ledger.v1",
+                "updated": write && migrated.is_some(),
+                "migration": migrated
+            }))?
+        );
+    } else if migrated.is_some() && write {
+        println!("NAOME task ledger migrated from task-state.");
+    } else if migrated.is_some() {
+        println!("NAOME task ledger migration is available; rerun with --write to apply it.");
+    } else {
+        println!("NAOME task ledger migration skipped; no active task-state task exists.");
+    }
+
+    Ok(())
+}

package/crates/naome-cli/src/workflow_commands.rs

@@ -1,8 +1,10 @@
 use std::path::Path;
 
 use naome_core::{
-    classify_mutations, doctor_report, refresh_integrity, safe_rg_args, tracked_process_report,
-    validate_search_command, verification_phase_plan,
+    agent_run_plan, classify_mutations, context_delta_report, decision_gate, doctor_report,
+    edit_session_watchdog, proof_plan_for_task, refresh_integrity, repository_capability_graph,
+    safe_rg_args, summarize_command_output, tracked_process_report, validate_search_command,
+    verification_phase_plan,
 };
 
 use crate::cli_args::option_value;
@@ -30,7 +32,7 @@ pub fn run_workflow_command(
     args: &[String],
 ) -> Result<(), Box<dyn std::error::Error>> {
     let Some(subcommand) = args.get(1).map(String::as_str) else {
-        return Err("naome workflow requires search-profile, check-search, phases, processes, or mutations.".into());
+        return Err("naome workflow requires agent-plan, context-delta, proof-plan, capabilities, edit-watchdog, decision-gate, digest, search-profile, check-search, phases, processes, or mutations.".into());
     };
     let json = args.iter().any(|arg| arg == "--json");
 
@@ -50,6 +52,29 @@ pub fn run_workflow_command(
             }
         }
         "check-search" => run_check_search(root, args, json)?,
+        "agent-plan" => print_json_or_label(
+            serde_json::to_value(agent_run_plan(root)?)?,
+            json,
+            "NAOME agent plan ready.",
+        )?,
+        "context-delta" => run_context_delta(root, args, json)?,
+        "proof-plan" => print_json_or_label(
+            serde_json::to_value(proof_plan_for_task(root, &[])?)?,
+            json,
+            "NAOME proof plan ready.",
+        )?,
+        "capabilities" => print_json_or_label(
+            serde_json::to_value(repository_capability_graph(root)?)?,
+            json,
+            "NAOME capability graph ready.",
+        )?,
+        "edit-watchdog" => run_edit_watchdog(root, args, json)?,
+        "decision-gate" => print_json_or_label(
+            serde_json::to_value(decision_gate(root)?)?,
+            json,
+            "NAOME decision gate ready.",
+        )?,
+        "digest" => run_digest(root, args, json)?,
         "phases" => {
             let plan = verification_phase_plan(root, &[])?;
             if json {
@@ -154,6 +179,78 @@ fn run_mutations(
     Ok(())
 }
 
+fn run_context_delta(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let read_paths = repeated_values(args, "--read-path");
+    print_json_or_label(
+        serde_json::to_value(context_delta_report(root, &read_paths)?)?,
+        json,
+        "NAOME context delta ready.",
+    )
+}
+
+fn run_edit_watchdog(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let paths = repeated_values(args, "--path");
+    if paths.is_empty() {
+        return Err("naome workflow edit-watchdog requires --path <path>.".into());
+    }
+    print_json_or_label(
+        serde_json::to_value(edit_session_watchdog(root, &paths)?)?,
+        json,
+        "NAOME edit watchdog ready.",
+    )
+}
+
+fn run_digest(root: &Path, args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let command = option_value(args, "--command").unwrap_or_else(|| "unknown".to_string());
+    let cwd = option_value(args, "--cwd").unwrap_or_else(|| ".".to_string());
+    let exit_code = option_value(args, "--exit-code")
+        .and_then(|value| value.parse::<i32>().ok())
+        .unwrap_or(1);
+    let max_lines = option_value(args, "--max-lines")
+        .and_then(|value| value.parse::<usize>().ok())
+        .unwrap_or(12);
+    let output = if let Some(path) = option_value(args, "--output-file") {
+        std::fs::read_to_string(root.join(path))?
+    } else {
+        option_value(args, "--output").unwrap_or_default()
+    };
+    print_json_or_label(
+        serde_json::to_value(summarize_command_output(
+            &command, &cwd, exit_code, &output, max_lines,
+        ))?,
+        json,
+        "NAOME output digest ready.",
+    )
+}
+
+fn repeated_values(args: &[String], flag: &str) -> Vec<String> {
+    args.windows(2)
+        .filter(|window| window[0] == flag)
+        .map(|window| window[1].clone())
+        .collect()
+}
+
+fn print_json_or_label(
+    value: serde_json::Value,
+    json: bool,
+    label: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if json {
+        println!("{}", serde_json::to_string_pretty(&value)?);
+    } else {
+        println!("{label}");
+    }
+    Ok(())
+}
+
 fn empty_label(values: &[String]) -> String {
     if values.is_empty() {
         "none".to_string()

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.3.0"
+version = "1.3.2"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -0,0 +1,75 @@
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+
+use super::types::{ContextCapsule, ContextItem};
+
+pub(super) fn normalize_paths(paths: Vec<String>) -> Vec<String> {
+    let normalized = paths
+        .into_iter()
+        .filter(|path| !path.trim().is_empty())
+        .map(|path| path.trim_start_matches("./").replace('\\', "/"))
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    let task_paths = normalized
+        .iter()
+        .filter(|path| !is_context_noise(path))
+        .cloned()
+        .collect::<Vec<_>>();
+    if task_paths.is_empty() {
+        normalized
+    } else {
+        task_paths
+    }
+}
+
+pub(super) fn context_item(root: &Path, path: &str, reason: &str, priority: &str) -> ContextItem {
+    ContextItem {
+        path: path.to_string(),
+        reason: reason.to_string(),
+        priority: priority.to_string(),
+        estimated_lines: fs::read_to_string(root.join(path))
+            .map(|content| content.lines().count().max(1))
+            .unwrap_or(1),
+    }
+}
+
+pub(super) fn capsule_for_paths(paths: &[String]) -> ContextCapsule {
+    let id = if paths.iter().any(|path| path.contains("quality")) {
+        "quality-work"
+    } else if paths
+        .iter()
+        .any(|path| path.contains("/route") || path.contains("/intent"))
+    {
+        "routing-work"
+    } else if paths.iter().any(|path| is_source_path(path)) {
+        "source-work"
+    } else if paths
+        .iter()
+        .any(|path| path.ends_with(".md") || path.contains("/docs/"))
+    {
+        "docs-work"
+    } else {
+        "general-work"
+    };
+    ContextCapsule {
+        id: id.to_string(),
+        task_type: id.trim_end_matches("-work").to_string(),
+        summary: format!("Compact context capsule for {id}."),
+    }
+}
+
+pub(super) fn is_source_path(path: &str) -> bool {
+    let lower = path.to_ascii_lowercase();
+    [
+        ".rs", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py", ".go", ".swift", ".kt",
+        ".java", ".c", ".cc", ".cpp", ".h", ".hpp", ".rb", ".php", ".cs", ".sh",
+    ]
+    .iter()
+    .any(|extension| lower.ends_with(extension))
+}
+
+fn is_context_noise(path: &str) -> bool {
+    matches!(path, ".naome/task-state.json" | ".naome/manifest.json") || path.contains("/native/")
+}

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

@@ -0,0 +1,134 @@
+use std::path::Path;
+
+use crate::{git, models::NaomeError};
+
+use super::helpers::{capsule_for_paths, context_item, is_source_path, normalize_paths};
+use super::types::{ContextBudgetLedger, ContextItem, ContextSelection};
+
+const MAX_CONTEXT_FILES: usize = 12;
+
+pub fn select_context_for_changed_paths(root: &Path) -> Result<ContextSelection, NaomeError> {
+    let paths = git::changed_paths(root)?;
+    Ok(selection_for_paths(root, "changed", paths))
+}
+
+pub fn select_context_for_prompt(
+    root: &Path,
+    prompt: impl AsRef<str>,
+) -> Result<ContextSelection, NaomeError> {
+    Ok(selection_for_paths(
+        root,
+        "prompt",
+        mentioned_paths(prompt.as_ref()),
+    ))
+}
+
+fn selection_for_paths(root: &Path, mode: &str, paths: Vec<String>) -> ContextSelection {
+    let target_paths = normalize_paths(paths);
+    let capsule = capsule_for_paths(&target_paths);
+    let mut required_context = target_paths
+        .iter()
+        .take(MAX_CONTEXT_FILES)
+        .map(|path| context_item(root, path, "changed_path", "required"))
+        .collect::<Vec<_>>();
+    if required_context.is_empty() {
+        required_context.push(context_item(
+            root,
+            ".naome/verification.json",
+            "minimal_harness_policy",
+            "required",
+        ));
+    }
+
+    let avoided_files = target_paths.len().saturating_sub(required_context.len());
+    ContextSelection {
+        schema: "naome.context-selection.v1".to_string(),
+        mode: mode.to_string(),
+        optional_context: optional_context(root, &capsule.id),
+        forbidden_context: forbidden_context(),
+        commands: commands_for_paths(&target_paths),
+        budget_ledger: budget_ledger(&required_context, avoided_files),
+        notes: vec![
+            "Read requiredContext first; read optionalContext only when the task is blocked without it.".to_string(),
+            "Use path-scoped checks during implementation and keep the final changed gate before completion.".to_string(),
+        ],
+        capsule,
+        required_context,
+    }
+}
+
+fn optional_context(root: &Path, capsule_id: &str) -> Vec<ContextItem> {
+    let candidates = match capsule_id {
+        "quality-work" => vec!["docs/naome/repository-quality.md", "docs/naome/testing.md"],
+        "routing-work" => vec!["docs/naome/agent-workflow.md", "docs/naome/testing.md"],
+        "docs-work" => vec!["docs/naome/index.md", "docs/naome/testing.md"],
+        _ => vec!["docs/naome/repository-quality.md", "docs/naome/testing.md"],
+    };
+    candidates
+        .into_iter()
+        .filter(|path| root.join(path).is_file())
+        .map(|path| context_item(root, path, "optional_capsule_context", "optional"))
+        .collect()
+}
+
+fn budget_ledger(required_context: &[ContextItem], avoided_files: usize) -> ContextBudgetLedger {
+    let estimated_lines = required_context
+        .iter()
+        .map(|item| item.estimated_lines)
+        .sum::<usize>();
+    ContextBudgetLedger {
+        max_context_files: MAX_CONTEXT_FILES,
+        selected_files: required_context.len(),
+        avoided_files,
+        estimated_lines,
+        estimated_tokens: estimated_lines.saturating_mul(8),
+        reason_codes: if avoided_files > 0 {
+            vec!["context_file_budget_reached".to_string()]
+        } else {
+            Vec::new()
+        },
+    }
+}
+
+fn commands_for_paths(paths: &[String]) -> Vec<String> {
+    let mut commands = paths
+        .iter()
+        .filter(|path| is_source_path(path))
+        .take(6)
+        .map(|path| format!("node .naome/bin/naome.js quality check --path {path}"))
+        .collect::<Vec<_>>();
+    commands.push("node .naome/bin/naome.js quality check --changed".to_string());
+    commands.push("git diff --check".to_string());
+    commands.sort();
+    commands.dedup();
+    commands
+}
+
+fn forbidden_context() -> Vec<String> {
+    [
+        ".git/**",
+        ".naome/archive/**",
+        ".naome/cache/**",
+        "node_modules/**",
+        "target/**",
+        "dist/**",
+        "build/**",
+    ]
+    .into_iter()
+    .map(str::to_string)
+    .collect()
+}
+
+fn mentioned_paths(prompt: &str) -> Vec<String> {
+    prompt
+        .split_whitespace()
+        .map(|token| {
+            token.trim_matches(|ch: char| {
+                matches!(ch, '"' | '\'' | '`' | ',' | ';' | ':' | ')' | '(')
+            })
+        })
+        .filter(|token| token.contains('/') || is_source_path(token) || token.ends_with(".md"))
+        .filter(|token| !token.starts_with('-') && !token.starts_with("http"))
+        .map(|token| token.trim_start_matches("./").replace('\\', "/"))
+        .collect()
+}

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

@@ -0,0 +1,43 @@
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextSelection {
+    pub schema: String,
+    pub mode: String,
+    pub capsule: ContextCapsule,
+    pub required_context: Vec<ContextItem>,
+    pub optional_context: Vec<ContextItem>,
+    pub forbidden_context: Vec<String>,
+    pub commands: Vec<String>,
+    pub budget_ledger: ContextBudgetLedger,
+    pub notes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextCapsule {
+    pub id: String,
+    pub summary: String,
+    pub task_type: String,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextItem {
+    pub path: String,
+    pub reason: String,
+    pub priority: String,
+    pub estimated_lines: usize,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextBudgetLedger {
+    pub max_context_files: usize,
+    pub selected_files: usize,
+    pub avoided_files: usize,
+    pub estimated_lines: usize,
+    pub estimated_tokens: usize,
+    pub reason_codes: Vec<String>,
+}

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

@@ -0,0 +1,6 @@
+mod helpers;
+mod select;
+mod types;
+
+pub use select::{select_context_for_changed_paths, select_context_for_prompt};
+pub use types::{ContextBudgetLedger, ContextCapsule, ContextItem, ContextSelection};

package/crates/naome-core/src/decision/states.rs

@@ -161,5 +161,5 @@ fn has_completed_task_owned_paths(task: Option<&TaskDecision>, changed_paths: &[
 }
 
 fn is_control_state_path(path: &str) -> bool {
-    path == ".naome/task-state.json"
+    path == ".naome/task-state.json" || path.starts_with(".naome/tasks/")
 }

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

@@ -1,7 +1,10 @@
 use std::path::Path;
 
+use serde_json::Value;
+
 use crate::git;
 use crate::models::{CheckDecision, Decision, NaomeError, TaskDecision};
+use crate::task_ledger::read_task_state_projection;
 
 mod checks;
 mod idle;
@@ -40,7 +43,7 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
         return Ok(decision);
     }
 
-    let task_state = read_json(root, ".naome/task-state.json")?;
+    let task_state = read_task_state_projection(root)?.unwrap_or(Value::Null);
     if let Some(decision) = setup_block_decision(root, &changed_paths, &harness_health)? {
         return Ok(decision);
     }

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

@@ -10,6 +10,8 @@ pub const MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/index.md",
     "docs/naome/first-run.md",
     "docs/naome/agent-workflow.md",
+    "docs/naome/context-economy.md",
+    "docs/naome/task-ledger.md",
     "docs/naome/execution.md",
     "docs/naome/upgrade.md",
 ];
@@ -21,12 +23,14 @@ pub const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
+    ".naome/repository-model.json",
     ".naome/repository-quality.json",
     ".naome/repository-structure.json",
     ".naome/repository-quality-baseline.json",
     "docs/naome/architecture.md",
     "docs/naome/decisions.md",
     "docs/naome/repo-profile.md",
+    "docs/naome/repository-model.md",
     "docs/naome/repository-quality.md",
     "docs/naome/repository-structure.md",
     "docs/naome/security.md",
@@ -42,6 +46,8 @@ pub const LOCAL_ONLY_MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/index.md",
     "docs/naome/first-run.md",
     "docs/naome/agent-workflow.md",
+    "docs/naome/context-economy.md",
+    "docs/naome/task-ledger.md",
     "docs/naome/execution.md",
     "docs/naome/upgrade.md",
 ];
@@ -54,6 +60,16 @@ pub const LOCAL_NATIVE_BINARY_PATHS: &[&str] = &[
     ".naome/task-journal.jsonl",
 ];
 
+pub const OPTIONAL_CODEX_HOOK_PATHS: &[&str] = &[
+    ".codex/config.toml",
+    ".codex/hooks.json",
+    ".naome/bin/codex-hook.js",
+    ".naome/bin/codex-hook-io.js",
+    ".naome/bin/codex-hook-policy.js",
+    ".naome/bin/codex-hook-runtime.js",
+    "docs/naome/codex-hooks.md",
+];
+
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct InstallPlan {
@@ -62,6 +78,7 @@ pub struct InstallPlan {
     pub machine_owned: Vec<&'static str>,
     pub project_owned: Vec<&'static str>,
     pub local_only_machine_owned: Vec<&'static str>,
+    pub optional_codex_hook_paths: Vec<&'static str>,
     pub gitignore_entries: Vec<&'static str>,
     pub git_exclude_entries: Vec<&'static str>,
     pub git_untrack_paths: Vec<&'static str>,
@@ -87,6 +104,7 @@ pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
         machine_owned: MACHINE_OWNED_PATHS.to_vec(),
         project_owned: PROJECT_OWNED_PATHS.to_vec(),
         local_only_machine_owned: LOCAL_ONLY_MACHINE_OWNED_PATHS.to_vec(),
+        optional_codex_hook_paths: OPTIONAL_CODEX_HOOK_PATHS.to_vec(),
         gitignore_entries,
         git_exclude_entries,
         git_untrack_paths,

package/crates/naome-core/src/intent/resolver_catalog/active.rs

@@ -0,0 +1,38 @@
+use super::super::resolver_shared::Policy;
+
+pub(crate) const POLICY_ACTIVE_BLOCKED: Policy = (
+    "block_unowned_diff",
+    false,
+    "The active task is blocked by out-of-scope changes.",
+    "Resolve the scope blocker before interpreting new work.",
+);
+pub(crate) const POLICY_ACTIVE_CANCEL: Policy = (
+    "cancel_current_task",
+    false,
+    "The prompt asks to cancel the active task.",
+    "Cancel or review the active task before starting another.",
+);
+pub(crate) const POLICY_ACTIVE_CONTINUE: Policy = (
+    "continue_current_task",
+    true,
+    "A task is active and the prompt appears to continue or finish it.",
+    "Continue the current task and keep proof current.",
+);
+pub(crate) const POLICY_ACTIVE_NEW_BLOCK: Policy = (
+    "block_ambiguous_intent",
+    false,
+    "A task is already active and the prompt appears to ask for a distinct new goal.",
+    "Complete, revise, or cancel the active task before starting another.",
+);
+pub(crate) const POLICY_ACTIVE_NO_COMMIT: Policy = (
+    "continue_current_task_without_commit",
+    true,
+    "A task is active and the prompt blocks committing.",
+    "Continue the active task without baselining.",
+);
+pub(crate) const POLICY_ACTIVE_REVIEW: Policy = (
+    "review_current_task_diff",
+    false,
+    "The prompt asks to review the active task diff.",
+    "Review the active task before mutating it further.",
+);