@lamentis/naome 1.0.2 → 1.1.1

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.0.2"
+version = "1.1.1"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.0.2"
+version = "1.1.1"
 dependencies = [
  "serde",
  "serde_json",

package/README.md

@@ -17,4 +17,11 @@ Set up a repository:
 naome sync
 ```
 
-Then paste the printed first-run prompt into your coding agent. Use `naome status`, `naome next`, and `naome commit` to inspect state, choose the next safe action, and baseline completed work.
+Keep the CLI current before refreshing an existing repo:
+
+```sh
+naome update
+naome sync
+```
+
+Then paste the printed first-run prompt into your coding agent. Use `naome status`, `naome next`, `naome route`, and `naome commit` to inspect state, route natural-language follow-ups, choose the next safe action, and baseline completed work.

package/bin/naome-node.js

@@ -58,7 +58,8 @@ Then read .naome/upgrade-state.json, .naome/task-state.json, and docs/naome/exec
 Run node .naome/bin/check-harness-health.js before feature work.
 If initialized is false, follow docs/naome/first-run.md.
 Do not begin feature work until NAOME intake is complete.
-After intake, ask the user to commit or clear NAOME changes, then run node .naome/bin/check-task-state.js --admission before accepting feature work.`;
+After intake, save the user's next natural-language request to a temporary prompt file, then run node .naome/bin/naome.js route --prompt-file <path> --execute --json.
+Follow userMessage, humanOptions, requiredContext, and canCreateTask from the route output before creating the requested task.`;
 
 let summaryTitle = "NAOME intake harness installed";
 let nextStepPrompt = firstRunPrompt;
@@ -512,6 +513,7 @@ async function runFreshInstall() {
   patchInstalledMachineOwnedIntegrity();
   ensureBuiltInVerificationChecks();
   patchManifestDate();
+  ensureCompleteUpgradeState(null);
   ensureArchiveDirectory();
   takeoverExistingAgents();
   ensureLocalOnlySourceControlBoundary();
@@ -524,6 +526,7 @@ function runExistingInstall(existingInstall) {
     printError("This repository already uses a newer NAOME harness.");
     console.error(`Installed: v${existingInstall.version}`);
     console.error(`Package:   v${packageVersion}`);
+    console.error("Run `naome update`, then rerun `naome sync` from the repository root.");
     process.exit(1);
   }
 

package/bin/naome.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const packageMetadata = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+const packageName = packageMetadata.name;
+const packageVersion = packageMetadata.version;
 const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
 const args = process.argv.slice(2);
 const [command] = args;
@@ -15,8 +18,16 @@ if (isHelpRequest(args)) {
   process.exit(0);
 }
 
+if (command === "update") {
+  runUpdateCommand(args.slice(1));
+}
+
 if (command === "install" || command === "sync") {
-  runNativePackageCommand(args);
+  if (args.includes("--check-update")) {
+    requireCurrentCliBeforeSync();
+  }
+
+  runNativePackageCommand(args.filter((arg) => arg !== "--check-update"));
 }
 
 const commandPath = findHarnessCommand(process.cwd());
@@ -42,11 +53,195 @@ function printHelp() {
   console.log("Usage:");
   console.log("  naome status [--json]");
   console.log("  naome next [--json]");
+  console.log("  naome intent --prompt-file <path> [--json]");
+  console.log("  naome intent --prompt <text> [--json]");
+  console.log("  naome route --prompt-file <path> [--execute] [--json]");
+  console.log("  naome route --prompt <text> [--execute] [--json]");
+  console.log("  naome explain --prompt-file <path> [--json]");
+  console.log("  naome explain --prompt <text> [--json]");
   console.log("  naome install");
-  console.log("  naome sync");
+  console.log("  naome sync [--check-update]");
+  console.log("  naome update [--json] [--execute]");
   console.log("  naome commit -m \"type(scope): message\"");
 }
 
+function runUpdateCommand(commandArgs) {
+  const json = commandArgs.includes("--json");
+  const execute = commandArgs.includes("--execute");
+
+  if (json && execute) {
+    console.error("NAOME: update --execute does not support --json output.");
+    process.exit(1);
+  }
+
+  const update = getUpdateState();
+  if (!update.ok) {
+    if (json) {
+      console.log(JSON.stringify(formatUpdateState(update), null, 2));
+    } else {
+      console.error("NAOME CLI update check failed.");
+      console.error(update.error);
+    }
+    process.exit(1);
+  }
+
+  if (!execute) {
+    if (json) {
+      console.log(JSON.stringify(formatUpdateState(update), null, 2));
+    } else if (update.outdated) {
+      printUpdateInstructions(update);
+    } else {
+      console.log(`NAOME CLI is current: v${update.currentVersion}.`);
+    }
+    process.exit(0);
+  }
+
+  if (!update.outdated) {
+    console.log(`NAOME CLI is current: v${update.currentVersion}.`);
+    process.exit(0);
+  }
+
+  printUpdateInstructions(update);
+  const result = spawnSync("npm", ["install", "-g", `${packageName}@latest`, "--force"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "inherit"
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status === null ? 1 : result.status);
+  }
+
+  console.log("NAOME CLI updated. Run `naome sync` from the repository root.");
+  process.exit(0);
+}
+
+function requireCurrentCliBeforeSync() {
+  const update = getUpdateState();
+
+  if (!update.ok) {
+    console.error("NAOME CLI update check failed.");
+    console.error(update.error);
+    process.exit(1);
+  }
+
+  if (!update.outdated) {
+    return;
+  }
+
+  console.error("NAOME CLI update required before sync.");
+  console.error(`Installed CLI: v${update.currentVersion}`);
+  console.error(`Latest CLI:    v${update.latestVersion}`);
+  console.error(`Run: ${update.installCommand}`);
+  console.error(`Then: ${update.nextCommand}`);
+  process.exit(1);
+}
+
+function getUpdateState() {
+  const latest = getLatestPackageVersion();
+  if (!latest.ok) {
+    return {
+      ok: false,
+      packageName,
+      currentVersion: packageVersion,
+      latestVersion: null,
+      outdated: false,
+      installCommand: `npm install -g ${packageName}@latest --force`,
+      nextCommand: "naome sync",
+      error: latest.error
+    };
+  }
+
+  return {
+    ok: true,
+    packageName,
+    currentVersion: packageVersion,
+    latestVersion: latest.version,
+    outdated: compareVersions(packageVersion, latest.version) < 0,
+    installCommand: `npm install -g ${packageName}@latest --force`,
+    nextCommand: "naome sync"
+  };
+}
+
+function formatUpdateState(update) {
+  return {
+    schema: "naome.update.v1",
+    ok: update.ok,
+    packageName: update.packageName,
+    currentVersion: update.currentVersion,
+    latestVersion: update.latestVersion,
+    outdated: update.outdated,
+    installCommand: update.installCommand,
+    nextCommand: update.nextCommand,
+    ...(update.ok ? {} : { error: update.error })
+  };
+}
+
+function printUpdateInstructions(update) {
+  console.log(`NAOME update available: v${update.currentVersion} -> v${update.latestVersion}.`);
+  console.log(`Run: ${update.installCommand}`);
+  console.log(`Then: ${update.nextCommand}`);
+}
+
+function getLatestPackageVersion() {
+  if (process.env.NAOME_TEST_NPM_LATEST_VERSION) {
+    return parseLatestVersion(process.env.NAOME_TEST_NPM_LATEST_VERSION);
+  }
+
+  const result = spawnSync("npm", ["view", packageName, "version", "--json"], {
+    cwd: process.cwd(),
+    encoding: "utf8"
+  });
+
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: (result.stderr || result.stdout || "npm view failed").trim()
+    };
+  }
+
+  return parseLatestVersion(result.stdout);
+}
+
+function parseLatestVersion(value) {
+  let version = String(value).trim();
+  if (!version) {
+    return { ok: false, error: "npm returned an empty package version." };
+  }
+
+  try {
+    const parsed = JSON.parse(version);
+    if (typeof parsed === "string") {
+      version = parsed;
+    }
+  } catch {
+    // npm can also emit the bare version when registry tooling changes output.
+  }
+
+  if (!isSemver(version)) {
+    return { ok: false, error: `npm returned an invalid package version: ${version}` };
+  }
+
+  return { ok: true, version };
+}
+
+function compareVersions(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+
+  for (let index = 0; index < 3; index += 1) {
+    if (leftParts[index] !== rightParts[index]) {
+      return leftParts[index] < rightParts[index] ? -1 : 1;
+    }
+  }
+
+  return 0;
+}
+
+function isSemver(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
 function runNativePackageCommand(args) {
   const nativeBinary = resolveNativePackageBinary();
   if (!nativeBinary) {

package/crates/naome-cli/Cargo.toml

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

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

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
@@ -29,6 +30,11 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 
     if command != "status"
         && command != "next"
+        && command != "intent"
+        && command != "route"
+        && command != "explain"
+        && command != "journal-task"
+        && command != "commit-paths"
         && command != "seed-verification"
         && command != "install-plan"
         && command != "install"
@@ -163,6 +169,84 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
         std::process::exit(1);
     }
 
+    if command == "intent" {
+        let prompt = prompt_from_args(&args)?;
+        let intent = naome_core::evaluate_intent(&root, &prompt, EvaluationOptions::online())?;
+        if args.iter().any(|arg| arg == "--json") {
+            println!("{}", serde_json::to_string_pretty(&intent)?);
+        } else {
+            print!("{}", naome_core::format_intent(&intent));
+        }
+        return Ok(());
+    }
+
+    if command == "route" {
+        let prompt = prompt_from_args(&args)?;
+        let route = naome_core::evaluate_route(
+            &root,
+            &prompt,
+            naome_core::RouteOptions {
+                execute: args.iter().any(|arg| arg == "--execute"),
+                evaluation: EvaluationOptions::online(),
+            },
+        )?;
+        if args.iter().any(|arg| arg == "--json") {
+            println!("{}", serde_json::to_string_pretty(&route)?);
+        } else {
+            println!("{}", route.user_message);
+            if !route.human_options.is_empty() {
+                println!("Human options: {}", route.human_options.join(", "));
+            }
+        }
+        return Ok(());
+    }
+
+    if command == "explain" {
+        let prompt = prompt_from_args(&args)?;
+        let explain = naome_core::explain_route(&root, &prompt, EvaluationOptions::online())?;
+        if args.iter().any(|arg| arg == "--json") {
+            println!("{}", serde_json::to_string_pretty(&explain)?);
+        } else {
+            println!("NAOME explain: {}", explain.winning_rule);
+            println!("Repo state: {}", explain.repo_state);
+            println!("Prompt intent: {}", explain.prompt_intent);
+            println!("Would mutate: {}", explain.would_mutate);
+            println!("Message: {}", explain.user_message);
+            if !explain.human_options.is_empty() {
+                println!("Human options: {}", explain.human_options.join(", "));
+            }
+        }
+        return Ok(());
+    }
+
+    if command == "journal-task" {
+        let outcome =
+            option_value(&args, "--outcome").unwrap_or_else(|| "naome_commit_baseline".to_string());
+        let commit_before = option_value(&args, "--commit-before");
+        let commit_after = option_value(&args, "--commit-after");
+        let entry = naome_core::append_task_journal(&root, &outcome, commit_before, commit_after)?;
+        if args.iter().any(|arg| arg == "--json") {
+            println!("{}", serde_json::to_string_pretty(&entry)?);
+        } else if entry.is_some() {
+            println!("NAOME task journal updated.");
+        } else {
+            println!("NAOME task journal had no active task to record.");
+        }
+        return Ok(());
+    }
+
+    if command == "commit-paths" {
+        let paths = naome_core::completed_task_commit_paths(&root)?;
+        if args.iter().any(|arg| arg == "--json") {
+            println!("{}", serde_json::to_string_pretty(&paths)?);
+        } else {
+            for path in paths {
+                println!("{path}");
+            }
+        }
+        return Ok(());
+    }
+
     let decision = evaluate_decision(&root, EvaluationOptions::online())?;
 
     if args.iter().any(|arg| arg == "--json") {
@@ -175,10 +259,12 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn is_help_request(args: &[String]) -> bool {
-    matches!(args.first().map(String::as_str), Some("help" | "--help" | "-h"))
-        || args
-            .get(1)
-            .is_some_and(|arg| arg == "--help" || arg == "-h" || arg == "help")
+    matches!(
+        args.first().map(String::as_str),
+        Some("help" | "--help" | "-h")
+    ) || args
+        .get(1)
+        .is_some_and(|arg| arg == "--help" || arg == "-h" || arg == "help")
 }
 
 fn find_harness_root(start: &Path) -> Option<PathBuf> {
@@ -211,6 +297,12 @@ fn print_help() {
     println!("Usage:");
     println!("  naome status [--json]");
     println!("  naome next [--json]");
+    println!("  naome intent --prompt-file <path> [--json]");
+    println!("  naome intent --prompt <text> [--json]");
+    println!("  naome route --prompt-file <path> [--execute] [--json]");
+    println!("  naome route --prompt <text> [--execute] [--json]");
+    println!("  naome explain --prompt-file <path> [--json]");
+    println!("  naome explain --prompt <text> [--json]");
     println!("  naome install [--package-root <path>] [--installer-js <path>]");
     println!("  naome sync [--package-root <path>] [--installer-js <path>]");
     println!("  naome install-plan [--harness-version <version>]");
@@ -226,6 +318,18 @@ fn option_value(args: &[String], option: &str) -> Option<String> {
         .map(|window| window[1].clone())
 }
 
+fn prompt_from_args(args: &[String]) -> Result<String, Box<dyn std::error::Error>> {
+    if let Some(prompt_file) = option_value(args, "--prompt-file") {
+        return Ok(fs::read_to_string(prompt_file)?);
+    }
+
+    if let Some(prompt) = option_value(args, "--prompt") {
+        return Ok(prompt);
+    }
+
+    Err("naome prompt routing requires --prompt-file <path> or --prompt <text>.".into())
+}
+
 fn run_install_bridge(command: &str, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     let package_root = option_value(args, "--package-root")
         .map(PathBuf::from)
@@ -288,11 +392,7 @@ fn resolve_package_root_from_exe() -> Option<PathBuf> {
     let native_dir = platform_dir.parent()?;
     if native_dir.file_name().and_then(|value| value.to_str()) == Some("native") {
         let package_root = native_dir.parent()?.to_path_buf();
-        if package_root
-            .join("bin")
-            .join("naome-node.js")
-            .is_file()
-        {
+        if package_root.join("bin").join("naome-node.js").is_file() {
             return Some(package_root);
         }
     }
@@ -301,10 +401,7 @@ fn resolve_package_root_from_exe() -> Option<PathBuf> {
 
 fn resolve_package_root_from_cwd() -> Option<PathBuf> {
     let current = std::env::current_dir().ok()?;
-    for candidate in [
-        current.join("packages").join("naome"),
-        current.clone(),
-    ] {
+    for candidate in [current.join("packages").join("naome"), current.clone()] {
         if candidate.join("bin").join("naome-node.js").is_file() {
             return Some(candidate);
         }

package/crates/naome-core/Cargo.toml

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

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

@@ -1,5 +1,5 @@
-use std::fs;
 use std::ffi::OsString;
+use std::fs;
 use std::path::Path;
 use std::process::Command;
 
@@ -8,6 +8,7 @@ use serde_json::Value;
 use crate::git;
 use crate::models::{CheckDecision, Decision, NaomeError, TaskDecision};
 use crate::paths;
+use crate::task_state::harness_refresh_diff;
 
 #[derive(Debug, Clone, Copy)]
 pub struct EvaluationOptions {
@@ -111,18 +112,38 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
                 vec!["create_task"],
                 "Task admission is clear; create the next task before feature work.",
             )
-        } else {
+        } else if has_completed_task_owned_paths(task.as_ref(), &changed_paths) {
             Decision::new(
                 "completed_task_unbaselined",
                 true,
-                "A completed NAOME task still has an unbaselined diff.",
+                "A completed NAOME task is verified and waiting for the next routing decision.",
                 vec![
                     "commit_task_baseline",
                     "review_task_diff",
                     "request_task_changes",
                     "cancel_task_changes",
                 ],
-                "Choose how to resolve the completed task diff before accepting new feature work.",
+                "Run NAOME intent for the next natural-language request; deterministic policy can baseline a valid completed task automatically.",
+            )
+        } else if harness_refresh_diff(root)?.is_some_and(|diff| diff.unrelated_paths.is_empty()) {
+            Decision::new(
+                "harness_repair_unbaselined",
+                true,
+                "Machine-owned NAOME harness refresh files changed outside an active task.",
+                vec![
+                    "commit_upgrade_baseline",
+                    "review_diff_first",
+                    "cancel_upgrade_baseline",
+                ],
+                "Run NAOME intent for the next natural-language request; deterministic policy can baseline a pure harness refresh automatically.",
+            )
+        } else {
+            Decision::new(
+                "dirty_unowned_diff",
+                true,
+                "The completed NAOME task has been baselined, but unrelated user changes remain.",
+                vec!["review_unowned_diff"],
+                "Review the unrelated diff, or route a new task so NAOME can isolate task work without touching it.",
             )
         };
         decision.changed_paths = changed_paths;
@@ -131,6 +152,8 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
         decision.required_context = vec![
             "docs/naome/execution.md".to_string(),
             ".naome/task-state.json".to_string(),
+            "docs/naome/agent-workflow.md".to_string(),
+            "docs/naome/testing.md".to_string(),
         ];
         return Ok(decision);
     }
@@ -175,6 +198,7 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
         decision.required_context = vec![
             "docs/naome/execution.md".to_string(),
             ".naome/task-state.json".to_string(),
+            "docs/naome/testing.md".to_string(),
         ];
         return Ok(decision);
     }
@@ -226,6 +250,12 @@ pub fn evaluate_decision(root: &Path, options: EvaluationOptions) -> Result<Deci
     decision.harness_health = harness_health;
     decision.task_admission = task_admission;
     decision.task = task;
+    decision.required_context = vec![
+        "docs/naome/agent-workflow.md".to_string(),
+        "docs/naome/testing.md".to_string(),
+        ".naome/verification.json".to_string(),
+        "docs/naome/architecture.md".to_string(),
+    ];
     Ok(decision)
 }
 
@@ -238,15 +268,20 @@ pub fn format_decision(decision: &Decision, mode: &str) -> String {
     let mut lines = vec![
         format!("{title}: {}", decision.state),
         format!("Blocked: {}", decision.blocked),
-        format!("Summary: {}", decision.summary),
+        format!("Summary: {}", decision.user_message),
         format!("Next action: {}", decision.next_action),
     ];
 
-    if !decision.allowed_actions.is_empty() {
+    if should_show_allowed_actions(decision) {
         lines.push(format!(
             "Allowed actions: {}",
             decision.allowed_actions.join(", ")
         ));
+    } else if is_intent_routed_baseline_state(&decision.state) {
+        lines.push(
+            "Intent routing: run `naome intent --prompt-file <path>` before presenting human choices."
+                .to_string(),
+        );
     }
 
     if !decision.changed_paths.is_empty() {
@@ -267,6 +302,19 @@ pub fn format_decision(decision: &Decision, mode: &str) -> String {
     lines.join("\n")
 }
 
+fn should_show_allowed_actions(decision: &Decision) -> bool {
+    !decision.allowed_actions.is_empty() && !is_intent_routed_baseline_state(&decision.state)
+}
+
+fn is_intent_routed_baseline_state(state: &str) -> bool {
+    matches!(
+        state,
+        "completed_task_unbaselined"
+            | "install_or_upgrade_unbaselined"
+            | "harness_repair_unbaselined"
+    )
+}
+
 fn classify_idle_diff(root: &Path, changed_paths: Vec<String>) -> Result<Decision, NaomeError> {
     let manifest = read_json(root, ".naome/manifest.json").unwrap_or(Value::Null);
     let machine_owned = string_array_at(&manifest, "machineOwned");
@@ -284,7 +332,21 @@ fn classify_idle_diff(root: &Path, changed_paths: Vec<String>) -> Result<Decisio
             .iter()
             .all(|path| paths::matches_any(path, &known_harness_paths));
 
-    let mut decision = if all_machine_owned {
+    let mut decision = if harness_refresh_diff(root)?
+        .is_some_and(|diff| diff.unrelated_paths.is_empty())
+    {
+        Decision::new(
+            "harness_repair_unbaselined",
+            true,
+            "Machine-owned NAOME harness refresh files changed outside an active task.",
+            vec![
+                "commit_upgrade_baseline",
+                "review_diff_first",
+                "cancel_upgrade_baseline",
+            ],
+            "Run NAOME intent for the next natural-language request; deterministic policy can baseline a pure harness refresh automatically.",
+        )
+    } else if all_machine_owned {
         Decision::new(
             "harness_repair_unbaselined",
             true,
@@ -313,8 +375,8 @@ fn classify_idle_diff(root: &Path, changed_paths: Vec<String>) -> Result<Decisio
             "dirty_unowned_diff",
             true,
             "The repository has changes not owned by an active NAOME task.",
-            vec!["review_unowned_diff", "clear_or_commit_unowned_diff"],
-            "Review, commit, or clear the unowned diff before accepting new feature work.",
+            vec!["review_unowned_diff"],
+            "Review the unowned diff, or route a new task so NAOME can isolate task work without touching it.",
         )
     };
 
@@ -345,6 +407,16 @@ fn is_control_state_path(path: &str) -> bool {
     path == ".naome/task-state.json"
 }
 
+fn has_completed_task_owned_paths(task: Option<&TaskDecision>, changed_paths: &[String]) -> bool {
+    let Some(task) = task else {
+        return false;
+    };
+
+    changed_paths
+        .iter()
+        .any(|path| is_control_state_path(path) || paths::matches_any(path, &task.allowed_paths))
+}
+
 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));
@@ -405,7 +477,7 @@ fn string_array_at(value: &Value, key: &str) -> Vec<String> {
 }
 
 fn extract_known_actions(output: &str) -> Vec<&'static str> {
-    const KNOWN: [&str; 12] = [
+    const KNOWN: [&str; 11] = [
         "commit_task_baseline",
         "review_task_diff",
         "request_task_changes",
@@ -416,7 +488,6 @@ fn extract_known_actions(output: &str) -> Vec<&'static str> {
         "run_first_run_protocol",
         "run_upgrade_protocol",
         "review_unowned_diff",
-        "clear_or_commit_unowned_diff",
         "create_task",
     ];