feat: add --profile ci and memoize ciTopology in-process

crates/no-mistakes/src/invocation.rs

@@ -51,6 +51,12 @@ fn deadline_test_lock() -> &'static std::sync::Mutex<()> {
     LOCK.get_or_init(|| std::sync::Mutex::new(()))
 }
 
+#[derive(clap::ValueEnum, Debug, Clone, Copy, PartialEq, Eq)]
+enum InvocationProfile {
+    /// Unbounded command and lock wait (`timeout: 0`, `lock-timeout: 0`).
+    Ci,
+}
+
 #[derive(clap::Args, Debug, Clone, Copy)]
 pub struct InvocationArgs {
     /// Maximum command execution time in seconds; 0 disables the deadline.
@@ -67,6 +73,9 @@ pub struct InvocationArgs {
     /// Fail immediately when another no-mistakes invocation holds the lock.
     #[arg(long, global = true)]
     fail_on_lock: bool,
+    /// Named timeout defaults. `ci` sets `--timeout 0 --lock-timeout 0`.
+    #[arg(long, value_enum, global = true)]
+    profile: Option<InvocationProfile>,
 }
 
 impl Default for InvocationArgs {
@@ -75,15 +84,20 @@ impl Default for InvocationArgs {
             timeout: DEFAULT_TIMEOUT_SECONDS,
             lock_timeout: DEFAULT_TIMEOUT_SECONDS,
             fail_on_lock: false,
+            profile: None,
         }
     }
 }
 
 impl InvocationArgs {
     pub fn options(self) -> InvocationOptions {
+        let (timeout, lock_timeout) = match self.profile {
+            Some(InvocationProfile::Ci) => (0, 0),
+            None => (self.timeout, self.lock_timeout),
+        };
         InvocationOptions {
-            timeout: nonzero_seconds(self.timeout),
-            lock_timeout: nonzero_seconds(self.lock_timeout),
+            timeout: nonzero_seconds(timeout),
+            lock_timeout: nonzero_seconds(lock_timeout),
             fail_on_lock: self.fail_on_lock,
             jobs: None,
         }

crates/no-mistakes/src/invocation/napi_options.rs

@@ -50,11 +50,20 @@ pub fn extract_napi_options_value(
         }
     };
     let jobs = take_jobs(object)?;
+    let profile_ci = match object.remove("profile") {
+        None | Some(Value::Null) => false,
+        Some(Value::String(value)) if value == "ci" => true,
+        Some(_) => {
+            return Err(anyhow!(
+                "invalid options JSON: profile must be \"ci\" when set"
+            ))
+        }
+    };
     Ok((
         value,
         InvocationOptions {
-            timeout,
-            lock_timeout,
+            timeout: if profile_ci { None } else { timeout },
+            lock_timeout: if profile_ci { None } else { lock_timeout },
             fail_on_lock,
             jobs,
         },

crates/no-mistakes/src/invocation/tests.rs

@@ -47,6 +47,7 @@ fn cli_defaults_and_zero_values_have_napi_parity() {
             timeout: 0,
             lock_timeout: 0,
             fail_on_lock: true,
+            profile: None,
         }
         .options(),
         InvocationOptions {
@@ -58,6 +59,25 @@ fn cli_defaults_and_zero_values_have_napi_parity() {
     );
 }
 
+#[test]
+fn ci_profile_disables_timeouts() {
+    assert_eq!(
+        InvocationArgs {
+            timeout: DEFAULT_TIMEOUT_SECONDS,
+            lock_timeout: DEFAULT_TIMEOUT_SECONDS,
+            fail_on_lock: false,
+            profile: Some(InvocationProfile::Ci),
+        }
+        .options(),
+        InvocationOptions {
+            timeout: None,
+            lock_timeout: None,
+            fail_on_lock: false,
+            jobs: None,
+        }
+    );
+}
+
 #[test]
 fn disabled_deadline_allows_timeout_check() {
     let _serial = deadline_test_lock()

crates/no-mistakes/src/invocation/tests/napi_options.rs

@@ -40,6 +40,19 @@ fn napi_missing_controls_disable_timeouts() {
     assert_eq!(options.jobs, None);
 }
 
+#[test]
+fn napi_profile_ci_is_stripped() {
+    let (json, options) =
+        extract_napi_options(r#"{"profile":"ci","timeout":10,"lockTimeout":5,"root":"."}"#)
+            .unwrap();
+    assert_eq!(options.timeout, None);
+    assert_eq!(options.lock_timeout, None);
+    assert_eq!(
+        serde_json::from_str::<Value>(&json).unwrap(),
+        serde_json::json!({"root":"."})
+    );
+}
+
 #[test]
 fn napi_jobs_parses_non_negative_integer_or_null() {
     let (_, options) = extract_napi_options(r#"{"jobs":4}"#).unwrap();
@@ -59,6 +72,7 @@ fn napi_controls_validate_types() {
         r#"{"failOnLock":1}"#,
         r#"{"jobs":-1}"#,
         r#"{"jobs":"4"}"#,
+        r#"{"profile":"local"}"#,
         "[]",
         "not-json",
     ] {

crates/no-mistakes/tests/cli_invocation.rs

@@ -68,6 +68,7 @@ fn invocation_help_documents_independent_timeouts_and_lock_failure() {
     assert!(help.contains("--timeout <SECONDS>"));
     assert!(help.contains("--lock-timeout <SECONDS>"));
     assert!(help.contains("--fail-on-lock"));
+    assert!(help.contains("--profile"));
     assert!(help.contains("[default: 30]"));
 }
 

docs/cli/README.md

@@ -23,6 +23,11 @@ or after the command name:
   is `30`; `0` waits indefinitely.
 - `--fail-on-lock` fails immediately when another invocation holds the lock,
   overriding `--lock-timeout`.
+- `--profile ci` sets `--timeout 0 --lock-timeout 0` for CI jobs that should
+  wait for the machine-wide lock and run without a command deadline. Node
+  `profile: "ci"` clears any supplied `timeout` / `lockTimeout` the same way.
+  `ciTopology()` memoizes in-process by resolved root, config mtime, and
+  workflows filter so repeated calls in one process do not re-parse workflows.
 
 Command and lock-wait timeouts exit with status `124`. Immediate lock
 contention and lock setup errors exit with status `2`. Errors are written to