@pushpalsdev/cli 1.0.35 → 1.0.37

package/dist/pushpals-cli.js

@@ -6,23 +6,323 @@ import {
   appendFileSync,
   chmodSync,
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   lstatSync,
   mkdirSync,
   readdirSync,
   readFileSync as readFileSync4,
-  rmSync,
+  rmSync as rmSync2,
   writeFileSync
 } from "fs";
 import { basename, delimiter, dirname, extname, join as join2, resolve as resolve4, win32 as pathWin32 } from "path";
 import { createInterface } from "readline";
 
+// ../shared/src/localbuddy_runtime.ts
+var TRUTHY = new Set(["1", "true", "yes", "on"]);
+var FALSY = new Set(["0", "false", "no", "off"]);
+
+// ../../scripts/start_runtime_services.ts
+var DEFAULT_SERVICE_MANAGER_POLL_MS = 1000;
+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;
+function formatEmbeddedRuntimeHealthLines(health) {
+  if (!health)
+    return [];
+  const lines = [`[pushpals] embeddedRuntime=${health.state} detail=${health.detail}`];
+  if (health.action) {
+    lines.push(`[pushpals] embeddedRuntimeAction=${health.action}`);
+  }
+  return lines;
+}
+function computeServiceRestartBackoffMs(attempt) {
+  const boundedAttempt = Math.max(1, Math.floor(attempt));
+  const exponential = DEFAULT_SERVICE_MANAGER_BASE_BACKOFF_MS * Math.pow(2, boundedAttempt - 1);
+  return Math.max(DEFAULT_SERVICE_MANAGER_BASE_BACKOFF_MS, Math.min(DEFAULT_SERVICE_MANAGER_MAX_BACKOFF_MS, Math.floor(exponential)));
+}
+function shouldRestartService(attempts, maxAttempts = DEFAULT_SERVICE_MANAGER_MAX_RESTART_ATTEMPTS) {
+  const normalizedAttempts = Math.max(0, Math.floor(attempts));
+  const normalizedMax = Math.max(1, Math.floor(maxAttempts));
+  return normalizedAttempts < normalizedMax;
+}
+function pipeProcessStreamToLines(stream, onLine) {
+  if (!stream || typeof stream === "number" || typeof stream.getReader !== "function")
+    return;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let pending = "";
+  (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        pending += decoder.decode(value, { stream: true });
+        const lines = pending.split(/\r?\n/);
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trimEnd();
+          if (!trimmed)
+            continue;
+          onLine?.(trimmed);
+        }
+      }
+      const rest = decoder.decode();
+      if (rest)
+        pending += rest;
+      const tail = pending.trimEnd();
+      if (tail)
+        onLine?.(tail);
+    } catch {} finally {
+      reader.releaseLock();
+    }
+  })();
+}
+function spawnManagedService(spec) {
+  const env = { ...spec.env ?? {} };
+  const proc = Bun.spawn(spec.command, {
+    cwd: spec.cwd,
+    env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  pipeProcessStreamToLines(proc.stdout, spec.onStdoutLine);
+  pipeProcessStreamToLines(proc.stderr, spec.onStderrLine);
+  const service = {
+    name: spec.name,
+    proc,
+    command: [...spec.command],
+    cwd: spec.cwd,
+    env,
+    exited: false,
+    exitCode: null,
+    launchedAtMs: Date.now(),
+    logPath: spec.logPath
+  };
+  proc.exited.then((code) => {
+    service.exited = true;
+    service.exitCode = code;
+  });
+  return service;
+}
+
+class ServiceManager {
+  services = new Map;
+  launchSpecs = new Map;
+  stateByService = new Map;
+  degradedServiceReasons = new Map;
+  pollMs;
+  maxRestartAttempts;
+  stableWindowMs;
+  computeRestartBackoffMs;
+  degradedAction;
+  spawnService;
+  onHealthChange;
+  onServiceDegraded;
+  onEvent;
+  timer;
+  stopped = false;
+  constructor(options = {}) {
+    this.pollMs = Math.max(50, Math.floor(options.pollMs ?? DEFAULT_SERVICE_MANAGER_POLL_MS));
+    this.maxRestartAttempts = Math.max(1, Math.floor(options.maxRestartAttempts ?? DEFAULT_SERVICE_MANAGER_MAX_RESTART_ATTEMPTS));
+    this.stableWindowMs = Math.max(1000, Math.floor(options.stableWindowMs ?? DEFAULT_SERVICE_MANAGER_STABLE_WINDOW_MS));
+    this.computeRestartBackoffMs = options.computeRestartBackoffMs ?? computeServiceRestartBackoffMs;
+    this.degradedAction = options.degradedAction ?? "Inspect the affected service logs or restart the runtime after fixing the failure.";
+    this.spawnService = options.spawnService ?? spawnManagedService;
+    this.onHealthChange = options.onHealthChange;
+    this.onServiceDegraded = options.onServiceDegraded;
+    this.onEvent = options.onEvent;
+    this.timer = setInterval(() => this.tick(), this.pollMs);
+  }
+  startService(spec) {
+    this.launchSpecs.set(spec.name, {
+      ...spec,
+      command: [...spec.command],
+      env: { ...spec.env ?? {} }
+    });
+    const service = this.spawnService(spec);
+    this.services.set(spec.name, service);
+    return service;
+  }
+  getServices() {
+    return Array.from(this.services.values());
+  }
+  getService(name) {
+    return this.services.get(name) ?? null;
+  }
+  getHealth() {
+    if (this.degradedServiceReasons.size === 0)
+      return null;
+    const detail = Array.from(this.degradedServiceReasons.entries()).map(([name, reason]) => `${name}: ${reason}`).join(" | ");
+    return {
+      state: "degraded",
+      detail,
+      action: this.degradedAction
+    };
+  }
+  stop() {
+    if (this.stopped)
+      return;
+    this.stopped = true;
+    clearInterval(this.timer);
+    for (const state of this.stateByService.values()) {
+      if (!state.pendingRestartTimer)
+        continue;
+      clearTimeout(state.pendingRestartTimer);
+      state.pendingRestartTimer = null;
+    }
+    for (const service of this.services.values()) {
+      try {
+        const pid = service.proc.pid;
+        if (process.platform === "win32" && typeof pid === "number" && pid > 0) {
+          Bun.spawnSync(["taskkill", "/PID", String(pid), "/T", "/F"], {
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "ignore"
+          });
+        } else {
+          service.proc.kill();
+        }
+      } catch {}
+    }
+  }
+  ensureState(name) {
+    const existing = this.stateByService.get(name);
+    if (existing)
+      return existing;
+    const created = {
+      attempts: 0,
+      nextRestartAtMs: 0,
+      lastRestartReason: "",
+      pendingRestartTimer: null
+    };
+    this.stateByService.set(name, created);
+    return created;
+  }
+  emitHealthChange() {
+    this.onHealthChange?.(this.getHealth());
+  }
+  emitEvent(level, line) {
+    this.onEvent?.(level, line);
+  }
+  tick() {
+    if (this.stopped)
+      return;
+    const now = Date.now();
+    for (const [name, service] of this.services.entries()) {
+      const launchSpec = this.launchSpecs.get(name);
+      if (!launchSpec)
+        continue;
+      const state = this.ensureState(name);
+      if (!service.exited) {
+        if (state.attempts > 0 && now - service.launchedAtMs >= this.stableWindowMs) {
+          state.attempts = 0;
+          state.nextRestartAtMs = 0;
+          state.lastRestartReason = "";
+        }
+        continue;
+      }
+      if (state.pendingRestartTimer)
+        continue;
+      if (state.nextRestartAtMs > now)
+        continue;
+      const reason = `exit code ${service.exitCode ?? "unknown"}`;
+      if (!shouldRestartService(state.attempts, this.maxRestartAttempts)) {
+        this.emitEvent("error", `Managed ${name} exited (${reason}) and reached restart limit (${state.attempts}/${this.maxRestartAttempts}).`);
+        this.launchSpecs.delete(name);
+        if (!this.degradedServiceReasons.has(name)) {
+          const degradationReason = `reached restart limit after ${reason} (${state.attempts}/${this.maxRestartAttempts})`;
+          this.degradedServiceReasons.set(name, degradationReason);
+          const health = this.getHealth();
+          if (health) {
+            this.onHealthChange?.(health);
+            this.onServiceDegraded?.(name, degradationReason, health);
+          }
+        }
+        continue;
+      }
+      const nextAttempt = state.attempts + 1;
+      state.lastRestartReason = reason;
+      const backoffMs = Math.max(1, Math.floor(this.computeRestartBackoffMs(nextAttempt)));
+      this.emitEvent("warn", `Managed ${name} exited (${reason}); restarting attempt ${nextAttempt}/${this.maxRestartAttempts} in ${backoffMs}ms.`);
+      state.nextRestartAtMs = now + backoffMs;
+      state.pendingRestartTimer = setTimeout(() => {
+        state.pendingRestartTimer = null;
+        state.nextRestartAtMs = 0;
+        if (this.stopped)
+          return;
+        const current = this.services.get(name);
+        if (!current || !current.exited)
+          return;
+        const spec = this.launchSpecs.get(name);
+        if (!spec)
+          return;
+        if (!shouldRestartService(state.attempts, this.maxRestartAttempts))
+          return;
+        state.attempts += 1;
+        const restarted = this.spawnService(spec);
+        this.services.set(name, restarted);
+        this.emitEvent("log", `Restarted managed ${name}.`);
+      }, backoffMs);
+    }
+  }
+}
+
+// ../../apps/workerpals/src/common/worktree_cleanup.ts
+import { existsSync, rmSync } from "fs";
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function windowsDeletionCandidates(worktreePath) {
+  const seen = new Set;
+  const out = [];
+  const add = (value) => {
+    if (!value || seen.has(value))
+      return;
+    seen.add(value);
+    out.push(value);
+  };
+  add(worktreePath);
+  if (process.platform === "win32" && /^[A-Za-z]:[\\/]/.test(worktreePath)) {
+    add(`\\\\?\\${worktreePath}`);
+  }
+  return out;
+}
+async function forceDeleteWorktreePath(worktreePath, options = {}) {
+  const retries = Math.max(1, Math.floor(options.retries ?? 5));
+  const delayMs = Math.max(0, Math.floor(options.delayMs ?? 120));
+  const sleep = options.sleepFn ?? defaultSleep;
+  const removePath = options.removeFn ?? ((targetPath) => rmSync(targetPath, { recursive: true, force: true }));
+  const pathExists = options.existsFn ?? ((targetPath) => existsSync(targetPath));
+  let lastError = "";
+  for (let attempt = 1;attempt <= retries; attempt++) {
+    if (!pathExists(worktreePath))
+      return { removed: true };
+    for (const candidate of windowsDeletionCandidates(worktreePath)) {
+      try {
+        removePath(candidate);
+      } catch (error) {
+        lastError = String(error);
+      }
+    }
+    if (!pathExists(worktreePath))
+      return { removed: true };
+    if (attempt < retries)
+      await sleep(delayMs * attempt);
+  }
+  return {
+    removed: !pathExists(worktreePath),
+    ...lastError ? { lastError } : {}
+  };
+}
+
 // ../shared/src/client_preflight.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { relative, resolve as resolve2 } from "path";
 
 // ../shared/src/config.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { join, resolve, isAbsolute } from "path";
 
 // ../shared/src/autonomy_policy.ts
@@ -101,8 +401,8 @@ function normalizeLoopbackHttpUrl(value, fallbackPort) {
 // ../shared/src/config.ts
 var PROJECT_ROOT = resolve(import.meta.dir, "..", "..", "..");
 var DEFAULT_CONFIG_DIR = "configs";
-var TRUTHY = new Set(["1", "true", "yes", "on"]);
-var FALSY = new Set(["0", "false", "no", "off"]);
+var TRUTHY2 = new Set(["1", "true", "yes", "on"]);
+var FALSY2 = new Set(["0", "false", "no", "off"]);
 var DEFAULT_WORKERPALS_QUALITY_CRITIC_MIN_SCORE = 8;
 var DEFAULT_WORKERPALS_QUALITY_MAX_AUTO_REVISIONS = 1;
 var DEFAULT_WORKERPALS_FILE_MODIFYING_JOBS = ["task.execute"];
@@ -133,9 +433,9 @@ function parseBoolEnv(name) {
   const raw = (process.env[name] ?? "").trim().toLowerCase();
   if (!raw)
     return null;
-  if (TRUTHY.has(raw))
+  if (TRUTHY2.has(raw))
     return true;
-  if (FALSY.has(raw))
+  if (FALSY2.has(raw))
     return false;
   return null;
 }
@@ -147,7 +447,7 @@ function parseIntEnv(name) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 function parseTomlFile(path) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return {};
   const raw = readFileSync(path, "utf-8");
   const parsed = Bun.TOML.parse(raw);
@@ -156,7 +456,7 @@ function parseTomlFile(path) {
   return parsed;
 }
 function parseRequiredTomlFile(path) {
-  if (!existsSync(path)) {
+  if (!existsSync2(path)) {
     throw new Error(`Missing required runtime config file: ${path}`);
   }
   return parseTomlFile(path);
@@ -192,9 +492,9 @@ function asBoolean(value, fallback) {
     return value;
   if (typeof value === "string") {
     const lowered = value.trim().toLowerCase();
-    if (TRUTHY.has(lowered))
+    if (TRUTHY2.has(lowered))
       return true;
-    if (FALSY.has(lowered))
+    if (FALSY2.has(lowered))
       return false;
   }
   return fallback;
@@ -949,7 +1249,7 @@ function validateVisionDocStructure(markdown) {
 // ../shared/src/client_preflight.ts
 function runtimeHasConfigDir(runtimeRoot, dirName) {
   const dirPath = resolve2(runtimeRoot, dirName);
-  return existsSync2(resolve2(dirPath, "default.toml")) || existsSync2(resolve2(dirPath, "local.example.toml")) || existsSync2(resolve2(dirPath, "local.toml"));
+  return existsSync3(resolve2(dirPath, "default.toml")) || existsSync3(resolve2(dirPath, "local.example.toml")) || existsSync3(resolve2(dirPath, "local.toml"));
 }
 function resolveClientConfigDir(projectRoot, runtimeRoot, explicitConfigDir) {
   if (explicitConfigDir && explicitConfigDir.trim()) {
@@ -1003,21 +1303,21 @@ function evaluateClientRuntimePreflight(options) {
   });
   const issues = [];
   const envPath = resolve2(runtimeRoot, ".env");
-  if (!existsSync2(envPath)) {
+  if (!existsSync3(envPath)) {
     const envExamplePath = resolve2(runtimeRoot, ".env.example");
     issues.push({
       code: "missing_env_file",
       message: `Missing required local env file: ${toDisplayPath(projectRoot, envPath)}.`,
-      copyCommands: existsSync2(envExamplePath) ? buildCopyCommands(projectRoot, envExamplePath, envPath) : undefined
+      copyCommands: existsSync3(envExamplePath) ? buildCopyCommands(projectRoot, envExamplePath, envPath) : undefined
     });
   }
   const localTomlPath = resolve2(runtimeRoot, "configs", "local.toml");
-  if (!existsSync2(localTomlPath)) {
+  if (!existsSync3(localTomlPath)) {
     const localExamplePath = resolve2(runtimeRoot, "configs", "local.example.toml");
     issues.push({
       code: "missing_local_toml",
       message: `Missing required local config file: ${toDisplayPath(projectRoot, localTomlPath)}.`,
-      copyCommands: existsSync2(localExamplePath) ? buildCopyCommands(projectRoot, localExamplePath, localTomlPath) : undefined
+      copyCommands: existsSync3(localExamplePath) ? buildCopyCommands(projectRoot, localExamplePath, localTomlPath) : undefined
     });
   }
   const autonomyEnabled = Boolean(config.remotebuddy.autonomy.enabled);
@@ -1034,11 +1334,11 @@ function evaluateClientRuntimePreflight(options) {
   }
   const visionPath = resolve2(projectRoot, "vision.md");
   const visionTemplatePath = resolve2(visionTemplateRoot, "vision.example.md");
-  if (!existsSync2(visionPath)) {
+  if (!existsSync3(visionPath)) {
     issues.push({
       code: "missing_vision_doc",
       message: "Missing required autonomy vision file: vision.md " + "(required when remotebuddy.autonomy.enabled=true).",
-      copyCommands: existsSync2(visionTemplatePath) ? buildCopyCommands(projectRoot, visionTemplatePath, visionPath) : undefined
+      copyCommands: existsSync3(visionTemplatePath) ? buildCopyCommands(projectRoot, visionTemplatePath, visionPath) : undefined
     });
     return {
       ok: false,
@@ -1152,14 +1452,14 @@ function normalizePresenceLookupToken(value) {
 }
 
 // ../shared/src/repo.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, statSync } from "fs";
 import { resolve as resolve3 } from "path";
 function resolveDotGitEntry(repoRoot) {
   return resolve3(repoRoot, ".git");
 }
 function resolveGitMetadataDir(repoRoot) {
   const dotGitPath = resolveDotGitEntry(repoRoot);
-  if (!existsSync3(dotGitPath))
+  if (!existsSync4(dotGitPath))
     return null;
   try {
     const stat = statSync(dotGitPath);
@@ -1178,7 +1478,7 @@ function resolveGitMetadataDir(repoRoot) {
     if (!match)
       return null;
     const gitDir = resolve3(repoRoot, match[1].trim());
-    return existsSync3(gitDir) ? gitDir : null;
+    return existsSync4(gitDir) ? gitDir : null;
   } catch {
     return null;
   }
@@ -1217,6 +1517,7 @@ 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 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";
 var EMBEDDED_RUNTIME_WINDOWS_SAFETY_CAPS = {
@@ -1292,6 +1593,9 @@ function formatWorkerExecutionReadinessLines(readiness) {
   }
   return lines;
 }
+function formatEmbeddedRuntimeHealthLines2(health) {
+  return formatEmbeddedRuntimeHealthLines(health);
+}
 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);
@@ -1600,7 +1904,7 @@ function copyTrackedRepoPath(repoRoot, sourcePath, destinationPath, force = true
     throw new Error("sourcePath is required");
   }
   const absoluteSource = resolve4(repoRoot, normalizedSource);
-  if (!existsSync4(absoluteSource)) {
+  if (!existsSync5(absoluteSource)) {
     throw new Error(`tracked repo source is missing: ${absoluteSource}`);
   }
   const trackedFiles = listTrackedRepoFilesForPath(repoRoot, normalizedSource);
@@ -1633,7 +1937,7 @@ function copyTrackedRepoPath(repoRoot, sourcePath, destinationPath, force = true
   }
 }
 function isCompleteWorkerpalSandboxRoot(root) {
-  return existsSync4(join2(root, "package.json")) && existsSync4(join2(root, "apps", "workerpals", "Dockerfile.sandbox")) && existsSync4(join2(root, "packages", "shared", "package.json")) && existsSync4(join2(root, "packages", "protocol", "package.json")) && existsSync4(join2(root, "configs", "default.toml")) && existsSync4(join2(root, "prompts", "workerpals")) && existsSync4(join2(root, "protocol", "schemas", "envelope.schema.json")) && existsSync4(join2(root, "protocol", "schemas", "events.schema.json"));
+  return existsSync5(join2(root, "package.json")) && existsSync5(join2(root, "apps", "workerpals", "Dockerfile.sandbox")) && existsSync5(join2(root, "packages", "shared", "package.json")) && existsSync5(join2(root, "packages", "protocol", "package.json")) && existsSync5(join2(root, "configs", "default.toml")) && existsSync5(join2(root, "prompts", "workerpals")) && existsSync5(join2(root, "protocol", "schemas", "envelope.schema.json")) && existsSync5(join2(root, "protocol", "schemas", "events.schema.json"));
 }
 function populateWorkerpalSandboxRuntimeAssets(runtimeRoot, force) {
   const sandbox = buildWorkerpalSandboxPaths(runtimeRoot);
@@ -1664,7 +1968,7 @@ function copySourceCheckoutWorkerpalSandboxBuildContext(sourceRoot, runtimeRoot,
   for (const [fromPath, toPath] of copyPairs) {
     copyTrackedRepoPath(sourceRoot, fromPath, toPath, force);
   }
-  if (existsSync4(join2(sourceRoot, "bun.lock"))) {
+  if (existsSync5(join2(sourceRoot, "bun.lock"))) {
     copyTrackedRepoPath(sourceRoot, "bun.lock", join2(sandbox.root, "bun.lock"), force);
   }
   populateWorkerpalSandboxRuntimeAssets(runtimeRoot, force);
@@ -1682,7 +1986,7 @@ function copyWorkerpalSandboxBuildContext(source, runtimeRoot, force) {
   copySourceCheckoutWorkerpalSandboxBuildContext(source.root, runtimeRoot, force);
 }
 function isCompleteRuntimeAssetSource(source) {
-  return existsSync4(source.envExamplePath) && existsSync4(source.visionExamplePath) && existsSync4(join2(source.configsDir, "default.toml")) && existsSync4(source.promptsDir) && existsSync4(join2(source.protocolSchemasDir, "envelope.schema.json")) && existsSync4(join2(source.protocolSchemasDir, "events.schema.json"));
+  return existsSync5(source.envExamplePath) && existsSync5(source.visionExamplePath) && existsSync5(join2(source.configsDir, "default.toml")) && existsSync5(source.promptsDir) && existsSync5(join2(source.protocolSchemasDir, "envelope.schema.json")) && existsSync5(join2(source.protocolSchemasDir, "events.schema.json"));
 }
 function resolveBundledRuntimeAssetSource() {
   const candidates = [
@@ -1697,10 +2001,10 @@ function resolveBundledRuntimeAssetSource() {
   return null;
 }
 function looksLikeMonitoringHubBuild(root) {
-  return existsSync4(join2(root, "index.html")) && existsSync4(join2(root, "_expo"));
+  return existsSync5(join2(root, "index.html")) && existsSync5(join2(root, "_expo"));
 }
 function latestPathMtimeMs(pathValue) {
-  if (!existsSync4(pathValue))
+  if (!existsSync5(pathValue))
     return 0;
   const stat = lstatSync(pathValue);
   let latest = stat.mtimeMs;
@@ -1753,7 +2057,7 @@ function resolveCliSourceCheckoutRoot() {
     resolve4(import.meta.dir, "..", "..", "..")
   ];
   for (const candidate of candidates) {
-    if (existsSync4(join2(candidate, "package.json")) && existsSync4(join2(candidate, "apps", "client", "app.json")) && existsSync4(join2(candidate, "scripts", "sync-cli-monitor-ui.ts"))) {
+    if (existsSync5(join2(candidate, "package.json")) && existsSync5(join2(candidate, "apps", "client", "app.json")) && existsSync5(join2(candidate, "scripts", "sync-cli-monitor-ui.ts"))) {
       return candidate;
     }
   }
@@ -1787,7 +2091,7 @@ async function ensureBundledMonitoringHubRoot() {
   return resolveBundledMonitoringHubRoot();
 }
 function repoLooksLikePushPalsSourceCheckout(repoRoot) {
-  return existsSync4(join2(repoRoot, "configs", "default.toml"));
+  return existsSync5(join2(repoRoot, "configs", "default.toml"));
 }
 function parseSemverFromPackageVersion(value) {
   const raw = String(value ?? "").trim();
@@ -1837,13 +2141,13 @@ async function resolveRuntimeReleaseTag(explicitTag) {
   return await fetchLatestReleaseTag();
 }
 function writeTextFileIfMissing(pathValue, text) {
-  if (existsSync4(pathValue))
+  if (existsSync5(pathValue))
     return;
   mkdirSync(dirname(pathValue), { recursive: true });
   writeFileSync(pathValue, text, "utf8");
 }
 function migrateEmbeddedRuntimeLocalToml(localTomlPath) {
-  if (!existsSync4(localTomlPath))
+  if (!existsSync5(localTomlPath))
     return;
   let original;
   try {
@@ -1893,8 +2197,8 @@ function copyBundledRuntimeAssets(runtimeRoot, force = 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"));
+  const hasProtocolSchemas = existsSync5(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync5(join2(protocolSchemasDir, "events.schema.json"));
+  return existsSync5(join2(runtimeRoot, ".env.example")) && existsSync5(join2(runtimeRoot, "vision.example.md")) && existsSync5(join2(runtimeRoot, "configs", "default.toml")) && existsSync5(join2(runtimeRoot, "prompts")) && hasProtocolSchemas && isCompleteWorkerpalSandboxRoot(join2(runtimeRoot, "sandbox"));
 }
 function seedRuntimePreflightAssets(runtimeRoot) {
   if (!hasSeededRuntimePreflightAssets(runtimeRoot)) {
@@ -1904,7 +2208,7 @@ function seedRuntimePreflightAssets(runtimeRoot) {
 `);
   const localExamplePath = join2(runtimeRoot, "configs", "local.example.toml");
   const localTomlPath = join2(runtimeRoot, "configs", "local.toml");
-  if (existsSync4(localExamplePath)) {
+  if (existsSync5(localExamplePath)) {
     writeTextFileIfMissing(localTomlPath, readFileSync4(localExamplePath, "utf8"));
   } else {
     writeTextFileIfMissing(localTomlPath, `# Local PushPals runtime overrides
@@ -1949,15 +2253,15 @@ async function downloadRuntimeAssetsFromSourceTag(runtimeRoot, tag) {
 async function ensureRuntimeAssets(runtimeRoot, runtimeTag) {
   console.log(`[pushpals] Preparing embedded runtime assets for ${runtimeTag}...`);
   const markerPath = join2(runtimeRoot, ".runtime-assets-tag");
-  const currentTag = existsSync4(markerPath) ? readFileSync4(markerPath, "utf8").trim() : "";
+  const currentTag = existsSync5(markerPath) ? readFileSync4(markerPath, "utf8").trim() : "";
   const protocolSchemasDir = join2(runtimeRoot, "protocol", "schemas");
-  const hasProtocolSchemas = existsSync4(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync4(join2(protocolSchemasDir, "events.schema.json"));
-  const hasAssets = 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"));
+  const hasProtocolSchemas = existsSync5(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync5(join2(protocolSchemasDir, "events.schema.json"));
+  const hasAssets = existsSync5(join2(runtimeRoot, ".env.example")) && existsSync5(join2(runtimeRoot, "vision.example.md")) && existsSync5(join2(runtimeRoot, "configs", "default.toml")) && existsSync5(join2(runtimeRoot, "prompts")) && hasProtocolSchemas && isCompleteWorkerpalSandboxRoot(join2(runtimeRoot, "sandbox"));
   if (!hasAssets || currentTag !== runtimeTag) {
     console.log(`[pushpals] Embedded runtime assets ${hasAssets ? "are stale" : "are missing"}; refreshing bundle...`);
     copyBundledRuntimeAssets(runtimeRoot);
-    const hasProtocolSchemasAfterCopy = existsSync4(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync4(join2(protocolSchemasDir, "events.schema.json"));
-    const hasAssetsAfterCopy = existsSync4(join2(runtimeRoot, ".env.example")) && existsSync4(join2(runtimeRoot, "vision.example.md")) && existsSync4(join2(runtimeRoot, "configs", "default.toml")) && existsSync4(join2(runtimeRoot, "prompts")) && hasProtocolSchemasAfterCopy && isCompleteWorkerpalSandboxRoot(join2(runtimeRoot, "sandbox"));
+    const hasProtocolSchemasAfterCopy = existsSync5(join2(protocolSchemasDir, "envelope.schema.json")) && existsSync5(join2(protocolSchemasDir, "events.schema.json"));
+    const hasAssetsAfterCopy = existsSync5(join2(runtimeRoot, ".env.example")) && existsSync5(join2(runtimeRoot, "vision.example.md")) && existsSync5(join2(runtimeRoot, "configs", "default.toml")) && existsSync5(join2(runtimeRoot, "prompts")) && hasProtocolSchemasAfterCopy && isCompleteWorkerpalSandboxRoot(join2(runtimeRoot, "sandbox"));
     if (!hasAssetsAfterCopy) {
       console.log("[pushpals] Bundled runtime assets are incomplete; falling back to release source downloads...");
       await downloadRuntimeAssetsFromSourceTag(runtimeRoot, runtimeTag);
@@ -1969,7 +2273,7 @@ async function ensureRuntimeAssets(runtimeRoot, runtimeTag) {
 `);
   const localExamplePath = join2(runtimeRoot, "configs", "local.example.toml");
   const localTomlPath = join2(runtimeRoot, "configs", "local.toml");
-  if (existsSync4(localExamplePath)) {
+  if (existsSync5(localExamplePath)) {
     writeTextFileIfMissing(localTomlPath, readFileSync4(localExamplePath, "utf8"));
   } else {
     writeTextFileIfMissing(localTomlPath, `# Local PushPals runtime overrides
@@ -2023,12 +2327,12 @@ function runtimeBinaryFilename(serviceName, platformKey) {
 function resolveRuntimeBinaryInstallState(runtimeRoot, platformKey) {
   const binDir = join2(runtimeRoot, "bin", platformKey);
   const tagMarkerPath = join2(binDir, ".runtime-tag");
-  const installedTag = existsSync4(tagMarkerPath) ? readFileSync4(tagMarkerPath, "utf8").trim() : "";
+  const installedTag = existsSync5(tagMarkerPath) ? readFileSync4(tagMarkerPath, "utf8").trim() : "";
   return { binDir, tagMarkerPath, installedTag };
 }
 function cleanupLegacyRuntimeBinaryLayouts(runtimeRoot, platformKey, activeBinDir) {
   const legacyRoot = join2(runtimeRoot, "bin");
-  if (!existsSync4(legacyRoot))
+  if (!existsSync5(legacyRoot))
     return;
   let entries;
   try {
@@ -2045,7 +2349,7 @@ function cleanupLegacyRuntimeBinaryLayouts(runtimeRoot, platformKey, activeBinDi
     if (!entry.name.endsWith(`-${platformKey}`))
       continue;
     try {
-      rmSync(candidateDir, { recursive: true, force: true });
+      rmSync2(candidateDir, { recursive: true, force: true });
     } catch {}
   }
 }
@@ -2117,7 +2421,7 @@ function resolveEmbeddedBunExecutableFromEnv(env, platform = process.platform, c
       continue;
     for (const candidate of candidates) {
       const fullPath = join2(dir, candidate);
-      if (existsSync4(fullPath)) {
+      if (existsSync5(fullPath)) {
         return fullPath;
       }
     }
@@ -2190,7 +2494,7 @@ function appendRuntimeServicesLogLine(logPath, line) {
   } catch {}
 }
 function readLogTail(logPath, maxLines = 40) {
-  if (!existsSync4(logPath))
+  if (!existsSync5(logPath))
     return "";
   const raw = readFileSync4(logPath, "utf8");
   const lines = raw.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.length > 0);
@@ -2216,7 +2520,7 @@ function extractRemoteBuddyAutonomousEngineState(logText) {
   return state;
 }
 function readRemoteBuddyAutonomousEngineState(logPath) {
-  if (!existsSync4(logPath))
+  if (!existsSync5(logPath))
     return "unknown";
   try {
     return extractRemoteBuddyAutonomousEngineState(readFileSync4(logPath, "utf8"));
@@ -2258,7 +2562,7 @@ async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
   const shouldRefreshAll = installedTag !== runtimeTag;
   let downloadedCount = 0;
   for (const binaryPath of requiredAssets) {
-    if (!shouldRefreshAll && existsSync4(binaryPath))
+    if (!shouldRefreshAll && existsSync5(binaryPath))
       continue;
     const assetName = binaryPath.split(/[\\/]/).pop() || "";
     await downloadBinaryAsset(runtimeTag, assetName, binaryPath);
@@ -2282,71 +2586,6 @@ async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
   console.log("[pushpals] Embedded runtime binaries are ready.");
   return runtimeBinaries;
 }
-function spawnRuntimeService(name, command, cwd, env, logPath, runtimeServicesLogPath) {
-  const header = `[pushpals] service=${name} command=${command.join(" ")} cwd=${cwd}`;
-  writeFileSync(logPath, `${header}
-`, "utf8");
-  if (runtimeServicesLogPath) {
-    appendRuntimeServicesLogLine(runtimeServicesLogPath, header);
-  }
-  const proc = Bun.spawn(command, {
-    cwd,
-    env,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const pipeToLog = async (stream, channel) => {
-    if (!stream)
-      return;
-    const reader = stream.getReader();
-    const decoder = new TextDecoder;
-    let pending = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const chunk = decoder.decode(value, { stream: true });
-      if (!chunk)
-        continue;
-      pending += chunk;
-      const lines = pending.split(/\r?\n/);
-      pending = lines.pop() ?? "";
-      for (const line of lines) {
-        const serviceLine = `[${channel}] ${line}`;
-        appendFileSync(logPath, `${serviceLine}
-`, "utf8");
-        if (runtimeServicesLogPath) {
-          appendRuntimeServicesLogLine(runtimeServicesLogPath, `[${name}] ${serviceLine}`);
-        }
-      }
-    }
-    const rest = decoder.decode();
-    if (rest)
-      pending += rest;
-    if (pending.trim().length > 0) {
-      const serviceLine = `[${channel}] ${pending.trimEnd()}`;
-      appendFileSync(logPath, `${serviceLine}
-`, "utf8");
-      if (runtimeServicesLogPath) {
-        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[${name}] ${serviceLine}`);
-      }
-    }
-  };
-  pipeToLog(proc.stdout, "stdout");
-  pipeToLog(proc.stderr, "stderr");
-  const service = {
-    name,
-    proc,
-    logPath,
-    exited: false,
-    exitCode: null
-  };
-  proc.exited.then((code) => {
-    service.exited = true;
-    service.exitCode = code;
-  });
-  return service;
-}
 function buildServiceStopCommand(pid, platform = process.platform) {
   if (platform === "win32" && typeof pid === "number" && pid > 0) {
     return ["taskkill", "/PID", String(pid), "/T", "/F"];
@@ -2560,6 +2799,12 @@ function quoteWindowsCmdArg(value) {
 function isOptionalEmbeddedService(name) {
   return name === "source_control_manager";
 }
+function computeEmbeddedServiceRestartBackoffMs(attempt) {
+  return computeServiceRestartBackoffMs(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, {
@@ -2721,6 +2966,7 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
 }
 async function cleanupLingeringPushPalsGitWorktrees(opts) {
   const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
+  const forceDeleteWorktreePathFn = opts.forceDeleteWorktreePathFn ?? forceDeleteWorktreePath;
   const list = await runCommandWithEnvFn(["git", "worktree", "list", "--porcelain"], opts.repoRoot, opts.env);
   if (!list.ok) {
     const detail = list.stderr || list.stdout || `exit ${list.exitCode}`;
@@ -2748,7 +2994,13 @@ async function cleanupLingeringPushPalsGitWorktrees(opts) {
       removed += 1;
       continue;
     }
-    failures.push(`${entry.path}: ${remove.stderr || remove.stdout || `exit ${remove.exitCode}`}`);
+    const forced = await forceDeleteWorktreePathFn(entry.path);
+    if (forced.removed) {
+      removed += 1;
+      continue;
+    }
+    const removeDetail = remove.stderr || remove.stdout || `exit ${remove.exitCode}`;
+    failures.push(`${entry.path}: ${removeDetail}${forced.lastError ? ` | fallback: ${forced.lastError}` : ""}`);
   }
   const prune = await runCommandWithEnvFn(["git", "worktree", "prune"], opts.repoRoot, opts.env);
   if (!prune.ok) {
@@ -3103,10 +3355,10 @@ function buildCliClearTargets(opts) {
   return targets;
 }
 function removeCliClearTarget(target) {
-  if (!existsSync4(target.path))
+  if (!existsSync5(target.path))
     return "missing";
   try {
-    rmSync(target.path, { recursive: true, force: true });
+    rmSync2(target.path, { recursive: true, force: true });
     return "removed";
   } catch (err) {
     return {
@@ -3482,7 +3734,6 @@ async function autoStartRuntimeServices(opts) {
   if (resolvedGitBinary) {
     applyResolvedGitBinaryToRuntimeEnv(runtimeEnv, resolvedGitBinary);
   }
-  const services = [];
   const startupStartedAt = Date.now();
   const startupPhases = [];
   const recordStartupPhase = (name, startedAt, status) => {
@@ -3521,23 +3772,70 @@ async function autoStartRuntimeServices(opts) {
   console.log(`[pushpals] service log (localbuddy)=${serviceLogPaths.localbuddy}`);
   console.log(`[pushpals] service log (remotebuddy)=${serviceLogPaths.remotebuddy}`);
   console.log(`[pushpals] service log (source_control_manager)=${serviceLogPaths.source_control_manager}`);
+  const serviceManager = new ServiceManager({
+    degradedAction: "Inspect the embedded service log or restart pushpals after fixing the runtime failure.",
+    onEvent: (level, line) => {
+      const cliLine = `[pushpals] ${line.replace(/^Managed /, "Embedded ").replace(/^Restarted managed /, "Restarted embedded ")}`;
+      if (level === "error") {
+        console.error(cliLine);
+      } else if (level === "warn") {
+        console.warn(cliLine);
+      } else {
+        console.log(cliLine);
+      }
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, cliLine);
+    },
+    onHealthChange: (health) => {
+      for (const line of formatEmbeddedRuntimeHealthLines2(health)) {
+        console.error(line);
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, line);
+      }
+    }
+  });
+  const launchService = (name, command) => {
+    const logPath = serviceLogPaths[name];
+    const header = `[pushpals] service=${name} command=${command.join(" ")} cwd=${opts.repoRoot}`;
+    writeFileSync(logPath, `${header}
+`, "utf8");
+    appendRuntimeServicesLogLine(runtimeServicesLogPath, header);
+    return serviceManager.startService({
+      name,
+      color: "",
+      command,
+      cwd: opts.repoRoot,
+      env: runtimeEnv,
+      logPath,
+      onStdoutLine: (line) => {
+        const serviceLine = `[stdout] ${line}`;
+        appendFileSync(logPath, `${serviceLine}
+`, "utf8");
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[${name}] ${serviceLine}`);
+      },
+      onStderrLine: (line) => {
+        const serviceLine = `[stderr] ${line}`;
+        appendFileSync(logPath, `${serviceLine}
+`, "utf8");
+        appendRuntimeServicesLogLine(runtimeServicesLogPath, `[${name}] ${serviceLine}`);
+      }
+    });
+  };
   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);
-    console.log(`[pushpals] server log: ${serverService.logPath}`);
+    const serverService = launchService("server", [runtimeBinaries.server]);
+    const serverLogPath = serverService.logPath ?? serviceLogPaths.server;
+    console.log(`[pushpals] server log: ${serverLogPath}`);
     const serverDeadline = Date.now() + DEFAULT_SERVER_BOOT_TIMEOUT_MS;
     let serverIsReady = false;
     while (Date.now() < serverDeadline) {
       if (serverService.exited) {
-        const tail = readLogTail(serverService.logPath);
+        const tail = readLogTail(serverLogPath);
         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 ? `
+        stopRuntimeServices(serviceManager.getServices());
+        throw new Error(`Embedded server exited during bootstrap (code=${serverService.exitCode ?? "unknown"}). ` + `See ${serverLogPath}${tail ? `
 --- server log tail ---
 ${tail}` : ""}`);
       }
@@ -3548,12 +3846,12 @@ ${tail}` : ""}`);
       await Bun.sleep(DEFAULT_RUNTIME_BOOT_POLL_MS);
     }
     if (!serverIsReady) {
-      const tail = readLogTail(serverService.logPath);
+      const tail = readLogTail(serverLogPath);
       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 ? `
+      stopRuntimeServices(serviceManager.getServices());
+      throw new Error(`Embedded server did not become healthy within ${DEFAULT_SERVER_BOOT_TIMEOUT_MS}ms. ` + `See ${serverLogPath}${tail ? `
 --- server log tail ---
 ${tail}` : ""}`);
     }
@@ -3567,9 +3865,8 @@ ${tail}` : ""}`);
   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}`);
+    const localbuddyService = launchService("localbuddy", [runtimeBinaries.localbuddy]);
+    console.log(`[pushpals] localbuddy log: ${localbuddyService.logPath ?? serviceLogPaths.localbuddy}`);
     recordStartupPhase("localbuddy", localBuddyPhaseStartedAt, "started");
   } else {
     recordStartupPhase("localbuddy", Date.now(), "skipped");
@@ -3578,13 +3875,13 @@ ${tail}` : ""}`);
   }
   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}`);
+  const remotebuddyService = launchService("remotebuddy", [runtimeBinaries.remotebuddy]);
+  const remotebuddyLogPath = remotebuddyService.logPath ?? serviceLogPaths.remotebuddy;
+  console.log(`[pushpals] remotebuddy log: ${remotebuddyLogPath}`);
   recordStartupPhase("remotebuddy", remoteBuddyPhaseStartedAt, "started");
   let lastReportedRemoteBuddyAutonomyState = "unknown";
   const reportRemoteBuddyAutonomousEngineState = () => {
-    const autonomyState = readRemoteBuddyAutonomousEngineState(remotebuddyService.logPath);
+    const autonomyState = readRemoteBuddyAutonomousEngineState(remotebuddyLogPath);
     if (autonomyState === "unknown" || autonomyState === lastReportedRemoteBuddyAutonomyState) {
       return;
     }
@@ -3635,9 +3932,11 @@ ${tail}` : ""}`);
     } 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}`);
+      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.`);
@@ -3651,30 +3950,36 @@ ${tail}` : ""}`);
   }
   const deadline = Date.now() + DEFAULT_RUNTIME_BOOT_TIMEOUT_MS;
   const readinessPhaseStartedAt = Date.now();
+  const optionalServiceExitWarned = new Set;
   while (Date.now() < deadline) {
     reportRemoteBuddyAutonomousEngineState();
-    for (let i = services.length - 1;i >= 0; i--) {
-      const service = services[i];
+    for (const service of serviceManager.getServices()) {
       if (service.exited) {
         if (isOptionalEmbeddedService(service.name)) {
-          console.warn(`[pushpals] Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}); continuing without SCM.`);
-          appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}); continuing.`);
-          const tail2 = readLogTail(service.logPath);
-          if (tail2) {
-            console.warn(`[pushpals] ${service.name} log tail:
+          const runtimeServiceName2 = service.name;
+          const serviceLogPath2 = service.logPath ?? serviceLogPaths[runtimeServiceName2];
+          if (!optionalServiceExitWarned.has(runtimeServiceName2)) {
+            console.warn(`[pushpals] Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}); startup will continue and host supervisor will attempt recovery.`);
+            appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}); startup will continue and host supervisor will attempt recovery.`);
+            const tail2 = readLogTail(serviceLogPath2);
+            if (tail2) {
+              console.warn(`[pushpals] ${service.name} log tail:
 ${tail2}`);
-            appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] ${service.name} log tail:
+              appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] ${service.name} log tail:
 ${tail2}`);
+            }
+            optionalServiceExitWarned.add(runtimeServiceName2);
           }
-          services.splice(i, 1);
           continue;
         }
-        const tail = readLogTail(service.logPath);
+        const runtimeServiceName = service.name;
+        const serviceLogPath = service.logPath ?? serviceLogPaths[runtimeServiceName];
+        const tail = readLogTail(serviceLogPath);
         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 ? `
+        stopRuntimeServices(serviceManager.getServices());
+        throw new Error(`Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}). ` + `See ${serviceLogPath}${tail ? `
 --- ${service.name} log tail ---
 ${tail}` : ""}`);
       }
@@ -3686,29 +3991,34 @@ ${tail}` : ""}`);
       const stabilityDeadline = Date.now() + DEFAULT_SERVICE_STABILITY_GRACE_MS;
       while (Date.now() < stabilityDeadline) {
         reportRemoteBuddyAutonomousEngineState();
-        for (let i = services.length - 1;i >= 0; i--) {
-          const service = services[i];
+        for (const service of serviceManager.getServices()) {
           if (!service.exited)
             continue;
           if (isOptionalEmbeddedService(service.name)) {
-            const tail2 = readLogTail(service.logPath);
-            console.warn(`[pushpals] Embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}); continuing without SCM.`);
-            appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}); continuing.`);
-            if (tail2) {
-              console.warn(`[pushpals] ${service.name} log tail:
+            const runtimeServiceName2 = service.name;
+            const serviceLogPath2 = service.logPath ?? serviceLogPaths[runtimeServiceName2];
+            if (!optionalServiceExitWarned.has(runtimeServiceName2)) {
+              const tail2 = readLogTail(serviceLogPath2);
+              console.warn(`[pushpals] Embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}); startup will continue and host supervisor will attempt recovery.`);
+              appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}); startup will continue and host supervisor will attempt recovery.`);
+              if (tail2) {
+                console.warn(`[pushpals] ${service.name} log tail:
 ${tail2}`);
-              appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] ${service.name} log tail:
+                appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] ${service.name} log tail:
 ${tail2}`);
+              }
+              optionalServiceExitWarned.add(runtimeServiceName2);
             }
-            services.splice(i, 1);
             continue;
           }
-          const tail = readLogTail(service.logPath);
+          const runtimeServiceName = service.name;
+          const serviceLogPath = service.logPath ?? serviceLogPaths[runtimeServiceName];
+          const tail = readLogTail(serviceLogPath);
           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 ? `
+          stopRuntimeServices(serviceManager.getServices());
+          throw new Error(`Embedded ${service.name} exited immediately after bootstrap (code=${service.exitCode ?? "unknown"}). ` + `See ${serviceLogPath}${tail ? `
 --- ${service.name} log tail ---
 ${tail}` : ""}`);
         }
@@ -3719,13 +4029,13 @@ ${tail}` : ""}`);
       emitStartupTimingSummary("ready");
       appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] embedded runtime is ready.");
       return {
-        services,
+        serviceManager,
         pushpalsLogPath: runtimeServicesLogPath
       };
     }
     await Bun.sleep(DEFAULT_RUNTIME_BOOT_POLL_MS);
   }
-  stopRuntimeServices(services);
+  stopRuntimeServices(serviceManager.getServices());
   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}).`);
@@ -3745,7 +4055,7 @@ ${tail}` : ""}`);
   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) {
-  if (!existsSync4(pathValue))
+  if (!existsSync5(pathValue))
     return {};
   try {
     const raw = readFileSync4(pathValue, "utf8");
@@ -3848,11 +4158,11 @@ function resolveMonitoringHubAssetPath(assetRoot, pathname) {
   const candidatePath = resolve4(root, relativePath);
   if (candidatePath !== root && !candidatePath.startsWith(rootPrefix))
     return null;
-  if (existsSync4(candidatePath))
+  if (existsSync5(candidatePath))
     return candidatePath;
   if (!extname(relativePath)) {
     const nestedIndexPath = resolve4(root, relativePath, "index.html");
-    if ((nestedIndexPath === root || nestedIndexPath.startsWith(rootPrefix)) && existsSync4(nestedIndexPath)) {
+    if ((nestedIndexPath === root || nestedIndexPath.startsWith(rootPrefix)) && existsSync5(nestedIndexPath)) {
       return nestedIndexPath;
     }
     return join2(root, "index.html");
@@ -3861,7 +4171,7 @@ function resolveMonitoringHubAssetPath(assetRoot, pathname) {
 }
 async function serveBundledMonitoringHub(assetRoot, pathname, bootstrap) {
   const assetPath = resolveMonitoringHubAssetPath(assetRoot, pathname);
-  if (!assetPath || !existsSync4(assetPath))
+  if (!assetPath || !existsSync5(assetPath))
     return null;
   if (assetPath.endsWith("index.html")) {
     const html = injectMonitoringHubBootstrap(readFileSync4(assetPath, "utf8"), bootstrap);
@@ -4405,7 +4715,7 @@ async function main() {
     platform: `${process.platform}/${process.arch}`,
     repoRoot
   };
-  let autoStartedServices = [];
+  let autoStartedServiceManager = null;
   let pushpalsLogPath;
   let resolvedRuntimeTagForAutoStart = preparedRuntime.runtimeTag || parsed.runtimeTag || "";
   const cleanupWorkerpalWarmContainersIfNeeded = async (phase) => {
@@ -4464,17 +4774,24 @@ async function main() {
     }
     return readiness;
   };
+  const reportEmbeddedRuntimeHealth = () => {
+    const health = autoStartedServiceManager?.getHealth() ?? null;
+    for (const line of formatEmbeddedRuntimeHealthLines2(health)) {
+      console.log(line);
+    }
+    return health;
+  };
   const stopAutoStartedServices = () => {
-    if (autoStartedServices.length === 0)
+    if (!autoStartedServiceManager)
       return;
-    stopRuntimeServices(autoStartedServices);
-    autoStartedServices = [];
+    autoStartedServiceManager.stop();
+    autoStartedServiceManager = null;
   };
   const stopAutoStartedServicesGracefully = async (reason) => {
-    if (autoStartedServices.length === 0)
+    if (!autoStartedServiceManager)
       return;
-    const services = autoStartedServices;
-    autoStartedServices = [];
+    const serviceManager = autoStartedServiceManager;
+    autoStartedServiceManager = null;
     const shutdown = await requestLocalRuntimeShutdown(serverUrl, repoRoot, reason);
     if (shutdown.attempted && shutdown.accepted) {
       console.log("[pushpals] Local runtime shutdown accepted; waiting for services to exit...");
@@ -4484,6 +4801,8 @@ async function main() {
     } else if (shutdown.detail) {
       console.warn(`[pushpals] ${shutdown.detail}`);
     }
+    serviceManager.stop();
+    const services = serviceManager.getServices();
     await stopRuntimeServicesGracefully(services);
     await cleanupWorkerpalWarmContainersIfNeeded("cli shutdown");
     await cleanupPushPalsGitWorktreesIfNeeded("cli shutdown");
@@ -4531,7 +4850,7 @@ async function main() {
           startLocalBuddy: resolveCliLocalBuddyAutostart(parsed.runtimeOnly, Boolean(config.localbuddy.enabled)),
           baseEnv: workerpalDockerPrecheck.env
         });
-        autoStartedServices = startedRuntime.services;
+        autoStartedServiceManager = startedRuntime.serviceManager;
         pushpalsLogPath = startedRuntime.pushpalsLogPath;
         serverHealthy = await probeServer(serverUrl);
       } catch (err) {
@@ -4655,6 +4974,7 @@ async function main() {
   console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
   console.log(`[pushpals] cliStateFile=${statePath ?? "unavailable"}`);
   reportWorkerExecutionReadinessFromSnapshot(startupWorkerExecutionReadiness);
+  reportEmbeddedRuntimeHealth();
   if (parsed.runtimeOnly) {
     console.log("[pushpals] runtimeOnly=true");
   } else {
@@ -4689,7 +5009,7 @@ ${line}
       try {
         monitoringHub?.stop();
       } catch {}
-      if (autoStartedServices.length > 0) {
+      if (autoStartedServiceManager) {
         console.log("[pushpals] Stopping embedded runtime services...");
       }
       await stopAutoStartedServicesGracefully("pushpals CLI exit");
@@ -4767,6 +5087,7 @@ ${line}
       console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
       console.log(monitoringHubUrl ? `[pushpals] monitoringHubUrl=${monitoringHubUrl}` : "[pushpals] monitoringHubUrl=unavailable");
       await reportWorkerExecutionReadiness();
+      reportEmbeddedRuntimeHealth();
       rl.prompt();
       continue;
     }
@@ -4806,6 +5127,7 @@ export {
   waitForWorkerpalCapacity,
   startEmbeddedMonitoringHub,
   shouldRunEmbeddedRuntimeStartupPrechecks,
+  shouldRestartEmbeddedService,
   resolveWorkerExecutionReadiness,
   resolveWindowsWhereExecutableCandidatesForEnv,
   resolveWindowsShellExecutableCandidatesForEnv,
@@ -4832,6 +5154,7 @@ export {
   formatTimestampedCliLine,
   formatSessionEventLine,
   formatRuntimeStartupTimingSummary,
+  formatEmbeddedRuntimeHealthLines2 as formatEmbeddedRuntimeHealthLines,
   extractRemoteBuddySessionConsumerHealth,
   extractRemoteBuddyAutonomousEngineState,
   ensureWorkerpalDockerImageReady,
@@ -4840,6 +5163,7 @@ export {
   describeWorkerExecutionReadiness,
   createSessionEventReplayFilter,
   copyTrackedRepoPath,
+  computeEmbeddedServiceRestartBackoffMs,
   cleanupLingeringWorkerpalWarmContainers,
   cleanupLingeringPushPalsGitWorktrees,
   bundledMonitoringHubNeedsRefresh,

package/package.json

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

package/runtime/sandbox/package.json

@@ -45,6 +45,7 @@
     "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:start:e2e": "bun test ./tests/integration/start.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",