@pushpalsdev/cli 1.1.4 → 1.1.6

package/dist/pushpals-cli.js

@@ -37,6 +37,7 @@ var DEFAULT_SERVICE_MANAGER_MAX_RESTART_ATTEMPTS = 4;
 var DEFAULT_SERVICE_MANAGER_STABLE_WINDOW_MS = 60000;
 var DEFAULT_SERVICE_MANAGER_BASE_BACKOFF_MS = 2000;
 var DEFAULT_SERVICE_MANAGER_MAX_BACKOFF_MS = 30000;
+var WINDOWS_TASKKILL_TIMEOUT_MS = 5000;
 function formatEmbeddedRuntimeHealthLines(health) {
   if (!health)
     return [];
@@ -165,7 +166,9 @@ class ServiceManager {
           Bun.spawnSync(["taskkill", "/PID", String(pid), "/T", "/F"], {
             stdin: "ignore",
             stdout: "ignore",
-            stderr: "ignore"
+            stderr: "ignore",
+            timeout: WINDOWS_TASKKILL_TIMEOUT_MS,
+            killSignal: "SIGKILL"
           });
         } else {
           existing.proc.kill("SIGKILL");
@@ -226,7 +229,9 @@ class ServiceManager {
           Bun.spawnSync(["taskkill", "/PID", String(pid), "/T", "/F"], {
             stdin: "ignore",
             stdout: "ignore",
-            stderr: "ignore"
+            stderr: "ignore",
+            timeout: WINDOWS_TASKKILL_TIMEOUT_MS,
+            killSignal: "SIGKILL"
           });
         } else {
           service.proc.kill("SIGKILL");
@@ -457,7 +462,8 @@ var DEFAULT_WORKERPALS_OUTPUT_MAX_CHARS = 192 * 1024;
 var DEFAULT_WORKERPALS_OUTPUT_MAX_LINES = 600;
 var DEFAULT_WORKERPALS_OUTPUT_MAX_HEAD_LINES = 120;
 var DEFAULT_WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS = 180000;
-var DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS = 45000;
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS = 90000;
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_BEHAVIOR = "retry_once";
 var DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS = 16000;
 var DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS = 8000;
 var DEFAULT_WORKERPALS_EXECUTOR = "openai_codex";
@@ -536,6 +542,13 @@ function asString(value, fallback) {
     return value.trim();
   return fallback;
 }
+function asQualityCriticTimeoutBehavior(value) {
+  const normalized = String(value ?? "").trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "skip" || normalized === "retry_once" || normalized === "block") {
+    return normalized;
+  }
+  return DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_BEHAVIOR;
+}
 function asBoolean(value, fallback) {
   if (typeof value === "boolean")
     return value;
@@ -830,6 +843,7 @@ function loadPushPalsConfig(options = {}) {
   const workerOutputMaxHeadLines = Math.max(1, Math.min(workerOutputMaxLines, asInt(parseIntEnv("WORKERPALS_OUTPUT_MAX_HEAD_LINES") ?? workerNode.output_max_head_lines, DEFAULT_WORKERPALS_OUTPUT_MAX_HEAD_LINES)));
   const workerQualityValidationStepTimeoutMs = Math.max(1000, asInt(parseIntEnv("WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS") ?? workerNode.quality_validation_step_timeout_ms, DEFAULT_WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS));
   const workerQualityCriticTimeoutMs = Math.max(1000, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS") ?? workerNode.quality_critic_timeout_ms, DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS));
+  const workerQualityCriticTimeoutBehavior = asQualityCriticTimeoutBehavior(process.env.WORKERPALS_QUALITY_CRITIC_TIMEOUT_BEHAVIOR ?? workerNode.quality_critic_timeout_behavior);
   const workerQualitySoftPassOnExhausted = parseBoolEnv("WORKERPALS_QUALITY_SOFT_PASS_ON_EXHAUSTED") ?? asBoolean(workerNode.quality_soft_pass_on_exhausted, true);
   const workerQualityScopeGateEnabled = parseBoolEnv("WORKERPALS_QUALITY_SCOPE_GATE_ENABLED") ?? asBoolean(workerNode.quality_scope_gate_enabled, true);
   const workerQualityValidationGateEnabled = parseBoolEnv("WORKERPALS_QUALITY_VALIDATION_GATE_ENABLED") ?? asBoolean(workerNode.quality_validation_gate_enabled, true);
@@ -843,6 +857,7 @@ function loadPushPalsConfig(options = {}) {
       return DEFAULT_WORKERPALS_QUALITY_CRITIC_MIN_SCORE;
     return Math.max(0, Math.min(10, parsed));
   })();
+  const workerQualityCriticModel = firstNonEmpty(process.env.WORKERPALS_QUALITY_CRITIC_MODEL, asString(workerNode.quality_critic_model, ""), "");
   const workerQualityCriticMaxDiffChars = Math.max(256, Math.min(524288, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS") ?? workerNode.quality_critic_max_diff_chars, DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS)));
   const workerQualityCriticMaxValidationOutputChars = Math.max(256, Math.min(524288, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS") ?? workerNode.quality_critic_max_validation_output_chars, DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS)));
   const workerExecutorResultPrefix = (() => {
@@ -1132,8 +1147,10 @@ function loadPushPalsConfig(options = {}) {
       qualityPublishGateEnabled: workerQualityPublishGateEnabled,
       qualityValidationStepTimeoutMs: workerQualityValidationStepTimeoutMs,
       qualityCriticTimeoutMs: workerQualityCriticTimeoutMs,
+      qualityCriticTimeoutBehavior: workerQualityCriticTimeoutBehavior,
       qualitySoftPassOnExhausted: workerQualitySoftPassOnExhausted,
       qualityCriticMinScore: workerQualityCriticMinScore,
+      qualityCriticModel: workerQualityCriticModel,
       qualityCriticMaxDiffChars: workerQualityCriticMaxDiffChars,
       qualityCriticMaxValidationOutputChars: workerQualityCriticMaxValidationOutputChars,
       executorResultPrefix: workerExecutorResultPrefix,
@@ -1620,6 +1637,13 @@ var DEFAULT_RUNTIME_BOOT_TIMEOUT_MS = 90000;
 var DEFAULT_RUNTIME_BOOT_POLL_MS = 1000;
 var DEFAULT_SERVER_BOOT_TIMEOUT_MS = 20000;
 var DEFAULT_SERVICE_STABILITY_GRACE_MS = 4000;
+var DEFAULT_COMMAND_OUTPUT_DRAIN_TIMEOUT_MS = 2000;
+var DEFAULT_COMMAND_OUTPUT_MAX_CHARS = 512000;
+var DEFAULT_REMOTEBUDDY_SILENT_STARTUP_FALLBACK_MS = 20000;
+var WINDOWS_TASKKILL_TIMEOUT_MS2 = 5000;
+var RUNTIME_BINARY_DOWNLOAD_ATTEMPTS = 3;
+var DEFAULT_STARTUP_GIT_PROBE_TIMEOUT_MS = 5000;
+var DEFAULT_STARTUP_GIT_REMOTE_TIMEOUT_MS = 1e4;
 var EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS = 4;
 var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 15000;
 var EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
@@ -1917,9 +1941,119 @@ function parsePositiveInt(value, fallback) {
     return fallback;
   return parsed;
 }
+function clampPositiveInt(value, min, max) {
+  if (!Number.isFinite(value))
+    return min;
+  return Math.max(min, Math.min(max, Math.trunc(value)));
+}
+function resolveStartupGitProbeTimeoutMs(env) {
+  return clampPositiveInt(parsePositiveInt(env.PUSHPALS_STARTUP_GIT_PROBE_TIMEOUT_MS, DEFAULT_STARTUP_GIT_PROBE_TIMEOUT_MS), 1000, 30000);
+}
+function resolveStartupGitRemoteTimeoutMs(env) {
+  return clampPositiveInt(parsePositiveInt(env.PUSHPALS_STARTUP_GIT_REMOTE_TIMEOUT_MS, DEFAULT_STARTUP_GIT_REMOTE_TIMEOUT_MS), 1000, 60000);
+}
+async function withStartupTimeout(promise, timeoutMs, timeoutValue) {
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolveTimeout) => {
+        timer = setTimeout(() => resolveTimeout(timeoutValue()), Math.max(1, timeoutMs));
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 function jsonHtmlBootstrap(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
+function appendBoundedProcessOutput(existing, next, maxChars) {
+  if (!next)
+    return existing;
+  const combined = `${existing}${next}`;
+  if (combined.length <= maxChars)
+    return combined;
+  return combined.slice(combined.length - maxChars);
+}
+function createProcessOutputCollector(stream, maxChars = DEFAULT_COMMAND_OUTPUT_MAX_CHARS) {
+  if (!stream) {
+    return {
+      done: Promise.resolve(""),
+      snapshot: () => "",
+      cancel: () => {}
+    };
+  }
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let output = "";
+  let cancelled = false;
+  let finished = false;
+  const done = (async () => {
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done)
+          break;
+        output = appendBoundedProcessOutput(output, decoder.decode(chunk.value, { stream: true }), maxChars);
+      }
+      output = appendBoundedProcessOutput(output, decoder.decode(), maxChars);
+    } catch (err) {
+      if (!cancelled) {
+        output = appendBoundedProcessOutput(output, `
+[pushpals] output read failed: ${String(err)}`, maxChars);
+      }
+    } finally {
+      finished = true;
+      try {
+        reader.releaseLock();
+      } catch {}
+    }
+    return output;
+  })();
+  return {
+    done,
+    snapshot: () => output,
+    cancel: () => {
+      if (finished || cancelled)
+        return;
+      cancelled = true;
+      try {
+        reader.cancel().catch(() => {});
+      } catch {}
+    }
+  };
+}
+async function finishProcessOutputCollector(collector, timeoutMs = DEFAULT_COMMAND_OUTPUT_DRAIN_TIMEOUT_MS) {
+  const result = await Promise.race([
+    collector.done.then((text) => ({ text, timedOut: false })),
+    Bun.sleep(Math.max(1, timeoutMs)).then(() => ({
+      text: collector.snapshot(),
+      timedOut: true
+    }))
+  ]);
+  if (result.timedOut) {
+    collector.cancel();
+  }
+  return result.text;
+}
+function terminateSpawnedProcessTree(proc, platform = process.platform) {
+  try {
+    const stopCommand = buildServiceStopCommand(proc.pid, platform);
+    if (stopCommand) {
+      Bun.spawnSync(stopCommand, {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        timeout: WINDOWS_TASKKILL_TIMEOUT_MS2,
+        killSignal: "SIGKILL"
+      });
+      return;
+    }
+    proc.kill("SIGKILL");
+  } catch {}
+}
 async function runCommandWithEnv(command, cwd, env, timeoutMs) {
   try {
     const proc = Bun.spawn(command, {
@@ -1928,32 +2062,37 @@ async function runCommandWithEnv(command, cwd, env, timeoutMs) {
       stdout: "pipe",
       stderr: "pipe"
     });
+    const stdoutCollector = createProcessOutputCollector(proc.stdout);
+    const stderrCollector = createProcessOutputCollector(proc.stderr);
     let timedOut = false;
-    let timer = null;
-    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        try {
-          const stopCommand = buildServiceStopCommand(proc.pid, process.platform);
-          if (stopCommand) {
-            Bun.spawnSync(stopCommand, {
-              stdin: "ignore",
-              stdout: "ignore",
-              stderr: "ignore"
-            });
-          } else {
-            proc.kill("SIGKILL");
-          }
-        } catch {}
-      }, timeoutMs);
+    const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
+    let timeout = null;
+    const exitCode = await Promise.race([
+      proc.exited,
+      hasTimeout ? new Promise((resolveTimeout) => {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          terminateSpawnedProcessTree(proc);
+          resolveTimeout(-1);
+        }, timeoutMs);
+      }) : new Promise(() => {})
+    ]);
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    if (timedOut) {
+      await Promise.race([
+        proc.exited.catch(() => -1),
+        Bun.sleep(DEFAULT_COMMAND_OUTPUT_DRAIN_TIMEOUT_MS)
+      ]);
+      stdoutCollector.cancel();
+      stderrCollector.cancel();
     }
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
+    const [stdout, stderr] = await Promise.all([
+      finishProcessOutputCollector(stdoutCollector),
+      finishProcessOutputCollector(stderrCollector)
     ]);
-    if (timer)
-      clearTimeout(timer);
     const normalizedStdout = stdout.trim();
     const normalizedStderr = stderr.trim();
     if (timedOut) {
@@ -2000,15 +2139,15 @@ function withWindowsGitSchannelEnv(env, platform = process.platform) {
     return env;
   return appendGitConfigEnv(env, "http.sslBackend", "schannel");
 }
-async function runGitWithEnv(args, cwd, env) {
-  return await runCommandWithEnv(["git", ...args], cwd, withWindowsGitSchannelEnv(env));
+async function runGitWithEnv(args, cwd, env, timeoutMs) {
+  return await runCommandWithEnv(["git", ...args], cwd, withWindowsGitSchannelEnv(env), timeoutMs);
 }
-async function runGit(args, cwd) {
+async function runGit(args, cwd, timeoutMs) {
   return await runGitWithEnv(args, cwd, {
     ...process.env,
     GIT_TERMINAL_PROMPT: "0",
     GCM_INTERACTIVE: "Never"
-  });
+  }, timeoutMs);
 }
 async function resolveCurrentGitRepoRoot(cwd) {
   const inside = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
@@ -2738,20 +2877,14 @@ function normalizeChildProcessEnv(baseEnv, platform = process.platform) {
   }
   return env;
 }
-async function resolveCommandPath(command, cwd, env) {
+async function resolveCommandPath(command, cwd, env, timeoutMs = resolveStartupGitProbeTimeoutMs(env)) {
   const lookupCommands = process.platform === "win32" ? resolveWindowsWhereExecutableCandidatesForEnv(env, process.platform).map((lookup) => [lookup, command]) : [["which", command]];
   for (const lookup of lookupCommands) {
     try {
-      const proc = Bun.spawn(lookup, {
-        cwd,
-        env,
-        stdout: "pipe",
-        stderr: "ignore"
-      });
-      const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
-      if (exitCode !== 0)
+      const result = await runCommandWithEnv(lookup, cwd, env, timeoutMs);
+      if (!result.ok)
         continue;
-      const resolved = stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+      const resolved = result.stdout.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
       if (resolved)
         return resolved;
     } catch {}
@@ -2791,6 +2924,23 @@ function readLogTail(logPath, maxLines = 40) {
 function hasStandaloneBunCrashSignature(text) {
   return /\bpanic\(main thread\)|\bsegmentation fault\b|oh no:\s*bun has crashed\b/i.test(String(text ?? ""));
 }
+function hasRemoteBuddyRuntimeOutput(logText) {
+  return String(logText ?? "").split(/\r?\n/).some((line) => /\[(?:stdout|stderr)\]/i.test(line));
+}
+function shouldUseRemoteBuddySilentStartupFallback(opts) {
+  const platform = opts.platform ?? process.platform;
+  const thresholdMs = Math.max(1, opts.thresholdMs ?? DEFAULT_REMOTEBUDDY_SILENT_STARTUP_FALLBACK_MS);
+  if (platform !== "win32")
+    return false;
+  if (!opts.fallbackAvailable)
+    return false;
+  if (opts.elapsedMs < thresholdMs)
+    return false;
+  const logText = String(opts.logText ?? "");
+  if (hasStandaloneBunCrashSignature(logText))
+    return false;
+  return !hasRemoteBuddyRuntimeOutput(logText);
+}
 function extractRemoteBuddyAutonomousEngineState(logText) {
   const text = String(logText ?? "");
   if (!text)
@@ -2819,21 +2969,33 @@ function readRemoteBuddyAutonomousEngineState(logPath) {
 async function downloadBinaryAsset(tag, assetName, outPath) {
   console.log(`[pushpals] Downloading embedded runtime binary ${assetName} from ${tag}...`);
   const url = `${GITHUB_RELEASE_URL}/${encodeURIComponent(tag)}/${assetName}`;
-  try {
-    const response = await fetchWithTimeout(url, { headers: GITHUB_HEADERS }, 60000);
-    if (!response.ok) {
-      throw new Error(`Failed to download ${assetName} from ${tag} (HTTP ${response.status})`);
-    }
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    mkdirSync(dirname(outPath), { recursive: true });
-    await Bun.write(outPath, bytes);
-    return;
-  } catch (err) {
-    const fallback = await downloadBinaryAssetWithWindowsCurlFallback(url, outPath, err);
-    if (fallback)
+  let lastError = null;
+  for (let attempt = 1;attempt <= RUNTIME_BINARY_DOWNLOAD_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetchWithTimeout(url, { headers: GITHUB_HEADERS }, 60000);
+      if (!response.ok) {
+        throw new Error(`Failed to download ${assetName} from ${tag} (HTTP ${response.status})`);
+      }
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      mkdirSync(dirname(outPath), { recursive: true });
+      await Bun.write(outPath, bytes);
       return;
-    throw err;
+    } catch (err) {
+      try {
+        const fallback = await downloadBinaryAssetWithWindowsCurlFallback(url, outPath, err);
+        if (fallback)
+          return;
+        lastError = err;
+      } catch (fallbackErr) {
+        lastError = fallbackErr;
+      }
+      if (attempt < RUNTIME_BINARY_DOWNLOAD_ATTEMPTS) {
+        console.warn(`[pushpals] Runtime binary download for ${assetName} failed on attempt ${attempt}/${RUNTIME_BINARY_DOWNLOAD_ATTEMPTS}; retrying...`);
+        await Bun.sleep(1000 * attempt);
+      }
+    }
   }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "unknown error"));
 }
 async function downloadBinaryAssetWithWindowsCurlFallback(url, outPath, cause) {
   if (process.platform !== "win32")
@@ -2926,7 +3088,9 @@ function stopRuntimeServices(services) {
         Bun.spawnSync(stopCommand, {
           stdin: "ignore",
           stdout: "ignore",
-          stderr: "ignore"
+          stderr: "ignore",
+          timeout: WINDOWS_TASKKILL_TIMEOUT_MS2,
+          killSignal: "SIGKILL"
         });
       } else {
         service.proc.kill("SIGKILL");
@@ -2961,6 +3125,11 @@ async function stopRuntimeServicesGracefully(services, timeoutMs = 1e4) {
   if (running.length === 0)
     return;
   const ordered = [...running].sort((a, b) => resolveGracefulShutdownPriority(a.name) - resolveGracefulShutdownPriority(b.name));
+  if (process.platform === "win32") {
+    stopRuntimeServices(ordered);
+    await waitForRuntimeServicesExit(ordered, Math.min(1000, timeoutMs));
+    return;
+  }
   const nonServer = ordered.filter((service) => service.name !== "server");
   const server = ordered.filter((service) => service.name === "server");
   for (const service of nonServer) {
@@ -3159,50 +3328,31 @@ function computeEmbeddedServiceRestartBackoffMs(attempt) {
 function shouldRestartEmbeddedService(attempts, maxAttempts = EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS) {
   return shouldRestartService(attempts, maxAttempts);
 }
-async function canSpawnCommand(command, cwd, env) {
-  try {
-    const proc = Bun.spawn(command, {
-      cwd,
-      env,
-      stdin: "ignore",
-      stdout: "ignore",
-      stderr: "ignore"
-    });
-    const exitCode = await proc.exited;
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
+async function canSpawnCommand(command, cwd, env, timeoutMs = resolveStartupGitProbeTimeoutMs(env)) {
+  const result = await runCommandWithEnv(command, cwd, env, timeoutMs);
+  return result.ok;
 }
-async function canSpawnGitViaWindowsShell(commandArgs, cwd, env, platform = process.platform) {
+async function canSpawnGitViaWindowsShell(commandArgs, cwd, env, platform = process.platform, timeoutMs = resolveStartupGitProbeTimeoutMs(env)) {
   if (platform !== "win32")
     return false;
   const commandLine = commandArgs.map((arg) => quoteWindowsCmdArg(arg)).join(" ");
   for (const shellExecutable of resolveWindowsShellExecutableCandidatesForEnv(env, platform)) {
-    try {
-      const proc = Bun.spawn([shellExecutable, "/d", "/s", "/c", commandLine], {
-        cwd,
-        env,
-        stdin: "ignore",
-        stdout: "ignore",
-        stderr: "ignore"
-      });
-      const exitCode = await proc.exited;
-      return exitCode === 0;
-    } catch {}
+    const result = await runCommandWithEnv([shellExecutable, "/d", "/s", "/c", commandLine], cwd, env, timeoutMs);
+    if (result.ok)
+      return true;
   }
   return false;
 }
-async function resolveSourceControlManagerGitProbe(cwd, env, platform = process.platform) {
+async function resolveSourceControlManagerGitProbe(cwd, env, platform = process.platform, timeoutMs = resolveStartupGitProbeTimeoutMs(env)) {
   const candidates = resolveRuntimeGitExecutableCandidates(env, platform);
   for (const candidate of candidates) {
-    if (await canSpawnCommand([candidate, "--version"], cwd, env)) {
+    if (await canSpawnCommand([candidate, "--version"], cwd, env, timeoutMs)) {
       return { ok: true, detail: candidate };
     }
   }
   if (platform === "win32") {
     for (const candidate of candidates) {
-      if (await canSpawnGitViaWindowsShell([candidate, "--version"], cwd, env, platform)) {
+      if (await canSpawnGitViaWindowsShell([candidate, "--version"], cwd, env, platform, timeoutMs)) {
         return { ok: true, detail: `${candidate} via shell` };
       }
     }
@@ -3630,7 +3780,12 @@ async function precheckSourceControlManagerGitAvailability(opts) {
   if (preconfiguredGitBinary) {
     applyResolvedGitBinaryToRuntimeEnv(env, preconfiguredGitBinary, platform);
   }
-  const remoteStatus = opts.gitRemoteCheckFn ? await opts.gitRemoteCheckFn(opts.repoRoot, opts.remote, env) : opts.repoHasRemoteFn ? await opts.repoHasRemoteFn(opts.repoRoot, opts.remote) ? { status: "ok", remote: opts.remote } : { status: "missing_remote", remote: opts.remote } : await checkGitRemoteConfigured(opts.repoRoot, opts.remote, env);
+  const remoteTimeoutMs = resolveStartupGitRemoteTimeoutMs(env);
+  const remoteStatus = await withStartupTimeout(opts.gitRemoteCheckFn ? opts.gitRemoteCheckFn(opts.repoRoot, opts.remote, env) : opts.repoHasRemoteFn ? opts.repoHasRemoteFn(opts.repoRoot, opts.remote).then((hasRemote) => hasRemote ? { status: "ok", remote: opts.remote } : { status: "missing_remote", remote: opts.remote }) : checkGitRemoteConfigured(opts.repoRoot, opts.remote, env, remoteTimeoutMs), remoteTimeoutMs, () => ({
+    status: "error",
+    remote: opts.remote,
+    detail: `timed out after ${remoteTimeoutMs}ms`
+  }));
   if (remoteStatus.status === "missing_remote") {
     return {
       status: "skipped",
@@ -3719,7 +3874,7 @@ function resolveWorkerpalStartupReadinessProbeTimeoutMs(config) {
 function shouldRunEmbeddedRuntimeStartupPrechecks(opts) {
   return !opts.serverHealthy && !opts.noAutoStart;
 }
-async function checkGitRemoteConfigured(repoRoot, remote, env) {
+async function checkGitRemoteConfigured(repoRoot, remote, env, timeoutMs = resolveStartupGitRemoteTimeoutMs(env ?? process.env)) {
   const normalizedRemote = String(remote ?? "").trim();
   if (!normalizedRemote) {
     return { status: "missing_remote", remote: normalizedRemote };
@@ -3728,7 +3883,7 @@ async function checkGitRemoteConfigured(repoRoot, remote, env) {
     ...process.env,
     GIT_TERMINAL_PROMPT: "0",
     GCM_INTERACTIVE: "Never"
-  });
+  }, timeoutMs);
   if (result.ok && result.stdout) {
     return { status: "ok", remote: normalizedRemote };
   }
@@ -3757,7 +3912,7 @@ async function checkPushpalsBranchOnRemote(repoRoot, remote, branch) {
     };
   }
   const ref = `refs/heads/${normalizedBranch}`;
-  const result = await runGit(["ls-remote", "--heads", normalizedRemote, ref], repoRoot);
+  const result = await runGit(["ls-remote", "--heads", normalizedRemote, ref], repoRoot, resolveStartupGitRemoteTimeoutMs(process.env));
   if (!result.ok) {
     const detail = result.stderr || result.stdout || `exit ${result.exitCode}`;
     return {
@@ -3789,8 +3944,9 @@ async function enforcePushpalsRemoteBranchPrecheck(repoRoot, remote, branch) {
     console.error("[pushpals] Precheck failed: create/push that branch first or set source_control_manager.pushpals_branch to an existing remote branch.");
     return false;
   }
-  console.error(`[pushpals] Precheck failed: could not verify remote branch "${result.remote}/${result.branch}": ${result.detail}`);
-  return false;
+  console.warn(`[pushpals] Precheck warning: could not verify remote branch "${result.remote}/${result.branch}": ${result.detail}`);
+  console.warn("[pushpals] Precheck warning: continuing startup without SourceControlManager branch verification because the remote check was inconclusive.");
+  return true;
 }
 function isPathEqualOrWithin(parentPath, childPath) {
   const parent = normalizeRepoPathForComparison(parentPath);
@@ -4338,16 +4494,25 @@ async function autoStartRuntimeServices(opts) {
     bundlePath: sandboxPaths.remotebuddyFallbackBundlePath
   } : null;
   let remoteBuddyFallbackActivated = false;
-  const maybeActivateRemoteBuddyWindowsFallback = () => {
+  const maybeActivateRemoteBuddyWindowsFallback = (reason = "crash") => {
     if (remoteBuddyFallbackActivated || !remoteBuddySourceFallback)
       return false;
     const tail = readLogTail(serviceLogPaths.remotebuddy, 120);
-    if (!hasStandaloneBunCrashSignature(tail))
+    if (reason === "crash" && !hasStandaloneBunCrashSignature(tail))
       return false;
+    if (reason === "silent_startup" && !shouldUseRemoteBuddySilentStartupFallback({
+      logText: tail,
+      elapsedMs: Date.now() - remoteBuddyPhaseStartedAt,
+      platform: process.platform,
+      fallbackAvailable: Boolean(remoteBuddySourceFallback)
+    })) {
+      return false;
+    }
     remoteBuddyFallbackActivated = true;
     lastReportedRemoteBuddyAutonomyState = "unknown";
-    console.warn("[pushpals] Embedded RemoteBuddy standalone binary crashed on Windows; retrying with source fallback under bun.");
-    appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] embedded remotebuddy standalone binary crashed on Windows; retrying with source fallback under bun.");
+    const fallbackReason = reason === "silent_startup" ? "produced no startup output on Windows" : "crashed on Windows";
+    console.warn(`[pushpals] Embedded RemoteBuddy standalone binary ${fallbackReason}; retrying with source fallback under bun.`);
+    appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded remotebuddy standalone binary ${fallbackReason}; retrying with source fallback under bun.`);
     replaceService("remotebuddy", [
       remoteBuddySourceFallback.bunBin,
       remoteBuddySourceFallback.bundlePath,
@@ -4459,31 +4624,35 @@ ${tail}` : ""}`);
     recordStartupPhase("workerpal", Date.now(), "disabled");
   }
   const scmHealthy = await probeSourceControlManager(opts.sourceControlManagerPort);
-  const scmGitProbe = await resolveSourceControlManagerGitProbe(opts.repoRoot, runtimeEnv, process.platform);
-  const scmRemoteStatus = await checkGitRemoteConfigured(opts.repoRoot, opts.sourceControlManagerRemote, runtimeEnv);
   if (!scmHealthy) {
     const scmPhaseStartedAt = Date.now();
+    console.log("[pushpals] Checking embedded SourceControlManager git/remote preflight...");
+    appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] checking embedded source_control_manager git/remote preflight.");
+    const scmGitProbe = await resolveSourceControlManagerGitProbe(opts.repoRoot, runtimeEnv, process.platform);
     if (!scmGitProbe.ok) {
       console.warn("[pushpals] Git is not available to embedded SourceControlManager; skipping SCM startup.");
       appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] source_control_manager skipped: git is unavailable in embedded runtime env (${scmGitProbe.detail}).`);
       recordStartupPhase("source_control_manager", scmPhaseStartedAt, "skipped_no_git");
-    } else if (scmRemoteStatus.status === "error") {
-      console.warn(`[pushpals] Could not inspect SourceControlManager git remote "${opts.sourceControlManagerRemote}"; skipping SCM startup.`);
-      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] source_control_manager skipped: remote "${opts.sourceControlManagerRemote}" could not be inspected (${scmRemoteStatus.detail}).`);
-      recordStartupPhase("source_control_manager", scmPhaseStartedAt, "skipped_remote_error");
-    } else if (scmRemoteStatus.status === "ok") {
-      console.log(`[pushpals] Embedded SourceControlManager git=${scmGitProbe.detail}`);
-      console.log("[pushpals] Starting embedded SourceControlManager...");
-      const sourceControlManagerService = launchService("source_control_manager", [
-        runtimeBinaries.sourceControlManager,
-        "--skip-clean-check"
-      ]);
-      console.log(`[pushpals] source_control_manager log: ${sourceControlManagerService.logPath ?? serviceLogPaths.source_control_manager}`);
-      recordStartupPhase("source_control_manager", scmPhaseStartedAt, "started");
     } else {
-      console.log(`[pushpals] Repo has no git remote "${opts.sourceControlManagerRemote}"; skipping embedded SourceControlManager.`);
-      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] source_control_manager skipped: repo has no remote "${opts.sourceControlManagerRemote}".`);
-      recordStartupPhase("source_control_manager", scmPhaseStartedAt, "skipped_no_remote");
+      const scmRemoteStatus = await checkGitRemoteConfigured(opts.repoRoot, opts.sourceControlManagerRemote, runtimeEnv);
+      if (scmRemoteStatus.status === "error") {
+        console.warn(`[pushpals] Could not inspect SourceControlManager git remote "${opts.sourceControlManagerRemote}"; skipping SCM startup.`);
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] source_control_manager skipped: remote "${opts.sourceControlManagerRemote}" could not be inspected (${scmRemoteStatus.detail}).`);
+        recordStartupPhase("source_control_manager", scmPhaseStartedAt, "skipped_remote_error");
+      } else if (scmRemoteStatus.status === "ok") {
+        console.log(`[pushpals] Embedded SourceControlManager git=${scmGitProbe.detail}`);
+        console.log("[pushpals] Starting embedded SourceControlManager...");
+        const sourceControlManagerService = launchService("source_control_manager", [
+          runtimeBinaries.sourceControlManager,
+          "--skip-clean-check"
+        ]);
+        console.log(`[pushpals] source_control_manager log: ${sourceControlManagerService.logPath ?? serviceLogPaths.source_control_manager}`);
+        recordStartupPhase("source_control_manager", scmPhaseStartedAt, "started");
+      } else {
+        console.log(`[pushpals] Repo has no git remote "${opts.sourceControlManagerRemote}"; skipping embedded SourceControlManager.`);
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] source_control_manager skipped: repo has no remote "${opts.sourceControlManagerRemote}".`);
+        recordStartupPhase("source_control_manager", scmPhaseStartedAt, "skipped_no_remote");
+      }
     }
   } else {
     recordStartupPhase("source_control_manager", Date.now(), "reused");
@@ -4495,6 +4664,10 @@ ${tail}` : ""}`);
   const optionalServiceExitWarned = new Set;
   while (Date.now() < deadline) {
     reportRemoteBuddyAutonomousEngineState();
+    if (maybeActivateRemoteBuddyWindowsFallback("silent_startup")) {
+      await Bun.sleep(DEFAULT_RUNTIME_BOOT_POLL_MS);
+      continue;
+    }
     for (const service of serviceManager.getServices()) {
       if (service.exited) {
         if (service.name === "remotebuddy" && maybeActivateRemoteBuddyWindowsFallback()) {
@@ -5249,8 +5422,7 @@ async function main() {
       sessionId
     });
     if (scmGitPrecheck.status === "failed") {
-      console.error(`[pushpals] Precheck failed: embedded SourceControlManager git command is unavailable (${scmGitPrecheck.detail}).`);
-      process.exit(1);
+      console.warn(`[pushpals] Embedded SourceControlManager precheck failed (${scmGitPrecheck.detail}); continuing startup without blocking on SCM.`);
     }
     workerpalDockerPrecheck = await precheckWorkerpalDockerAvailability({
       repoRoot,
@@ -5460,12 +5632,16 @@ async function main() {
     }
     process.exit(1);
   }
-  const workerpalCapacity = await waitForWorkerpalCapacity({
+  const shouldProbeWorkerpalStartupCapacity = Boolean(config.remotebuddy.autoSpawnWorkerpals);
+  const workerpalCapacity = shouldProbeWorkerpalStartupCapacity ? await waitForWorkerpalCapacity({
     serverUrl,
     timeoutMs: resolveWorkerpalStartupReadinessProbeTimeoutMs(config),
     ttlMs: config.remotebuddy.workerpalOnlineTtlMs
-  });
-  if (!workerpalCapacity.ok) {
+  }) : {
+    ok: false,
+    detail: "WorkerPal auto-spawn is disabled"
+  };
+  if (shouldProbeWorkerpalStartupCapacity && !workerpalCapacity.ok) {
     console.warn(`[pushpals] WorkerPal readiness probe did not find idle capacity yet (${workerpalCapacity.detail}).`);
     console.warn("[pushpals] Continuing startup; WorkerPal warmup may still be in progress and first task dispatch can be delayed.");
     if (workerpalDockerPrecheck.status === "failed") {
@@ -5478,7 +5654,13 @@ async function main() {
   const startupWorkerExecutionReadiness = workerpalCapacity.ok ? {
     state: "ready",
     detail: workerpalCapacity.detail
-  } : workerpalDockerPrecheck.status === "failed" ? describeWorkerExecutionReadiness({
+  } : !shouldProbeWorkerpalStartupCapacity ? describeWorkerExecutionReadiness({
+    autoSpawnWorkerpals: false,
+    requireDocker: Boolean(config.remotebuddy.workerpalDocker) && Boolean(config.remotebuddy.workerpalRequireDocker),
+    dockerPrecheck: workerpalDockerPrecheck,
+    onlineWorkers: 0,
+    idleWorkers: 0
+  }) : workerpalDockerPrecheck.status === "failed" ? describeWorkerExecutionReadiness({
     autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
     requireDocker: Boolean(config.remotebuddy.workerpalDocker) && Boolean(config.remotebuddy.workerpalRequireDocker),
     dockerPrecheck: workerpalDockerPrecheck,
@@ -5689,8 +5871,10 @@ export {
   waitForWorkerpalCapacity,
   startEmbeddedMonitoringHub,
   shutdownEmbeddedServiceManagerGracefully,
+  shouldUseRemoteBuddySilentStartupFallback,
   shouldRunEmbeddedRuntimeStartupPrechecks,
   shouldRestartEmbeddedService,
+  runCommandWithEnv,
   resolveWorkerpalDockerProbe,
   resolveWorkerExecutionReadiness,
   resolveWindowsWhereExecutableCandidatesForEnv,
@@ -5716,6 +5900,7 @@ export {
   isDockerCleanupTimeoutDetail,
   isCliExitCommand,
   injectMonitoringHubBootstrap,
+  hasRemoteBuddyRuntimeOutput,
   formatWorkerExecutionReadinessLines,
   formatTimestampedCliLine,
   formatSessionEventLine,