@pushpalsdev/cli 1.0.85 → 1.0.93

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

@@ -65,6 +65,8 @@ type WorkerJobResult = JobResult & {
 
 const DEFAULT_LLM_MODEL = "local-model";
 const CODEX_UNAVAILABLE_WORKER_EXIT_CODE = 86;
+const CODEX_UNAVAILABLE_DOCKER_SHUTDOWN_GRACE_MS = 5_000;
+const CODEX_UNAVAILABLE_WORKER_FORCE_EXIT_MS = 4_000;
 const CONFIG = loadPushPalsConfig();
 const LOG = new Logger("WorkerPals");
 
@@ -360,6 +362,36 @@ function shouldRecycleWorkerForCodexUnavailableFailure(
   ].some((needle) => text.includes(needle));
 }
 
+async function shutdownDockerExecutorBeforeCodexRecycle(
+  dockerExecutor: DockerExecutor | null,
+): Promise<void> {
+  if (!dockerExecutor) return;
+
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  let timedOut = false;
+  try {
+    await Promise.race([
+      dockerExecutor.shutdown(),
+      new Promise<void>((resolvePromise) => {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          resolvePromise();
+        }, CODEX_UNAVAILABLE_DOCKER_SHUTDOWN_GRACE_MS);
+      }),
+    ]);
+  } catch (err) {
+    console.error(`[WorkerPals] Docker shutdown cleanup failed: ${String(err)}`);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+
+  if (timedOut) {
+    console.warn(
+      `[WorkerPals] Docker shutdown cleanup exceeded ${CODEX_UNAVAILABLE_DOCKER_SHUTDOWN_GRACE_MS}ms; exiting worker for Codex recycle anyway.`,
+    );
+  }
+}
+
 function parseArgs(): {
   server: string;
   pollMs: number;
@@ -1667,21 +1699,46 @@ async function workerLoop(
             }
           } finally {
             clearInterval(busyHeartbeat);
-            if (
-              !recycleWorkerAfterJob &&
-              job.sessionId &&
-              result?.cooldownMs &&
-              result.cooldownMs > 0
-            ) {
-              await transport.queueSessionCommand(job.sessionId, {
-                type: "assistant_message",
-                payload: {
-                  text: `WorkerPal is cooling down for ${formatDurationMs(result.cooldownMs)} after transient infrastructure failures.`,
+            if (recycleWorkerAfterJob) {
+              runtimeState.shutdownRequested = true;
+              const forceExitTimer = setTimeout(() => {
+                console.warn(
+                  `[WorkerPals] Forcing worker recycle ${CODEX_UNAVAILABLE_WORKER_FORCE_EXIT_MS}ms after Codex backend failure.`,
+                );
+                process.exit(CODEX_UNAVAILABLE_WORKER_EXIT_CODE);
+              }, CODEX_UNAVAILABLE_WORKER_FORCE_EXIT_MS);
+              try {
+                await maybeHeartbeat("offline", null, true);
+                if (directWorktreePath) {
+                  await removeIsolatedWorktree(opts.repo, directWorktreePath).catch((err) => {
+                    console.error(
+                      `[WorkerPals] Failed to remove isolated worktree before Codex recycle: ${String(
+                        err,
+                      )}`,
+                    );
+                  });
+                  directWorktreePath = null;
+                }
+                await shutdownDockerExecutorBeforeCodexRecycle(dockerExecutor);
+              } finally {
+                clearTimeout(forceExitTimer);
+                process.exit(CODEX_UNAVAILABLE_WORKER_EXIT_CODE);
+              }
+            }
+            if (job.sessionId && result?.cooldownMs && result.cooldownMs > 0) {
+              await transport.queueSessionCommand(
+                job.sessionId,
+                {
+                  type: "assistant_message",
+                  payload: {
+                    text: `WorkerPal is cooling down for ${formatDurationMs(result.cooldownMs)} after transient infrastructure failures.`,
+                  },
+                  from: `worker:${opts.workerId}`,
                 },
-                from: `worker:${opts.workerId}`,
-              }, { priority: "high" });
+                { priority: "high" },
+              );
             }
-            if (!recycleWorkerAfterJob && result?.cooldownMs && result.cooldownMs > 0) {
+            if (result?.cooldownMs && result.cooldownMs > 0) {
               const cooldownMs = Math.max(0, Math.floor(result.cooldownMs));
               console.warn(
                 `[WorkerPals] Entering cooldown for ${formatDurationMs(cooldownMs)} after retry exhaustion.`,
@@ -1697,18 +1754,6 @@ async function workerLoop(
                 console.error(`[WorkerPals] Failed to remove isolated worktree: ${String(err)}`);
               });
             }
-            if (recycleWorkerAfterJob) {
-              runtimeState.shutdownRequested = true;
-              await maybeHeartbeat("offline", null, true);
-              if (dockerExecutor) {
-                try {
-                  await dockerExecutor.shutdown();
-                } catch (err) {
-                  console.error(`[WorkerPals] Docker shutdown cleanup failed: ${String(err)}`);
-                }
-              }
-              process.exit(CODEX_UNAVAILABLE_WORKER_EXIT_CODE);
-            }
           }
         }
       }

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

@@ -319,7 +319,11 @@ export function validateScopeInvariants(
   componentArea: AutonomyComponentArea | null | undefined,
   targetPathsInput: unknown[],
   writeGlobsInput: unknown[],
-  options?: { requireWriteGlobs?: boolean; allowMultipleComponentRoots?: boolean },
+  options?: {
+    requireWriteGlobs?: boolean;
+    allowMultipleComponentRoots?: boolean;
+    hintsOnly?: boolean;
+  },
 ): ScopeValidationResult {
   const errors: string[] = [];
   const scopeSeeds = collectScopeSeedPaths(targetPathsInput, writeGlobsInput);
@@ -327,7 +331,8 @@ export function validateScopeInvariants(
     normalizeAutonomyComponentArea(componentArea) ??
     deriveAutonomyComponentArea(targetPathsInput, writeGlobsInput);
   const allowMultipleComponentRoots = options?.allowMultipleComponentRoots === true;
-  if (!normalizedComponentArea && scopeSeeds.length > 1 && !allowMultipleComponentRoots) {
+  const hintsOnly = options?.hintsOnly === true;
+  if (!hintsOnly && !normalizedComponentArea && scopeSeeds.length > 1 && !allowMultipleComponentRoots) {
     errors.push(
       `scope spans multiple component roots: ${scopeSeeds.slice(0, 6).join(", ")}`,
     );
@@ -341,7 +346,7 @@ export function validateScopeInvariants(
       errors.push(`invalid target_path: ${String(raw ?? "")}`);
       continue;
     }
-    if (rootPrefix && !underRoot(normalized, rootPrefix)) {
+    if (!hintsOnly && rootPrefix && !underRoot(normalized, rootPrefix)) {
       errors.push(`target_path outside component root: ${normalized}`);
       continue;
     }
@@ -362,20 +367,21 @@ export function validateScopeInvariants(
       errors.push(`invalid write_glob: ${String(raw ?? "")}`);
       continue;
     }
-    if (hasForbiddenBroadGlob(normalized)) {
+    if (!hintsOnly && hasForbiddenBroadGlob(normalized)) {
       errors.push(`forbidden broad write_glob: ${normalized}`);
       continue;
     }
     const prefix = literalPrefix(normalized);
-    if (!prefix) {
+    if (!hintsOnly && !prefix) {
       errors.push(`write_glob literal prefix cannot be empty: ${normalized}`);
       continue;
     }
-    if (rootPrefix && !underRoot(prefix, rootPrefix)) {
+    if (!hintsOnly && rootPrefix && !underRoot(prefix, rootPrefix)) {
       errors.push(`write_glob outside component root: ${normalized}`);
       continue;
     }
     if (
+      !hintsOnly &&
       !normalizedTargetPaths.some(
         (targetPath) => targetPath === prefix || targetPath.startsWith(`${prefix}/`),
       )
@@ -393,13 +399,13 @@ export function validateScopeInvariants(
     errors.push("write_globs must be provided and non-empty");
   }
 
-  if (normalizedTargetPaths.length > 0 && normalizedWriteGlobs.length > 0) {
+  if (!hintsOnly && normalizedTargetPaths.length > 0 && normalizedWriteGlobs.length > 0) {
     for (const targetPath of normalizedTargetPaths) {
       const covered = normalizedWriteGlobs.some((glob) => matchesGlob(targetPath, glob));
       if (!covered) errors.push(`target_path not covered by write_globs: ${targetPath}`);
     }
   }
-  if (!normalizedComponentArea && !allowMultipleComponentRoots) {
+  if (!hintsOnly && !normalizedComponentArea && !allowMultipleComponentRoots) {
     errors.push("component_area could not be derived from scope");
   }
 

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

@@ -53,6 +53,7 @@ export interface CommunicationManagerOptions {
   sessionId: string;
   from: string;
   authToken?: string | null;
+  fetchImpl?: typeof fetch;
 }
 
 export class CommunicationManager {
@@ -60,12 +61,14 @@ export class CommunicationManager {
   private readonly sessionId: string;
   private readonly from: string;
   private readonly authToken: string | null;
+  private readonly fetchImpl: typeof fetch;
 
   constructor(opts: CommunicationManagerOptions) {
     this.serverUrl = opts.serverUrl;
     this.sessionId = opts.sessionId;
     this.from = opts.from;
     this.authToken = opts.authToken ?? null;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
   }
 
   private headers(): Record<string, string> {
@@ -121,7 +124,7 @@ export class CommunicationManager {
       if (meta.turnId) body.turnId = meta.turnId;
       if (meta.parentId) body.parentId = meta.parentId;
 
-      const response = await fetch(this.commandUrl(sessionId), {
+      const response = await this.fetchImpl(this.commandUrl(sessionId), {
         method: "POST",
         headers: this.headers(),
         body: JSON.stringify(body),

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

@@ -1929,7 +1929,7 @@ export function loadPushPalsConfig(options: LoadOptions = {}): PushPalsConfig {
         ),
         allowReadAnywhere:
           parseBoolEnv("REMOTEBUDDY_AUTONOMY_ALLOW_READ_ANYWHERE") ??
-          asBoolean(remoteAutonomyNode.allow_read_anywhere, false),
+          asBoolean(remoteAutonomyNode.allow_read_anywhere, true),
         prFeedbackCommentRows: Math.max(
           1,
           Math.min(

package/runtime/sandbox/prompts/workerpals/miniswe_completion_requirement.md

@@ -1 +1 @@
-Completion requirement: handle all requested edits across all explicit target paths before setting done=true.
+Completion requirement: solve the requested task before setting done=true. Target paths are relevance hints; edit other behavior-owning files when needed and explain why.

package/runtime/sandbox/prompts/workerpals/miniswe_explicit_targets_block.md

@@ -1,2 +1,2 @@
-Explicit target paths:
+Target path hints:
 {{targets_block}}

package/runtime/sandbox/prompts/workerpals/openai_codex_task_execute_system_prompt.md

@@ -11,7 +11,10 @@ Non-negotiable runtime invariants:
 
 Execution rules:
 
-- Keep edits minimal, correct, and scoped to the requested task.
+- Keep edits minimal, correct, and relevant to the requested task.
+- You have repo-wide read/write access inside an isolated WorkerPal sandbox. Target paths and write globs are starting-point/relevance hints, not hard write boundaries.
+- If the hinted file is a thin wrapper or the behavior lives elsewhere, edit the behavior-owning file(s) needed to solve the task and explain the scope expansion in your final response.
+- Avoid irrelevant sprawl; the review agent will judge whether changed files are necessary for the requested outcome.
 - Read relevant files before editing, then run focused validation.
 - Use direct commands without shell wrappers. Prefer plain commands like `git diff -- path`, `git add <path>`, `git status --porcelain`, and `pwd`.
 - Do not wrap commands in `/bin/bash -lc`, `sh -lc`, `cmd /c`, or `powershell -Command`, and avoid pipelines, `awk`, heredocs, or multi-command shell snippets unless they are truly unavoidable.

package/runtime/sandbox/prompts/workerpals/openhands_minimal_system_prompt.j2

@@ -1,10 +1,12 @@
 You are PushPals WorkerPal running inside OpenHands.
 
-Operate with strict scope:
+Operate with strict relevance:
 - Focus only on the current user task.
 - If the task is a question, answer directly and do not edit files.
 - If code/file changes are requested, implement them end-to-end.
 - Reuse existing repository conventions and avoid unrelated refactors/docs.
+- Treat target paths and write globs as starting-point/relevance hints, not hard write boundaries.
+- If the behavior lives outside the hinted files, edit the owning files and explain the scope expansion.
 
 Execution loop:
 - Prefer concrete execution over planning chatter.

package/runtime/sandbox/prompts/workerpals/openhands_task_execute_system_prompt.md

@@ -3,7 +3,8 @@ You are PushPals WorkerPal running inside OpenHands.
 Execution rules:
 
 - Focus only on the task below.
-- Keep changes minimal, correct, and scoped to the request.
+- Keep changes minimal, correct, and relevant to the request.
+- Target paths and write globs are starting-point/relevance hints, not hard write boundaries; if the behavior lives elsewhere, edit the owning files and explain why.
 - Read relevant files before editing.
 - Reuse existing project conventions and tooling.
 - If the task is a question/explanation, answer directly and do not edit files.

package/runtime/sandbox/prompts/workerpals/workerpals_system_prompt.md

@@ -6,7 +6,7 @@ Your mission:
 
 - Take the user (or RemoteBuddy) request and fully execute it end-to-end.
 - You are responsible for breaking the work down into concrete subtasks, completing them, validating, reviewing your own changes, and preparing a high-quality commit message when the work is ready.
-- You have full read/write access within the assigned repository only; do not access files outside that repository.
+- You have full read/write access within the assigned repository sandbox only; do not access files outside that repository. Target paths and write globs are starting-point/relevance hints, not hard write boundaries.
 
 Mindset:
 
@@ -64,7 +64,7 @@ Execution workflow (you MUST follow this):
      - Performance: no unnecessary work on UI thread, no extra network calls, no large bundles
      - Cross-platform: iOS/Android/Web differences guarded appropriately
      - Security: no secret leakage, safe networking defaults, no unsafe shell usage
-   - Make any final polish edits that improve clarity without changing scope.
+   - Make any final polish edits that improve clarity without drifting from the task.
 
 7. Prepare to commit (when appropriate)
    - When the work is ready, produce a detailed commit message (do NOT actually commit unless your system explicitly allows it).