@pushpalsdev/cli 1.1.18 → 1.1.20

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

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

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

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

package/runtime/sandbox/configs/default.toml

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

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

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