@lamentis/naome 1.2.0 → 1.3.0

package/bin/naome.js

@@ -12,7 +12,7 @@ const packageVersion = packageMetadata.version;
 const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
 const args = process.argv.slice(2);
 const [command] = args;
-const helpCommands = "status [--json]|next [--json]|intent --prompt-file <path> [--json]|intent --prompt <text> [--json]|route --prompt-file <path> [--execute] [--json]|route --prompt <text> [--execute] [--json]|explain --prompt-file <path> [--json]|explain --prompt <text> [--json]|install|sync [--check-update]|update [--json] [--execute]|quality init [--json]|quality check --changed [--json]|quality report [--json]|cleanup plan [--json]|cleanup route --path <path> [--json]|refresh-integrity [--json]|workflow search-profile|check-search|phases|processes|mutations [--json]|commit -m \"type(scope): message\"".split("|");
+const helpCommands = "status [--json]|next [--json]|intent --prompt-file <path> [--json]|intent --prompt <text> [--json]|route --prompt-file <path> [--execute] [--json]|route --prompt <text> [--execute] [--json]|explain --prompt-file <path> [--json]|explain --prompt <text> [--json]|doctor [--json]|install|sync [--check-update]|update [--json] [--execute]|quality init [--baseline|--deep-baseline] [--json]|quality check --changed [--include-scanned-paths] [--json]|quality report [--deep] [--include-scanned-paths] [--json]|quality cache status [--json]|quality cache clear|semantic report [--deep] [--json]|semantic check --changed [--json]|semantic route --finding <id> [--json]|semantic loop [--json]|structure report [--json]|structure explain --path <path> [--json]|cleanup plan [--json]|cleanup route --path <path> [--json]|refresh-integrity [--json]|workflow search-profile|check-search|phases|processes|mutations [--json]|commit -m \"type(scope): message\"".split("|");
 
 if (isHelpRequest(args)) {
   printHelp();
@@ -265,13 +265,19 @@ function runNativePackageCommand(args) {
 
 function ensureRepositoryQualityInitialized(nativeBinary, qualityConfigExisted) {
   const root = process.cwd();
-  if (qualityConfigExisted || !existsSync(join(root, ".naome"))) {
+  if (!existsSync(join(root, ".naome"))) {
     return;
   }
 
-  for (const path of repositoryQualityPaths(root)) {
-    if (existsSync(path)) {
-      unlinkSync(path);
+  if (qualityConfigExisted && repositoryQualitySupportFilesExist(root)) {
+    return;
+  }
+
+  if (!qualityConfigExisted) {
+    for (const path of repositoryQualityPaths(root)) {
+      if (existsSync(path)) {
+        unlinkSync(path);
+      }
     }
   }
 
@@ -294,6 +300,21 @@ function ensureRepositoryQualityInitialized(nativeBinary, qualityConfigExisted)
     }
     process.exit(result.status === null ? 1 : result.status);
   }
+
+  const output = result.stdout.trim();
+  if (output) {
+    try {
+      const init = JSON.parse(output);
+      if (init.configWritten || init.structureConfigWritten) {
+        console.log("repository quality policy initialized");
+      }
+      if (init.baselinePending) {
+        console.log("baseline pending: run naome quality init --baseline");
+      }
+    } catch (_error) {
+      console.log(output);
+    }
+  }
 }
 
 function repositoryQualityConfigPath(root) {
@@ -303,10 +324,18 @@ function repositoryQualityConfigPath(root) {
 function repositoryQualityPaths(root) {
   return [
     repositoryQualityConfigPath(root),
+    join(root, ".naome", "repository-structure.json"),
     join(root, ".naome", "repository-quality-baseline.json")
   ];
 }
 
+function repositoryQualitySupportFilesExist(root) {
+  return [
+    join(root, ".naome", "repository-structure.json"),
+    join(root, ".naome", "repository-quality-baseline.json")
+  ].every((path) => existsSync(path));
+}
+
 function resolveNativePackageBinary() {
   const candidates = [
     process.env.NAOME_NATIVE_BIN && resolve(process.cwd(), process.env.NAOME_NATIVE_BIN),

package/crates/naome-cli/Cargo.toml

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

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

@@ -3,11 +3,13 @@ use std::path::Path;
 use crate::check_commands::{run_harness_health, run_task_state, run_verification_contract};
 use crate::install_bridge::run_install_bridge;
 use crate::prompt_commands::{run_explain, run_intent, run_route};
-use crate::quality_commands::{run_cleanup_command, run_quality_command};
+use crate::quality_commands::{
+    run_cleanup_command, run_quality_command, run_semantic_command, run_structure_command,
+};
 use crate::simple_commands::{
     print_install_plan, run_commit_paths, run_journal_task, seed_verification,
 };
-use crate::workflow_commands::{run_refresh_integrity, run_workflow_command};
+use crate::workflow_commands::{run_doctor, run_refresh_integrity, run_workflow_command};
 
 pub fn dispatch_command(
     root: &Path,
@@ -19,7 +21,10 @@ pub fn dispatch_command(
         "install-plan" => print_install_plan(args)?,
         "seed-verification" => seed_verification(root)?,
         "refresh-integrity" => run_refresh_integrity(root, args)?,
+        "doctor" => run_doctor(root, args)?,
         "quality" => run_quality_command(root, args)?,
+        "semantic" => run_semantic_command(root, args)?,
+        "structure" => run_structure_command(root, args)?,
         "cleanup" => run_cleanup_command(root, args)?,
         "workflow" => run_workflow_command(root, args)?,
         "check-harness-health" => run_harness_health(root, args)?,

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

@@ -22,14 +22,23 @@ const HELP: &str = r#"Usage:
   naome route --prompt <text> [--execute] [--json]
   naome explain --prompt-file <path> [--json]
   naome explain --prompt <text> [--json]
+  naome doctor [--json]
   naome install [--package-root <path>] [--installer-js <path>]
   naome sync [--package-root <path>] [--installer-js <path>]
   naome install-plan [--harness-version <version>]
   naome seed-verification
   naome refresh-integrity [--root <path>] [--json]
-  naome quality init [--json]
-  naome quality check --changed [--json]
-  naome quality report [--json]
+  naome quality init [--baseline|--deep-baseline] [--json]
+  naome quality check --changed [--include-scanned-paths] [--json]
+  naome quality report [--deep] [--include-scanned-paths] [--json]
+  naome quality cache status [--json]
+  naome quality cache clear
+  naome semantic report [--deep] [--json]
+  naome semantic check --changed [--json]
+  naome semantic route --finding <id> [--json]
+  naome semantic loop [--json]
+  naome structure report [--json]
+  naome structure explain --path <path> [--json]
   naome cleanup plan [--json]
   naome cleanup route --path <path> [--json]
   naome workflow search-profile [--json]
@@ -41,6 +50,30 @@ const HELP: &str = r#"Usage:
   naome check-task-state [--root <path>] [--admission|--progress|--commit-gate|--push-gate] [--allow-missing-archive]
   naome validate-verification [--root <path>]"#;
 
+const PUBLIC_COMMANDS: &[&str] = &[
+    "status",
+    "next",
+    "intent",
+    "route",
+    "explain",
+    "doctor",
+    "journal-task",
+    "commit-paths",
+    "seed-verification",
+    "refresh-integrity",
+    "workflow",
+    "quality",
+    "semantic",
+    "structure",
+    "cleanup",
+    "install-plan",
+    "install",
+    "sync",
+    "check-harness-health",
+    "check-task-state",
+    "validate-verification",
+];
+
 fn main() {
     if let Err(error) = run() {
         eprintln!("NAOME: {error}");
@@ -60,25 +93,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    if command != "status"
-        && command != "next"
-        && command != "intent"
-        && command != "route"
-        && command != "explain"
-        && command != "journal-task"
-        && command != "commit-paths"
-        && command != "seed-verification"
-        && command != "refresh-integrity"
-        && command != "workflow"
-        && command != "quality"
-        && command != "cleanup"
-        && command != "install-plan"
-        && command != "install"
-        && command != "sync"
-        && command != "check-harness-health"
-        && command != "check-task-state"
-        && command != "validate-verification"
-    {
+    if !PUBLIC_COMMANDS.contains(&command) {
         print_help();
         return Err(format!("unknown command: {command}").into());
     }

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

@@ -1,7 +1,9 @@
 use std::path::Path;
 
 use naome_core::{
-    check_repository_quality, init_repository_quality, plan_quality_cleanup, route_quality_cleanup,
+    check_repository_quality, check_semantic_legacy, clear_quality_cache,
+    explain_repository_structure, init_repository_quality_with_mode, plan_quality_cleanup,
+    quality_cache_status, route_quality_cleanup, semantic_route_for_finding, QualityInitMode,
     QualityMode,
 };
 
@@ -9,22 +11,28 @@ use crate::cli_args::option_value;
 
 pub fn run_quality_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 quality requires init, check, or report.".into());
+        return Err("naome quality requires init, check, report, or cache.".into());
     };
     let json = args.iter().any(|arg| arg == "--json");
 
     match subcommand {
         "init" => {
-            let result = init_repository_quality(root)?;
+            let result = init_repository_quality_with_mode(root, quality_init_mode(args)?)?;
             if json {
                 println!("{}", serde_json::to_string_pretty(&result)?);
             } else {
                 println!("NAOME repository quality initialized.");
-                println!("Baseline violations: {}", result.baseline_violations);
+                if result.baseline_pending {
+                    println!("repository quality policy initialized");
+                    println!("baseline pending: run naome quality init --baseline");
+                } else {
+                    println!("Baseline violations: {}", result.baseline_violations);
+                }
             }
         }
         "check" => run_quality_check(root, args, json)?,
-        "report" => run_quality_report(root, json)?,
+        "report" => run_quality_report(root, args, json)?,
+        "cache" => run_quality_cache(root, args, json)?,
         _ => return Err(format!("unknown naome quality command: {subcommand}").into()),
     }
     Ok(())
@@ -44,6 +52,42 @@ pub fn run_cleanup_command(root: &Path, args: &[String]) -> Result<(), Box<dyn s
     Ok(())
 }
 
+pub fn run_structure_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 structure requires report or explain.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "report" => run_structure_report(root, json)?,
+        "explain" => run_structure_explain(root, args, json)?,
+        _ => return Err(format!("unknown naome structure command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+pub fn run_semantic_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 semantic requires report, check, route, or loop.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "report" => run_semantic_report(root, args, json)?,
+        "check" => run_semantic_check(root, args, json)?,
+        "route" => run_semantic_route(root, args, json)?,
+        "loop" => run_semantic_loop(root, json)?,
+        _ => return Err(format!("unknown naome semantic command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
 fn run_quality_check(
     root: &Path,
     args: &[String],
@@ -52,9 +96,9 @@ fn run_quality_check(
     if !args.iter().any(|arg| arg == "--changed") {
         return Err("naome quality check requires --changed.".into());
     }
-    let report = check_repository_quality(root, QualityMode::Changed)?;
+    let report = check_repository_quality(root, QualityMode::ChangedFast)?;
     if json {
-        println!("{}", serde_json::to_string_pretty(&report)?);
+        println!("{}", report_json(&report, args)?);
     } else if report.ok {
         println!("NAOME repository quality OK.");
     } else {
@@ -72,10 +116,19 @@ fn run_quality_check(
     Ok(())
 }
 
-fn run_quality_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
-    let report = check_repository_quality(root, QualityMode::Report)?;
+fn run_quality_report(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mode = if args.iter().any(|arg| arg == "--deep") {
+        QualityMode::DeepReport
+    } else {
+        QualityMode::Report
+    };
+    let report = check_repository_quality(root, mode)?;
     if json {
-        println!("{}", serde_json::to_string_pretty(&report)?);
+        println!("{}", report_json(&report, args)?);
     } else if report.violations.is_empty() {
         println!("NAOME repository quality report: no debt found.");
     } else {
@@ -91,6 +144,32 @@ fn run_quality_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error:
     Ok(())
 }
 
+fn run_quality_cache(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(action) = args.get(2).map(String::as_str) else {
+        return Err("naome quality cache requires status or clear.".into());
+    };
+    let status = match action {
+        "status" => quality_cache_status(root)?,
+        "clear" => clear_quality_cache(root)?,
+        _ => return Err(format!("unknown naome quality cache command: {action}").into()),
+    };
+    if json {
+        println!("{}", serde_json::to_string_pretty(&status)?);
+    } else if action == "clear" {
+        println!("NAOME quality cache cleared.");
+    } else {
+        println!(
+            "NAOME quality cache: {} entrie(s), {} byte(s).",
+            status.entry_count, status.bytes
+        );
+    }
+    Ok(())
+}
+
 fn run_cleanup_plan(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
     let plan = plan_quality_cleanup(root)?;
     if json {
@@ -132,6 +211,234 @@ fn run_cleanup_route(
     Ok(())
 }
 
+fn run_structure_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let mut report = check_repository_quality(root, QualityMode::Report)?;
+    report
+        .violations
+        .retain(|violation| is_structure_check(&violation.check_id));
+    report.summary.violation_count = report.violations.len();
+    report.summary.blocking_violation_count = report.violations.len();
+    report.summary.baseline_violation_count = report
+        .violations
+        .iter()
+        .filter(|violation| violation.baseline)
+        .count();
+    report.ok = report.violations.is_empty();
+    report.schema = "naome.repository-structure-report.v1".to_string();
+
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.violations.is_empty() {
+        println!("NAOME repository structure report: no debt found.");
+    } else {
+        println!(
+            "NAOME repository structure report: {} violation(s).",
+            report.violations.len()
+        );
+        for violation in report.violations.iter().take(20) {
+            print_quality_violation(violation);
+        }
+    }
+    Ok(())
+}
+
+fn run_structure_explain(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(path) = option_value(args, "--path") else {
+        return Err("naome structure explain requires --path <path>.".into());
+    };
+    let explanation = explain_repository_structure(root, path)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&explanation)?);
+    } else {
+        println!(
+            "{} role={} layer={} directory={}",
+            explanation.path, explanation.role, explanation.layer, explanation.directory
+        );
+        if let Some(language) = explanation.language {
+            println!("language={language}");
+        }
+        if let Some(module) = explanation.module {
+            println!("module={module}");
+        }
+    }
+    Ok(())
+}
+
+fn run_semantic_report(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mode = if args.iter().any(|arg| arg == "--deep") {
+        QualityMode::DeepReport
+    } else {
+        QualityMode::Report
+    };
+    let report = check_semantic_legacy(root, mode)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.findings.is_empty() {
+        println!("NAOME semantic legacy report: no cleanup candidates found.");
+    } else {
+        println!(
+            "NAOME semantic legacy report: {} finding(s).",
+            report.findings.len()
+        );
+        for finding in report.findings.iter().take(20) {
+            println!(
+                "- {} {}: {}",
+                finding.kind, finding.occurrences[0].path, finding.summary
+            );
+        }
+    }
+    Ok(())
+}
+
+fn run_semantic_check(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !args.iter().any(|arg| arg == "--changed") {
+        return Err("naome semantic check requires --changed.".into());
+    }
+    let report = check_semantic_legacy(root, QualityMode::ChangedFast)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.ok {
+        println!("NAOME semantic legacy check OK.");
+    } else {
+        eprintln!(
+            "NAOME semantic legacy check failed with {} finding(s).",
+            report.findings.len()
+        );
+        for finding in report.findings.iter().take(20) {
+            eprintln!(
+                "- {} {}: {}",
+                finding.kind, finding.occurrences[0].path, finding.summary
+            );
+        }
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_semantic_route(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(finding_id) = option_value(args, "--finding") else {
+        return Err("naome semantic route requires --finding <id>.".into());
+    };
+    let report = check_semantic_legacy(root, QualityMode::DeepReport)?;
+    let Some(finding) = semantic_route_for_finding(&report, &finding_id) else {
+        return Err(format!("semantic finding not found: {finding_id}").into());
+    };
+    if json {
+        println!("{}", serde_json::to_string_pretty(&finding)?);
+    } else {
+        println!("NAOME semantic cleanup route for {}", finding.id);
+        println!("{}", finding.cleanup_route.intent);
+        for instruction in &finding.cleanup_route.agent_instructions {
+            println!("- {instruction}");
+        }
+        let paths = finding
+            .occurrences
+            .iter()
+            .map(|occurrence| occurrence.path.as_str())
+            .collect::<Vec<_>>()
+            .join(", ");
+        println!("Affected paths: {paths}");
+    }
+    Ok(())
+}
+
+fn run_semantic_loop(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let changed = check_semantic_legacy(root, QualityMode::ChangedFast)?;
+    let (action, finding) = if let Some(finding) = changed.findings.first().cloned() {
+        ("cleanup_changed_finding", Some(finding))
+    } else {
+        let report = check_semantic_legacy(root, QualityMode::Report)?;
+        if let Some(finding) = report.findings.first().cloned() {
+            ("report_legacy_debt", Some(finding))
+        } else {
+            ("complete", None)
+        }
+    };
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.semantic-loop.v1",
+                "ok": action != "cleanup_changed_finding",
+                "action": action,
+                "finding": finding
+            }))?
+        );
+    } else {
+        match finding {
+            Some(finding) => {
+                println!("NAOME semantic loop action: {action}");
+                println!("{} {}", finding.kind, finding.id);
+                println!("{}", finding.summary);
+                println!("Run: naome semantic route --finding {} --json", finding.id);
+            }
+            None => println!("NAOME semantic loop complete: no semantic cleanup candidates found."),
+        }
+    }
+    Ok(())
+}
+
+fn is_structure_check(check_id: &str) -> bool {
+    matches!(
+        check_id,
+        "directory-role-mixing"
+            | "misplaced-file-role"
+            | "root-file-sprawl"
+            | "dumping-ground-directory"
+            | "directory-size"
+            | "path-depth"
+            | "case-collision"
+            | "test-source-pairing"
+    )
+}
+
+fn quality_init_mode(args: &[String]) -> Result<QualityInitMode, Box<dyn std::error::Error>> {
+    let baseline = args.iter().any(|arg| arg == "--baseline");
+    let deep_baseline = args.iter().any(|arg| arg == "--deep-baseline");
+    if baseline && deep_baseline {
+        return Err("naome quality init accepts only one baseline mode.".into());
+    }
+    Ok(if deep_baseline {
+        QualityInitMode::DeepBaseline
+    } else if baseline {
+        QualityInitMode::Baseline
+    } else {
+        QualityInitMode::SeedOnly
+    })
+}
+
+fn report_json(
+    report: &naome_core::QualityReport,
+    args: &[String],
+) -> Result<String, Box<dyn std::error::Error>> {
+    let mut value = serde_json::to_value(report)?;
+    if !args.iter().any(|arg| arg == "--include-scanned-paths") {
+        if let Some(object) = value.as_object_mut() {
+            object.remove("scannedPaths");
+        }
+    }
+    Ok(serde_json::to_string_pretty(&value)?)
+}
+
 fn print_quality_violation(violation: &naome_core::QualityViolation) {
     let location = violation
         .line

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

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use naome_core::{
-    classify_mutations, refresh_integrity, safe_rg_args, tracked_process_report,
+    classify_mutations, doctor_report, refresh_integrity, safe_rg_args, tracked_process_report,
     validate_search_command, verification_phase_plan,
 };
 
@@ -83,6 +83,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],

package/crates/naome-core/Cargo.toml

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

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

@@ -0,0 +1,64 @@
+use std::ffi::OsString;
+use std::path::Path;
+use std::process::Command;
+
+use crate::models::{CheckDecision, NaomeError};
+
+pub(super) fn run_node_check(
+    root: &Path,
+    script: &str,
+    args: &[&str],
+) -> Result<CheckDecision, NaomeError> {
+    let mut command_args = vec![script.to_string()];
+    command_args.extend(args.iter().map(ToString::to_string));
+    let node_bin = std::env::var_os("NAOME_NODE_BIN").unwrap_or_else(|| OsString::from("node"));
+    let output = Command::new(&node_bin)
+        .args(&command_args)
+        .current_dir(root)
+        .output()?;
+    let mut combined = String::new();
+    combined.push_str(&String::from_utf8_lossy(&output.stdout));
+    combined.push_str(&String::from_utf8_lossy(&output.stderr));
+
+    Ok(CheckDecision {
+        command: format!(
+            "{} {}{}",
+            node_bin.to_string_lossy(),
+            script,
+            if args.is_empty() {
+                String::new()
+            } else {
+                format!(" {}", args.join(" "))
+            }
+        ),
+        exit_code: output.status.code(),
+        ok: output.status.success(),
+        output: combined.trim().to_string(),
+    })
+}
+
+pub(super) fn extract_known_actions(output: &str) -> Vec<&'static str> {
+    const KNOWN: [&str; 11] = [
+        "commit_task_baseline",
+        "review_task_diff",
+        "request_task_changes",
+        "cancel_task_changes",
+        "commit_upgrade_baseline",
+        "review_diff_first",
+        "cancel_upgrade_baseline",
+        "run_first_run_protocol",
+        "run_upgrade_protocol",
+        "review_unowned_diff",
+        "create_task",
+    ];
+
+    let actions: Vec<&'static str> = KNOWN
+        .into_iter()
+        .filter(|action| output.contains(action))
+        .collect();
+    if actions.is_empty() {
+        vec!["review_task_admission"]
+    } else {
+        actions
+    }
+}