@pushpalsdev/cli 1.1.19 → 1.1.21

package/dist/pushpals-cli.js

@@ -1040,6 +1040,7 @@ function loadPushPalsConfig(options = {}) {
         enabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_ENABLED") ?? asBoolean(remoteAutonomyNode.enabled, true),
         killSwitchEnabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_KILL_SWITCH_ENABLED") ?? asBoolean(remoteAutonomyNode.kill_switch_enabled, false),
         tickIntervalMs: Math.max(5000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_TICK_INTERVAL_MS") ?? remoteAutonomyNode.tick_interval_ms, 120000)),
+        startupGraceMs: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_STARTUP_GRACE_MS") ?? remoteAutonomyNode.startup_grace_ms, 120000)),
         heartbeatLogMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_HEARTBEAT_LOG_MS") ?? remoteAutonomyNode.heartbeat_log_ms, 30000)),
         visionContextMaxChars: Math.max(1000, Math.min(1e6, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_VISION_CONTEXT_MAX_CHARS") ?? remoteAutonomyNode.vision_context_max_chars, 65536))),
         ideationBudgetMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_IDEATION_BUDGET_MS") ?? remoteAutonomyNode.ideation_budget_ms, 20000)),
@@ -1648,7 +1649,8 @@ var DEFAULT_STARTUP_GIT_PROBE_TIMEOUT_MS = 5000;
 var DEFAULT_STARTUP_GIT_REMOTE_TIMEOUT_MS = 1e4;
 var DEFAULT_EMBEDDED_SERVICE_LAUNCH_WARN_MS = 5000;
 var EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS = 4;
-var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 15000;
+var DEFAULT_WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 5000;
+var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS_ENV = "PUSHPALS_WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS";
 var BLOCKING_WORKERPAL_IMAGE_BUILD_ENV = "PUSHPALS_BLOCKING_WORKERPAL_IMAGE_BUILD";
 var CLI_SESSION_JOB_LOG_MAX_CHARS = 700;
 var CLI_SESSION_SHOW_JOB_EVENTS_ENV = "PUSHPALS_CLI_SHOW_JOB_EVENTS";
@@ -1681,6 +1683,13 @@ function formatTimestampedCliLine(line, at = new Date) {
 function isTruthyCliEnvValue(value) {
   return /^(1|true|yes|on)$/i.test(String(value ?? "").trim());
 }
+function parseCliIntEnv(name, env = process.env) {
+  const raw = env[name];
+  if (raw == null || String(raw).trim() === "")
+    return null;
+  const parsed = Number.parseInt(String(raw), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
 function shouldShowCliSessionOperationalEvents(env = process.env) {
   return isTruthyCliEnvValue(env[CLI_SESSION_SHOW_JOB_EVENTS_ENV]);
 }
@@ -3899,8 +3908,12 @@ async function precheckWorkerpalDockerAvailability(opts) {
 function resolveWorkerpalCapacityTimeoutMs(config) {
   return Math.max(config.remotebuddy.waitForWorkerpalMs, config.remotebuddy.workerpalStartupTimeoutMs, config.remotebuddy.workerpalDocker ? config.workerpals.dockerAgentStartupTimeoutMs + 15000 : 0, 1e4);
 }
+function resolveWorkerpalStartupReadinessProbeMaxMs(env = process.env) {
+  const configured = parseCliIntEnv(WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS_ENV, env);
+  return Math.max(1000, configured ?? DEFAULT_WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS);
+}
 function resolveWorkerpalStartupReadinessProbeTimeoutMs(config) {
-  return Math.max(5000, Math.min(resolveWorkerpalCapacityTimeoutMs(config), WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS));
+  return Math.max(1000, Math.min(resolveWorkerpalCapacityTimeoutMs(config), resolveWorkerpalStartupReadinessProbeMaxMs()));
 }
 function shouldPrepareEmbeddedWorkerpalDockerImageBlocking(opts = {}) {
   const env = opts.env ?? process.env;
@@ -6082,6 +6095,7 @@ export {
   shouldPrepareEmbeddedWorkerpalDockerImageBlocking,
   shouldDeferRemoteBuddySessionConsumerReadiness,
   runCommandWithEnv,
+  resolveWorkerpalStartupReadinessProbeMaxMs,
   resolveWorkerpalDockerProbe,
   resolveWorkerExecutionReadiness,
   resolveWindowsWhereExecutableCandidatesForEnv,

package/package.json

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

package/runtime/configs/default.toml

@@ -75,6 +75,7 @@ session_id = "remotebuddy-dev"
 enabled = true
 kill_switch_enabled = false
 tick_interval_ms = 300000
+startup_grace_ms = 120000
 heartbeat_log_ms = 30000
 vision_context_max_chars = 65536
 ideation_budget_ms = 20000

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

@@ -1323,6 +1323,7 @@ function loadPushPalsConfig(options = {}) {
         enabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_ENABLED") ?? asBoolean(remoteAutonomyNode.enabled, true),
         killSwitchEnabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_KILL_SWITCH_ENABLED") ?? asBoolean(remoteAutonomyNode.kill_switch_enabled, false),
         tickIntervalMs: Math.max(5000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_TICK_INTERVAL_MS") ?? remoteAutonomyNode.tick_interval_ms, 120000)),
+        startupGraceMs: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_STARTUP_GRACE_MS") ?? remoteAutonomyNode.startup_grace_ms, 120000)),
         heartbeatLogMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_HEARTBEAT_LOG_MS") ?? remoteAutonomyNode.heartbeat_log_ms, 30000)),
         visionContextMaxChars: Math.max(1000, Math.min(1e6, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_VISION_CONTEXT_MAX_CHARS") ?? remoteAutonomyNode.vision_context_max_chars, 65536))),
         ideationBudgetMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_IDEATION_BUDGET_MS") ?? remoteAutonomyNode.ideation_budget_ms, 20000)),
@@ -6569,6 +6570,7 @@ class RemoteBuddyAutonomousEngine {
   cfg;
   runtimeEnabled = true;
   timer = null;
+  startupGraceTimer = null;
   startupFastTickTimer = null;
   heartbeatTimer = null;
   inFlight = false;
@@ -6641,7 +6643,8 @@ class RemoteBuddyAutonomousEngine {
       console.log(`[RemoteBuddyAutonomousEngine] heartbeat: status=running run=${this.currentRunId} phase=${this.currentPhase} run_elapsed_ms=${runElapsedMs} phase_elapsed_ms=${phaseElapsedMs}`);
       return;
     }
-    const nextTickInMs = this.timer && this.nextTickAtMs > 0 ? Math.max(0, this.nextTickAtMs - now) : 0;
+    const hasScheduledTick = Boolean(this.timer || this.startupGraceTimer || this.startupFastTickTimer);
+    const nextTickInMs = hasScheduledTick && this.nextTickAtMs > 0 ? Math.max(0, this.nextTickAtMs - now) : 0;
     const lastAgeMs = this.lastCompletedAtMs > 0 ? Math.max(0, now - this.lastCompletedAtMs) : -1;
     console.log(`[RemoteBuddyAutonomousEngine] heartbeat: status=idle last_outcome=${this.lastOutcome} detail=${this.lastDetail} last_tick_age_ms=${lastAgeMs} next_tick_in_ms=${nextTickInMs}`);
   }
@@ -6667,6 +6670,15 @@ class RemoteBuddyAutonomousEngine {
   startupFastTickDelayMs() {
     return Math.max(1000, Math.min(STARTUP_FAST_TICK_MAX_DELAY_MS, Math.floor(this.cfg.tickIntervalMs / 10)));
   }
+  startupGraceMs() {
+    return Math.max(0, this.cfg.startupGraceMs ?? 0);
+  }
+  clearStartupGraceTimer() {
+    if (this.startupGraceTimer) {
+      clearTimeout(this.startupGraceTimer);
+      this.startupGraceTimer = null;
+    }
+  }
   clearStartupFastTickTimer() {
     if (this.startupFastTickTimer) {
       clearTimeout(this.startupFastTickTimer);
@@ -8160,22 +8172,42 @@ Scope:
     });
   }
   start() {
-    if (!this.runtimeEnabled || this.timer)
+    if (!this.runtimeEnabled || this.timer || this.startupGraceTimer)
       return;
     console.log(`[RemoteBuddyAutonomousEngine] Using dedicated autonomy worktree ${this.autonomyRepo} (remote=${this.gitRemote} integration=${this.integrationBranch} base=${this.baseBranch}).`);
     this.startupFastTickAttemptsRemaining = STARTUP_FAST_TICK_MAX_ATTEMPTS;
-    this.nextTickAtMs = Date.now();
-    this.timer = setInterval(() => {
-      this.nextTickAtMs = Date.now() + this.cfg.tickIntervalMs;
-      this.tick();
-    }, this.cfg.tickIntervalMs);
+    const startInterval = () => {
+      if (this.timer)
+        return;
+      this.timer = setInterval(() => {
+        this.nextTickAtMs = Date.now() + this.cfg.tickIntervalMs;
+        this.tick();
+      }, this.cfg.tickIntervalMs);
+    };
+    const firstTickDelayMs = this.startupGraceMs();
+    this.nextTickAtMs = Date.now() + firstTickDelayMs;
     this.heartbeatTimer = setInterval(() => {
       this.logHeartbeat();
     }, this.cfg.heartbeatLogMs);
     this.logHeartbeat();
+    if (firstTickDelayMs > 0) {
+      console.log(`[RemoteBuddyAutonomousEngine] startup autonomy tick delayed by ${firstTickDelayMs}ms to leave cold-start capacity available for user work.`);
+      this.startupGraceTimer = setTimeout(() => {
+        this.startupGraceTimer = null;
+        if (!this.runtimeEnabled)
+          return;
+        startInterval();
+        this.nextTickAtMs = Date.now() + this.cfg.tickIntervalMs;
+        this.tick();
+      }, firstTickDelayMs);
+      return;
+    }
+    startInterval();
+    this.nextTickAtMs = Date.now() + this.cfg.tickIntervalMs;
     this.tick();
   }
   stop() {
+    this.clearStartupGraceTimer();
     this.clearStartupFastTickTimer();
     if (this.timer) {
       clearInterval(this.timer);
@@ -9014,7 +9046,7 @@ class RemoteBuddyOrchestrator {
     console.log(`[RemoteBuddy] Budgets: interactive=${this.executionBudgetInteractiveMs}ms normal=${this.executionBudgetNormalMs}ms background=${this.executionBudgetBackgroundMs}ms finalization=${this.finalizationBudgetMs}ms`);
     console.log(`[RemoteBuddy] Failure log fetch on job failures: ${this.fetchFailureLogsOnJobFailure ? "on" : "off"}`);
     console.log(`[RemoteBuddy] Persistent memory: ${this.memoryEnabled ? "on" : "off"} crossSession=${this.memoryIncludeCrossSession ? "on" : "off"} recallItems=${this.memoryMaxRecallItems} recallChars=${this.memoryMaxRecallChars} retentionDays=${this.memoryRetentionDays}`);
-    console.log(`[RemoteBuddy] Autonomous engine: ${CONFIG.remotebuddy.autonomy.enabled ? "enabled" : "disabled"} tick=${CONFIG.remotebuddy.autonomy.tickIntervalMs}ms maxConcurrentObjectives=${CONFIG.remotebuddy.autonomy.maxConcurrentObjectives} maxDispatchPerHour=${CONFIG.remotebuddy.autonomy.maxDispatchPerHour} exploreRate=${CONFIG.remotebuddy.autonomy.exploreRate.toFixed(2)} allowDirtyWorktree=${CONFIG.remotebuddy.autonomy.allowDirtyWorktree ? "on" : "off"}`);
+    console.log(`[RemoteBuddy] Autonomous engine: ${CONFIG.remotebuddy.autonomy.enabled ? "enabled" : "disabled"} tick=${CONFIG.remotebuddy.autonomy.tickIntervalMs}ms startupGrace=${CONFIG.remotebuddy.autonomy.startupGraceMs}ms maxConcurrentObjectives=${CONFIG.remotebuddy.autonomy.maxConcurrentObjectives} maxDispatchPerHour=${CONFIG.remotebuddy.autonomy.maxDispatchPerHour} exploreRate=${CONFIG.remotebuddy.autonomy.exploreRate.toFixed(2)} allowDirtyWorktree=${CONFIG.remotebuddy.autonomy.allowDirtyWorktree ? "on" : "off"}`);
     console.log(`[RemoteBuddy] Autonomy runtime-config polling: every ${this.autonomyConfigPollMs}ms`);
   }
   async emitStartupStatus() {

package/runtime/sandbox/apps/workerpals/src/common/generic_python_executor.ts

@@ -29,6 +29,9 @@ interface GenericPythonExecutorConfig {
 }
 
 const BACKEND_TIMEOUT_RESULT_GRACE_MS = 30_000;
+const OPENAI_CODEX_MIN_VALIDATION_RESERVE_MS = 180_000;
+const OPENAI_CODEX_MAX_VALIDATION_RESERVE_MS = 600_000;
+const OPENAI_CODEX_MIN_PRIMARY_TURN_BUDGET_MS = 600_000;
 
 function estimateTokensFromText(text: string): number {
   return Math.max(0, Math.ceil(String(text ?? "").length / 3));
@@ -143,6 +146,27 @@ export function resolveGenericPythonExecutorTimeoutMs(params: {
   return configuredTimeoutMs;
 }
 
+export function resolveOpenAICodexValidationReserveMs(
+  executionBudgetMs: number | null | undefined,
+): number {
+  if (typeof executionBudgetMs !== "number" || !Number.isFinite(executionBudgetMs)) return 0;
+  const budgetMs = Math.max(10_000, Math.floor(executionBudgetMs));
+  const targetReserveMs = Math.floor(
+    Math.min(
+      budgetMs,
+      Math.max(
+        OPENAI_CODEX_MIN_VALIDATION_RESERVE_MS,
+        Math.min(OPENAI_CODEX_MAX_VALIDATION_RESERVE_MS, budgetMs * 0.35),
+      ),
+    ),
+  );
+  const maxReserveAfterPrimaryTurn = Math.max(
+    0,
+    budgetMs - OPENAI_CODEX_MIN_PRIMARY_TURN_BUDGET_MS,
+  );
+  return Math.max(0, Math.min(targetReserveMs, maxReserveAfterPrimaryTurn));
+}
+
 export function resolveGenericPythonExecutorChildTimeoutMs(params: {
   backendName: string;
   hostTimeoutMs: number;
@@ -154,8 +178,11 @@ export function resolveGenericPythonExecutorChildTimeoutMs(params: {
     typeof params.executionBudgetMs === "number" && Number.isFinite(params.executionBudgetMs)
       ? Math.max(10_000, Math.floor(params.executionBudgetMs))
       : null;
+  const validationReserveMs = resolveOpenAICodexValidationReserveMs(executionBudgetMs);
   const childBudgetMs =
-    executionBudgetMs == null ? hostTimeoutMs : Math.min(hostTimeoutMs, executionBudgetMs);
+    executionBudgetMs == null
+      ? hostTimeoutMs
+      : Math.min(hostTimeoutMs, Math.max(1_000, executionBudgetMs - validationReserveMs));
   const graceMs = Math.min(
     BACKEND_TIMEOUT_RESULT_GRACE_MS,
     Math.max(2_000, Math.floor(childBudgetMs / 10)),
@@ -305,15 +332,30 @@ export function createGenericPythonExecutor(
       "utf-8",
     ).toString("base64");
     const args = [pythonBin, scriptPath, payloadBase64];
-    const childTimeoutEnv = resolveGenericPythonExecutorChildTimeoutEnv({
+    const childTimeoutMs = resolveGenericPythonExecutorChildTimeoutMs({
       backendName,
       hostTimeoutMs: timeoutMs,
       executionBudgetMs,
     });
+    const childTimeoutEnv =
+      childTimeoutMs == null
+        ? {}
+        : {
+            WORKERPALS_OPENAI_CODEX_TIMEOUT_MS: String(childTimeoutMs),
+            WORKERPALS_OPENAI_CODEX_TIMEOUT_S: String(
+              Math.max(1, Math.floor(childTimeoutMs / 1000)),
+            ),
+          };
+    const childTimeoutDetail =
+      childTimeoutMs != null
+        ? `; codex_child_timeout=${childTimeoutMs}ms; reserved_validation_budget=${resolveOpenAICodexValidationReserveMs(
+            executionBudgetMs,
+          )}ms`
+        : "";
 
     onLog?.(
       "stdout",
-      `[${backendLabel}Executor] Spawning ${backendName} executor (timeout=${timeoutMs}ms; ${timeoutDetail})`,
+      `[${backendLabel}Executor] Spawning ${backendName} executor (timeout=${timeoutMs}ms; ${timeoutDetail}${childTimeoutDetail})`,
     );
 
     try {

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

@@ -34,6 +34,7 @@ import type {
   DockerWarmShellResult,
   DockerWarmStartupContext,
 } from "./backends/types.js";
+import { resolveFreshWorktreeBaseRef } from "./worktree_base_ref.js";
 
 const DEFAULT_OPENHANDS_MODEL = "local-model";
 const DEFAULT_CONFIG = loadPushPalsConfig();
@@ -2106,7 +2107,27 @@ export class DockerExecutor {
       reviewAgent && typeof reviewAgent.resolutionType === "string"
         ? reviewAgent.resolutionType.trim().toLowerCase()
         : "";
-    if (resolutionType !== "merge_conflict") return this.options.baseRef;
+    if (resolutionType !== "merge_conflict") {
+      return resolveFreshWorktreeBaseRef({
+        requestedRef: this.options.baseRef,
+        integrationBranch:
+          this.config.sourceControlManager.mainBranch ||
+          this.config.workerpals.baseRef ||
+          this.options.baseRef,
+        sourceBaseBranch: this.config.sourceControlManager.baseBranch,
+        git: (args) => this.runGitBaseRefCommand(args),
+        log: (level, message) => {
+          const line = `[DockerExecutor] ${message}`;
+          if (level === "warn") {
+            console.warn(line);
+            onLog?.("stderr", line);
+          } else {
+            console.log(line);
+            onLog?.("stdout", line);
+          }
+        },
+      });
+    }
 
     const normalizedHeadRef = normalizeMergeConflictHeadRef(reviewAgent?.prHeadRef);
     if (!normalizedHeadRef) {
@@ -2150,6 +2171,26 @@ export class DockerExecutor {
     return remoteRef;
   }
 
+  private async runGitBaseRefCommand(
+    args: string[],
+  ): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+    const proc = Bun.spawn(["git", ...args], {
+      cwd: this.options.repo,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    return {
+      ok: exitCode === 0,
+      stdout,
+      stderr,
+    };
+  }
+
   /**
    * Pull the Docker image
    */

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

@@ -190,6 +190,7 @@ export interface QualityGatePolicy {
 }
 
 const BROWSER_VALIDATION_MAX_AUTO_REVISIONS = 3;
+const CRITIC_COMPACT_RETRY_MIN_REDUCTION_RATIO = 0.25;
 
 export function qualityRevisionLoopUpperBound(policy: {
   maxAutoRevisions: number;
@@ -232,6 +233,37 @@ export function qualityRevisionBudgetDecision(opts: {
   };
 }
 
+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;
@@ -879,6 +911,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 +2132,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 +3710,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 +4838,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 +5817,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 +6280,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 +6350,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 +6440,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 +7054,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 +7083,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 +7121,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 +7129,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 +7146,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 +7155,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 +7175,7 @@ async function runCodexCriticReview(
     );
     return {
       status: "done",
+      payload,
       review: {
         score,
         findings,
@@ -7081,11 +7189,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") {
@@ -7316,6 +7449,42 @@ export async function executeJob(
         );
         continue;
       }
+      if (sequencer === "rebase" && !resume.resumed) {
+        mergeConflictPass += 1;
+        const budget = qualityRevisionBudgetDecision({
+          jobElapsedMs: Date.now() - attemptStartedAt,
+          executionBudgetMs,
+        });
+        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");
+          onLog?.(
+            "stdout",
+            `[MergeConflict] ${retryDetail}; rerunning resolver pass ${
+              mergeConflictPass + 1
+            } with focused rebase-completion guidance.`,
+          );
+          continue;
+        }
+        if (!budget.shouldStart) {
+          onLog?.(
+            "stderr",
+            `[MergeConflict] Not rerunning unfinished rebase resolver: remaining execution budget is ${budget.remainingBudgetMs}ms (< ${budget.minimumRevisionBudgetMs}ms).`,
+          );
+        }
+      }
       const detail =
         `Merge-conflict job returned with git ${sequencer} still in progress. ` +
         `Finish the ${sequencer} before returning control to WorkerPals.`;
@@ -7440,14 +7609,30 @@ 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);
     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,

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

@@ -197,6 +197,15 @@ function buildPlannerGuidance(
     lines.push(
       "- Use direct commands only while resolving this rebase. Prefer `git diff -- <path>`, `git add <path>`, and `git -c core.editor=true rebase --continue` instead of `/bin/bash -lc`, `sh -lc`, `awk`, or chained shell snippets.",
     );
+    lines.push(
+      "- Primary success condition: finish the git rebase and leave no active rebase/merge/cherry-pick state. Do not spend budget polishing, broadening, or refactoring tests beyond what is required to remove conflict markers and keep both sides' intended behavior.",
+    );
+    lines.push(
+      "- Rebase convergence rule: after resolving each conflicted file, run `git diff --name-only --diff-filter=U`. If no unresolved paths remain, stage the resolved files and continue the rebase immediately before doing broader validation.",
+    );
+    lines.push(
+      "- Budget rule: if conflict resolution is running long, choose the smallest side-preserving resolution, stage it, and continue the rebase. A clean rebased branch with focused follow-up validation is better than a richer partial patch left mid-rebase.",
+    );
     lines.push(
       "- After editing, run `git add <files>` and `git -c core.editor=true rebase --continue` until the rebase completes.",
     );

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

@@ -47,6 +47,7 @@ import { DockerExecutionExhaustedError, DockerExecutor } from "./docker_executor
 import { forceDeleteWorktreePath } from "./common/worktree_cleanup.js";
 import { WorkerServerTransport, type WorkerHeartbeatPayload } from "./common/server_transport.js";
 import { DEFAULT_DOCKER_TIMEOUT_MS, parseDockerTimeoutMs } from "./timeout_policy.js";
+import { resolveFreshWorktreeBaseRef } from "./worktree_base_ref.js";
 
 type CommitRef = {
   branch: string;
@@ -314,6 +315,8 @@ async function reportWorkerLlmUsage(
 }
 
 function integrationBranchName(): string {
+  const configuredIntegrationBranch = CONFIG.sourceControlManager.mainBranch.trim();
+  if (configuredIntegrationBranch) return configuredIntegrationBranch;
   const configuredBaseRef = CONFIG.workerpals.baseRef.trim();
   if (!configuredBaseRef) return "main_agents";
   return configuredBaseRef.replace(/^origin\//, "").trim() || "main_agents";
@@ -665,33 +668,17 @@ async function runJob(
 }
 
 async function resolveWorktreeBaseRef(repo: string, requestedRef: string): Promise<string> {
-  const integrationBranch = integrationBranchName();
-  const integrationRemoteRef = `origin/${integrationBranch}`;
-  const candidates = new Set<string>([
+  return resolveFreshWorktreeBaseRef({
     requestedRef,
-    integrationRemoteRef,
-    integrationBranch,
-    "HEAD",
-  ]);
-  if (requestedRef.startsWith("origin/")) {
-    const branch = requestedRef.slice("origin/".length);
-    const fetchResult = await git(repo, ["fetch", "origin", branch, "--quiet"]);
-    if (!fetchResult.ok) {
-      console.warn(
-        `[WorkerPals] Could not refresh ${requestedRef}; continuing with local refs (${fetchResult.stderr || fetchResult.stdout})`,
-      );
-    }
-    candidates.add(branch);
-  } else if (requestedRef !== "HEAD") {
-    candidates.add(`origin/${requestedRef}`);
-  }
-
-  for (const ref of candidates) {
-    const parsed = await git(repo, ["rev-parse", "--verify", "--quiet", ref]);
-    if (parsed.ok) return ref;
-  }
-
-  return "HEAD";
+    integrationBranch: integrationBranchName(),
+    sourceBaseBranch: CONFIG.sourceControlManager.baseBranch,
+    git: (args) => git(repo, args),
+    log: (level, message) => {
+      const line = `[WorkerPals] ${message}`;
+      if (level === "warn") console.warn(line);
+      else console.log(line);
+    },
+  });
 }
 
 async function createIsolatedWorktree(

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

@@ -0,0 +1,141 @@
+export type GitBaseRefCommandResult = {
+  ok: boolean;
+  stdout?: string;
+  stderr?: string;
+};
+
+export type GitBaseRefCommand = (args: string[]) => Promise<GitBaseRefCommandResult>;
+
+export type WorktreeBaseRefLogLevel = "info" | "warn";
+
+export type ResolveFreshWorktreeBaseRefOptions = {
+  requestedRef: string;
+  integrationBranch: string;
+  sourceBaseBranch: string;
+  remote?: string;
+  git: GitBaseRefCommand;
+  log?: (level: WorktreeBaseRefLogLevel, message: string) => void;
+};
+
+function normalizeBranchName(value: string): string {
+  return value
+    .trim()
+    .replace(/^refs\/heads\//, "")
+    .replace(/^origin\//, "")
+    .replace(/^\/+|\/+$/g, "");
+}
+
+function normalizeRequestedRef(value: string): string {
+  return value.trim() || "HEAD";
+}
+
+function remoteRef(remote: string, branch: string): string {
+  return `${remote}/${branch}`;
+}
+
+function isIntegrationBaseRequest(ref: string, integrationBranch: string, remote: string): boolean {
+  const normalized = normalizeRequestedRef(ref);
+  const branch = normalizeBranchName(normalized);
+  return (
+    branch === integrationBranch ||
+    normalized === remoteRef(remote, integrationBranch) ||
+    normalized === `refs/remotes/${remote}/${integrationBranch}`
+  );
+}
+
+async function fetchRemoteBranch(
+  git: GitBaseRefCommand,
+  remote: string,
+  branch: string,
+): Promise<GitBaseRefCommandResult> {
+  if (!remote || !branch || branch === "HEAD") return { ok: true };
+  return git(["fetch", remote, branch, "--quiet"]);
+}
+
+async function refExists(git: GitBaseRefCommand, ref: string): Promise<boolean> {
+  const result = await git(["rev-parse", "--verify", "--quiet", ref]);
+  return result.ok;
+}
+
+async function isAncestor(
+  git: GitBaseRefCommand,
+  ancestorRef: string,
+  descendantRef: string,
+): Promise<boolean> {
+  const result = await git(["merge-base", "--is-ancestor", ancestorRef, descendantRef]);
+  return result.ok;
+}
+
+export async function resolveExistingWorktreeBaseRef(
+  options: Omit<ResolveFreshWorktreeBaseRefOptions, "sourceBaseBranch" | "log">,
+): Promise<string> {
+  const remote = (options.remote ?? "origin").trim() || "origin";
+  const requestedRef = normalizeRequestedRef(options.requestedRef);
+  const integrationBranch = normalizeBranchName(options.integrationBranch) || "main_agents";
+  const integrationRemoteRef = remoteRef(remote, integrationBranch);
+  const candidates = new Set<string>([
+    requestedRef,
+    integrationRemoteRef,
+    integrationBranch,
+    "HEAD",
+  ]);
+
+  if (requestedRef.startsWith(`${remote}/`)) {
+    const branch = requestedRef.slice(`${remote}/`.length);
+    await fetchRemoteBranch(options.git, remote, branch);
+    candidates.add(branch);
+  } else if (requestedRef !== "HEAD") {
+    candidates.add(remoteRef(remote, requestedRef));
+  }
+
+  for (const ref of candidates) {
+    if (await refExists(options.git, ref)) return ref;
+  }
+
+  return "HEAD";
+}
+
+export async function resolveFreshWorktreeBaseRef(
+  options: ResolveFreshWorktreeBaseRefOptions,
+): Promise<string> {
+  const remote = (options.remote ?? "origin").trim() || "origin";
+  const requestedRef = normalizeRequestedRef(options.requestedRef);
+  const integrationBranch = normalizeBranchName(options.integrationBranch) || "main_agents";
+  const sourceBaseBranch = normalizeBranchName(options.sourceBaseBranch) || "main";
+  const resolvedRef = await resolveExistingWorktreeBaseRef({
+    requestedRef,
+    integrationBranch,
+    remote,
+    git: options.git,
+  });
+
+  if (
+    !sourceBaseBranch ||
+    sourceBaseBranch === integrationBranch ||
+    !isIntegrationBaseRequest(requestedRef, integrationBranch, remote)
+  ) {
+    return resolvedRef;
+  }
+
+  const sourceBaseRef = remoteRef(remote, sourceBaseBranch);
+  const fetchSource = await fetchRemoteBranch(options.git, remote, sourceBaseBranch);
+  if (!fetchSource.ok) {
+    options.log?.(
+      "warn",
+      `Could not refresh ${sourceBaseRef}; checking local ref before keeping ${resolvedRef} (${fetchSource.stderr || fetchSource.stdout || "fetch failed"}).`,
+    );
+  }
+
+  if (!(await refExists(options.git, sourceBaseRef))) return resolvedRef;
+
+  if (resolvedRef !== "HEAD" && (await refExists(options.git, resolvedRef))) {
+    const sourceAlreadyIncluded = await isAncestor(options.git, sourceBaseRef, resolvedRef);
+    if (sourceAlreadyIncluded) return resolvedRef;
+  }
+
+  options.log?.(
+    "warn",
+    `Worktree base ${resolvedRef} does not contain ${sourceBaseRef}; using ${sourceBaseRef} for new WorkerPal jobs to avoid stale integration-branch checkouts.`,
+  );
+  return sourceBaseRef;
+}

package/runtime/sandbox/configs/default.toml

@@ -75,6 +75,7 @@ session_id = "remotebuddy-dev"
 enabled = true
 kill_switch_enabled = false
 tick_interval_ms = 300000
+startup_grace_ms = 120000
 heartbeat_log_ms = 30000
 vision_context_max_chars = 65536
 ideation_budget_ms = 20000

package/runtime/sandbox/packages/shared/src/config.ts

@@ -128,6 +128,7 @@ export interface PushPalsConfig {
       enabled: boolean;
       killSwitchEnabled: boolean;
       tickIntervalMs: number;
+      startupGraceMs: number;
       heartbeatLogMs: number;
       visionContextMaxChars: number;
       ideationBudgetMs: number;
@@ -1671,6 +1672,14 @@ export function loadPushPalsConfig(options: LoadOptions = {}): PushPalsConfig {
             120_000,
           ),
         ),
+        startupGraceMs: Math.max(
+          0,
+          asInt(
+            parseIntEnv("REMOTEBUDDY_AUTONOMY_STARTUP_GRACE_MS") ??
+              remoteAutonomyNode.startup_grace_ms,
+            120_000,
+          ),
+        ),
         heartbeatLogMs: Math.max(
           1_000,
           asInt(