@pushpalsdev/cli 1.0.1

package/dist/pushpals-cli.js

@@ -0,0 +1,1249 @@
+#!/usr/bin/env bun
+// @bun
+
+// ../../scripts/pushpals-cli.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { createInterface } from "readline";
+
+// ../shared/src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve, isAbsolute } from "path";
+var PROJECT_ROOT = resolve(import.meta.dir, "..", "..", "..");
+var DEFAULT_CONFIG_DIR = "configs";
+var LEGACY_CONFIG_DIR = "config";
+var TRUTHY = new Set(["1", "true", "yes", "on"]);
+var FALSY = new Set(["0", "false", "no", "off"]);
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_MIN_SCORE = 8;
+var DEFAULT_WORKERPALS_FILE_MODIFYING_JOBS = ["task.execute"];
+var DEFAULT_WORKERPALS_OUTPUT_MAX_CHARS = 192 * 1024;
+var DEFAULT_WORKERPALS_OUTPUT_MAX_LINES = 600;
+var DEFAULT_WORKERPALS_OUTPUT_MAX_HEAD_LINES = 120;
+var DEFAULT_WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS = 180000;
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS = 45000;
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS = 16000;
+var DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS = 8000;
+var DEFAULT_WORKERPALS_EXECUTOR_RESULT_PREFIX = "__PUSHPALS_OH_RESULT__ ";
+var DEFAULT_REMOTEBUDDY_MEMORY_MAX_RECALL_ITEMS = 12;
+var DEFAULT_REMOTEBUDDY_MEMORY_MAX_RECALL_CHARS = 2400;
+var DEFAULT_REMOTEBUDDY_MEMORY_MAX_SUMMARY_CHARS = 420;
+var DEFAULT_REMOTEBUDDY_MEMORY_RETENTION_DAYS = 30;
+var cachedConfig = null;
+var cachedConfigKey = "";
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = (value ?? "").trim();
+    if (trimmed)
+      return trimmed;
+  }
+  return "";
+}
+function parseBoolEnv(name) {
+  const raw = (process.env[name] ?? "").trim().toLowerCase();
+  if (!raw)
+    return null;
+  if (TRUTHY.has(raw))
+    return true;
+  if (FALSY.has(raw))
+    return false;
+  return null;
+}
+function parseIntEnv(name) {
+  const raw = (process.env[name] ?? "").trim();
+  if (!raw)
+    return null;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseTomlFile(path) {
+  if (!existsSync(path))
+    return {};
+  const raw = readFileSync(path, "utf-8");
+  const parsed = Bun.TOML.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return {};
+  return parsed;
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeDeep(base, override) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const existing = out[key];
+    if (isObject(existing) && isObject(value)) {
+      out[key] = mergeDeep(existing, value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function getObject(parent, key) {
+  const value = parent[key];
+  if (isObject(value))
+    return value;
+  return {};
+}
+function asString(value, fallback) {
+  if (typeof value === "string" && value.trim())
+    return value.trim();
+  return fallback;
+}
+function asBoolean(value, fallback) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const lowered = value.trim().toLowerCase();
+    if (TRUTHY.has(lowered))
+      return true;
+    if (FALSY.has(lowered))
+      return false;
+  }
+  return fallback;
+}
+function asInt(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return Math.floor(value);
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+}
+function asIntOrNull(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return Math.floor(value);
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return null;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+}
+function asCheckArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  const checks = [];
+  for (const entry of value) {
+    if (!isObject(entry))
+      continue;
+    const name = asString(entry.name, "").trim();
+    const command = asString(entry.command, "").trim();
+    if (!name || !command)
+      continue;
+    const timeoutMs = Math.max(1000, asInt(entry.timeout_ms ?? entry.timeoutMs, 300000));
+    checks.push({ name, command, timeoutMs });
+  }
+  return checks;
+}
+function asStringNumberRecord(value) {
+  if (!isObject(value))
+    return {};
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const name = key.trim();
+    if (!name)
+      continue;
+    const num = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw.trim(), 10) : Number.NaN;
+    if (!Number.isFinite(num))
+      continue;
+    out[name] = Math.max(0, Math.floor(num));
+  }
+  return out;
+}
+function resolvePathFromRoot(projectRoot, value) {
+  if (!value)
+    return projectRoot;
+  if (isAbsolute(value))
+    return resolve(value);
+  return resolve(projectRoot, value);
+}
+function resolveRuntimeConfigDir(projectRoot, configuredDir) {
+  if (configuredDir && configuredDir.trim()) {
+    return resolvePathFromRoot(projectRoot, configuredDir);
+  }
+  const canonicalDir = resolvePathFromRoot(projectRoot, DEFAULT_CONFIG_DIR);
+  const legacyDir = resolvePathFromRoot(projectRoot, LEGACY_CONFIG_DIR);
+  if (existsSync(join(canonicalDir, "default.toml")))
+    return canonicalDir;
+  if (existsSync(join(legacyDir, "default.toml")))
+    return legacyDir;
+  return canonicalDir;
+}
+function parseTomlWithLegacyFallback(primaryPath, fallbackPath) {
+  if (existsSync(primaryPath))
+    return parseTomlFile(primaryPath);
+  if (fallbackPath && existsSync(fallbackPath))
+    return parseTomlFile(fallbackPath);
+  return {};
+}
+function normalizeBackend(value) {
+  const text = value.trim().toLowerCase();
+  if (!text)
+    return "lmstudio";
+  if (text === "openai_compatible")
+    return "lmstudio";
+  if (text === "ollama_chat")
+    return "ollama";
+  return text;
+}
+function normalizeWorkerImageRebuildMode(value) {
+  const text = value.trim().toLowerCase();
+  if (text === "always" || text === "1" || text === "true" || text === "yes" || text === "on") {
+    return "always";
+  }
+  if (text === "never" || text === "0" || text === "false" || text === "no" || text === "off") {
+    return "never";
+  }
+  return "auto";
+}
+function normalizeStartupPortConflictPolicy(value) {
+  const text = value.trim().toLowerCase().replace(/-/g, "_");
+  if (text === "terminate_pushpals" || text === "kill_pushpals" || text === "auto_kill_pushpals") {
+    return "terminate_pushpals";
+  }
+  return "fail";
+}
+function defaultApiKeyForBackend(backend, endpoint) {
+  const normalizedBackend = backend.trim().toLowerCase();
+  const normalizedEndpoint = endpoint.trim().toLowerCase();
+  const openAiKey = (process.env.OPENAI_API_KEY ?? "").trim();
+  if (normalizedBackend === "openai") {
+    return openAiKey;
+  }
+  if (normalizedBackend === "lmstudio") {
+    return "lmstudio";
+  }
+  if (normalizedEndpoint.includes("api.openai.com")) {
+    return openAiKey;
+  }
+  return "";
+}
+function resolveLlmConfig(serviceNode, envPrefix, defaults, globalSessionId) {
+  const llmNode = getObject(serviceNode, "llm");
+  const backend = normalizeBackend(firstNonEmpty(process.env[`${envPrefix}_LLM_BACKEND`], asString(llmNode.backend, defaults.backend), defaults.backend));
+  const endpoint = firstNonEmpty(process.env[`${envPrefix}_LLM_ENDPOINT`], asString(llmNode.endpoint, defaults.endpoint), defaults.endpoint);
+  const model = firstNonEmpty(process.env[`${envPrefix}_LLM_MODEL`], asString(llmNode.model, defaults.model), defaults.model);
+  const sessionId = firstNonEmpty(process.env[`${envPrefix}_LLM_SESSION_ID`], asString(llmNode.session_id, defaults.sessionId), process.env.PUSHPALS_LLM_SESSION_ID, globalSessionId);
+  const apiKey = firstNonEmpty(process.env[`${envPrefix}_LLM_API_KEY`], defaultApiKeyForBackend(backend, endpoint));
+  const reasoningEffort = firstNonEmpty(process.env[`${envPrefix}_LLM_REASONING_EFFORT`], asString(llmNode.reasoning_effort, ""));
+  const codexAuthMode = firstNonEmpty(process.env[`${envPrefix}_LLM_CODEX_AUTH_MODE`], asString(llmNode.codex_auth_mode, ""));
+  const codexBin = firstNonEmpty(process.env[`${envPrefix}_LLM_CODEX_BIN`], asString(llmNode.codex_bin, ""));
+  const codexTimeoutMs = Math.max(1e4, asInt(parseIntEnv(`${envPrefix}_LLM_CODEX_TIMEOUT_MS`) ?? llmNode.codex_timeout_ms, 120000));
+  return {
+    backend,
+    endpoint,
+    model,
+    sessionId,
+    apiKey,
+    reasoningEffort,
+    codexAuthMode,
+    codexBin,
+    codexTimeoutMs
+  };
+}
+function loadPushPalsConfig(options = {}) {
+  const projectRoot = resolve(options.projectRoot ?? PROJECT_ROOT);
+  const configDir = resolveRuntimeConfigDir(projectRoot, options.configDir);
+  const legacyConfigDir = resolvePathFromRoot(projectRoot, LEGACY_CONFIG_DIR);
+  const fallbackConfigDir = !options.configDir && configDir !== legacyConfigDir ? legacyConfigDir : "";
+  const cacheKey = `${projectRoot}::${configDir}::${process.env.PUSHPALS_PROFILE ?? ""}`;
+  if (!options.reload && cachedConfig && cachedConfigKey === cacheKey) {
+    return cachedConfig;
+  }
+  const defaultToml = parseTomlWithLegacyFallback(join(configDir, "default.toml"), fallbackConfigDir ? join(fallbackConfigDir, "default.toml") : undefined);
+  const preferredProfile = firstNonEmpty(process.env.PUSHPALS_PROFILE, asString(defaultToml.profile, "dev"), "dev");
+  const profileToml = parseTomlWithLegacyFallback(join(configDir, `${preferredProfile}.toml`), fallbackConfigDir ? join(fallbackConfigDir, `${preferredProfile}.toml`) : undefined);
+  const localExampleToml = parseTomlWithLegacyFallback(join(configDir, "local.example.toml"), fallbackConfigDir ? join(fallbackConfigDir, "local.example.toml") : undefined);
+  const localToml = parseTomlWithLegacyFallback(join(configDir, "local.toml"), fallbackConfigDir ? join(fallbackConfigDir, "local.toml") : undefined);
+  const merged = mergeDeep(mergeDeep(mergeDeep(defaultToml, profileToml), localExampleToml), localToml);
+  const profile = firstNonEmpty(process.env.PUSHPALS_PROFILE, asString(merged.profile, preferredProfile), preferredProfile);
+  const sessionId = firstNonEmpty(process.env.PUSHPALS_SESSION_ID, asString(merged.session_id, "dev"), "dev");
+  const llmNode = getObject(merged, "llm");
+  const lmStudioNode = getObject(llmNode, "lmstudio");
+  const lmStudioContextWindow = Math.max(512, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_CONTEXT_WINDOW") ?? lmStudioNode.context_window, 4096));
+  const lmStudioMinOutputTokens = Math.max(64, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_MIN_OUTPUT_TOKENS") ?? lmStudioNode.min_output_tokens, 256));
+  const lmStudioTokenSafetyMargin = Math.max(16, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_TOKEN_SAFETY_MARGIN") ?? lmStudioNode.token_safety_margin, 64));
+  const lmStudioBatchTailMessages = Math.max(1, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_BATCH_TAIL_MESSAGES") ?? lmStudioNode.batch_tail_messages, 3));
+  const lmStudioBatchChunkTokens = Math.max(0, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_BATCH_CHUNK_TOKENS") ?? lmStudioNode.batch_chunk_tokens, 0));
+  const lmStudioBatchMemoryChars = Math.max(0, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_BATCH_MEMORY_CHARS") ?? lmStudioNode.batch_memory_chars, 0));
+  const pathsNode = getObject(merged, "paths");
+  const dataDir = resolvePathFromRoot(projectRoot, firstNonEmpty(process.env.PUSHPALS_DATA_DIR, asString(pathsNode.data_dir, "outputs/data")));
+  const sharedDbPath = resolvePathFromRoot(projectRoot, firstNonEmpty(process.env.PUSHPALS_DB_PATH, asString(pathsNode.shared_db_path, join(dataDir, "pushpals.db"))));
+  const remotebuddyDbPath = resolvePathFromRoot(projectRoot, firstNonEmpty(process.env.REMOTEBUDDY_DB_PATH, asString(pathsNode.remotebuddy_db_path, join(dataDir, "remotebuddy-state.db"))));
+  const serverNode = getObject(merged, "server");
+  const serverPort = Math.max(1, asInt(parseIntEnv("PUSHPALS_PORT") ?? serverNode.port, 3001));
+  const serverUrl = firstNonEmpty(process.env.PUSHPALS_SERVER_URL, asString(serverNode.url, `http://localhost:${serverPort}`), `http://localhost:${serverPort}`);
+  const serverHost = asString(serverNode.host, "0.0.0.0");
+  const debugHttp = parseBoolEnv("PUSHPALS_DEBUG_HTTP") ?? asBoolean(serverNode.debug_http, false);
+  const staleClaimTtlMs = Math.max(5000, asInt(parseIntEnv("PUSHPALS_STALE_CLAIM_TTL_MS") ?? serverNode.stale_claim_ttl_ms, 120000));
+  const staleClaimSweepIntervalMs = Math.max(1000, asInt(parseIntEnv("PUSHPALS_STALE_CLAIM_SWEEP_INTERVAL_MS") ?? serverNode.stale_claim_sweep_interval_ms, 5000));
+  const globalStatusHeartbeatMs = parseIntEnv("PUSHPALS_STATUS_HEARTBEAT_MS");
+  const localNode = getObject(merged, "localbuddy");
+  const localPort = Math.max(1, asInt(parseIntEnv("LOCAL_AGENT_PORT") ?? localNode.port, 3003));
+  const localStatusHeartbeatMs = Math.max(0, asInt(parseIntEnv("LOCALBUDDY_STATUS_HEARTBEAT_MS") ?? globalStatusHeartbeatMs ?? localNode.status_heartbeat_ms, 120000));
+  const localLlm = resolveLlmConfig(localNode, "LOCALBUDDY", {
+    backend: "lmstudio",
+    endpoint: "http://127.0.0.1:1234",
+    model: "local-model",
+    sessionId: "localbuddy-dev"
+  }, sessionId);
+  const remoteNode = getObject(merged, "remotebuddy");
+  const remoteStatusHeartbeatMs = Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_STATUS_HEARTBEAT_MS") ?? globalStatusHeartbeatMs ?? remoteNode.status_heartbeat_ms, 120000));
+  const remotePollMs = Math.max(200, asInt(parseIntEnv("REMOTEBUDDY_POLL_MS") ?? remoteNode.poll_ms, 2000));
+  const remoteLlm = resolveLlmConfig(remoteNode, "REMOTEBUDDY", {
+    backend: "lmstudio",
+    endpoint: "http://127.0.0.1:1234",
+    model: "local-model",
+    sessionId: "remotebuddy-dev"
+  }, sessionId);
+  const remoteMemoryNode = getObject(remoteNode, "memory");
+  const remoteMemoryEnabled = parseBoolEnv("REMOTEBUDDY_MEMORY_ENABLED") ?? asBoolean(remoteMemoryNode.enabled, true);
+  const remoteMemoryIncludeCrossSession = parseBoolEnv("REMOTEBUDDY_MEMORY_INCLUDE_CROSS_SESSION") ?? asBoolean(remoteMemoryNode.include_cross_session, true);
+  const remoteMemoryMaxRecallItems = Math.max(1, Math.min(128, asInt(parseIntEnv("REMOTEBUDDY_MEMORY_MAX_RECALL_ITEMS") ?? remoteMemoryNode.max_recall_items, DEFAULT_REMOTEBUDDY_MEMORY_MAX_RECALL_ITEMS)));
+  const remoteMemoryMaxRecallChars = Math.max(120, Math.min(64000, asInt(parseIntEnv("REMOTEBUDDY_MEMORY_MAX_RECALL_CHARS") ?? remoteMemoryNode.max_recall_chars, DEFAULT_REMOTEBUDDY_MEMORY_MAX_RECALL_CHARS)));
+  const remoteMemoryMaxSummaryChars = Math.max(64, Math.min(16000, asInt(parseIntEnv("REMOTEBUDDY_MEMORY_MAX_SUMMARY_CHARS") ?? remoteMemoryNode.max_summary_chars, DEFAULT_REMOTEBUDDY_MEMORY_MAX_SUMMARY_CHARS)));
+  const remoteMemoryRetentionDays = Math.max(1, Math.min(3650, asInt(parseIntEnv("REMOTEBUDDY_MEMORY_RETENTION_DAYS") ?? remoteMemoryNode.retention_days, DEFAULT_REMOTEBUDDY_MEMORY_RETENTION_DAYS)));
+  const remoteAutonomyNode = getObject(remoteNode, "autonomy");
+  const remoteAutonomyReplayNode = getObject(remoteAutonomyNode, "replay");
+  const remoteAutonomyDispatchByTypeCfg = {
+    flaky_test: 4,
+    lint_fix: 3,
+    type_fix: 3,
+    small_refactor: 2,
+    feature_small: 2,
+    feature_medium: 1,
+    feature_large: 0,
+    docs: 1,
+    dep_bump: 0
+  };
+  const remoteAutonomyDispatchByType = {
+    ...remoteAutonomyDispatchByTypeCfg,
+    ...asStringNumberRecord(remoteAutonomyNode.max_dispatch_per_hour_by_type)
+  };
+  const remoteAutonomyDispatchByComponentCfg = {
+    "apps/server": 3,
+    "apps/remotebuddy": 2,
+    "apps/workerpals": 2,
+    "apps/client": 2,
+    "packages/protocol": 1,
+    "packages/shared": 2,
+    "tests/integration": 2,
+    "tests/unit": 2
+  };
+  const remoteAutonomyDispatchByComponentRaw = asStringNumberRecord(remoteAutonomyNode.max_dispatch_per_hour_by_component);
+  const remoteAutonomyDispatchByComponent = {
+    ...remoteAutonomyDispatchByComponentCfg
+  };
+  const normalizeAutonomyComponentKey = (value) => value.trim().toLowerCase().replace(/\\/g, "/").replace(/_+/g, "/").replace(/-+/g, "/").replace(/\/+/g, "/");
+  const canonicalComponentByNormalized = new Map(Object.keys(remoteAutonomyDispatchByComponentCfg).map((key) => [normalizeAutonomyComponentKey(key), key]));
+  for (const [rawKey, rawValue] of Object.entries(remoteAutonomyDispatchByComponentRaw)) {
+    const normalized = normalizeAutonomyComponentKey(rawKey);
+    const canonical = canonicalComponentByNormalized.get(normalized);
+    if (!canonical)
+      continue;
+    const parsed = typeof rawValue === "number" ? rawValue : typeof rawValue === "string" ? Number.parseInt(rawValue.trim(), 10) : Number.NaN;
+    remoteAutonomyDispatchByComponent[canonical] = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : 0;
+  }
+  const workerNode = getObject(merged, "workerpals");
+  const workerOpenHandsNode = getObject(workerNode, "openhands");
+  const workerPollMs = Math.max(200, asInt(parseIntEnv("WORKERPALS_POLL_MS") ?? workerNode.poll_ms, 2000));
+  const workerHeartbeatMs = Math.max(200, asInt(parseIntEnv("WORKERPALS_HEARTBEAT_MS") ?? workerNode.heartbeat_ms, 5000));
+  const workerExecutor = firstNonEmpty(process.env.WORKERPALS_EXECUTOR, asString(workerNode.executor, "openhands"), "openhands").toLowerCase();
+  const workerOpenHandsPython = firstNonEmpty(process.env.WORKERPALS_OPENHANDS_PYTHON, asString(workerNode.openhands_python, "python"), "python");
+  const workerOpenHandsTimeoutMs = Math.max(1e4, asInt(parseIntEnv("WORKERPALS_OPENHANDS_TIMEOUT_MS") ?? workerNode.openhands_timeout_ms, 1800000));
+  const workerMiniswePython = firstNonEmpty(process.env.WORKERPALS_MINISWE_PYTHON, asString(workerNode.miniswe_python, "python"), "python");
+  const workerMinisweTimeoutMs = Math.max(1e4, asInt(parseIntEnv("WORKERPALS_MINISWE_TIMEOUT_MS") ?? workerNode.miniswe_timeout_ms, 1800000));
+  const workerOpenAICodexPython = firstNonEmpty(process.env.PUSHPALS_OPENAI_CODEX_PYTHON, asString(workerNode.openai_codex_python, "python"), "python");
+  const workerOpenAICodexTimeoutMs = Math.max(1e4, asInt(workerNode.openai_codex_timeout_ms, 7200000));
+  const workerQualityMaxAutoRevisions = Math.max(0, Math.min(10, asInt(parseIntEnv("WORKERPALS_QUALITY_MAX_AUTO_REVISIONS") ?? workerNode.quality_max_auto_revisions, 4)));
+  const workerFileModifyingJobs = (() => {
+    const envRaw = firstNonEmpty(process.env.WORKERPALS_FILE_MODIFYING_JOBS);
+    const parsed = envRaw ? envRaw.split(",").map((entry) => entry.trim()).filter(Boolean) : asStringArray(workerNode.file_modifying_jobs);
+    const out = parsed.length > 0 ? parsed : DEFAULT_WORKERPALS_FILE_MODIFYING_JOBS;
+    return [...new Set(out)];
+  })();
+  const workerOutputMaxChars = Math.max(8192, Math.min(4194304, asInt(parseIntEnv("WORKERPALS_OUTPUT_MAX_CHARS") ?? workerNode.output_max_chars, DEFAULT_WORKERPALS_OUTPUT_MAX_CHARS)));
+  const workerOutputMaxLines = Math.max(50, Math.min(20000, asInt(parseIntEnv("WORKERPALS_OUTPUT_MAX_LINES") ?? workerNode.output_max_lines, DEFAULT_WORKERPALS_OUTPUT_MAX_LINES)));
+  const workerOutputMaxHeadLines = Math.max(1, Math.min(workerOutputMaxLines, asInt(parseIntEnv("WORKERPALS_OUTPUT_MAX_HEAD_LINES") ?? workerNode.output_max_head_lines, DEFAULT_WORKERPALS_OUTPUT_MAX_HEAD_LINES)));
+  const workerQualityValidationStepTimeoutMs = Math.max(1000, asInt(parseIntEnv("WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS") ?? workerNode.quality_validation_step_timeout_ms, DEFAULT_WORKERPALS_QUALITY_VALIDATION_STEP_TIMEOUT_MS));
+  const workerQualityCriticTimeoutMs = Math.max(1000, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS") ?? workerNode.quality_critic_timeout_ms, DEFAULT_WORKERPALS_QUALITY_CRITIC_TIMEOUT_MS));
+  const workerQualitySoftPassOnExhausted = parseBoolEnv("WORKERPALS_QUALITY_SOFT_PASS_ON_EXHAUSTED") ?? asBoolean(workerNode.quality_soft_pass_on_exhausted, true);
+  const workerQualityCriticMinScore = (() => {
+    const configThresholdRaw = workerNode.quality_critic_min_score == null ? "" : String(workerNode.quality_critic_min_score);
+    const raw = firstNonEmpty(process.env.WORKERPALS_QUALITY_CRITIC_MIN_SCORE, configThresholdRaw, String(DEFAULT_WORKERPALS_QUALITY_CRITIC_MIN_SCORE));
+    const parsed = Number.parseFloat(raw);
+    if (!Number.isFinite(parsed))
+      return DEFAULT_WORKERPALS_QUALITY_CRITIC_MIN_SCORE;
+    return Math.max(0, Math.min(10, parsed));
+  })();
+  const workerQualityCriticMaxDiffChars = Math.max(256, Math.min(524288, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS") ?? workerNode.quality_critic_max_diff_chars, DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_DIFF_CHARS)));
+  const workerQualityCriticMaxValidationOutputChars = Math.max(256, Math.min(524288, asInt(parseIntEnv("WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS") ?? workerNode.quality_critic_max_validation_output_chars, DEFAULT_WORKERPALS_QUALITY_CRITIC_MAX_VALIDATION_OUTPUT_CHARS)));
+  const workerExecutorResultPrefix = (() => {
+    if (process.env.WORKERPALS_EXECUTOR_RESULT_PREFIX !== undefined) {
+      const raw = process.env.WORKERPALS_EXECUTOR_RESULT_PREFIX;
+      if (typeof raw === "string" && raw.length > 0)
+        return raw;
+    }
+    if (Object.prototype.hasOwnProperty.call(workerNode, "executor_result_prefix") && typeof workerNode.executor_result_prefix === "string" && workerNode.executor_result_prefix.length > 0) {
+      return workerNode.executor_result_prefix;
+    }
+    return DEFAULT_WORKERPALS_EXECUTOR_RESULT_PREFIX;
+  })();
+  const workerOpenHandsStuckGuardEnabled = parseBoolEnv("WORKERPALS_OPENHANDS_STUCK_GUARD_ENABLED") ?? asBoolean(workerNode.openhands_stuck_guard_enabled, true);
+  const workerOpenHandsStuckGuardExploreLimit = Math.max(6, asInt(parseIntEnv("WORKERPALS_OPENHANDS_STUCK_GUARD_EXPLORE_LIMIT") ?? workerNode.openhands_stuck_guard_explore_limit, 18));
+  const workerOpenHandsStuckGuardMinElapsedMs = Math.max(60000, asInt(parseIntEnv("WORKERPALS_OPENHANDS_STUCK_GUARD_MIN_ELAPSED_MS") ?? workerNode.openhands_stuck_guard_min_elapsed_ms, 180000));
+  const workerOpenHandsStuckGuardBroadScanLimit = Math.max(1, asInt(parseIntEnv("WORKERPALS_OPENHANDS_STUCK_GUARD_BROAD_SCAN_LIMIT") ?? workerNode.openhands_stuck_guard_broad_scan_limit, 2));
+  const workerOpenHandsStuckGuardNoProgressMaxMs = Math.max(60000, asInt(parseIntEnv("WORKERPALS_OPENHANDS_STUCK_GUARD_NO_PROGRESS_MAX_MS") ?? workerNode.openhands_stuck_guard_no_progress_max_ms, 300000));
+  const workerOpenHandsAutoSteerEnabled = parseBoolEnv("WORKERPALS_OPENHANDS_AUTO_STEER_ENABLED") ?? asBoolean(workerOpenHandsNode.auto_steer_enabled, true);
+  const workerOpenHandsAutoSteerInitialDelaySec = Math.max(0, Math.min(600, asInt(parseIntEnv("WORKERPALS_OPENHANDS_AUTO_STEER_INITIAL_DELAY_SEC") ?? workerOpenHandsNode.auto_steer_initial_delay_sec, 90)));
+  const workerOpenHandsAutoSteerIntervalSec = Math.max(15, Math.min(600, asInt(parseIntEnv("WORKERPALS_OPENHANDS_AUTO_STEER_INTERVAL_SEC") ?? workerOpenHandsNode.auto_steer_interval_sec, 60)));
+  const workerOpenHandsAutoSteerMaxNudges = Math.max(0, Math.min(120, asInt(parseIntEnv("WORKERPALS_OPENHANDS_AUTO_STEER_MAX_NUDGES") ?? workerOpenHandsNode.auto_steer_max_nudges, 30)));
+  const workerRequirePush = parseBoolEnv("WORKERPALS_REQUIRE_PUSH") ?? asBoolean(workerNode.require_push, false);
+  const workerPushAgentBranchEnv = parseBoolEnv("WORKERPALS_PUSH_AGENT_BRANCH");
+  const workerPushAgentBranch = workerRequirePush || (workerPushAgentBranchEnv ?? asBoolean(workerNode.push_agent_branch, false));
+  const workerSkipDockerSelfCheck = parseBoolEnv("WORKERPALS_SKIP_DOCKER_SELF_CHECK") ?? asBoolean(workerNode.skip_docker_self_check, false);
+  const workerDockerAgentStartupTimeoutMs = Math.max(1e4, Math.min(180000, asInt(parseIntEnv("WORKERPALS_DOCKER_AGENT_STARTUP_TIMEOUT_MS") ?? workerNode.docker_agent_startup_timeout_ms, 45000)));
+  const workerDockerWarmMaxAttempts = Math.max(1, Math.min(5, asInt(parseIntEnv("WORKERPALS_DOCKER_WARM_MAX_ATTEMPTS") ?? workerNode.docker_warm_max_attempts, 3)));
+  const workerDockerWarmRetryBackoffMs = Math.max(250, Math.min(60000, asInt(parseIntEnv("WORKERPALS_DOCKER_WARM_RETRY_BACKOFF_MS") ?? workerNode.docker_warm_retry_backoff_ms, 2000)));
+  const workerDockerJobMaxAttempts = Math.max(1, Math.min(3, asInt(parseIntEnv("WORKERPALS_DOCKER_JOB_MAX_ATTEMPTS") ?? workerNode.docker_job_max_attempts, 2)));
+  const workerDockerJobRetryBackoffMs = Math.max(250, Math.min(60000, asInt(parseIntEnv("WORKERPALS_DOCKER_JOB_RETRY_BACKOFF_MS") ?? workerNode.docker_job_retry_backoff_ms, 3000)));
+  const workerDockerWarmMemoryMb = Math.max(512, Math.min(32768, asInt(parseIntEnv("WORKERPALS_DOCKER_WARM_MEMORY_MB") ?? workerNode.docker_warm_memory_mb, 2048)));
+  const workerDockerWarmCpus = Math.max(1, Math.min(16, asInt(parseIntEnv("WORKERPALS_DOCKER_WARM_CPUS") ?? workerNode.docker_warm_cpus, 2)));
+  const workerLlm = resolveLlmConfig(workerNode, "WORKERPALS", {
+    backend: "lmstudio",
+    endpoint: "http://127.0.0.1:1234",
+    model: "local-model",
+    sessionId: "workerpals-dev"
+  }, sessionId);
+  const scmNode = getObject(merged, "source_control_manager");
+  const scmRepoPath = resolvePathFromRoot(projectRoot, firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REPO_PATH, asString(scmNode.repo_path, ".worktrees/source_control_manager"), ".worktrees/source_control_manager"));
+  const scmRemote = asString(process.env.SOURCE_CONTROL_MANAGER_REMOTE ?? scmNode.remote, "origin");
+  const scmMainBranch = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_MAIN_BRANCH, process.env.PUSHPALS_INTEGRATION_BRANCH, asString(scmNode.pushpals_branch, "main_agents"), "main_agents");
+  const scmBaseBranch = firstNonEmpty(process.env.PUSHPALS_INTEGRATION_BASE_BRANCH, asString(scmNode.base_branch, "main"), "main");
+  const scmBranchPrefix = asString(process.env.SOURCE_CONTROL_MANAGER_BRANCH_PREFIX ?? scmNode.branch_prefix, "agent/");
+  const scmPollIntervalSeconds = Math.max(1, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_POLL_INTERVAL_SECONDS") ?? scmNode.poll_interval_seconds, 10));
+  const scmChecks = asCheckArray(scmNode.checks);
+  const scmStateDir = resolvePathFromRoot(projectRoot, firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_STATE_DIR, asString(scmNode.state_dir, join(dataDir, "source_control_manager")), join(dataDir, "source_control_manager")));
+  const scmPort = Math.max(1, Math.min(65535, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_PORT") ?? scmNode.port, 3002)));
+  const scmDeleteAfterMerge = parseBoolEnv("SOURCE_CONTROL_MANAGER_DELETE_AFTER_MERGE") ?? asBoolean(scmNode.delete_after_merge, false);
+  const scmMaxAttempts = Math.max(1, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_MAX_ATTEMPTS") ?? scmNode.max_attempts, 3));
+  const scmMergeStrategyRaw = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_MERGE_STRATEGY, asString(scmNode.merge_strategy, "cherry-pick"), "cherry-pick");
+  const scmMergeStrategy = scmMergeStrategyRaw === "no-ff" || scmMergeStrategyRaw === "ff-only" ? scmMergeStrategyRaw : "cherry-pick";
+  let scmPushMainAfterMerge = asBoolean(scmNode.push_main_after_merge, true);
+  const scmPushMainAfterMergeEnv = parseBoolEnv("SOURCE_CONTROL_MANAGER_PUSH_MAIN_AFTER_MERGE");
+  if (scmPushMainAfterMergeEnv != null)
+    scmPushMainAfterMerge = scmPushMainAfterMergeEnv;
+  const scmNoPushEnv = parseBoolEnv("SOURCE_CONTROL_MANAGER_NO_PUSH");
+  if (scmNoPushEnv != null)
+    scmPushMainAfterMerge = !scmNoPushEnv;
+  let scmOpenPrAfterPush = asBoolean(scmNode.open_pr_after_push, true);
+  const scmOpenPrAfterPushEnv = parseBoolEnv("SOURCE_CONTROL_MANAGER_OPEN_PR_AFTER_PUSH");
+  if (scmOpenPrAfterPushEnv != null)
+    scmOpenPrAfterPush = scmOpenPrAfterPushEnv;
+  const scmDisableAutoPrEnv = parseBoolEnv("SOURCE_CONTROL_MANAGER_DISABLE_AUTO_PR");
+  if (scmDisableAutoPrEnv != null)
+    scmOpenPrAfterPush = !scmDisableAutoPrEnv;
+  const scmPrBaseBranch = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_PR_BASE_BRANCH, asString(scmNode.pr_base_branch, scmBaseBranch), scmBaseBranch);
+  const scmPrTitle = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_PR_TITLE, asString(scmNode.pr_title, ""));
+  const scmPrBody = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_PR_BODY, asString(scmNode.pr_body, ""));
+  const scmPrDraft = parseBoolEnv("SOURCE_CONTROL_MANAGER_PR_DRAFT") ?? asBoolean(scmNode.pr_draft, false);
+  const scmStatusHeartbeatMs = Math.max(0, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_STATUS_HEARTBEAT_MS") ?? globalStatusHeartbeatMs ?? scmNode.status_heartbeat_ms, 120000));
+  const scmSkipCleanCheck = parseBoolEnv("SOURCE_CONTROL_MANAGER_SKIP_CLEAN_CHECK") ?? asBoolean(scmNode.skip_clean_check, false);
+  const scmAutoCreateMainBranch = parseBoolEnv("SOURCE_CONTROL_MANAGER_AUTO_CREATE_MAIN_BRANCH") ?? asBoolean(scmNode.auto_create_main_branch, false);
+  const scmReviewAgentNode = getObject(scmNode, "review_agent");
+  const scmReviewAgentEnabled = parseBoolEnv("SOURCE_CONTROL_MANAGER_REVIEW_AGENT_ENABLED") ?? asBoolean(scmReviewAgentNode.enabled, false);
+  const scmReviewAgentPollIntervalMs = Math.max(5000, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_REVIEW_AGENT_POLL_INTERVAL_MS") ?? scmReviewAgentNode.poll_interval_ms, 60000));
+  const scmReviewAgentReviewerMdPath = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_REVIEWER_MD_PATH, asString(scmReviewAgentNode.reviewer_md_path, "prompts/review_agent/reviewer.md"), "prompts/review_agent/reviewer.md");
+  const scmReviewAgentPassThreshold = (() => {
+    const configThresholdRaw = scmReviewAgentNode.pass_threshold == null ? "" : String(scmReviewAgentNode.pass_threshold);
+    const raw = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_PASS_THRESHOLD, configThresholdRaw, "9.5");
+    const parsed = Number.parseFloat(raw);
+    return Number.isFinite(parsed) ? Math.max(1, Math.min(10, parsed)) : 9.5;
+  })();
+  const scmReviewAgentMaxPrCommentsBeforeGiveUp = Math.max(1, Math.min(100, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_REVIEW_AGENT_MAX_PR_COMMENTS_BEFORE_GIVE_UP") ?? scmReviewAgentNode.max_pr_comments_before_give_up, 10)));
+  const scmReviewAgentMergeMethodRaw = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_MERGE_METHOD, asString(scmReviewAgentNode.merge_method, "squash"), "squash").toLowerCase();
+  const scmReviewAgentMergeMethod = scmReviewAgentMergeMethodRaw === "merge" || scmReviewAgentMergeMethodRaw === "rebase" ? scmReviewAgentMergeMethodRaw : "squash";
+  const scmReviewAgentCodexBin = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_CODEX_BIN, asString(scmReviewAgentNode.codex_bin, "bun x --yes @openai/codex"), "bun x --yes @openai/codex");
+  const scmReviewAgentCodexAuthMode = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_CODEX_AUTH_MODE, asString(scmReviewAgentNode.codex_auth_mode, "chatgpt"), "chatgpt");
+  const scmReviewAgentCodexHomeDir = firstNonEmpty(process.env.SOURCE_CONTROL_MANAGER_REVIEW_AGENT_CODEX_HOME_DIR, asString(scmReviewAgentNode.codex_home_dir, ""));
+  const scmReviewAgentCodexTimeoutMs = Math.max(30000, asInt(parseIntEnv("SOURCE_CONTROL_MANAGER_REVIEW_AGENT_CODEX_TIMEOUT_MS") ?? scmReviewAgentNode.codex_timeout_ms, 300000));
+  const startupNode = getObject(merged, "startup");
+  const startupWorkerImageRebuild = normalizeWorkerImageRebuildMode(firstNonEmpty(process.env.PUSHPALS_WORKER_IMAGE_REBUILD, asString(startupNode.worker_image_rebuild, "auto"), "auto"));
+  const startupLogConfigOnStart = parseBoolEnv("PUSHPALS_LOG_CONFIG_ON_START") ?? asBoolean(startupNode.log_config_on_start, true);
+  const startupSyncIntegrationWithMain = parseBoolEnv("PUSHPALS_SYNC_INTEGRATION_WITH_MAIN") ?? asBoolean(startupNode.sync_integration_with_main, true);
+  const startupSkipLlmPreflight = parseBoolEnv("PUSHPALS_SKIP_LLM_PREFLIGHT") ?? asBoolean(startupNode.skip_llm_preflight, false);
+  const startupAutoStartLmStudio = parseBoolEnv("PUSHPALS_AUTO_START_LMSTUDIO") ?? asBoolean(startupNode.auto_start_lmstudio, true);
+  const startupLmStudioReadyTimeoutMs = Math.max(1000, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_READY_TIMEOUT_MS") ?? startupNode.lmstudio_ready_timeout_ms, 120000));
+  const startupLmStudioCli = firstNonEmpty(process.env.PUSHPALS_LMSTUDIO_CLI, asString(startupNode.lmstudio_cli, "lms"), "lms");
+  const startupLmStudioPort = Math.max(1, Math.min(65535, asInt(parseIntEnv("PUSHPALS_LMSTUDIO_PORT") ?? startupNode.lmstudio_port, 1234)));
+  const startupLmStudioStartArgs = firstNonEmpty(process.env.PUSHPALS_LMSTUDIO_START_ARGS, asString(startupNode.lmstudio_start_args, ""));
+  const startupWarmup = parseBoolEnv("PUSHPALS_STARTUP_WARMUP") ?? asBoolean(startupNode.startup_warmup, true);
+  const startupWarmupTimeoutMs = Math.max(15000, asInt(parseIntEnv("PUSHPALS_STARTUP_WARMUP_TIMEOUT_MS") ?? startupNode.startup_warmup_timeout_ms, 120000));
+  const startupWarmupPollMs = Math.max(250, Math.min(5000, asInt(parseIntEnv("PUSHPALS_STARTUP_WARMUP_POLL_MS") ?? startupNode.startup_warmup_poll_ms, 1000)));
+  const startupAllowExternalClean = parseBoolEnv("PUSHPALS_ALLOW_EXTERNAL_CLEAN") ?? asBoolean(startupNode.allow_external_clean, false);
+  const startupPortPreflight = parseBoolEnv("PUSHPALS_STARTUP_PORT_PREFLIGHT") ?? asBoolean(startupNode.port_preflight, true);
+  const startupPortConflictPolicy = normalizeStartupPortConflictPolicy(firstNonEmpty(process.env.PUSHPALS_STARTUP_PORT_CONFLICT_POLICY, asString(startupNode.port_conflict_policy, "terminate_pushpals"), "terminate_pushpals"));
+  const clientNode = getObject(merged, "client");
+  const authToken = firstNonEmpty(process.env.PUSHPALS_AUTH_TOKEN) || null;
+  const gitToken = firstNonEmpty(process.env.PUSHPALS_GIT_TOKEN, process.env.GITHUB_TOKEN, process.env.GH_TOKEN) || null;
+  const config = {
+    projectRoot,
+    configDir,
+    profile,
+    sessionId,
+    authToken,
+    gitToken,
+    llm: {
+      lmstudio: {
+        contextWindow: lmStudioContextWindow,
+        minOutputTokens: lmStudioMinOutputTokens,
+        tokenSafetyMargin: lmStudioTokenSafetyMargin,
+        batchTailMessages: lmStudioBatchTailMessages,
+        batchChunkTokens: lmStudioBatchChunkTokens,
+        batchMemoryChars: lmStudioBatchMemoryChars
+      }
+    },
+    paths: {
+      dataDir,
+      sharedDbPath,
+      remotebuddyDbPath
+    },
+    server: {
+      url: serverUrl,
+      host: serverHost,
+      port: serverPort,
+      debugHttp,
+      staleClaimTtlMs,
+      staleClaimSweepIntervalMs
+    },
+    localbuddy: {
+      port: localPort,
+      statusHeartbeatMs: localStatusHeartbeatMs,
+      llm: localLlm
+    },
+    remotebuddy: {
+      pollMs: remotePollMs,
+      statusHeartbeatMs: remoteStatusHeartbeatMs,
+      workerpalOnlineTtlMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_WORKERPAL_ONLINE_TTL_MS") ?? remoteNode.workerpal_online_ttl_ms, 15000)),
+      waitForWorkerpalMs: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_WAIT_FOR_WORKERPAL_MS") ?? remoteNode.wait_for_workerpal_ms, 15000)),
+      autoSpawnWorkerpals: parseBoolEnv("REMOTEBUDDY_AUTO_SPAWN_WORKERPALS") ?? asBoolean(remoteNode.auto_spawn_workerpals, true),
+      maxWorkerpals: Math.max(1, asInt(remoteNode.max_workerpals, 20)),
+      workerpalStartupTimeoutMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_WORKERPAL_STARTUP_TIMEOUT_MS") ?? remoteNode.workerpal_startup_timeout_ms, 1e4)),
+      workerpalDocker: parseBoolEnv("REMOTEBUDDY_WORKERPAL_DOCKER") ?? asBoolean(remoteNode.workerpal_docker, true),
+      workerpalRequireDocker: parseBoolEnv("REMOTEBUDDY_WORKERPAL_REQUIRE_DOCKER") ?? asBoolean(remoteNode.workerpal_require_docker, true),
+      workerpalImage: firstNonEmpty(process.env.REMOTEBUDDY_WORKERPAL_IMAGE, asString(remoteNode.workerpal_image, "")) || null,
+      workerpalPollMs: asIntOrNull(parseIntEnv("REMOTEBUDDY_WORKERPAL_POLL_MS")) ?? asIntOrNull(remoteNode.workerpal_poll_ms),
+      workerpalHeartbeatMs: asIntOrNull(parseIntEnv("REMOTEBUDDY_WORKERPAL_HEARTBEAT_MS")) ?? asIntOrNull(remoteNode.workerpal_heartbeat_ms),
+      workerpalLabels: firstNonEmpty(process.env.REMOTEBUDDY_WORKERPAL_LABELS) ? firstNonEmpty(process.env.REMOTEBUDDY_WORKERPAL_LABELS).split(",").map((value) => value.trim()).filter(Boolean) : asStringArray(remoteNode.workerpal_labels),
+      executionBudgetInteractiveMs: Math.max(60000, asInt(parseIntEnv("REMOTEBUDDY_EXECUTION_BUDGET_INTERACTIVE_MS") ?? remoteNode.execution_budget_interactive_ms, 300000)),
+      executionBudgetNormalMs: Math.max(120000, asInt(parseIntEnv("REMOTEBUDDY_EXECUTION_BUDGET_NORMAL_MS") ?? remoteNode.execution_budget_normal_ms, 900000)),
+      executionBudgetBackgroundMs: Math.max(180000, asInt(parseIntEnv("REMOTEBUDDY_EXECUTION_BUDGET_BACKGROUND_MS") ?? remoteNode.execution_budget_background_ms, 1800000)),
+      finalizationBudgetMs: Math.max(30000, asInt(parseIntEnv("REMOTEBUDDY_FINALIZATION_BUDGET_MS") ?? remoteNode.finalization_budget_ms, 120000)),
+      crashRestartEnabled: parseBoolEnv("REMOTEBUDDY_CRASH_RESTART_ENABLED") ?? asBoolean(remoteNode.crash_restart_enabled, true),
+      crashRestartMaxRestarts: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_CRASH_RESTART_MAX_RESTARTS") ?? remoteNode.crash_restart_max_restarts, 3)),
+      crashRestartBackoffMs: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_CRASH_RESTART_BACKOFF_MS") ?? remoteNode.crash_restart_backoff_ms, 3000)),
+      memory: {
+        enabled: remoteMemoryEnabled,
+        includeCrossSession: remoteMemoryIncludeCrossSession,
+        maxRecallItems: remoteMemoryMaxRecallItems,
+        maxRecallChars: remoteMemoryMaxRecallChars,
+        maxSummaryChars: remoteMemoryMaxSummaryChars,
+        retentionDays: remoteMemoryRetentionDays
+      },
+      autonomy: {
+        enabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_ENABLED") ?? asBoolean(remoteAutonomyNode.enabled, false),
+        killSwitchEnabled: parseBoolEnv("REMOTEBUDDY_AUTONOMY_KILL_SWITCH_ENABLED") ?? asBoolean(remoteAutonomyNode.kill_switch_enabled, false),
+        tickIntervalMs: Math.max(5000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_TICK_INTERVAL_MS") ?? remoteAutonomyNode.tick_interval_ms, 120000)),
+        heartbeatLogMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_HEARTBEAT_LOG_MS") ?? remoteAutonomyNode.heartbeat_log_ms, 30000)),
+        visionContextMaxChars: Math.max(1000, Math.min(1e6, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_VISION_CONTEXT_MAX_CHARS") ?? remoteAutonomyNode.vision_context_max_chars, 65536))),
+        ideationBudgetMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_IDEATION_BUDGET_MS") ?? remoteAutonomyNode.ideation_budget_ms, 20000)),
+        llmTimeoutMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_LLM_TIMEOUT_MS") ?? remoteAutonomyNode.llm_timeout_ms, 12000)),
+        allowDirtyWorktree: parseBoolEnv("REMOTEBUDDY_AUTONOMY_ALLOW_DIRTY_WORKTREE") ?? asBoolean(remoteAutonomyNode.allow_dirty_worktree, false),
+        ideationMaxCandidates: Math.max(1, Math.min(100, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_IDEATION_MAX_CANDIDATES") ?? remoteAutonomyNode.ideation_max_candidates, 20))),
+        topK: Math.max(1, Math.min(20, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_TOP_K") ?? remoteAutonomyNode.top_k, 3))),
+        exploreRate: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_EXPLORE_RATE, asString(remoteAutonomyNode.explore_rate, "0.3"), "0.3")));
+          return Number.isFinite(parsed) ? parsed : 0.3;
+        })())),
+        minConfidence: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_MIN_CONFIDENCE, asString(remoteAutonomyNode.min_confidence, "0.65"), "0.65")));
+          return Number.isFinite(parsed) ? parsed : 0.65;
+        })())),
+        maxConcurrentObjectives: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_MAX_CONCURRENT_OBJECTIVES") ?? remoteAutonomyNode.max_concurrent_objectives, 2)),
+        maxDispatchPerHour: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_MAX_DISPATCH_PER_HOUR") ?? remoteAutonomyNode.max_dispatch_per_hour, 6)),
+        maxDispatchPerHourByType: remoteAutonomyDispatchByType,
+        maxDispatchPerHourByComponent: remoteAutonomyDispatchByComponent,
+        maxTokenUsagePerHour: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_MAX_TOKEN_USAGE_PER_HOUR") ?? remoteAutonomyNode.max_token_usage_per_hour, 120000)),
+        maxRuntimeMsPerHour: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_MAX_RUNTIME_MS_PER_HOUR") ?? remoteAutonomyNode.max_runtime_ms_per_hour, 5400000)),
+        cooldownFailStreakThreshold: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_COOLDOWN_FAIL_STREAK_THRESHOLD") ?? remoteAutonomyNode.cooldown_fail_streak_threshold, 2)),
+        cooldownMs: Math.max(1000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_COOLDOWN_MS") ?? remoteAutonomyNode.cooldown_ms, 1800000)),
+        staleObjectiveTtlMs: Math.max(60000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_STALE_OBJECTIVE_TTL_MS") ?? remoteAutonomyNode.stale_objective_ttl_ms, 2700000)),
+        staleObjectiveSweepIntervalMs: Math.max(5000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_STALE_OBJECTIVE_SWEEP_INTERVAL_MS") ?? remoteAutonomyNode.stale_objective_sweep_interval_ms, 60000)),
+        autoFreezeFailStreakThreshold: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_AUTO_FREEZE_FAIL_STREAK_THRESHOLD") ?? remoteAutonomyNode.auto_freeze_fail_streak_threshold, 3)),
+        autoFreezeDurationMs: Math.max(60000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_AUTO_FREEZE_DURATION_MS") ?? remoteAutonomyNode.auto_freeze_duration_ms, 1800000)),
+        evaluatorWindowHours: Math.max(1, Math.min(168, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_EVALUATOR_WINDOW_HOURS") ?? remoteAutonomyNode.evaluator_window_hours, 24))),
+        evaluatorMinSamples: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_EVALUATOR_MIN_SAMPLES") ?? remoteAutonomyNode.evaluator_min_samples, 6)),
+        evaluatorMinSuccessRate: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_EVALUATOR_MIN_SUCCESS_RATE, asString(remoteAutonomyNode.evaluator_min_success_rate, "0.45"), "0.45")));
+          return Number.isFinite(parsed) ? parsed : 0.45;
+        })())),
+        evaluatorMaxRegretRate: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_EVALUATOR_MAX_REGRET_RATE, asString(remoteAutonomyNode.evaluator_max_regret_rate, "0.35"), "0.35")));
+          return Number.isFinite(parsed) ? parsed : 0.35;
+        })())),
+        evaluatorRunIntervalMs: Math.max(1e4, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_EVALUATOR_RUN_INTERVAL_MS") ?? remoteAutonomyNode.evaluator_run_interval_ms, 120000)),
+        alertQueuePendingThreshold: Math.max(1, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_ALERT_QUEUE_PENDING_THRESHOLD") ?? remoteAutonomyNode.alert_queue_pending_threshold, 20)),
+        alertJobFailureRateThreshold: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_ALERT_JOB_FAILURE_RATE_THRESHOLD, asString(remoteAutonomyNode.alert_job_failure_rate_threshold, "0.3"), "0.3")));
+          return Number.isFinite(parsed) ? parsed : 0.3;
+        })())),
+        alertAutonomyFailureRateThreshold: Math.max(0, Math.min(1, (() => {
+          const parsed = Number.parseFloat(String(firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_ALERT_AUTONOMY_FAILURE_RATE_THRESHOLD, asString(remoteAutonomyNode.alert_autonomy_failure_rate_threshold, "0.45"), "0.45")));
+          return Number.isFinite(parsed) ? parsed : 0.45;
+        })())),
+        allowReadAnywhere: parseBoolEnv("REMOTEBUDDY_AUTONOMY_ALLOW_READ_ANYWHERE") ?? asBoolean(remoteAutonomyNode.allow_read_anywhere, false),
+        prFeedbackCommentRows: Math.max(1, Math.min(200, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_PR_FEEDBACK_COMMENT_ROWS") ?? remoteAutonomyNode.pr_feedback_comment_rows, 16))),
+        prFeedbackCommentChars: Math.max(32, Math.min(20000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_PR_FEEDBACK_COMMENT_CHARS") ?? remoteAutonomyNode.pr_feedback_comment_chars, 600))),
+        prFeedbackSummaryChars: Math.max(32, Math.min(20000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_PR_FEEDBACK_SUMMARY_CHARS") ?? remoteAutonomyNode.pr_feedback_summary_chars, 600))),
+        questionTtlMs: Math.max(60000, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_QUESTION_TTL_MS") ?? remoteAutonomyNode.question_ttl_ms, 259200000)),
+        policyVersion: firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_POLICY_VERSION, asString(remoteAutonomyNode.policy_version, "policy-v3.3"), "policy-v3.3"),
+        impactModelVersion: firstNonEmpty(process.env.REMOTEBUDDY_AUTONOMY_IMPACT_MODEL_VERSION, asString(remoteAutonomyNode.impact_model_version, "impact-v1"), "impact-v1"),
+        replay: {
+          storePromptPayloads: parseBoolEnv("REMOTEBUDDY_AUTONOMY_REPLAY_STORE_PROMPT_PAYLOADS") ?? asBoolean(remoteAutonomyReplayNode.store_prompt_payloads, false),
+          maxRunsWithPayloads: Math.max(0, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_REPLAY_MAX_RUNS_WITH_PAYLOADS") ?? remoteAutonomyReplayNode.max_runs_with_payloads, 50)),
+          maxPayloadBytes: Math.max(1024, asInt(parseIntEnv("REMOTEBUDDY_AUTONOMY_REPLAY_MAX_PAYLOAD_BYTES") ?? remoteAutonomyReplayNode.max_payload_bytes, 262144))
+        }
+      },
+      llm: remoteLlm
+    },
+    workerpals: {
+      pollMs: workerPollMs,
+      heartbeatMs: workerHeartbeatMs,
+      executor: workerExecutor,
+      openhandsPython: workerOpenHandsPython,
+      openhandsTimeoutMs: workerOpenHandsTimeoutMs,
+      miniswePython: workerMiniswePython,
+      minisweTimeoutMs: workerMinisweTimeoutMs,
+      openaiCodexPython: workerOpenAICodexPython,
+      openaiCodexTimeoutMs: workerOpenAICodexTimeoutMs,
+      openhandsStuckGuardEnabled: workerOpenHandsStuckGuardEnabled,
+      openhandsStuckGuardExploreLimit: workerOpenHandsStuckGuardExploreLimit,
+      openhandsStuckGuardMinElapsedMs: workerOpenHandsStuckGuardMinElapsedMs,
+      openhandsStuckGuardBroadScanLimit: workerOpenHandsStuckGuardBroadScanLimit,
+      openhandsStuckGuardNoProgressMaxMs: workerOpenHandsStuckGuardNoProgressMaxMs,
+      openhandsAutoSteerEnabled: workerOpenHandsAutoSteerEnabled,
+      openhandsAutoSteerInitialDelaySec: workerOpenHandsAutoSteerInitialDelaySec,
+      openhandsAutoSteerIntervalSec: workerOpenHandsAutoSteerIntervalSec,
+      openhandsAutoSteerMaxNudges: workerOpenHandsAutoSteerMaxNudges,
+      requirePush: workerRequirePush,
+      pushAgentBranch: workerPushAgentBranch,
+      requireDocker: parseBoolEnv("WORKERPALS_REQUIRE_DOCKER") ?? asBoolean(workerNode.require_docker, false),
+      skipDockerSelfCheck: workerSkipDockerSelfCheck,
+      dockerImage: firstNonEmpty(process.env.WORKERPALS_DOCKER_IMAGE, asString(workerNode.docker_image, "pushpals-worker-sandbox:latest"), "pushpals-worker-sandbox:latest"),
+      dockerTimeoutMs: Math.max(1e4, asInt(parseIntEnv("WORKERPALS_DOCKER_TIMEOUT_MS") ?? workerNode.docker_timeout_ms, 7260000)),
+      dockerIdleTimeoutMs: Math.max(0, asInt(parseIntEnv("WORKERPALS_DOCKER_IDLE_TIMEOUT_MS") ?? workerNode.docker_idle_timeout_ms, 600000)),
+      dockerAgentStartupTimeoutMs: workerDockerAgentStartupTimeoutMs,
+      dockerWarmMaxAttempts: workerDockerWarmMaxAttempts,
+      dockerWarmRetryBackoffMs: workerDockerWarmRetryBackoffMs,
+      dockerJobMaxAttempts: workerDockerJobMaxAttempts,
+      dockerJobRetryBackoffMs: workerDockerJobRetryBackoffMs,
+      dockerWarmMemoryMb: workerDockerWarmMemoryMb,
+      dockerWarmCpus: workerDockerWarmCpus,
+      fileModifyingJobs: workerFileModifyingJobs,
+      outputMaxChars: workerOutputMaxChars,
+      outputMaxLines: workerOutputMaxLines,
+      outputMaxHeadLines: workerOutputMaxHeadLines,
+      qualityMaxAutoRevisions: workerQualityMaxAutoRevisions,
+      qualityValidationStepTimeoutMs: workerQualityValidationStepTimeoutMs,
+      qualityCriticTimeoutMs: workerQualityCriticTimeoutMs,
+      qualitySoftPassOnExhausted: workerQualitySoftPassOnExhausted,
+      qualityCriticMinScore: workerQualityCriticMinScore,
+      qualityCriticMaxDiffChars: workerQualityCriticMaxDiffChars,
+      qualityCriticMaxValidationOutputChars: workerQualityCriticMaxValidationOutputChars,
+      executorResultPrefix: workerExecutorResultPrefix,
+      dockerNetworkMode: asString(process.env.WORKERPALS_DOCKER_NETWORK_MODE ?? workerNode.docker_network_mode, "bridge"),
+      baseRef: firstNonEmpty(process.env.WORKERPALS_BASE_REF, asString(workerNode.base_ref, "origin/main_agents"), "origin/main_agents"),
+      labels: firstNonEmpty(process.env.WORKERPALS_LABELS) ? firstNonEmpty(process.env.WORKERPALS_LABELS).split(",").map((value) => value.trim()).filter(Boolean) : asStringArray(workerNode.labels),
+      failureCooldownMs: Math.max(0, asInt(parseIntEnv("WORKERPALS_FAILURE_COOLDOWN_MS") ?? parseIntEnv("WORKERPALS_DOCKER_FAILURE_COOLDOWN_MS") ?? workerNode.failure_cooldown_ms, 20000)),
+      llm: workerLlm
+    },
+    sourceControlManager: {
+      repoPath: scmRepoPath,
+      remote: scmRemote,
+      mainBranch: scmMainBranch,
+      baseBranch: scmBaseBranch,
+      branchPrefix: scmBranchPrefix,
+      pollIntervalSeconds: scmPollIntervalSeconds,
+      checks: scmChecks,
+      stateDir: scmStateDir,
+      port: scmPort,
+      deleteAfterMerge: scmDeleteAfterMerge,
+      maxAttempts: scmMaxAttempts,
+      mergeStrategy: scmMergeStrategy,
+      pushMainAfterMerge: scmPushMainAfterMerge,
+      openPrAfterPush: scmOpenPrAfterPush,
+      prBaseBranch: scmPrBaseBranch,
+      prTitle: scmPrTitle || null,
+      prBody: scmPrBody || null,
+      prDraft: scmPrDraft,
+      statusHeartbeatMs: scmStatusHeartbeatMs,
+      skipCleanCheck: scmSkipCleanCheck,
+      autoCreateMainBranch: scmAutoCreateMainBranch,
+      reviewAgent: {
+        enabled: scmReviewAgentEnabled,
+        pollIntervalMs: scmReviewAgentPollIntervalMs,
+        reviewerMdPath: scmReviewAgentReviewerMdPath,
+        passThreshold: scmReviewAgentPassThreshold,
+        maxPrCommentsBeforeGiveUp: scmReviewAgentMaxPrCommentsBeforeGiveUp,
+        mergeMethod: scmReviewAgentMergeMethod,
+        codexBin: scmReviewAgentCodexBin,
+        codexAuthMode: scmReviewAgentCodexAuthMode,
+        codexHomeDir: scmReviewAgentCodexHomeDir,
+        codexTimeoutMs: scmReviewAgentCodexTimeoutMs
+      }
+    },
+    startup: {
+      workerImageRebuild: startupWorkerImageRebuild,
+      logConfigOnStart: startupLogConfigOnStart,
+      syncIntegrationWithMain: startupSyncIntegrationWithMain,
+      skipLlmPreflight: startupSkipLlmPreflight,
+      autoStartLmStudio: startupAutoStartLmStudio,
+      lmStudioReadyTimeoutMs: startupLmStudioReadyTimeoutMs,
+      lmStudioCli: startupLmStudioCli,
+      lmStudioPort: startupLmStudioPort,
+      lmStudioStartArgs: startupLmStudioStartArgs,
+      startupWarmup,
+      startupWarmupTimeoutMs,
+      startupWarmupPollMs,
+      allowExternalClean: startupAllowExternalClean,
+      portPreflight: startupPortPreflight,
+      portConflictPolicy: startupPortConflictPolicy
+    },
+    client: {
+      localAgentUrl: firstNonEmpty(process.env.EXPO_PUBLIC_LOCAL_AGENT_URL, asString(clientNode.local_agent_url, `http://localhost:${localPort}`), `http://localhost:${localPort}`),
+      traceTailLines: Math.max(10, asInt(parseIntEnv("EXPO_PUBLIC_PUSHPALS_TRACE_TAIL_LINES") ?? clientNode.trace_tail_lines, 100))
+    }
+  };
+  cachedConfig = config;
+  cachedConfigKey = cacheKey;
+  return config;
+}
+
+// ../../scripts/pushpals-cli.ts
+var DEFAULT_MONITOR_PORT = 8081;
+var MONITOR_SCAN_PORTS = 32;
+var HTTP_TIMEOUT_MS = 2500;
+var LOCALBUDDY_TIMEOUT_MS = 4000;
+var SSE_RECONNECT_MS = 1500;
+var stateVersion = 1;
+function printUsage() {
+  console.log("PushPals CLI");
+  console.log("");
+  console.log("Usage:");
+  console.log("  pushpals [options]");
+  console.log("");
+  console.log("Options:");
+  console.log("  --server-url <url>     Override PushPals server URL");
+  console.log("  --local-agent-url <url> Override LocalBuddy URL");
+  console.log("  --session-id <id>      Override session ID");
+  console.log("  --hub-url <url>        Override monitoring hub URL");
+  console.log("  --no-stream            Disable live session event stream");
+  console.log("  -h, --help             Show this help");
+  console.log("");
+  console.log("Chat commands:");
+  console.log("  /hub                   Print monitoring hub URL");
+  console.log("  /open                  Open monitoring hub in browser");
+  console.log("  /status                Print active endpoints");
+  console.log("  /exit, /quit           Quit CLI");
+  console.log("");
+  console.log("Notes:");
+  console.log("  - Must be run from inside a git repository.");
+  console.log("  - LocalBuddy must be running and attached to the same repo root.");
+}
+function parseArgs(argv) {
+  const options = { noStream: false };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      printUsage();
+      return null;
+    }
+    if (arg === "--no-stream") {
+      options.noStream = true;
+      continue;
+    }
+    if (arg === "--server-url") {
+      options.serverUrl = argv[++i];
+      continue;
+    }
+    if (arg === "--local-agent-url") {
+      options.localAgentUrl = argv[++i];
+      continue;
+    }
+    if (arg === "--session-id") {
+      options.sessionId = argv[++i];
+      continue;
+    }
+    if (arg === "--hub-url") {
+      options.monitoringHubUrl = argv[++i];
+      continue;
+    }
+    console.error(`[pushpals] Unknown argument: ${arg}`);
+    printUsage();
+    process.exit(2);
+  }
+  return options;
+}
+function normalizeUrl(value, fallback = "") {
+  const text = String(value ?? "").trim();
+  const selected = text || fallback;
+  return selected.replace(/\/+$/, "");
+}
+function parsePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? "").trim(), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return fallback;
+  return parsed;
+}
+function normalizePath(value) {
+  const normalized = resolve2(value).replace(/\\/g, "/").replace(/\/+$/, "");
+  if (process.platform === "win32")
+    return normalized.toLowerCase();
+  return normalized;
+}
+async function runGit(args, cwd) {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { ok: exitCode === 0, stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
+}
+async function resolveCurrentGitRepoRoot(cwd) {
+  const inside = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (!inside.ok || inside.stdout !== "true")
+    return null;
+  const root = await runGit(["rev-parse", "--show-toplevel"], cwd);
+  if (!root.ok || !root.stdout)
+    return null;
+  return resolve2(root.stdout);
+}
+async function fetchWithTimeout(url, init = {}, timeoutMs = HTTP_TIMEOUT_MS) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchJsonWithTimeout(url, init = {}, timeoutMs = HTTP_TIMEOUT_MS) {
+  try {
+    const response = await fetchWithTimeout(url, init, timeoutMs);
+    if (!response.ok)
+      return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function authHeaders(authToken) {
+  if (!authToken)
+    return {};
+  return { Authorization: `Bearer ${authToken}` };
+}
+async function probeLocalBuddy(localAgentUrl, authToken) {
+  return await fetchJsonWithTimeout(`${localAgentUrl}/healthz`, { headers: authHeaders(authToken) }, LOCALBUDDY_TIMEOUT_MS);
+}
+function readCliState(pathValue) {
+  if (!existsSync2(pathValue))
+    return {};
+  try {
+    const raw = readFileSync2(pathValue, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return {};
+    return {
+      monitoringHubUrl: typeof parsed.monitoringHubUrl === "string" ? parsed.monitoringHubUrl : undefined,
+      serverUrl: typeof parsed.serverUrl === "string" ? parsed.serverUrl : undefined,
+      localAgentUrl: typeof parsed.localAgentUrl === "string" ? parsed.localAgentUrl : undefined,
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : undefined,
+      repoRoot: typeof parsed.repoRoot === "string" ? parsed.repoRoot : undefined,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined
+    };
+  } catch {
+    return {};
+  }
+}
+function writeCliState(pathValue, state) {
+  const payload = {
+    version: stateVersion,
+    ...state,
+    updatedAt: new Date().toISOString()
+  };
+  mkdirSync(dirname(pathValue), { recursive: true });
+  writeFileSync(pathValue, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+async function looksLikeMonitoringHub(url) {
+  try {
+    const response = await fetchWithTimeout(url, {}, 700);
+    if (!response.ok)
+      return false;
+    const contentType = String(response.headers.get("content-type") ?? "").toLowerCase();
+    if (!contentType.includes("text/html"))
+      return false;
+    const text = await response.text();
+    const sample = text.slice(0, 8192).toLowerCase();
+    return sample.includes("pushpals") || sample.includes("mission control") || sample.includes("jobs & traces");
+  } catch {
+    return false;
+  }
+}
+async function resolveMonitoringHubUrl(preferredUrl, fallbackPort) {
+  const explicit = normalizeUrl(preferredUrl);
+  if (explicit)
+    return explicit;
+  const basePort = fallbackPort;
+  for (let port = basePort;port < basePort + MONITOR_SCAN_PORTS; port++) {
+    const candidate = `http://localhost:${port}`;
+    if (await looksLikeMonitoringHub(candidate))
+      return candidate;
+  }
+  return `http://localhost:${basePort}`;
+}
+async function sendMessageToLocalBuddy(localAgentUrl, text) {
+  let response;
+  try {
+    response = await fetchWithTimeout(`${localAgentUrl}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text })
+    }, 30000);
+  } catch (err) {
+    console.error(`[pushpals] Failed to reach LocalBuddy: ${String(err)}`);
+    return false;
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    console.error(`[pushpals] LocalBuddy rejected message: HTTP ${response.status} ${detail}`);
+    return false;
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    console.error("[pushpals] LocalBuddy response stream missing.");
+    return false;
+  }
+  let buffer = "";
+  const decoder = new TextDecoder;
+  let complete = false;
+  let ok = true;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const chunks = buffer.split(`
+
+`);
+    buffer = chunks.pop() ?? "";
+    for (const chunk of chunks) {
+      const dataLine = chunk.split(/\r?\n/).map((line) => line.trim()).find((line) => line.startsWith("data: "));
+      if (!dataLine)
+        continue;
+      try {
+        const payload = JSON.parse(dataLine.slice(6));
+        const type = String(payload.type ?? "").trim().toLowerCase();
+        const message = String(payload.message ?? "").trim();
+        if (type === "status" && message) {
+          console.log(`[localbuddy] ${message}`);
+        } else if (type === "error") {
+          ok = false;
+          console.log(`[localbuddy] ERROR: ${message || "Unknown failure"}`);
+        } else if (type === "complete") {
+          complete = true;
+          const requestId = payload.data && typeof payload.data.requestId === "string" ? payload.data.requestId : "";
+          if (requestId) {
+            console.log(`[localbuddy] requestId=${requestId}`);
+          } else if (message) {
+            console.log(`[localbuddy] ${message}`);
+          }
+        }
+      } catch {}
+    }
+  }
+  return ok && complete;
+}
+function formatSessionEventLine(event) {
+  const type = String(event.type ?? "").toLowerCase();
+  const from = String(event.from ?? "");
+  const payload = event.payload ?? {};
+  if (type === "message")
+    return null;
+  if (type === "assistant_message") {
+    const text = String(payload.text ?? "").trim();
+    if (!text)
+      return null;
+    return `assistant> ${text}`;
+  }
+  if (type === "task_progress") {
+    const taskId = String(payload.taskId ?? "").slice(0, 8);
+    const message = String(payload.message ?? "").trim();
+    return message ? `[task ${taskId}] ${message}` : null;
+  }
+  if (type === "task_failed") {
+    const taskId = String(payload.taskId ?? "").slice(0, 8);
+    const message = String(payload.message ?? "").trim();
+    return `[task ${taskId}] failed: ${message || "unknown"}`;
+  }
+  if (type === "task_completed") {
+    const taskId = String(payload.taskId ?? "").slice(0, 8);
+    const summary = String(payload.summary ?? "").trim();
+    return `[task ${taskId}] completed${summary ? `: ${summary}` : ""}`;
+  }
+  if (type === "job_failed") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const message = String(payload.message ?? "").trim();
+    return `[job ${jobId}] failed: ${message || "unknown"}`;
+  }
+  if (type === "error") {
+    const message = String(payload.message ?? "").trim();
+    return `[event error] ${message || "unknown"}`;
+  }
+  if (type === "status") {
+    const state = String(payload.state ?? "").trim();
+    const detail = String(payload.detail ?? "").trim();
+    const source = from || String(payload.agentId ?? "status");
+    return detail ? `[status ${source}] ${state || "unknown"} - ${detail}` : `[status ${source}] ${state || "unknown"}`;
+  }
+  return null;
+}
+async function runSessionStream(serverUrl, sessionId, authToken, print, signal) {
+  let cursor = 0;
+  while (!signal.aborted) {
+    const headers = authHeaders(authToken);
+    try {
+      const response = await fetchWithTimeout(`${serverUrl}/sessions/${encodeURIComponent(sessionId)}/events${cursor > 0 ? `?after=${cursor}` : ""}`, { headers }, 15000);
+      if (!response.ok || !response.body) {
+        print(`[pushpals] Session stream unavailable: HTTP ${response.status}`);
+        await Bun.sleep(SSE_RECONNECT_MS);
+        continue;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder;
+      let buffer = "";
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        const blocks = buffer.split(`
+
+`);
+        buffer = blocks.pop() ?? "";
+        for (const block of blocks) {
+          if (!block.trim())
+            continue;
+          let blockCursor = 0;
+          let rawData = "";
+          for (const line2 of block.split(/\r?\n/)) {
+            if (line2.startsWith("id:")) {
+              const idText = line2.slice(3).trim();
+              const parsed2 = Number.parseInt(idText, 10);
+              if (Number.isFinite(parsed2) && parsed2 > 0) {
+                blockCursor = parsed2;
+              }
+            } else if (line2.startsWith("data:")) {
+              rawData += `${line2.slice(5).trim()}
+`;
+            }
+          }
+          if (!rawData.trim())
+            continue;
+          let parsed = null;
+          try {
+            parsed = JSON.parse(rawData.trim());
+          } catch {
+            continue;
+          }
+          const serverCursor = typeof parsed.cursor === "number" && Number.isFinite(parsed.cursor) ? parsed.cursor : 0;
+          cursor = Math.max(cursor, blockCursor, serverCursor);
+          if (!parsed.envelope)
+            continue;
+          const line = formatSessionEventLine(parsed.envelope);
+          if (line)
+            print(line);
+        }
+      }
+    } catch {}
+    if (!signal.aborted) {
+      await Bun.sleep(SSE_RECONNECT_MS);
+    }
+  }
+}
+async function openMonitoringHub(url) {
+  let cmd = null;
+  if (process.platform === "win32") {
+    const escaped = url.replace(/'/g, "''");
+    cmd = ["powershell", "-NoProfile", "-Command", `Start-Process '${escaped}'`];
+  } else if (process.platform === "darwin") {
+    cmd = ["open", url];
+  } else {
+    cmd = ["xdg-open", url];
+  }
+  const proc = Bun.spawn(cmd, {
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  const code = await proc.exited;
+  return code === 0;
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (!parsed)
+    return;
+  const config = loadPushPalsConfig();
+  const cwd = process.cwd();
+  const repoRoot = await resolveCurrentGitRepoRoot(cwd);
+  if (!repoRoot) {
+    console.error("[pushpals] Refusing to start: current directory is not a git repository.");
+    console.error(`[pushpals] cwd=${cwd}`);
+    console.error("[pushpals] Run from a repo directory, or initialize one with `git init`.");
+    process.exit(1);
+  }
+  const serverUrl = normalizeUrl(parsed.serverUrl ?? process.env.PUSHPALS_SERVER_URL, config.server.url);
+  const localAgentUrl = normalizeUrl(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();
+  const authToken = config.authToken;
+  const health = await probeLocalBuddy(localAgentUrl, authToken);
+  if (!health?.ok) {
+    console.error(`[pushpals] LocalBuddy is unavailable at ${localAgentUrl}.`);
+    console.error("[pushpals] Start the stack first, then rerun `pushpals`.");
+    process.exit(1);
+  }
+  const localBuddyRepo = health.repo ? resolve2(health.repo) : "";
+  if (!localBuddyRepo) {
+    console.error("[pushpals] LocalBuddy health response did not include repo path.");
+    process.exit(1);
+  }
+  if (normalizePath(localBuddyRepo) !== normalizePath(repoRoot)) {
+    console.error("[pushpals] Repo mismatch detected.");
+    console.error(`[pushpals] currentRepo=${repoRoot}`);
+    console.error(`[pushpals] localBuddyRepo=${localBuddyRepo}`);
+    console.error("[pushpals] LocalBuddy must run against the same repo. Start PushPals from this repo and retry.");
+    process.exit(1);
+  }
+  const localBuddySessionId = health.sessionId && String(health.sessionId).trim() ? String(health.sessionId).trim() : sessionId;
+  if (sessionId && sessionId !== localBuddySessionId) {
+    console.warn(`[pushpals] Requested sessionId=${sessionId}, but LocalBuddy is currently attached to sessionId=${localBuddySessionId}.`);
+  }
+  const statePath = resolve2(repoRoot, ".git", "pushpals-cli-state.json");
+  const saved = readCliState(statePath);
+  const preferredHubUrl = normalizeUrl(parsed.monitoringHubUrl ?? process.env.PUSHPALS_MONITOR_URL ?? saved.monitoringHubUrl ?? "");
+  const monitorPort = parsePositiveInt(process.env.PUSHPALS_CLIENT_PORT, DEFAULT_MONITOR_PORT);
+  const monitoringHubUrl = await resolveMonitoringHubUrl(preferredHubUrl, monitorPort);
+  writeCliState(statePath, {
+    monitoringHubUrl,
+    serverUrl,
+    localAgentUrl,
+    sessionId: localBuddySessionId,
+    repoRoot
+  });
+  console.log("[pushpals] Connected.");
+  console.log(`monitoringHubUrl=${monitoringHubUrl}`);
+  console.log(`serverUrl=${serverUrl}`);
+  console.log(`localAgentUrl=${localAgentUrl}`);
+  console.log(`sessionId=${localBuddySessionId}`);
+  console.log(`repoRoot=${repoRoot}`);
+  console.log(`cliStateFile=${statePath}`);
+  console.log("[pushpals] Type a message and press Enter. Use /exit to quit.");
+  const streamAbort = new AbortController;
+  let rl = null;
+  const printIncoming = (line) => {
+    if (!line)
+      return;
+    if (rl) {
+      process.stdout.write(`
+${line}
+`);
+      rl.prompt();
+      return;
+    }
+    console.log(line);
+  };
+  const streamTask = parsed.noStream ? Promise.resolve() : runSessionStream(serverUrl, localBuddySessionId, authToken, printIncoming, streamAbort.signal);
+  let shuttingDown = false;
+  const requestStop = () => {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    streamAbort.abort();
+    if (rl)
+      rl.close();
+  };
+  process.once("SIGINT", requestStop);
+  process.once("SIGTERM", requestStop);
+  rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  rl.setPrompt("you> ");
+  rl.prompt();
+  for await (const rawLine of rl) {
+    const text = String(rawLine ?? "").trim();
+    if (!text) {
+      rl.prompt();
+      continue;
+    }
+    if (text === "/exit" || text === "/quit") {
+      requestStop();
+      break;
+    }
+    if (text === "/hub") {
+      console.log(`monitoringHubUrl=${monitoringHubUrl}`);
+      rl.prompt();
+      continue;
+    }
+    if (text === "/status") {
+      console.log(`serverUrl=${serverUrl}`);
+      console.log(`localAgentUrl=${localAgentUrl}`);
+      console.log(`sessionId=${sessionId}`);
+      console.log(`repoRoot=${repoRoot}`);
+      console.log(`monitoringHubUrl=${monitoringHubUrl}`);
+      rl.prompt();
+      continue;
+    }
+    if (text === "/open") {
+      const opened = await openMonitoringHub(monitoringHubUrl);
+      console.log(opened ? `[pushpals] Opened ${monitoringHubUrl}` : `[pushpals] Failed to open browser. Use this link: ${monitoringHubUrl}`);
+      rl.prompt();
+      continue;
+    }
+    const ok = await sendMessageToLocalBuddy(localAgentUrl, text);
+    if (!ok) {
+      console.log("[pushpals] Message failed.");
+    }
+    rl.prompt();
+  }
+  requestStop();
+  await Promise.race([streamTask, Bun.sleep(2000)]);
+}
+main().catch((err) => {
+  console.error(`[pushpals] Fatal: ${String(err)}`);
+  process.exit(1);
+});