@pushpalsdev/cli 1.1.22 → 1.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/.pushpals-remotebuddy-fallback.js

@@ -8285,6 +8285,7 @@ function buildWorkerSpawnCommand(options) {
 }
 
 // apps/remotebuddy/src/remotebuddy_main.ts
+var AUTONOMY_TASK_DEDUPE_COOLDOWN_MS = 6 * 60 * 60 * 1000;
 var CONFIG = loadPushPalsConfig();
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -8464,6 +8465,11 @@ function buildTaskExecuteDedupeKey(sessionId, params) {
   }
   return `task.execute:${normalizedOrigin}:${normalizedSessionId}:${uniqueTargets.join("|")}`.toLowerCase();
 }
+function resolveTaskExecuteDedupeCooldownMs(params, dedupeKey) {
+  if (!dedupeKey)
+    return 0;
+  return params.origin === "autonomy" ? AUTONOMY_TASK_DEDUPE_COOLDOWN_MS : 0;
+}
 function parseAutonomyRequestMetadata(value) {
   let root = asObject2(value);
   if (!root && typeof value === "string") {
@@ -9509,6 +9515,9 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
       const dedupeKey = buildTaskExecuteDedupeKey(sessionId, params);
       if (dedupeKey)
         payload.dedupeKey = dedupeKey;
+      const dedupeCooldownMs = resolveTaskExecuteDedupeCooldownMs(params, dedupeKey);
+      if (dedupeCooldownMs > 0)
+        payload.dedupeCooldownMs = dedupeCooldownMs;
       if (targetWorkerId)
         payload.targetWorkerId = targetWorkerId;
       const res = await this.fetchImpl(`${this.server}/jobs/enqueue`, {
@@ -10603,6 +10612,7 @@ if (import.meta.main) {
   });
 }
 export {
+  resolveTaskExecuteDedupeCooldownMs,
   extractRequiredValidationStepsFromVisionMarkdown,
   buildTaskExecuteDedupeKey,
   RemoteBuddyOrchestrator

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/openai_codex_executor.py

@@ -8,6 +8,7 @@ that the TypeScript host parses.
 from __future__ import annotations
 
 import json
+import hashlib
 import os
 import re
 from shutil import rmtree, which
@@ -108,11 +109,13 @@ _MAX_CREDIBLE_WRAPPER_LOOP_TOP_LEVELS = 4
 _MAX_NO_EDIT_RECOVERY_ATTEMPTS = 1
 _MAX_ROLLOUT_RECOVERY_ATTEMPTS = 1
 _DEFAULT_NO_EDIT_WATCHDOG_S = 480
-_SMALL_TASK_NO_EDIT_WATCHDOG_S = 360
+_SMALL_TASK_NO_EDIT_WATCHDOG_S = 240
+_NARROW_TEST_TASK_NO_EDIT_WATCHDOG_S = 180
 _WEB_REVIEW_NO_EDIT_WATCHDOG_S = 240
 _DEFAULT_NO_EDIT_RECHECK_S = 120
 _DEFAULT_ROLLOUT_WATCHDOG_S = 300
 _SMALL_TASK_ROLLOUT_WATCHDOG_S = 240
+_NARROW_TEST_TASK_ROLLOUT_WATCHDOG_S = 150
 _WEB_REVIEW_ROLLOUT_WATCHDOG_S = 180
 
 
@@ -590,6 +593,21 @@ def _looks_like_small_task_prompt(prompt: str) -> bool:
         "browser smoke",
         "web delivery",
         "navigation trustworthy",
+        "test-only",
+        "test only",
+        "contract test",
+        "contract coverage",
+        "ranking contract",
+        "focused scenario",
+        "targeted test",
+        "one-file",
+        "one file",
+        "single-file",
+        "single file",
+        "max_files_to_edit: 1",
+        "max_files_to_edit=1",
+        "maxfilestoedit: 1",
+        "maxfilestoedit=1",
     )
     heavy_markers = (
         "merge-conflict",
@@ -606,6 +624,34 @@ def _looks_like_small_task_prompt(prompt: str) -> bool:
     )
 
 
+def _looks_like_narrow_test_task_prompt(prompt: str) -> bool:
+    text = str(prompt or "").lower()
+    if not text:
+        return False
+    narrow_markers = (
+        "contract test",
+        "contract coverage",
+        "ranking contract",
+        "test-only",
+        "test only",
+        "targeted test",
+        "focused scenario",
+    )
+    if not any(marker in text for marker in narrow_markers):
+        return False
+    broad_markers = (
+        "full render harness",
+        "full-surface",
+        "full surface",
+        "e2e",
+        "browser validation",
+        "browser smoke",
+        "migration",
+        "broad refactor",
+    )
+    return not any(marker in text for marker in broad_markers)
+
+
 def _resolve_task_reasoning_effort(
     configured_effort: str,
     prompt: str,
@@ -651,7 +697,9 @@ def _resolve_no_edit_watchdog_seconds(
         return None
 
     prompt_text = str(prompt or "").lower()
-    if "repo-native web review" in prompt_text or "web review path" in prompt_text:
+    if _looks_like_narrow_test_task_prompt(prompt):
+        default_s = _NARROW_TEST_TASK_NO_EDIT_WATCHDOG_S
+    elif "repo-native web review" in prompt_text or "web review path" in prompt_text:
         default_s = _WEB_REVIEW_NO_EDIT_WATCHDOG_S
     else:
         default_s = (
@@ -702,7 +750,9 @@ def _resolve_rollout_watchdog_seconds(
         else:
             return max(1, min(parsed, max(1, communicate_timeout_s - 1)))
 
-    if _looks_like_web_review_prompt(prompt):
+    if _looks_like_narrow_test_task_prompt(prompt):
+        default_s = _NARROW_TEST_TASK_ROLLOUT_WATCHDOG_S
+    elif _looks_like_web_review_prompt(prompt):
         default_s = _WEB_REVIEW_ROLLOUT_WATCHDOG_S
     elif _looks_like_small_task_prompt(prompt):
         default_s = _SMALL_TASK_ROLLOUT_WATCHDOG_S
@@ -713,9 +763,39 @@ def _resolve_rollout_watchdog_seconds(
     return max(90, min(default_s, max(90, communicate_timeout_s - 60)))
 
 
-def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot: List[str]) -> str:
-    delta = [p for p in changed_paths if p not in baseline_snapshot]
-    inspected = delta if delta else changed_paths
+def _baseline_snapshot_paths(baseline_snapshot: Any) -> List[str]:
+    if isinstance(baseline_snapshot, dict):
+        return [str(path) for path in baseline_snapshot.keys()]
+    if isinstance(baseline_snapshot, list):
+        return [str(path) for path in baseline_snapshot]
+    return []
+
+
+def _paths_changed_after_baseline(
+    repo: str,
+    changed_paths: List[str],
+    baseline_snapshot: Any,
+) -> List[str]:
+    baseline_paths = set(_baseline_snapshot_paths(baseline_snapshot))
+    if not baseline_paths:
+        return list(changed_paths)
+
+    delta: List[str] = []
+    baseline_fingerprints = baseline_snapshot if isinstance(baseline_snapshot, dict) else {}
+    for path in changed_paths:
+        if path not in baseline_paths:
+            delta.append(path)
+            continue
+        if baseline_fingerprints:
+            current_fingerprint = _changed_path_fingerprint(repo, path)
+            if current_fingerprint != str(baseline_fingerprints.get(path) or ""):
+                delta.append(path)
+    return delta
+
+
+def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot: Any) -> str:
+    baseline_paths = set(_baseline_snapshot_paths(baseline_snapshot))
+    inspected = [p for p in changed_paths if p not in baseline_paths] if baseline_paths else changed_paths
     non_publishable = [p for p in inspected if not _is_publishable_changed_path(p)]
     if not non_publishable:
         return ""
@@ -735,6 +815,8 @@ def _describe_publishable_paths(paths: List[str]) -> str:
 def _build_no_edit_recovery_guidance(trace_excerpt: str, artifact_only_paths: str = "") -> str:
     lines = [
         "No-edit watchdog recovery: the previous Codex attempt spent too much of the execution budget without producing publishable file changes.",
+        "This recovery attempt has a patch-first contract: make one publishable edit before any further broad discovery. If you need one narrow read of the hinted file to place the edit, do that once, then patch immediately.",
+        "Do not repeat the same read/search sequence from the previous attempt. Re-reading the target without editing is a failed recovery.",
         "Start from the already inspected context. Do not re-read broad repo topology, route wrappers, or missing test infrastructure unless that is the blocker.",
         "Runtime/dependency artifacts such as node_modules, outputs, .worktrees, .codex, dist, build, and coverage do not count as progress.",
         "Within the first response/action, edit the smallest behavior-owning file that satisfies the task. If the hinted file is a thin wrapper, patch the owner you already identified.",
@@ -1686,10 +1768,99 @@ def _is_publishable_changed_path(path: str) -> bool:
     return not re.search(r"(^|/)(outputs|node_modules|\.worktrees|\.codex|dist|build|coverage)(/|$)", normalized)
 
 
-def _codex_changed_paths(repo: str, baseline_snapshot: List[str]) -> Tuple[List[str], List[str], List[str]]:
+def _filesystem_fingerprint(repo: str, raw_path: str) -> str:
+    root = Path(repo)
+    target = (root / raw_path).resolve()
+    try:
+        root_resolved = root.resolve()
+        common = os.path.commonpath([str(root_resolved), str(target)])
+        if common != str(root_resolved):
+            return "outside-repo"
+    except Exception:
+        return "unresolved"
+    digest = hashlib.sha256()
+    if not target.exists():
+        return "missing"
+    if target.is_file():
+        digest.update(b"file\0")
+        try:
+            digest.update(str(target.stat().st_size).encode("utf-8"))
+            with target.open("rb") as handle:
+                while True:
+                    chunk = handle.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    digest.update(chunk)
+        except Exception as exc:
+            digest.update(f"read-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+        return digest.hexdigest()
+    if target.is_dir():
+        digest.update(b"dir\0")
+        files_seen = 0
+        try:
+            for dirpath, dirnames, filenames in os.walk(target):
+                dirnames.sort()
+                filenames.sort()
+                for filename in filenames:
+                    if files_seen >= 128:
+                        digest.update(b"\0truncated")
+                        return digest.hexdigest()
+                    child = Path(dirpath) / filename
+                    try:
+                        rel = child.relative_to(root_resolved).as_posix()
+                    except Exception:
+                        rel = child.name
+                    digest.update(rel.encode("utf-8", errors="replace"))
+                    digest.update(b"\0")
+                    digest.update(str(child.stat().st_size).encode("utf-8"))
+                    digest.update(b"\0")
+                    try:
+                        with child.open("rb") as handle:
+                            digest.update(handle.read(64 * 1024))
+                    except Exception as exc:
+                        digest.update(f"read-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+                    files_seen += 1
+        except Exception as exc:
+            digest.update(f"walk-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+        return digest.hexdigest()
+    return "special"
+
+
+def _changed_path_fingerprint(repo: str, path: str) -> str:
+    normalized = str(path or "").strip()
+    if not normalized:
+        return ""
+    digest = hashlib.sha256()
+    digest.update(normalized.replace("\\", "/").encode("utf-8", errors="replace"))
+    digest.update(b"\0fs\0")
+    digest.update(_filesystem_fingerprint(repo, normalized).encode("utf-8", errors="replace"))
+    return digest.hexdigest()
+
+
+def _capture_git_change_snapshot(repo: str) -> Dict[str, str]:
+    return {path: _changed_path_fingerprint(repo, path) for path in summarize_git_changes(repo)}
+
+
+def _normalize_baseline_snapshot(repo: str, baseline_changes: Any) -> Dict[str, str]:
+    if isinstance(baseline_changes, dict):
+        return {
+            str(path): str(fingerprint)
+            for path, fingerprint in baseline_changes.items()
+            if str(path or "").strip()
+        }
+    if isinstance(baseline_changes, list):
+        return {
+            str(path): _changed_path_fingerprint(repo, str(path))
+            for path in baseline_changes
+            if str(path or "").strip()
+        }
+    return _capture_git_change_snapshot(repo)
+
+
+def _codex_changed_paths(repo: str, baseline_snapshot: Any) -> Tuple[List[str], List[str], List[str]]:
     changed_paths = summarize_git_changes(repo)
-    delta = [p for p in changed_paths if p not in baseline_snapshot]
-    effective = [p for p in (delta if delta else changed_paths) if _is_publishable_changed_path(p)]
+    delta = _paths_changed_after_baseline(repo, changed_paths, baseline_snapshot)
+    effective = [p for p in delta if _is_publishable_changed_path(p)]
     return changed_paths, delta, effective
 
 
@@ -1851,7 +2022,7 @@ def _run_codex_task(
         prompt,
         model,
     )
-    baseline_snapshot = list(baseline_changes) if baseline_changes is not None else summarize_git_changes(repo)
+    baseline_snapshot = _normalize_baseline_snapshot(repo, baseline_changes)
 
     with tempfile.TemporaryDirectory(prefix="pushpals-codex-") as tmp_dir:
         last_message_path = Path(tmp_dir) / "codex-last-message.txt"

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/test_openai_codex_runtime_config.py

@@ -36,6 +36,7 @@ from openai_codex_executor import (
     _build_rollout_recovery_guidance,
     _collect_disallowed_shell_wrapper_rejections,
     _codex_changed_paths,
+    _capture_git_change_snapshot,
     _describe_non_publishable_paths,
     _detect_offtrack_rollout,
     _detect_codex_workaround_signal,
@@ -944,6 +945,75 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("too broad/noisy", str(result.get("stderr") or ""))
         self.assertIn("area0", str(result.get("stderr") or ""))
 
+    def test_run_codex_task_timeout_ignores_broad_dirty_baseline(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-timeout-dirty-baseline-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# timeout dirty baseline repo\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "README.md"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed timeout dirty baseline repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            for index in range(5):
+                root = repo / f"area{index}"
+                root.mkdir(exist_ok=True)
+                (root / "changed.txt").write_text("pre-existing dirty change\n", encoding="utf-8")
+
+            stub_path = Path(temp_dir) / "fake_codex_timeout_dirty_baseline.py"
+            stub_path.write_text(
+                "\n".join(
+                    [
+                        "import sys",
+                        "import time",
+                        "",
+                        "sys.stdin.read()",
+                        "print('item.completed | Still thinking without changing baseline files.', flush=True)",
+                        "time.sleep(5)",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+
+            env_overrides = {
+                "PUSHPALS_OPENAI_CODEX_BIN_JSON": json.dumps([sys.executable, str(stub_path)]),
+                "PUSHPALS_OPENAI_CODEX_AUTH_MODE": "api_key",
+                "OPENAI_API_KEY": "pushpals-timeout-dirty-baseline-test-key",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "1",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "0",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Make a compact scoped patch, then continue thinking too long.",
+                    [],
+                )
+
+        self.assertFalse(result.get("ok"), result)
+        self.assertEqual(result.get("exitCode"), 124)
+        self.assertIn("execution timed out", str(result.get("summary") or ""))
+        self.assertNotIn("broad/noisy", str(result.get("summary") or ""))
+        self.assertNotIn("too broad/noisy", str(result.get("stderr") or ""))
+
     def test_run_codex_task_retries_once_when_no_edit_watchdog_fires(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-no-edit-watchdog-") as temp_dir:
             repo = Path(temp_dir) / "repo"
@@ -1215,6 +1285,86 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertGreaterEqual(len(delta), 2)
         self.assertEqual(effective, [])
 
+    def test_codex_changed_paths_ignores_publishable_paths_dirty_at_baseline(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-dirty-baseline-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# dirty baseline repo\n", encoding="utf-8")
+            (repo / "src").mkdir()
+            (repo / "src" / "existing.ts").write_text("export const value = 1;\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "."], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed dirty baseline repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            (repo / "README.md").write_text("# dirty baseline repo\n\npre-existing edit\n", encoding="utf-8")
+            (repo / "src" / "existing.ts").write_text("export const value = 2;\n", encoding="utf-8")
+            baseline = _capture_git_change_snapshot(str(repo))
+
+            changed_paths, delta, effective = _codex_changed_paths(str(repo), baseline)
+
+        self.assertIn("README.md", changed_paths)
+        self.assertEqual(delta, [])
+        self.assertEqual(effective, [])
+
+    def test_codex_changed_paths_counts_worker_edits_to_dirty_baseline_paths(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-dirty-baseline-mutated-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# dirty baseline mutation repo\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "README.md"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed dirty baseline mutation repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            (repo / "README.md").write_text("# dirty baseline mutation repo\n\npre-existing edit\n", encoding="utf-8")
+            baseline = _capture_git_change_snapshot(str(repo))
+            (repo / "README.md").write_text(
+                "# dirty baseline mutation repo\n\npre-existing edit\nworker edit\n",
+                encoding="utf-8",
+            )
+
+            _, delta, effective = _codex_changed_paths(str(repo), baseline)
+
+        self.assertEqual(delta, ["README.md"])
+        self.assertEqual(effective, ["README.md"])
+
     def test_non_publishable_path_summary_names_artifact_only_dirty_paths(self) -> None:
         changed_paths = [
             "node_modules/react/index.js",
@@ -1236,6 +1386,16 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
 
         self.assertEqual(watchdog_s, 240)
 
+    def test_narrow_contract_tests_use_fast_no_edit_watchdog(self) -> None:
+        prompt = (
+            "Update app/__tests__/opportunity-graph.contract.test.ts to tighten the "
+            "ranking contract test. Keep this test-only and preserve existing behavior."
+        )
+        with mock.patch.dict(os.environ, {"WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": ""}, clear=False):
+            watchdog_s = _resolve_no_edit_watchdog_seconds(prompt, 1200)
+
+        self.assertEqual(watchdog_s, 180)
+
     def test_no_edit_recovery_guidance_warns_against_artifact_only_progress(self) -> None:
         guidance = _build_no_edit_recovery_guidance(
             "item.completed | still inspecting",
@@ -1243,6 +1403,8 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         )
 
         self.assertIn("node_modules", guidance)
+        self.assertIn("patch-first contract", guidance)
+        self.assertIn("Re-reading the target without editing is a failed recovery", guidance)
         self.assertIn("do not invent PushPals/autonomy-specific files", guidance)
         self.assertIn("Previous Codex event trace excerpt", guidance)
 
@@ -1261,6 +1423,15 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertEqual(no_edit_s, 240)
         self.assertEqual(rollout_s, 180)
 
+    def test_narrow_contract_rollout_watchdog_is_earlier_than_no_edit_watchdog(self) -> None:
+        prompt = "Tighten the focused contract test for one ranking behavior."
+        with mock.patch.dict(os.environ, {"WORKERPALS_OPENAI_CODEX_ROLLOUT_WATCHDOG_S": ""}, clear=False):
+            no_edit_s = _resolve_no_edit_watchdog_seconds(prompt, 1200)
+            rollout_s = _resolve_rollout_watchdog_seconds(prompt, 1200, no_edit_s)
+
+        self.assertEqual(no_edit_s, 180)
+        self.assertEqual(rollout_s, 120)
+
     def test_offtrack_rollout_detects_missing_path_and_harness_drift(self) -> None:
         trace = {
             "summaries": [

package/runtime/sandbox/apps/workerpals/src/workerpals_main.ts

@@ -1785,9 +1785,10 @@ async function workerLoop(
                   terminalStage: currentJobPhase ?? (result.ok ? "completed" : "worker"),
                   executorBackend: resolveExecutor(CONFIG),
                   summary: result.summary,
-                  watchdogFired: /timed out|timeout|signal 15|terminated|exit 143|exit 137/i.test(
-                    `${result.summary}\n${result.stderr ?? ""}`,
-                  ),
+                  watchdogFired:
+                    /watchdog|rollout coach|timed out|timeout|signal 15|terminated|exit 143|exit 137/i.test(
+                      `${result.summary}\n${result.stderr ?? ""}\n${result.stdout ?? ""}`,
+                    ),
                   metadata: {
                     workerId: opts.workerId,
                     docker: Boolean(dockerExecutor),