@lamentis/naome 1.3.6 → 1.3.8

package/crates/naome-core/tests/route_harness_refresh.rs

@@ -9,6 +9,12 @@ use repo_support::{
     TestRepo,
 };
 
+fn repair_prompt(prompt: &str) -> String {
+    format!(
+        "```naome-prompt-envelope-v1\n{{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"fix\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"repair_request\",\"taskIntent\":\"none\",\"risk\":\"none\",\"requestedActions\":[\"repair\"],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}}\n```\n\n{prompt}"
+    )
+}
+
 #[test]
 fn execute_route_baselines_harness_refresh_before_dirty_repo_worktree() {
     let repo = TestRepo::dirty_harness_refresh_repo("route-dirty-harness-refresh-worktree", true);
@@ -66,7 +72,7 @@ fn execute_route_repair_request_baselines_harness_refresh_only() {
 
     let route = evaluate_route(
         repo.path(),
-        "please repair all",
+        &repair_prompt("please repair all"),
         RouteOptions {
             execute: true,
             evaluation: EvaluationOptions::offline(),

package/crates/naome-core/tests/route_user_diff.rs

@@ -27,7 +27,7 @@ fn execute_route_does_not_mutate_or_offer_clear_commit_for_dirty_unowned_diff()
     )
     .unwrap();
 
-    assert_eq!(route.policy_action, "block_unowned_diff");
+    assert_eq!(route.policy_action, "normalize_prompt_first");
     assert!(!route.mutation_performed);
     assert!(!route.can_create_task);
     assert_eq!(route.executed_actions, Vec::<String>::new());

package/crates/naome-core/tests/task_ledger.rs

@@ -190,6 +190,70 @@ fn task_state_validation_reports_stale_rendered_projection_when_ledger_exists()
     }));
 }
 
+#[test]
+fn ignored_local_runtime_ledger_does_not_stale_committed_projection() {
+    let repo = TestRepo::new("ignored-runtime-ledger");
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n.naome/tasks/\n");
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_complete_ledger(&head);
+    repo.write_naome_json("task-state.json", compact_complete_state(&head));
+    repo.write_file("README.md", "# Changed\n");
+
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
+#[test]
+fn compact_completed_task_state_survives_incomplete_local_runtime_ledger() {
+    let repo = TestRepo::new("compact-over-runtime-ledger");
+    repo.init_git();
+    repo.write_file("README.md", "# Baseline\n");
+    repo.write_base_harness(Some(idle_state()));
+    repo.git(&["add", "."]);
+    repo.git(&["commit", "-m", "baseline"]);
+    let head = repo.git_stdout(&["rev-parse", "HEAD"]);
+    repo.write_naome_json("task-state.json", compact_complete_state(&head));
+    repo.write_file(
+        ".naome/tasks/active.json",
+        &format_json(object([
+            ("schema", json!("naome.task-ledger-active.v1")),
+            ("version", json!(1)),
+            ("primaryTaskId", json!("old-local-task")),
+            (
+                "worklanes",
+                json!([{ "id": "default", "taskId": "old-local-task", "status": "active" }]),
+            ),
+        ])),
+    );
+    repo.write_file(
+        ".naome/tasks/old-local-task/task.json",
+        &format_json(task_spec_record_with_id(&head, "old-local-task")),
+    );
+    repo.write_file(
+        ".naome/tasks/old-local-task/events.jsonl",
+        concat!(
+            "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"implementing\",\"recordedAt\":\"2026-05-08T00:00:01.000Z\"}\n",
+            "{\"schema\":\"naome.task-ledger-event.v1\",\"type\":\"status\",\"status\":\"complete\",\"recordedAt\":\"2026-05-08T00:00:02.000Z\"}\n"
+        ),
+    );
+    repo.write_file("README.md", "# Changed\n");
+
+    let projected = read_task_state_projection(repo.path()).unwrap().unwrap();
+
+    assert_eq!(
+        projected["activeTask"]["proofBatches"][0]["proofs"][0]["checkId"],
+        "diff-check"
+    );
+    let report = validate_task_state(repo.path(), TaskStateOptions::default()).unwrap();
+    assert!(report.errors.is_empty(), "{:?}", report.errors);
+}
+
 trait LedgerHarness {
     fn write_base_harness(&self, task_state: Option<Value>);
     fn write_complete_ledger(&self, admission_head: &str);
@@ -298,10 +362,14 @@ fn compact_active_task(admission_head: &str) -> Value {
 }
 
 fn task_spec_record(admission_head: &str) -> Value {
+    task_spec_record_with_id(admission_head, "readme-task")
+}
+
+fn task_spec_record_with_id(admission_head: &str, task_id: &str) -> Value {
     object([
         ("schema", json!("naome.task-ledger-task.v1")),
         ("version", json!(1)),
-        ("id", json!("readme-task")),
+        ("id", json!(task_id)),
         ("request", json!("Update README.")),
         ("userPrompt", user_prompt()),
         ("admission", admission_record(admission_head)),

package/crates/naome-core/tests/task_state_compact.rs

@@ -6,6 +6,12 @@ use task_state_compact_support::{
     compact_state, large_compact_state, large_expanded_state, legacy_state, MiniRepo,
 };
 
+fn new_task_prompt(prompt: &str) -> String {
+    format!(
+        "```naome-prompt-envelope-v1\n{{\"schema\":\"naome.prompt-envelope.v1\",\"requestKind\":\"implementation\",\"mutationIntent\":\"modify_files\",\"workflowAction\":\"none\",\"taskIntent\":\"new_task\",\"risk\":\"none\",\"requestedActions\":[],\"referencedPaths\":[],\"constraints\":[],\"uncertainties\":[]}}\n```\n\n{prompt}"
+    )
+}
+
 #[test]
 fn legacy_v1_proof_results_remain_valid() {
     let repo = MiniRepo::new();
@@ -30,7 +36,7 @@ fn compact_path_sets_and_batches_cover_completion_commit_and_route() {
 
     let route = evaluate_route(
         repo.path(),
-        "new task",
+        &new_task_prompt("new task"),
         RouteOptions {
             execute: false,
             evaluation: EvaluationOptions::offline(),

package/crates/naome-core/tests/task_state_compact_support/states.rs

@@ -129,14 +129,16 @@ fn base_state(admission_head: &str, proof_payload: Value) -> Value {
     task.as_object_mut()
         .unwrap()
         .extend(proof_payload.as_object().unwrap().clone());
-    json!({
-        "schema": "naome.task-state.v2",
-        "version": 2,
-        "status": "complete",
-        "activeTask": task,
-        "blocker": null,
-        "updatedAt": T0
-    })
+    let mut state: Value = serde_json::from_str(include_str!(
+        "../../../../templates/naome-root/.naome/task-state.json"
+    ))
+    .unwrap();
+    state["schema"] = json!("naome.task-state.v2");
+    state["version"] = json!(2);
+    state["status"] = json!("complete");
+    state["activeTask"] = task;
+    state["updatedAt"] = json!(T0);
+    state
 }
 
 fn proof(check_id: &str, command: &str, cwd: &str) -> Value {

package/crates/naome-core/tests/task_state_support/states.rs

@@ -13,14 +13,14 @@ pub fn complete_task_state(overrides: Value) -> Value {
 }
 
 fn task_state_record(status: &str, active_task: Value, updated_at: Value) -> Value {
-    json!({
-        "schema": "naome.task-state.v1",
-        "version": 1,
-        "status": status,
-        "activeTask": active_task,
-        "blocker": null,
-        "updatedAt": updated_at
-    })
+    let mut state: Value = serde_json::from_str(include_str!(
+        "../../../../templates/naome-root/.naome/task-state.json"
+    ))
+    .unwrap();
+    state["status"] = json!(status);
+    state["activeTask"] = active_task;
+    state["updatedAt"] = updated_at;
+    state
 }
 
 pub fn active_task(overrides: Value) -> Value {

package/crates/naome-core/tests/workflow_support/mod.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lamentis/naome",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "Native-first CLI for the NAOME agent harness.",
   "license": "Apache-2.0",
   "type": "module",

package/templates/naome-root/.naome/manifest.json

@@ -1,5 +1,5 @@
 {
-  "harnessVersion": "1.2.0",
+  "harnessVersion": "1.3.8",
   "installedAt": null,
   "integrity": {
     ".naome/bin/check-harness-health.js": "sha256:dc4de52b79c69600b9ba47b924e2c2b8de61a2cbfab6d1ccc0f1924d963db657",
@@ -8,12 +8,12 @@
     ".naome/package.json": "sha256:8005a3491db7d92f36ac66369861589f9c47123d3a7c71e643fc2c06168cd45a",
     ".naome/task-contract.schema.json": "sha256:1b3b62350328d0d6d660e36d1d1baaa2b88718530db774f9ab2a9e2fcba369c8",
     "AGENTS.md": "sha256:e8b2fc786c1c72b69ba8f2b2ffce4f459e799c7453ce9ff4a9f6448a8f9e6b4f",
-    "docs/naome/agent-workflow.md": "sha256:2fd1fd02eb6849133b9e8227421914580b1c469a60388a063c1b6ed48016b48d",
+    "docs/naome/agent-workflow.md": "sha256:0be1c29adfbcd3fd73c4f904080ffc67237692fe413871a30243538c4db38ac7",
     "docs/naome/context-economy.md": "sha256:3ed5075815ecf4ada46a5e65438769310307c35759fcd46b13dc0b96e02bebd9",
     "docs/naome/execution.md": "sha256:bfc5d55838942ec8e3d790b59e3c634ff5bf6a2298265cef3dca9788a097eafb",
     "docs/naome/first-run.md": "sha256:1466ce8c65e19a1514885f917db14e8a772350e3f6d1c03a66326963365919e1",
     "docs/naome/index.md": "sha256:07ef776f49130319a5280bdb3ae38af22141708253f38eb983a4336fbae1b25a",
-    "docs/naome/task-ledger.md": "sha256:ac637a31abdd13eee15a49086594e63f5c88fe12a5cf621b227310788ae7e583",
+    "docs/naome/task-ledger.md": "sha256:6ca7222c80079b4662fb718d3c71d686770646f1fa52b83b0e90aed1c5a1101b",
     "docs/naome/upgrade.md": "sha256:2c60f0441bbd98bd528d109b30a7ded4b0ad55d61ffb9f52edac9e93b7999cb1"
   },
   "machineOwned": [

package/templates/naome-root/.naomeignore

@@ -3,3 +3,4 @@
 
 .naome/archive/
 .naome/cache/
+.naome/tasks/

package/templates/naome-root/docs/naome/agent-workflow.md

@@ -11,11 +11,20 @@ Use this workflow after first-run intake is complete.
    `canCreateTask` fields instead of inventing routing or final-response text.
    If route returns a `taskRoot` different from the current directory, continue
    the task from that path and leave the original worktree untouched.
-   When preparing the route prompt file, prepend a fenced `naome-intent-v2`
-   JSON envelope that states `workflowAction`, `taskIntent`, and `risk` using
-   canonical NAOME schema constants such as `commit_request`,
-   `task_revision`, and `credential_context`. Keep the original user text below
-   it. Do not derive workflow actions from natural-language keywords.
+   When preparing the route prompt file, first normalize the user's raw prompt
+   into a fenced `naome-prompt-envelope-v1` JSON envelope. The envelope is the
+   routing input; the raw user text below it is audit text. Use canonical NAOME
+   schema fields such as `requestKind`, `mutationIntent`,
+   `publicationIntent`, `requestedActions`, `referencedPaths`, `constraints`,
+   `uncertainties`, `workflowAction`, `taskIntent`, and `risk`. Do not derive
+   workflow actions from natural-language keywords, localized words, or the
+   prompt's prose language. If a prompt file has no envelope, route returns a
+   non-mutating `normalize_prompt_first` decision and the agent must add the
+   deterministic envelope before retrying. `naome-intent-v2` is not supported.
+   Unknown envelope values require normalization, and conflicting envelope
+   fields block as ambiguous instead of mutating. Put concrete files in
+   `referencedPaths`; prompt context selection treats those paths as the
+   primary source of path intent.
 3. Use `node .naome/bin/naome.js explain --prompt-file <path> --json` only when
    debugging why a policy won.
 4. Run `node .naome/bin/naome.js status --json` when reporting state without
@@ -110,22 +119,20 @@ Use this workflow after first-run intake is complete.
 1. Identify changed files.
 2. Match them against `.naome/verification.json`.
 3. Run the required checks when available.
-4. Prefer ledger-backed task updates. `naome sync` migrates active legacy
+4. Prefer local ledger-backed task updates. `naome sync` migrates active legacy
    task-state automatically; if a legacy-only active task is still present, run
    `node .naome/bin/naome.js task migrate-ledger --write --json` before adding
    completion proof.
-5. Record proof as compact `proofPathSets` and `proofBatches` in
-   `.naome/tasks/<task-id>/task.json` when many checks share evidence paths.
-   Use `.naome/tasks/<task-id>/proofs/` only when separate per-check files are
-   needed for parallel writers or durable audit detail. If legacy compatibility
-   work is unavoidable, use the same compact fields in `.naome/task-state.json`
-   and include every changed in-scope path reported by git in expanded proof
-   evidence.
+5. Record proof as compact `proofPathSets` and `proofBatches` in the local
+   ledger when many checks share evidence paths. Use local per-check proof files
+   only when separate writers need them during the run. The committed release
+   artifact is `.naome/task-state.json`; include every changed in-scope path
+   reported by git in expanded proof evidence.
 6. Run `node .naome/bin/naome.js task render-state --write --json` before
    external compatibility checks. Do not hand-edit the rendered projection when
    `.naome/tasks/active.json` exists.
-7. Do not list `.naome/task-state.json` or `.naome/tasks/` as task scope or
-   proof evidence.
+7. Do not list `.naome/task-state.json` or local task runtime folders as task
+   scope or proof evidence.
 8. Stop tracked long-running processes or mark them explicitly allowed in
    `.naome/processes.json`.
 9. Set task status to `complete` in the ledger event stream or legacy task

package/templates/naome-root/docs/naome/architecture.md

@@ -8,16 +8,25 @@ Status: Uninitialized
 
 ## Known Boundaries
 
-- NAOME information falls into durable project state, durable task ledger,
-  generated projection, local runtime state, run evidence, and product source.
+- NAOME information falls into durable project state, generated projection,
+  local runtime state, run evidence, and product source.
 - Durable project state is committed repository or package state needed to
   reinstall or reconstruct the harness.
-- `.naome/task-state.json` is a generated compatibility projection when
-  `.naome/tasks/active.json` exists. Render it from the ledger instead of
-  hand-editing it.
-- `.naome/tmp/` is local runtime state and must not be committed.
-- Per-check proof files are run evidence. Prefer compact ledger proof batches
-  when many release checks share the same evidence paths.
+- `.naome/task-state.json` is the committed compact task-state projection.
+- `.naome/tmp/` and `.naome/tasks/` are local runtime state and must not be
+  committed.
+- Per-check proof files are local run evidence. Prefer compact proof batches in
+  the committed task-state projection when many release checks share the same
+  evidence paths.
+- Prompt routing uses fenced `naome-prompt-envelope-v1` JSON envelopes as the
+  deterministic routing input. Raw natural-language prompts are audit text and
+  must not be treated as workflow authority until an agent normalizes them into
+  canonical fields such as `requestKind`, `mutationIntent`,
+  `publicationIntent`, `requestedActions`, `workflowAction`, `taskIntent`, and
+  `risk`. Legacy `naome-intent-v2` envelopes are not supported. Unknown
+  envelope values require prompt normalization, conflicting fields block as
+  ambiguous, and `referencedPaths` is the primary context-selection source for
+  prompt-mentioned files.
 
 ## Assumed Boundaries
 

package/templates/naome-root/docs/naome/task-ledger.md

@@ -1,8 +1,9 @@
 # Task Ledger
 
-NAOME task state is moving from one mutable aggregate file to a canonical task
-ledger. The compatibility file `.naome/task-state.json` remains supported, but
-new deterministic task tooling can use `.naome/tasks/` as the source of truth.
+NAOME task state is moving from one mutable aggregate file to a local task
+ledger. The compatibility file `.naome/task-state.json` remains the compact
+committed projection, while `.naome/tasks/` is machine-local runtime state for
+efficient task updates.
 
 ## Layout
 
@@ -33,9 +34,10 @@ new deterministic task tooling can use `.naome/tasks/` as the source of truth.
 ## Compatibility
 
 Existing `naome.task-state.v1` and `naome.task-state.v2` files remain valid. If
-`.naome/tasks/active.json` exists, NAOME readers build a canonical task model
-from the ledger and render a `naome.task-state.v2` projection. If no ledger is
-present, readers fall back to `.naome/task-state.json`.
+a current local ledger exists, NAOME readers build a canonical task model from
+it and render a `naome.task-state.v2` projection. If no local ledger is present,
+or an older local completed ledger lacks proof detail that the committed compact
+projection still has, readers fall back to `.naome/task-state.json`.
 
 Use this command when an external tool needs the compatibility file refreshed:
 
@@ -44,21 +46,22 @@ node .naome/bin/naome.js task render-state --write --json
 ```
 
 `naome sync` automatically splits an active legacy `task-state` file into the
-ledger layout. The explicit command remains available for repair or tests:
+local ledger layout. The explicit command remains available for repair or
+tests:
 
 ```text
 node .naome/bin/naome.js task migrate-ledger --write --json
 ```
 
 After `.naome/tasks/active.json` exists, `.naome/task-state.json` is a rendered
-compatibility projection. NAOME gates reject a stale projection and report the
-render command instead of accepting hand-edited aggregate state.
+compatibility projection. NAOME gates reject a stale active projection and
+report the render command instead of accepting hand-edited aggregate state.
 
 ## Conflict Policy
 
-`.naome/tasks/` is NAOME control state. It is not task feature scope and is not
-required as proof evidence. Gates ignore ledger control files when checking
-whether product changes stay inside `allowedPaths`.
+`.naome/tasks/` is local NAOME runtime state. It is ignored, untracked by
+`naome sync`, and not task feature scope or proof evidence. Gates ignore ledger
+control files when checking whether product changes stay inside `allowedPaths`.
 
 The intended long-term model is:
 
@@ -76,8 +79,8 @@ instead of all competing for `.naome/task-state.json`.
 ## Information Policy
 
 Use `node .naome/bin/naome.js workflow information --path <path> --json` before
-changing NAOME control files whose retention is unclear. Durable configuration,
-templates, task specs, and task events are restored from repository or package
-state. `.naome/task-state.json` is generated from durable state. `.naome/tmp/`
-is local runtime state. Per-check proof files are run evidence; compact release
-proof batches keep release diffs readable without losing verification coverage.
+changing NAOME control files whose retention is unclear. Durable configuration
+and templates are restored from repository or package state.
+`.naome/task-state.json` is the committed compact task projection. `.naome/tmp/`
+and `.naome/tasks/` are local runtime state. Compact release proof batches keep
+release diffs readable without tracking per-task runtime folders.

package/crates/naome-core/src/intent/patterns.rs

@@ -1,170 +0,0 @@
-use super::model::IntentKind;
-
-pub(crate) fn normalized(text: &str) -> String {
-    text.to_lowercase()
-        .chars()
-        .map(|ch| if ch.is_alphanumeric() { ch } else { ' ' })
-        .collect::<String>()
-        .split_whitespace()
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
-pub(crate) fn lexical_tokens(text: &str) -> Vec<String> {
-    text.split_whitespace()
-        .map(|token| {
-            token
-                .trim_matches(|ch: char| !ch.is_alphanumeric() && ch != '_' && ch != '-')
-                .to_lowercase()
-        })
-        .filter(|token| !token.is_empty())
-        .collect()
-}
-
-pub(crate) fn structured_workflow_intents(text: &str) -> Vec<IntentKind> {
-    let tokens = lexical_tokens(text);
-    let mut intents = Vec::new();
-
-    if let Some(intent) = structured_action(&tokens) {
-        intents.push(intent);
-    }
-    if let Some(intent) = legacy_v1_short_action_request(&tokens) {
-        intents.push(intent);
-    }
-    if legacy_v1_no_commit(&tokens) {
-        intents.push(IntentKind::NoCommitRequest);
-    }
-    if has_structured_token(&tokens, &["no_commit", "without_commit"]) {
-        intents.push(IntentKind::NoCommitRequest);
-    }
-
-    intents.sort_by_key(|kind| kind.as_str());
-    intents.dedup();
-    intents
-}
-
-pub(crate) fn command_workflow_intents(text: &str) -> Vec<IntentKind> {
-    let tokens = lexical_tokens(text);
-    let mut intents = Vec::new();
-    if let Some(intent) = cli_action(&tokens) {
-        intents.push(intent);
-    }
-    intents
-}
-
-pub(crate) fn explicit_task_intent(text: &str) -> Option<IntentKind> {
-    let tokens = lexical_tokens(text);
-    if has_structured_token(&tokens, &["task_revision", "current_task", "active_task"]) {
-        return Some(IntentKind::TaskRevision);
-    }
-    if has_structured_token(&tokens, &["new_task", "create_new_task", "separate_task"]) {
-        return Some(IntentKind::NewTask);
-    }
-    None
-}
-
-pub(crate) fn is_generic_work_request(text: &str) -> bool {
-    !lexical_tokens(text).is_empty()
-}
-
-fn structured_action(tokens: &[String]) -> Option<IntentKind> {
-    policy_action(tokens)
-}
-
-fn policy_action(tokens: &[String]) -> Option<IntentKind> {
-    for token in tokens {
-        let intent = match token.as_str() {
-            "commit_task_baseline" | "commit_user_diff" | "commit_upgrade_baseline" => {
-                IntentKind::CommitRequest
-            }
-            "review_task_diff" | "review_current_task_diff" | "review_unowned_diff" => {
-                IntentKind::ReviewRequest
-            }
-            "repair_harness" | "repair_harness_only" => IntentKind::RepairRequest,
-            "cancel_task_changes" | "cancel_current_task" => IntentKind::CancelRequest,
-            "continue_current_task" | "task_complete" | "complete_task" => {
-                IntentKind::TaskCompletion
-            }
-            "answer_status_only" => IntentKind::StatusQuestion,
-            "clear_or_commit_unowned_diff" => IntentKind::Ambiguous,
-            _ => continue,
-        };
-        return Some(intent);
-    }
-    None
-}
-
-fn cli_action(tokens: &[String]) -> Option<IntentKind> {
-    match (
-        tokens.first().map(String::as_str),
-        tokens.get(1).map(String::as_str),
-    ) {
-        (Some("naome"), Some("commit")) => Some(IntentKind::CommitRequest),
-        (Some("naome"), Some("status")) => Some(IntentKind::StatusQuestion),
-        (Some("naome"), Some("sync" | "update" | "install")) => Some(IntentKind::RepairRequest),
-        (Some("git"), Some("commit")) => Some(IntentKind::CommitRequest),
-        _ => None,
-    }
-}
-
-// Kept only so pre-v2 route callers keep their existing conservative behavior.
-// A naome-intent-v2 envelope clears these candidates before policy resolution.
-fn legacy_v1_short_action_request(tokens: &[String]) -> Option<IntentKind> {
-    let action_index = tokens
-        .iter()
-        .position(|token| legacy_v1_action_intent(token).is_some())?;
-    if action_index > 1 || tokens.len() > 6 {
-        return None;
-    }
-
-    let intent = legacy_v1_action_intent(&tokens[action_index])?;
-    if intent == IntentKind::StatusQuestion || tokens.len() <= 3 {
-        return Some(intent);
-    }
-    if tokens.len() <= 2 || legacy_v1_has_action_scope(tokens) {
-        return Some(intent);
-    }
-    None
-}
-
-fn legacy_v1_no_commit(tokens: &[String]) -> bool {
-    tokens
-        .windows(3)
-        .any(|window| window[0] == "do" && window[1] == "not" && window[2] == "commit")
-        || tokens
-            .windows(2)
-            .any(|window| matches!(window[0].as_str(), "no" | "without") && window[1] == "commit")
-}
-
-fn legacy_v1_action_intent(token: &str) -> Option<IntentKind> {
-    match token {
-        "commit" | "baseline" => Some(IntentKind::CommitRequest),
-        "review" => Some(IntentKind::ReviewRequest),
-        "repair" | "sync" => Some(IntentKind::RepairRequest),
-        "cancel" => Some(IntentKind::CancelRequest),
-        "complete" | "completion" => Some(IntentKind::TaskCompletion),
-        "status" => Some(IntentKind::StatusQuestion),
-        _ => None,
-    }
-}
-
-fn legacy_v1_has_action_scope(tokens: &[String]) -> bool {
-    has_structured_token(
-        tokens,
-        &[
-            "task",
-            "diff",
-            "harness",
-            "baseline",
-            "state",
-            "current_task",
-            "active_task",
-        ],
-    )
-}
-
-fn has_structured_token(tokens: &[String], accepted: &[&str]) -> bool {
-    tokens
-        .iter()
-        .any(|token| accepted.iter().any(|accepted| token == accepted))
-}