@pushpalsdev/cli 1.0.28 → 1.0.30

package/dist/pushpals-cli.js

@@ -1946,8 +1946,14 @@ function cleanupLegacyRuntimeBinaryLayouts(runtimeRoot, platformKey, activeBinDi
 function buildEmbeddedRuntimeEnv(baseEnv, opts) {
   const env = normalizeChildProcessEnv(baseEnv);
   const useRuntimeConfig = opts.useRuntimeConfig !== false;
+  const inherited = { ...env };
+  if (!useRuntimeConfig) {
+    delete inherited.PUSHPALS_CONFIG_DIR_OVERRIDE;
+    delete inherited.PUSHPALS_WORKERPALS_SANDBOX_ROOT;
+    delete inherited.PUSHPALS_RUNTIME_TAG;
+  }
   return {
-    ...env,
+    ...inherited,
     PUSHPALS_REPO_ROOT_OVERRIDE: opts.repoRoot,
     PUSHPALS_PROJECT_ROOT_OVERRIDE: opts.repoRoot,
     ...useRuntimeConfig ? {
@@ -2484,6 +2490,36 @@ async function resolveWorkerpalDockerProbe(cwd, env, platform = process.platform
 var WORKERPAL_SANDBOX_RUNTIME_TAG_LABEL = "pushpals.runtime_tag";
 var WORKERPAL_SANDBOX_COMPONENT_LABEL = "pushpals.component=workerpals-sandbox";
 var WORKERPAL_WARM_COMPONENT_LABEL = "pushpals.component=workerpals-warm";
+var SOURCE_CONTROL_MANAGER_TEMP_BRANCH_PREFIX = "_source_control_manager/";
+function normalizeFsPathForComparison(value) {
+  const resolved = resolve4(String(value ?? "").trim()).replace(/\\/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function parseGitWorktreeListPorcelain(stdout) {
+  const entries = [];
+  const blocks = String(stdout ?? "").split(/\r?\n\r?\n/g).map((block) => block.trim()).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.split(/\r?\n/g);
+    const pathLine = lines.find((line) => line.startsWith("worktree "));
+    if (!pathLine)
+      continue;
+    const branchLine = lines.find((line) => line.startsWith("branch "));
+    entries.push({
+      path: pathLine.slice("worktree ".length).trim(),
+      branch: branchLine ? branchLine.slice("branch ".length).trim() : null,
+      detached: lines.includes("detached")
+    });
+  }
+  return entries;
+}
+function isWorkerpalEphemeralWorktreePath(repoRoot, worktreePath) {
+  const expectedPrefix = `${normalizeFsPathForComparison(join2(repoRoot, ".worktrees"))}/`;
+  const normalizedPath = normalizeFsPathForComparison(worktreePath);
+  if (!normalizedPath.startsWith(expectedPrefix))
+    return false;
+  const leaf = basename(normalizedPath);
+  return /^(job|selfcheck)-.*-workerpal-[a-z0-9._-]+/i.test(leaf);
+}
 function resolveConfiguredDockerExecutable(env, platform = process.platform) {
   const configured = String(env.PUSHPALS_DOCKER_BIN_ABSOLUTE ?? env.PUSHPALS_DOCKER_BIN ?? (platform === "win32" ? "docker.exe" : "docker")).trim();
   return configured || (platform === "win32" ? "docker.exe" : "docker");
@@ -2531,6 +2567,80 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
     removed: containerIds.length
   };
 }
+async function cleanupLingeringPushPalsGitWorktrees(opts) {
+  const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
+  const list = await runCommandWithEnvFn(["git", "worktree", "list", "--porcelain"], opts.repoRoot, opts.env);
+  if (!list.ok) {
+    const detail = list.stderr || list.stdout || `exit ${list.exitCode}`;
+    return {
+      ok: false,
+      detail: `failed to inspect lingering PushPals git artifacts: ${detail}`,
+      removed: 0
+    };
+  }
+  const currentRepoPath = normalizeFsPathForComparison(opts.repoRoot);
+  const removable = parseGitWorktreeListPorcelain(list.stdout).filter((entry) => {
+    const normalizedPath = normalizeFsPathForComparison(entry.path);
+    if (normalizedPath === currentRepoPath)
+      return false;
+    if (entry.branch?.startsWith(`refs/heads/${SOURCE_CONTROL_MANAGER_TEMP_BRANCH_PREFIX}`)) {
+      return true;
+    }
+    return isWorkerpalEphemeralWorktreePath(opts.repoRoot, entry.path);
+  });
+  let removed = 0;
+  const failures = [];
+  for (const entry of removable) {
+    const remove = await runCommandWithEnvFn(["git", "worktree", "remove", "--force", "--force", entry.path], opts.repoRoot, opts.env);
+    if (remove.ok) {
+      removed += 1;
+      continue;
+    }
+    failures.push(`${entry.path}: ${remove.stderr || remove.stdout || `exit ${remove.exitCode}`}`);
+  }
+  const prune = await runCommandWithEnvFn(["git", "worktree", "prune"], opts.repoRoot, opts.env);
+  if (!prune.ok) {
+    failures.push(`prune: ${prune.stderr || prune.stdout || `exit ${prune.exitCode}`}`);
+  }
+  const deleteTempBranches = await runCommandWithEnvFn([
+    "git",
+    "for-each-ref",
+    "--format=%(refname:short)",
+    `refs/heads/${SOURCE_CONTROL_MANAGER_TEMP_BRANCH_PREFIX}`
+  ], opts.repoRoot, opts.env);
+  if (!deleteTempBranches.ok) {
+    failures.push(`list temp branches: ${deleteTempBranches.stderr || deleteTempBranches.stdout || `exit ${deleteTempBranches.exitCode}`}`);
+  } else {
+    const branches = deleteTempBranches.stdout.split(/\r?\n/g).map((value) => value.trim()).filter(Boolean);
+    for (const branch of branches) {
+      const deleteResult = await runCommandWithEnvFn(["git", "branch", "-D", branch], opts.repoRoot, opts.env);
+      if (!deleteResult.ok) {
+        failures.push(`${branch}: ${deleteResult.stderr || deleteResult.stdout || `exit ${deleteResult.exitCode}`}`);
+      } else {
+        removed += 1;
+      }
+    }
+  }
+  if (removed === 0 && failures.length === 0) {
+    return {
+      ok: true,
+      detail: "no lingering PushPals git artifacts found",
+      removed: 0
+    };
+  }
+  if (failures.length > 0) {
+    return {
+      ok: false,
+      detail: `removed ${removed} lingering PushPals git artifact(s), but cleanup was incomplete: ${failures.join(" | ")}`,
+      removed
+    };
+  }
+  return {
+    ok: true,
+    detail: `removed ${removed} lingering PushPals git artifact(s)`,
+    removed
+  };
+}
 async function inspectDockerImageRuntimeTag(dockerExecutable, imageName, cwd, env) {
   const inspect = await runCommandWithEnv([
     dockerExecutable,
@@ -3843,8 +3953,45 @@ function formatSessionEventLine(event) {
   }
   return null;
 }
+function buildSessionEventReplayFingerprint(event) {
+  const type = String(event.type ?? "").trim().toLowerCase();
+  if (type !== "status")
+    return null;
+  const payload = event.payload ?? {};
+  const source = String(event.from ?? payload.agentId ?? "status").trim().toLowerCase();
+  const state = String(payload.state ?? "").trim().toLowerCase();
+  const detail = String(payload.detail ?? "").trim().toLowerCase();
+  const message = String(payload.message ?? "").trim().toLowerCase();
+  return {
+    source,
+    fingerprint: `${type}:${source}:${state}:${detail}:${message}`
+  };
+}
+function createSessionEventReplayFilter() {
+  const seenEventIds = new Set;
+  const lastStatusFingerprintBySource = new Map;
+  return {
+    shouldRender(event) {
+      const eventId = String(event.id ?? "").trim();
+      if (eventId) {
+        if (seenEventIds.has(eventId))
+          return false;
+        seenEventIds.add(eventId);
+      }
+      const replayStatus = buildSessionEventReplayFingerprint(event);
+      if (!replayStatus)
+        return true;
+      const previous = lastStatusFingerprintBySource.get(replayStatus.source);
+      if (previous === replayStatus.fingerprint)
+        return false;
+      lastStatusFingerprintBySource.set(replayStatus.source, replayStatus.fingerprint);
+      return true;
+    }
+  };
+}
 async function runSessionStream(serverUrl, sessionId, client, print, signal) {
   let cursor = 0;
+  const replayFilter = createSessionEventReplayFilter();
   while (!signal.aborted) {
     try {
       const response = await fetchWithTimeout(`${serverUrl}/sessions/${encodeURIComponent(sessionId)}/events${buildClientTransportQuery(cursor, client)}`, {}, 15000);
@@ -3894,6 +4041,8 @@ async function runSessionStream(serverUrl, sessionId, client, print, signal) {
           cursor = Math.max(cursor, blockCursor, serverCursor);
           if (!parsed.envelope)
             continue;
+          if (!replayFilter.shouldRender(parsed.envelope))
+            continue;
           const line = formatSessionEventLine(parsed.envelope);
           if (line)
             print(line);
@@ -4034,6 +4183,19 @@ async function main() {
       console.log(`[pushpals] ${cleanup.detail} (${phase}).`);
     }
   };
+  const cleanupPushPalsGitWorktreesIfNeeded = async (phase) => {
+    const cleanup = await cleanupLingeringPushPalsGitWorktrees({
+      repoRoot,
+      env: workerpalDockerPrecheck.env
+    });
+    if (!cleanup.ok) {
+      console.warn(`[pushpals] PushPals worktree cleanup warning (${phase}): ${cleanup.detail}`);
+      return;
+    }
+    if (cleanup.removed > 0) {
+      console.log(`[pushpals] ${cleanup.detail} (${phase}).`);
+    }
+  };
   const stopAutoStartedServices = () => {
     if (autoStartedServices.length === 0)
       return;
@@ -4056,6 +4218,7 @@ async function main() {
     }
     await stopRuntimeServicesGracefully(services);
     await cleanupWorkerpalWarmContainersIfNeeded("cli shutdown");
+    await cleanupPushPalsGitWorktreesIfNeeded("cli shutdown");
   };
   let serverHealthy = await probeServer(serverUrl);
   const serverWasAlreadyHealthy = serverHealthy;
@@ -4085,6 +4248,7 @@ async function main() {
   };
   if (!serverHealthy) {
     await cleanupWorkerpalWarmContainersIfNeeded("startup preflight");
+    await cleanupPushPalsGitWorktreesIfNeeded("startup preflight");
     if (!parsed.noAutoStart) {
       try {
         const startedRuntime = await autoStartRuntimeServices({
@@ -4381,8 +4545,10 @@ export {
   ensureWorkerpalDockerImageReady,
   ensureRuntimeBinaries,
   downloadRuntimeAssetsFromSourceTag,
+  createSessionEventReplayFilter,
   copyTrackedRepoPath,
   cleanupLingeringWorkerpalWarmContainers,
+  cleanupLingeringPushPalsGitWorktrees,
   bundledMonitoringHubNeedsRefresh,
   buildWorkerpalSandboxPaths,
   buildServiceStopCommand,

package/package.json

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

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

@@ -130,14 +130,51 @@ export function redactSensitiveText(value: string): string {
 }
 
 export function buildCriticRevisionIssues(
-  critic: { score: number; mustFix: string[] } | null | undefined,
+  critic:
+    | {
+        score: number;
+        findings?: string[];
+        mustFix?: string[];
+        revisionGuidance?: string;
+      }
+    | null
+    | undefined,
   qualityCriticMinScore: number,
 ): string[] {
   if (!critic) return [];
   if (critic.score >= qualityCriticMinScore) return [];
-  return [
+  const issues = [
     `Critic score ${critic.score.toFixed(1)} is below required threshold ${qualityCriticMinScore}.`,
   ];
+  const mustFix = Array.isArray(critic.mustFix) ? critic.mustFix : [];
+  const findings = Array.isArray(critic.findings) ? critic.findings : [];
+  const revisionGuidance = String(critic.revisionGuidance ?? "").trim();
+  const actionableItems = (mustFix.length > 0 ? mustFix : findings)
+    .map((entry) => toSingleLine(entry, 180))
+    .filter(Boolean)
+    .slice(0, 3);
+  for (const item of actionableItems) {
+    issues.push(mustFix.length > 0 ? `Critic must-fix: ${item}` : `Critic finding: ${item}`);
+  }
+  if (revisionGuidance) {
+    issues.push(`Critic revision guidance: ${toSingleLine(revisionGuidance, 220)}`);
+  }
+  return issues;
+}
+
+export function buildQualityGateRevisionIssues(
+  qualityIssues: string[],
+  critic: CriticReview | null,
+  qualityCriticMinScore: number,
+): string[] {
+  const normalizedQualityIssues = qualityIssues
+    .map((entry) => String(entry ?? "").trim())
+    .filter(Boolean);
+  if (!critic || critic.score >= qualityCriticMinScore) {
+    return [...normalizedQualityIssues];
+  }
+  const merged = [...normalizedQualityIssues, ...buildCriticRevisionIssues(critic, qualityCriticMinScore)];
+  return [...new Set(merged)];
 }
 
 export function resolveReviewFixCompletionBranch(
@@ -3006,9 +3043,10 @@ export async function executeJob(
       : executor === "openai_codex"
         ? await runCodexCriticReview(repo, attemptParams, quality, runtimeConfig, onLog)
         : await runTaskCriticReview(repo, attemptParams, quality, runtimeConfig, onLog);
+    const deterministicRequiresRevision = !quality.ok;
     const criticRequiresRevision = Boolean(critic && critic.score < qualityCriticMinScore);
 
-    if (!criticRequiresRevision) {
+    if (!deterministicRequiresRevision && !criticRequiresRevision) {
       if (critic) {
         onLog?.(
           "stdout",
@@ -3018,10 +3056,11 @@ export async function executeJob(
       return result;
     }
 
-    const issues: string[] = [];
-    if (criticRequiresRevision && critic) {
-      issues.push(...buildCriticRevisionIssues(critic, qualityCriticMinScore));
-    }
+    const issues = buildQualityGateRevisionIssues(
+      quality.issues,
+      critic,
+      qualityCriticMinScore,
+    );
     const issueSummary = issues.map((entry) => toSingleLine(entry, 180)).join(" | ");
     if (revisionAttempt >= qualityMaxAutoRevisions) {
       if (qualitySoftPassOnExhausted) {