@pushpalsdev/cli 1.1.10 → 1.1.11

package/dist/pushpals-cli.js

@@ -3036,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})...`);
@@ -3057,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);
@@ -4695,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")) {
@@ -4738,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;
@@ -5208,8 +5233,10 @@ function formatSessionEventLine(event) {
   if (type === "job_log") {
     const jobId = String(payload.jobId ?? "").slice(0, 8);
     const stream = String(payload.stream ?? "").toLowerCase() === "stderr" ? " stderr" : "";
-    const line = compactCliSessionJobLogLine(String(payload.line ?? "").trim());
-    return line ? `[job ${jobId}${stream}] ${line}` : null;
+    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);
@@ -5264,6 +5291,47 @@ function compactCliSessionJobLogLine(line) {
     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.10",
+  "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

@@ -32,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,
@@ -298,6 +299,8 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             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)
@@ -305,6 +308,42 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             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.",
@@ -571,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

@@ -738,6 +738,72 @@ def _append_list_guidance(lines: List[str], label: str, values: List[str]) -> No
         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):
@@ -768,6 +834,9 @@ def _build_planning_guidance(params: Dict[str, Any]) -> str:
         "  - 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):
@@ -869,6 +938,7 @@ 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)

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 {

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

@@ -176,7 +176,7 @@ export interface QualityGatePolicy {
   criticMinScore: number;
 }
 
-const BROWSER_VALIDATION_MAX_AUTO_REVISIONS = 8;
+const BROWSER_VALIDATION_MAX_AUTO_REVISIONS = 3;
 
 export function qualityRevisionLoopUpperBound(policy: {
   maxAutoRevisions: number;
@@ -378,6 +378,97 @@ function buildDiffBudgetWarning(
     .join(", ")}${meaningfulChangedPaths.length > 12 ? ", ..." : ""}`;
 }
 
+function isNonPublishableArtifactPath(path: string): boolean {
+  return /(^|\/)(outputs|node_modules|\.worktrees|\.codex|dist|build|coverage)(\/|$)/i.test(
+    path.replace(/\\/g, "/"),
+  );
+}
+
+export function publishableChangedPaths(changedPaths: string[]): string[] {
+  return changedPaths.filter((path) => !isNonPublishableArtifactPath(path));
+}
+
+function collectPlanningText(planning: TaskExecutePlanning): string {
+  return [
+    planning.intent,
+    planning.riskLevel,
+    ...(planning.targetPaths ?? []),
+    ...(planning.acceptanceCriteria ?? []),
+    ...(planning.validationSteps ?? []),
+    ...(planning.requiredValidationSteps ?? []),
+    ...(planning.discovery?.keywords ?? []),
+    ...(planning.discovery?.likelyDirs ?? []),
+    ...(planning.discovery?.ripgrepQueries ?? []),
+  ]
+    .map((part) => String(part ?? ""))
+    .join("\n")
+    .toLowerCase();
+}
+
+function planningLooksLikeVisualDerivationTask(planning: TaskExecutePlanning): boolean {
+  const text = collectPlanningText(planning);
+  return /\b(visual|readability|battlefield|render(?:ing)?|projectile|planet|ship|ring|danger|threat|ownership|dense action|style|ui surface)\b/i.test(
+    text,
+  );
+}
+
+function buildTestHarnessConvergenceWarning(
+  planning: TaskExecutePlanning,
+  issues: string[],
+  validationRuns: ValidationExecutionResult[],
+): string | null {
+  const combined = [
+    ...issues,
+    ...validationRuns.flatMap((run) => [run.command, run.stdout, run.stderr]),
+  ]
+    .map((part) => String(part ?? ""))
+    .join("\n");
+  const hasMockImportFailure =
+    /\bCannot find module\b|\bdoes not provide an export\b|\bno exported member\b|\bimport error\b|\bundefined is not a function\b/i.test(
+      combined,
+    ) &&
+    /\b(react[- ]native|reactNativeMock|Animated\.View|expo-secure-store|SettingsContext|skin validator|mock|test helper|__mocks__)\b/i.test(
+      combined,
+    );
+  if (!hasMockImportFailure) return null;
+  const visualPrefix = planningLooksLikeVisualDerivationTask(planning)
+    ? " For this visual/rendering task, prefer pure helper/state/style-prop tests over a full React Native surface render."
+    : "";
+  return (
+    "Test harness convergence warning: validation is failing in mock/import setup rather than product behavior." +
+    visualPrefix +
+    " Do not keep expanding broad shared mocks to rescue an over-scoped component render test. If the repo does not already have stable React Native render-test infrastructure for this surface, replace the full-surface regression with smaller deterministic helper/state coverage and one focused assertion on the behavior-owning API."
+  );
+}
+
+function buildBroadSharedMockWarning(
+  planning: TaskExecutePlanning,
+  changedPaths: string[],
+): string | null {
+  const meaningfulChangedPaths = changedPaths.filter(
+    (path) => !/(^|\/)(outputs|node_modules|\.worktrees|dist|build|coverage)(\/|$)/i.test(path),
+  );
+  const broadMockPaths = meaningfulChangedPaths.filter((path) =>
+    /(^|\/)(__mocks__|tests\/.*mock|test.*mock|reactNativeMock|setupTests?|jest\.|vitest\.|mock)(\.|\/|$)/i.test(
+      path,
+    ),
+  );
+  if (broadMockPaths.length === 0) return null;
+  const smallTask =
+    planning.riskLevel !== "high" &&
+    ((planning.targetPaths?.length ?? 0) <= 2 || planning.acceptanceCriteria.length <= 3);
+  if (!smallTask && !planningLooksLikeVisualDerivationTask(planning)) return null;
+  const explicitlyRequested = /mock|test harness|react native test|component render/i.test(
+    collectPlanningText(planning),
+  );
+  if (explicitlyRequested) return null;
+  return `Broad mock warning: this focused task now changes shared mock/test-harness file(s): ${broadMockPaths
+    .slice(0, 6)
+    .join(", ")}${
+    broadMockPaths.length > 6 ? ", ..." : ""
+  }. Before continuing, prefer behavior-owned helper/state tests or existing stable render-test infrastructure; do not add broad React Native mocks for a small visual/control change unless the task explicitly requires harness repair.`;
+}
+
 const TEST_ASSERTION_BALANCE_ISSUE =
   "Changed test files do not show both positive and negative assertion coverage (expected both).";
 
@@ -3527,6 +3618,22 @@ export function buildQualityRevisionHint(
   );
   const diffBudgetWarning = buildDiffBudgetWarning(planning, changedPaths, focusedBrowserRepair);
   if (diffBudgetWarning) lines.push(diffBudgetWarning);
+  const broadSharedMockWarning = buildBroadSharedMockWarning(planning, changedPaths);
+  if (broadSharedMockWarning) lines.push(broadSharedMockWarning);
+  const testHarnessConvergenceWarning = buildTestHarnessConvergenceWarning(
+    planning,
+    issues,
+    validationRuns,
+  );
+  if (testHarnessConvergenceWarning) lines.push(testHarnessConvergenceWarning);
+  if (planningLooksLikeVisualDerivationTask(planning)) {
+    lines.push(
+      "Visual derivation testing rule: prefer pure helper/state/style-prop tests for planet/projectile/ownership/readability cues. Only add a full React Native render regression when this repo already has a stable harness for that exact surface; otherwise keep render-visible behavior covered through the derived inputs that drive it.",
+    );
+  }
+  lines.push(
+    "Phase soft-budget reminder: if discovery, test-harness setup, or validation repair is running long, reduce the approach before spending more time. Small/medium tasks should converge toward a useful patch within roughly 20 minutes.",
+  );
   const validationAlreadyPassed =
     validationRuns.length > 0 && validationRuns.every((run) => run.ok);
   if (validationAlreadyPassed && !focusedBrowserRepair) {
@@ -6645,6 +6752,53 @@ export async function executeJob(
       };
     }
 
+    const preQualityStatus = await git(repo, ["status", "--porcelain"]);
+    const preQualityChangedPaths = preQualityStatus.ok
+      ? parseChangedPathsFromStatus(preQualityStatus.stdout)
+      : [];
+    const preQualityPublishablePaths = publishableChangedPaths(preQualityChangedPaths);
+    const executorText = `${result.summary ?? ""}\n${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    const shellWrapperReturn =
+      /shell-wrapper command rejections|command-router shell-wrapper|command policy rejection/i.test(
+        executorText,
+      );
+    if (preQualityChangedPaths.length > 0 && preQualityPublishablePaths.length === 0) {
+      const detail = `Executor changed only non-publishable dependency/runtime artifact path(s): ${preQualityChangedPaths
+        .slice(0, 12)
+        .join(", ")}${preQualityChangedPaths.length > 12 ? ", ..." : ""}.`;
+      onLog?.(
+        "stderr",
+        `[QualityGate] ${detail} Skipping ValidationGate/CriticGate because there is no PR-worthy patch to validate.`,
+      );
+      return {
+        ok: false,
+        summary: "Executor produced no publishable code changes",
+        stdout: result.stdout,
+        stderr: [result.stderr ?? "", detail].filter(Boolean).join("\n"),
+        exitCode: 4,
+      };
+    }
+    if (
+      preQualityPublishablePaths.length === 0 &&
+      (qualityGatePolicy.mode === "review_fix" || shellWrapperReturn)
+    ) {
+      const reason =
+        qualityGatePolicy.mode === "review_fix"
+          ? "Review-fix executor returned without publishable code changes."
+          : "Codex hit shell-wrapper command rejections without leaving a publishable patch.";
+      onLog?.(
+        "stderr",
+        `[QualityGate] ${reason} Skipping ValidationGate/CriticGate and failing fast.`,
+      );
+      return {
+        ok: false,
+        summary: reason,
+        stdout: result.stdout,
+        stderr: [result.stderr ?? "", reason].filter(Boolean).join("\n"),
+        exitCode: 4,
+      };
+    }
+
     const quality = await runDeterministicQualityGate(
       repo,
       attemptParams,

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

@@ -342,6 +342,70 @@ function isNoisyProgressLine(line: string): boolean {
   return /^(📦 Installing \[\d+\/\d+\]|🔍 Resolving\.\.\.|🔒 Saving lockfile\.\.\.)$/.test(line);
 }
 
+type WorkerJobPhase =
+  | "discovering"
+  | "editing"
+  | "test harness repair"
+  | "focused validation"
+  | "full validation"
+  | "final diff review"
+  | "publishing"
+  | "quality revision";
+
+function inferWorkerJobPhaseFromLogLine(line: string): WorkerJobPhase | null {
+  const text = String(line ?? "").trim();
+  if (!text) return null;
+  if (/Quality gate requested revision|Quality revision required|revision guidance/i.test(text)) {
+    return "quality revision";
+  }
+  if (
+    /test harness|React Native package|reactNativeMock|mock helper|mock was missing|expo-secure-store|import error|Cannot find module|does not provide an export|no exported member|Animated\.View|SettingsContext|skin validator/i.test(
+      text,
+    )
+  ) {
+    return "test harness repair";
+  }
+  if (
+    /focused validation|focused checks|targeted test|focused test|new regression|focused regression|fast checks|rerunning .*regression|node --check/i.test(
+      text,
+    )
+  ) {
+    return "focused validation";
+  }
+  if (
+    /ValidationGate|required validation|full .*test suite|whole Bun test|repo-level|bun test\b|bunx? tsc|typecheck|type check|bun run lint|web:e2e|browser smoke/i.test(
+      text,
+    )
+  ) {
+    return "full validation";
+  }
+  if (/creating commit|Publish blocked|publish-blocked|completion ref|enqueueCompletion/i.test(text)) {
+    return "publishing";
+  }
+  if (
+    /final diff|diff review|git diff|git status|whitespace|line-ending|line ending|pruning|remove unrelated|remaining diff|changed files/i.test(
+      text,
+    )
+  ) {
+    return "final diff review";
+  }
+  if (
+    /editing|patch|implemented|adding|fixing|updating|wiring|in place|changes are in place|making .*change|tightening|restore|normalizing/i.test(
+      text,
+    )
+  ) {
+    return "editing";
+  }
+  if (
+    /read|inspect|checking|locating|opening|artifact|screenshot|README|context|discover|search|rg |current checkout|worktree/i.test(
+      text,
+    )
+  ) {
+    return "discovering";
+  }
+  return null;
+}
+
 export function shouldEmitDirectSessionJobEvent(options: {
   ok: boolean;
   statusPersistedToServer: boolean;
@@ -1352,6 +1416,7 @@ async function workerLoop(
           let lastCleanLog = "";
           let lastCleanLogAt = 0;
           let lastForwardedJobLogAt = Date.now();
+          let currentJobPhase: WorkerJobPhase | null = null;
 
           const emitJobLog = job.sessionId
             ? (stream: "stdout" | "stderr", line: string): boolean => {
@@ -1367,6 +1432,7 @@ async function workerLoop(
                 lastCleanLog = cleaned;
                 lastCleanLogAt = now;
                 lastForwardedJobLogAt = now;
+                currentJobPhase = inferWorkerJobPhaseFromLogLine(cleaned) ?? currentJobPhase;
                 const logTs = new Date(now).toISOString();
 
                 const seq = stream === "stdout" ? ++stdoutSeq : ++stderrSeq;
@@ -1374,7 +1440,14 @@ async function workerLoop(
                   job.sessionId,
                   {
                     type: "job_log",
-                    payload: { jobId: job.id, stream, seq, line: cleaned, ts: logTs },
+                    payload: {
+                      jobId: job.id,
+                      stream,
+                      seq,
+                      line: cleaned,
+                      ts: logTs,
+                      phase: currentJobPhase,
+                    },
                     from: `worker:${opts.workerId}`,
                   },
                   { droppable: true },
@@ -1409,9 +1482,9 @@ async function workerLoop(
                     "stdout",
                     `[WorkerPals] Job ${job.id} still running after ${formatDurationMs(
                       now - jobClaimedAtMs,
-                    )} (kind=${job.kind}, worker=${opts.workerId}, quiet_for=${formatDurationMs(
-                      quietForMs,
-                    )}).`,
+                    )} (kind=${job.kind}, worker=${opts.workerId}, phase=${
+                      currentJobPhase ?? "unknown"
+                    }, quiet_for=${formatDurationMs(quietForMs)}).`,
                   );
                 }, jobProgressLogEveryMs)
               : null;