Synced from monorepo

Synced from monorepo

Changes:
- Shell: accept target response id on rewind execute
- Shell: stamp response id on chat user message chunks
- Worktree: optional rebuild and stale git registration cleanup in auto-GC
- Worktree: kind-aware auto-GC TTLs and config knobs
- Worktree: macOS process CWD scan and Unix PID liveness for GC guards
- Worktree: automatic throttled GC on startup (Linux age-based; non-Linux dead-only)
- Pager: add `[ui].combine_queued_prompts` to batch queued follow-ups
- Shell: stop overwriting user skills
- Tools: read markdown in `skills/` directories untruncated
- `/usage` shows per-session token and dollar usage in the TUI
- Security: prompt on environment-dumping `ps` variants
- Security: always-safe `kubectl` no longer runs arbitrary kubeconfig credential plugins without permission
- Tools: make scheduler deletion durable
- Shell: add relocation storage primitives
- Shell: give side model calls their own conversation ids
- Fix five workflow-runtime bugs (budget, pause, cancel, reconnect)
- Security: peel `env -S` / `--split-string` operands in the Bash permission gate (managed deny/ask)
- Pager: expose doctor in the TUI
- Security: block unauthorized RCE via abused safe commands
- Pager idle watcher cue: "1 subagent still running" instead of "watching · 1 subagent"
- Security: block `rg --pre` arbitrary code execution in auto-mode
- Voice: diagnose silent-mic failures (macOS permission) and add doctor/terminal-setup Voice section
- App builder deployer: `allow_forking` and `show_built_with_grok`
- Pager: stop stacking duplicate "Worked for" markers on parked turns
- Shell: support `max` as a distinct reasoning effort tier
- Tools: serialize background `/loop` fires on the whole work unit
- Shell: add working-directory relocation state primitives
- Proto: `ClientToolResult` and `ChatConfig` client-side tools
- Shell: model providers
- Chat: select App Builder product on the Build path
- Shell: attach author identity to feedback when the deployment opts in
- Doctor: fix for SSH wrap setup
- Workflow authoring skills: create-workflow and import-claude-workflow docs
- Add read-only grok doctor
- Sandbox: apply Landlock without a controlling TTY
- Pager: recover image paste over grok wrap on headless remotes
- Pager: make actions screen-mode aware
- Shell: resume sessions when the working directory moves
- Pager: centralize terminal diagnostics
- Workspace: gate inline shell file access
- Pager: centralize terminal probes
- Pager: edit minimal prompts in an external editor
- Pager: standardize backgrounding on Ctrl+B
- Shell: recap rides the parent turn's prompt cache
- Tools: add scheduler lifecycle version clock

Source-Revision: 0f4d7c91b8b2b408333f6de1e8a76cb8eaa71899

crates/codegen/xai-grok-test-support/src/headless.rs

@@ -17,12 +17,19 @@ pub struct HeadlessResult {
     pub stdout: String,
     pub stderr: String,
     pub timed_out: bool,
+    /// Wall time of the grok invocation; logged so CI timeout budgets can be
+    /// tuned against observed durations.
+    pub elapsed: Duration,
 }
 
-const HEADLESS_TIMEOUT_SECS: u64 = 60;
+/// Timeout for one headless grok invocation: 60 seconds, multiplied by
+/// [`crate::scaled`]'s `GROK_TEST_TIMEOUT_SCALE`.
+fn headless_timeout() -> Duration {
+    crate::scaled(Duration::from_secs(60))
+}
 
-/// Run `grok` with the given args against the mock server, with a 60s timeout.
-/// Uses an isolated HOME and disables telemetry.
+/// Run `grok` with the given args against the mock server, bounded by
+/// [`headless_timeout_secs`]. Uses an isolated HOME and disables telemetry.
 pub async fn run_headless(
     server: &MockInferenceServer,
     args: &[&str],
@@ -55,6 +62,7 @@ pub async fn run_headless_with_env(
 
 pub async fn run_headless_with_cmd(mut cmd: tokio::process::Command) -> HeadlessResult {
     let binary = grok_binary();
+    let started = std::time::Instant::now();
     let mut child = cmd
         .spawn()
         .unwrap_or_else(|e| panic!("failed to spawn grok binary at {}: {e}", binary.display()));
@@ -75,12 +83,7 @@ pub async fn run_headless_with_cmd(mut cmd: tokio::process::Command) -> Headless
         Ok::<Vec<u8>, std::io::Error>(stderr_buf)
     });
 
-    let (status, timed_out) = match tokio::time::timeout(
-        Duration::from_secs(HEADLESS_TIMEOUT_SECS),
-        child.wait(),
-    )
-    .await
-    {
+    let (status, timed_out) = match tokio::time::timeout(headless_timeout(), child.wait()).await {
         Ok(result) => (
             result.unwrap_or_else(|e| {
                 panic!("failed to wait for grok binary {}: {e}", binary.display())
@@ -110,11 +113,17 @@ pub async fn run_headless_with_cmd(mut cmd: tokio::process::Command) -> Headless
         Err(err) => panic!("stderr task join failed for {}: {err}", binary.display()),
     };
 
+    let elapsed = started.elapsed();
+    // Timing breadcrumb for tuning CI timeout budgets against observed
+    // durations (visible with --nocapture).
+    eprintln!("[harness-timing] headless grok run: {elapsed:?} (timed_out={timed_out})");
+
     HeadlessResult {
         status,
         stdout: String::from_utf8_lossy(&stdout_bytes).into_owned(),
         stderr: String::from_utf8_lossy(&stderr_bytes).into_owned(),
         timed_out,
+        elapsed,
     }
 }
 
@@ -140,7 +149,8 @@ pub fn assert_headless_success(
 ) {
     assert!(
         !result.timed_out,
-        "{label}: timed out after {HEADLESS_TIMEOUT_SECS}s\nstderr tail:\n{}",
+        "{label}: timed out after {:?}\nstderr tail:\n{}",
+        headless_timeout(),
         stderr_tail(&result.stderr, 500)
     );
     assert!(