@pushpalsdev/cli 1.0.30 → 1.0.32

package/dist/pushpals-cli.js

@@ -1217,6 +1217,15 @@ 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 WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 15000;
+var EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
+var EMBEDDED_RUNTIME_WINDOWS_SAFETY_CAPS = {
+  REMOTEBUDDY_WORKERPAL_STARTUP_TIMEOUT_MS: "120000",
+  WORKERPALS_DOCKER_AGENT_STARTUP_TIMEOUT_MS: "90000",
+  WORKERPALS_SKIP_DOCKER_SELF_CHECK: "1",
+  WORKERPALS_DOCKER_WARM_MEMORY_MB: "1024",
+  WORKERPALS_DOCKER_WARM_CPUS: "1"
+};
 var GITHUB_OWNER = "PushPalsDev";
 var GITHUB_REPO = "pushpals";
 var GITHUB_API_URL = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`;
@@ -1235,6 +1244,98 @@ function formatTimestampedCliLine(line, at = new Date) {
   }
   return `[${at.toISOString()}]${text}`;
 }
+function formatRuntimeStartupTimingSummary(input) {
+  const phaseSummary = input.phases.map((phase) => `${phase.name}=${Math.max(0, Math.floor(phase.durationMs))}ms(${phase.status.trim() || "unknown"})`).join(" ");
+  const detail = typeof input.detail === "string" && input.detail.trim() ? ` detail=${input.detail.trim()}` : "";
+  return `[pushpals] startup timing summary: outcome=${input.outcome} ` + `total=${Math.max(0, Math.floor(input.totalDurationMs))}ms${detail}` + (phaseSummary ? ` ${phaseSummary}` : "");
+}
+function describeWorkerExecutionReadiness(opts) {
+  const onlineWorkers = Math.max(0, Math.floor(opts.onlineWorkers));
+  const idleWorkers = Math.max(0, Math.floor(opts.idleWorkers));
+  if (idleWorkers > 0) {
+    return {
+      state: "ready",
+      detail: `${idleWorkers} idle / ${onlineWorkers} online`
+    };
+  }
+  if (onlineWorkers > 0) {
+    return {
+      state: "warming",
+      detail: `${idleWorkers} idle / ${onlineWorkers} online`,
+      action: "Wait for WorkerPal warmup or active jobs to finish, then retry /status or send the request again."
+    };
+  }
+  if (!opts.autoSpawnWorkerpals) {
+    return {
+      state: "blocked",
+      detail: "No online WorkerPals are reported and auto-spawn is disabled.",
+      action: "Start a WorkerPals backend manually or enable RemoteBuddy auto-spawn."
+    };
+  }
+  if (opts.requireDocker && opts.dockerPrecheck?.status === "failed") {
+    return {
+      state: "blocked",
+      detail: `Docker-backed WorkerPal auto-spawn is unavailable: ${opts.dockerPrecheck.detail}`,
+      action: "Start Docker Desktop or the Docker daemon, then retry startup or rerun /status."
+    };
+  }
+  return {
+    state: "warming",
+    detail: "No online WorkerPals are reported yet.",
+    action: "Wait for WorkerPal auto-spawn/warmup to finish, then rerun /status."
+  };
+}
+function formatWorkerExecutionReadinessLines(readiness) {
+  const lines = [
+    `[pushpals] workerExecution=${readiness.state} detail=${readiness.detail}`
+  ];
+  if (readiness.action) {
+    lines.push(`[pushpals] workerExecutionAction=${readiness.action}`);
+  }
+  return lines;
+}
+function summarizeWorkerStatusRows(workers) {
+  const onlineWorkers = workers.filter((worker) => Boolean(worker?.isOnline) && String(worker?.status ?? "").trim().toLowerCase() !== "offline");
+  const idleWorkers = onlineWorkers.filter((worker) => Number(worker?.activeJobCount ?? 0) <= 0);
+  return {
+    onlineWorkers: onlineWorkers.length,
+    idleWorkers: idleWorkers.length
+  };
+}
+async function resolveWorkerExecutionReadiness(opts) {
+  let workers = [];
+  try {
+    workers = await (opts.fetchWorkersFn ?? fetchWorkerStatusRows)(opts.serverUrl, opts.ttlMs);
+  } catch (error) {
+    return {
+      state: "blocked",
+      detail: `Unable to query WorkerPal status: ${String(error)}`,
+      action: "Check runtime connectivity, then retry /status or restart the runtime."
+    };
+  }
+  const { onlineWorkers, idleWorkers } = summarizeWorkerStatusRows(workers);
+  let dockerPrecheck = opts.dockerPrecheck ?? null;
+  const shouldProbeDockerAvailability = onlineWorkers === 0 && opts.autoSpawnWorkerpals && opts.dockerEnabled && opts.requireDocker && !dockerPrecheck && typeof opts.repoRoot === "string" && opts.repoRoot.trim().length > 0 && typeof opts.runtimeRoot === "string" && opts.runtimeRoot.trim().length > 0 && typeof opts.preflightUsesEmbeddedRuntime === "boolean";
+  if (shouldProbeDockerAvailability) {
+    dockerPrecheck = await (opts.precheckDockerAvailabilityFn ?? precheckWorkerpalDockerAvailability)({
+      repoRoot: opts.repoRoot,
+      runtimeRoot: opts.runtimeRoot,
+      preflightUsesEmbeddedRuntime: opts.preflightUsesEmbeddedRuntime,
+      autoSpawnWorkerpals: opts.autoSpawnWorkerpals,
+      dockerEnabled: opts.dockerEnabled,
+      requireDocker: opts.requireDocker,
+      sessionId: opts.sessionId,
+      baseEnv: opts.baseEnv
+    });
+  }
+  return describeWorkerExecutionReadiness({
+    autoSpawnWorkerpals: opts.autoSpawnWorkerpals,
+    requireDocker: opts.dockerEnabled && opts.requireDocker,
+    dockerPrecheck,
+    onlineWorkers,
+    idleWorkers
+  });
+}
 function normalizeCliInteractiveMessage(input) {
   const trimmed = String(input ?? "").trim();
   const command = ASK_REMOTE_BUDDY_COMMAND.toLowerCase();
@@ -1792,8 +1893,15 @@ function copyBundledRuntimeAssets(runtimeRoot, force = true) {
   copyRuntimeAssetBundle(bundledSource, runtimeRoot, force);
   return true;
 }
+function hasSeededRuntimePreflightAssets(runtimeRoot) {
+  const protocolSchemasDir = join2(runtimeRoot, "protocol", "schemas");
+  const hasProtocolSchemas = existsSync4(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync4(join2(protocolSchemasDir, "events.schema.json"));
+  return existsSync4(join2(runtimeRoot, ".env.example")) && existsSync4(join2(runtimeRoot, "vision.example.md")) && existsSync4(join2(runtimeRoot, "configs", "default.toml")) && existsSync4(join2(runtimeRoot, "prompts")) && hasProtocolSchemas && isCompleteWorkerpalSandboxRoot(join2(runtimeRoot, "sandbox"));
+}
 function seedRuntimePreflightAssets(runtimeRoot) {
-  copyBundledRuntimeAssets(runtimeRoot, false);
+  if (!hasSeededRuntimePreflightAssets(runtimeRoot)) {
+    copyBundledRuntimeAssets(runtimeRoot, false);
+  }
   writeTextFileIfMissing(join2(runtimeRoot, ".env"), `# Local PushPals runtime environment
 `);
   const localExamplePath = join2(runtimeRoot, "configs", "local.example.toml");
@@ -1946,12 +2054,20 @@ function cleanupLegacyRuntimeBinaryLayouts(runtimeRoot, platformKey, activeBinDi
 function buildEmbeddedRuntimeEnv(baseEnv, opts) {
   const env = normalizeChildProcessEnv(baseEnv);
   const useRuntimeConfig = opts.useRuntimeConfig !== false;
+  const platform = opts.platform ?? process.platform;
+  const embeddedBunBin = resolveEmbeddedBunExecutableFromEnv(env, platform);
   const inherited = { ...env };
   if (!useRuntimeConfig) {
     delete inherited.PUSHPALS_CONFIG_DIR_OVERRIDE;
     delete inherited.PUSHPALS_WORKERPALS_SANDBOX_ROOT;
     delete inherited.PUSHPALS_RUNTIME_TAG;
   }
+  const disableEmbeddedSafetyCaps = parseBooleanFlag(env[EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV]) === true;
+  const shouldApplyEmbeddedWindowsSafetyCaps = useRuntimeConfig && platform === "win32" && !disableEmbeddedSafetyCaps;
+  const embeddedWindowsSafetyCaps = shouldApplyEmbeddedWindowsSafetyCaps ? Object.fromEntries(Object.entries(EMBEDDED_RUNTIME_WINDOWS_SAFETY_CAPS).filter(([key]) => {
+    const existing = env[key];
+    return typeof existing !== "string" || existing.trim().length === 0;
+  })) : {};
   return {
     ...inherited,
     PUSHPALS_REPO_ROOT_OVERRIDE: opts.repoRoot,
@@ -1966,12 +2082,50 @@ function buildEmbeddedRuntimeEnv(baseEnv, opts) {
     },
     PUSHPALS_PROTOCOL_SCHEMAS_DIR: join2(opts.runtimeRoot, "protocol", "schemas"),
     ...typeof opts.sessionId === "string" && opts.sessionId.trim() ? { PUSHPALS_SESSION_ID: opts.sessionId.trim() } : {},
+    ...embeddedBunBin ? { PUSHPALS_BUN_BIN: embeddedBunBin } : {},
+    ...embeddedWindowsSafetyCaps,
     ...typeof env.PUSHPALS_GIT_BIN === "string" && env.PUSHPALS_GIT_BIN.trim() ? { PUSHPALS_GIT_BIN: env.PUSHPALS_GIT_BIN.trim() } : {},
     ...typeof env.PUSHPALS_GIT_BIN_ABSOLUTE === "string" && env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() ? { PUSHPALS_GIT_BIN_ABSOLUTE: env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() } : {},
     ...typeof env.PUSHPALS_DOCKER_BIN === "string" && env.PUSHPALS_DOCKER_BIN.trim() ? { PUSHPALS_DOCKER_BIN: env.PUSHPALS_DOCKER_BIN.trim() } : {},
     ...typeof env.PUSHPALS_DOCKER_BIN_ABSOLUTE === "string" && env.PUSHPALS_DOCKER_BIN_ABSOLUTE.trim() ? { PUSHPALS_DOCKER_BIN_ABSOLUTE: env.PUSHPALS_DOCKER_BIN_ABSOLUTE.trim() } : {}
   };
 }
+function parseBooleanFlag(raw) {
+  const normalized = String(raw ?? "").trim().toLowerCase();
+  if (!normalized)
+    return null;
+  if (["1", "true", "yes", "on", "y"].includes(normalized))
+    return true;
+  if (["0", "false", "no", "off", "n"].includes(normalized))
+    return false;
+  return null;
+}
+function resolveEmbeddedBunExecutableFromEnv(env, platform = process.platform, currentExecPathOverride) {
+  const explicit = String(env.PUSHPALS_BUN_BIN ?? "").trim();
+  if (explicit)
+    return explicit;
+  const currentExecPath = String(currentExecPathOverride ?? process.execPath ?? "").trim();
+  const currentExecLeaf = basename(currentExecPath).toLowerCase();
+  if (currentExecLeaf === "bun" || currentExecLeaf === "bun.exe") {
+    return currentExecPath;
+  }
+  const pathValue = platform === "win32" ? String(env.PATH ?? env.Path ?? "").trim() : String(env.PATH ?? "").trim();
+  if (!pathValue)
+    return "";
+  const candidates = platform === "win32" ? ["bun.exe", "bun", "bun.cmd", "bun.bat"] : ["bun"];
+  for (const rawDir of pathValue.split(delimiter)) {
+    const dir = rawDir.trim();
+    if (!dir)
+      continue;
+    for (const candidate of candidates) {
+      const fullPath = join2(dir, candidate);
+      if (existsSync4(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  return "";
+}
 function normalizeChildProcessEnv(baseEnv, platform = process.platform) {
   const env = {};
   for (const [key, value] of Object.entries(baseEnv)) {
@@ -2840,6 +2994,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 resolveWorkerpalStartupReadinessProbeTimeoutMs(config) {
+  return Math.max(5000, Math.min(resolveWorkerpalCapacityTimeoutMs(config), WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS));
+}
+function shouldRunEmbeddedRuntimeStartupPrechecks(opts) {
+  return !opts.serverHealthy && !opts.noAutoStart;
+}
 async function checkGitRemoteConfigured(repoRoot, remote, env) {
   const normalizedRemote = String(remote ?? "").trim();
   if (!normalizedRemote) {
@@ -3193,15 +3353,14 @@ async function waitForWorkerpalCapacity(opts) {
   let lastObservedOnline = 0;
   while (Date.now() < deadline) {
     const workers = await (opts.fetchWorkersFn ?? fetchWorkerStatusRows)(opts.serverUrl, opts.ttlMs);
-    const onlineWorkers = workers.filter((worker) => Boolean(worker?.isOnline) && String(worker?.status ?? "").trim().toLowerCase() !== "offline");
-    const idleWorkers = onlineWorkers.filter((worker) => Number(worker?.activeJobCount ?? 0) <= 0);
-    if (onlineWorkers.length > 0) {
-      lastObservedOnline = Math.max(lastObservedOnline, onlineWorkers.length);
+    const summary = summarizeWorkerStatusRows(workers);
+    if (summary.onlineWorkers > 0) {
+      lastObservedOnline = Math.max(lastObservedOnline, summary.onlineWorkers);
     }
-    if (idleWorkers.length > 0) {
+    if (summary.idleWorkers > 0) {
       return {
         ok: true,
-        detail: `${idleWorkers.length} idle / ${onlineWorkers.length} online`
+        detail: `${summary.idleWorkers} idle / ${summary.onlineWorkers} online`
       };
     }
     await (opts.sleepFn ?? Bun.sleep)(DEFAULT_RUNTIME_BOOT_POLL_MS);
@@ -3324,6 +3483,29 @@ async function autoStartRuntimeServices(opts) {
     applyResolvedGitBinaryToRuntimeEnv(runtimeEnv, resolvedGitBinary);
   }
   const services = [];
+  const startupStartedAt = Date.now();
+  const startupPhases = [];
+  const recordStartupPhase = (name, startedAt, status) => {
+    startupPhases.push({
+      name,
+      durationMs: Math.max(0, Date.now() - startedAt),
+      status
+    });
+  };
+  const emitStartupTimingSummary = (outcome, detail) => {
+    const summary = formatRuntimeStartupTimingSummary({
+      outcome,
+      totalDurationMs: Date.now() - startupStartedAt,
+      phases: startupPhases,
+      detail
+    });
+    if (outcome === "failed") {
+      console.warn(summary);
+    } else {
+      console.log(summary);
+    }
+    appendRuntimeServicesLogLine(runtimeServicesLogPath, summary);
+  };
   const runToken = timestampFileToken();
   const logDir = join2(runtimeRoot, "logs", "bootstrap");
   mkdirSync(logDir, { recursive: true });
@@ -3341,6 +3523,7 @@ async function autoStartRuntimeServices(opts) {
   console.log(`[pushpals] service log (source_control_manager)=${serviceLogPaths.source_control_manager}`);
   const serverHealthy = await probeServer(opts.serverUrl);
   if (!serverHealthy) {
+    const serverPhaseStartedAt = Date.now();
     console.log("[pushpals] Starting embedded server...");
     const serverService = spawnRuntimeService("server", [runtimeBinaries.server], opts.repoRoot, runtimeEnv, serviceLogPaths.server, runtimeServicesLogPath);
     services.push(serverService);
@@ -3351,6 +3534,8 @@ async function autoStartRuntimeServices(opts) {
       if (serverService.exited) {
         const tail = readLogTail(serverService.logPath);
         appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded server exited during bootstrap (code=${serverService.exitCode ?? "unknown"}).`);
+        recordStartupPhase("server", serverPhaseStartedAt, "exited");
+        emitStartupTimingSummary("failed", "server exited during bootstrap");
         stopRuntimeServices(services);
         throw new Error(`Embedded server exited during bootstrap (code=${serverService.exitCode ?? "unknown"}). ` + `See ${serverService.logPath}${tail ? `
 --- server log tail ---
@@ -3365,29 +3550,38 @@ ${tail}` : ""}`);
     if (!serverIsReady) {
       const tail = readLogTail(serverService.logPath);
       appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded server did not become healthy within ${DEFAULT_SERVER_BOOT_TIMEOUT_MS}ms.`);
+      recordStartupPhase("server", serverPhaseStartedAt, "timeout");
+      emitStartupTimingSummary("failed", "server health timeout");
       stopRuntimeServices(services);
       throw new Error(`Embedded server did not become healthy within ${DEFAULT_SERVER_BOOT_TIMEOUT_MS}ms. ` + `See ${serverService.logPath}${tail ? `
 --- server log tail ---
 ${tail}` : ""}`);
     }
+    recordStartupPhase("server", serverPhaseStartedAt, "started");
     console.log("[pushpals] Embedded server is healthy.");
   } else {
+    recordStartupPhase("server", Date.now(), "reused");
     console.log("[pushpals] Server already healthy; skipping embedded server start.");
     appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] server already healthy; embedded server start skipped.");
   }
   if (localBuddyEnabled) {
+    const localBuddyPhaseStartedAt = Date.now();
     console.log("[pushpals] Starting embedded LocalBuddy...");
     const localbuddyService = spawnRuntimeService("localbuddy", [runtimeBinaries.localbuddy], opts.repoRoot, runtimeEnv, serviceLogPaths.localbuddy, runtimeServicesLogPath);
     services.push(localbuddyService);
     console.log(`[pushpals] localbuddy log: ${localbuddyService.logPath}`);
+    recordStartupPhase("localbuddy", localBuddyPhaseStartedAt, "started");
   } else {
+    recordStartupPhase("localbuddy", Date.now(), "skipped");
     console.log("[pushpals] Embedded LocalBuddy disabled for this CLI session; skipping start.");
     appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] localbuddy disabled for this CLI session; embedded localbuddy start skipped.");
   }
+  const remoteBuddyPhaseStartedAt = Date.now();
   console.log("[pushpals] Starting embedded RemoteBuddy...");
   const remotebuddyService = spawnRuntimeService("remotebuddy", [runtimeBinaries.remotebuddy], opts.repoRoot, runtimeEnv, serviceLogPaths.remotebuddy, runtimeServicesLogPath);
   services.push(remotebuddyService);
   console.log(`[pushpals] remotebuddy log: ${remotebuddyService.logPath}`);
+  recordStartupPhase("remotebuddy", remoteBuddyPhaseStartedAt, "started");
   let lastReportedRemoteBuddyAutonomyState = "unknown";
   const reportRemoteBuddyAutonomousEngineState = () => {
     const autonomyState = readRemoteBuddyAutonomousEngineState(remotebuddyService.logPath);
@@ -3405,48 +3599,58 @@ ${tail}` : ""}`);
   };
   reportRemoteBuddyAutonomousEngineState();
   if (runtimePreflight.config.remotebuddy.autoSpawnWorkerpals) {
-    const workerpalReadyTimeoutMs = resolveWorkerpalCapacityTimeoutMs(runtimePreflight.config);
+    const workerpalPhaseStartedAt = Date.now();
+    const workerpalReadinessProbeTimeoutMs = resolveWorkerpalStartupReadinessProbeTimeoutMs(runtimePreflight.config);
     const workerpalCapacity = await waitForWorkerpalCapacity({
       serverUrl: opts.serverUrl,
-      timeoutMs: workerpalReadyTimeoutMs,
+      timeoutMs: workerpalReadinessProbeTimeoutMs,
       ttlMs: runtimePreflight.config.remotebuddy.workerpalOnlineTtlMs
     });
     if (!workerpalCapacity.ok) {
-      const tail = readLogTail(remotebuddyService.logPath);
-      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded workerpal capacity did not become available within ${workerpalReadyTimeoutMs}ms.`);
-      stopRuntimeServices(services);
-      throw new Error(`Embedded WorkerPal capacity did not become available within ${workerpalReadyTimeoutMs}ms (${workerpalCapacity.detail}). ` + `See ${remotebuddyService.logPath}${tail ? `
---- remotebuddy log tail ---
-${tail}` : ""}`);
+      const startupProbeWarning = `embedded workerpal readiness probe did not find idle capacity within ${workerpalReadinessProbeTimeoutMs}ms ` + `(${workerpalCapacity.detail}); continuing startup while WorkerPal warmup finishes in the background.`;
+      console.warn(`[pushpals] ${startupProbeWarning}`);
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] ${startupProbeWarning}`);
+      recordStartupPhase("workerpal", workerpalPhaseStartedAt, "deferred");
+    } else {
+      console.log(`[pushpals] Embedded WorkerPal capacity is ready (${workerpalCapacity.detail}).`);
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded workerpal capacity ready (${workerpalCapacity.detail}).`);
+      recordStartupPhase("workerpal", workerpalPhaseStartedAt, "ready");
     }
-    console.log(`[pushpals] Embedded WorkerPal capacity is ready (${workerpalCapacity.detail}).`);
-    appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded workerpal capacity ready (${workerpalCapacity.detail}).`);
+  } else {
+    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();
     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 = spawnRuntimeService("source_control_manager", [runtimeBinaries.sourceControlManager, "--skip-clean-check"], opts.repoRoot, runtimeEnv, serviceLogPaths.source_control_manager, runtimeServicesLogPath);
       services.push(sourceControlManagerService);
       console.log(`[pushpals] source_control_manager log: ${sourceControlManagerService.logPath}`);
+      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");
     console.log("[pushpals] SourceControlManager already healthy; skipping embedded start.");
     appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] source_control_manager already healthy; embedded start skipped.");
   }
   const deadline = Date.now() + DEFAULT_RUNTIME_BOOT_TIMEOUT_MS;
+  const readinessPhaseStartedAt = Date.now();
   while (Date.now() < deadline) {
     reportRemoteBuddyAutonomousEngineState();
     for (let i = services.length - 1;i >= 0; i--) {
@@ -3467,6 +3671,8 @@ ${tail2}`);
         }
         const tail = readLogTail(service.logPath);
         appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}).`);
+        recordStartupPhase("readiness", readinessPhaseStartedAt, "failed");
+        emitStartupTimingSummary("failed", `${service.name} exited during startup`);
         stopRuntimeServices(services);
         throw new Error(`Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}). ` + `See ${service.logPath}${tail ? `
 --- ${service.name} log tail ---
@@ -3499,6 +3705,8 @@ ${tail2}`);
           }
           const tail = readLogTail(service.logPath);
           appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}).`);
+          recordStartupPhase("readiness", readinessPhaseStartedAt, "failed");
+          emitStartupTimingSummary("failed", `${service.name} exited immediately after bootstrap`);
           stopRuntimeServices(services);
           throw new Error(`Embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}). ` + `See ${service.logPath}${tail ? `
 --- ${service.name} log tail ---
@@ -3507,6 +3715,8 @@ ${tail}` : ""}`);
         await Bun.sleep(250);
       }
       console.log("[pushpals] Embedded runtime is ready.");
+      recordStartupPhase("readiness", readinessPhaseStartedAt, "ready");
+      emitStartupTimingSummary("ready");
       appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] embedded runtime is ready.");
       return {
         services,
@@ -3519,13 +3729,19 @@ ${tail}` : ""}`);
   const remoteBuddyHealth = await probeRemoteBuddySessionConsumer(opts.serverUrl, opts.sessionId);
   if (!localBuddyEnabled && !remoteBuddyHealth.ok) {
     appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] timed out waiting for RemoteBuddy session consumer readiness after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms (${remoteBuddyHealth.detail}).`);
+    recordStartupPhase("readiness", readinessPhaseStartedAt, "timeout");
+    emitStartupTimingSummary("failed", "remotebuddy readiness timeout");
     throw new Error(`Timed out waiting for RemoteBuddy session consumer readiness after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms (${remoteBuddyHealth.detail})`);
   }
   if (!localBuddyEnabled) {
     appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] timed out waiting for embedded runtime readiness after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms.`);
+    recordStartupPhase("readiness", readinessPhaseStartedAt, "timeout");
+    emitStartupTimingSummary("failed", "embedded runtime readiness timeout");
     throw new Error(`Timed out waiting for embedded runtime readiness after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms`);
   }
   appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] timed out waiting for LocalBuddy at ${opts.localAgentUrl} and RemoteBuddy session consumer after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms.`);
+  recordStartupPhase("readiness", readinessPhaseStartedAt, "timeout");
+  emitStartupTimingSummary("failed", "localbuddy and remotebuddy readiness timeout");
   throw new Error(`Timed out waiting for LocalBuddy at ${opts.localAgentUrl} and RemoteBuddy session consumer after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms`);
 }
 function readCliState(pathValue) {
@@ -4127,32 +4343,59 @@ async function main() {
   } else {
     console.warn("[pushpals] RemoteBuddy autonomy is disabled in config (remotebuddy.autonomy.enabled=false); continuing.");
   }
-  const scmGitPrecheck = await precheckSourceControlManagerGitAvailability({
-    repoRoot,
-    remote: config.sourceControlManager.remote,
-    runtimeRoot: preparedRuntime.runtimeRoot,
-    preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime
-  });
-  if (scmGitPrecheck.status === "failed") {
-    console.error(`[pushpals] Precheck failed: embedded SourceControlManager git command is unavailable (${scmGitPrecheck.detail}).`);
-    process.exit(1);
-  }
-  const workerpalDockerPrecheck = await precheckWorkerpalDockerAvailability({
-    repoRoot,
-    runtimeRoot: preparedRuntime.runtimeRoot,
-    preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime,
-    autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
-    dockerEnabled: Boolean(config.remotebuddy.workerpalDocker),
-    requireDocker: Boolean(config.remotebuddy.workerpalRequireDocker),
-    baseEnv: scmGitPrecheck.env
-  });
-  const precheckPassed = await enforcePushpalsRemoteBranchPrecheck(repoRoot, config.sourceControlManager.remote, config.sourceControlManager.mainBranch);
-  if (!precheckPassed) {
-    process.exit(1);
-  }
   const serverUrl = normalizeLoopbackUrl(parsed.serverUrl ?? process.env.PUSHPALS_SERVER_URL, config.server.url);
   const localAgentUrl = normalizeLoopbackUrl(parsed.localAgentUrl ?? process.env.EXPO_PUBLIC_LOCAL_AGENT_URL, config.client.localAgentUrl);
   const sessionId = String(parsed.sessionId ?? process.env.PUSHPALS_SESSION_ID ?? config.sessionId).trim();
+  let serverHealthy = await probeServer(serverUrl);
+  const serverWasAlreadyHealthy = serverHealthy;
+  const runEmbeddedRuntimeStartupPrechecks = shouldRunEmbeddedRuntimeStartupPrechecks({
+    serverHealthy,
+    noAutoStart: parsed.noAutoStart
+  });
+  if (runEmbeddedRuntimeStartupPrechecks) {
+    const precheckPassed = await enforcePushpalsRemoteBranchPrecheck(repoRoot, config.sourceControlManager.remote, config.sourceControlManager.mainBranch);
+    if (!precheckPassed) {
+      process.exit(1);
+    }
+  }
+  let scmGitPrecheck = {
+    status: "skipped",
+    detail: runEmbeddedRuntimeStartupPrechecks ? "embedded SourceControlManager startup precheck not run" : serverHealthy ? "embedded SourceControlManager startup precheck skipped because runtime is already healthy" : "embedded SourceControlManager startup precheck skipped because auto-start is disabled",
+    env: buildEmbeddedRuntimeEnv(process.env, {
+      repoRoot,
+      runtimeRoot: preparedRuntime.runtimeRoot,
+      useRuntimeConfig: preparedRuntime.preflightUsesEmbeddedRuntime,
+      sessionId
+    })
+  };
+  let workerpalDockerPrecheck = {
+    status: "skipped",
+    detail: runEmbeddedRuntimeStartupPrechecks ? "embedded WorkerPal Docker startup precheck not run" : serverHealthy ? "embedded WorkerPal Docker startup precheck skipped because runtime is already healthy" : "embedded WorkerPal Docker startup precheck skipped because auto-start is disabled",
+    env: scmGitPrecheck.env
+  };
+  if (runEmbeddedRuntimeStartupPrechecks) {
+    scmGitPrecheck = await precheckSourceControlManagerGitAvailability({
+      repoRoot,
+      remote: config.sourceControlManager.remote,
+      runtimeRoot: preparedRuntime.runtimeRoot,
+      preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime,
+      sessionId
+    });
+    if (scmGitPrecheck.status === "failed") {
+      console.error(`[pushpals] Precheck failed: embedded SourceControlManager git command is unavailable (${scmGitPrecheck.detail}).`);
+      process.exit(1);
+    }
+    workerpalDockerPrecheck = await precheckWorkerpalDockerAvailability({
+      repoRoot,
+      runtimeRoot: preparedRuntime.runtimeRoot,
+      preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime,
+      autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
+      dockerEnabled: Boolean(config.remotebuddy.workerpalDocker),
+      requireDocker: Boolean(config.remotebuddy.workerpalRequireDocker),
+      sessionId,
+      baseEnv: scmGitPrecheck.env
+    });
+  }
   const cliVersion = String(process.env.PUSHPALS_CLI_PACKAGE_VERSION ?? "").trim() || "unknown";
   const cliClient = {
     clientId: createRuntimeClientId("cli"),
@@ -4196,6 +4439,31 @@ async function main() {
       console.log(`[pushpals] ${cleanup.detail} (${phase}).`);
     }
   };
+  const reportWorkerExecutionReadiness = async () => {
+    const readiness = await resolveWorkerExecutionReadiness({
+      serverUrl,
+      ttlMs: config.remotebuddy.workerpalOnlineTtlMs,
+      autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
+      dockerEnabled: Boolean(config.remotebuddy.workerpalDocker),
+      requireDocker: Boolean(config.remotebuddy.workerpalRequireDocker),
+      repoRoot,
+      runtimeRoot: preparedRuntime.runtimeRoot,
+      preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime,
+      sessionId,
+      dockerPrecheck: workerpalDockerPrecheck,
+      baseEnv: workerpalDockerPrecheck.env
+    });
+    for (const line of formatWorkerExecutionReadinessLines(readiness)) {
+      console.log(line);
+    }
+    return readiness;
+  };
+  const reportWorkerExecutionReadinessFromSnapshot = (readiness) => {
+    for (const line of formatWorkerExecutionReadinessLines(readiness)) {
+      console.log(line);
+    }
+    return readiness;
+  };
   const stopAutoStartedServices = () => {
     if (autoStartedServices.length === 0)
       return;
@@ -4220,14 +4488,12 @@ async function main() {
     await cleanupWorkerpalWarmContainersIfNeeded("cli shutdown");
     await cleanupPushPalsGitWorktreesIfNeeded("cli shutdown");
   };
-  let serverHealthy = await probeServer(serverUrl);
-  const serverWasAlreadyHealthy = serverHealthy;
   if (!serverHealthy && workerpalDockerPrecheck.status === "failed") {
     console.error(`[pushpals] Precheck failed: Docker-backed WorkerPal auto-spawn is required but Docker is unavailable (${workerpalDockerPrecheck.detail}).`);
     console.error("[pushpals] Precheck failed: start Docker Desktop or the Docker daemon, then retry pushpals.");
     process.exit(1);
   }
-  if (workerpalDockerPrecheck.status !== "failed") {
+  if (runEmbeddedRuntimeStartupPrechecks && workerpalDockerPrecheck.status !== "failed") {
     const workerpalImagePrecheck = await prepareEmbeddedWorkerpalDockerImageIfNeeded({
       preparedRuntime,
       config,
@@ -4247,8 +4513,10 @@ async function main() {
     detail: `No connected RemoteBuddy session consumer found for session ${sessionId}`
   };
   if (!serverHealthy) {
-    await cleanupWorkerpalWarmContainersIfNeeded("startup preflight");
-    await cleanupPushPalsGitWorktreesIfNeeded("startup preflight");
+    if (runEmbeddedRuntimeStartupPrechecks) {
+      await cleanupWorkerpalWarmContainersIfNeeded("startup preflight");
+      await cleanupPushPalsGitWorktreesIfNeeded("startup preflight");
+    }
     if (!parsed.noAutoStart) {
       try {
         const startedRuntime = await autoStartRuntimeServices({
@@ -4269,6 +4537,10 @@ async function main() {
       } catch (err) {
         console.error(`[pushpals] Auto-start failed: ${String(err)}`);
         stopAutoStartedServices();
+        if (runEmbeddedRuntimeStartupPrechecks) {
+          await cleanupWorkerpalWarmContainersIfNeeded("startup failure cleanup");
+          await cleanupPushPalsGitWorktreesIfNeeded("startup failure cleanup");
+        }
       }
     }
     if (!serverHealthy) {
@@ -4318,20 +4590,33 @@ async function main() {
   }
   const workerpalCapacity = await waitForWorkerpalCapacity({
     serverUrl,
-    timeoutMs: resolveWorkerpalCapacityTimeoutMs(config),
+    timeoutMs: resolveWorkerpalStartupReadinessProbeTimeoutMs(config),
     ttlMs: config.remotebuddy.workerpalOnlineTtlMs
   });
   if (!workerpalCapacity.ok) {
-    stopAutoStartedServices();
-    console.error(`[pushpals] WorkerPal capacity is not ready for repo ${repoRoot}: ${workerpalCapacity.detail}.`);
+    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") {
-      console.error(`[pushpals] Docker precheck detail: ${workerpalDockerPrecheck.detail}`);
+      console.warn(`[pushpals] Docker precheck detail: ${workerpalDockerPrecheck.detail}`);
     } else if (serverWasAlreadyHealthy) {
-      console.error("[pushpals] A PushPals runtime is already serving this repo, but it does not currently have an idle WorkerPal available.");
-      console.error("[pushpals] Wait for a worker to become idle or restart the runtime after fixing WorkerPal startup.");
+      console.warn("[pushpals] A PushPals runtime is already serving this repo, but it does not currently have an idle WorkerPal available.");
+      console.warn("[pushpals] Wait for a worker to become idle or restart the runtime after fixing WorkerPal startup.");
     }
-    process.exit(1);
   }
+  const startupWorkerExecutionReadiness = workerpalCapacity.ok ? {
+    state: "ready",
+    detail: workerpalCapacity.detail
+  } : workerpalDockerPrecheck.status === "failed" ? describeWorkerExecutionReadiness({
+    autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
+    requireDocker: Boolean(config.remotebuddy.workerpalDocker) && Boolean(config.remotebuddy.workerpalRequireDocker),
+    dockerPrecheck: workerpalDockerPrecheck,
+    onlineWorkers: 0,
+    idleWorkers: 0
+  }) : {
+    state: "warming",
+    detail: workerpalCapacity.detail,
+    action: "Wait for WorkerPal auto-spawn/warmup to finish, then rerun /status."
+  };
   const saved = statePath ? readCliState(statePath) : {};
   pushpalsLogPath = pushpalsLogPath || (typeof saved.pushpalsLogPath === "string" ? saved.pushpalsLogPath : undefined);
   const preferredHubUrl = normalizeUrl(parsed.monitoringHubUrl ?? process.env.PUSHPALS_MONITOR_URL ?? saved.monitoringHubUrl ?? "");
@@ -4369,6 +4654,7 @@ async function main() {
   console.log(`[pushpals] repoRoot=${repoRoot}`);
   console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
   console.log(`[pushpals] cliStateFile=${statePath ?? "unavailable"}`);
+  reportWorkerExecutionReadinessFromSnapshot(startupWorkerExecutionReadiness);
   if (parsed.runtimeOnly) {
     console.log("[pushpals] runtimeOnly=true");
   } else {
@@ -4480,6 +4766,7 @@ ${line}
       console.log(`[pushpals] repoRoot=${repoRoot}`);
       console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
       console.log(monitoringHubUrl ? `[pushpals] monitoringHubUrl=${monitoringHubUrl}` : "[pushpals] monitoringHubUrl=unavailable");
+      await reportWorkerExecutionReadiness();
       rl.prompt();
       continue;
     }
@@ -4518,11 +4805,14 @@ if (import.meta.main) {
 export {
   waitForWorkerpalCapacity,
   startEmbeddedMonitoringHub,
+  shouldRunEmbeddedRuntimeStartupPrechecks,
+  resolveWorkerExecutionReadiness,
   resolveWindowsWhereExecutableCandidatesForEnv,
   resolveWindowsShellExecutableCandidatesForEnv,
   resolveRuntimeGitExecutableCandidates,
   resolveRuntimeDockerExecutableCandidates,
   resolvePreferredRuntimeReleaseTag,
+  resolveEmbeddedBunExecutableFromEnv,
   resolveCommandPath,
   resolveCliStatePath,
   resolveCliLocalBuddyAutostart,
@@ -4538,13 +4828,16 @@ export {
   normalizeChildProcessEnv,
   isCliExitCommand,
   injectMonitoringHubBootstrap,
+  formatWorkerExecutionReadinessLines,
   formatTimestampedCliLine,
   formatSessionEventLine,
+  formatRuntimeStartupTimingSummary,
   extractRemoteBuddySessionConsumerHealth,
   extractRemoteBuddyAutonomousEngineState,
   ensureWorkerpalDockerImageReady,
   ensureRuntimeBinaries,
   downloadRuntimeAssetsFromSourceTag,
+  describeWorkerExecutionReadiness,
   createSessionEventReplayFilter,
   copyTrackedRepoPath,
   cleanupLingeringWorkerpalWarmContainers,

package/package.json

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

package/runtime/sandbox/package.json

@@ -44,6 +44,7 @@
     "format:check": "prettier --check .",
     "test:prompt-policy": "bun test tests/prompt-policy.enforcement.test.ts",
     "test:cli:integration": "bun test tests/cli.invocation-logging.test.ts tests/cli.runtime-bootstrap.test.ts tests/client.runtime-bootstrap.test.ts tests/shared.client-preflight.test.ts",
+    "test:cli:e2e": "bun test ./tests/integration/cli.e2e.ts",
     "test:root": "bun test tests",
     "test:protocol": "bun run tests/protocol.integration.ts",
     "test:integration": "python -u tests/integration/integration_controller.py --mode integration",