@pushpalsdev/cli 1.1.9 → 1.1.10

package/dist/pushpals-cli.js

@@ -1647,6 +1647,7 @@ var DEFAULT_STARTUP_GIT_REMOTE_TIMEOUT_MS = 1e4;
 var DEFAULT_EMBEDDED_SERVICE_LAUNCH_WARN_MS = 5000;
 var EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS = 4;
 var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 15000;
+var CLI_SESSION_JOB_LOG_MAX_CHARS = 700;
 var EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
 var EMBEDDED_RUNTIME_WINDOWS_SAFETY_CAPS = {
   REMOTEBUDDY_WORKERPAL_STARTUP_TIMEOUT_MS: "120000",
@@ -5192,6 +5193,29 @@ function formatSessionEventLine(event) {
   const type = String(event.type ?? "").toLowerCase();
   const from = String(event.from ?? "");
   const payload = event.payload ?? {};
+  if (type === "job_enqueued") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const kind = String(payload.kind ?? "").trim();
+    const taskId = String(payload.taskId ?? "").slice(0, 8);
+    const detail = kind || (taskId ? `task ${taskId}` : "queued");
+    return `[job ${jobId}] queued: ${detail}`;
+  }
+  if (type === "job_claimed") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const workerId = String(payload.workerId ?? "").trim();
+    return `[job ${jobId}] claimed${workerId ? ` by ${workerId}` : ""}`;
+  }
+  if (type === "job_log") {
+    const jobId = String(payload.jobId ?? "").slice(0, 8);
+    const stream = String(payload.stream ?? "").toLowerCase() === "stderr" ? " stderr" : "";
+    const line = compactCliSessionJobLogLine(String(payload.line ?? "").trim());
+    return line ? `[job ${jobId}${stream}] ${line}` : null;
+  }
+  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 (!shouldDisplayInteractiveSessionEvent(event))
     return null;
   if (type === "message")
@@ -5217,10 +5241,10 @@ function formatSessionEventLine(event) {
     const summary = String(payload.summary ?? "").trim();
     return `[task ${taskId}] completed${summary ? `: ${summary}` : ""}`;
   }
-  if (type === "job_failed") {
+  if (type === "job_completed") {
     const jobId = String(payload.jobId ?? "").slice(0, 8);
-    const message = String(payload.message ?? "").trim();
-    return `[job ${jobId}] failed: ${message || "unknown"}`;
+    const summary = String(payload.summary ?? "").trim();
+    return `[job ${jobId}] completed${summary ? `: ${summary}` : ""}`;
   }
   if (type === "error") {
     const message = String(payload.message ?? "").trim();
@@ -5234,6 +5258,12 @@ function formatSessionEventLine(event) {
   }
   return null;
 }
+function compactCliSessionJobLogLine(line) {
+  const compacted = line.replace(/\s+/g, " ").trim();
+  if (compacted.length <= CLI_SESSION_JOB_LOG_MAX_CHARS)
+    return compacted;
+  return `${compacted.slice(0, CLI_SESSION_JOB_LOG_MAX_CHARS - 3)}...`;
+}
 function buildSessionEventReplayFingerprint(event) {
   const type = String(event.type ?? "").trim().toLowerCase();
   if (type !== "status")

package/package.json

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

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

@@ -1,3 +1,4 @@
+import base64
 import os
 import re
 import json
@@ -19,6 +20,7 @@ from executor_base import (
     Logger,
     SettingsResolver,
     config_dir_for_runtime_config,
+    parse_task_execute_payload,
     runtime_config,
 )
 from openai_codex_executor import (
@@ -257,6 +259,52 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("Keep assertions strict", prompt)
         self.assertIn("bun test tests/localbuddy.request-status.test.ts", prompt)
 
+    def test_parse_payload_adds_structured_planning_guidance(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-planning-guidance-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            payload = {
+                "kind": "task.execute",
+                "repo": str(repo),
+                "params": {
+                    "instruction": "Improve the game startup smoke path",
+                    "schemaVersion": 2,
+                    "planning": {
+                        "intent": "code_change",
+                        "riskLevel": "medium",
+                        "queuePriority": "normal",
+                        "queueWaitBudgetMs": 90_000,
+                        "executionBudgetMs": 1_800_000,
+                        "finalizationBudgetMs": 120_000,
+                        "scope": {
+                            "readAnywhere": True,
+                            "writeAllowed": True,
+                            "writeGlobs": ["app/**", "scripts/**"],
+                        },
+                        "targetPaths": ["app/__tests__/_layout.autonomy.test.ts"],
+                        "discovery": {
+                            "ripgrepQueries": ['rg "home-screen|web:e2e" app scripts'],
+                            "likelyDirs": ["app", "scripts"],
+                            "keywords": ["home-screen", "web:e2e"],
+                        },
+                        "acceptanceCriteria": ["Home shell startup is assertable"],
+                        "validationSteps": ["bun test", "bun run web:e2e"],
+                        "requiredValidationSteps": ["bun run web:e2e"],
+                    },
+                },
+            }
+            encoded = base64.b64encode(json.dumps(payload).encode("utf-8")).decode("ascii")
+
+            task = parse_task_execute_payload(["executor", encoded], logger=Logger("[test]"))
+            guidance = "\n".join(task.supplemental_guidance)
+
+            self.assertIn("Task planning contract from PushPals", guidance)
+            self.assertIn("Worker phase contract", guidance)
+            self.assertIn("Write globs are relevance hints, not hard limits", guidance)
+            self.assertIn("app/__tests__/_layout.autonomy.test.ts", guidance)
+            self.assertIn("Home shell startup is assertable", guidance)
+            self.assertIn("bun run web:e2e", guidance)
+
     def test_detects_codex_workaround_signals(self) -> None:
         signal = _detect_codex_workaround_signal(
             "Adapting test to avoid external Codex calls because Codex CLI isn't available in this environment.",

package/runtime/sandbox/apps/workerpals/src/backends/shared/executor_base.py

@@ -717,6 +717,110 @@ def _is_non_actionable_planner_guidance(text: str) -> bool:
     return any(marker in lower for marker in blocked_markers)
 
 
+def _string_list(value: Any, *, limit: int = 12, max_chars: int = 220) -> List[str]:
+    if not isinstance(value, list):
+        return []
+    out: List[str] = []
+    for item in value:
+        text = to_single_line(item, max_chars)
+        if text:
+            out.append(text)
+        if len(out) >= limit:
+            break
+    return out
+
+
+def _append_list_guidance(lines: List[str], label: str, values: List[str]) -> None:
+    if not values:
+        return
+    lines.append(f"- {label}:")
+    for value in values:
+        lines.append(f"  - {value}")
+
+
+def _build_planning_guidance(params: Dict[str, Any]) -> str:
+    planning = params.get("planning")
+    if not isinstance(planning, dict):
+        return ""
+
+    lines: List[str] = ["Task planning contract from PushPals:"]
+    intent = to_single_line(planning.get("intent"), 80)
+    risk = to_single_line(planning.get("riskLevel"), 80)
+    priority = to_single_line(planning.get("queuePriority"), 80)
+    summary_parts = []
+    if intent:
+        summary_parts.append(f"intent={intent}")
+    if risk:
+        summary_parts.append(f"risk={risk}")
+    if priority:
+        summary_parts.append(f"priority={priority}")
+    if summary_parts:
+        lines.append(f"- Planning summary: {', '.join(summary_parts)}")
+    lines.append(
+        "- Worker phase contract: discovering -> editing -> focused validation -> full validation handoff -> final diff review."
+    )
+    lines.append(
+        "  - discovering: inspect relevant files/artifacts and state the current hypothesis before editing."
+    )
+    lines.append("  - editing: make the smallest behavior-owning patch.")
+    lines.append("  - focused validation: run targeted fast checks for the changed surface.")
+    lines.append(
+        "  - full validation: let PushPals ValidationGate own long required/browser checks unless one local confirmation is explicitly useful."
+    )
+    lines.append("  - final diff review: remove unrelated churn before returning.")
+
+    scope = planning.get("scope")
+    if isinstance(scope, dict):
+        write_allowed = scope.get("writeAllowed")
+        read_anywhere = scope.get("readAnywhere")
+        scope_parts = []
+        if isinstance(read_anywhere, bool):
+            scope_parts.append(f"read_anywhere={str(read_anywhere).lower()}")
+        if isinstance(write_allowed, bool):
+            scope_parts.append(f"write_allowed={str(write_allowed).lower()}")
+        if scope_parts:
+            lines.append(f"- Repo access: {', '.join(scope_parts)}")
+        write_globs = _string_list(scope.get("writeGlobs"), limit=10)
+        if write_globs:
+            lines.append("- Write globs are relevance hints, not hard limits; edit behavior-owning files as needed.")
+            _append_list_guidance(lines, "Write-scope hints", write_globs)
+        forbidden = _string_list(scope.get("forbiddenGlobs"), limit=8)
+        _append_list_guidance(lines, "Forbidden path hints", forbidden)
+
+    _append_list_guidance(lines, "Target path hints", _string_list(planning.get("targetPaths"), limit=12))
+
+    discovery = planning.get("discovery")
+    if isinstance(discovery, dict):
+        _append_list_guidance(
+            lines,
+            "Suggested discovery commands",
+            _string_list(discovery.get("ripgrepQueries"), limit=8),
+        )
+        _append_list_guidance(lines, "Likely directories", _string_list(discovery.get("likelyDirs"), limit=8))
+        _append_list_guidance(lines, "Search keywords", _string_list(discovery.get("keywords"), limit=12))
+
+    _append_list_guidance(
+        lines,
+        "Acceptance criteria",
+        _string_list(planning.get("acceptanceCriteria"), limit=10, max_chars=260),
+    )
+    _append_list_guidance(
+        lines,
+        "Planned validation steps",
+        _string_list(planning.get("validationSteps"), limit=8, max_chars=260),
+    )
+    _append_list_guidance(
+        lines,
+        "Required vision.md validation steps",
+        _string_list(planning.get("requiredValidationSteps"), limit=8, max_chars=260),
+    )
+
+    guidance = "\n".join(lines).strip()
+    if len(guidance) > 4000:
+        guidance = guidance[:4000].rstrip() + "\n- Planning guidance truncated to stay within worker prompt budget."
+    return guidance
+
+
 def parse_task_execute_payload(
     argv: List[str],
     *,
@@ -765,6 +869,9 @@ def parse_task_execute_payload(
     quality_revision_hint = str(params.get("qualityRevisionHint") or "").strip()
 
     supplemental_guidance: List[str] = []
+    planning_guidance = _build_planning_guidance(params)
+    if planning_guidance:
+        supplemental_guidance.append(planning_guidance)
     if planner_instruction and planner_instruction != instruction:
         if _is_non_actionable_planner_guidance(planner_instruction):
             log.info(

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

@@ -6,11 +6,13 @@
 import {
   existsSync,
   lstatSync,
+  mkdirSync,
   readdirSync,
   readFileSync,
   renameSync,
   rmSync,
   unlinkSync,
+  writeFileSync,
 } from "fs";
 import { resolve } from "path";
 import {
@@ -24,6 +26,7 @@ import {
   matchesGlob,
   normalizeTargetPath,
   requirementsForValidationCommand,
+  resolveGitStateFilePath,
   sanitizeSourceControlIdentityField,
   type SourceControlCommitIdentity,
   type ToolRequirement,
@@ -93,6 +96,8 @@ export interface BrowserValidationRepairPacket {
   selector: string | null;
   expected: string | null;
   failureFocus: string | null;
+  lastVerifiedStage?: string | null;
+  pageUrl?: string | null;
   digest: string;
   previousDigest: string | null;
   previousStage: string | null;
@@ -101,10 +106,32 @@ export interface BrowserValidationRepairPacket {
   previousFailureFocus: string | null;
   progress: "first_failure" | "same_failure" | "new_failure";
   needsDiagnosticProbe: boolean;
+  mustReadArtifactsBeforeEdit?: boolean;
   artifacts: string[];
+  artifactSummaries?: string[];
+  knownFailureHints?: string[];
   output: string;
 }
 
+interface BrowserFailureMemoryEntry {
+  key: string;
+  jobFamily: string;
+  command: string;
+  failureKind: BrowserValidationFailureKind;
+  stage: string | null;
+  selector: string | null;
+  expected: string | null;
+  failureFocus: string | null;
+  digest: string;
+  count: number;
+  firstSeenAt: string;
+  lastSeenAt: string;
+  lastVerifiedStage: string | null;
+  pageUrl: string | null;
+  artifactSummaries: string[];
+  suggestedRemedy: string;
+}
+
 interface DeterministicQualityResult {
   ok: boolean;
   skipped: boolean;
@@ -326,6 +353,31 @@ export function buildQualityGateRevisionIssues(
   return [...new Set(merged)];
 }
 
+function buildDiffBudgetWarning(
+  planning: TaskExecutePlanning,
+  changedPaths: string[],
+  focusedBrowserRepair: boolean,
+): string | null {
+  const meaningfulChangedPaths = changedPaths.filter(
+    (path) => !/(^|\/)(outputs|node_modules|\.worktrees|dist|build|coverage)(\/|$)/i.test(path),
+  );
+  if (meaningfulChangedPaths.length === 0) return null;
+  const explicitBudget = Number(planning.scope.maxFilesToEdit);
+  const hasExplicitBudget = Number.isFinite(explicitBudget) && explicitBudget > 0;
+  const smallTask =
+    focusedBrowserRepair ||
+    (planning.riskLevel !== "high" &&
+      (planning.targetPaths?.length ?? 0) <= 2 &&
+      planning.acceptanceCriteria.length <= 3);
+  const budget = hasExplicitBudget ? Math.floor(explicitBudget) : smallTask ? 5 : 10;
+  if (meaningfulChangedPaths.length <= budget) return null;
+  return `Diff budget warning: this task now changes ${meaningfulChangedPaths.length} file(s), above the ${budget}-file ${
+    hasExplicitBudget ? "planning.scope.maxFilesToEdit" : smallTask ? "small-task" : "default"
+  } budget. Before editing more, remove unrelated churn and keep only behavior-owning files needed for the current repair. Changed files: ${meaningfulChangedPaths
+    .slice(0, 12)
+    .join(", ")}${meaningfulChangedPaths.length > 12 ? ", ..." : ""}`;
+}
+
 const TEST_ASSERTION_BALANCE_ISSUE =
   "Changed test files do not show both positive and negative assertion coverage (expected both).";
 
@@ -2032,6 +2084,253 @@ function lastBrowserVerifiedStage(text: string): string | null {
   return lastVerified ? toSingleLine(lastVerified, 80) : null;
 }
 
+function extractBrowserValidationUrl(text: string): string | null {
+  const clean = stripAnsiControlSequences(text);
+  const patterns = [
+    /\b(?:page\s+url|current\s+url|browser\s+url|url)\s*[:=]\s*(https?:\/\/[^\s|"'`<>]+)/i,
+    /\b(?:navigated\s+to|opened|loading)\s+(https?:\/\/[^\s|"'`<>]+)/i,
+    /\b(https?:\/\/(?:127\.0\.0\.1|localhost|0\.0\.0\.0):\d+\/?[^\s|"'`<>]*)/i,
+  ];
+  for (const pattern of patterns) {
+    const match = clean.match(pattern);
+    const url = match?.[1]?.replace(/[),.;]+$/, "").trim();
+    if (url) return toSingleLine(url, 160);
+  }
+  return null;
+}
+
+function inferBrowserArtifactKind(path: string): string {
+  if (/\.(?:png|jpe?g|webp)$/i.test(path)) return "screenshot";
+  if (/\.zip$/i.test(path)) return "trace";
+  if (/\.webm$/i.test(path)) return "video";
+  if (/\.(?:log|txt)$/i.test(path)) return "log";
+  if (/\.json$/i.test(path)) return "json";
+  return "artifact";
+}
+
+function inferBrowserArtifactStageFromPath(path: string): string | null {
+  const fileName = path.split(/[\\/]/).pop() ?? "";
+  const baseName = fileName.replace(/\.[^.]+$/, "");
+  const candidates = [
+    baseName.match(/^\d+[-_](.+)$/)?.[1],
+    baseName.match(/(?:failure|failed|screenshot|snapshot)[-_](.+)$/i)?.[1],
+  ];
+  const raw = candidates.find((entry) => entry && entry.trim());
+  if (!raw) return null;
+  return toSingleLine(raw.replace(/[-_]+/g, " "), 80);
+}
+
+function summarizeBrowserValidationArtifacts(params: {
+  repo?: string;
+  artifacts: string[];
+  context: string;
+}): string[] {
+  const allArtifacts = mergeBrowserValidationArtifacts(
+    params.artifacts,
+    collectRecentBrowserValidationArtifacts(params.repo),
+  );
+  const out: string[] = [];
+  const contextStage = extractBrowserValidationStage(params.context);
+  const contextSelector = extractBrowserValidationSelector(params.context);
+  const contextUrl = extractBrowserValidationUrl(params.context);
+  const contextLastVerified = lastBrowserVerifiedStage(params.context);
+  for (const artifact of allArtifacts.slice(0, 6)) {
+    const kind = inferBrowserArtifactKind(artifact);
+    let artifactText = "";
+    if (params.repo && !/^(?:\/repo|\/workspace|[A-Za-z]:[\\/])/.test(artifact)) {
+      try {
+        artifactText = readFileSync(resolve(params.repo, artifact), "utf8");
+      } catch {
+        artifactText = "";
+      }
+    } else if (existsSync(artifact) && /\.(?:log|txt|json)$/i.test(artifact)) {
+      try {
+        artifactText = readFileSync(artifact, "utf8");
+      } catch {
+        artifactText = "";
+      }
+    }
+    const artifactContext = artifactText ? stripAnsiControlSequences(artifactText) : "";
+    const stage =
+      inferBrowserArtifactStageFromPath(artifact) ||
+      extractBrowserValidationStage(artifactContext) ||
+      contextStage;
+    const selector = extractBrowserValidationSelector(artifactContext) || contextSelector;
+    const url = extractBrowserValidationUrl(artifactContext) || contextUrl;
+    const lastVerified = lastBrowserVerifiedStage(artifactContext) || contextLastVerified;
+    const detail = [
+      `${artifact} [${kind}]`,
+      stage ? `stage=${stage}` : "",
+      selector ? `selector=${selector}` : "",
+      url ? `url=${url}` : "",
+      lastVerified ? `last_verified=${lastVerified}` : "",
+    ]
+      .filter(Boolean)
+      .join(" ");
+    out.push(toSingleLine(detail, 280));
+  }
+  return out;
+}
+
+function browserFailureSuggestedRemedy(packet: BrowserValidationRepairPacket): string {
+  if (packet.failureKind === "assertion") {
+    return [
+      "Read the latest artifact/log/DOM state before editing.",
+      "Preserve already-passing browser stages.",
+      packet.selector
+        ? `Repair or replace the exact failing locator ${packet.selector} with a stable rendered signal for the same UI stage.`
+        : "Repair the exact visible UI assertion or add a stable test id/accessibility label to existing UI.",
+    ].join(" ");
+  }
+  if (packet.failureKind === "startup" || packet.failureKind === "runtime") {
+    return "Treat as browser startup/runtime provisioning; do not rewrite product UI assertions until ValidationGate reaches an assertion stage.";
+  }
+  if (packet.failureKind === "network") {
+    return "Treat as local server/network readiness; add bounded startup diagnostics and avoid changing gameplay/UI behavior.";
+  }
+  return "Inspect captured validation output and repair the current failing stage with the smallest behavior-owning diff.";
+}
+
+function normalizeFailureMemoryToken(value: string | null | undefined): string {
+  return toSingleLine(value ?? "", 120).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+export function buildTaskFailureJobFamily(params: Record<string, unknown>): string {
+  const planning = params.planning && typeof params.planning === "object"
+    ? (params.planning as Partial<TaskExecutePlanning>)
+    : {};
+  const autonomy = params.autonomy && typeof params.autonomy === "object"
+    ? (params.autonomy as Record<string, unknown>)
+    : {};
+  const targetHints = [
+    ...(Array.isArray(planning.targetPaths) ? planning.targetPaths : []),
+    ...(Array.isArray(planning.scope?.writeGlobs) ? planning.scope.writeGlobs : []),
+    ...(Array.isArray(planning.validationSteps) ? planning.validationSteps : []),
+    ...(Array.isArray(planning.requiredValidationSteps) ? planning.requiredValidationSteps : []),
+  ]
+    .map((entry) => normalizeFailureMemoryToken(String(entry)))
+    .filter(Boolean)
+    .slice(0, 8);
+  const area = normalizeFailureMemoryToken(String(autonomy.componentArea ?? autonomy.component_area ?? ""));
+  const intent = normalizeFailureMemoryToken(String(planning.intent ?? ""));
+  return [area, intent, ...targetHints].filter(Boolean).join("|") || "general";
+}
+
+function browserFailureMemoryKey(jobFamily: string, packet: BrowserValidationRepairPacket): string {
+  return [
+    jobFamily,
+    validationCommandKey(packet.command),
+    packet.failureKind,
+    normalizeFailureMemoryToken(packet.failureFocus),
+    normalizeFailureMemoryToken(packet.stage),
+    normalizeFailureMemoryToken(packet.selector),
+    normalizeFailureMemoryToken(packet.expected),
+  ]
+    .filter(Boolean)
+    .join("|");
+}
+
+function resolveFailureMemoryPath(repo: string): string {
+  const rootCandidates = [
+    process.env.PUSHPALS_PROJECT_ROOT_OVERRIDE,
+    process.env.PUSHPALS_REPO_ROOT_OVERRIDE,
+    process.env.PUSHPALS_REPO_PATH,
+    repo,
+  ]
+    .map((entry) => String(entry ?? "").trim())
+    .filter(Boolean);
+  const root = rootCandidates.find((entry) => existsSync(entry)) ?? repo;
+  const gitStatePath = resolveGitStateFilePath(root, "pushpals-worker-failure-memory.json");
+  if (gitStatePath) return gitStatePath;
+  return resolve(root, "outputs", "data", "workerpals-failure-memory.json");
+}
+
+function readBrowserFailureMemory(repo: string): BrowserFailureMemoryEntry[] {
+  const memoryPath = resolveFailureMemoryPath(repo);
+  try {
+    const parsed = JSON.parse(readFileSync(memoryPath, "utf8")) as { entries?: unknown };
+    if (!Array.isArray(parsed.entries)) return [];
+    return parsed.entries
+      .filter((entry): entry is BrowserFailureMemoryEntry => Boolean(entry && typeof entry === "object"))
+      .slice(0, 80);
+  } catch {
+    return [];
+  }
+}
+
+export function knownFailureHintsForPacket(
+  repo: string,
+  jobFamily: string,
+  packet: BrowserValidationRepairPacket,
+): string[] {
+  const entries = readBrowserFailureMemory(repo)
+    .filter((entry) => {
+      if (entry.jobFamily !== jobFamily) return false;
+      if (validationCommandKey(entry.command) !== validationCommandKey(packet.command)) return false;
+      if (entry.failureKind !== packet.failureKind) return false;
+      if (packet.failureFocus && entry.failureFocus && packet.failureFocus !== entry.failureFocus) return false;
+      if (packet.stage && entry.stage && packet.stage !== entry.stage) return false;
+      return true;
+    })
+    .sort((a, b) => b.count - a.count || b.lastSeenAt.localeCompare(a.lastSeenAt))
+    .slice(0, 3);
+  return entries.map((entry) =>
+    toSingleLine(
+      `seen ${entry.count}x before for this repo/job family; last=${entry.lastSeenAt}; focus=${entry.failureFocus ?? entry.stage ?? "unknown"}; remedy=${entry.suggestedRemedy}`,
+      360,
+    ),
+  );
+}
+
+export function recordBrowserFailureMemory(
+  repo: string,
+  jobFamily: string,
+  packet: BrowserValidationRepairPacket,
+): void {
+  const memoryPath = resolveFailureMemoryPath(repo);
+  const now = new Date().toISOString();
+  const entries = readBrowserFailureMemory(repo);
+  const key = browserFailureMemoryKey(jobFamily, packet);
+  const existing = entries.find((entry) => entry.key === key);
+  if (existing) {
+    existing.count += 1;
+    existing.lastSeenAt = now;
+    existing.digest = packet.digest;
+    existing.lastVerifiedStage = packet.lastVerifiedStage ?? null;
+    existing.pageUrl = packet.pageUrl ?? null;
+    existing.artifactSummaries = (packet.artifactSummaries ?? []).slice(0, 6);
+    existing.suggestedRemedy = browserFailureSuggestedRemedy(packet);
+  } else {
+    entries.push({
+      key,
+      jobFamily,
+      command: packet.command,
+      failureKind: packet.failureKind,
+      stage: packet.stage,
+      selector: packet.selector,
+      expected: packet.expected,
+      failureFocus: packet.failureFocus,
+      digest: packet.digest,
+      count: 1,
+      firstSeenAt: now,
+      lastSeenAt: now,
+      lastVerifiedStage: packet.lastVerifiedStage ?? null,
+      pageUrl: packet.pageUrl ?? null,
+      artifactSummaries: (packet.artifactSummaries ?? []).slice(0, 6),
+      suggestedRemedy: browserFailureSuggestedRemedy(packet),
+    });
+  }
+  const next = entries
+    .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt))
+    .slice(0, 80);
+  try {
+    mkdirSync(resolve(memoryPath, ".."), { recursive: true });
+    writeFileSync(memoryPath, `${JSON.stringify({ version: 1, entries: next }, null, 2)}\n`);
+  } catch {
+    // Failure memory is advisory; never fail a worker job because persistence is unavailable.
+  }
+}
+
 export function extractValidationFailureRetryDigest(
   run: {
     command: string;
@@ -2075,6 +2374,7 @@ export function buildBrowserValidationRepairPacket(
   validationRuns: ValidationExecutionResult[],
   previousFailureDigests: Map<string, string> = new Map(),
   repo?: string,
+  knownFailureHints: string[] = [],
 ): BrowserValidationRepairPacket | null {
   for (const run of validationRuns) {
     if (run.ok || !isLongRunningBrowserValidationCommand(run.command)) continue;
@@ -2091,6 +2391,8 @@ export function buildBrowserValidationRepairPacket(
     const enrichedBrowserContext = [combined, recentLogSummary].filter(Boolean).join("\n");
     const selector = extractBrowserValidationSelector(enrichedBrowserContext);
     const expected = extractBrowserValidationExpectedUi(enrichedBrowserContext);
+    const lastVerifiedStage = lastBrowserVerifiedStage(enrichedBrowserContext);
+    const pageUrl = extractBrowserValidationUrl(enrichedBrowserContext);
     const stage = refineBrowserValidationStage(
       extractBrowserValidationStage(enrichedBrowserContext),
       selector,
@@ -2129,6 +2431,15 @@ export function buildBrowserValidationRepairPacket(
     const needsDiagnosticProbe =
       failureKind === "assertion" &&
       sameFailureSignal;
+    const artifacts = mergeBrowserValidationArtifacts(
+      extractBrowserValidationArtifacts(combined),
+      collectRecentBrowserValidationArtifacts(repo),
+    );
+    const artifactSummaries = summarizeBrowserValidationArtifacts({
+      repo,
+      artifacts,
+      context: enrichedBrowserContext,
+    });
     return {
       command: run.command,
       failureKind,
@@ -2136,6 +2447,8 @@ export function buildBrowserValidationRepairPacket(
       selector,
       expected,
       failureFocus,
+      lastVerifiedStage,
+      pageUrl,
       digest,
       previousDigest,
       previousStage,
@@ -2144,10 +2457,10 @@ export function buildBrowserValidationRepairPacket(
       previousFailureFocus,
       progress,
       needsDiagnosticProbe,
-      artifacts: mergeBrowserValidationArtifacts(
-        extractBrowserValidationArtifacts(combined),
-        collectRecentBrowserValidationArtifacts(repo),
-      ),
+      mustReadArtifactsBeforeEdit: failureKind === "assertion",
+      artifacts,
+      artifactSummaries,
+      knownFailureHints: knownFailureHints.slice(0, 3),
       output: [
         summarizeBrowserValidationOutput(combined) || digest,
         recentLogSummary,
@@ -3204,10 +3517,16 @@ export function buildQualityRevisionHint(
   validationRuns: ValidationExecutionResult[] = [],
   validationBlocker: ValidationBlocker | null = null,
   browserRepairPacket: BrowserValidationRepairPacket | null = null,
+  changedPaths: string[] = [],
 ): string {
   const lines: string[] = [];
   lines.push("Quality revision required before completion.");
   const focusedBrowserRepair = Boolean(browserRepairPacket);
+  lines.push(
+    "Worker phase contract: (1) discovering - inspect only the relevant files/artifacts and name the current hypothesis; (2) editing - make the smallest behavior-owning patch; (3) focused validation - run targeted fast checks; (4) full validation - let PushPals ValidationGate own long required checks unless a single local confirmation is explicitly useful; (5) final diff review - verify changed files are necessary and no unrelated churn remains.",
+  );
+  const diffBudgetWarning = buildDiffBudgetWarning(planning, changedPaths, focusedBrowserRepair);
+  if (diffBudgetWarning) lines.push(diffBudgetWarning);
   const validationAlreadyPassed =
     validationRuns.length > 0 && validationRuns.every((run) => run.ok);
   if (validationAlreadyPassed && !focusedBrowserRepair) {
@@ -3232,6 +3551,12 @@ export function buildQualityRevisionHint(
     if (browserRepairPacket.failureFocus) {
       lines.push(`- Failure focus: ${browserRepairPacket.failureFocus}`);
     }
+    if (browserRepairPacket.lastVerifiedStage) {
+      lines.push(`- Last verified browser checkpoint: ${browserRepairPacket.lastVerifiedStage}`);
+    }
+    if (browserRepairPacket.pageUrl) {
+      lines.push(`- Browser URL at failure: ${browserRepairPacket.pageUrl}`);
+    }
     if (browserRepairPacket.expected) {
       lines.push(`- Expected UI: ${browserRepairPacket.expected}`);
     }
@@ -3248,6 +3573,18 @@ export function buildQualityRevisionHint(
         "- Failure artifacts: none were captured in command output; if this repo writes screenshots/traces, inspect the latest browser failure artifact before changing selectors.",
       );
     }
+    if ((browserRepairPacket.artifactSummaries ?? []).length > 0) {
+      lines.push("Latest browser artifact summaries:");
+      for (const artifactSummary of browserRepairPacket.artifactSummaries ?? []) {
+        lines.push(`- ${artifactSummary}`);
+      }
+    }
+    if ((browserRepairPacket.knownFailureHints ?? []).length > 0) {
+      lines.push("Known issue/remedy memory for this repo/job family:");
+      for (const hint of browserRepairPacket.knownFailureHints ?? []) {
+        lines.push(`- ${hint}`);
+      }
+    }
     if (browserRepairPacket.digest) {
       lines.push(`- Current failure: ${browserRepairPacket.digest}`);
     }
@@ -3276,6 +3613,11 @@ export function buildQualityRevisionHint(
     } else {
       lines.push("- Breadcrumb: first captured failure for this command in this revision loop");
     }
+    if (browserRepairPacket.mustReadArtifactsBeforeEdit) {
+      lines.push(
+        "- Diagnostic artifact read requirement: before editing, explicitly inspect the listed latest artifact/log/DOM summary for the failing stage. If the artifacts are missing, stale, or stop before the failing locator, add a tiny temporary diagnostic/log for locator counts, visible text, URL, and nearby DOM/test-id state before changing product code or selectors.",
+      );
+    }
     if (browserRepairPacket.needsDiagnosticProbe) {
       lines.push(
         "- Convergence mode: diagnostic-first repair. This same browser focus failed in the previous revision, so do not guess another selector or rewrite a different stage.",
@@ -3457,7 +3799,7 @@ export function buildQualityRevisionHint(
     for (const step of planning.requiredValidationSteps ?? []) lines.push(`- ${step}`);
   }
   lines.push("Apply a minimal corrective patch, run focused validation, then finish.");
-  return lines.join("\n").slice(0, 6000);
+  return lines.join("\n").slice(0, 8000);
 }
 
 function inferTargetPathFromInstruction(text: string): string | null {
@@ -6214,6 +6556,7 @@ export async function executeJob(
   let revisionAttempt = 0;
   let revisionHint = "";
   const previousValidationFailureDigests = new Map<string, string>();
+  const failureJobFamily = buildTaskFailureJobFamily(normalizedParams);
   while (revisionAttempt <= qualityRevisionLoopMax) {
     const attemptParams: Record<string, unknown> = { ...normalizedParams };
     if (revisionHint) {
@@ -6313,11 +6656,19 @@ export async function executeJob(
         revisionAttempt,
       },
     );
-    const browserRepairPacket = buildBrowserValidationRepairPacket(
+    let browserRepairPacket = buildBrowserValidationRepairPacket(
       quality.validationRuns,
       previousValidationFailureDigests,
       repo,
     );
+    if (browserRepairPacket) {
+      const knownFailureHints = knownFailureHintsForPacket(repo, failureJobFamily, browserRepairPacket);
+      browserRepairPacket = {
+        ...browserRepairPacket,
+        knownFailureHints,
+      };
+      recordBrowserFailureMemory(repo, failureJobFamily, browserRepairPacket);
+    }
     for (const run of quality.validationRuns) {
       if (run.ok) continue;
       const digest = extractValidationFailureRetryDigest(run, repo);
@@ -6592,6 +6943,7 @@ export async function executeJob(
       validationOutsideTaskScope ? [] : quality.validationRuns,
       validationOutsideTaskScope ? null : quality.blocker,
       validationOutsideTaskScope ? null : browserRepairPacket,
+      quality.changedPaths,
     );
     onLog?.(
       "stderr",

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

@@ -67,6 +67,7 @@ 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 DEFAULT_JOB_PROGRESS_LOG_EVERY_MS = 60_000;
 const CONFIG = loadPushPalsConfig();
 const LOG = new Logger("WorkerPals");
 
@@ -197,7 +198,12 @@ async function reportToolRunForUnsuccessfulJob(args: {
   if (record.failureClass === "unknown" && record.tool === "shell") return;
 
   try {
-    const response = await postJsonWithTimeout(`${args.opts.server}/tool-runs`, args.headers, record, 5_000);
+    const response = await postJsonWithTimeout(
+      `${args.opts.server}/tool-runs`,
+      args.headers,
+      record,
+      5_000,
+    );
     if (!response.ok) {
       const detail = await response.text().catch(() => "");
       console.warn(
@@ -315,6 +321,13 @@ function formatDurationMs(durationMs: number): string {
   return `${minutes}m ${seconds}s`;
 }
 
+function resolveJobProgressLogEveryMs(): number {
+  const raw = Number.parseInt(process.env.PUSHPALS_WORKERPAL_PROGRESS_LOG_MS ?? "", 10);
+  if (Number.isFinite(raw) && raw === 0) return 0;
+  if (Number.isFinite(raw) && raw >= 10_000) return raw;
+  return DEFAULT_JOB_PROGRESS_LOG_EVERY_MS;
+}
+
 function sanitizeJobLogLine(line: string): string {
   // Strip ANSI escape/control sequences and collapse whitespace.
   const cleaned = line
@@ -985,8 +998,7 @@ function failNoChangeReviewFixJob(jobId: string, result: WorkerJobResult): Worke
   return {
     ...result,
     ok: false,
-    summary:
-      `Rejected review-fix job ${jobId} produced no code changes; refusing unchanged branch re-review.`,
+    summary: `Rejected review-fix job ${jobId} produced no code changes; refusing unchanged branch re-review.`,
     stderr: [
       result.stderr,
       "Review-fix jobs must make at least one concrete code/test/docs change before requesting another review.",
@@ -1002,9 +1014,7 @@ function taskExecuteOrigin(params: Record<string, unknown> | undefined): "user"
   if (!params) return "user";
   if (params.origin === "autonomy") return "autonomy";
   const autonomy = params.autonomy;
-  return autonomy && typeof autonomy === "object" && !Array.isArray(autonomy)
-    ? "autonomy"
-    : "user";
+  return autonomy && typeof autonomy === "object" && !Array.isArray(autonomy) ? "autonomy" : "user";
 }
 
 async function enqueueCompletion(
@@ -1109,15 +1119,19 @@ async function failActiveJobOnShutdown(
     runtimeState.currentSessionId &&
     shouldEmitDirectSessionJobEvent({ ok: false, statusPersistedToServer })
   ) {
-    await transport.queueSessionCommand(runtimeState.currentSessionId, {
-      type: "job_failed",
-      payload: {
-        jobId: activeJobId,
-        message,
-        detail,
+    await transport.queueSessionCommand(
+      runtimeState.currentSessionId,
+      {
+        type: "job_failed",
+        payload: {
+          jobId: activeJobId,
+          message,
+          detail,
+        },
+        from: `worker:${opts.workerId}`,
       },
-      from: `worker:${opts.workerId}`,
-    }, { priority: "high" });
+      { priority: "high" },
+    );
   }
 }
 
@@ -1224,10 +1238,7 @@ async function workerLoop(
         const job = data.job;
 
         if (job) {
-          if (
-            dockerExecutor &&
-            dockerExecutor.shouldPrepareMergeConflictJobBeforeExecution(job)
-          ) {
+          if (dockerExecutor && dockerExecutor.shouldPrepareMergeConflictJobBeforeExecution(job)) {
             const deferMs = dockerExecutor.recommendedMergeConflictDeferMs();
             const deferred = await deferClaimedJobForMaintenance(opts, headers, job.id, deferMs);
             if (!deferred.ok) {
@@ -1325,50 +1336,86 @@ async function workerLoop(
           }, heartbeatEveryMs);
 
           if (job.sessionId) {
-            await transport.queueSessionCommand(job.sessionId, {
-              type: "job_claimed",
-              payload: { jobId: job.id, workerId: opts.workerId },
-              from: `worker:${opts.workerId}`,
-            }, { priority: "high" });
+            await transport.queueSessionCommand(
+              job.sessionId,
+              {
+                type: "job_claimed",
+                payload: { jobId: job.id, workerId: opts.workerId },
+                from: `worker:${opts.workerId}`,
+              },
+              { priority: "high" },
+            );
           }
 
           let stdoutSeq = 0;
           let stderrSeq = 0;
           let lastCleanLog = "";
           let lastCleanLogAt = 0;
+          let lastForwardedJobLogAt = Date.now();
 
-          const onLog = job.sessionId
-            ? (stream: "stdout" | "stderr", line: string) => {
+          const emitJobLog = job.sessionId
+            ? (stream: "stdout" | "stderr", line: string): boolean => {
                 const cleaned = sanitizeJobLogLine(line);
-                if (!cleaned) return;
-                // Print executor logs locally only in debug mode.
-                if (LOG.isDebugEnabled()) LOG.debug(`[${stream}] ${cleaned}`);
+                if (!cleaned) return false;
 
                 // Drop high-frequency terminal progress redraw spam; keep meaningful lines.
-                if (isNoisyProgressLine(cleaned)) return;
+                if (isNoisyProgressLine(cleaned)) return false;
 
                 // Collapse very noisy duplicate lines emitted in tight loops.
                 const now = Date.now();
-                if (cleaned === lastCleanLog && now - lastCleanLogAt < 1_000) return;
+                if (cleaned === lastCleanLog && now - lastCleanLogAt < 1_000) return false;
                 lastCleanLog = cleaned;
                 lastCleanLogAt = now;
+                lastForwardedJobLogAt = now;
                 const logTs = new Date(now).toISOString();
 
                 const seq = stream === "stdout" ? ++stdoutSeq : ++stderrSeq;
-                void transport.queueSessionCommand(job.sessionId, {
-                  type: "job_log",
-                  payload: { jobId: job.id, stream, seq, line: cleaned, ts: logTs },
-                  from: `worker:${opts.workerId}`,
-                }, { droppable: true });
+                void transport.queueSessionCommand(
+                  job.sessionId,
+                  {
+                    type: "job_log",
+                    payload: { jobId: job.id, stream, seq, line: cleaned, ts: logTs },
+                    from: `worker:${opts.workerId}`,
+                  },
+                  { droppable: true },
+                );
                 void transport.queueJobLog(job.id, {
                   stream,
                   seq,
                   message: cleaned,
                   ts: logTs,
                 });
+                return true;
+              }
+            : undefined;
+
+          const onLog = emitJobLog
+            ? (stream: "stdout" | "stderr", line: string) => {
+                const cleaned = sanitizeJobLogLine(line);
+                if (LOG.isDebugEnabled() && cleaned) LOG.debug(`[${stream}] ${cleaned}`);
+                emitJobLog(stream, line);
               }
             : undefined;
 
+          const jobClaimedAtMs = Date.now();
+          const jobProgressLogEveryMs = resolveJobProgressLogEveryMs();
+          const jobProgressTimer =
+            emitJobLog && jobProgressLogEveryMs > 0
+              ? setInterval(() => {
+                  const now = Date.now();
+                  const quietForMs = Math.max(0, now - lastForwardedJobLogAt);
+                  if (quietForMs < jobProgressLogEveryMs) return;
+                  emitJobLog(
+                    "stdout",
+                    `[WorkerPals] Job ${job.id} still running after ${formatDurationMs(
+                      now - jobClaimedAtMs,
+                    )} (kind=${job.kind}, worker=${opts.workerId}, quiet_for=${formatDurationMs(
+                      quietForMs,
+                    )}).`,
+                  );
+                }, jobProgressLogEveryMs)
+              : null;
+
           let directWorktreePath: string | null = null;
           let executionRepo = opts.repo;
           let result: WorkerJobResult | null = null;
@@ -1611,11 +1658,15 @@ async function workerLoop(
                 durationMs: jobDurationMs,
                 phase: job.kind,
               });
-              const response = await postJsonWithTimeout(`${opts.server}/jobs/${job.id}/fail`, headers, {
-                message: result.summary,
-                detail: redactSensitiveText(result.stderr ?? ""),
-                durationMs: jobDurationMs,
-              });
+              const response = await postJsonWithTimeout(
+                `${opts.server}/jobs/${job.id}/fail`,
+                headers,
+                {
+                  message: result.summary,
+                  detail: redactSensitiveText(result.stderr ?? ""),
+                  durationMs: jobDurationMs,
+                },
+              );
               statusPersistedToServer = response.ok;
               console.log(
                 `[WorkerPals] Job ${job.id} failed in ${formatDurationMs(jobDurationMs)}: ${result.summary}`,
@@ -1703,6 +1754,7 @@ async function workerLoop(
             }
           } finally {
             clearInterval(busyHeartbeat);
+            if (jobProgressTimer) clearInterval(jobProgressTimer);
             if (recycleWorkerAfterJob) {
               runtimeState.shutdownRequested = true;
               const forceExitTimer = setTimeout(() => {
@@ -1895,7 +1947,9 @@ async function main(): Promise<void> {
           },
         }),
       );
-      await withTimeout(failActiveJobOnShutdown(opts, headers, runtimeState, transport, signalName));
+      await withTimeout(
+        failActiveJobOnShutdown(opts, headers, runtimeState, transport, signalName),
+      );
       await withTimeout(transport.flush());
       if (dockerExecutor) {
         await withTimeout(