@pushpalsdev/cli 1.1.9 → 1.1.11

package/dist/pushpals-cli.js

@@ -1647,6 +1647,7 @@ var DEFAULT_STARTUP_GIT_REMOTE_TIMEOUT_MS = 1e4;
 var DEFAULT_EMBEDDED_SERVICE_LAUNCH_WARN_MS = 5000;
 var EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS = 4;
 var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 15000;
+var CLI_SESSION_JOB_LOG_MAX_CHARS = 700;
 var EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
 var EMBEDDED_RUNTIME_WINDOWS_SAFETY_CAPS = {
   REMOTEBUDDY_WORKERPAL_STARTUP_TIMEOUT_MS: "120000",
@@ -3035,6 +3036,17 @@ async function downloadBinaryAssetWithWindowsCurlFallback(url, outPath, cause) {
   renameSync(tmpPath, outPath);
   return true;
 }
+async function runWithConcurrency(items, concurrency, worker) {
+  const workerCount = Math.max(1, Math.min(items.length, Math.floor(concurrency)));
+  let nextIndex = 0;
+  await Promise.all(Array.from({ length: workerCount }, async () => {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      await worker(items[currentIndex], currentIndex);
+    }
+  }));
+}
 async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
   const platformKey = resolveRuntimePlatformKey();
   console.log(`[pushpals] Preparing embedded runtime binaries for ${runtimeTag} (${platformKey})...`);
@@ -3056,14 +3068,15 @@ async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
     runtimeBinaries.sourceControlManager
   ];
   const shouldRefreshAll = installedTag !== runtimeTag;
-  let downloadedCount = 0;
-  for (const binaryPath of requiredAssets) {
-    if (!shouldRefreshAll && existsSync5(binaryPath))
-      continue;
+  const assetsToDownload = requiredAssets.filter((binaryPath) => shouldRefreshAll || !existsSync5(binaryPath));
+  if (assetsToDownload.length > 1) {
+    console.log(`[pushpals] Downloading ${assetsToDownload.length} runtime binary asset(s) with bounded parallelism...`);
+  }
+  await runWithConcurrency(assetsToDownload, 3, async (binaryPath) => {
     const assetName = binaryPath.split(/[\\/]/).pop() || "";
     await downloadBinaryAsset(runtimeTag, assetName, binaryPath);
-    downloadedCount++;
-  }
+  });
+  const downloadedCount = assetsToDownload.length;
   writeFileSync(tagMarkerPath, `${runtimeTag}
 `, "utf8");
   cleanupLegacyRuntimeBinaryLayouts(runtimeRoot, platformKey, binDir);
@@ -4694,6 +4707,8 @@ ${tail}` : ""}`);
   const deadline = Date.now() + DEFAULT_RUNTIME_BOOT_TIMEOUT_MS;
   const readinessPhaseStartedAt = Date.now();
   const optionalServiceExitWarned = new Set;
+  let lastReadinessWaitLogAt = 0;
+  let lastReadinessWaitDetail = "";
   while (Date.now() < deadline) {
     reportRemoteBuddyAutonomousEngineState();
     if (maybeActivateRemoteBuddyWindowsFallback("silent_startup")) {
@@ -4737,6 +4752,17 @@ ${tail}` : ""}`);
     }
     const health = localBuddyEnabled ? await probeLocalBuddy(opts.localAgentUrl) : null;
     const remoteBuddyHealth2 = await probeRemoteBuddySessionConsumer(opts.serverUrl, opts.sessionId);
+    if (localBuddyEnabled && !health?.ok || !remoteBuddyHealth2.ok) {
+      const localBuddyDetail = localBuddyEnabled ? health?.ok ? "LocalBuddy ready" : "LocalBuddy not ready" : "LocalBuddy skipped";
+      const readinessDetail = `${localBuddyDetail}; ${remoteBuddyHealth2.detail}`;
+      const now = Date.now();
+      if (readinessDetail !== lastReadinessWaitDetail || now - lastReadinessWaitLogAt >= 5000) {
+        console.log(`[pushpals] Waiting for embedded runtime readiness: ${readinessDetail}`);
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] waiting for embedded runtime readiness: ${readinessDetail}`);
+        lastReadinessWaitDetail = readinessDetail;
+        lastReadinessWaitLogAt = now;
+      }
+    }
     if ((!localBuddyEnabled || health?.ok) && remoteBuddyHealth2.ok) {
       reportRemoteBuddyAutonomousEngineState();
       const stabilityDeadline = Date.now() + DEFAULT_SERVICE_STABILITY_GRACE_MS;
@@ -5192,6 +5218,31 @@ function formatSessionEventLine(event) {
   const type = String(event.type ?? "").toLowerCase();
   const from = String(event.from ?? "");
   const payload = event.payload ?? {};
+  if (type === "job_enqueued") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const kind = String(payload.kind ?? "").trim();
+    const taskId = String(payload.taskId ?? "").slice(0, 8);
+    const detail = kind || (taskId ? `task ${taskId}` : "queued");
+    return `[job ${jobId}] queued: ${detail}`;
+  }
+  if (type === "job_claimed") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const workerId = String(payload.workerId ?? "").trim();
+    return `[job ${jobId}] claimed${workerId ? ` by ${workerId}` : ""}`;
+  }
+  if (type === "job_log") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const stream = String(payload.stream ?? "").toLowerCase() === "stderr" ? " stderr" : "";
+    const phase = compactCliSessionJobLogLine(String(payload.phase ?? "").trim());
+    const phaseLabel = phase ? ` phase:${phase}` : "";
+    const line = formatCliSessionJobLogLine(String(payload.line ?? "").trim());
+    return line ? `[job ${jobId}${stream}${phaseLabel}] ${line}` : null;
+  }
+  if (type === "job_failed") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const message = String(payload.message ?? "").trim();
+    return `[job ${jobId}] failed: ${message || "unknown"}`;
+  }
   if (!shouldDisplayInteractiveSessionEvent(event))
     return null;
   if (type === "message")
@@ -5217,10 +5268,10 @@ function formatSessionEventLine(event) {
     const summary = String(payload.summary ?? "").trim();
     return `[task ${taskId}] completed${summary ? `: ${summary}` : ""}`;
   }
-  if (type === "job_failed") {
+  if (type === "job_completed") {
     const jobId = String(payload.jobId ?? "").slice(0, 8);
-    const message = String(payload.message ?? "").trim();
-    return `[job ${jobId}] failed: ${message || "unknown"}`;
+    const summary = String(payload.summary ?? "").trim();
+    return `[job ${jobId}] completed${summary ? `: ${summary}` : ""}`;
   }
   if (type === "error") {
     const message = String(payload.message ?? "").trim();
@@ -5234,6 +5285,53 @@ function formatSessionEventLine(event) {
   }
   return null;
 }
+function compactCliSessionJobLogLine(line) {
+  const compacted = line.replace(/\s+/g, " ").trim();
+  if (compacted.length <= CLI_SESSION_JOB_LOG_MAX_CHARS)
+    return compacted;
+  return `${compacted.slice(0, CLI_SESSION_JOB_LOG_MAX_CHARS - 3)}...`;
+}
+function formatCliSessionJobLogLine(line) {
+  const compacted = compactCliSessionJobLogLine(line);
+  if (!compacted)
+    return null;
+  if (shouldSuppressCliSessionJobLogLine(compacted))
+    return null;
+  const codexItem = compacted.match(/^\[OpenAICodexExecutor\]\s+\[codex\]\s+item\.(?:completed|updated)\s+\|\s+(.+)$/i);
+  if (codexItem?.[1]) {
+    return `[codex] ${compactCliSessionJobLogLine(codexItem[1])}`;
+  }
+  return compacted;
+}
+function shouldSuppressCliSessionJobLogLine(line) {
+  const text = String(line ?? "").trim();
+  if (!text)
+    return true;
+  if (/^(___RESULT___|__PUSHPALS_OH_RESULT__)\b/.test(text))
+    return true;
+  if (/^\[DockerExecutor\]\s+Linked worktree dependency artifact/i.test(text))
+    return true;
+  if (/^\[Openai_codexExecutor\]\s+Spawning openai_codex executor/i.test(text))
+    return true;
+  if (/^\[OpenAICodexExecutor\]\s+(?:Planner guidance|Codex auth mode|ChatGPT auth mode|Starting codex exec|codex exec finished|Codex JSON stream captured|Codex stdout captured|No reasoning-like|Reasoning-like event|Usage observed|Temporarily masked repo-local)/i.test(text)) {
+    return true;
+  }
+  if (/^\[OpenAICodexExecutor\]\s+codex exec still running\b/i.test(text))
+    return true;
+  if (/^\[OpenAICodexExecutor\]\s+\[codex\]\s+(?:thread|turn)\.started\b/i.test(text)) {
+    return true;
+  }
+  if (/^\[OpenAICodexExecutor\]\s+\[codex\]\s+item\.started\b/i.test(text))
+    return true;
+  if (/^\[OpenAICodexExecutor\]\s+\[codex\]\s+item\.completed\s*$/i.test(text))
+    return true;
+  if (/^\[OpenAICodexExecutor\]\s+\[codex\]\s+item\.updated\s*$/i.test(text))
+    return true;
+  if (/^\[OpenAICodexExecutor\]\s+\[stderr\].*codex_core::tools::router: error=exec_command failed/i.test(text)) {
+    return true;
+  }
+  return false;
+}
 function buildSessionEventReplayFingerprint(event) {
   const type = String(event.type ?? "").trim().toLowerCase();
   if (type !== "status")

package/package.json

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

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

@@ -1432,10 +1432,15 @@ def _merge_usage_records(first: Any, second: Any) -> Dict[str, Any]:
     return merged
 
 
+def _is_publishable_changed_path(path: str) -> bool:
+    normalized = str(path or "").replace("\\", "/").lower()
+    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]]:
     changed_paths = summarize_git_changes(repo)
     delta = [p for p in changed_paths if p not in baseline_snapshot]
-    effective = delta if delta else changed_paths
+    effective = [p for p in (delta if delta else changed_paths) if _is_publishable_changed_path(p)]
     return changed_paths, delta, effective
 
 

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

@@ -1,3 +1,4 @@
+import base64
 import os
 import re
 import json
@@ -19,6 +20,7 @@ from executor_base import (
     Logger,
     SettingsResolver,
     config_dir_for_runtime_config,
+    parse_task_execute_payload,
     runtime_config,
 )
 from openai_codex_executor import (
@@ -30,6 +32,7 @@ from openai_codex_executor import (
     _resolve_reasoning_effort,
     _build_instruction,
     _collect_disallowed_shell_wrapper_rejections,
+    _codex_changed_paths,
     _detect_codex_workaround_signal,
     _extract_usage_counts,
     _load_prompt_template,
@@ -257,6 +260,90 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("Keep assertions strict", prompt)
         self.assertIn("bun test tests/localbuddy.request-status.test.ts", prompt)
 
+    def test_parse_payload_adds_structured_planning_guidance(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-planning-guidance-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            payload = {
+                "kind": "task.execute",
+                "repo": str(repo),
+                "params": {
+                    "instruction": "Improve the game startup smoke path",
+                    "schemaVersion": 2,
+                    "planning": {
+                        "intent": "code_change",
+                        "riskLevel": "medium",
+                        "queuePriority": "normal",
+                        "queueWaitBudgetMs": 90_000,
+                        "executionBudgetMs": 1_800_000,
+                        "finalizationBudgetMs": 120_000,
+                        "scope": {
+                            "readAnywhere": True,
+                            "writeAllowed": True,
+                            "writeGlobs": ["app/**", "scripts/**"],
+                        },
+                        "targetPaths": ["app/__tests__/_layout.autonomy.test.ts"],
+                        "discovery": {
+                            "ripgrepQueries": ['rg "home-screen|web:e2e" app scripts'],
+                            "likelyDirs": ["app", "scripts"],
+                            "keywords": ["home-screen", "web:e2e"],
+                        },
+                        "acceptanceCriteria": ["Home shell startup is assertable"],
+                        "validationSteps": ["bun test", "bun run web:e2e"],
+                        "requiredValidationSteps": ["bun run web:e2e"],
+                    },
+                },
+            }
+            encoded = base64.b64encode(json.dumps(payload).encode("utf-8")).decode("ascii")
+
+            task = parse_task_execute_payload(["executor", encoded], logger=Logger("[test]"))
+            guidance = "\n".join(task.supplemental_guidance)
+
+            self.assertIn("Worker speed/convergence contract", guidance)
+            self.assertIn("roughly 20 minutes", guidance)
+            self.assertIn("Task planning contract from PushPals", guidance)
+            self.assertIn("Worker phase contract", guidance)
+            self.assertIn("Write globs are relevance hints, not hard limits", guidance)
+            self.assertIn("app/__tests__/_layout.autonomy.test.ts", guidance)
+            self.assertIn("Home shell startup is assertable", guidance)
+            self.assertIn("bun run web:e2e", guidance)
+
+    def test_parse_payload_prefers_helper_tests_for_visual_derivation_tasks(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-visual-guidance-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            payload = {
+                "kind": "task.execute",
+                "repo": str(repo),
+                "params": {
+                    "instruction": (
+                        "Improve battlefield readability by making planet ownership rings, "
+                        "projectile trails, and danger cues clearer."
+                    ),
+                    "schemaVersion": 2,
+                    "planning": {
+                        "intent": "code_change",
+                        "riskLevel": "medium",
+                        "queuePriority": "normal",
+                        "queueWaitBudgetMs": 90_000,
+                        "executionBudgetMs": 1_800_000,
+                        "finalizationBudgetMs": 120_000,
+                        "scope": {"readAnywhere": True, "writeAllowed": True},
+                        "targetPaths": ["app/game.tsx"],
+                        "acceptanceCriteria": ["Projectile and ownership readability improve"],
+                        "validationSteps": ["bun test app/__tests__/battlefieldReadability.test.ts"],
+                    },
+                },
+            }
+            encoded = base64.b64encode(json.dumps(payload).encode("utf-8")).decode("ascii")
+
+            task = parse_task_execute_payload(["executor", encoded], logger=Logger("[test]"))
+            guidance = "\n".join(task.supplemental_guidance)
+
+            self.assertIn("Visual/rendering task rule", guidance)
+            self.assertIn("prefer pure helper/state/style-prop tests", guidance)
+            self.assertIn("full React Native/component render regression", guidance)
+
     def test_detects_codex_workaround_signals(self) -> None:
         signal = _detect_codex_workaround_signal(
             "Adapting test to avoid external Codex calls because Codex CLI isn't available in this environment.",
@@ -523,6 +610,45 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("src/", str(result.get("stdout") or ""))
         self.assertNotIn("Recovered after Codex attempts", str(result.get("stdout") or ""))
 
+    def test_codex_changed_paths_filters_dependency_artifacts_from_publishable_delta(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-artifact-delta-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# artifact delta test\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 artifact test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            (repo / "node_modules").mkdir()
+            (repo / "node_modules" / "linked.txt").write_text("artifact\n", encoding="utf-8")
+            (repo / "outputs").mkdir()
+            (repo / "outputs" / "runtime.log").write_text("artifact\n", encoding="utf-8")
+            changed_paths, delta, effective = _codex_changed_paths(str(repo), [])
+
+        self.assertGreaterEqual(len(changed_paths), 2)
+        self.assertGreaterEqual(len(delta), 2)
+        self.assertEqual(effective, [])
+
     def test_run_codex_task_escalates_wrapper_recovery_and_recovers(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-wrapper-recovery-") as temp_dir:
             repo = Path(temp_dir) / "repo"

package/runtime/sandbox/apps/workerpals/src/backends/shared/executor_base.py

@@ -717,6 +717,179 @@ def _is_non_actionable_planner_guidance(text: str) -> bool:
     return any(marker in lower for marker in blocked_markers)
 
 
+def _string_list(value: Any, *, limit: int = 12, max_chars: int = 220) -> List[str]:
+    if not isinstance(value, list):
+        return []
+    out: List[str] = []
+    for item in value:
+        text = to_single_line(item, max_chars)
+        if text:
+            out.append(text)
+        if len(out) >= limit:
+            break
+    return out
+
+
+def _append_list_guidance(lines: List[str], label: str, values: List[str]) -> None:
+    if not values:
+        return
+    lines.append(f"- {label}:")
+    for value in values:
+        lines.append(f"  - {value}")
+
+
+def _joined_task_text(params: Dict[str, Any]) -> str:
+    pieces: List[str] = []
+
+    def collect(value: Any) -> None:
+        if isinstance(value, str):
+            pieces.append(value)
+        elif isinstance(value, list):
+            for item in value:
+                collect(item)
+        elif isinstance(value, dict):
+            for item in value.values():
+                collect(item)
+
+    collect(params.get("instruction"))
+    collect(params.get("plannerWorkerInstruction"))
+    collect(params.get("qualityRevisionHint"))
+    planning = params.get("planning")
+    if isinstance(planning, dict):
+        collect(planning.get("targetPaths"))
+        collect(planning.get("acceptanceCriteria"))
+        collect(planning.get("validationSteps"))
+        collect(planning.get("requiredValidationSteps"))
+        collect(planning.get("discovery"))
+    return "\n".join(pieces).lower()
+
+
+def _looks_like_visual_derivation_task(params: Dict[str, Any]) -> bool:
+    text = _joined_task_text(params)
+    visual_markers = (
+        "visual",
+        "readability",
+        "battlefield",
+        "render",
+        "rendering",
+        "projectile",
+        "planet",
+        "ship",
+        "ring",
+        "danger",
+        "threat",
+        "ownership",
+        "dense action",
+        "ui surface",
+        "style",
+        "styles",
+    )
+    return any(marker in text for marker in visual_markers)
+
+
+def _build_efficiency_guidance(params: Dict[str, Any]) -> str:
+    lines: List[str] = [
+        "Worker speed/convergence contract from PushPals:",
+        "- Target useful completion in roughly 20 minutes for small or medium repo tasks; optimize for the smallest coherent patch over exhaustive exploration.",
+        "- Phase soft budgets: discovery <= 5m, editing <= 10m, focused validation <= 5m, final diff review <= 2m. If a phase runs long, narrow scope rather than expanding the harness.",
+        "- Test-harness soft budget: if setting up a focused test requires multiple new shared mocks, broad React Native shims, or repeated import fixes, stop building that harness and switch to smaller pure helper/state coverage.",
+    ]
+    if _looks_like_visual_derivation_task(params):
+        lines.extend(
+            [
+                "- Visual/rendering task rule: prefer pure helper/state/style-prop tests for derived visual cues. Use a full React Native/component render regression only if the repo already has a stable harness for that exact surface.",
+                "- Full-surface React Native tests are a last resort for visual derivation work; do not spend the job constructing broad mocks just to assert pixels or nested component trees.",
+            ]
+        )
+    return "\n".join(lines)
+
+
+def _build_planning_guidance(params: Dict[str, Any]) -> str:
+    planning = params.get("planning")
+    if not isinstance(planning, dict):
+        return ""
+
+    lines: List[str] = ["Task planning contract from PushPals:"]
+    intent = to_single_line(planning.get("intent"), 80)
+    risk = to_single_line(planning.get("riskLevel"), 80)
+    priority = to_single_line(planning.get("queuePriority"), 80)
+    summary_parts = []
+    if intent:
+        summary_parts.append(f"intent={intent}")
+    if risk:
+        summary_parts.append(f"risk={risk}")
+    if priority:
+        summary_parts.append(f"priority={priority}")
+    if summary_parts:
+        lines.append(f"- Planning summary: {', '.join(summary_parts)}")
+    lines.append(
+        "- Worker phase contract: discovering -> editing -> focused validation -> full validation handoff -> final diff review."
+    )
+    lines.append(
+        "  - discovering: inspect relevant files/artifacts and state the current hypothesis before editing."
+    )
+    lines.append("  - editing: make the smallest behavior-owning patch.")
+    lines.append("  - focused validation: run targeted fast checks for the changed surface.")
+    lines.append(
+        "  - full validation: let PushPals ValidationGate own long required/browser checks unless one local confirmation is explicitly useful."
+    )
+    lines.append("  - final diff review: remove unrelated churn before returning.")
+    lines.append(
+        "- Phase soft budget: aim for discovery <= 5m, editing <= 10m, focused validation <= 5m, final diff review <= 2m; if test harness setup starts consuming the budget, reduce to simpler helper/state coverage."
+    )
+
+    scope = planning.get("scope")
+    if isinstance(scope, dict):
+        write_allowed = scope.get("writeAllowed")
+        read_anywhere = scope.get("readAnywhere")
+        scope_parts = []
+        if isinstance(read_anywhere, bool):
+            scope_parts.append(f"read_anywhere={str(read_anywhere).lower()}")
+        if isinstance(write_allowed, bool):
+            scope_parts.append(f"write_allowed={str(write_allowed).lower()}")
+        if scope_parts:
+            lines.append(f"- Repo access: {', '.join(scope_parts)}")
+        write_globs = _string_list(scope.get("writeGlobs"), limit=10)
+        if write_globs:
+            lines.append("- Write globs are relevance hints, not hard limits; edit behavior-owning files as needed.")
+            _append_list_guidance(lines, "Write-scope hints", write_globs)
+        forbidden = _string_list(scope.get("forbiddenGlobs"), limit=8)
+        _append_list_guidance(lines, "Forbidden path hints", forbidden)
+
+    _append_list_guidance(lines, "Target path hints", _string_list(planning.get("targetPaths"), limit=12))
+
+    discovery = planning.get("discovery")
+    if isinstance(discovery, dict):
+        _append_list_guidance(
+            lines,
+            "Suggested discovery commands",
+            _string_list(discovery.get("ripgrepQueries"), limit=8),
+        )
+        _append_list_guidance(lines, "Likely directories", _string_list(discovery.get("likelyDirs"), limit=8))
+        _append_list_guidance(lines, "Search keywords", _string_list(discovery.get("keywords"), limit=12))
+
+    _append_list_guidance(
+        lines,
+        "Acceptance criteria",
+        _string_list(planning.get("acceptanceCriteria"), limit=10, max_chars=260),
+    )
+    _append_list_guidance(
+        lines,
+        "Planned validation steps",
+        _string_list(planning.get("validationSteps"), limit=8, max_chars=260),
+    )
+    _append_list_guidance(
+        lines,
+        "Required vision.md validation steps",
+        _string_list(planning.get("requiredValidationSteps"), limit=8, max_chars=260),
+    )
+
+    guidance = "\n".join(lines).strip()
+    if len(guidance) > 4000:
+        guidance = guidance[:4000].rstrip() + "\n- Planning guidance truncated to stay within worker prompt budget."
+    return guidance
+
+
 def parse_task_execute_payload(
     argv: List[str],
     *,
@@ -765,6 +938,10 @@ def parse_task_execute_payload(
     quality_revision_hint = str(params.get("qualityRevisionHint") or "").strip()
 
     supplemental_guidance: List[str] = []
+    supplemental_guidance.append(_build_efficiency_guidance(params))
+    planning_guidance = _build_planning_guidance(params)
+    if planning_guidance:
+        supplemental_guidance.append(planning_guidance)
     if planner_instruction and planner_instruction != instruction:
         if _is_non_actionable_planner_guidance(planner_instruction):
             log.info(

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

@@ -43,10 +43,10 @@ const WORKERPAL_SANDBOX_COMPONENT_LABEL = "pushpals.component=workerpals-sandbox
 const DOCKER_IMAGE_INSPECT_TIMEOUT_MS = 15_000;
 const DOCKER_IMAGE_BUILD_TIMEOUT_MS = 10 * 60_000;
 const DOCKER_IMAGE_PULL_TIMEOUT_MS = 10 * 60_000;
-const BROWSER_VALIDATION_JOB_REPAIR_ATTEMPTS = 8;
-const BROWSER_VALIDATION_JOB_OVERHEAD_MS = 15 * 60_000;
-const BROWSER_VALIDATION_JOB_MIN_TIMEOUT_MS = 4 * 60 * 60_000;
-const BROWSER_VALIDATION_JOB_MAX_TIMEOUT_MS = 8 * 60 * 60_000;
+const BROWSER_VALIDATION_JOB_REPAIR_ATTEMPTS = 3;
+const BROWSER_VALIDATION_JOB_OVERHEAD_MS = 5 * 60_000;
+const BROWSER_VALIDATION_JOB_MIN_TIMEOUT_MS = 20 * 60_000;
+const BROWSER_VALIDATION_JOB_MAX_TIMEOUT_MS = 45 * 60_000;
 
 function parseClampedInt(value: unknown, defaultValue: number, min: number, max: number): number {
   const parsed =
@@ -312,7 +312,7 @@ export function resolveDockerJobTimeoutMs(
     BROWSER_VALIDATION_JOB_MAX_TIMEOUT_MS,
     Math.max(BROWSER_VALIDATION_JOB_MIN_TIMEOUT_MS, estimatedTimeoutMs),
   );
-  return Math.max(baseTimeoutMs, boundedTimeoutMs);
+  return Math.max(Math.min(baseTimeoutMs, boundedTimeoutMs), BROWSER_VALIDATION_JOB_MIN_TIMEOUT_MS);
 }
 
 export class DockerExecutor {
@@ -1221,7 +1221,8 @@ export class DockerExecutor {
     });
     const timeoutMs = resolveDockerJobTimeoutMs(this.options.timeoutMs, job);
     if (timeoutMs !== this.options.timeoutMs) {
-      const note = `[DockerExecutor] Extended job timeout for browser validation convergence: ${timeoutMs}ms (configured ${this.options.timeoutMs}ms).`;
+      const verb = timeoutMs > this.options.timeoutMs ? "Extended" : "Capped";
+      const note = `[DockerExecutor] ${verb} job timeout for browser validation convergence: ${timeoutMs}ms (configured ${this.options.timeoutMs}ms).`;
       console.log(note);
       onLog?.("stdout", note);
     }
@@ -1246,7 +1247,7 @@ export class DockerExecutor {
     const timer = setTimeout(() => {
       timedOutByDocker = true;
       const elapsedMs = Math.max(1, Date.now() - startedAtMs);
-      const timeoutMsg = `[DockerExecutor] Job timeout in warm container after ${elapsedMs}ms (limit ${this.options.timeoutMs}ms): ${this.warmContainerName}`;
+      const timeoutMsg = `[DockerExecutor] Job timeout in warm container after ${elapsedMs}ms (limit ${timeoutMs}ms): ${this.warmContainerName}`;
       console.log(timeoutMsg);
       onLog?.("stderr", timeoutMsg);
       try {