@pushpalsdev/cli 1.1.20 → 1.1.22

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

@@ -32,7 +32,14 @@ import {
   type ToolRequirement,
 } from "shared";
 import { resolveExecutor, type WorkerpalsRuntimeConfig } from "./common/executor_backend.js";
-import type { JobPublishBlockedInfo, JobResult } from "./common/types.js";
+import type {
+  JobDiagnostics,
+  JobPatchSnapshotDiagnostics,
+  JobPublishBlockedInfo,
+  JobResult,
+  JobTerminalDiagnostics,
+  JobValidationRunDiagnostics,
+} from "./common/types.js";
 import {
   compactJobOutput,
   truncate,
@@ -190,6 +197,9 @@ export interface QualityGatePolicy {
 }
 
 const BROWSER_VALIDATION_MAX_AUTO_REVISIONS = 3;
+const CRITIC_COMPACT_RETRY_MIN_REDUCTION_RATIO = 0.25;
+const MAX_DIAGNOSTIC_PATH_SAMPLES = 50;
+const MAX_DIAGNOSTIC_TEXT_CHARS = 8_000;
 
 export function qualityRevisionLoopUpperBound(policy: {
   maxAutoRevisions: number;
@@ -232,6 +242,89 @@ export function qualityRevisionBudgetDecision(opts: {
   };
 }
 
+const MERGE_CONFLICT_RETRY_EXECUTION_BUDGET_MS = 300_000;
+const MERGE_CONFLICT_RETRY_FINALIZATION_BUDGET_MS = 60_000;
+const MERGE_CONFLICT_MIN_RETRY_EXECUTION_BUDGET_MS = 120_000;
+
+export function mergeConflictResolverRetryBudgetDecision(opts: {
+  jobElapsedMs: number;
+  executionBudgetMs: number;
+  finalizationBudgetMs: number;
+}): {
+  shouldStart: boolean;
+  executionBudgetMs: number;
+  finalizationBudgetMs: number;
+  remainingTotalBudgetMs: number;
+  minimumExecutionBudgetMs: number;
+} {
+  const configuredExecutionBudgetMs = Number(opts.executionBudgetMs);
+  if (!Number.isFinite(configuredExecutionBudgetMs) || configuredExecutionBudgetMs <= 0) {
+    return {
+      shouldStart: true,
+      executionBudgetMs: MERGE_CONFLICT_RETRY_EXECUTION_BUDGET_MS,
+      finalizationBudgetMs: MERGE_CONFLICT_RETRY_FINALIZATION_BUDGET_MS,
+      remainingTotalBudgetMs: Number.POSITIVE_INFINITY,
+      minimumExecutionBudgetMs: MERGE_CONFLICT_MIN_RETRY_EXECUTION_BUDGET_MS,
+    };
+  }
+
+  const configuredFinalizationBudgetMs = Math.max(0, Number(opts.finalizationBudgetMs) || 0);
+  const elapsedMs = Math.max(0, Number(opts.jobElapsedMs) || 0);
+  const remainingTotalBudgetMs = Math.max(
+    0,
+    Math.floor(configuredExecutionBudgetMs + configuredFinalizationBudgetMs - elapsedMs),
+  );
+  const finalizationBudgetMs = Math.min(
+    MERGE_CONFLICT_RETRY_FINALIZATION_BUDGET_MS,
+    configuredFinalizationBudgetMs,
+    remainingTotalBudgetMs,
+  );
+  const availableExecutionBudgetMs = Math.max(0, remainingTotalBudgetMs - finalizationBudgetMs);
+  const executionBudgetMs = Math.min(
+    MERGE_CONFLICT_RETRY_EXECUTION_BUDGET_MS,
+    Math.floor(availableExecutionBudgetMs),
+  );
+
+  return {
+    shouldStart: executionBudgetMs >= MERGE_CONFLICT_MIN_RETRY_EXECUTION_BUDGET_MS,
+    executionBudgetMs: Math.max(10_000, executionBudgetMs),
+    finalizationBudgetMs,
+    remainingTotalBudgetMs,
+    minimumExecutionBudgetMs: MERGE_CONFLICT_MIN_RETRY_EXECUTION_BUDGET_MS,
+  };
+}
+
+export function shouldRetryCriticTimeoutWithCompact(opts: {
+  timeoutBehavior: string;
+  qualityOk: boolean;
+  validationPassed: boolean;
+  initialPromptChars: number;
+  compactPromptChars: number;
+}): boolean {
+  if (opts.timeoutBehavior !== "retry_once") return false;
+  if (!opts.qualityOk || !opts.validationPassed) return true;
+  const initialPromptChars = Math.max(1, Math.floor(opts.initialPromptChars));
+  const compactPromptChars = Math.max(0, Math.floor(opts.compactPromptChars));
+  const reductionRatio = 1 - compactPromptChars / initialPromptChars;
+  return reductionRatio >= CRITIC_COMPACT_RETRY_MIN_REDUCTION_RATIO;
+}
+
+export function shouldSkipCriticAfterExecutorTimeout(opts: {
+  executor: string;
+  policyMode: string;
+  executorText: string;
+  qualityOk: boolean;
+  validationPassed: boolean;
+  qualityIssues: string[];
+  changedPaths: string[];
+}): boolean {
+  if (opts.executor !== "openai_codex") return false;
+  if (opts.policyMode !== "default") return false;
+  if (!opts.qualityOk || !opts.validationPassed) return false;
+  if (opts.qualityIssues.length > 0 || opts.changedPaths.length === 0) return false;
+  return /\b(openai_codex|codex(?: exec)?)\b[^\r\n]*\btimed out\b/i.test(opts.executorText);
+}
+
 export function workerAttemptRolloutScore(params: {
   executorElapsedMs: number;
   qualityElapsedMs: number;
@@ -498,6 +591,162 @@ export function publishableChangedPaths(changedPaths: string[]): string[] {
   return changedPaths.filter((path) => !isNonPublishableArtifactPath(path));
 }
 
+function compactDiagnosticText(value: unknown, maxChars = MAX_DIAGNOSTIC_TEXT_CHARS): string | null {
+  const text = String(value ?? "").replace(/\s+$/g, "");
+  if (!text.trim()) return null;
+  return text.length <= maxChars ? text : text.slice(Math.max(0, text.length - maxChars));
+}
+
+function diagnosticPathSample(paths: string[], limit = MAX_DIAGNOSTIC_PATH_SAMPLES): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of paths) {
+    const path = String(raw ?? "").replace(/\\/g, "/").replace(/^\.\/+/, "").trim();
+    if (!path || seen.has(path)) continue;
+    seen.add(path);
+    out.push(path);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function diagnosticTopLevelDirs(paths: string[]): string[] {
+  const seen = new Set<string>();
+  for (const path of paths) {
+    const normalized = String(path ?? "").replace(/\\/g, "/").replace(/^\.\/+/, "").trim();
+    if (!normalized) continue;
+    const top = normalized.includes("/") ? normalized.split("/", 1)[0] : normalized;
+    if (top) seen.add(top);
+    if (seen.size >= 20) break;
+  }
+  return [...seen];
+}
+
+function buildPatchSnapshotDiagnostics(
+  changedPaths: string[],
+  attempt: number,
+  phase: string,
+): JobPatchSnapshotDiagnostics {
+  const publishable = publishableChangedPaths(changedPaths);
+  const artifactOnly = changedPaths.filter((path) => isNonPublishableArtifactPath(path));
+  return {
+    attempt,
+    phase,
+    publishableFileCount: publishable.length,
+    artifactOnlyPathCount: artifactOnly.length,
+    changedPathSample: diagnosticPathSample(changedPaths),
+    topLevelDirs: diagnosticTopLevelDirs(publishable.length > 0 ? publishable : changedPaths),
+    capturedAt: new Date().toISOString(),
+  };
+}
+
+function classifyValidationRunFailure(run: ValidationExecutionResult): string | null {
+  if (run.ok) return null;
+  const combined = `${run.command}\n${run.stdout}\n${run.stderr}`.toLowerCase();
+  if (run.exitCode === 124 || combined.includes("timed out") || combined.includes("timeout")) {
+    return "timeout";
+  }
+  if (run.exitCode === 127 || combined.includes("missing tool") || combined.includes("not found")) {
+    return "missing_tool";
+  }
+  if (/browser|playwright|cypress|locator|page\.|screenshot|web:e2e/.test(combined)) {
+    return "browser_validation";
+  }
+  if (/cannot find module|import error|does not provide an export|no exported member|mock/.test(combined)) {
+    return "test_harness";
+  }
+  return "nonzero_exit";
+}
+
+function buildValidationRunDiagnostics(
+  runs: ValidationExecutionResult[],
+  attempt: number,
+): JobValidationRunDiagnostics[] {
+  return runs.slice(0, 20).map((run) => ({
+    attempt,
+    command: run.command,
+    exitCode: run.exitCode,
+    durationMs: run.elapsedMs,
+    passed: run.ok,
+    failureClass: classifyValidationRunFailure(run),
+    stdoutTail: compactDiagnosticText(run.stdout),
+    stderrTail: compactDiagnosticText(run.stderr),
+  }));
+}
+
+function inferTerminalFailureClass(result: JobResult, changedPaths: string[]): string {
+  if (result.ok) return "success";
+  const text = `${result.summary ?? ""}\n${result.stderr ?? ""}\n${result.stdout ?? ""}`.toLowerCase();
+  const publishableCount = publishableChangedPaths(changedPaths).length;
+  if (changedPaths.length > 0 && publishableCount === 0) return "artifact_only_no_publishable_patch";
+  if (result.exitCode === 124 || text.includes("timed out") || text.includes("timeout")) return "timeout";
+  if (text.includes("validationgate") || text.includes("validation")) return "validation";
+  if (text.includes("scopegate") || text.includes("scope")) return "scope";
+  if (text.includes("criticgate") || text.includes("critic")) return "critic";
+  if (text.includes("publish")) return "publish";
+  if (text.includes("shell-wrapper") || text.includes("command-router")) return "command_policy";
+  return "executor_failure";
+}
+
+function inferTerminalStage(result: JobResult, fallback: string): string {
+  const text = `${result.summary ?? ""}\n${result.stderr ?? ""}`.toLowerCase();
+  if (text.includes("validationgate") || text.includes("validation")) return "validation";
+  if (text.includes("scopegate") || text.includes("scope")) return "scope";
+  if (text.includes("criticgate") || text.includes("critic")) return "critic";
+  if (text.includes("publish")) return "publish";
+  if (text.includes("quality gate")) return "quality";
+  if (text.includes("codex") || text.includes("executor")) return "executor";
+  return fallback;
+}
+
+function mergeJobDiagnostics(base: JobDiagnostics | undefined, extra: JobDiagnostics): JobDiagnostics {
+  return {
+    ...(base ?? {}),
+    ...extra,
+    attempts: [...(base?.attempts ?? []), ...(extra.attempts ?? [])],
+    phaseSpans: [...(base?.phaseSpans ?? []), ...(extra.phaseSpans ?? [])],
+    validationRuns: [...(base?.validationRuns ?? []), ...(extra.validationRuns ?? [])],
+    patchSnapshots: [...(base?.patchSnapshots ?? []), ...(extra.patchSnapshots ?? [])],
+    terminal: extra.terminal ?? base?.terminal,
+    metadata: {
+      ...(base?.metadata ?? {}),
+      ...(extra.metadata ?? {}),
+    },
+  };
+}
+
+function withJobDiagnostics(result: JobResult, diagnostics: JobDiagnostics): JobResult {
+  return {
+    ...result,
+    diagnostics: mergeJobDiagnostics(result.diagnostics, diagnostics),
+  };
+}
+
+function buildTerminalDiagnostics(args: {
+  result: JobResult;
+  executor: string;
+  changedPaths: string[];
+  terminalStage: string;
+  timeoutMs?: number | null;
+  metadata?: Record<string, unknown>;
+}): JobTerminalDiagnostics {
+  const publishable = publishableChangedPaths(args.changedPaths);
+  const artifactOnly = args.changedPaths.filter((path) => isNonPublishableArtifactPath(path));
+  const text = `${args.result.summary ?? ""}\n${args.result.stderr ?? ""}\n${args.result.stdout ?? ""}`;
+  return {
+    failureClass: inferTerminalFailureClass(args.result, args.changedPaths),
+    terminalStage: inferTerminalStage(args.result, args.terminalStage),
+    executorBackend: args.executor,
+    summary: compactDiagnosticText(args.result.summary, 1_000),
+    watchdogFired: /watchdog|rollout coach/i.test(text),
+    timeoutMs: args.timeoutMs ?? null,
+    publishableFileCount: publishable.length,
+    artifactOnlyPathCount: artifactOnly.length,
+    changedPathSample: diagnosticPathSample(args.changedPaths),
+    metadata: args.metadata,
+  };
+}
+
 function collectPlanningText(planning: TaskExecutePlanning): string {
   return [
     planning.intent,
@@ -879,6 +1128,10 @@ function parseJsonObjectLoose(text: string): Record<string, unknown> | null {
 }
 
 const COMMIT_MSG_MAX_DIFF_CHARS = 120_000;
+const COMMIT_MSG_LLM_MAX_CHANGED_PATHS = 20;
+const COMMIT_MSG_GENERATOR_DEFAULT_TIMEOUT_MS = 15_000;
+const COMMIT_MSG_GENERATOR_MIN_TIMEOUT_MS = 3_000;
+const COMMIT_MSG_GENERATOR_MAX_TIMEOUT_MS = 30_000;
 
 const SHELL_CONTROL_TOKENS = new Set(["&&", "||", ";", "|"]);
 
@@ -2096,6 +2349,18 @@ function classifyBrowserValidationFailureKindFromText(text: string): BrowserVali
   return "unknown";
 }
 
+export function shouldRetryBrowserValidationRunOnce(run: ValidationExecutionResult): boolean {
+  if (run.ok || !isLongRunningBrowserValidationCommand(run.command)) return false;
+  const combined = stripAnsiControlSequences([run.stderr, run.stdout].filter(Boolean).join("\n"));
+  const digest = extractValidationFailureDigest(run);
+  const failureKind = classifyBrowserValidationFailureKindFromText(`${digest}\n${combined}`);
+  if (failureKind === "runtime" || failureKind === "network") return true;
+  if (failureKind === "startup") return true;
+  return /\b(Route\/startup smoke failure|startup smoke failure|home route startup)\b/i.test(
+    `${digest}\n${combined}`,
+  );
+}
+
 function extractBrowserValidationStage(text: string): string | null {
   const patterns = [
     /\bBrowser validation failed during\s+([^:.\r\n|]+?)\s+stage\b/i,
@@ -3662,12 +3927,34 @@ async function runDeterministicQualityGate(
         continue;
       }
       onLog?.("stdout", `[ValidationGate] Running "${command}"`);
-      const run = await runValidationCommand(
+      let run = await runValidationCommand(
         repo,
         command,
         resolveValidationCommandTimeoutMs(command, qualityValidationStepTimeoutMs),
         outputPolicy,
       );
+      const firstDigest = run.ok ? "" : extractValidationFailureDigest(run);
+      if (shouldRetryBrowserValidationRunOnce(run)) {
+        onLog?.(
+          "stderr",
+          `[ValidationGate] Retrying browser validation once after retryable startup/runtime failure: ${command}${firstDigest ? ` - ${firstDigest}` : ""}`,
+        );
+        const retryRun = await runValidationCommand(
+          repo,
+          command,
+          resolveValidationCommandTimeoutMs(command, qualityValidationStepTimeoutMs),
+          outputPolicy,
+        );
+        if (!retryRun.ok && firstDigest) {
+          retryRun.stderr = [
+            `Previous browser validation attempt failed before retry: ${firstDigest}`,
+            retryRun.stderr,
+          ]
+            .filter(Boolean)
+            .join("\n");
+        }
+        run = retryRun;
+      }
       validationRuns.push(run);
       const digest = run.ok ? "" : extractValidationFailureDigest(run);
       const runSummary = `[ValidationGate] ${run.ok ? "Passed" : "Failed"} (${run.elapsedMs}ms, exit ${run.exitCode}): ${command}${digest ? ` - ${digest}` : ""}`;
@@ -4768,17 +5055,19 @@ export async function createJobCommit(
       ...toNonEmptyStringArray(jobPlanning?.requiredValidationSteps),
       ...loadRequiredValidationStepsFromVision(repo),
     ];
-    const llmCommitMsg = await generateCommitMessageFromDiff(
-      diff,
-      {
-        instruction: String(job.params?.instruction ?? ""),
-        type: normalizeCommitType(job.kind, job.params),
-        area: inferCommitArea(job.kind, job.params, changedPaths),
-        validationSteps: jobValidationSteps,
-      },
-      repo,
-      runtimeConfig,
-    ).catch(() => null);
+    const llmCommitMsg = shouldUseLlmCommitMessageForStagedDiff({ changedPaths, diff })
+      ? await generateCommitMessageFromDiff(
+          diff,
+          {
+            instruction: String(job.params?.instruction ?? ""),
+            type: normalizeCommitType(job.kind, job.params),
+            area: inferCommitArea(job.kind, job.params, changedPaths),
+            validationSteps: jobValidationSteps,
+          },
+          repo,
+          runtimeConfig,
+        ).catch(() => null)
+      : null;
     if (!llmCommitMsg) {
       console.warn(
         `[WorkerPals] Commit message generator unavailable for job ${job.id}; using deterministic fallback.`,
@@ -5745,17 +6034,19 @@ async function createMergeConflictJobCommit(
       ...toNonEmptyStringArray(jobPlanning?.requiredValidationSteps),
       ...loadRequiredValidationStepsFromVision(repo),
     ];
-    const llmCommitMsg = await generateCommitMessageFromDiff(
-      diff,
-      {
-        instruction: String(job.params?.instruction ?? ""),
-        type: normalizeCommitType(job.kind, job.params),
-        area: inferCommitArea(job.kind, job.params, changedPaths),
-        validationSteps: jobValidationSteps,
-      },
-      repo,
-      runtimeConfig,
-    ).catch(() => null);
+    const llmCommitMsg = shouldUseLlmCommitMessageForStagedDiff({ changedPaths, diff })
+      ? await generateCommitMessageFromDiff(
+          diff,
+          {
+            instruction: String(job.params?.instruction ?? ""),
+            type: normalizeCommitType(job.kind, job.params),
+            area: inferCommitArea(job.kind, job.params, changedPaths),
+            validationSteps: jobValidationSteps,
+          },
+          repo,
+          runtimeConfig,
+        ).catch(() => null)
+      : null;
     if (!llmCommitMsg) {
       console.warn(
         `[WorkerPals] Commit message generator unavailable for merge-conflict job ${job.id}; using deterministic fallback.`,
@@ -6206,6 +6497,38 @@ async function generateCommitMessageFromDiff(
   return generateCommitMessageFromDiffViaHttp(prompt, opts, runtimeConfig);
 }
 
+export function resolveCommitMessageGeneratorTimeoutMs(
+  runtimeConfig: WorkerpalsRuntimeConfig = DEFAULT_CONFIG,
+): number {
+  const workerpalsConfig = runtimeConfig.workerpals as Record<string, unknown>;
+  const llmConfig =
+    workerpalsConfig.llm && typeof workerpalsConfig.llm === "object"
+      ? (workerpalsConfig.llm as Record<string, unknown>)
+      : {};
+  const configuredRaw =
+    workerpalsConfig.commitMessageTimeoutMs ??
+    workerpalsConfig.commit_message_timeout_ms ??
+    llmConfig.commitMessageTimeoutMs ??
+    llmConfig.commit_message_timeout_ms ??
+    Bun.env.WORKERPALS_COMMIT_MESSAGE_TIMEOUT_MS;
+  const configured = Number(configuredRaw);
+  const value = Number.isFinite(configured)
+    ? configured
+    : COMMIT_MSG_GENERATOR_DEFAULT_TIMEOUT_MS;
+  return Math.max(
+    COMMIT_MSG_GENERATOR_MIN_TIMEOUT_MS,
+    Math.min(COMMIT_MSG_GENERATOR_MAX_TIMEOUT_MS, Math.floor(value)),
+  );
+}
+
+export function shouldUseLlmCommitMessageForStagedDiff(params: {
+  changedPaths: string[];
+  diff: string;
+}): boolean {
+  if (!String(params.diff ?? "").trim()) return false;
+  return params.changedPaths.length <= COMMIT_MSG_LLM_MAX_CHANGED_PATHS;
+}
+
 type CommitMessagePrompt = {
   systemPrompt: string;
   userMessage: string;
@@ -6244,11 +6567,7 @@ async function generateCommitMessageFromDiffViaCodex(
   if (!model) return null;
   const codexPrefix = await resolveCodexCommandPrefix(repo, runtimeConfig.workerpals.llm.codexBin);
   if (!codexPrefix) return null;
-  const timeoutMs = (() => {
-    const value = Number(runtimeConfig.workerpals.llm.codexTimeoutMs);
-    if (!Number.isFinite(value)) return 120_000;
-    return Math.max(10_000, Math.min(600_000, Math.floor(value)));
-  })();
+  const timeoutMs = resolveCommitMessageGeneratorTimeoutMs(runtimeConfig);
   const reasoningEffort = normalizeCodexReasoningEffort(
     runtimeConfig.workerpals.llm.reasoningEffort,
     model,
@@ -6338,7 +6657,7 @@ async function generateCommitMessageFromDiffViaHttp(
   if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 30_000);
+  const timer = setTimeout(() => controller.abort(), resolveCommitMessageGeneratorTimeoutMs(runtimeConfig));
   try {
     const response = await fetch(endpoint, {
       method: "POST",
@@ -6952,6 +7271,7 @@ async function runCodexCriticReview(
       validationChars: validationSummary.length,
     };
   };
+  type CodexCriticPayload = Awaited<ReturnType<typeof buildCriticInstruction>>;
 
   const tmpOutputPath = `/tmp/pushpals-critic-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`;
   const buildCmd = () => {
@@ -6980,13 +7300,17 @@ async function runCodexCriticReview(
   const runAttempt = async (
     attempt: number,
     compact: boolean,
-  ): Promise<{ status: "timeout" } | { status: "done"; review: CriticReview | null }> => {
+    payloadOverride?: CodexCriticPayload,
+  ): Promise<
+    | { status: "timeout"; payload: CodexCriticPayload }
+    | { status: "done"; review: CriticReview | null; payload: CodexCriticPayload }
+  > => {
     try {
       unlinkSync(tmpOutputPath);
     } catch {
       /* ignore stale/missing critic output */
     }
-    const payload = await buildCriticInstruction(compact);
+    const payload = payloadOverride ?? (await buildCriticInstruction(compact));
     const startedAt = Date.now();
     onLog?.(
       "stdout",
@@ -7014,7 +7338,7 @@ async function runCodexCriticReview(
     clearTimeout(timer);
 
     if (timedOut) {
-      return { status: "timeout" };
+      return { status: "timeout", payload };
     }
     if (exitCode !== 0) {
       const stderrText = await new Response(proc.stderr).text();
@@ -7022,7 +7346,7 @@ async function runCodexCriticReview(
         "stderr",
         `[CriticGate] Codex exited ${exitCode}: ${toSingleLine(stderrText, 220)}`,
       );
-      return { status: "done", review: null };
+      return { status: "done", review: null, payload };
     }
 
     let lastMessage = "";
@@ -7039,7 +7363,7 @@ async function runCodexCriticReview(
 
     if (!lastMessage) {
       onLog?.("stderr", "[CriticGate] Codex: no output message captured; skipping.");
-      return { status: "done", review: null };
+      return { status: "done", review: null, payload };
     }
 
     const reviewObj = parseJsonObjectLoose(lastMessage);
@@ -7048,7 +7372,7 @@ async function runCodexCriticReview(
         "stderr",
         `[CriticGate] Codex returned non-JSON: ${toSingleLine(lastMessage, 220)}`,
       );
-      return { status: "done", review: null };
+      return { status: "done", review: null, payload };
     }
 
     const scoreRaw = Number(reviewObj.score);
@@ -7068,6 +7392,7 @@ async function runCodexCriticReview(
     );
     return {
       status: "done",
+      payload,
       review: {
         score,
         findings,
@@ -7081,11 +7406,36 @@ async function runCodexCriticReview(
   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);
+      const compactPayload = await buildCriticInstruction(true);
+      const validationPassed =
+        quality.validationRuns.length > 0 && quality.validationRuns.every((run) => run.ok);
+      if (
+        shouldRetryCriticTimeoutWithCompact({
+          timeoutBehavior,
+          qualityOk: quality.ok,
+          validationPassed,
+          initialPromptChars: attempt.payload.promptChars,
+          compactPromptChars: compactPayload.promptChars,
+        })
+      ) {
+        onLog?.(
+          "stderr",
+          `[CriticGate] Codex timed out after ${qualityCriticTimeoutMs}ms; retrying once with compact critic input.`,
+        );
+        attempt = await runAttempt(2, true, compactPayload);
+      } else {
+        const reductionPct = Math.max(
+          0,
+          Math.round(
+            (1 - compactPayload.promptChars / Math.max(1, attempt.payload.promptChars)) * 100,
+          ),
+        );
+        onLog?.(
+          "stderr",
+          `[CriticGate] Codex timed out after ${qualityCriticTimeoutMs}ms; compact critic input only reduced prompt by ${reductionPct}% after clean validation; skipping retry.`,
+        );
+        return null;
+      }
     }
     if (attempt.status === "timeout") {
       if (timeoutBehavior === "block") {
@@ -7246,6 +7596,8 @@ export async function executeJob(
   const jobStartedAt = Date.now();
   const previousValidationFailureDigests = new Map<string, string>();
   const failureJobFamily = buildTaskFailureJobFamily(normalizedParams);
+  const diagnosticValidationRuns: JobValidationRunDiagnostics[] = [];
+  const diagnosticPatchSnapshots: JobPatchSnapshotDiagnostics[] = [];
   while (revisionAttempt <= qualityRevisionLoopMax) {
     const attemptStartedAt = Date.now();
     const attemptParams: Record<string, unknown> = { ...normalizedParams };
@@ -7255,7 +7607,7 @@ export async function executeJob(
     }
 
     const executor = resolveExecutor(runtimeConfig);
-    const executeBudgets = { executionBudgetMs, finalizationBudgetMs };
+    const defaultExecuteBudgets = { executionBudgetMs, finalizationBudgetMs };
     const runExecutor = getBackendTaskExecutor(executor);
     if (!runExecutor) {
       return {
@@ -7267,14 +7619,17 @@ export async function executeJob(
     let result: Awaited<ReturnType<typeof runExecutor>> | null = null;
     let mergeConflictPass = 0;
     let executorElapsedMs = 0;
+    let nextMergeConflictExecuteBudgets: typeof defaultExecuteBudgets | null = null;
     while (true) {
+      const currentExecuteBudgets = nextMergeConflictExecuteBudgets ?? defaultExecuteBudgets;
+      nextMergeConflictExecuteBudgets = null;
       const currentResult = await runExecutor(
         kind,
         attemptParams,
         repo,
         runtimeConfig,
         onLog,
-        executeBudgets,
+        currentExecuteBudgets,
       );
       if (!currentResult.ok) return currentResult;
       result = currentResult;
@@ -7308,14 +7663,77 @@ export async function executeJob(
             exitCode: 4,
           };
         }
+        const retryBudget = mergeConflictResolverRetryBudgetDecision({
+          jobElapsedMs: Date.now() - attemptStartedAt,
+          executionBudgetMs,
+          finalizationBudgetMs,
+        });
+        if (!retryBudget.shouldStart) {
+          const detail =
+            "Merge-conflict rebase advanced into another conflicted commit, but remaining job budget " +
+            `is ${retryBudget.remainingTotalBudgetMs}ms (< ${retryBudget.minimumExecutionBudgetMs}ms execution).`;
+          onLog?.("stderr", `[MergeConflict] ${detail}`);
+          return {
+            ok: false,
+            summary: detail,
+            stdout: currentResult.stdout,
+            stderr: [currentResult.stderr ?? "", resume.detail ?? detail].filter(Boolean).join("\n"),
+            exitCode: 4,
+          };
+        }
+        nextMergeConflictExecuteBudgets = {
+          executionBudgetMs: retryBudget.executionBudgetMs,
+          finalizationBudgetMs: retryBudget.finalizationBudgetMs,
+        };
         onLog?.(
           "stdout",
           `[MergeConflict] Rebase surfaced another conflicted commit after auto-continue; rerunning resolver pass ${
             mergeConflictPass + 1
-          }.`,
+          } with a capped completion budget (${retryBudget.executionBudgetMs}ms execution).`,
         );
         continue;
       }
+      if (sequencer === "rebase" && !resume.resumed) {
+        mergeConflictPass += 1;
+        const budget = mergeConflictResolverRetryBudgetDecision({
+          jobElapsedMs: Date.now() - attemptStartedAt,
+          executionBudgetMs,
+          finalizationBudgetMs,
+        });
+        if (mergeConflictPass < MAX_MERGE_CONFLICT_RESOLUTION_PASSES && budget.shouldStart) {
+          const retryDetail =
+            resume.detail ??
+            "the previous resolver pass returned before the prepared rebase completed";
+          const previousHint = String(attemptParams.qualityRevisionHint ?? "").trim();
+          attemptParams.qualityRevisionHint = [
+            previousHint,
+            [
+              `Merge-conflict resolver pass ${mergeConflictPass} left the rebase unfinished: ${retryDetail}.`,
+              "Focus only on completing the active rebase. Inspect unresolved files with `git diff --name-only --diff-filter=U`, remove remaining conflict markers, stage resolved files, and run `git -c core.editor=true rebase --continue` until no rebase remains.",
+              "Do not broaden the patch or run full validation before the rebase is complete.",
+            ].join("\n"),
+          ]
+            .filter(Boolean)
+            .join("\n\n");
+          nextMergeConflictExecuteBudgets = {
+            executionBudgetMs: budget.executionBudgetMs,
+            finalizationBudgetMs: budget.finalizationBudgetMs,
+          };
+          onLog?.(
+            "stdout",
+            `[MergeConflict] ${retryDetail}; rerunning resolver pass ${
+              mergeConflictPass + 1
+            } with focused rebase-completion guidance and capped budget (${budget.executionBudgetMs}ms execution).`,
+          );
+          continue;
+        }
+        if (!budget.shouldStart) {
+          onLog?.(
+            "stderr",
+            `[MergeConflict] Not rerunning unfinished rebase resolver: remaining total budget is ${budget.remainingTotalBudgetMs}ms (< ${budget.minimumExecutionBudgetMs}ms execution).`,
+          );
+        }
+      }
       const detail =
         `Merge-conflict job returned with git ${sequencer} still in progress. ` +
         `Finish the ${sequencer} before returning control to WorkerPals.`;
@@ -7342,6 +7760,11 @@ export async function executeJob(
       ? parseChangedPathsFromStatus(preQualityStatus.stdout)
       : [];
     const preQualityPublishablePaths = publishableChangedPaths(preQualityChangedPaths);
+    if (preQualityChangedPaths.length > 0) {
+      diagnosticPatchSnapshots.push(
+        buildPatchSnapshotDiagnostics(preQualityChangedPaths, revisionAttempt, "executor"),
+      );
+    }
     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(
@@ -7355,13 +7778,24 @@ export async function executeJob(
         "stderr",
         `[QualityGate] ${detail} Skipping ValidationGate/CriticGate because there is no PR-worthy patch to validate.`,
       );
-      return {
+      const failure: JobResult = {
         ok: false,
         summary: `Executor produced no publishable code changes (${detail})`,
         stdout: result.stdout,
         stderr: [result.stderr ?? "", detail].filter(Boolean).join("\n"),
         exitCode: 4,
       };
+      return withJobDiagnostics(failure, {
+        terminal: buildTerminalDiagnostics({
+          result: failure,
+          executor,
+          changedPaths: preQualityChangedPaths,
+          terminalStage: "executor",
+          timeoutMs: executionBudgetMs,
+          metadata: { revisionAttempt, executorElapsedMs },
+        }),
+        patchSnapshots: [...diagnosticPatchSnapshots],
+      });
     }
     if (
       preQualityPublishablePaths.length === 0 &&
@@ -7375,13 +7809,24 @@ export async function executeJob(
         "stderr",
         `[QualityGate] ${reason} Skipping ValidationGate/CriticGate and failing fast.`,
       );
-      return {
+      const failure: JobResult = {
         ok: false,
         summary: reason,
         stdout: result.stdout,
         stderr: [result.stderr ?? "", reason].filter(Boolean).join("\n"),
         exitCode: 4,
       };
+      return withJobDiagnostics(failure, {
+        terminal: buildTerminalDiagnostics({
+          result: failure,
+          executor,
+          changedPaths: preQualityChangedPaths,
+          terminalStage: "executor",
+          timeoutMs: executionBudgetMs,
+          metadata: { revisionAttempt, executorElapsedMs, shellWrapperReturn },
+        }),
+        patchSnapshots: [...diagnosticPatchSnapshots],
+      });
     }
 
     const qualityStartedAt = Date.now();
@@ -7397,6 +7842,12 @@ export async function executeJob(
       },
     );
     const qualityElapsedMs = Date.now() - qualityStartedAt;
+    diagnosticPatchSnapshots.push(
+      buildPatchSnapshotDiagnostics(quality.changedPaths, revisionAttempt, "quality"),
+    );
+    diagnosticValidationRuns.push(
+      ...buildValidationRunDiagnostics(quality.validationRuns, revisionAttempt),
+    );
     const validationCommandElapsedMs = quality.validationRuns.reduce(
       (total, run) => total + Math.max(0, Number(run.elapsedMs) || 0),
       0,
@@ -7440,14 +7891,54 @@ export async function executeJob(
           blocker: null,
         }
       : quality;
+    const validationPassed =
+      quality.validationRuns.length > 0 && quality.validationRuns.every((run) => run.ok);
+    const skipCriticAfterExecutorTimeout = shouldSkipCriticAfterExecutorTimeout({
+      executor,
+      policyMode: qualityGatePolicy.mode,
+      executorText,
+      qualityOk: quality.ok,
+      validationPassed,
+      qualityIssues: qualityForCritic.issues,
+      changedPaths: quality.changedPaths,
+    });
     const critic =
-      quality.skipped || !qualityGatePolicy.criticGateEnabled
+      quality.skipped || !qualityGatePolicy.criticGateEnabled || skipCriticAfterExecutorTimeout
         ? null
         : executor === "openai_codex"
           ? await runCodexCriticReview(repo, attemptParams, qualityForCritic, runtimeConfig, onLog)
           : await runTaskCriticReview(repo, attemptParams, qualityForCritic, runtimeConfig, onLog);
+    const annotateTerminalResult = (
+      terminalResult: JobResult,
+      terminalStage: string,
+      changedPaths: string[] = quality.changedPaths,
+    ): JobResult =>
+      withJobDiagnostics(terminalResult, {
+        terminal: buildTerminalDiagnostics({
+          result: terminalResult,
+          executor,
+          changedPaths,
+          terminalStage,
+          timeoutMs: executionBudgetMs,
+          metadata: {
+            revisionAttempt,
+            executorElapsedMs,
+            qualityElapsedMs,
+            validationFailureScope: quality.validationFailureScope,
+            validationRuns: quality.validationRuns.length,
+            criticScore: critic?.score ?? null,
+          },
+        }),
+        validationRuns: [...diagnosticValidationRuns],
+        patchSnapshots: [...diagnosticPatchSnapshots],
+      });
     if (!qualityGatePolicy.criticGateEnabled) {
       onLog?.("stdout", "[CriticGate] Disabled by workerpals.quality_critic_gate_enabled=false.");
+    } else if (skipCriticAfterExecutorTimeout) {
+      onLog?.(
+        "stdout",
+        "[CriticGate] Skipping Codex critic after primary Codex executor timeout because deterministic quality and validation are clean.",
+      );
     }
     const rolloutScore = workerAttemptRolloutScore({
       executorElapsedMs,
@@ -7500,7 +7991,7 @@ export async function executeJob(
         "stderr",
         "[PublishGate] Disabled by workerpals.quality_publish_gate_enabled=false; returning worker result despite gate failures.",
       );
-      return {
+      const advisoryResult: JobResult = {
         ...result,
         summary: `${result.summary} (publish gate disabled; quality gate findings were advisory)`,
         stderr: truncate(
@@ -7515,6 +8006,7 @@ export async function executeJob(
         ),
         exitCode: typeof result.exitCode === "number" ? result.exitCode : 0,
       };
+      return annotateTerminalResult(advisoryResult, "quality");
     }
 
     if (!deterministicRequiresRevision && !criticRequiresRevision) {
@@ -7533,13 +8025,14 @@ export async function executeJob(
           outputPolicyForRuntime(runtimeConfig),
         );
         onLog?.("stderr", `[QualityGate] ${requiredSummary}`);
-        return {
+        const failure: JobResult = {
           ok: false,
           summary: requiredSummary,
           stdout: result.stdout,
           stderr: diagnostics,
           exitCode: 4,
         };
+        return annotateTerminalResult(failure, "validation");
       }
       if (critic) {
         onLog?.(
@@ -7547,7 +8040,7 @@ export async function executeJob(
           `[CriticGate] review score ${critic.score.toFixed(1)}/10 (threshold ${qualityCriticMinScore}).`,
         );
       }
-      return result;
+      return annotateTerminalResult(result, "completed");
     }
 
     const blockerIssue = quality.blocker
@@ -7607,13 +8100,14 @@ export async function executeJob(
       } else if (quality.requiredValidationFailures.length > 0) {
         const requiredSummary = `Required vision.md validation blocked publishing: ${quality.requiredValidationFailures.join("; ")}`;
         onLog?.("stderr", `[QualityGate] ${requiredSummary}`);
-        return {
+        const failure: JobResult = {
           ok: false,
           summary: requiredSummary,
           stdout: result.stdout,
           stderr: blockerDiagnostics,
           exitCode: 4,
         };
+        return annotateTerminalResult(failure, "validation");
       } else if (shouldSoftPassValidationBlocker(qualityGatePolicy, quality.blocker)) {
         onLog?.(
           "stderr",
@@ -7622,7 +8116,7 @@ export async function executeJob(
             260,
           )}`,
         );
-        return {
+        const softPass: JobResult = {
           ...result,
           summary:
             `${result.summary} ` +
@@ -7630,15 +8124,17 @@ export async function executeJob(
           stderr: blockerDiagnostics,
           exitCode: typeof result.exitCode === "number" ? result.exitCode : 0,
         };
+        return annotateTerminalResult(softPass, "quality");
       } else {
         onLog?.("stderr", `[QualityGate] ${blockerSummary}`);
-        return {
+        const failure: JobResult = {
           ok: false,
           summary: blockerSummary,
           stdout: result.stdout,
           stderr: blockerDiagnostics,
           exitCode: 4,
         };
+        return annotateTerminalResult(failure, "quality");
       }
     }
     if (revisionAttempt >= activeMaxAutoRevisions) {
@@ -7655,13 +8151,14 @@ export async function executeJob(
         );
         const requiredSummary = `Required vision.md validation failed after ${revisionAttempt} auto-revision attempt(s): ${quality.requiredValidationFailures.join("; ")}`;
         onLog?.("stderr", `[QualityGate] ${requiredSummary}`);
-        return {
+        const failure: JobResult = {
           ok: false,
           summary: requiredSummary,
           stdout: result.stdout,
           stderr: diagnostics,
           exitCode: 4,
         };
+        return annotateTerminalResult(failure, "validation");
       }
       if (qualitySoftPassOnExhausted) {
         const diagnostics = truncate(
@@ -7677,14 +8174,15 @@ export async function executeJob(
             260,
           )}`,
         );
-        return {
+        const softPass: JobResult = {
           ...result,
           summary: `${result.summary} (quality gate soft-pass after ${revisionAttempt} auto-revision attempt(s))`,
           stderr: diagnostics,
           exitCode: typeof result.exitCode === "number" ? result.exitCode : 0,
         };
+        return annotateTerminalResult(softPass, "quality");
       }
-      return {
+      const failure: JobResult = {
         ok: false,
         summary: `Quality gate failed after ${revisionAttempt} auto-revision attempt(s): ${toSingleLine(
           issueSummary,
@@ -7699,6 +8197,7 @@ export async function executeJob(
         ),
         exitCode: 4,
       };
+      return annotateTerminalResult(failure, "quality");
     }
 
     const revisionBudget = qualityRevisionBudgetDecision({
@@ -7715,7 +8214,7 @@ export async function executeJob(
         220,
       )}`;
       onLog?.("stderr", `[QualityGate] ${budgetSummary}`);
-      return {
+      const failure: JobResult = {
         ok: false,
         summary: budgetSummary,
         stdout: result.stdout,
@@ -7731,6 +8230,7 @@ export async function executeJob(
         ),
         exitCode: 4,
       };
+      return annotateTerminalResult(failure, "quality");
     }
 
     revisionAttempt += 1;