@lamentis/naome 1.2.1 → 1.3.1

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

@@ -1,8 +1,10 @@
 use std::path::Path;
 
 use naome_core::{
-    classify_mutations, 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 {
@@ -83,6 +108,26 @@ pub fn run_workflow_command(
     Ok(())
 }
 
+pub fn run_doctor(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let report = doctor_report(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else {
+        println!(
+            "NAOME doctor: {}",
+            if report.ok { "ok" } else { "attention needed" }
+        );
+        println!("{}", report.next_action);
+        if !report.recommended_check_ids.is_empty() {
+            println!(
+                "Recommended checks: {}",
+                report.recommended_check_ids.join(", ")
+            );
+        }
+    }
+    Ok(())
+}
+
 fn run_check_search(
     root: &Path,
     args: &[String],
@@ -134,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.2.1"
+version = "1.3.1"
 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/git.rs

@@ -63,12 +63,14 @@ fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
         return Vec::new();
     };
 
-    content
+    let mut patterns = content
         .lines()
         .map(str::trim)
         .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
         .map(normalize_ignore_pattern)
-        .collect()
+        .collect::<Vec<_>>();
+    patterns.push(".naome/cache/**".to_string());
+    patterns
 }
 
 fn normalize_ignore_pattern(pattern: &str) -> String {

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",
 ];
@@ -50,9 +56,20 @@ pub const LOCAL_NATIVE_BINARY_PATHS: &[&str] = &[
     ".naome/bin/naome-rust",
     ".naome/bin/naome-rust.exe",
     ".naome/archive",
+    ".naome/cache",
     ".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 {
@@ -61,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>,
@@ -72,6 +90,7 @@ pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
         "# NAOME local machine-owned harness files.",
         ".naome/archive/",
         ".naome/bin/naome-rust*",
+        ".naome/cache/",
         ".naome/task-journal.jsonl",
     ];
     git_exclude_entries.extend_from_slice(LOCAL_ONLY_MACHINE_OWNED_PATHS);
@@ -85,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/journal.rs

@@ -8,6 +8,7 @@ use serde::Serialize;
 use serde_json::Value;
 
 use crate::models::NaomeError;
+use crate::task_ledger::read_task_state_projection;
 use crate::task_state::canonical_proof_check_ids;
 
 const JOURNAL_PATH: &str = ".naome/task-journal.jsonl";
@@ -35,7 +36,7 @@ pub fn append_task_journal(
     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 task_state = read_task_state_projection(root)?.unwrap_or(Value::Null);
     let Some(active_task) = task_state
         .get("activeTask")
         .filter(|value| !value.is_null())
@@ -125,12 +126,6 @@ fn proof_summary(active_task: &Value) -> Vec<String> {
     canonical_proof_check_ids(active_task)
 }
 
-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)

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

@@ -1,3 +1,4 @@
+mod context;
 mod decision;
 mod git;
 mod harness_health;
@@ -7,12 +8,18 @@ mod journal;
 mod models;
 mod paths;
 mod quality;
+mod repository_model;
 mod route;
+mod task_ledger;
 mod task_state;
 mod verification;
 mod verification_contract;
 mod workflow;
 
+pub use context::{
+    select_context_for_changed_paths, select_context_for_prompt, ContextBudgetLedger,
+    ContextCapsule, ContextItem, ContextSelection,
+};
 pub use decision::{evaluate_decision, format_decision, EvaluationOptions};
 pub use harness_health::{validate_harness_health, HarnessHealthOptions};
 pub use install_plan::{install_plan, InstallPlan};
@@ -21,12 +28,27 @@ pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence}
 pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
 pub use quality::{
-    check_repository_quality, explain_repository_structure, init_repository_quality,
-    plan_quality_cleanup, route_quality_cleanup, QualityCleanupPlan, QualityCleanupRoute,
-    QualityCleanupTask, QualityInitResult, QualityMode, QualityReport, QualitySummary,
-    QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig, StructurePathExplanation,
+    check_repository_quality, check_repository_quality_paths, check_semantic_legacy,
+    check_semantic_legacy_paths,
+    clear_quality_cache, explain_repository_structure, init_repository_quality,
+    init_repository_quality_with_mode, plan_quality_cleanup, quality_cache_status,
+    reconcile_repository_quality, route_quality_cleanup, semantic_route_for_finding,
+    QualityCacheStatus, QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask,
+    QualityInitMode, QualityInitResult, QualityMode, QualityReconcileReport, QualityReport,
+    QualitySummary, QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig,
+    SemanticFinding, SemanticReport, StructurePathExplanation,
+};
+pub use repository_model::{
+    explain_repository_model_path, refresh_repository_model, repository_model_drift,
+    RepositoryEntity, RepositoryFact, RepositoryModel, RepositoryModelDrift,
+    RepositoryModelRefresh, RepositoryPathExplanation, RepositoryPathFact, RepositoryRoot,
+    RepositoryVerificationCheck, RepositoryWorldSignal,
 };
 pub use route::{evaluate_route, explain_route, ExplainDecision, RouteDecision, RouteOptions};
+pub use task_ledger::{
+    migrate_task_state_to_ledger, read_task_state_projection, render_task_state_from_ledger,
+    TaskLedgerProjection, TaskLedgerStatus,
+};
 pub use task_state::{
     completed_task_commit_paths, validate_task_state, TaskStateMode, TaskStateOptions,
     TaskStateReport,
@@ -34,8 +56,13 @@ pub use task_state::{
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;
 pub use workflow::{
-    classify_mutations, refresh_integrity, safe_rg_args, summarize_command_output,
-    tracked_process_report, validate_read_boundaries, validate_search_command,
-    verification_phase_plan, CommandCheckResult, CommandOutputSummary, IntegrityRefreshReport,
-    MutationClassification, ProcessReport, ReadActivity, VerificationPhasePlan, WorkflowFinding,
+    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_read_boundaries,
+    validate_search_command, verification_phase_plan, AgentRunPlan, CapabilityGraph,
+    CapabilityRoot, CommandCheckResult, CommandOutputSummary, ContextDeltaReport, DecisionGate,
+    DoctorReport, DoctorSection, EditSessionWatchdog, ExecutionPlanLedger, ExecutionPlanStep,
+    IntegrityRefreshReport, MutationClassification, ProcessReport, ProofPlan, ReadActivity,
+    RepositoryCapability, RepositoryPolicySection, VerificationEdge, VerificationPhasePlan,
+    WorkflowFinding,
 };