@pushpalsdev/cli 1.1.5 → 1.1.7

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

@@ -635,6 +635,7 @@ export function tokenizeValidationCommandArgv(command: string): string[] | null
   const out: string[] = [];
   let current = "";
   let quote: "'" | '"' | null = null;
+  let escaped = false;
 
   const pushCurrent = () => {
     if (!current) return;
@@ -643,7 +644,16 @@ export function tokenizeValidationCommandArgv(command: string): string[] | null
   };
 
   for (const ch of trimmed) {
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
     if (quote) {
+      if (quote === '"' && ch === "\\") {
+        escaped = true;
+        continue;
+      }
       if (ch === quote) {
         quote = null;
       } else {
@@ -662,6 +672,7 @@ export function tokenizeValidationCommandArgv(command: string): string[] | null
     }
     current += ch;
   }
+  if (escaped) current += "\\";
   if (quote) return null;
   pushCurrent();
   if (out.length === 0) return null;
@@ -826,6 +837,11 @@ export async function runValidationArgv(
   outputPolicy: Partial<OutputCompactionPolicy>,
   timeoutMessage: string,
 ): Promise<ValidationExecutionResult> {
+  type ValidationWaitResult =
+    | { type: "exit"; code: number }
+    | { type: "timeout" }
+    | { type: "failure-signal" }
+    | { type: "success-signal" };
   const startedAt = Date.now();
   const proc = Bun.spawn(argv, {
     cwd: repo,
@@ -846,7 +862,7 @@ export async function runValidationArgv(
   let stoppedAfterSuccessSignal = false;
   const timeout = Math.max(1_000, timeoutMs);
   let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
-  const timeoutPromise = new Promise<{ type: "timeout" }>((resolveTimeout) => {
+  const timeoutPromise = new Promise<ValidationWaitResult>((resolveTimeout) => {
     timeoutTimer = setTimeout(() => {
       timedOut = true;
       resolveTimeout({ type: "timeout" });
@@ -855,7 +871,7 @@ export async function runValidationArgv(
 
   let browserSignalTimer: ReturnType<typeof setInterval> | null = null;
   const browserSignalPromise = isLongRunningBrowserValidationCommand(command)
-    ? new Promise<{ type: "failure-signal" | "success-signal" }>((resolveBrowserSignal) => {
+    ? new Promise<ValidationWaitResult>((resolveBrowserSignal) => {
         const idleMs = browserValidationFailureIdleMs(env);
         const successIdleMs = browserValidationSuccessIdleMs(env);
         browserSignalTimer = setInterval(() => {
@@ -877,11 +893,11 @@ export async function runValidationArgv(
           }
         }, 250);
       })
-    : new Promise<never>(() => {
+    : new Promise<ValidationWaitResult>(() => {
         // Non-browser validations should only end on process exit or timeout.
       });
 
-  const exitOrTimeout = await Promise.race([
+  const exitOrTimeout = await Promise.race<ValidationWaitResult>([
     proc.exited.then((code) => ({ type: "exit" as const, code })),
     timeoutPromise,
     browserSignalPromise,
@@ -1740,9 +1756,9 @@ function classifyBrowserValidationFailureKindFromText(text: string): BrowserVali
 
 function extractBrowserValidationStage(text: string): string | null {
   const patterns = [
-    /\bBrowser validation failed during\s+([^:.\r\n]+?)\s+stage\b/i,
-    /\bfailed during\s+([^:.\r\n]+?)\s+stage\b/i,
-    /\b(?:stage|phase)\s*[:=]\s*["'`]?([^"'`.\r\n]+)["'`]?/i,
+    /\bBrowser validation failed during\s+([^:.\r\n|]+?)\s+stage\b/i,
+    /\bfailed during\s+([^:.\r\n|]+?)\s+stage\b/i,
+    /\b(?:stage|phase)\s*[:=]\s*["'`]?([^"'`.\r\n|]+)["'`]?/i,
   ];
   for (const pattern of patterns) {
     const match = text.match(pattern);
@@ -1757,6 +1773,27 @@ function extractBrowserValidationStage(text: string): string | null {
   return null;
 }
 
+function refineBrowserValidationStage(
+  stage: string | null,
+  selector: string | null,
+  expected: string | null,
+  text: string,
+): string | null {
+  const combined = stripAnsiControlSequences(
+    [stage, selector, expected, text].filter(Boolean).join(" "),
+  ).toLowerCase();
+  if (/\b(game-control-panel|planet control panel|selected planet panel)\b/i.test(combined)) {
+    return "planet control panel";
+  }
+  if (/\bsettings-home-button\b|\breturn to home from settings\b/i.test(combined)) {
+    return "settings return";
+  }
+  if (/\bshop-home-button\b|\breturn to home from shop\b/i.test(combined)) {
+    return "shop return";
+  }
+  return stage;
+}
+
 function inferBrowserValidationFailureFocus(params: {
   stage?: string | null;
   selector?: string | null;
@@ -1980,13 +2017,60 @@ function summarizeBrowserValidationOutput(text: string): string {
     .map((line) => line.trim())
     .filter(Boolean)
     .filter((line) =>
-      /\b(Web end-to-end smoke test failed|Browser validation failed|Expected |locator\.|page\.|waiting for getBy|Call log:|ERR_SOCKET_BAD_PORT|EADDRINUSE|EPERM|EACCES|browserType\.launch|Executable doesn't exist|Expo exited early|freeport|net::ERR_|Validation command timed out|terminated by signal|SIGTERM|timed out after \d+ms)/i.test(
+      /\b(Web end-to-end smoke test failed|Browser validation failed|Expected |locator\.|page\.|waiting for getBy|Call log:|Verified:|Saved screenshot|Saved trace|ERR_SOCKET_BAD_PORT|EADDRINUSE|EPERM|EACCES|browserType\.launch|Executable doesn't exist|Expo exited early|freeport|net::ERR_|Validation command timed out|terminated by signal|SIGTERM|timed out after \d+ms)/i.test(
         line,
       ),
     );
   return toSingleLine(lines.slice(0, 8).join(" | "), 900);
 }
 
+function lastBrowserVerifiedStage(text: string): string | null {
+  const verifiedStages = [...stripAnsiControlSequences(text).matchAll(/\bVerified:\s+([^|\r\n]+)/gi)]
+    .map((match) => match[1]?.trim())
+    .filter((entry): entry is string => Boolean(entry));
+  const lastVerified = verifiedStages.at(-1);
+  return lastVerified ? toSingleLine(lastVerified, 80) : null;
+}
+
+export function extractValidationFailureRetryDigest(
+  run: {
+    command: string;
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+    elapsedMs?: number;
+  },
+  repo?: string,
+): string {
+  const baseDigest = extractValidationFailureDigest(run);
+  if (!isLongRunningBrowserValidationCommand(run.command)) return baseDigest;
+  const combined = stripAnsiControlSequences([run.stderr, run.stdout].filter(Boolean).join("\n"));
+  const failureKind = classifyBrowserValidationFailureKindFromText(`${baseDigest}\n${combined}`);
+  if (failureKind !== "assertion") return baseDigest;
+
+  const recentLogSummary = summarizeRecentBrowserValidationLogs(repo);
+  const enrichedBrowserContext = [combined, recentLogSummary].filter(Boolean).join("\n");
+  const selector = extractBrowserValidationSelector(enrichedBrowserContext);
+  const expected = extractBrowserValidationExpectedUi(enrichedBrowserContext);
+  const stage = refineBrowserValidationStage(
+    extractBrowserValidationStage(enrichedBrowserContext),
+    selector,
+    expected,
+    enrichedBrowserContext,
+  );
+  const lastVerified = lastBrowserVerifiedStage(enrichedBrowserContext);
+  const output = summarizeBrowserValidationOutput(enrichedBrowserContext);
+  const parts = [
+    baseDigest,
+    stage ? `stage=${stage}` : "",
+    selector ? `selector=${selector}` : "",
+    expected ? `expected=${expected}` : "",
+    lastVerified ? `last verified=${lastVerified}` : "",
+    output && output !== baseDigest ? output : "",
+  ].filter(Boolean);
+  return toSingleLine(parts.join(" | "), 900) || baseDigest;
+}
+
 export function buildBrowserValidationRepairPacket(
   validationRuns: ValidationExecutionResult[],
   previousFailureDigests: Map<string, string> = new Map(),
@@ -1995,15 +2079,24 @@ export function buildBrowserValidationRepairPacket(
   for (const run of validationRuns) {
     if (run.ok || !isLongRunningBrowserValidationCommand(run.command)) continue;
     const combined = stripAnsiControlSequences([run.stderr, run.stdout].filter(Boolean).join("\n"));
-    const digest = extractValidationFailureDigest(run);
-    const failureKind = classifyBrowserValidationFailureKindFromText(`${digest}\n${combined}`);
+    const baseDigest = extractValidationFailureDigest(run);
+    const failureKind = classifyBrowserValidationFailureKindFromText(`${baseDigest}\n${combined}`);
     if (failureKind === "unknown") continue;
+    const digest =
+      failureKind === "assertion"
+        ? extractValidationFailureRetryDigest(run, repo) || baseDigest
+        : baseDigest;
     const previousDigest = previousFailureDigests.get(validationCommandKey(run.command)) ?? null;
     const recentLogSummary = summarizeRecentBrowserValidationLogs(repo);
     const enrichedBrowserContext = [combined, recentLogSummary].filter(Boolean).join("\n");
-    const stage = extractBrowserValidationStage(enrichedBrowserContext);
     const selector = extractBrowserValidationSelector(enrichedBrowserContext);
     const expected = extractBrowserValidationExpectedUi(enrichedBrowserContext);
+    const stage = refineBrowserValidationStage(
+      extractBrowserValidationStage(enrichedBrowserContext),
+      selector,
+      expected,
+      enrichedBrowserContext,
+    );
     const previousStage = previousDigest ? extractBrowserValidationStage(previousDigest) : null;
     const previousSelector = previousDigest ? extractBrowserValidationSelector(previousDigest) : null;
     const previousExpected = previousDigest ? extractBrowserValidationExpectedUi(previousDigest) : null;
@@ -2021,17 +2114,21 @@ export function buildBrowserValidationRepairPacket(
           text: previousDigest,
         })
       : null;
+    const sameFailureSignal =
+      Boolean(previousDigest) &&
+      (previousDigest === digest ||
+        (Boolean(failureFocus) &&
+          failureFocus === previousFailureFocus &&
+          (!selector || !previousSelector || selector === previousSelector)));
     const progress =
       previousDigest == null
         ? "first_failure"
-        : previousDigest === digest
+        : sameFailureSignal
           ? "same_failure"
           : "new_failure";
     const needsDiagnosticProbe =
       failureKind === "assertion" &&
-      Boolean(previousDigest) &&
-      Boolean(failureFocus) &&
-      failureFocus === previousFailureFocus;
+      sameFailureSignal;
     return {
       command: run.command,
       failureKind,
@@ -2203,14 +2300,19 @@ export function inferFallbackValidationCommandsForTestTask(
     /\b(pytest|python)\b/.test(lowerInstruction) ||
     changedTestPaths.some((entry) => entry.toLowerCase().endsWith(".py"));
 
+  const bunTestPath = (path: string) => formatBunTestPathArg(path);
   const normalizedTarget = (targetPath ?? "").replace(/\\/g, "/").trim();
   if (normalizedTarget && isLikelyTestPath(normalizedTarget)) {
-    add(pythonSignal ? `pytest ${normalizedTarget}` : `bun test ${normalizedTarget}`);
+    add(pythonSignal ? `pytest ${normalizedTarget}` : `bun test ${bunTestPath(normalizedTarget)}`);
   }
 
   if (changedTestPaths.length > 0) {
-    const focused = changedTestPaths.slice(0, 4).join(" ");
-    add(pythonSignal ? `pytest ${focused}` : `bun test ${focused}`);
+    const focused = changedTestPaths.slice(0, 4);
+    add(
+      pythonSignal
+        ? `pytest ${focused.join(" ")}`
+        : `bun test ${focused.map((entry) => bunTestPath(entry)).join(" ")}`,
+    );
   }
 
   const scopeHints = [
@@ -2238,6 +2340,24 @@ export function inferFallbackValidationCommandsForTestTask(
   return candidates.slice(0, 4);
 }
 
+export function formatBunTestPathArg(path: string): string {
+  const normalized = String(path ?? "").replace(/\\/g, "/").trim();
+  if (!normalized) return normalized;
+  const pathArg =
+    normalized.startsWith("./") ||
+    normalized.startsWith("../") ||
+    normalized.startsWith("/") ||
+    /^[A-Za-z]:\//.test(normalized)
+      ? normalized
+      : `./${normalized}`;
+  return quoteValidationCommandArg(pathArg);
+}
+
+function quoteValidationCommandArg(arg: string): string {
+  if (!/[\s"\\]/.test(arg)) return arg;
+  return `"${arg.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
 export function isTestFocusedTask(
   instruction: string,
   planning: TaskExecutePlanning,
@@ -2642,49 +2762,67 @@ async function runDeterministicQualityGate(
   };
 }
 
-async function runTaskCriticReview(
-  repo: string,
-  params: Record<string, unknown>,
-  quality: DeterministicQualityResult,
+type QualityCriticTimeoutBehavior = "skip" | "retry_once" | "block";
+
+function resolveQualityCriticTimeoutMs(runtimeConfig: WorkerpalsRuntimeConfig): number {
+  const value = Number(runtimeConfig.workerpals.qualityCriticTimeoutMs);
+  if (!Number.isFinite(value)) return 90_000;
+  return Math.max(1_000, Math.min(7_200_000, Math.floor(value)));
+}
+
+function resolveQualityCriticTimeoutBehavior(
   runtimeConfig: WorkerpalsRuntimeConfig,
-  onLog?: (stream: "stdout" | "stderr", line: string) => void,
-): Promise<CriticReview | null> {
-  const endpoint = normalizeChatCompletionsEndpoint(runtimeConfig.workerpals.llm.endpoint);
-  const model = runtimeConfig.workerpals.llm.model.trim();
-  if (!endpoint || !model) return null;
+): QualityCriticTimeoutBehavior {
+  const value = String(runtimeConfig.workerpals.qualityCriticTimeoutBehavior ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, "_");
+  if (value === "skip" || value === "retry_once" || value === "block") return value;
+  return "retry_once";
+}
 
-  const changedForDiff = quality.changedPaths.slice(0, 8);
-  let diffText = "";
-  if (changedForDiff.length > 0) {
-    const diffResult = await git(repo, ["diff", "--", ...changedForDiff]);
-    diffText = diffResult.ok ? diffResult.stdout : diffResult.stderr;
-  }
-  const qualityCriticMaxDiffChars = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticMaxDiffChars);
-    if (!Number.isFinite(value)) return 16_000;
-    return Math.max(256, Math.min(524_288, Math.floor(value)));
-  })();
-  const qualityCriticMaxValidationOutputChars = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticMaxValidationOutputChars);
-    if (!Number.isFinite(value)) return 8_000;
-    return Math.max(256, Math.min(524_288, Math.floor(value)));
-  })();
-  const qualityCriticTimeoutMs = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticTimeoutMs);
-    if (!Number.isFinite(value)) return 45_000;
-    return Math.max(1_000, Math.min(7_200_000, Math.floor(value)));
-  })();
-  diffText = compactJobOutput(diffText, outputPolicyForRuntime(runtimeConfig)).slice(
-    0,
-    qualityCriticMaxDiffChars,
-  );
+function resolveQualityCriticModel(
+  runtimeConfig: WorkerpalsRuntimeConfig,
+  fallback = "",
+): string {
+  return String(runtimeConfig.workerpals.qualityCriticModel ?? "").trim() || fallback.trim();
+}
+
+function resolveQualityCriticMaxDiffChars(
+  runtimeConfig: WorkerpalsRuntimeConfig,
+  compact = false,
+): number {
+  const value = Number(runtimeConfig.workerpals.qualityCriticMaxDiffChars);
+  const max = Number.isFinite(value) ? value : 16_000;
+  const bounded = Math.max(256, Math.min(524_288, Math.floor(max)));
+  return compact ? Math.min(bounded, 6_000) : bounded;
+}
 
-  const validationSummary = quality.validationRuns
+function resolveQualityCriticMaxValidationOutputChars(
+  runtimeConfig: WorkerpalsRuntimeConfig,
+  compact = false,
+): number {
+  const value = Number(runtimeConfig.workerpals.qualityCriticMaxValidationOutputChars);
+  const max = Number.isFinite(value) ? value : 8_000;
+  const bounded = Math.max(256, Math.min(524_288, Math.floor(max)));
+  return compact ? Math.min(bounded, 2_000) : bounded;
+}
+
+function buildCriticValidationSummary(
+  quality: DeterministicQualityResult,
+  maxValidationOutputChars: number,
+): string {
+  const allPassed =
+    quality.validationRuns.length > 0 && quality.validationRuns.every((run) => run.ok);
+  return quality.validationRuns
     .map((run) => {
-      const output = [run.stdout, run.stderr]
-        .filter(Boolean)
-        .join("\n")
-        .slice(0, qualityCriticMaxValidationOutputChars);
+      const output =
+        allPassed
+          ? ""
+          : [run.stdout, run.stderr]
+              .filter(Boolean)
+              .join("\n")
+              .slice(0, maxValidationOutputChars);
       return [
         `Command: ${run.command}`,
         `Result: ${run.ok ? "pass" : "fail"} (exit ${run.exitCode}, ${run.elapsedMs}ms)`,
@@ -2694,6 +2832,38 @@ async function runTaskCriticReview(
         .join("\n");
     })
     .join("\n\n---\n\n");
+}
+
+function criticTimeoutReview(
+  source: "Codex" | "LLM",
+  timeoutMs: number,
+  elapsedMs: number,
+): CriticReview {
+  const summary = `${source} critic timed out after ${elapsedMs}ms (timeout=${timeoutMs}ms).`;
+  return {
+    score: 0,
+    findings: [summary],
+    mustFix: [
+      "CriticGate timeout behavior is set to block; complete the critic review by reducing critic input, choosing a faster critic model, or increasing workerpals.quality_critic_timeout_ms.",
+    ],
+    revisionGuidance:
+      "Do not change product code for this finding unless product code caused the critic prompt explosion. Adjust CriticGate configuration or reduce validation/diff evidence volume.",
+    raw: JSON.stringify({ score: 0, findings: [summary], must_fix: ["CriticGate timed out"] }),
+  };
+}
+
+async function runTaskCriticReview(
+  repo: string,
+  params: Record<string, unknown>,
+  quality: DeterministicQualityResult,
+  runtimeConfig: WorkerpalsRuntimeConfig,
+  onLog?: (stream: "stdout" | "stderr", line: string) => void,
+): Promise<CriticReview | null> {
+  const endpoint = normalizeChatCompletionsEndpoint(runtimeConfig.workerpals.llm.endpoint);
+  const model = resolveQualityCriticModel(runtimeConfig, runtimeConfig.workerpals.llm.model.trim());
+  if (!endpoint || !model) return null;
+  const qualityCriticTimeoutMs = resolveQualityCriticTimeoutMs(runtimeConfig);
+  const timeoutBehavior = resolveQualityCriticTimeoutBehavior(runtimeConfig);
 
   const planning = params.planning as TaskExecutePlanning;
   const instruction = String(params.instruction ?? "").trim();
@@ -2711,33 +2881,65 @@ async function runTaskCriticReview(
   const changedPathsText =
     quality.changedPaths.map((entry) => `- ${entry}`).join("\n") || "- (none)";
   const criticSystem = loadPromptTemplate("workerpals/task_quality_critic_system_prompt.md").trim();
-  const criticUser = loadPromptTemplate("workerpals/task_quality_critic_user_prompt.md", {
-    instruction,
-    acceptance_criteria: acceptanceCriteriaText,
-    validation_steps: validationStepsText,
-    changed_paths: changedPathsText,
-    diff_excerpt: diffText || "(empty diff excerpt)",
-    validation_evidence: validationSummary || "(no validation output)",
-  });
 
   const apiKey = runtimeConfig.workerpals.llm.apiKey.trim() || "local";
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-  const bodyBase = {
-    model,
-    messages: [
-      { role: "system", content: criticSystem },
-      { role: "user", content: criticUser },
-    ],
-    temperature: 0,
-    max_tokens: 700,
+
+  const buildAttemptPayload = async (compact: boolean) => {
+    const changedForDiff = quality.changedPaths.slice(0, compact ? 4 : 8);
+    let diffText = "";
+    if (changedForDiff.length > 0) {
+      const diffResult = await git(repo, ["diff", "--", ...changedForDiff]);
+      diffText = diffResult.ok ? diffResult.stdout : diffResult.stderr;
+    }
+    diffText = compactJobOutput(diffText, outputPolicyForRuntime(runtimeConfig)).slice(
+      0,
+      resolveQualityCriticMaxDiffChars(runtimeConfig, compact),
+    );
+    const validationSummary = buildCriticValidationSummary(
+      quality,
+      resolveQualityCriticMaxValidationOutputChars(runtimeConfig, compact),
+    );
+    const criticUser = loadPromptTemplate("workerpals/task_quality_critic_user_prompt.md", {
+      instruction,
+      acceptance_criteria: acceptanceCriteriaText,
+      validation_steps: validationStepsText,
+      changed_paths: changedPathsText,
+      diff_excerpt: diffText || "(empty diff excerpt)",
+      validation_evidence: validationSummary || "(no validation output)",
+    });
+    const promptChars = criticSystem.length + criticUser.length;
+    const promptBytes = new TextEncoder().encode(`${criticSystem}\n${criticUser}`).length;
+    return {
+      bodyBase: {
+        model,
+        messages: [
+          { role: "system", content: criticSystem },
+          { role: "user", content: criticUser },
+        ],
+        temperature: 0,
+        max_tokens: compact ? 500 : 700,
+      },
+      promptChars,
+      promptBytes,
+      diffChars: diffText.length,
+      validationChars: validationSummary.length,
+    };
   };
 
-  const runCriticRequest = async (responseFormat: Record<string, unknown> | null) => {
+  const runCriticRequest = async (
+    bodyBase: Record<string, unknown>,
+    responseFormat: Record<string, unknown> | null,
+  ) => {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), qualityCriticTimeoutMs);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, qualityCriticTimeoutMs);
     try {
       const response = await fetch(endpoint, {
         method: "POST",
@@ -2748,14 +2950,29 @@ async function runTaskCriticReview(
         signal: controller.signal,
       });
       const text = await response.text();
-      return { response, text };
+      return { timedOut: false as const, response, text };
+    } catch (err) {
+      if (!timedOut && String((err as { name?: unknown })?.name ?? "") !== "AbortError") {
+        throw err;
+      }
+      return { timedOut: true as const, err };
     } finally {
       clearTimeout(timer);
     }
   };
 
-  try {
-    let request = await runCriticRequest({ type: "json_object" });
+  const runAttempt = async (
+    attempt: number,
+    compact: boolean,
+  ): Promise<{ status: "timeout" } | { status: "done"; review: CriticReview | null }> => {
+    const payload = await buildAttemptPayload(compact);
+    const startedAt = Date.now();
+    onLog?.(
+      "stdout",
+      `[CriticGate] LLM review attempt ${attempt}${compact ? " (compact)" : ""}: model=${model} timeout_ms=${qualityCriticTimeoutMs} behavior=${timeoutBehavior} prompt_chars=${payload.promptChars} prompt_bytes=${payload.promptBytes} diff_chars=${payload.diffChars} validation_chars=${payload.validationChars}`,
+    );
+    let request = await runCriticRequest(payload.bodyBase, { type: "json_object" });
+    if (request.timedOut) return { status: "timeout" };
     if (!request.response.ok && request.response.status === 400) {
       const lowered = request.text.toLowerCase();
       if (lowered.includes("response_format")) {
@@ -2763,7 +2980,8 @@ async function runTaskCriticReview(
           "stdout",
           "[CriticGate] fallback: response_format json_object unsupported; retrying without strict response_format.",
         );
-        request = await runCriticRequest(null);
+        request = await runCriticRequest(payload.bodyBase, null);
+        if (request.timedOut) return { status: "timeout" };
       }
     }
     if (!request.response.ok) {
@@ -2771,12 +2989,12 @@ async function runTaskCriticReview(
         "stderr",
         `[CriticGate] review request failed (${request.response.status}): ${toSingleLine(request.text, 240)}`,
       );
-      return null;
+      return { status: "done", review: null };
     }
 
-    const payload = parseJsonObjectLoose(request.text) ?? JSON.parse(request.text);
-    const choices = Array.isArray((payload as Record<string, unknown>).choices)
-      ? ((payload as Record<string, unknown>).choices as Array<Record<string, unknown>>)
+    const responsePayload = parseJsonObjectLoose(request.text) ?? JSON.parse(request.text);
+    const choices = Array.isArray((responsePayload as Record<string, unknown>).choices)
+      ? ((responsePayload as Record<string, unknown>).choices as Array<Record<string, unknown>>)
       : [];
     const content = String(
       (choices[0]?.message as Record<string, unknown> | undefined)?.content ?? "",
@@ -2790,7 +3008,7 @@ async function runTaskCriticReview(
           220,
         )}`,
       );
-      return null;
+      return { status: "done", review: null };
     }
 
     const scoreRaw = Number(reviewObj.score);
@@ -2804,13 +3022,43 @@ async function runTaskCriticReview(
       .trim()
       .slice(0, 2000);
     const score = Number.isFinite(scoreRaw) ? Math.max(0, Math.min(10, scoreRaw)) : 0;
+    onLog?.(
+      "stdout",
+      `[CriticGate] LLM review completed in ${Date.now() - startedAt}ms (attempt ${attempt}).`,
+    );
     return {
-      score,
-      findings,
-      mustFix,
-      revisionGuidance,
-      raw: compactJobOutput(content, outputPolicyForRuntime(runtimeConfig)),
+      status: "done",
+      review: {
+        score,
+        findings,
+        mustFix,
+        revisionGuidance,
+        raw: compactJobOutput(content, outputPolicyForRuntime(runtimeConfig)),
+      },
     };
+  };
+
+  try {
+    let attempt = await runAttempt(1, false);
+    if (attempt.status === "timeout" && timeoutBehavior === "retry_once") {
+      onLog?.(
+        "stderr",
+        `[CriticGate] LLM review timed out after ${qualityCriticTimeoutMs}ms; retrying once with compact critic input.`,
+      );
+      attempt = await runAttempt(2, true);
+    }
+    if (attempt.status === "timeout") {
+      if (timeoutBehavior === "block") {
+        onLog?.(
+          "stderr",
+          `[CriticGate] LLM review timed out after ${qualityCriticTimeoutMs}ms; blocking because quality_critic_timeout_behavior=block.`,
+        );
+        return criticTimeoutReview("LLM", qualityCriticTimeoutMs, qualityCriticTimeoutMs);
+      }
+      onLog?.("stderr", `[CriticGate] LLM timed out after ${qualityCriticTimeoutMs}ms; skipping.`);
+      return null;
+    }
+    return attempt.review;
   } catch (err) {
     onLog?.(
       "stderr",
@@ -2905,7 +3153,10 @@ export function buildQualityRevisionHint(
         "- Convergence mode: diagnostic-first repair. This same browser focus failed in the previous revision, so do not guess another selector or rewrite a different stage.",
       );
       lines.push(
-        "- Diagnostic requirement: before editing again, inspect or add a tiny temporary diagnostic around the failing stage that records locator counts, visible textContent, role/ARIA attributes, data-testid values, and a nearby DOM snippet for the candidate nodes.",
+        "- Diagnostic requirement: before editing again, inspect or add a tiny temporary diagnostic around the failing stage that records locator counts, visible textContent, role/ARIA attributes, data-testid values, bounding boxes, and a nearby DOM snippet for the candidate nodes.",
+      );
+      lines.push(
+        "- Artifact freshness rule: only trust screenshots/logs captured after the failing action in the current revision. If the screenshot is stale or stops before the failing locator, capture or print the DOM state instead of reasoning from that image.",
       );
       lines.push(
         "- React Native Web note: screenshots can show the intended state while Playwright reads a duplicate or stale rendered node. Prefer one unique selected-state test id or a semantic checked attribute on the stable pressable, then assert locator count and visibility.",
@@ -2947,7 +3198,7 @@ export function buildQualityRevisionHint(
     );
     if (browserRepairPacket.needsDiagnosticProbe) {
       lines.push(
-        `Validation rerun rule: PushPals ValidationGate will rerun "${browserRepairPacket.command}" after the patch, but this is now a repeated browser assertion. If a quick local startup probe shows the browser server can run in this executor, run one targeted "${browserRepairPacket.command}" confirmation after the DOM-backed fix. Do not hand off another unverified selector guess.`,
+        `Validation rerun rule: PushPals ValidationGate will rerun "${browserRepairPacket.command}" after the patch, but this is now a repeated browser assertion. If a quick local startup probe shows the browser server can run in this executor, run exactly one targeted "${browserRepairPacket.command}" confirmation after the DOM-backed fix. Do not stop after fast checks only. Do not hand off another unverified selector guess.`,
       );
     } else {
       lines.push(
@@ -5462,86 +5713,92 @@ async function runCodexCriticReview(
 
   const instruction = String(params.instruction ?? "").trim();
   const planning = params.planning as TaskExecutePlanning;
-
-  const changedForDiff = quality.changedPaths.slice(0, 8);
-  let diffText = "";
-  const qualityCriticMaxDiffChars = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticMaxDiffChars);
-    if (!Number.isFinite(value)) return 16_000;
-    return Math.max(256, Math.min(524_288, Math.floor(value)));
-  })();
-  const qualityCriticMaxValidationOutputChars = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticMaxValidationOutputChars);
-    if (!Number.isFinite(value)) return 8_000;
-    return Math.max(256, Math.min(524_288, Math.floor(value)));
-  })();
-  const qualityCriticTimeoutMs = (() => {
-    const value = Number(runtimeConfig.workerpals.qualityCriticTimeoutMs);
-    if (!Number.isFinite(value)) return 45_000;
-    return Math.max(1_000, Math.min(7_200_000, Math.floor(value)));
-  })();
-  if (changedForDiff.length > 0) {
-    const diffResult = await git(repo, ["diff", "--", ...changedForDiff]);
-    diffText = (diffResult.ok ? diffResult.stdout : diffResult.stderr).slice(
+  const qualityCriticTimeoutMs = resolveQualityCriticTimeoutMs(runtimeConfig);
+  const timeoutBehavior = resolveQualityCriticTimeoutBehavior(runtimeConfig);
+  const criticModel = resolveQualityCriticModel(runtimeConfig);
+
+  const buildCriticInstruction = async (compact: boolean) => {
+    const changedForDiff = quality.changedPaths.slice(0, compact ? 4 : 8);
+    let diffText = "";
+    if (changedForDiff.length > 0) {
+      const diffResult = await git(repo, ["diff", "--", ...changedForDiff]);
+      diffText = diffResult.ok ? diffResult.stdout : diffResult.stderr;
+    }
+    diffText = compactJobOutput(diffText, outputPolicyForRuntime(runtimeConfig)).slice(
       0,
-      qualityCriticMaxDiffChars,
+      resolveQualityCriticMaxDiffChars(runtimeConfig, compact),
     );
-  }
-
-  const validationSummary = quality.validationRuns
-    .map((run) => {
-      const output = [run.stdout, run.stderr]
-        .filter(Boolean)
-        .join("\n")
-        .slice(0, qualityCriticMaxValidationOutputChars);
-      return [
-        `Command: ${run.command}`,
-        `Result: ${run.ok ? "pass" : "fail"} (exit ${run.exitCode})`,
-        output,
-      ]
-        .filter(Boolean)
-        .join("\n");
-    })
-    .join("\n---\n");
-
-  const criticInstruction = loadPromptTemplate(
-    "workerpals/codex_quality_critic_instruction_prompt.md",
-    {
-      instruction,
-      acceptance_criteria:
-        planning.acceptanceCriteria.map((c) => `- ${c}`).join("\n") || "- (none)",
-      changed_paths: quality.changedPaths.join(", ") || "(none)",
-      diff_section: diffText ? `Diff:\n${diffText}` : "Diff: (empty - no changes detected)",
-      validation_section: validationSummary
-        ? `Validation:\n${validationSummary}`
-        : "Validation: (none)",
-    },
-  );
+    const validationSummary = buildCriticValidationSummary(
+      quality,
+      resolveQualityCriticMaxValidationOutputChars(runtimeConfig, compact),
+    );
+    const criticInstruction = loadPromptTemplate(
+      "workerpals/codex_quality_critic_instruction_prompt.md",
+      {
+        instruction,
+        acceptance_criteria:
+          planning.acceptanceCriteria.map((c) => `- ${c}`).join("\n") || "- (none)",
+        changed_paths: quality.changedPaths.join(", ") || "(none)",
+        diff_section: diffText ? `Diff:\n${diffText}` : "Diff: (empty - no changes detected)",
+        validation_section: validationSummary
+          ? `Validation:\n${validationSummary}`
+          : "Validation: (none)",
+      },
+    );
+    return {
+      criticInstruction,
+      promptChars: criticInstruction.length,
+      promptBytes: new TextEncoder().encode(criticInstruction).length,
+      diffChars: diffText.length,
+      validationChars: validationSummary.length,
+    };
+  };
 
   const tmpOutputPath = `/tmp/pushpals-critic-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`;
-  const cmd = [
-    ...codexPrefix,
-    "-c",
-    'model_reasoning_effort="low"',
-    "-a",
-    "never",
-    "exec",
-    "-s",
-    "read-only",
-    "--output-last-message",
-    tmpOutputPath,
-    "-",
-  ];
+  const buildCmd = () => {
+    const cmd = [
+      ...codexPrefix,
+      "-c",
+      'model_reasoning_effort="low"',
+      "-a",
+      "never",
+      "exec",
+      "-s",
+      "read-only",
+      "--color",
+      "never",
+      "--output-last-message",
+      tmpOutputPath,
+    ];
+    if (criticModel) cmd.push("-m", criticModel);
+    cmd.push("-");
+    return cmd;
+  };
 
   const env = buildWorkerSandboxWritableEnv(repo);
   const codexMask = maskRepoLocalCodexFilesForCodexCli(repo, env);
-  try {
-    const proc = Bun.spawn(cmd, {
+
+  const runAttempt = async (
+    attempt: number,
+    compact: boolean,
+  ): Promise<{ status: "timeout" } | { status: "done"; review: CriticReview | null }> => {
+    try {
+      unlinkSync(tmpOutputPath);
+    } catch {
+      /* ignore stale/missing critic output */
+    }
+    const payload = await buildCriticInstruction(compact);
+    const startedAt = Date.now();
+    onLog?.(
+      "stdout",
+      `[CriticGate] Codex review attempt ${attempt}${compact ? " (compact)" : ""}: model=${criticModel || "(codex default)"} timeout_ms=${qualityCriticTimeoutMs} behavior=${timeoutBehavior} prompt_chars=${payload.promptChars} prompt_bytes=${payload.promptBytes} diff_chars=${payload.diffChars} validation_chars=${payload.validationChars}`,
+    );
+    const proc = Bun.spawn(buildCmd(), {
       cwd: repo,
       env,
       stdout: "pipe",
       stderr: "pipe",
-      stdin: new Blob([criticInstruction]),
+      stdin: new Blob([payload.criticInstruction]),
     });
 
     let timedOut = false;
@@ -5558,8 +5815,7 @@ async function runCodexCriticReview(
     clearTimeout(timer);
 
     if (timedOut) {
-      onLog?.("stderr", "[CriticGate] Codex timed out; skipping.");
-      return null;
+      return { status: "timeout" };
     }
     if (exitCode !== 0) {
       const stderrText = await new Response(proc.stderr).text();
@@ -5567,7 +5823,7 @@ async function runCodexCriticReview(
         "stderr",
         `[CriticGate] Codex exited ${exitCode}: ${toSingleLine(stderrText, 220)}`,
       );
-      return null;
+      return { status: "done", review: null };
     }
 
     let lastMessage = "";
@@ -5584,7 +5840,7 @@ async function runCodexCriticReview(
 
     if (!lastMessage) {
       onLog?.("stderr", "[CriticGate] Codex: no output message captured; skipping.");
-      return null;
+      return { status: "done", review: null };
     }
 
     const reviewObj = parseJsonObjectLoose(lastMessage);
@@ -5593,7 +5849,7 @@ async function runCodexCriticReview(
         "stderr",
         `[CriticGate] Codex returned non-JSON: ${toSingleLine(lastMessage, 220)}`,
       );
-      return null;
+      return { status: "done", review: null };
     }
 
     const scoreRaw = Number(reviewObj.score);
@@ -5607,14 +5863,43 @@ async function runCodexCriticReview(
     const revisionGuidance = String(reviewObj.revision_guidance ?? "")
       .trim()
       .slice(0, 2000);
-    onLog?.("stdout", `[CriticGate] Codex score: ${score}/10`);
+    onLog?.(
+      "stdout",
+      `[CriticGate] Codex score: ${score}/10 (${Date.now() - startedAt}ms, attempt ${attempt})`,
+    );
     return {
-      score,
-      findings,
-      mustFix,
-      revisionGuidance,
-      raw: compactJobOutput(lastMessage, outputPolicyForRuntime(runtimeConfig)),
+      status: "done",
+      review: {
+        score,
+        findings,
+        mustFix,
+        revisionGuidance,
+        raw: compactJobOutput(lastMessage, outputPolicyForRuntime(runtimeConfig)),
+      },
     };
+  };
+
+  try {
+    let attempt = await runAttempt(1, false);
+    if (attempt.status === "timeout" && timeoutBehavior === "retry_once") {
+      onLog?.(
+        "stderr",
+        `[CriticGate] Codex timed out after ${qualityCriticTimeoutMs}ms; retrying once with compact critic input.`,
+      );
+      attempt = await runAttempt(2, true);
+    }
+    if (attempt.status === "timeout") {
+      if (timeoutBehavior === "block") {
+        onLog?.(
+          "stderr",
+          `[CriticGate] Codex timed out after ${qualityCriticTimeoutMs}ms; blocking because quality_critic_timeout_behavior=block.`,
+        );
+        return criticTimeoutReview("Codex", qualityCriticTimeoutMs, qualityCriticTimeoutMs);
+      }
+      onLog?.("stderr", `[CriticGate] Codex timed out after ${qualityCriticTimeoutMs}ms; skipping.`);
+      return null;
+    }
+    return attempt.review;
   } catch (err) {
     onLog?.("stderr", `[CriticGate] Codex error: ${toSingleLine(err, 220)} (skipping).`);
     return null;
@@ -5857,7 +6142,7 @@ export async function executeJob(
     );
     for (const run of quality.validationRuns) {
       if (run.ok) continue;
-      const digest = extractValidationFailureDigest(run);
+      const digest = extractValidationFailureRetryDigest(run, repo);
       if (digest) previousValidationFailureDigests.set(validationCommandKey(run.command), digest);
     }
     const validationOutsideTaskScope =