@pushpalsdev/cli 1.1.17 → 1.1.19

package/package.json

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

package/runtime/sandbox/.pushpals-remotebuddy-fallback.js

@@ -4812,6 +4812,46 @@ var IGNORED_REPO_TARGET_DIRS = new Set([
   "__pycache__",
   "target"
 ]);
+function isPushPalsRepository(repoRoot) {
+  return existsSync4(resolve4(repoRoot, "apps", "remotebuddy", "src", "autonomous_engine.ts")) && existsSync4(resolve4(repoRoot, "apps", "workerpals", "src", "workerpals_main.ts")) && existsSync4(resolve4(repoRoot, "packages", "shared", "src", "autonomy_policy.ts"));
+}
+function isPushPalsInternalUserRepoPath(path) {
+  const normalized = asString2(path).replace(/\\/g, "/").toLowerCase();
+  if (!normalized)
+    return false;
+  return /(^|\/)_layout\.autonomy\.test\.[cm]?[jt]sx?$/.test(normalized);
+}
+function containsPushPalsInternalUserRepoText(text) {
+  return /\b(queue_health|workerpal|remotebuddy|sourcecontrolmanager|source_control_manager|reviewagent|pushpals)\b/i.test(text);
+}
+function candidateLeaksPushPalsInternals(candidate) {
+  if ([candidate.component_area, ...candidate.target_paths].some((path) => isPushPalsInternalUserRepoPath(path))) {
+    return true;
+  }
+  const publicText = [
+    candidate.title,
+    candidate.problem_statement,
+    candidate.vision_alignment_reason,
+    ...candidate.feature_hypotheses,
+    ...candidate.target_paths
+  ].join(`
+`);
+  return containsPushPalsInternalUserRepoText(publicText);
+}
+function buildRepoNativeFallbackInstruction(candidate) {
+  return [
+    candidate.title,
+    "",
+    candidate.problem_statement,
+    "",
+    "Keep the change scoped to the repo's own product/runtime behavior. Do not add PushPals, WorkerPal, RemoteBuddy, queue-health, or autonomy-internal concepts to user-facing code or tests.",
+    "",
+    "Scope:",
+    `- target_paths: ${candidate.target_paths.join(", ")}`,
+    `- write_globs: ${candidate.scope.write_globs.join(", ")}`
+  ].join(`
+`);
+}
 function pathBasename(path) {
   const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "");
   const idx = normalized.lastIndexOf("/");
@@ -4890,10 +4930,13 @@ function collectRepoTargetFiles(repoRoot, startRelativePath, maxResults, maxDept
 function discoverRepoTargetProfiles(repoRoot, maxProfiles = 16) {
   const profiles = [];
   const seen = new Set;
+  const allowPushPalsInternalTargets = isPushPalsRepository(repoRoot);
   const add = (targetPath) => {
     const finalPath = normalizeAutonomyComponentArea(targetPath);
     if (!finalPath)
       return;
+    if (!allowPushPalsInternalTargets && isPushPalsInternalUserRepoPath(finalPath))
+      return;
     if (seen.has(finalPath))
       return;
     seen.add(finalPath);
@@ -4959,6 +5002,8 @@ function chooseRepoObjectiveTargetProfile(profiles, objective) {
   let best = null;
   for (const profile of profiles) {
     const label = profile.label.toLowerCase();
+    if (isPushPalsInternalUserRepoPath(label))
+      continue;
     const profileTokens = new Set(profile.keywords);
     let score = 0;
     for (const token of hintTokens) {
@@ -4988,6 +5033,17 @@ function chooseRepoObjectiveTargetProfile(profiles, objective) {
       if (productSurface)
         score += 1;
     }
+    if (/\b(web|browser|smoke|e2e|review path|review|navigation|delivery|trust)\b/i.test(objective.title)) {
+      if (/(^|\/)(scripts?|tools?)\/.*(web|browser|smoke|e2e|playwright)/i.test(label)) {
+        score += 8;
+      }
+      if (/\b(app\/(_layout|index)|route|navigation|shell|home|screen)\b/i.test(label)) {
+        score += 4;
+      }
+      if (validationSurface && !/(web|browser|smoke|e2e|playwright)/i.test(label)) {
+        score -= 3;
+      }
+    }
     if (categories.has("performance")) {
       if (productSurface || /\b(perf|render|animation|worker|server)\b/i.test(label))
         score += 4;
@@ -7479,6 +7535,7 @@ ${JSON.stringify(input.messages ?? [])}`),
       }
       const normalizedCandidates = [];
       const dropReasonCounts = new Map;
+      const allowPushPalsInternalCandidates = isPushPalsRepository(this.autonomyRepo);
       const recordDropReason = (reason) => {
         dropReasonCounts.set(reason, (dropReasonCounts.get(reason) ?? 0) + 1);
       };
@@ -7553,6 +7610,11 @@ ${JSON.stringify(input.messages ?? [])}`),
           candidate.component_area = scopeValidation.componentArea ?? candidate.component_area;
           candidate.target_paths = scopeValidation.normalizedTargetPaths;
           candidate.scope.write_globs = scopeValidation.normalizedWriteGlobs;
+          if (!allowPushPalsInternalCandidates && candidateLeaksPushPalsInternals(candidate)) {
+            recordDropReason(`${source}_pushpals_internal_leak`);
+            console.warn(`[RemoteBuddyAutonomousEngine] dropping candidate ${candidate.id}: PushPals-internal concepts do not belong in user-repo autonomy work.`);
+            continue;
+          }
           const missingTargetPaths = findMissingRepoTargetPaths(this.autonomyRepo, candidate.target_paths);
           if (missingTargetPaths.length > 0) {
             recordDropReason(`${source}_target_paths_missing_in_repo`);
@@ -7966,13 +8028,17 @@ ${JSON.stringify(input.messages ?? [])}`),
         outcomeDetail = "lock_renew_failed_before_enqueue";
         return;
       }
-      const instruction = canonicalizeInstructionTextForBun(asString2(planningJson.instruction) || `${selected.candidate.title}
+      let instruction = canonicalizeInstructionTextForBun(asString2(planningJson.instruction) || `${selected.candidate.title}
 
 ${selected.candidate.problem_statement}
 
 Scope:
 - target_paths: ${selected.candidate.target_paths.join(", ")}
 - write_globs: ${selected.candidate.scope.write_globs.join(", ")}`);
+      if (!isPushPalsRepository(this.autonomyRepo) && containsPushPalsInternalUserRepoText(instruction)) {
+        console.warn(`[RemoteBuddyAutonomousEngine] replacing autonomy instruction for ${selected.candidate.id}: planner output contained PushPals-internal wording.`);
+        instruction = canonicalizeInstructionTextForBun(buildRepoNativeFallbackInstruction(selected.candidate));
+      }
       this.setPhase("enqueue_request");
       const requestId = await this.enqueueSyntheticRequest(instruction, {
         objectiveId,
@@ -8426,7 +8492,7 @@ function ensureWriteGlobsCoverTargetPaths(targetPaths, writeGlobs) {
   }
   return { normalizedWriteGlobs, uncoveredTargets, addedGlobs };
 }
-function buildExecutionGuidance(plan, targetPaths, requiredValidationSteps = []) {
+function buildExecutionGuidance(plan, targetPaths, requiredValidationSteps = [], repoHintDiagnostics = []) {
   const lines = [];
   const targets = normalizePathHints(targetPaths.length > 0 ? targetPaths : plan.scope.write_globs ?? []);
   if (targets.length > 0) {
@@ -8438,6 +8504,13 @@ function buildExecutionGuidance(plan, targetPaths, requiredValidationSteps = [])
     lines.push("- Do not prepend a leading slash to target paths.");
     lines.push("- These paths are relevance hints, not hard write boundaries; edit the behavior-owning files needed for the task and explain any expansion.");
   }
+  if (repoHintDiagnostics.length > 0) {
+    lines.push("Repo hint preflight:");
+    for (const diagnostic of repoHintDiagnostics.slice(0, 8)) {
+      lines.push(`- ${diagnostic}`);
+    }
+    lines.push("- If a hinted path is absent, treat it as stale guidance unless the user explicitly asked to create that path. Prefer an existing repo-native owner or nearby test.");
+  }
   lines.push("Scope:");
   lines.push(`- read_anywhere: ${plan.scope.read_anywhere ? "true" : "false"}`);
   lines.push(`- write_allowed: ${plan.scope.write_allowed ? "true" : "false"}`);
@@ -8490,6 +8563,75 @@ function buildExecutionGuidance(plan, targetPaths, requiredValidationSteps = [])
   return lines.join(`
 `).trim();
 }
+function pathHintHasGlob(value) {
+  return /[*?[\]{}]/.test(value);
+}
+function pathHintLooksLikeConcreteFile(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\.\/+/, "");
+  const tail = normalized.split("/").pop() ?? normalized;
+  return /\.[A-Za-z0-9][A-Za-z0-9_-]{0,12}$/.test(tail);
+}
+function requestAllowsCreatingMissingPath(value) {
+  return /\b(create|add|new|scaffold|generate|introduce|write)\b.{0,80}\b(file|test|module|component|script|page|route|fixture|helper)\b/i.test(value);
+}
+function shouldTreatMissingTargetAsStale(repoRoot, path, requestText) {
+  const normalized = normalizeTargetPath(path);
+  if (!normalized || normalized === "." || pathHintHasGlob(normalized))
+    return false;
+  if (!pathHintLooksLikeConcreteFile(normalized))
+    return false;
+  if (existsSync5(resolve5(repoRoot, normalized)))
+    return false;
+  if (requestAllowsCreatingMissingPath(requestText))
+    return false;
+  return true;
+}
+function sanitizeRepoNativeTargetHints(params) {
+  const requestText = [
+    params.prompt,
+    params.plan.worker_instruction,
+    params.plan.assistant_message,
+    ...params.plan.acceptance_criteria,
+    ...params.targetPaths
+  ].join(`
+`);
+  const diagnostics = [];
+  const staleHints = [];
+  const targetPaths = params.targetPaths.filter((path) => {
+    const normalized = normalizeTargetPath(path);
+    if (!normalized)
+      return false;
+    if (!shouldTreatMissingTargetAsStale(params.repoRoot, normalized, requestText))
+      return true;
+    staleHints.push(normalized);
+    diagnostics.push(`Path hint "${normalized}" does not exist in this checkout; it was removed as a canonical target and kept only as advisory context.`);
+    return false;
+  });
+  if (staleHints.length > 0) {
+    const staleLower = staleHints.map((path) => path.toLowerCase());
+    params.plan.validation_steps = params.plan.validation_steps.filter((step) => {
+      const lower = step.replace(/\\/g, "/").toLowerCase();
+      return !staleLower.some((path) => lower.includes(path));
+    });
+    params.plan.scope.write_globs = params.plan.scope.write_globs.filter((glob) => {
+      const normalized = normalizeTargetPath(glob);
+      if (!normalized)
+        return false;
+      return !staleLower.includes(normalized.toLowerCase());
+    });
+    if (!params.plan.discovery) {
+      params.plan.discovery = { ripgrep_queries: [] };
+    }
+    const keywords = new Set([...params.plan.discovery.keywords ?? []]);
+    for (const path of staleHints) {
+      const tail = path.split("/").pop();
+      if (tail)
+        keywords.add(tail.replace(/\.[^.]+$/, ""));
+    }
+    params.plan.discovery.keywords = [...keywords].slice(0, 12);
+  }
+  return { targetPaths, diagnostics, staleHints };
+}
 var VALIDATION_COMMAND_PREFIX = /^(git|bun|bunx|npm|npx|pnpm|yarn|node|python|python3|uv|pytest|vitest|jest|tsc|eslint|ruff|mypy|go|cargo|make|docker|pwsh|powershell|sh|bash)\b/i;
 var VALIDATION_GENERIC_SAFE = /^(git\s+status\s+--porcelain|git\s+diff\b)/i;
 var PATH_TOKEN_REGEX = /\b([A-Za-z0-9._/\-\\]+\.[A-Za-z0-9._-]+)\b/g;
@@ -9923,7 +10065,17 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
       }
       this.pushContext(`[user] ${toSingleLine(prompt, 700)}`, requestSessionId);
       this.pushContext(`[plan] ${toSingleLine(JSON.stringify(plan), 900)}`, requestSessionId);
-      const targetPaths = autonomyMetadata && autonomyMetadata.targetPaths.length > 0 ? autonomyMetadata.targetPaths : plannerTargetPaths(plan, prompt);
+      let targetPaths = autonomyMetadata && autonomyMetadata.targetPaths.length > 0 ? autonomyMetadata.targetPaths : plannerTargetPaths(plan, prompt);
+      const repoHintPreflight = sanitizeRepoNativeTargetHints({
+        repoRoot: this.repo,
+        prompt,
+        plan,
+        targetPaths
+      });
+      targetPaths = repoHintPreflight.targetPaths;
+      if (repoHintPreflight.diagnostics.length > 0) {
+        console.warn(`[RemoteBuddy] Repo hint preflight: ${repoHintPreflight.diagnostics.slice(0, 3).join(" | ")}`);
+      }
       this.rememberPersistentMemory("plan", `intent=${plan.intent} worker=${plan.requires_worker ? "yes" : "no"} lane=${plan.lane} risk=${plan.risk_level} targets=${targetPaths.slice(0, 6).join(",") || "(none)"}`, requestId, requestSessionId);
       const targetPath = targetPaths[0];
       const isAnalysisFromEngine = plan.intent === "analysis" && Boolean(autonomyMetadata);
@@ -9961,8 +10113,9 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
         }
         if (!forceWorker) {
           const missing = [];
-          if (targetPaths.length === 0)
+          if (targetPaths.length === 0 && repoHintPreflight.diagnostics.length === 0) {
             missing.push("target_paths");
+          }
           if (plan.acceptance_criteria.length === 0)
             missing.push("acceptance_criteria");
           if (plan.validation_steps.length === 0)
@@ -9981,7 +10134,7 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
       }
       const canonicalInstruction = prompt.trim();
       const rawPlannerInstruction = sanitizePlannerWorkerInstruction(String(plan.worker_instruction ?? ""), canonicalInstruction);
-      const executionGuidance = buildExecutionGuidance(plan, targetPaths, requiredValidationSteps);
+      const executionGuidance = buildExecutionGuidance(plan, targetPaths, requiredValidationSteps, repoHintPreflight.diagnostics);
       const plannerWorkerInstruction = [rawPlannerInstruction, executionGuidance].filter(Boolean).join(`
 
 `).trim();
@@ -10087,6 +10240,7 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
           } : {},
           acceptanceCriteria: plan.acceptance_criteria,
           validationSteps: plan.validation_steps,
+          ...repoHintPreflight.diagnostics.length > 0 ? { repoHintDiagnostics: repoHintPreflight.diagnostics } : {},
           ...requiredValidationSteps.length > 0 ? { requiredValidationSteps } : {},
           queuePriority: priority,
           queueWaitBudgetMs,

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/openai_codex_executor.py

@@ -104,8 +104,13 @@ _MAX_WRAPPER_RECOVERY_ATTEMPTS = 2
 _MAX_WRAPPER_BOOTSTRAP_OUTPUT_CHARS = 1_200
 _MAX_WRAPPER_BOOTSTRAP_TOTAL_CHARS = 5_000
 _MAX_NO_EDIT_RECOVERY_ATTEMPTS = 1
+_MAX_ROLLOUT_RECOVERY_ATTEMPTS = 1
 _DEFAULT_NO_EDIT_WATCHDOG_S = 480
 _SMALL_TASK_NO_EDIT_WATCHDOG_S = 360
+_WEB_REVIEW_NO_EDIT_WATCHDOG_S = 240
+_DEFAULT_ROLLOUT_WATCHDOG_S = 300
+_SMALL_TASK_ROLLOUT_WATCHDOG_S = 240
+_WEB_REVIEW_ROLLOUT_WATCHDOG_S = 180
 
 
 def _model_supports_xhigh_reasoning(model: str) -> bool:
@@ -577,6 +582,11 @@ def _looks_like_small_task_prompt(prompt: str) -> bool:
         "startup shell",
         "shell polish",
         "visual/affordance",
+        "repo-native web review",
+        "web review path",
+        "browser smoke",
+        "web delivery",
+        "navigation trustworthy",
     )
     heavy_markers = (
         "merge-conflict",
@@ -637,18 +647,142 @@ def _resolve_no_edit_watchdog_seconds(
     if communicate_timeout_s < 600:
         return None
 
-    default_s = _SMALL_TASK_NO_EDIT_WATCHDOG_S if _looks_like_small_task_prompt(prompt) else _DEFAULT_NO_EDIT_WATCHDOG_S
+    prompt_text = str(prompt or "").lower()
+    if "repo-native web review" in prompt_text or "web review path" in prompt_text:
+        default_s = _WEB_REVIEW_NO_EDIT_WATCHDOG_S
+    else:
+        default_s = (
+            _SMALL_TASK_NO_EDIT_WATCHDOG_S
+            if _looks_like_small_task_prompt(prompt)
+            else _DEFAULT_NO_EDIT_WATCHDOG_S
+        )
     return max(120, min(default_s, max(120, communicate_timeout_s - 60)))
 
 
-def _build_no_edit_recovery_guidance(trace_excerpt: str) -> str:
+def _looks_like_web_review_prompt(prompt: str) -> bool:
+    text = str(prompt or "").lower()
+    return "repo-native web review" in text or "web review path" in text
+
+
+def _resolve_rollout_watchdog_seconds(
+    prompt: str,
+    communicate_timeout_s: Optional[int],
+    no_edit_watchdog_s: Optional[int],
+) -> Optional[int]:
+    if not communicate_timeout_s or communicate_timeout_s < 600:
+        return None
+
+    raw = os.environ.get("WORKERPALS_OPENAI_CODEX_ROLLOUT_WATCHDOG_S", "").strip()
+    if raw:
+        if raw == "0":
+            return None
+        parsed = _to_positive_int(raw)
+        if parsed is None:
+            log.info(
+                f"Invalid WORKERPALS_OPENAI_CODEX_ROLLOUT_WATCHDOG_S={raw!r}; using default rollout watchdog."
+            )
+        else:
+            return max(1, min(parsed, max(1, communicate_timeout_s - 1)))
+
+    if _looks_like_web_review_prompt(prompt):
+        default_s = _WEB_REVIEW_ROLLOUT_WATCHDOG_S
+    elif _looks_like_small_task_prompt(prompt):
+        default_s = _SMALL_TASK_ROLLOUT_WATCHDOG_S
+    else:
+        default_s = _DEFAULT_ROLLOUT_WATCHDOG_S
+    if no_edit_watchdog_s is not None:
+        default_s = min(default_s, max(90, no_edit_watchdog_s - 60))
+    return max(90, min(default_s, max(90, communicate_timeout_s - 60)))
+
+
+def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot: List[str]) -> str:
+    delta = [p for p in changed_paths if p not in baseline_snapshot]
+    inspected = delta if delta else changed_paths
+    non_publishable = [p for p in inspected if not _is_publishable_changed_path(p)]
+    if not non_publishable:
+        return ""
+    listed = ", ".join(non_publishable[:8])
+    if len(non_publishable) > 8:
+        listed += ", ..."
+    return listed
+
+
+def _build_no_edit_recovery_guidance(trace_excerpt: str, artifact_only_paths: str = "") -> str:
     lines = [
         "No-edit watchdog recovery: the previous Codex attempt spent too much of the execution budget without producing publishable file changes.",
         "Start from the already inspected context. Do not re-read broad repo topology, route wrappers, or missing test infrastructure unless that is the blocker.",
+        "Runtime/dependency artifacts such as node_modules, outputs, .worktrees, .codex, dist, build, and coverage do not count as progress.",
         "Within the first response/action, edit the smallest behavior-owning file that satisfies the task. If the hinted file is a thin wrapper, patch the owner you already identified.",
+        "If a hinted test path is absent, do not invent PushPals/autonomy-specific files in the user repo. Add repo-native coverage beside existing tests, or make a tiny behavior/script patch with no new broad harness.",
         "Use existing tests or a narrow helper/style assertion; do not create broad React Native mocks or a new full render harness for a compact shell/visual polish task.",
         "Run at most one focused fast validation check before final diff review; let PushPals ValidationGate own long required/browser validation.",
     ]
+    if artifact_only_paths:
+        lines.append(f"Only non-publishable artifact paths changed so far: {artifact_only_paths}.")
+    if trace_excerpt:
+        lines.append("Previous Codex event trace excerpt:")
+        lines.append(trace_excerpt)
+    return "\n".join(lines)
+
+
+def _trace_summaries_text(trace: Dict[str, Any]) -> str:
+    summaries = trace.get("summaries")
+    if not isinstance(summaries, list):
+        return ""
+    return "\n".join(str(item or "") for item in summaries[-80:]).lower()
+
+
+def _detect_offtrack_rollout(trace: Dict[str, Any], artifact_only_paths: str = "") -> str:
+    text = _trace_summaries_text(trace)
+    if artifact_only_paths:
+        return f"only non-publishable artifact paths changed: {artifact_only_paths}"
+    if not text:
+        return ""
+    checks: List[Tuple[str, re.Pattern[str]]] = [
+        (
+            "the worker is spending time on missing hinted files or absent repo scaffolding",
+            re.compile(
+                r"(not present|not found|no existing|no .* directory|missing .* checkout|not listed in the checkout|checkout is much smaller|hinted .* absent)",
+                re.I,
+            ),
+        ),
+        (
+            "the worker is drifting into broad test-harness or React Native mock repair",
+            re.compile(
+                r"(full[- ]?(surface|render)|test harness repair|react native mock|broad .*mock|shared mock|adding .*mock helper|full component render)",
+                re.I,
+            ),
+        ),
+        (
+            "the worker is about to add PushPals/autonomy internals to a user repo",
+            re.compile(
+                r"(_layout\.autonomy|queue_health|workerpal|remotebuddy|reviewagent|pushpals-internal|no autonomy module)",
+                re.I,
+            ),
+        ),
+    ]
+    for reason, pattern in checks:
+        if pattern.search(text):
+            return reason
+    return ""
+
+
+def _build_rollout_recovery_guidance(
+    reason: str,
+    trace_excerpt: str,
+    artifact_only_paths: str = "",
+) -> str:
+    lines = [
+        "Rollout coach recovery: the previous Codex trajectory looked unlikely to produce a publishable, repo-native patch inside the budget.",
+        f"Detected off-track signal: {reason or 'no publishable progress despite concerning trace signals'}.",
+        "Do not continue the same exploration path. Start from the prior findings and make the smallest publishable edit first.",
+        "If the requested or hinted file/path is absent, treat it as a stale hint: choose an existing repo-native owner or existing test nearby instead of creating PushPals/autonomy-specific scaffolding.",
+        "For web review or shell-validation work, prefer an existing browser/e2e script, route shell, or navigation surface over generic autonomy infrastructure.",
+        "Avoid broad React Native render harnesses and shared mock expansion unless the repo already has that stable infrastructure and the task explicitly asks for it.",
+        "After the first patch, run one focused fast check or stop with a concise final update so ValidationGate can run the expensive suite.",
+    ]
+    if artifact_only_paths:
+        lines.append(f"Only non-publishable artifact paths changed so far: {artifact_only_paths}.")
     if trace_excerpt:
         lines.append("Previous Codex event trace excerpt:")
         lines.append(trace_excerpt)
@@ -1597,6 +1731,7 @@ def _run_codex_task(
     wrapper_recovery_attempt: int = 0,
     model_compatibility_recovery_attempt: int = 0,
     no_edit_recovery_attempt: int = 0,
+    rollout_recovery_attempt: int = 0,
     model_override: Optional[str] = None,
     baseline_changes: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
@@ -1889,17 +2024,35 @@ def _run_codex_task(
             next_progress_at = started_at + float(progress_interval_s)
             timed_out = False
             no_edit_watchdog_fired = False
+            no_edit_artifact_only_paths = ""
+            rollout_watchdog_fired = False
+            rollout_watchdog_reason = ""
+            rollout_artifact_only_paths = ""
             command_policy_rejection_loop = False
             no_edit_watchdog_s = (
                 _resolve_no_edit_watchdog_seconds(prompt, communicate_timeout_s)
                 if no_edit_recovery_attempt <= _MAX_NO_EDIT_RECOVERY_ATTEMPTS
                 else None
             )
+            rollout_watchdog_s = (
+                _resolve_rollout_watchdog_seconds(
+                    prompt,
+                    communicate_timeout_s,
+                    no_edit_watchdog_s,
+                )
+                if rollout_recovery_attempt <= _MAX_ROLLOUT_RECOVERY_ATTEMPTS
+                else None
+            )
             no_edit_deadline = (
                 started_at + float(no_edit_watchdog_s)
                 if no_edit_watchdog_s is not None
                 else None
             )
+            rollout_deadline = (
+                started_at + float(rollout_watchdog_s)
+                if rollout_watchdog_s is not None
+                else None
+            )
 
             while proc.poll() is None:
                 now = time.monotonic()
@@ -1909,16 +2062,54 @@ def _run_codex_task(
                     break
 
                 if no_edit_deadline is not None and now >= no_edit_deadline:
-                    _, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
+                    changed_paths, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
                     if not effective_paths:
+                        no_edit_artifact_only_paths = _describe_non_publishable_paths(
+                            changed_paths,
+                            baseline_snapshot,
+                        )
                         no_edit_watchdog_fired = True
+                        artifact_detail = (
+                            f" Artifact-only dirty paths: {no_edit_artifact_only_paths}."
+                            if no_edit_artifact_only_paths
+                            else ""
+                        )
                         log.info(
-                            f"No-edit watchdog fired after {int(no_edit_watchdog_s or 0)}s with no publishable file changes; retrying with patch-first guidance."
+                            f"No-edit watchdog fired after {int(no_edit_watchdog_s or 0)}s with no publishable file changes.{artifact_detail} Retrying with patch-first guidance."
                         )
                         _terminate_active_child()
                         break
                     no_edit_deadline = None
 
+                if rollout_deadline is not None and now >= rollout_deadline:
+                    changed_paths, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
+                    if not effective_paths:
+                        with trace_lock:
+                            live_trace = dict(stdout_trace_state)
+                            summaries = stdout_trace_state.get("summaries")
+                            if isinstance(summaries, list):
+                                live_trace["summaries"] = list(summaries)
+                        rollout_artifact_only_paths = _describe_non_publishable_paths(
+                            changed_paths,
+                            baseline_snapshot,
+                        )
+                        rollout_watchdog_reason = _detect_offtrack_rollout(
+                            live_trace,
+                            rollout_artifact_only_paths,
+                        )
+                        if rollout_watchdog_reason:
+                            rollout_watchdog_fired = True
+                            artifact_detail = (
+                                f" Artifact-only dirty paths: {rollout_artifact_only_paths}."
+                                if rollout_artifact_only_paths
+                                else ""
+                            )
+                            log.info(
+                                f"Rollout coach fired after {int(rollout_watchdog_s or 0)}s: {rollout_watchdog_reason}.{artifact_detail} Retrying with course-correction guidance."
+                            )
+                            _terminate_active_child()
+                            break
+
                 with trace_lock:
                     wrapper_rejections = to_int(wrapper_rejection_state.get("count"), 0)
                 if wrapper_rejections >= 3:
@@ -1986,11 +2177,50 @@ def _run_codex_task(
                         continue
                     rejected_shell_wrappers.append(text)
 
+        if rollout_watchdog_fired:
+            if rollout_recovery_attempt < _MAX_ROLLOUT_RECOVERY_ATTEMPTS:
+                retry_guidance = [
+                    *supplemental_guidance,
+                    _build_rollout_recovery_guidance(
+                        rollout_watchdog_reason,
+                        trace_excerpt,
+                        rollout_artifact_only_paths,
+                    ),
+                ]
+                return _run_codex_task(
+                    repo,
+                    instruction,
+                    retry_guidance,
+                    wrapper_recovery_attempt=wrapper_recovery_attempt,
+                    model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                    no_edit_recovery_attempt=no_edit_recovery_attempt,
+                    rollout_recovery_attempt=rollout_recovery_attempt + 1,
+                    model_override=model_override,
+                    baseline_changes=baseline_snapshot,
+                )
+            detail = (
+                "Codex trajectory remained off-track after rollout coach recovery: "
+                f"{rollout_watchdog_reason or 'no publishable progress'}."
+            )
+            if trace_excerpt:
+                detail = f"{detail}\n{trace_excerpt}"
+            return {
+                "ok": False,
+                "summary": "openai_codex rollout coach could not recover publishable progress",
+                "stdout": _truncate(stdout),
+                "stderr": _truncate(f"{detail}\n{stderr}".strip()),
+                "exitCode": 124,
+                "usage": usage,
+            }
+
         if no_edit_watchdog_fired:
             if no_edit_recovery_attempt < _MAX_NO_EDIT_RECOVERY_ATTEMPTS:
                 retry_guidance = [
                     *supplemental_guidance,
-                    _build_no_edit_recovery_guidance(trace_excerpt),
+                    _build_no_edit_recovery_guidance(
+                        trace_excerpt,
+                        no_edit_artifact_only_paths,
+                    ),
                 ]
                 return _run_codex_task(
                     repo,
@@ -1999,6 +2229,7 @@ def _run_codex_task(
                     wrapper_recovery_attempt=wrapper_recovery_attempt,
                     model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
                     no_edit_recovery_attempt=no_edit_recovery_attempt + 1,
+                    rollout_recovery_attempt=rollout_recovery_attempt,
                     model_override=model_override,
                     baseline_changes=baseline_snapshot,
                 )
@@ -2050,9 +2281,20 @@ def _run_codex_task(
                     "exitCode": 0,
                     "usage": usage,
                 }
+            changed_paths, _, _ = _codex_changed_paths(repo, baseline_snapshot)
+            artifact_only_paths = _describe_non_publishable_paths(changed_paths, baseline_snapshot)
+            if artifact_only_paths:
+                detail = (
+                    f"{detail}\nOnly non-publishable artifact paths changed before timeout: "
+                    f"{artifact_only_paths}."
+                )
             return {
                 "ok": False,
-                "summary": "openai_codex execution timed out",
+                "summary": (
+                    "openai_codex timed out without publishable changes"
+                    if artifact_only_paths
+                    else "openai_codex execution timed out"
+                ),
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                 "exitCode": 124,
@@ -2149,6 +2391,7 @@ def _run_codex_task(
                         wrapper_recovery_attempt=wrapper_recovery_attempt + 1,
                         model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
                         no_edit_recovery_attempt=no_edit_recovery_attempt,
+                        rollout_recovery_attempt=rollout_recovery_attempt,
                         model_override=model_override,
                         baseline_changes=baseline_snapshot,
                     )
@@ -2232,6 +2475,7 @@ def _run_codex_task(
                     wrapper_recovery_attempt=wrapper_recovery_attempt,
                     model_compatibility_recovery_attempt=model_compatibility_recovery_attempt + 1,
                     no_edit_recovery_attempt=no_edit_recovery_attempt,
+                    rollout_recovery_attempt=rollout_recovery_attempt,
                     model_override=LEGACY_CODEX_MODEL_FALLBACK,
                     baseline_changes=baseline_snapshot,
                 )