fix(runtime): restore deterministic CLI contracts [AI: OpenAI gpt-5.6-sol via OpenCode]

Author: chubes4

crates/homeboy-cli/src/commands/infra/route/local_detach_fanout.rs

@@ -339,7 +339,8 @@ fn detached_fanout_child_args(
     fanout_id: &str,
     pin_fanout_id: bool,
 ) -> Vec<String> {
-    let mut args: Vec<String> = normalized_args
+    let owned_args = crate::command_capability::homeboy_owned_args(normalized_args);
+    let mut args: Vec<String> = owned_args
         .iter()
         .skip(1)
         .filter(|arg| {
@@ -351,6 +352,7 @@ fn detached_fanout_child_args(
         args.push("--fanout-id".to_string());
         args.push(fanout_id.to_string());
     }
+    args.extend(normalized_args.iter().skip(owned_args.len()).cloned());
     args
 }
 
@@ -414,6 +416,7 @@ fn materialize_plan_from(
 /// Both spellings clap accepts are covered: a separated `--input -` names the
 /// following element, an attached `--input=-` names itself.
 fn stdin_input_index(args: &[String]) -> Option<usize> {
+    let args = crate::command_capability::homeboy_owned_args(args);
     args.iter().enumerate().find_map(|(index, arg)| {
         if arg == "--input" && args.get(index + 1).is_some_and(|value| value == "-") {
             Some(index + 1)
@@ -868,6 +871,36 @@ mod tests {
         assert_eq!(args[args.len() - 1], "wave-9");
     }
 
+    #[test]
+    fn the_child_argv_preserves_forwarded_detach_named_arguments() {
+        let normalized = [
+            "homeboy",
+            "--detach-after-handoff",
+            "agent-task",
+            "fanout",
+            "run-plan",
+            "--input",
+            "@plan.json",
+            "--",
+            "--detach-after-handoff",
+        ]
+        .map(str::to_string);
+        let args = detached_fanout_child_args(&normalized, "wave-9", false);
+
+        assert_eq!(
+            args,
+            [
+                "agent-task",
+                "fanout",
+                "run-plan",
+                "--input",
+                "@plan.json",
+                "--",
+                "--detach-after-handoff",
+            ]
+        );
+    }
+
     /// An operator who named the wave must not get a second, contradictory id.
     #[test]
     fn an_already_named_wave_is_not_re_pinned() {
@@ -919,6 +952,27 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_forwarded_input_flag_is_not_materialized() {
+        let session = tempfile::tempdir().expect("temp session root");
+        let mut args = vec![
+            "fanout".to_string(),
+            "--input".to_string(),
+            "@plan.json".to_string(),
+            "--".to_string(),
+            "--input".to_string(),
+            "-".to_string(),
+        ];
+        let mut source = std::io::Cursor::new(br#"{"schema":"x"}"#.to_vec());
+
+        assert_eq!(
+            materialize_plan_from(&mut args, session.path(), &mut source)
+                .expect("forwarded input does not need materialization"),
+            None
+        );
+        assert_eq!(args[4..], ["--input", "-"]);
+    }
+
     /// An argv with no stdin plan must be left exactly alone.
     #[test]
     fn a_file_plan_is_left_untouched() {

crates/homeboy-cli/src/commands/infra/route/tests/dispatch.rs

@@ -1803,7 +1803,7 @@ fn lab_cook_plan_preserves_actual_cli_provenance_through_handoff_serialization()
                 "--max-attempts",
                 "3",
                 "--max-provider-executions",
-                "1",
+                "3",
                 "--protected-branch",
                 "main",
                 "--protected-branch",

crates/homeboy-cli/src/commands/json_output/ops.rs

@@ -38,13 +38,18 @@ mod tests {
         macro_rules! assert_registered_as_ops {
             ($(($module:ident, $variant:ident, $handler:path),)*) => {
                 $({
-                    // Module names are the command names, except `self_cmd`,
-                    // which exists only because `self` is a Rust keyword.
+                    // Module names are command names with Rust identifier
+                    // separators normalized; `self_cmd` exists only because
+                    // `self` is a Rust keyword.
                     let module = stringify!($module);
-                    let name = if module == "self_cmd" { "self" } else { module };
+                    let name = if module == "self_cmd" {
+                        "self".to_string()
+                    } else {
+                        module.replace('_', "-")
+                    };
 
                     assert_eq!(
-                        registered_command_json_family(name),
+                        registered_command_json_family(&name),
                         Some(CommandJsonFamily::Ops),
                         "ops descriptor `{name}` is missing from COMMAND_SPECS or is \
                          registered outside the Ops JSON family, so it would never \

crates/homeboy-cli/src/commands/triage.rs

@@ -366,22 +366,24 @@ mod tests {
         assert_eq!(default.args.poll_interval, "60s");
     }
 
-    /// The two spellings are one argument, not two: supplying both is a
-    /// duplicate value for the same id, and the last one wins rather than
-    /// silently producing two independent intervals.
+    /// The published alias is one argument: the canonical spelling takes the
+    /// value, while a duplicate spelling is rejected by Clap.
     #[test]
     fn watch_interval_spellings_are_one_argument() {
-        let cli = TestCli::try_parse_from([
+        let result = TestCli::try_parse_from([
             "triage",
             "--watch",
             "Extra-Chill/homeboy#2238",
             "--poll-interval",
             "30s",
             "--interval",
             "45s",
-        ])
-        .expect("both spellings parse");
-        assert_eq!(cli.args.poll_interval, "45s");
+        ]);
+        assert!(result.is_err(), "duplicate spellings must be rejected");
+        assert_eq!(
+            result.err().expect("duplicate spelling error").kind(),
+            clap::error::ErrorKind::ArgumentConflict
+        );
     }
 
     #[test]

crates/homeboy-cli/src/commands/utils/resource_policy/mod.rs

@@ -834,25 +834,20 @@ mod tests {
     }
 
     #[test]
-    fn agent_task_mutating_recovery_commands_remain_resource_managed() {
-        // Bounded readers are exempt above; replay and promotion still execute
-        // provider or worktree operations and retain resource admission.
-        for args in [
-            [
-                "homeboy",
-                "agent-task",
-                "replay-provider-boundary",
-                "agent-task-123",
-            ]
-            .as_slice(),
-            ["homeboy", "agent-task", "review", "agent-task-123"].as_slice(),
-        ] {
-            let cli = Cli::parse_from(args);
-            assert!(
-                hot_command(&cli.command).is_some(),
-                "{args:?} must retain resource admission"
-            );
-        }
+    fn agent_task_provider_replay_remains_resource_managed() {
+        // `review` is a bounded metadata read. Provider replay executes work
+        // against the selected runner and retains resource admission.
+        let args = [
+            "homeboy",
+            "agent-task",
+            "replay-provider-boundary",
+            "agent-task-123",
+        ];
+        let cli = Cli::parse_from(args);
+        assert!(
+            hot_command(&cli.command).is_some(),
+            "{args:?} must retain resource admission"
+        );
     }
 
     #[test]

crates/homeboy-core/src/daemon/mod.rs

@@ -2784,6 +2784,17 @@ fn enqueue_exec_job(
             request.capture_patch,
         )
     })?;
+    // Resolve this before runner-specific preparation so the opaque process plan
+    // can retain the same authority the daemon uses for durable lifecycle state.
+    let canonical_durable_run_id = resolve_exec_idempotency_key(
+        request.idempotency_key.as_deref(),
+        exec_request_run_ref_metadata(
+            request.lifecycle.as_ref(),
+            request.lab_runner_workload.as_ref(),
+            request.metadata.as_ref(),
+        )
+        .as_ref(),
+    );
     let plan = runner_exec_driver::prepare_exec(runner_exec_driver::RunnerExecPrepareRequest {
         runner_id: request.runner_id,
         runner: request.runner,
@@ -2800,6 +2811,7 @@ fn enqueue_exec_job(
         source_snapshot: request.source_snapshot,
         require_paths: request.require_paths,
         extension_env_providers: request.extension_env_providers,
+        authoritative_run_id: canonical_durable_run_id.clone(),
         validate_require_paths_on_host: true,
     })?;
     let source_snapshot = Some(plan.source_snapshot.clone());
@@ -2811,15 +2823,6 @@ fn enqueue_exec_job(
     // controllers that predate the explicit field. Either way the resolved key
     // is folded into the lifecycle's `durable_run_id` below, which is what the
     // job-store dedup guard keys on.
-    let canonical_durable_run_id = resolve_exec_idempotency_key(
-        request.idempotency_key.as_deref(),
-        exec_request_run_ref_metadata(
-            lifecycle.as_ref(),
-            request.lab_runner_workload.as_ref(),
-            request.metadata.as_ref(),
-        )
-        .as_ref(),
-    );
     if let Some(durable_run_id) = canonical_durable_run_id {
         lifecycle
             .get_or_insert_with(RunnerJobLifecycleMetadata::default)
@@ -3110,6 +3113,7 @@ fn enqueue_exec_job(
                 let metrics = process_output.metrics.clone();
                 let capture = process_output.capture.clone();
                 let extension_env_provenance = process_output.extension_env_provenance.clone();
+                let diagnostic_hints = process_output.diagnostic_hints.clone();
                 if cancellation_requested.load(Ordering::SeqCst) {
                     let evidence = stall_evidence
                         .lock()
@@ -3169,7 +3173,7 @@ fn enqueue_exec_job(
                 } else {
                     None
                 };
-                let result = json!({
+                let mut result = json!({
                     "runner_id": plan.runner_id,
                     "cwd": plan.cwd,
                     "command": plan.command,
@@ -3183,6 +3187,9 @@ fn enqueue_exec_job(
                     "capture": capture,
                     "extension_env_providers": extension_env_provenance,
                 });
+                if !diagnostic_hints.is_empty() {
+                    result["diagnostic_hints"] = json!(diagnostic_hints);
+                }
                 if exit_code != 0 {
                     job.result(result.clone())?;
                     return Err(Error::remote_command_failed(RemoteCommandFailedDetails {

crates/homeboy-core/src/daemon/runner_exec_driver.rs

@@ -46,6 +46,9 @@ pub struct RunnerExecPrepareRequest {
     pub require_paths: Vec<String>,
     /// Ordered installed extension IDs whose runner-local scripts contribute env.
     pub extension_env_providers: Vec<String>,
+    /// Canonical durable run identity resolved by the daemon from the explicit
+    /// idempotency key or its compatible lifecycle/metadata fallback.
+    pub authoritative_run_id: Option<String>,
     pub validate_require_paths_on_host: bool,
 }
 
@@ -132,6 +135,8 @@ pub struct DaemonExecOutput {
     pub stderr: String,
     pub exit_code: i32,
     pub extension_env_provenance: Value,
+    /// Non-secret runner diagnostics persisted with the terminal result.
+    pub diagnostic_hints: Vec<String>,
     /// Serialized `RunnerResourceMetrics`, if any.
     pub metrics: Option<Value>,
     /// Serialized command-capture metadata, if any.

crates/homeboy-extension/src/env_provider.rs

@@ -261,6 +261,27 @@ fn parse_env_provider_output(stdout: &str) -> Result<Vec<(String, String)>> {
 mod tests {
     use super::*;
 
+    #[cfg(unix)]
+    fn install_provider_fixture(root: &Path, id: &str, output: &str) {
+        use std::os::unix::fs::PermissionsExt;
+
+        let source = root.join(id);
+        std::fs::create_dir_all(&source).expect("provider source directory");
+        std::fs::write(
+            source.join(format!("{id}.json")),
+            format!(
+                r#"{{"id":"{id}","name":"{id}","version":"1.0.0","env_provider":{{"script":"env.sh"}}}}"#
+            ),
+        )
+        .expect("provider manifest");
+        let script = source.join("env.sh");
+        std::fs::write(&script, format!("#!/bin/sh\nprintf '%s\\n' '{output}'\n"))
+            .expect("provider script");
+        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755))
+            .expect("provider executable");
+        crate::install(&source.display().to_string(), Some(id)).expect("install provider fixture");
+    }
+
     #[test]
     fn parses_blank_output_as_no_env() {
         assert!(parse_env_provider_output("\n").unwrap().is_empty());
@@ -309,4 +330,24 @@ mod tests {
         assert!(!payload.contains(secret));
         assert!(payload.contains("claim_ref"));
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn providers_cannot_contribute_the_same_public_environment_key() {
+        homeboy_core::test_support::with_isolated_home(|_| {
+            let root = tempfile::tempdir().expect("provider fixtures");
+            install_provider_fixture(root.path(), "first", r#"{"SHARED_KEY":"first"}"#);
+            install_provider_fixture(root.path(), "second", r#"{"SHARED_KEY":"second"}"#);
+
+            let error = resolve_installed_all(
+                &RunnerJobExecutionContext::local("homeboy"),
+                &["first".to_string(), "second".to_string()],
+                root.path(),
+                &[],
+            )
+            .expect_err("provider-provider public env collision must fail");
+
+            assert!(error.message.contains("SHARED_KEY"));
+        });
+    }
 }

crates/homeboy-lab-runner/src/daemon_exec_driver.rs

@@ -26,6 +26,7 @@ use super::Runner;
 struct DaemonPreparedPlan {
     plan: PreparedRunnerProcess,
     extension_env_providers: Vec<String>,
+    authoritative_run_id: Option<String>,
 }
 
 /// The runner layer's `RunnerExecDriver`. Registered with core at startup.
@@ -71,6 +72,7 @@ impl RunnerExecDriver for RunnerDaemonExecDriver {
             &request.env,
             secret_env_plan,
         );
+        let authoritative_run_id = request.authoritative_run_id;
         let plan = prepare_daemon_local_process(RunnerProcessRequest {
             runner_id: request.runner_id,
             runner,
@@ -103,6 +105,7 @@ impl RunnerExecDriver for RunnerDaemonExecDriver {
             plan_token: Arc::new(DaemonPreparedPlan {
                 plan,
                 extension_env_providers: request.extension_env_providers,
+                authoritative_run_id,
             }),
         }))
     }
@@ -153,17 +156,20 @@ impl RunnerExecDriver for RunnerDaemonExecDriver {
             execution_context,
             &base.extension_env_providers,
             std::path::Path::new(&plan.cwd),
-            &plan
-                .env
-                .iter()
-                .map(|(key, value)| (key.clone(), value.clone()))
-                .collect::<Vec<_>>(),
+            &plan.env,
+            base.authoritative_run_id.as_deref(),
         )?;
         for contribution in &contributions {
             for (key, value) in &contribution.public_env {
                 plan.env.insert(key.clone(), value.clone());
             }
         }
+        let diagnostic_hints = super::execution::apply_explicit_runner_exec_run_id_env(
+            &mut plan.env,
+            base.authoritative_run_id.as_deref(),
+        )
+        .into_iter()
+        .collect();
         let extension_env_provenance = serde_json::to_value(&contributions).map_err(|err| {
             homeboy_core::error::Error::internal_json(
                 err.to_string(),
@@ -196,6 +202,7 @@ impl RunnerExecDriver for RunnerDaemonExecDriver {
                 .capture
                 .and_then(|capture| serde_json::to_value(capture).ok()),
             extension_env_provenance,
+            diagnostic_hints,
         })
     }
 }